Re: transform

On 25 Feb, 16:02, "kwikius" <a...@servocomm.freeserve.co.uk> wrote:


What the hey.. dump the std stuff and no more loop :-)

#include <vector>
#include <quan/fun/for_each.hpp>
#include <quan/fun/container_reserve.hpp>
#include <quan/fun/container_push_back.hpp>
#include <quan/fun/output.hpp>
#include <quan/fun/std_at.hpp>

namespace quan { namespace fun{

//overload for_each to wrap integral iterator...
 template <typename T, typename F>
 typename boost::enable_if<
   std::tr1::is_integral<T>,
   void
 >::type
 for_each(T const & n, F const & f)
 {
   for (T i =0; i !=n; ++ i) {
      f(i);
   }
 }

}}
//...so we can push for loop body into a functor...
namespace{
   namespace impl{
      template <typename In, typename Out>
      struct apply{
         apply( In & in_in, Out & out_in)
         : in(in_in),out(out_in){}
         In & in;
         Out & out;
         void operator()(size_t n) const
         {
            using quan::fun::for_each;
            using quan::fun::push_back;
            using quan::fun::output;
            using quan::fun::std_at;

            out.push_back(typename Out::value_type());
            out.back().reserve(in.size());
            for_each(in,push_back(std_at(n),out.at(n)));
            for_each(out.at(n),output(std::cout," "));
            std::cout << '\n';
         }
      };
   }
   template <typename In, typename Out>
   impl::apply<In,Out> apply(In & in, Out & out)
   {
      return impl::apply<In,Out>(in,out);
   }
}

int main()
{

   using quan::fun::for_each;
   using quan::fun::push_back;

   std::vector< std::vector<double> > v(2);
   for_each(v,quan::fun::reserve(6));

   double ar1[] ={ 1, 2, 3, 4 ,5 ,6},
            ar2[] = {7, 7 ,8 ,8 ,9 ,9 };

   for_each(ar1,push_back(v[0]));
   for_each(ar2,push_back(v[1]));

   std::vector< std::vector<double> > result;
   for_each(v[0].size(),apply(v,result));

}
/*
output:

1 7
2 7
3 8
4 8
5 9
6 9
*/