///////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2007-2011, Industrial Light & Magic, a division of Lucas
// Digital Ltd. LLC
// 
// All rights reserved.
// 
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
// *       Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// *       Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// *       Neither the name of Industrial Light & Magic nor the names of
// its contributors may be used to endorse or promote products derived
// from this software without specific prior written permission. 
// 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
///////////////////////////////////////////////////////////////////////////

#ifndef _PyImathFixedArray2D_h_
#define _PyImathFixedArray2D_h_

#include <boost/python.hpp>
#include <boost/operators.hpp>
#include <boost/shared_array.hpp>
#include <boost/any.hpp>
#include <Iex.h>
#include <iostream>
#include "PyImathFixedArray.h"
#include "PyImathOperators.h"
#include <ImathVec.h>

namespace PyImath {

template <class T>
class FixedArray2D
{
    T *                 _ptr;
    IMATH_NAMESPACE::Vec2<size_t> _length;
    IMATH_NAMESPACE::Vec2<size_t> _stride;
    size_t              _size; //flattened size of the array

    // this handle optionally stores a shared_array to allocated array data
    // so that everything is freed properly on exit.
    boost::any _handle;

  public:

    FixedArray2D(T *ptr, Py_ssize_t lengthX, Py_ssize_t lengthY, Py_ssize_t strideX = 1)
        : _ptr(ptr), _length(lengthX, lengthY), _stride(strideX, lengthX), _handle()
    {
        if (lengthX < 0 || lengthY < 0)
            throw IEX_NAMESPACE::LogicExc("Fixed array 2d lengths must be non-negative");
        if (strideX <= 0)
            throw IEX_NAMESPACE::LogicExc("Fixed array 2d strides must be positive");
        initializeSize();
        //std::cout << "fixed array external construct" << std::endl;
        // nothing
    }

    FixedArray2D(T *ptr, Py_ssize_t lengthX, Py_ssize_t lengthY, Py_ssize_t strideX, Py_ssize_t strideY)
        : _ptr(ptr), _length(lengthX, lengthY), _stride(strideX, strideY), _handle()
    {
        if (lengthX < 0 || lengthY < 0)
            throw IEX_NAMESPACE::LogicExc("Fixed array 2d lengths must be non-negative");
        if (strideX <= 0 || strideY < 0)
            throw IEX_NAMESPACE::LogicExc("Fixed array 2d strides must be positive");
        initializeSize();
        //std::cout << "fixed array external construct" << std::endl;
        // nothing
    }

    FixedArray2D(T *ptr, Py_ssize_t lengthX, Py_ssize_t lengthY, Py_ssize_t strideX, Py_ssize_t strideY, boost::any handle) 
        : _ptr(ptr), _length(lengthX, lengthY), _stride(strideX, strideY), _handle(handle)
    {
        initializeSize();
        //std::cout << "fixed array external construct with handle" << std::endl;
        // nothing
    }

    explicit FixedArray2D(Py_ssize_t lengthX, Py_ssize_t lengthY)
        : _ptr(0), _length(lengthX, lengthY), _stride(1, lengthX), _handle()
    {
        if (lengthX < 0 || lengthY < 0)
            throw IEX_NAMESPACE::LogicExc("Fixed array 2d lengths must be non-negative");
        initializeSize();
        T tmp = FixedArrayDefaultValue<T>::value();
        boost::shared_array<T> a(new T[_size]);
        for (size_t i=0; i<_size; ++i) a[i] = tmp;
        _handle = a;
        _ptr = a.get();
    }

    explicit FixedArray2D(const IMATH_NAMESPACE::V2i& length)
        : _ptr(0), _length(length), _stride(1, length.x), _handle()
    {
        if (length.x < 0 || length.y < 0)
            throw IEX_NAMESPACE::LogicExc("Fixed array 2d lengths must be non-negative");
        initializeSize();
        T tmp = FixedArrayDefaultValue<T>::value();
        boost::shared_array<T> a(new T[_size]);
        for (size_t i=0; i<_size; ++i) a[i] = tmp;
        _handle = a;
        _ptr = a.get();
    }

    FixedArray2D(const T &initialValue, Py_ssize_t lengthX, Py_ssize_t lengthY)
        : _ptr(0), _length(lengthX, lengthY), _stride(1, lengthX), _handle()
    {
        if (lengthX < 0 || lengthY < 0)
            throw IEX_NAMESPACE::LogicExc("Fixed array 2d lengths must be non-negative");
        initializeSize();
        boost::shared_array<T> a(new T[_size]);
        for (size_t i=0; i<_size; ++i) a[i] = initialValue;
        _handle = a;
        _ptr = a.get();
    }
    void initializeSize()
    {
        _size = _length.x*_length.y;
    }

    template <class S>
    explicit FixedArray2D(const FixedArray2D<S> &other)
        : _ptr(0), _length(other.len()), _stride(1, other.len().x), _handle()
    {
        initializeSize();
        boost::shared_array<T> a(new T[_size]);
        size_t z = 0;
        for (size_t j = 0; j < _length.y; ++j)
            for (size_t i = 0; i < _length.x; ++i)
                a[z++] = T(other(i,j));
        _handle = a;
        _ptr = a.get();
    }

    FixedArray2D(const FixedArray2D &other)
        : _ptr(other._ptr), _length(other._length), _stride(other._stride), _size(other._size), _handle(other._handle)
    {
        //std::cout << "fixed array copy consturct construct" << std::endl;
        // nothing
    }
        
    const FixedArray2D &
    operator = (const FixedArray2D &other)
    {
        if (&other == this) return *this;

        //std::cout << "fixed array assign" << std::endl;

        _ptr = other._ptr;
        _length = other._length;
        _stride = other._stride;
        _handle = other._handle;

        _size = _length.x*_length.y;

        return *this;
    }

    ~FixedArray2D()
    {
        //std::cout << "fixed array delete" << std::endl;
    }

    const boost::any & handle() { return _handle; }

    size_t canonical_index(Py_ssize_t index, size_t length) const
    {
        if (index < 0) index += length;
        if (index >= length || index < 0) {
            PyErr_SetString(PyExc_IndexError, "Index out of range");
            boost::python::throw_error_already_set();
        }
        return index;
    }

    void extract_slice_indices(PyObject *index, size_t length, size_t &start, size_t &end, Py_ssize_t &step, size_t &slicelength) const
    {
        if (PySlice_Check(index)) {
            PySliceObject *slice = reinterpret_cast<PySliceObject *>(index);
            Py_ssize_t s, e, sl;
            if (PySlice_GetIndicesEx(slice,length,&s,&e,&step,&sl) == -1) {
                boost::python::throw_error_already_set();
            }
            if (s < 0 || e < 0 || sl < 0) {
                throw IEX_NAMESPACE::LogicExc("Slice extraction produced invalid start, end, or length indices");
            }
            start = s;
            end = e;
            slicelength = sl;
        } else if (PyInt_Check(index)) {
            size_t i = canonical_index(PyInt_AsSsize_t(index), length);
            start = i; end = i+1; step = 1; slicelength = 1;
        } else {
            PyErr_SetString(PyExc_TypeError, "Object is not a slice");
	    boost::python::throw_error_already_set();
        }
        //std::cout << "Slice indices are " << start << " " << end << " " << step << " " << slicelength << std::endl;
    }

    // return_internal_reference doesn't seem to work with non-class types
    typedef typename boost::mpl::if_<boost::is_class<T>,T&,T>::type get_type;
//    get_type    getitem(Py_ssize_t index) const { return _ptr[canonical_index(index)*_stride]; }
    //FIXME: const does not work here with at least IMATH_NAMESPACE::Color4, why it works for V3fArray?
    get_type getitem(Py_ssize_t i, Py_ssize_t j) //const
    {
        return (*this)(canonical_index(i, _length.x), canonical_index(j, _length.y));
    }

    //FIXME: anyway to seperate 2:3,4:5 from 2,4? we'd like to return int for the second one, and also 1d array for 2, 4:5 or 2:3, 4
    FixedArray2D getslice(PyObject *index) const
    {
        if (PyTuple_Check(index) && PyTuple_Size(index) == 2)
        {
            size_t startx=0, endx=0, slicelengthx=0;
            size_t starty=0, endy=0, slicelengthy=0;
            Py_ssize_t stepx=0;
            Py_ssize_t stepy=0;
            extract_slice_indices(PyTuple_GetItem(index, 0),_length.x,startx,endx,stepx,slicelengthx);
            extract_slice_indices(PyTuple_GetItem(index, 1),_length.y,starty,endy,stepy,slicelengthy);
            FixedArray2D f(slicelengthx, slicelengthy);
            for (size_t j=0,z=0; j<slicelengthy; j++)
                for (size_t i=0; i<slicelengthx; ++i)
                    f._ptr[z++] = (*this)(startx+i*stepx, starty+j*stepy);
            return f;
        }
        else
        {
            PyErr_SetString(PyExc_TypeError, "Slice syntax error");
            boost::python::throw_error_already_set();
        }
        return FixedArray2D(0,0);
    }

    //FIXME: for 2D array, cannot reduce the size, or maybe returning 1D array?
    FixedArray2D getslice_mask(const FixedArray2D<int> &mask) const
    {
//         size_t len = match_dimension(mask);
//         size_t slicelength = 0;
//         for (size_t i=0; i<len; ++i) if (mask[i]) slicelength++;
//         FixedArray2D f(slicelength, _length.y);
//         for (size_t i=0,z=0; i<len; ++i) {
//             if (mask[i]) {
//                 for (size_t j = 0; j < _length.y; j++)
//                     f._ptr[z++] = (*this)(i,j);
//             }
//         }
//         return f;
        IMATH_NAMESPACE::Vec2<size_t> len = match_dimension(mask);
        FixedArray2D f(len);
        for (size_t j=0; j<len.y; j++)
            for (size_t i=0; i<len.x; i++)
                if (mask(i,j))
                    f(i,j) = (*this)(i,j);
        return f;
    }

//     void setitem(const boost::python::tuple& index, const T &data)
//     {
//         Py_ssize_t i = boost::python::extract<Py_ssize_t>(index[0]);
//         Py_ssize_t j = boost::python::extract<Py_ssize_t>(index[1]);
//         (*this)(i,j) = data;
//     }
    void
    setitem_scalar(PyObject *index, const T &data)
    {
        if (!PyTuple_Check(index) || PyTuple_Size(index) != 2)
        {
            PyErr_SetString(PyExc_TypeError, "Slice syntax error");
            boost::python::throw_error_already_set();
        }

        size_t startx=0, endx=0, slicelengthx=0;
        size_t starty=0, endy=0, slicelengthy=0;
        Py_ssize_t stepx=0;
        Py_ssize_t stepy=0;
        extract_slice_indices(PyTuple_GetItem(index, 0),_length.x,startx,endx,stepx,slicelengthx);
        extract_slice_indices(PyTuple_GetItem(index, 1),_length.y,starty,endy,stepy,slicelengthy);
        for (size_t j=0; j<slicelengthy; j++)
            for (size_t i=0; i<slicelengthx; ++i)
                (*this)(startx+i*stepx, starty+j*stepy) = data;
    }

    void
    setitem_scalar_mask(const FixedArray2D<int> &mask, const T &data)
    {
        IMATH_NAMESPACE::Vec2<size_t> len = match_dimension(mask);
        for (size_t j = 0; j < len.y; j++)
            for (size_t i=0; i<len.x; ++i)
                if (mask(i,j))
                    (*this)(i,j) = data;
    }

    void
    setitem_vector(PyObject *index, const FixedArray2D &data)
    {
        //TODO:sanity check
        size_t startx=0, endx=0, slicelengthx=0;
        size_t starty=0, endy=0, slicelengthy=0;
        Py_ssize_t stepx=0;
        Py_ssize_t stepy=0;
        extract_slice_indices(PyTuple_GetItem(index, 0),_length.x,startx,endx,stepx,slicelengthx);
        extract_slice_indices(PyTuple_GetItem(index, 1),_length.y,starty,endy,stepy,slicelengthy);
        // we have a valid range of indices
        if (data.len() != IMATH_NAMESPACE::Vec2<size_t>(slicelengthx, slicelengthy)) {
            PyErr_SetString(PyExc_IndexError, "Dimensions of source do not match destination");
            boost::python::throw_error_already_set();
        }
        for (size_t i=0; i<slicelengthx; ++i)
            for (size_t j=0; j<slicelengthy; ++j)
                (*this)(startx+i*stepx, starty+j*stepy) = data(i,j);
    }

    void
    setitem_vector_mask(const FixedArray2D<int> &mask, const FixedArray2D &data)
    {
        IMATH_NAMESPACE::Vec2<size_t> len = match_dimension(mask);
        if (data.len() == len) {
            for (size_t j = 0; j < len.y; j++)
                for (size_t i=0; i<len.x; ++i)
                    if (mask(i,j))
                        (*this)(i,j) = data(i,j);
        } else {
            PyErr_SetString(PyExc_IndexError, "Dimensions of source data do not match destination");
            boost::python::throw_error_already_set();
        }
    }

    void
    setitem_array1d_mask(const FixedArray2D<int> &mask, const FixedArray<T> &data)
    {
        IMATH_NAMESPACE::Vec2<size_t> len = match_dimension(mask);
        if (data.len() == len.x*len.y) {
            for (size_t j = 0, z = 0; j < len.y; j++)
                for (size_t i=0; i<len.x; ++i, ++z)
                    if (mask(i,j))
                        (*this)(i,j) = data[z];
        } else {
            size_t count = 0;
            for (size_t j = 0, z = 0; j < len.y; j++)
                for (size_t i=0; i<len.x; ++i, ++z)
                    if (mask(i,j)) count++;

            if (data.len() != count) {
                PyErr_SetString(PyExc_IndexError, "Dimensions of source data do not match destination either masked or unmasked");
                boost::python::throw_error_already_set();
            }

            for (size_t j = 0, z = 0; j < len.y; j++)
                for (size_t i=0; i<len.x; ++i)
                    if (mask(i,j))
                        (*this)(i,j) = data[z++];
        }
    }

    void
    setitem_array1d(PyObject *index, const FixedArray<T> &data)
    {
        //TODO:sanity check
        size_t startx=0, endx=0, slicelengthx=0;
        size_t starty=0, endy=0, slicelengthy=0;
        Py_ssize_t stepx=0;
        Py_ssize_t stepy=0;
        extract_slice_indices(PyTuple_GetItem(index, 0),_length.x,startx,endx,stepx,slicelengthx);
        extract_slice_indices(PyTuple_GetItem(index, 1),_length.y,starty,endy,stepy,slicelengthy);
        // we have a valid range of indices
        if (data.len() != slicelengthx*slicelengthy) {
            PyErr_SetString(PyExc_IndexError, "Dimensions of source data do not match destination");
            boost::python::throw_error_already_set();
        }
        for (size_t j=0, z=0; j<slicelengthy; ++j)
            for (size_t i=0; i<slicelengthx; ++i, ++z)
                (*this)(startx+i*stepx, starty+j*stepy) = data[z];
    }

    IMATH_NAMESPACE::Vec2<size_t> len() const { return _length; }
    IMATH_NAMESPACE::Vec2<size_t> stride() const { return _stride; }
    T       & operator () (size_t i, size_t j)       { return _ptr[_stride.x*(j*_stride.y + i)]; }
    const T & operator () (size_t i, size_t j) const { return _ptr[_stride.x*(j*_stride.y + i)]; }
    size_t totalLen() const { return _size; }
    boost::python::tuple size() const
    {
        return boost::python::make_tuple(_length.x, _length.y);
    }

    static boost::python::class_<FixedArray2D<T> > register_(const char *name, const char *doc)
    {
        // a little tricky, but here we go - class types return internal references
        // but fundemental types just get copied.  this typedef sets up the appropriate
        // call policy for each type.
        typedef typename boost::mpl::if_<
            boost::is_class<T>,
            boost::python::return_internal_reference<>,
            boost::python::default_call_policies>::type call_policy;

        boost::python::class_<FixedArray2D<T> > c(name,doc, boost::python::init<size_t, size_t>(
            "construct an array of the specified length initialized to the default value for the type"));
        c
            .def(boost::python::init<const FixedArray2D<T> &>("construct an array with the same values as the given array"))
            .def(boost::python::init<const T &,size_t,size_t>("construct an array of the specified length initialized to the specified default value"))
            .def("__getitem__", &FixedArray2D<T>::getslice)
            .def("__getitem__", &FixedArray2D<T>::getslice_mask)
//             .def("__getitem__", &FixedArray2D<T>::getitem, call_policy())
            .def("item", &FixedArray2D<T>::getitem, call_policy())
//             .def("__setitem__", &FixedArray2D<T>::setitem)
            .def("__setitem__", &FixedArray2D<T>::setitem_scalar)
            .def("__setitem__", &FixedArray2D<T>::setitem_scalar_mask)
            .def("__setitem__", &FixedArray2D<T>::setitem_vector)
            .def("__setitem__", &FixedArray2D<T>::setitem_vector_mask)
            .def("__setitem__", &FixedArray2D<T>::setitem_array1d)
            .def("__setitem__", &FixedArray2D<T>::setitem_array1d_mask)
            .def("__len__",&FixedArray2D<T>::totalLen)
            .def("size",&FixedArray2D<T>::size)
            .def("ifelse",&FixedArray2D<T>::ifelse_scalar)
            .def("ifelse",&FixedArray2D<T>::ifelse_vector)
            ;
        return c;
    }

//     template <class T2>
//     size_t match_dimension(const FixedArray<T2> &a1) const
//     {
//         if (_length.x != a1.len()) {
//             PyErr_SetString(PyExc_IndexError, "Dimensions of source do not match destination");
//             boost::python::throw_error_already_set();
//         }
//         return _length.x;
//     }

    template <class T2>
    IMATH_NAMESPACE::Vec2<size_t> match_dimension(const FixedArray2D<T2> &a1) const
    {
        if (len() != a1.len()) {
            PyErr_SetString(PyExc_IndexError, "Dimensions of source do not match destination");
            boost::python::throw_error_already_set();
        }
        return len();
    }

    FixedArray2D<T> ifelse_vector(const FixedArray2D<int> &choice, const FixedArray2D<T> &other) {
        IMATH_NAMESPACE::Vec2<size_t> len = match_dimension(choice);
        match_dimension(other);
        FixedArray2D<T> tmp(len); // should use default construction but V3f doens't initialize
        for (size_t j = 0; j < len.y; ++j)
            for (size_t i = 0; i < len.x; ++i)
                tmp(i,j) = choice(i,j) ? (*this)(i,j) : other(i,j);
        return tmp;
    }

    FixedArray2D<T> ifelse_scalar(const FixedArray2D<int> &choice, const T &other) {
        IMATH_NAMESPACE::Vec2<size_t> len = match_dimension(choice);
        FixedArray2D<T> tmp(len); // should use default construction but V3f doens't initialize
        for (size_t j = 0; j < len.y; ++j)
            for (size_t i = 0; i < len.x; ++i)
                tmp(i,j) = choice(i,j) ? (*this)(i,j) : other;
        return tmp;
    }

};
 
// unary operation application
template <template <class,class> class Op, class T1, class Ret>
FixedArray2D<Ret> apply_array2d_unary_op(const FixedArray2D<T1> &a1)
{
    IMATH_NAMESPACE::Vec2<size_t> len = a1.len();
    FixedArray2D<Ret> retval(len.x,len.y);
    for (int j=0; j<len.y; ++j) {
        for (int i=0;i<len.x;++i) {
            retval(i,j) = Op<T1,Ret>::apply(a1(i,j));
        }
    }
    return retval;
}

// binary operation application
template <template <class,class,class> class Op, class T1, class T2, class Ret>
FixedArray2D<Ret> apply_array2d_array2d_binary_op(const FixedArray2D<T1> &a1, const FixedArray2D<T2> &a2)
{
    IMATH_NAMESPACE::Vec2<size_t> len = a1.match_dimension(a2);
    FixedArray2D<Ret> retval(len.x,len.y);
    for (int j=0; j<len.y; ++j) {
        for (int i=0;i<len.x;++i) {
            retval(i,j) = Op<T1,T2,Ret>::apply(a1(i,j),a2(i,j));
        }
    }
    return retval;
}

template <template <class,class,class> class Op, class T1, class T2, class Ret>
FixedArray2D<Ret> apply_array2d_scalar_binary_op(const FixedArray2D<T1> &a1, const T2 &a2)
{
    IMATH_NAMESPACE::Vec2<size_t> len = a1.len();
    FixedArray2D<Ret> retval(len.x,len.y);
    for (int j=0; j<len.y; ++j) {
        for (int i=0;i<len.x;++i) {
            retval(i,j) = Op<T1,T2,Ret>::apply(a1(i,j),a2);
        }
    }
    return retval;
}

template <template <class,class,class> class Op, class T1, class T2, class Ret>
FixedArray2D<Ret> apply_array2d_scalar_binary_rop(const FixedArray2D<T1> &a1, const T2 &a2)
{
    IMATH_NAMESPACE::Vec2<size_t> len = a1.len();
    FixedArray2D<Ret> retval(len.x,len.y);
    for (int j=0; j<len.y; ++j) {
        for (int i=0;i<len.x;++i) {
            retval(i,j) = Op<T2,T1,Ret>::apply(a2,a1(i,j));
        }
    }
    return retval;
}

// in-place binary operation application
template <template <class,class> class Op, class T1, class T2>
FixedArray2D<T1> & apply_array2d_array2d_ibinary_op(FixedArray2D<T1> &a1, const FixedArray2D<T2> &a2)
{
    IMATH_NAMESPACE::Vec2<size_t> len = a1.match_dimension(a2);
    for (int j=0; j<len.y; ++j) {
        for (int i=0;i<len.x;++i) {
            Op<T1,T2>::apply(a1(i,j),a2(i,j));
        }
    }
    return a1;
}

// in-place binary operation application
template <template <class,class> class Op, class T1, class T2>
FixedArray2D<T1> & apply_array2d_scalar_ibinary_op(FixedArray2D<T1> &a1, const T2 &a2)
{
    IMATH_NAMESPACE::Vec2<size_t> len = a1.len();
    for (int j=0; j<len.y; ++j) {
        for (int i=0;i<len.x;++i) {
            Op<T1,T2>::apply(a1(i,j),a2);
        }
    }
    return a1;
}

    
// PyObject* PyNumber_Add(	PyObject *o1, PyObject *o2)
template <class T> static FixedArray2D<T> operator + (const FixedArray2D<T> &a0, const FixedArray2D<T> &a1) { return apply_array2d_array2d_binary_op<op_add,T,T,T>(a0,a1); }
template <class T> static FixedArray2D<T> operator + (const FixedArray2D<T> &a0, const T &v1)               { return apply_array2d_scalar_binary_op<op_add,T,T,T>(a0,v1); }
template <class T> static FixedArray2D<T> operator + (const T &v1, const FixedArray2D<T> &a0)               { return a0+v1; }

// PyObject* PyNumber_Subtract(	PyObject *o1, PyObject *o2)
template <class T> static FixedArray2D<T> operator - (const FixedArray2D<T> &a0, const FixedArray2D<T> &a1) { return apply_array2d_array2d_binary_op<op_sub,T,T,T>(a0,a1); }
template <class T> static FixedArray2D<T> operator - (const FixedArray2D<T> &a0, const T &v1)               { return apply_array2d_scalar_binary_op<op_sub,T,T,T>(a0,v1); }
template <class T> static FixedArray2D<T> operator - (const T &v1, const FixedArray2D<T> &a0)               { return apply_array2d_scalar_binary_op<op_rsub,T,T,T>(a0,v1); }

// PyObject* PyNumber_Multiply(	PyObject *o1, PyObject *o2)
template <class T> static FixedArray2D<T> operator * (const FixedArray2D<T> &a0, const FixedArray2D<T> &a1) { return apply_array2d_array2d_binary_op<op_mul,T,T,T>(a0,a1); }
template <class T> static FixedArray2D<T> operator * (const FixedArray2D<T> &a0, const T &v1)               { return apply_array2d_scalar_binary_op<op_mul,T,T,T>(a0,v1); }
template <class T> static FixedArray2D<T> operator * (const T &v1, const FixedArray2D<T> &a0)               { return a0*v1; }

// PyObject* PyNumber_Divide(	PyObject *o1, PyObject *o2)
template <class T> static FixedArray2D<T> operator / (const FixedArray2D<T> &a0, const FixedArray2D<T> &a1) { return apply_array2d_array2d_binary_op<op_div,T,T,T>(a0,a1); }
template <class T> static FixedArray2D<T> operator / (const FixedArray2D<T> &a0, const T &v1)               { return apply_array2d_scalar_binary_op<op_div,T,T,T>(a0,v1); }
// no reversed scalar/array2d divide - no meaning

// PyObject* PyNumber_FloorDivide(	PyObject *o1, PyObject *o2)
// PyObject* PyNumber_TrueDivide(	PyObject *o1, PyObject *o2)
// PyObject* PyNumber_Remainder(	PyObject *o1, PyObject *o2)
template <class T> static FixedArray2D<T> operator % (const FixedArray2D<T> &a0, const FixedArray2D<T> &a1) { return apply_array2d_array2d_binary_op<op_mod,T,T,T>(a0,a1); }
template <class T> static FixedArray2D<T> operator % (const FixedArray2D<T> &a0, const T &v1)               { return apply_array2d_scalar_binary_op<op_mod,T,T,T>(a0,v1); }
// no reversed scalar%array2d remainder - no meaning

// PyObject* PyNumber_Divmod(	PyObject *o1, PyObject *o2)

// PyObject* PyNumber_Power(	PyObject *o1, PyObject *o2, PyObject *o3)
template <class T> static FixedArray2D<T> pow_array2d_array2d (const FixedArray2D<T> &a0, const FixedArray2D<T> &a1) { return apply_array2d_array2d_binary_op<op_pow,T,T,T>(a0,a1); }
template <class T> static FixedArray2D<T> pow_array2d_scalar (const FixedArray2D<T> &a0, const T &v1)                { return apply_array2d_scalar_binary_op<op_pow,T,T,T>(a0,v1); }
// no reversed scalar/array2d pow - no meaning

// PyObject* PyNumber_Negative(	PyObject *o)
template <class T> static FixedArray2D<T> operator - (const FixedArray2D<T> &a0) { return apply_array2d_unary_op<op_neg,T,T>(a0); }

// PyObject* PyNumber_Positive(	PyObject *o)

// PyObject* PyNumber_Absolute(	PyObject *o)
template <class T> static FixedArray2D<T> abs (const FixedArray2D<T> &a0)        { return apply_array2d_unary_op<op_abs,T,T>(a0); }

// PyObject* PyNumber_Invert(	PyObject *o)
template <class T> static FixedArray2D<T> operator ~ (const FixedArray2D<T> &a0) { return apply_array2d_unary_op<op_inverse,T,T>(a0); }

// PyObject* PyNumber_Lshift(	PyObject *o1, PyObject *o2)
template <class T> static FixedArray2D<T> operator << (const FixedArray2D<T> &a0, const FixedArray2D<T> &a1) { return apply_array2d_array2d_binary_op<op_lshift,T,T,T>(a0,a1); }
template <class T> static FixedArray2D<T> operator << (const FixedArray2D<T> &a0, const T &v1)               { return apply_array2d_scalar_binary_op<op_lshift,T,T,T>(a0,v1); }
// no reversed

// PyObject* PyNumber_Rshift(	PyObject *o1, PyObject *o2)
template <class T> static FixedArray2D<T> operator >> (const FixedArray2D<T> &a0, const FixedArray2D<T> &a1) { return apply_array2d_array2d_binary_op<op_rshift,T,T,T>(a0,a1); }
template <class T> static FixedArray2D<T> operator >> (const FixedArray2D<T> &a0, const T &v1)               { return apply_array2d_scalar_binary_op<op_rshift,T,T,T>(a0,v1); }
// no reversed

// PyObject* PyNumber_And(	PyObject *o1, PyObject *o2)
template <class T> static FixedArray2D<T> operator & (const FixedArray2D<T> &a0, const FixedArray2D<T> &a1) { return apply_array2d_array2d_binary_op<op_bitand,T,T,T>(a0,a1); }
template <class T> static FixedArray2D<T> operator & (const FixedArray2D<T> &a0, const T &v1)               { return apply_array2d_scalar_binary_op<op_bitand,T,T,T>(a0,v1); }
template <class T> static FixedArray2D<T> operator & (const T &v1, const FixedArray2D<T> &a0)               { return a0&v1; }

// PyObject* PyNumber_Xor(	PyObject *o1, PyObject *o2)
template <class T> static FixedArray2D<T> operator ^ (const FixedArray2D<T> &a0, const FixedArray2D<T> &a1) { return apply_array2d_array2d_binary_op<op_xor,T,T,T>(a0,a1); }
template <class T> static FixedArray2D<T> operator ^ (const FixedArray2D<T> &a0, const T &v1)               { return apply_array2d_scalar_binary_op<op_xor,T,T,T>(a0,v1); }
template <class T> static FixedArray2D<T> operator ^ (const T &v1, const FixedArray2D<T> &a0)               { return a0^v1; }

// PyObject* PyNumber_Or(	PyObject *o1, PyObject *o2)
template <class T> static FixedArray2D<T> operator | (const FixedArray2D<T> &a0, const FixedArray2D<T> &a1) { return apply_array2d_array2d_binary_op<op_bitor,T,T,T>(a0,a1); }
template <class T> static FixedArray2D<T> operator | (const FixedArray2D<T> &a0, const T &v1)               { return apply_array2d_scalar_binary_op<op_bitor,T,T,T>(a0,v1); }
template <class T> static FixedArray2D<T> operator | (const T &v1, const FixedArray2D<T> &a0)               { return a0|v1; }


// PyObject* PyNumber_InPlaceAdd(	PyObject *o1, PyObject *o2)
template <class T> static FixedArray2D<T> & operator += (FixedArray2D<T> &a0, const FixedArray2D<T> &a1) { return apply_array2d_array2d_ibinary_op<op_iadd,T,T>(a0,a1); }
template <class T> static FixedArray2D<T> & operator += (FixedArray2D<T> &a0, const T &v1)               { return apply_array2d_scalar_ibinary_op<op_iadd,T,T>(a0,v1); }

// PyObject* PyNumber_InPlaceSubtract(	PyObject *o1, PyObject *o2)
template <class T> static FixedArray2D<T> & operator -= (FixedArray2D<T> &a0, const FixedArray2D<T> &a1) { return apply_array2d_array2d_ibinary_op<op_isub,T,T>(a0,a1); }
template <class T> static FixedArray2D<T> & operator -= (FixedArray2D<T> &a0, const T &v1)               { return apply_array2d_scalar_ibinary_op<op_isub,T,T>(a0,v1); }

// PyObject* PyNumber_InPlaceMultiply(	PyObject *o1, PyObject *o2)
template <class T> static FixedArray2D<T> & operator *= (FixedArray2D<T> &a0, const FixedArray2D<T> &a1) { return apply_array2d_array2d_ibinary_op<op_imul,T,T>(a0,a1); }
template <class T> static FixedArray2D<T> & operator *= (FixedArray2D<T> &a0, const T &v1)               { return apply_array2d_scalar_ibinary_op<op_imul,T,T>(a0,v1); }

// PyObject* PyNumber_InPlaceDivide(	PyObject *o1, PyObject *o2)
template <class T> static FixedArray2D<T> & operator /= (FixedArray2D<T> &a0, const FixedArray2D<T> &a1) { return apply_array2d_array2d_ibinary_op<op_idiv,T,T>(a0,a1); }
template <class T> static FixedArray2D<T> & operator /= (FixedArray2D<T> &a0, const T &v1)               { return apply_array2d_scalar_ibinary_op<op_idiv,T,T>(a0,v1); }

// PyObject* PyNumber_InPlaceFloorDivide(	PyObject *o1, PyObject *o2)
// not implemented

// PyObject* PyNumber_InPlaceTrueDivide(	PyObject *o1, PyObject *o2)
// not implemented

// PyObject* PyNumber_InPlaceRemainder(	PyObject *o1, PyObject *o2)
template <class T> static FixedArray2D<T> & operator %= (FixedArray2D<T> &a0, const FixedArray2D<T> &a1) { return apply_array2d_array2d_ibinary_op<op_imod,T,T>(a0,a1); }
template <class T> static FixedArray2D<T> & operator %= (FixedArray2D<T> &a0, const T &v1)               { return apply_array2d_scalar_ibinary_op<op_imod,T,T>(a0,v1); }

// PyObject* PyNumber_InPlacePower(	PyObject *o1, PyObject *o2, PyObject *o3)
template <class T> static FixedArray2D<T> & ipow_array2d_array2d (FixedArray2D<T> &a0, const FixedArray2D<T> &a1) { return apply_array2d_array2d_ibinary_op<op_ipow,T,T>(a0,a1); }
template <class T> static FixedArray2D<T> & ipow_array2d_scalar (FixedArray2D<T> &a0, const T &v1)                { return apply_array2d_scalar_ibinary_op<op_ipow,T,T>(a0,v1); }

// PyObject* PyNumber_InPlaceLshift(	PyObject *o1, PyObject *o2)
template <class T> static FixedArray2D<T> & operator <<= (FixedArray2D<T> &a0, const FixedArray2D<T> &a1) { return apply_array2d_array2d_ibinary_op<op_ilshift,T,T>(a0,a1); }
template <class T> static FixedArray2D<T> & operator <<= (FixedArray2D<T> &a0, const T &v1)               { return apply_array2d_scalar_ibinary_op<op_ilshift,T,T>(a0,v1); }

// PyObject* PyNumber_InPlaceRshift(	PyObject *o1, PyObject *o2)
template <class T> static FixedArray2D<T> & operator >>= (FixedArray2D<T> &a0, const FixedArray2D<T> &a1) { return apply_array2d_array2d_ibinary_op<op_irshift,T,T>(a0,a1); }
template <class T> static FixedArray2D<T> & operator >>= (FixedArray2D<T> &a0, const T &v1)               { return apply_array2d_scalar_ibinary_op<op_irshift,T,T>(a0,v1); }

// PyObject* PyNumber_InPlaceAnd(	PyObject *o1, PyObject *o2)
template <class T> static FixedArray2D<T> & operator &= (FixedArray2D<T> &a0, const FixedArray2D<T> &a1) { return apply_array2d_array2d_ibinary_op<op_ibitand,T,T>(a0,a1); }
template <class T> static FixedArray2D<T> & operator &= (FixedArray2D<T> &a0, const T &v1)               { return apply_array2d_scalar_ibinary_op<op_ibitand,T,T>(a0,v1); }

// PyObject* PyNumber_InPlaceXor(	PyObject *o1, PyObject *o2)
template <class T> static FixedArray2D<T> & operator ^= (FixedArray2D<T> &a0, const FixedArray2D<T> &a1) { return apply_array2d_array2d_ibinary_op<op_ixor,T,T>(a0,a1); }
template <class T> static FixedArray2D<T> & operator ^= (FixedArray2D<T> &a0, const T &v1)               { return apply_array2d_scalar_ibinary_op<op_ixor,T,T>(a0,v1); }

// PyObject* PyNumber_InPlaceOr(	PyObject *o1, PyObject *o2)
template <class T> static FixedArray2D<T> & operator |= (FixedArray2D<T> &a0, const FixedArray2D<T> &a1) { return apply_array2d_array2d_ibinary_op<op_ibitor,T,T>(a0,a1); }
template <class T> static FixedArray2D<T> & operator |= (FixedArray2D<T> &a0, const T &v1)               { return apply_array2d_scalar_ibinary_op<op_ibitor,T,T>(a0,v1); }

template <class T>
static void add_arithmetic_math_functions(boost::python::class_<FixedArray2D<T> > &c) {
    using namespace boost::python;
    c
        .def("__add__",&apply_array2d_array2d_binary_op<op_add,T,T,T>)
        .def("__add__",&apply_array2d_scalar_binary_op<op_add,T,T,T>)
        .def("__radd__",&apply_array2d_scalar_binary_rop<op_add,T,T,T>)
        .def("__sub__",&apply_array2d_array2d_binary_op<op_sub,T,T,T>)
        .def("__sub__",&apply_array2d_scalar_binary_op<op_sub,T,T,T>)
        .def("__rsub__",&apply_array2d_scalar_binary_op<op_rsub,T,T,T>)
        .def("__mul__",&apply_array2d_array2d_binary_op<op_mul,T,T,T>)
        .def("__mul__",&apply_array2d_scalar_binary_op<op_mul,T,T,T>)
        .def("__rmul__",&apply_array2d_scalar_binary_rop<op_mul,T,T,T>)
        .def("__div__",&apply_array2d_array2d_binary_op<op_div,T,T,T>)
        .def("__div__",&apply_array2d_scalar_binary_op<op_div,T,T,T>)
        .def("__truediv__",&apply_array2d_array2d_binary_op<op_div,T,T,T>)
        .def("__truediv__",&apply_array2d_scalar_binary_op<op_div,T,T,T>)
        .def("__neg__",&apply_array2d_unary_op<op_neg,T,T>)
        .def("__iadd__",&apply_array2d_array2d_ibinary_op<op_iadd,T,T>,return_internal_reference<>())
        .def("__iadd__",&apply_array2d_scalar_ibinary_op<op_iadd,T,T>,return_internal_reference<>())
        .def("__isub__",&apply_array2d_array2d_ibinary_op<op_isub,T,T>,return_internal_reference<>())
        .def("__isub__",&apply_array2d_scalar_ibinary_op<op_isub,T,T>,return_internal_reference<>())
        .def("__imul__",&apply_array2d_array2d_ibinary_op<op_imul,T,T>,return_internal_reference<>())
        .def("__imul__",&apply_array2d_scalar_ibinary_op<op_imul,T,T>,return_internal_reference<>())
        .def("__idiv__",&apply_array2d_array2d_ibinary_op<op_idiv,T,T>,return_internal_reference<>())
        .def("__idiv__",&apply_array2d_scalar_ibinary_op<op_idiv,T,T>,return_internal_reference<>())
        .def("__itruediv__",&apply_array2d_array2d_ibinary_op<op_idiv,T,T>,return_internal_reference<>())
        .def("__itruediv__",&apply_array2d_scalar_ibinary_op<op_idiv,T,T>,return_internal_reference<>())
        ;
}


template <class T>
static void add_pow_math_functions(boost::python::class_<FixedArray2D<T> > &c) {
    using namespace boost::python;
    c
        .def("__pow__",&apply_array2d_array2d_binary_op<op_pow,T,T,T>)
        .def("__pow__",&apply_array2d_scalar_binary_op<op_pow,T,T,T>)
        .def("__rpow__",&apply_array2d_scalar_binary_rop<op_rpow,T,T,T>)
        .def("__ipow__",&apply_array2d_array2d_ibinary_op<op_ipow,T,T>,return_internal_reference<>())
        .def("__ipow__",&apply_array2d_scalar_ibinary_op<op_ipow,T,T>,return_internal_reference<>())
        ;
}

template <class T>
static void add_mod_math_functions(boost::python::class_<FixedArray2D<T> > &c) {
    using namespace boost::python;
    c
        .def("__mod__",&apply_array2d_array2d_binary_op<op_mod,T,T,T>)
        .def("__mod__",&apply_array2d_scalar_binary_op<op_mod,T,T,T>)
        .def("__imod__",&apply_array2d_array2d_ibinary_op<op_imod,T,T>,return_internal_reference<>())
        .def("__imod__",&apply_array2d_scalar_ibinary_op<op_imod,T,T>,return_internal_reference<>())
        ;
}

template <class T>
static void add_shift_math_functions(boost::python::class_<FixedArray2D<T> > &c) {
    using namespace boost::python;
    c
        .def("__lshift__",&apply_array2d_array2d_binary_op<op_lshift,T,T,T>)
        .def("__lshift__",&apply_array2d_scalar_binary_op<op_lshift,T,T,T>)
        .def("__ilshift__",&apply_array2d_array2d_ibinary_op<op_ilshift,T,T>,return_internal_reference<>())
        .def("__ilshift__",&apply_array2d_scalar_ibinary_op<op_ilshift,T,T>,return_internal_reference<>())
        .def("__rshift__",&apply_array2d_array2d_binary_op<op_rshift,T,T,T>)
        .def("__rshift__",&apply_array2d_scalar_binary_op<op_rshift,T,T,T>)
        .def("__irshift__",&apply_array2d_array2d_ibinary_op<op_irshift,T,T>,return_internal_reference<>())
        .def("__irshift__",&apply_array2d_scalar_ibinary_op<op_irshift,T,T>,return_internal_reference<>())
        ;
}

template <class T>
static void add_bitwise_math_functions(boost::python::class_<FixedArray2D<T> > &c) {
    using namespace boost::python;
    c
        .def("__and__",&apply_array2d_array2d_binary_op<op_bitand,T,T,T>)
        .def("__and__",&apply_array2d_scalar_binary_op<op_bitand,T,T,T>)
        .def("__iand__",&apply_array2d_array2d_ibinary_op<op_ibitand,T,T>,return_internal_reference<>())
        .def("__iand__",&apply_array2d_scalar_ibinary_op<op_ibitand,T,T>,return_internal_reference<>())
        .def("__or__",&apply_array2d_array2d_binary_op<op_bitor,T,T,T>)
        .def("__or__",&apply_array2d_scalar_binary_op<op_bitor,T,T,T>)
        .def("__ior__",&apply_array2d_array2d_ibinary_op<op_ibitor,T,T>,return_internal_reference<>())
        .def("__ior__",&apply_array2d_scalar_ibinary_op<op_ibitor,T,T>,return_internal_reference<>())
        .def("__xor__",&apply_array2d_array2d_binary_op<op_xor,T,T,T>)
        .def("__xor__",&apply_array2d_scalar_binary_op<op_xor,T,T,T>)
        .def("__ixor__",&apply_array2d_array2d_ibinary_op<op_ixor,T,T>,return_internal_reference<>())
        .def("__ixor__",&apply_array2d_scalar_ibinary_op<op_ixor,T,T>,return_internal_reference<>())
        ;
}

template <class T>
static void add_comparison_functions(boost::python::class_<FixedArray2D<T> > &c) {
    using namespace boost::python;
    c
        .def("__eq__",&apply_array2d_array2d_binary_op<op_eq,T,T,int>)
        .def("__eq__",&apply_array2d_scalar_binary_op<op_eq,T,T,int>)
        .def("__ne__",&apply_array2d_array2d_binary_op<op_ne,T,T,int>)
        .def("__ne__",&apply_array2d_scalar_binary_op<op_ne,T,T,int>)
        ;
}

template <class T>
static void add_ordered_comparison_functions(boost::python::class_<FixedArray2D<T> > &c) {
    using namespace boost::python;
    c
        .def("__lt__",&apply_array2d_array2d_binary_op<op_lt,T,T,int>)
        .def("__lt__",&apply_array2d_scalar_binary_op<op_lt,T,T,int>)
        .def("__gt__",&apply_array2d_array2d_binary_op<op_gt,T,T,int>)
        .def("__gt__",&apply_array2d_scalar_binary_op<op_gt,T,T,int>)
        .def("__le__",&apply_array2d_array2d_binary_op<op_le,T,T,int>)
        .def("__le__",&apply_array2d_scalar_binary_op<op_le,T,T,int>)
        .def("__ge__",&apply_array2d_array2d_binary_op<op_ge,T,T,int>)
        .def("__ge__",&apply_array2d_scalar_binary_op<op_ge,T,T,int>)
        ;
}

template <class S,class T>
static void add_explicit_construction_from_type(boost::python::class_<FixedArray2D<T> > &c) {
    using namespace boost::python;
    c.def(boost::python::init<FixedArray2D<S> >("copy contents of other array into this one"));
}

}

#endif