#include "../ContainerOperation.hpp"
#include <boost/lambda/lambda.hpp>
#include <boost/lambda/bind.hpp>
#include <boost/foreach.hpp>
#include <boost/static_assert.hpp>


template <
         typename T,
         template <typename ELEM,typename = std::allocator<ELEM> >
         class CONT 
>
std::ostream& operator<<(std::ostream& os, const CONT<T>& array)
{
     os << "[";
        BOOST_FOREACH(T val, array)
        {
           std::cout << val << "\t";
        }
     os << "]";
     return os;
}

template <typename T,
         template <typename ELEM, typename = std::allocator<ELEM> >
         class CONT
>
CONT<T> operator-(CONT<T> arr1, CONT<T> arr2)
{
   using namespace boost::lambda;
   BOOST_STATIC_ASSERT(sizeof(arr1) == sizeof(arr2));
   std::transform(arr1.begin(), arr1.end(), arr2.begin(), arr1.begin(), _1 -= _2);
   return arr1;
}

template <typename T,
         template <typename ELEM, typename = std::allocator<ELEM> >
         class CONT
>
CONT<T> operator+(CONT<T> arr1, CONT<T> arr2)
{
   using namespace boost::lambda;
   BOOST_STATIC_ASSERT(sizeof(arr1) == sizeof(arr2));
   std::transform(arr1.begin(), arr1.end(), arr2.begin(), arr1.begin(), _1 += _2);
   return arr1;
}

template <typename T,
         template <typename ELEM, typename = std::allocator<ELEM> >
         class CONT
>
CONT<T> operator*(CONT<T> arr1, CONT<T> arr2)
{
   using namespace boost::lambda;
   BOOST_STATIC_ASSERT(sizeof(arr1) == sizeof(arr2));
   std::transform(arr1.begin(), arr1.end(), arr2.begin(), arr1.begin(), _1 *= _2);
   return arr1;
}

template <typename T,
         template <typename ELEM, typename = std::allocator<ELEM> >
         class CONT
>
CONT<T> operator/(CONT<T> arr1, CONT<T> arr2)
{
   using namespace boost::lambda;
   BOOST_STATIC_ASSERT(sizeof(arr1) == sizeof(arr2));
   std::transform(arr1.begin(), arr1.end(), arr2.begin(), arr1.begin(), _1 /= _2);
   return arr1;
}

template <typename T,
         template <typename ELEM, typename = std::allocator<ELEM> >
         class CONT
>
CONT<T> operator%(CONT<T> arr1, CONT<T> arr2)
{
   using namespace boost::lambda;
   BOOST_STATIC_ASSERT(sizeof(arr1) == sizeof(arr2));
   std::transform(arr1.begin(), arr1.end(), arr2.begin(), arr1.end(), _1 %= _2);
   return arr1;
}

template <typename T,
         template <typename ELEM, typename = std::allocator<ELEM> >
         class CONT
>
CONT<T> operator+(CONT<T> arr1, const T& rval)
{
   using namespace boost::lambda;
   std::transform(arr1.begin(), arr1.end(), arr1.begin(), _1 += rval);
   return arr1;
}

template <typename T,
         template <typename ELEM, typename = std::allocator<ELEM> >
         class CONT
>
CONT<T> operator-(CONT<T> arr1, const T& rval)
{
   using namespace boost::lambda;
   std::transform(arr1.begin(), arr1.end(), arr1.begin(), _1 -= rval);
   return arr1;
}

template <typename T,
         template <typename ELEM, typename = std::allocator<ELEM> >
         class CONT
>
CONT<T> operator*(CONT<T> arr1, const T& rval)
{
   using namespace boost::lambda;
   std::transform(arr1.begin(), arr1.end(), arr1.begin(), _1 *= rval);
   return arr1;
}

template <typename T,
         template <typename ELEM, typename = std::allocator<ELEM> >
         class CONT
>
CONT<T> operator/(CONT<T> arr1, const T& rval)
{
   using namespace boost::lambda;
   std::transform(arr1.begin(), arr1.end(), arr1.begin(), _1 /= rval);
   return arr1;
}

template <typename T,
         template <typename ELEM, typename = std::allocator<ELEM> >
         class CONT
>
CONT<T> operator%(CONT<T> arr1, const T& rval)
{
   using namespace boost::lambda;
   std::transform(arr1.begin(), arr1.end(), arr1.begin(), _1 %= rval);
   return arr1;
}