#include <boost/python/class.hpp>
#include <boost/python/init.hpp>
#include <boost/python/module.hpp>
#include <boost/python/def.hpp>
#include <boost/python/operators.hpp>
#include <boost/python/suite/indexing/vector_indexing_suite.hpp>
#include <vector>
#include <complex>
#include <numeric>
#include <iterator>
#include "mismatch.H"
#include "vector_arith.hpp"
#include "Scalar.H"

typedef std::complex<double> Complex;
typedef std::complex<int> ComplexI;

using namespace boost::python;

using namespace vec;

// ordinary vector
#define VECIMP(TYPE, PROXY) \
  class_<std::vector<TYPE> >("vector_"#TYPE) \
    .def(init<size_t>()) \
    .def(init<size_t,TYPE>()) \
    .def(init<const std::vector<TYPE>&>()) \
    .def("size", &std::vector<TYPE>::size) \
    .def("resize", (void (std::vector<TYPE>::*)(size_t, const TYPE&) )&std::vector<TYPE>::resize) \
    .def("resize", (void (std::vector<TYPE>::*)(size_t) )&std::vector<TYPE>::resize) \
    .def(self + self) \
    .def(self - self) \
    .def(self * self) \
    .def(self / self) \
    .def(self + TYPE()) \
    .def(self - TYPE()) \
    .def(self * TYPE()) \
    .def(self / TYPE()) \
    .def(self + std::complex<TYPE>()) \
    .def(self - std::complex<TYPE>()) \
    .def(self * std::complex<TYPE>()) \
    .def(self / std::complex<TYPE>()) \
    .def(self += self)					     \
    .def(self -= self)					     \
    .def(self *= self)					     \
    .def(self /= self)					     \
    .def(self += TYPE())				     \
    .def(self -= TYPE())				     \
    .def(self *= TYPE())				     \
    .def(self /= TYPE())				     \
    .def(vector_indexing_suite<std::vector<TYPE>, PROXY >()) \
    ;

// vector<complex>
#define VECCMPLXIMP(TYPE, PROXY) \
  class_<std::vector<TYPE> >("vector_"#TYPE) \
    .def(init<size_t>()) \
    .def(init<size_t,TYPE>()) \
    .def(init<const std::vector<TYPE>&>()) \
    .def("size", &std::vector<TYPE>::size) \
    .def("resize", (void (std::vector<TYPE>::*)(size_t, const TYPE&) )&std::vector<TYPE>::resize) \
    .def("resize", (void (std::vector<TYPE>::*)(size_t) )&std::vector<TYPE>::resize) \
    .def(self + self) \
    .def(self - self) \
    .def(self * self) \
    .def(self / self) \
    .def(self + TYPE()) \
    .def(self - TYPE()) \
    .def(self * TYPE()) \
    .def(self / TYPE()) \
    .def(self + Scalar<TYPE>::type()) \
    .def(self - Scalar<TYPE>::type()) \
    .def(self * Scalar<TYPE>::type()) \
    .def(self / Scalar<TYPE>::type()) \
    .def(self + other<std::vector<Scalar<TYPE>::type> >())	     \
    .def(other<std::vector<Scalar<TYPE>::type> >() + self)	     \
    .def(self - other<std::vector<Scalar<TYPE>::type> >())	     \
    .def(other<std::vector<Scalar<TYPE>::type> >() - self)	     \
    .def(self * other<std::vector<Scalar<TYPE>::type> >())	     \
    .def(other<std::vector<Scalar<TYPE>::type> >() * self)	     \
    .def(self / other<std::vector<Scalar<TYPE>::type> >())	     \
    .def(other<std::vector<Scalar<TYPE>::type> >() / self)	     \
    .def(self += self)					     \
    .def(self -= self)					     \
    .def(self *= self)					     \
    .def(self /= self)					     \
    .def(self += other<std::vector<Scalar<TYPE>::type> >())	     \
    .def(self -= other<std::vector<Scalar<TYPE>::type> >())	     \
    .def(self *= other<std::vector<Scalar<TYPE>::type> >())	     \
    .def(self /= other<std::vector<Scalar<TYPE>::type> >())	     \
    .def(self += TYPE())				     \
    .def(self -= TYPE())				     \
    .def(self *= TYPE())				     \
    .def(self /= TYPE())				     \
    .def(self += Scalar<TYPE>::type())		     \
    .def(self -= Scalar<TYPE>::type())			     \
    .def(self *= Scalar<TYPE>::type())			     \
    .def(self /= Scalar<TYPE>::type())			     \
    .def(vector_indexing_suite<std::vector<TYPE>, PROXY >()) \
    ;


BOOST_PYTHON_MODULE(vector)
{    

  VECIMP (double, false);

  VECCMPLXIMP (Complex, true);

  class_<ComplexI >("CInt")
    .def(init<int,int>())
    .def ("real", &ComplexI::real)
    .def ("imag", &ComplexI::imag)
    ;

  VECIMP (int, false);

  VECCMPLXIMP (ComplexI, true);

}