//
// SPDX-License-Identifier: BSD-3-Clause
// Copyright Contributors to the OpenEXR Project.
//

// clang-format off


#ifndef _PyImathAutovectorize_h_
#define _PyImathAutovectorize_h_

#include <Python.h>
#define BOOST_BIND_GLOBAL_PLACEHOLDERS
#include <boost/python.hpp>
#include <boost/mpl/size.hpp>
#include <boost/mpl/pop_front.hpp>
#include <boost/mpl/push_front.hpp>
#include <boost/mpl/front.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/transform.hpp>
#include <boost/mpl/remove_if.hpp>
#include <boost/mpl/equal.hpp>
#include <boost/mpl/for_each.hpp>
#include <boost/mpl/not.hpp>
#include <boost/mpl/count.hpp>
#include <boost/mpl/or.hpp>
#include <boost/type_traits/is_base_of.hpp>
#include <boost/type_traits/function_traits.hpp>
#include <boost/static_assert.hpp>
#include <boost/python/args.hpp>
#include <iostream>
#include "PyImathFixedArray.h"
#include "PyImathTask.h"
#include "PyImathUtil.h"

namespace PyImath {

struct op_with_precomputation {};

namespace detail {

using boost::is_base_of;
using boost::is_same;
using boost::is_const;
using boost::remove_const;
using boost::remove_reference;
using boost::function_traits;

using boost::mpl::at;
using boost::mpl::at_c;
using boost::mpl::push_front;
using boost::mpl::vector;
using boost::mpl::push_back;
using boost::mpl::transform;
using boost::mpl::fold;
using boost::mpl::_;
using boost::mpl::_1;
using boost::mpl::_2;
using boost::mpl::long_;
using boost::mpl::false_;
using boost::mpl::true_;
using boost::mpl::not_;
using boost::mpl::or_;
using boost::mpl::and_;
using boost::mpl::size;
using boost::mpl::remove_if;
using boost::mpl::if_;
using boost::mpl::for_each;


struct null_precomputation {
    static void precompute(size_t len) { return; }
};

template <class T> struct op_precompute
{
    static void
    apply(size_t len)
    {
        if_<is_base_of<op_with_precomputation,T>,
            T,
            null_precomputation>::type::precompute(len);
    }
};

template <int N>
struct possible_vectorizations
{
    typedef typename fold<
        typename possible_vectorizations<N-1>::type,
        vector<>,
        push_back<push_back<_1,push_back<_2,false_> >,push_back<_2,true_> >
    >::type type;
};

template <>
struct possible_vectorizations<0>
{
    typedef vector<vector<> > type;    
};

template <class Vectorizable>
struct disallow_vectorization
{
    template <class Vectorize>
    struct apply
    {
        // Valid = !Vectorize || Vectorizable
        typedef typename transform<Vectorize,not_<_> >::type DontVectorize;
        typedef typename transform<DontVectorize,Vectorizable,or_<_,_> >::type Valid;
        typedef typename not_<fold<Valid,true_,and_<_,_> > >::type type;
    };
};

template <class Vectorizable>
struct allowable_vectorizations
{
    typedef typename possible_vectorizations<size<Vectorizable>::value>::type possible;
    typedef typename remove_if<possible,disallow_vectorization<Vectorizable> >::type type;
};

template <class T>
bool any_masked(const T &value)
{
    return false;
};

template <class T>
bool any_masked(const PyImath::FixedArray<T> &value)
{
    return value.isMaskedReference();
};

template <class T1, class T2>
bool any_masked(const T1 &a, const T2 &b)
{
    return any_masked(a) || any_masked(b);
}

template <class T1, class T2, class T3>
bool any_masked(const T1 &a, const T2 &b, const T3 &c)
{
    return any_masked(a,b) || any_masked(c);
}

template <class T1, class T2, class T3, class T4>
bool any_masked(const T1 &a, const T2 &b, const T3 &c, const T4 &d)
{
    return any_masked(a,b) || any_masked(c,d);
}

//-----------------------------------------------------------------------------------------

//
// measure_argument returns a pair indicating the integral length of the argument
// (scalar arguments have implicit length 1), and a bool indicating whether the argument
// is a vectorized argument.
//
template <class T>
struct measure_argument
{
    static inline std::pair<size_t,bool> apply(T arg) { return std::make_pair(1,false); }
};

template <class T>
struct measure_argument<PyImath::FixedArray<T> >
{
    static inline std::pair<size_t,bool> apply(const PyImath::FixedArray<T> &arg) { return std::make_pair(arg.len(),true); }
};

//
// match_lengths returns the compatible length given two argument lengths
//
static inline std::pair<size_t,bool>
match_lengths(const std::pair<size_t,bool> &len1, const std::pair<size_t,bool> &len2)
{
    // scalar arguemnts are always compatible with other arguments
    if (len1.second == false) return len2;
    if (len2.second == false) return len1;

    // now both arguments are vectorized, check for dimension match
    if (len1.first != len2.first)
      throw std::invalid_argument("Array dimensions passed into function do not match");

    return len1;
}


//
// measure_arguments finds the length that a return value from a given
// set of arguments should have, throwing an exception if the lengths
// are incompatible.  If all arguments are scalar, length 1 is returned.
//
template <class arg1_type>
size_t
measure_arguments(const arg1_type &arg1)
{
    std::pair<size_t,bool> len = measure_argument<arg1_type>::apply(arg1);
    return len.first;
}

template <class arg1_type, class arg2_type>
size_t
measure_arguments(const arg1_type &arg1, const arg2_type &arg2)
{
    std::pair<size_t,bool> len = measure_argument<arg1_type>::apply(arg1);
    len = match_lengths(len,measure_argument<arg2_type>::apply(arg2));
    return len.first;
}

template <class arg1_type, class arg2_type, class arg3_type>
size_t
measure_arguments(const arg1_type &arg1, const arg2_type &arg2, const arg3_type &arg3)
{
    std::pair<size_t,bool> len = measure_argument<arg1_type>::apply(arg1);
    len = match_lengths(len,measure_argument<arg2_type>::apply(arg2));
    len = match_lengths(len,measure_argument<arg3_type>::apply(arg3));
    return len.first;
}

template <class arg1_type, class arg2_type, class arg3_type, class arg4_type>
size_t
measure_arguments(const arg1_type &arg1, const arg2_type &arg2, const arg3_type &arg3, const arg4_type &arg4)
{
    std::pair<size_t,bool> len = measure_argument<arg1_type>::apply(arg1);
    len = match_lengths(len,measure_argument<arg2_type>::apply(arg2));
    len = match_lengths(len,measure_argument<arg3_type>::apply(arg3));
    len = match_lengths(len,measure_argument<arg4_type>::apply(arg4));
    return len.first;
}

template <class arg1_type, class arg2_type, class arg3_type, class arg4_type, class arg5_type>
size_t
measure_arguments(const arg1_type &arg1, const arg2_type &arg2, const arg3_type &arg3, const arg4_type &arg4, const arg5_type &arg5)
{
    std::pair<size_t,bool> len = measure_argument<arg1_type>::apply(arg1);
    len = match_lengths(len,measure_argument<arg2_type>::apply(arg2));
    len = match_lengths(len,measure_argument<arg3_type>::apply(arg3));
    len = match_lengths(len,measure_argument<arg4_type>::apply(arg4));
    len = match_lengths(len,measure_argument<arg5_type>::apply(arg5));
    return len.first;
}

//-----------------------------------------------------------------------------------------

template <class T>
struct create_uninitalized_return_value
{
    static T apply(size_t length)
    {
        return T();
    }
};

template <class T>
struct create_uninitalized_return_value<PyImath::FixedArray<T> >
{
    static PyImath::FixedArray<T> apply(size_t length)
    {
        return PyImath::FixedArray<T>(Py_ssize_t(length),PyImath::UNINITIALIZED);
    }
};

template <class T, class VectorizeArg>
struct vectorized_result_type
{
    typedef typename if_<VectorizeArg,PyImath::FixedArray<T>,T>::type type;
};

template <typename T>
struct SimpleNonArrayWrapper
{
    struct ReadOnlyDirectAccess
    {
        ReadOnlyDirectAccess (const T& arg)
            : _arg (arg) {}
        ReadOnlyDirectAccess (const ReadOnlyDirectAccess& other)
            : _arg (other._arg) {}

        const T&  operator[] (size_t) const { return _arg; }

      private:
        const T&  _arg;
    };

    struct WritableDirectAccess : public ReadOnlyDirectAccess
    {
        WritableDirectAccess (T& arg)
            : ReadOnlyDirectAccess (arg), _arg (arg) {}
        WritableDirectAccess (const WritableDirectAccess& other)
            : ReadOnlyDirectAccess (other), _arg (other._arg) {}

        T&  operator[] (size_t) { return _arg; }

      private:
        T&  _arg;
    };

    typedef ReadOnlyDirectAccess ReadOnlyMaskedAccess;
    typedef WritableDirectAccess WritableMaskedAccess;
};


template <class T>
struct access_type
{
    typedef typename remove_reference<T>::type     prim_type;
    typedef typename remove_const<prim_type>::type base_type;
    typedef typename if_<is_const<prim_type>,
                         const PyImath::FixedArray<base_type> &,
                               PyImath::FixedArray<base_type> &>::type reference_type;
    typedef typename remove_reference<reference_type>::type class_type;

    typedef typename if_<is_const<prim_type>,
                         typename class_type::ReadOnlyMaskedAccess,
                         typename class_type::WritableMaskedAccess>::type masked;
    typedef typename if_<is_const<prim_type>,
                         typename class_type::ReadOnlyDirectAccess,
                         typename class_type::WritableDirectAccess>::type direct;
};

template <class T, class VectorizeArg>
struct argument_access_type
{
    typedef typename remove_const<typename remove_reference<T>::type>::type base_type;
    typedef typename if_<VectorizeArg,const PyImath::FixedArray<base_type> &,T>::type type;

    typedef typename if_<VectorizeArg,
                         typename remove_reference<type>::type,
                              SimpleNonArrayWrapper<base_type> >::type _class_type;

    typedef typename _class_type::ReadOnlyMaskedAccess masked;
    typedef typename _class_type::ReadOnlyDirectAccess direct;
};

template <class T, class VectorizeArg>
struct result_access_type
{
    typedef typename remove_const<typename remove_reference<T>::type>::type base_type;
    typedef typename if_<VectorizeArg,PyImath::FixedArray<base_type>,T>::type type;

    typedef typename if_<VectorizeArg, type,
                         SimpleNonArrayWrapper<base_type> >::type _class_type;

    typedef typename _class_type::WritableMaskedAccess masked;
    typedef typename _class_type::WritableDirectAccess direct;
};

template <class AccessType, class T>
AccessType getArrayAccess (T&  value)
           { return AccessType (value); }

template <class AccessType, class T>
AccessType getArrayAccess (const PyImath::FixedArray<T>& array)
           { return AccessType (array); }

template <class AccessType, class T>
AccessType getArrayAccess (PyImath::FixedArray<T>& array)
           { return AccessType (array); }

//

template <class Op, class result_access_type, class access_type>
struct VectorizedOperation1 : public Task
{
    result_access_type retAccess;
    access_type        access;

    VectorizedOperation1 (result_access_type r, access_type a1)
        : retAccess (r), access (a1) {}

    void execute(size_t start, size_t end)
    {
        for (size_t i = start; i < end; ++i)
        {
            retAccess[i] = Op::apply (access[i]);
        }
    }
};

template <class Op, class result_access_type, class access_type, class arg1_access_type>
struct VectorizedOperation2 : public Task
{
    result_access_type retAccess;
    access_type        access;
    arg1_access_type   argAccess;

    VectorizedOperation2(result_access_type r, access_type a1, arg1_access_type a2)
        : retAccess (r), access (a1), argAccess (a2) {}

    void execute(size_t start, size_t end)
    {
        for (size_t i = start; i < end; ++i)
        {
            retAccess[i] = Op::apply (access[i], argAccess[i]);
        }
    }
};

template <class Op, class result_access_type, class access_type,
                    class arg1_access_type, class arg2_access_type>
struct VectorizedOperation3 : public Task
{
    result_access_type retAccess;
    access_type        access;
    arg1_access_type   arg1Access;
    arg2_access_type   arg2Access;

    VectorizedOperation3(result_access_type r, access_type a,
                         arg1_access_type a1, arg2_access_type a2)
        : retAccess(r), access(a), arg1Access(a1), arg2Access(a2) {}

    void execute(size_t start, size_t end)
    {
        for (size_t i = start; i < end; ++i)
        {
            retAccess[i] = Op::apply(access[i], arg1Access[i], arg2Access[i]);
        }
    }
};

template <class Op, class result_access_type, class access_type,
                    class arg1_access_type, class arg2_access_type, class arg3_access_type>
struct VectorizedOperation4 : public Task
{
    result_access_type retAccess;
    access_type        access;
    arg1_access_type   arg1Access;
    arg2_access_type   arg2Access;
    arg3_access_type   arg3Access;

    VectorizedOperation4(result_access_type r, access_type a,
                         arg1_access_type a1, arg2_access_type a2, arg3_access_type a3)
        : retAccess(r), access(a), arg1Access(a1), arg2Access(a2), arg3Access(a3) {}

    void execute(size_t start, size_t end)
    {
        for (size_t i = start; i < end; ++i)
        {
            retAccess[i] = Op::apply(access[i], arg1Access[i], arg2Access[i], arg3Access[i]);
        }
    }
};

template <class Op, class result_access_type, class access_type,
                    class arg1_access_type, class arg2_access_type, class arg3_access_type, class arg4_access_type>
struct VectorizedOperation5 : public Task
{
    result_access_type retAccess;
    access_type        access;
    arg1_access_type   arg1Access;
    arg2_access_type   arg2Access;
    arg3_access_type   arg3Access;
    arg4_access_type   arg4Access;

    VectorizedOperation5(result_access_type r, access_type a,
                         arg1_access_type a1, arg2_access_type a2, arg3_access_type a3, arg4_access_type a4)
        : retAccess(r), access(a), arg1Access(a1), arg2Access(a2), arg3Access(a3), arg4Access(a4) {}

    void execute(size_t start, size_t end)
    {
        for (size_t i = start; i < end; ++i)
        {
            retAccess[i] = Op::apply(access[i], arg1Access[i], arg2Access[i], arg3Access[i], arg4Access[i]);
        }
    }
};

template <class Op, class Vectorize, class Func>
struct VectorizedFunction1 {
    BOOST_STATIC_ASSERT((size<Vectorize>::value == function_traits<Func>::arity));

    typedef function_traits<Func> traits;
    typedef typename fold<Vectorize,false_,or_<_,_> >::type any_vectorized;

    typedef typename result_access_type<typename traits::result_type,
                                        any_vectorized>::type result_type;
    typedef typename result_access_type<typename traits::result_type,
                                        any_vectorized>::direct result_access_type;
    // Result array is created here 'from scratch', so is always 'direct' access.

    typedef typename argument_access_type<typename traits::arg1_type,
                              typename at<Vectorize,long_<0> >::type>::type arg1_type;
    typedef typename argument_access_type<typename traits::arg1_type,
                              typename at<Vectorize,long_<0> >::type>::direct arg1_direct_access_type;
    typedef typename argument_access_type<typename traits::arg1_type,
                              typename at<Vectorize,long_<0> >::type>::masked arg1_masked_access_type;

    static result_type
    apply(arg1_type arg1)
    {
        PY_IMATH_LEAVE_PYTHON;
        size_t len = measure_arguments(arg1);
        op_precompute<Op>::apply(len);
        result_type retval = create_uninitalized_return_value<result_type>::apply(len);

        result_access_type resultAccess = getArrayAccess<result_access_type> (retval);

        if (any_masked(arg1))
        {
            arg1_masked_access_type argAccess =
                 getArrayAccess<arg1_masked_access_type> (arg1);

            VectorizedOperation1<Op,result_access_type,arg1_masked_access_type>
                vop (resultAccess, argAccess);
            dispatchTask(vop,len);
        }
        else
        {
            arg1_direct_access_type argAccess =
                 getArrayAccess<arg1_direct_access_type> (arg1);

            VectorizedOperation1<Op,result_access_type,arg1_direct_access_type>
                vop (resultAccess, argAccess);
            dispatchTask(vop,len);
        }

        PY_IMATH_RETURN_PYTHON;        
        return retval;
    }

    static std::string
    format_arguments(const boost::python::detail::keywords<1> &args)
    {
        // TODO: add types here
        return std::string("(")+args.elements[0].name+") - ";
    }
};

template <class Op, class Vectorize, class Func>
struct VectorizedFunction2 {
    BOOST_STATIC_ASSERT((size<Vectorize>::value == function_traits<Func>::arity));

    typedef function_traits<Func> traits;
    typedef typename fold<Vectorize,false_,or_<_,_> >::type any_vectorized;

    typedef typename result_access_type<typename traits::result_type,
                                        any_vectorized>::type result_type;
    typedef typename result_access_type<typename traits::result_type,
                                        any_vectorized>::direct result_access_type;
    // Result array is created here 'from scratch', so is always 'direct' access.

    typedef typename argument_access_type<typename traits::arg1_type,
                              typename at<Vectorize,long_<0> >::type>::type arg1_type;
    typedef typename argument_access_type<typename traits::arg1_type,
                              typename at<Vectorize,long_<0> >::type>::direct arg1_direct_access_type;
    typedef typename argument_access_type<typename traits::arg1_type,
                              typename at<Vectorize,long_<0> >::type>::masked arg1_masked_access_type;

    typedef typename argument_access_type<typename traits::arg2_type,
                              typename at<Vectorize,long_<1> >::type>::type arg2_type;
    typedef typename argument_access_type<typename traits::arg2_type,
                              typename at<Vectorize,long_<1> >::type>::direct arg2_direct_access_type;
    typedef typename argument_access_type<typename traits::arg2_type,
                              typename at<Vectorize,long_<1> >::type>::masked arg2_masked_access_type;

    static result_type
    apply(arg1_type arg1, arg2_type arg2)
    {
        PY_IMATH_LEAVE_PYTHON;
        size_t len = measure_arguments(arg1,arg2);
        op_precompute<Op>::apply(len);
        result_type retval = create_uninitalized_return_value<result_type>::apply(len);

        result_access_type resultAccess = getArrayAccess<result_access_type> (retval);

        if (any_masked(arg1))
        {
            arg1_masked_access_type arg1Access =
                 getArrayAccess<arg1_masked_access_type> (arg1);

            if (any_masked(arg2))
            {
                arg2_masked_access_type arg2Access =
                     getArrayAccess<arg2_masked_access_type> (arg2);

                VectorizedOperation2<Op,result_access_type,
                                   arg1_masked_access_type,
                                   arg2_masked_access_type>
                    vop (resultAccess, arg1Access, arg2Access);
                dispatchTask(vop,len);
            }
            else
            {
                arg2_direct_access_type arg2Access =
                     getArrayAccess<arg2_direct_access_type> (arg2);

                VectorizedOperation2<Op,result_access_type,
                                   arg1_masked_access_type,
                                   arg2_direct_access_type>
                    vop (resultAccess, arg1Access, arg2Access);
                dispatchTask(vop,len);
            }
        }
        else
        {
            arg1_direct_access_type arg1Access =
                 getArrayAccess<arg1_direct_access_type> (arg1);

            if (any_masked(arg2))
            {
                arg2_masked_access_type arg2Access =
                     getArrayAccess<arg2_masked_access_type> (arg2);

                VectorizedOperation2<Op,result_access_type,
                                   arg1_direct_access_type,
                                   arg2_masked_access_type>
                    vop (resultAccess, arg1Access, arg2Access);
                dispatchTask(vop,len);
            }
            else
            {
                arg2_direct_access_type arg2Access =
                     getArrayAccess<arg2_direct_access_type> (arg2);

                VectorizedOperation2<Op,result_access_type,
                                   arg1_direct_access_type,
                                   arg2_direct_access_type>
                    vop (resultAccess, arg1Access, arg2Access);
                dispatchTask(vop,len);
            }
        }

        PY_IMATH_RETURN_PYTHON;        
        return retval;
    }

    static std::string
    format_arguments(const boost::python::detail::keywords<2> &args)
    {
        // TODO: add types here
        return std::string("(")+args.elements[0].name+","+args.elements[1].name+") - ";
    }
};

template <class Op, class Vectorize, class Func>
struct VectorizedFunction3 {
    BOOST_STATIC_ASSERT((size<Vectorize>::value == function_traits<Func>::arity));

    typedef function_traits<Func> traits;
    typedef typename fold<Vectorize,false_,or_<_,_> >::type any_vectorized;

    typedef typename result_access_type<typename traits::result_type,
                                        any_vectorized>::type result_type;
    typedef typename result_access_type<typename traits::result_type,
                                        any_vectorized>::direct result_access_type;
    // Result array is created here 'from scratch', so is always 'direct' access.

    typedef typename argument_access_type<typename traits::arg1_type,
                              typename at<Vectorize,long_<0> >::type>::type arg1_type;
    typedef typename argument_access_type<typename traits::arg1_type,
                              typename at<Vectorize,long_<0> >::type>::direct arg1_direct_access_type;
    typedef typename argument_access_type<typename traits::arg1_type,
                              typename at<Vectorize,long_<0> >::type>::masked arg1_masked_access_type;

    typedef typename argument_access_type<typename traits::arg2_type,
                              typename at<Vectorize,long_<1> >::type>::type arg2_type;
    typedef typename argument_access_type<typename traits::arg2_type,
                              typename at<Vectorize,long_<1> >::type>::direct arg2_direct_access_type;
    typedef typename argument_access_type<typename traits::arg2_type,
                              typename at<Vectorize,long_<1> >::type>::masked arg2_masked_access_type;

    typedef typename argument_access_type<typename traits::arg3_type,
                              typename at<Vectorize,long_<2> >::type>::type arg3_type;
    typedef typename argument_access_type<typename traits::arg3_type,
                              typename at<Vectorize,long_<2> >::type>::direct arg3_direct_access_type;
    typedef typename argument_access_type<typename traits::arg3_type,
                              typename at<Vectorize,long_<2> >::type>::masked arg3_masked_access_type;

    static result_type
    apply(arg1_type arg1, arg2_type arg2, arg3_type arg3)
    {
        PY_IMATH_LEAVE_PYTHON;
        size_t len = measure_arguments(arg1,arg2,arg3);
        op_precompute<Op>::apply(len);
        result_type retval = create_uninitalized_return_value<result_type>::apply(len);

        result_access_type resultAccess = getArrayAccess<result_access_type> (retval);

        if (any_masked(arg1))
        {
            arg1_masked_access_type arg1Access =
                 getArrayAccess<arg1_masked_access_type> (arg1);

            if (any_masked(arg2))
            {
                arg2_masked_access_type arg2Access =
                     getArrayAccess<arg2_masked_access_type> (arg2);

                if (any_masked(arg3))
                {
                    arg3_masked_access_type arg3Access =
                         getArrayAccess<arg3_masked_access_type> (arg3);

                    VectorizedOperation3<Op,result_access_type,
                                       arg1_masked_access_type,
                                       arg2_masked_access_type,
                                       arg3_masked_access_type>
                        vop (resultAccess, arg1Access, arg2Access, arg3Access);
                    dispatchTask(vop,len);
                }
                else
                {
                    arg3_direct_access_type arg3Access =
                         getArrayAccess<arg3_direct_access_type> (arg3);

                    VectorizedOperation3<Op,result_access_type,
                                       arg1_masked_access_type,
                                       arg2_masked_access_type,
                                       arg3_direct_access_type>
                        vop (resultAccess, arg1Access, arg2Access, arg3Access);
                    dispatchTask(vop,len);
                }
            }
            else
            {
                arg2_direct_access_type arg2Access =
                     getArrayAccess<arg2_direct_access_type> (arg2);

                if (any_masked(arg3))
                {
                    arg3_masked_access_type arg3Access =
                         getArrayAccess<arg3_masked_access_type> (arg3);

                    VectorizedOperation3<Op,result_access_type,
                                       arg1_masked_access_type,
                                       arg2_direct_access_type,
                                       arg3_masked_access_type>
                        vop (resultAccess, arg1Access, arg2Access, arg3Access);
                    dispatchTask(vop,len);
                }
                else
                {
                    arg3_direct_access_type arg3Access =
                         getArrayAccess<arg3_direct_access_type> (arg3);

                    VectorizedOperation3<Op,result_access_type,
                                       arg1_masked_access_type,
                                       arg2_direct_access_type,
                                       arg3_direct_access_type>
                        vop (resultAccess, arg1Access, arg2Access, arg3Access);
                    dispatchTask(vop,len);
                }
            }
        }
        else
        {
            arg1_direct_access_type arg1Access =
                 getArrayAccess<arg1_direct_access_type> (arg1);

            if (any_masked(arg2))
            {
                arg2_masked_access_type arg2Access =
                     getArrayAccess<arg2_masked_access_type> (arg2);

                if (any_masked(arg3))
                {
                    arg3_masked_access_type arg3Access =
                         getArrayAccess<arg3_masked_access_type> (arg3);

                    VectorizedOperation3<Op,result_access_type,
                                       arg1_direct_access_type,
                                       arg2_masked_access_type,
                                       arg3_masked_access_type>
                        vop (resultAccess, arg1Access, arg2Access, arg3Access);
                    dispatchTask(vop,len);
                }
                else
                {
                    arg3_direct_access_type arg3Access =
                         getArrayAccess<arg3_direct_access_type> (arg3);

                    VectorizedOperation3<Op,result_access_type,
                                       arg1_direct_access_type,
                                       arg2_masked_access_type,
                                       arg3_direct_access_type>
                        vop (resultAccess, arg1Access, arg2Access, arg3Access);
                    dispatchTask(vop,len);
                }
            }
            else
            {
                arg2_direct_access_type arg2Access =
                     getArrayAccess<arg2_direct_access_type> (arg2);

                if (any_masked(arg3))
                {
                    arg3_masked_access_type arg3Access =
                         getArrayAccess<arg3_masked_access_type> (arg3);

                    VectorizedOperation3<Op,result_access_type,
                                       arg1_direct_access_type,
                                       arg2_direct_access_type,
                                       arg3_masked_access_type>
                        vop (resultAccess, arg1Access, arg2Access, arg3Access);
                    dispatchTask(vop,len);
                }
                else
                {
                    arg3_direct_access_type arg3Access =
                         getArrayAccess<arg3_direct_access_type> (arg3);

                    VectorizedOperation3<Op,result_access_type,
                                       arg1_direct_access_type,
                                       arg2_direct_access_type,
                                       arg3_direct_access_type>
                        vop (resultAccess, arg1Access, arg2Access, arg3Access);
                    dispatchTask(vop,len);
                }
            }
        }

        PY_IMATH_RETURN_PYTHON;
        return retval;
    }

    static std::string
    format_arguments(const boost::python::detail::keywords<3> &args)
    {
        // TODO: add types here
        return std::string("(")+args.elements[0].name+","+args.elements[1].name+","+args.elements[2].name+") - ";
    }
};

template <class Op, class Vectorize, class Func>
struct VectorizedFunction4 {
    BOOST_STATIC_ASSERT((size<Vectorize>::value == function_traits<Func>::arity));

    typedef function_traits<Func> traits;
    typedef typename fold<Vectorize,false_,or_<_,_> >::type any_vectorized;

    typedef typename result_access_type<typename traits::result_type,
                                        any_vectorized>::type result_type;
    typedef typename result_access_type<typename traits::result_type,
                                        any_vectorized>::direct result_access_type;
    // Result array is created here 'from scratch', so is always 'direct' access.

    typedef typename argument_access_type<typename traits::arg1_type,
                              typename at<Vectorize,long_<0> >::type>::type arg1_type;
    typedef typename argument_access_type<typename traits::arg1_type,
                              typename at<Vectorize,long_<0> >::type>::direct arg1_direct_access_type;
    typedef typename argument_access_type<typename traits::arg1_type,
                              typename at<Vectorize,long_<0> >::type>::masked arg1_masked_access_type;

    typedef typename argument_access_type<typename traits::arg2_type,
                              typename at<Vectorize,long_<1> >::type>::type arg2_type;
    typedef typename argument_access_type<typename traits::arg2_type,
                              typename at<Vectorize,long_<1> >::type>::direct arg2_direct_access_type;
    typedef typename argument_access_type<typename traits::arg2_type,
                              typename at<Vectorize,long_<1> >::type>::masked arg2_masked_access_type;

    typedef typename argument_access_type<typename traits::arg3_type,
                              typename at<Vectorize,long_<2> >::type>::type arg3_type;
    typedef typename argument_access_type<typename traits::arg3_type,
                              typename at<Vectorize,long_<2> >::type>::direct arg3_direct_access_type;
    typedef typename argument_access_type<typename traits::arg3_type,
                              typename at<Vectorize,long_<2> >::type>::masked arg3_masked_access_type;

    typedef typename argument_access_type<typename traits::arg4_type,
                              typename at<Vectorize,long_<3> >::type>::type arg4_type;
    typedef typename argument_access_type<typename traits::arg4_type,
                              typename at<Vectorize,long_<3> >::type>::direct arg4_direct_access_type;
    typedef typename argument_access_type<typename traits::arg4_type,
                              typename at<Vectorize,long_<3> >::type>::masked arg4_masked_access_type;

    static result_type
    apply(arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4)
    {
        PY_IMATH_LEAVE_PYTHON;
        size_t len = measure_arguments(arg1,arg2,arg3,arg4);
        op_precompute<Op>::apply(len);
        result_type retval = create_uninitalized_return_value<result_type>::apply(len);

        result_access_type resultAccess = getArrayAccess<result_access_type> (retval);

        if (any_masked(arg1))
        {
            arg1_masked_access_type arg1Access =
                 getArrayAccess<arg1_masked_access_type> (arg1);

            if (any_masked(arg2))
            {
                arg2_masked_access_type arg2Access =
                     getArrayAccess<arg2_masked_access_type> (arg2);

                if (any_masked(arg3))
                {
                    arg3_masked_access_type arg3Access =
                         getArrayAccess<arg3_masked_access_type> (arg3);

                    if (any_masked(arg4))
                    {
                        arg4_masked_access_type arg4Access =
                            getArrayAccess<arg4_masked_access_type> (arg4);

                        VectorizedOperation4<Op,result_access_type,
                                           arg1_masked_access_type,
                                           arg2_masked_access_type,
                                           arg3_masked_access_type,
                                           arg4_masked_access_type>
                            vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access);
                        dispatchTask(vop,len);
                    }
                    else
                    {
                        arg4_direct_access_type arg4Access =
                            getArrayAccess<arg4_direct_access_type> (arg4);

                        VectorizedOperation4<Op,result_access_type,
                                           arg1_masked_access_type,
                                           arg2_masked_access_type,
                                           arg3_masked_access_type,
                                           arg4_direct_access_type>
                            vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access);
                        dispatchTask(vop,len);
                    }
                }
                else
                {
                    arg3_direct_access_type arg3Access =
                         getArrayAccess<arg3_direct_access_type> (arg3);

                    if (any_masked(arg4))
                    {
                        arg4_masked_access_type arg4Access =
                            getArrayAccess<arg4_masked_access_type> (arg4);

                        VectorizedOperation4<Op,result_access_type,
                                           arg1_masked_access_type,
                                           arg2_masked_access_type,
                                           arg3_direct_access_type,
                                           arg4_masked_access_type>
                            vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access);
                    }
                    else
                    {
                        arg4_direct_access_type arg4Access =
                            getArrayAccess<arg4_direct_access_type> (arg4);

                        VectorizedOperation4<Op,result_access_type,
                                           arg1_masked_access_type,
                                           arg2_masked_access_type,
                                           arg3_direct_access_type,
                                           arg4_direct_access_type>
                            vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access);
                        dispatchTask(vop,len);
                    }
                }
            }
            else
            {
                arg2_direct_access_type arg2Access =
                     getArrayAccess<arg2_direct_access_type> (arg2);

                if (any_masked(arg3))
                {
                    arg3_masked_access_type arg3Access =
                         getArrayAccess<arg3_masked_access_type> (arg3);

                    if (any_masked(arg4))
                    {
                        arg4_masked_access_type arg4Access =
                            getArrayAccess<arg4_masked_access_type> (arg4);

                        VectorizedOperation4<Op,result_access_type,
                                           arg1_masked_access_type,
                                           arg2_direct_access_type,
                                           arg3_masked_access_type,
                                           arg4_masked_access_type>
                            vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access);
                        dispatchTask(vop,len);
                    }
                    else
                    {
                        arg4_direct_access_type arg4Access =
                            getArrayAccess<arg4_direct_access_type> (arg4);

                        VectorizedOperation4<Op,result_access_type,
                                           arg1_masked_access_type,
                                           arg2_direct_access_type,
                                           arg3_masked_access_type,
                                           arg4_direct_access_type>
                            vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access);
                        dispatchTask(vop,len);
                    }
                }
                else
                {
                    arg3_direct_access_type arg3Access =
                         getArrayAccess<arg3_direct_access_type> (arg3);

                    if (any_masked(arg4))
                    {
                        arg4_masked_access_type arg4Access =
                            getArrayAccess<arg4_masked_access_type> (arg4);

                        VectorizedOperation4<Op,result_access_type,
                                           arg1_masked_access_type,
                                           arg2_direct_access_type,
                                           arg3_direct_access_type,
                                           arg4_masked_access_type>
                            vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access);
                        dispatchTask(vop,len);
                    }
                    else
                    {
                        arg4_direct_access_type arg4Access =
                            getArrayAccess<arg4_direct_access_type> (arg4);

                        VectorizedOperation4<Op,result_access_type,
                                           arg1_masked_access_type,
                                           arg2_direct_access_type,
                                           arg3_direct_access_type,
                                           arg4_direct_access_type>
                            vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access);
                        dispatchTask(vop,len);
                    }
                }
            }
        }
        else
        {
            arg1_direct_access_type arg1Access =
                 getArrayAccess<arg1_direct_access_type> (arg1);

            if (any_masked(arg2))
            {
                arg2_masked_access_type arg2Access =
                     getArrayAccess<arg2_masked_access_type> (arg2);

                if (any_masked(arg3))
                {
                    arg3_masked_access_type arg3Access =
                         getArrayAccess<arg3_masked_access_type> (arg3);

                    if (any_masked(arg4))
                    {
                        arg4_masked_access_type arg4Access =
                            getArrayAccess<arg4_masked_access_type> (arg4);

                        VectorizedOperation4<Op,result_access_type,
                                           arg1_direct_access_type,
                                           arg2_masked_access_type,
                                           arg3_masked_access_type,
                                           arg4_masked_access_type>
                            vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access);
                        dispatchTask(vop,len);
                    }
                    else
                    {
                        arg4_direct_access_type arg4Access =
                            getArrayAccess<arg4_direct_access_type> (arg4);

                        VectorizedOperation4<Op,result_access_type,
                                           arg1_direct_access_type,
                                           arg2_masked_access_type,
                                           arg3_masked_access_type,
                                           arg4_direct_access_type>
                            vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access);
                        dispatchTask(vop,len);
                    }
                }
                else
                {
                    arg3_direct_access_type arg3Access =
                         getArrayAccess<arg3_direct_access_type> (arg3);

                    if (any_masked(arg4))
                    {
                        arg4_masked_access_type arg4Access =
                            getArrayAccess<arg4_masked_access_type> (arg4);

                        VectorizedOperation4<Op,result_access_type,
                                           arg1_direct_access_type,
                                           arg2_masked_access_type,
                                           arg3_direct_access_type,
                                           arg4_masked_access_type>
                            vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access);
                        dispatchTask(vop,len);
                    }
                    else
                    {
                        arg4_direct_access_type arg4Access =
                            getArrayAccess<arg4_direct_access_type> (arg4);

                        VectorizedOperation4<Op,result_access_type,
                                           arg1_direct_access_type,
                                           arg2_masked_access_type,
                                           arg3_direct_access_type,
                                           arg4_direct_access_type>
                            vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access);
                        dispatchTask(vop,len);
                    }
                }
            }
            else
            {
                arg2_direct_access_type arg2Access =
                     getArrayAccess<arg2_direct_access_type> (arg2);

                if (any_masked(arg3))
                {
                    arg3_masked_access_type arg3Access =
                         getArrayAccess<arg3_masked_access_type> (arg3);

                    if (any_masked(arg4))
                    {
                        arg4_masked_access_type arg4Access =
                            getArrayAccess<arg4_masked_access_type> (arg4);

                        VectorizedOperation4<Op,result_access_type,
                                           arg1_direct_access_type,
                                           arg2_direct_access_type,
                                           arg3_masked_access_type,
                                           arg4_masked_access_type>
                            vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access);
                        dispatchTask(vop,len);
                    }
                    else
                    {
                        arg4_direct_access_type arg4Access =
                            getArrayAccess<arg4_direct_access_type> (arg4);

                        VectorizedOperation4<Op,result_access_type,
                                           arg1_direct_access_type,
                                           arg2_direct_access_type,
                                           arg3_masked_access_type,
                                           arg4_direct_access_type>
                            vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access);
                        dispatchTask(vop,len);
                    }
                }
                else
                {
                    arg3_direct_access_type arg3Access =
                         getArrayAccess<arg3_direct_access_type> (arg3);

                    if (any_masked(arg4))
                    {
                        arg4_masked_access_type arg4Access =
                            getArrayAccess<arg4_masked_access_type> (arg4);

                        VectorizedOperation4<Op,result_access_type,
                                           arg1_direct_access_type,
                                           arg2_direct_access_type,
                                           arg3_direct_access_type,
                                           arg4_masked_access_type>
                            vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access);
                        dispatchTask(vop,len);
                    }
                    else
                    {
                        arg4_direct_access_type arg4Access =
                            getArrayAccess<arg4_direct_access_type> (arg4);

                        VectorizedOperation4<Op,result_access_type,
                                           arg1_direct_access_type,
                                           arg2_direct_access_type,
                                           arg3_direct_access_type,
                                           arg4_direct_access_type>
                            vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access);
                        dispatchTask(vop,len);
                    }
                }
            }
        }

        PY_IMATH_RETURN_PYTHON;
        return retval;
    }

    static std::string
    format_arguments(const boost::python::detail::keywords<4> &args)
    {
        // TODO: add types here
        return std::string("(")+args.elements[0].name+","+args.elements[1].name+","+args.elements[2].name+","+args.elements[3].name+") - ";
    }
};

template <class Op, class Vectorize, class Func>
struct VectorizedFunction5 {
    BOOST_STATIC_ASSERT((size<Vectorize>::value == function_traits<Func>::arity));

    typedef function_traits<Func> traits;
    typedef typename fold<Vectorize,false_,or_<_,_> >::type any_vectorized;

    typedef typename result_access_type<typename traits::result_type,
                                        any_vectorized>::type result_type;
    typedef typename result_access_type<typename traits::result_type,
                                        any_vectorized>::direct result_access_type;
    // Result array is created here 'from scratch', so is always 'direct' access.

    typedef typename argument_access_type<typename traits::arg1_type,
                              typename at<Vectorize,long_<0> >::type>::type arg1_type;
    typedef typename argument_access_type<typename traits::arg1_type,
                              typename at<Vectorize,long_<0> >::type>::direct arg1_direct_access_type;
    typedef typename argument_access_type<typename traits::arg1_type,
                              typename at<Vectorize,long_<0> >::type>::masked arg1_masked_access_type;

    typedef typename argument_access_type<typename traits::arg2_type,
                              typename at<Vectorize,long_<1> >::type>::type arg2_type;
    typedef typename argument_access_type<typename traits::arg2_type,
                              typename at<Vectorize,long_<1> >::type>::direct arg2_direct_access_type;
    typedef typename argument_access_type<typename traits::arg2_type,
                              typename at<Vectorize,long_<1> >::type>::masked arg2_masked_access_type;

    typedef typename argument_access_type<typename traits::arg3_type,
                              typename at<Vectorize,long_<2> >::type>::type arg3_type;
    typedef typename argument_access_type<typename traits::arg3_type,
                              typename at<Vectorize,long_<2> >::type>::direct arg3_direct_access_type;
    typedef typename argument_access_type<typename traits::arg3_type,
                              typename at<Vectorize,long_<2> >::type>::masked arg3_masked_access_type;

    typedef typename argument_access_type<typename traits::arg4_type,
                              typename at<Vectorize,long_<3> >::type>::type arg4_type;
    typedef typename argument_access_type<typename traits::arg4_type,
                              typename at<Vectorize,long_<3> >::type>::direct arg4_direct_access_type;
    typedef typename argument_access_type<typename traits::arg4_type,
                              typename at<Vectorize,long_<3> >::type>::masked arg4_masked_access_type;

    typedef typename argument_access_type<typename traits::arg5_type,
                              typename at<Vectorize,long_<4> >::type>::type arg5_type;
    typedef typename argument_access_type<typename traits::arg5_type,
                              typename at<Vectorize,long_<4> >::type>::direct arg5_direct_access_type;
    typedef typename argument_access_type<typename traits::arg5_type,
                              typename at<Vectorize,long_<4> >::type>::masked arg5_masked_access_type;

    static result_type
    apply(arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, arg5_type arg5)
    {
        PY_IMATH_LEAVE_PYTHON;
        size_t len = measure_arguments(arg1,arg2,arg3,arg4,arg5);
        op_precompute<Op>::apply(len);
        result_type retval = create_uninitalized_return_value<result_type>::apply(len);

        result_access_type resultAccess = getArrayAccess<result_access_type> (retval);

        if (any_masked(arg1))
        {
            arg1_masked_access_type arg1Access =
                 getArrayAccess<arg1_masked_access_type> (arg1);

            if (any_masked(arg2))
            {
                arg2_masked_access_type arg2Access =
                     getArrayAccess<arg2_masked_access_type> (arg2);

                if (any_masked(arg3))
                {
                    arg3_masked_access_type arg3Access =
                         getArrayAccess<arg3_masked_access_type> (arg3);

                    if (any_masked(arg4))
                    {
                        arg4_masked_access_type arg4Access =
                            getArrayAccess<arg4_masked_access_type> (arg4);

                        if (any_masked(arg5))
                        {
                            arg5_masked_access_type arg5Access =
                                getArrayAccess<arg5_masked_access_type> (arg5);

                            VectorizedOperation5<Op,result_access_type,
                                               arg1_masked_access_type,
                                               arg2_masked_access_type,
                                               arg3_masked_access_type,
                                               arg4_masked_access_type,
                                               arg5_masked_access_type>
                                vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
                            dispatchTask(vop,len);
                        }
                        else
                        {
                            arg5_direct_access_type arg5Access =
                                getArrayAccess<arg5_direct_access_type> (arg5);

                            VectorizedOperation5<Op,result_access_type,
                                               arg1_masked_access_type,
                                               arg2_masked_access_type,
                                               arg3_masked_access_type,
                                               arg4_masked_access_type,
                                               arg5_direct_access_type>
                                vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
                            dispatchTask(vop,len);
                        }
                    }
                    else
                    {
                        arg4_direct_access_type arg4Access =
                            getArrayAccess<arg4_direct_access_type> (arg4);

                        if (any_masked(arg5))
                        {
                            arg5_masked_access_type arg5Access =
                                getArrayAccess<arg5_masked_access_type> (arg5);

                            VectorizedOperation5<Op,result_access_type,
                                               arg1_masked_access_type,
                                               arg2_masked_access_type,
                                               arg3_masked_access_type,
                                               arg4_direct_access_type,
                                               arg5_masked_access_type>
                                vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
                            dispatchTask(vop,len);
                        }
                        else
                        {
                            arg5_direct_access_type arg5Access =
                                getArrayAccess<arg5_direct_access_type> (arg5);

                            VectorizedOperation5<Op,result_access_type,
                                               arg1_masked_access_type,
                                               arg2_masked_access_type,
                                               arg3_masked_access_type,
                                               arg4_direct_access_type,
                                               arg5_direct_access_type>
                                vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
                            dispatchTask(vop,len);
                        }
                    }
                }
                else
                {
                    arg3_direct_access_type arg3Access =
                         getArrayAccess<arg3_direct_access_type> (arg3);

                    if (any_masked(arg4))
                    {
                        arg4_masked_access_type arg4Access =
                            getArrayAccess<arg4_masked_access_type> (arg4);

                        if (any_masked(arg5))
                        {
                            arg5_masked_access_type arg5Access =
                                getArrayAccess<arg5_masked_access_type> (arg5);

                            VectorizedOperation5<Op,result_access_type,
                                               arg1_masked_access_type,
                                               arg2_masked_access_type,
                                               arg3_direct_access_type,
                                               arg4_masked_access_type,
                                               arg5_masked_access_type>
                                vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
                            dispatchTask(vop,len);
                        }
                        else
                        {
                            arg5_direct_access_type arg5Access =
                                getArrayAccess<arg5_direct_access_type> (arg5);

                            VectorizedOperation5<Op,result_access_type,
                                               arg1_masked_access_type,
                                               arg2_masked_access_type,
                                               arg3_direct_access_type,
                                               arg4_masked_access_type,
                                               arg5_direct_access_type>
                                vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
                            dispatchTask(vop,len);
                        }
                    }
                    else
                    {
                        arg4_direct_access_type arg4Access =
                            getArrayAccess<arg4_direct_access_type> (arg4);

                        if (any_masked(arg5))
                        {
                            arg5_masked_access_type arg5Access =
                                getArrayAccess<arg5_masked_access_type> (arg5);

                            VectorizedOperation5<Op,result_access_type,
                                               arg1_masked_access_type,
                                               arg2_masked_access_type,
                                               arg3_direct_access_type,
                                               arg4_direct_access_type,
                                               arg5_masked_access_type>
                                vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
                            dispatchTask(vop,len);
                        }
                        else
                        {
                            arg5_direct_access_type arg5Access =
                                getArrayAccess<arg5_direct_access_type> (arg5);

                            VectorizedOperation5<Op,result_access_type,
                                               arg1_masked_access_type,
                                               arg2_masked_access_type,
                                               arg3_direct_access_type,
                                               arg4_direct_access_type,
                                               arg5_direct_access_type>
                                vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
                            dispatchTask(vop,len);
                        }
                    }
                }
            }
            else
            {
                arg2_direct_access_type arg2Access =
                     getArrayAccess<arg2_direct_access_type> (arg2);

                if (any_masked(arg3))
                {
                    arg3_masked_access_type arg3Access =
                         getArrayAccess<arg3_masked_access_type> (arg3);

                    if (any_masked(arg4))
                    {
                        arg4_masked_access_type arg4Access =
                            getArrayAccess<arg4_masked_access_type> (arg4);

                        if (any_masked(arg5))
                        {
                            arg5_masked_access_type arg5Access =
                                getArrayAccess<arg5_masked_access_type> (arg5);

                            VectorizedOperation5<Op,result_access_type,
                                               arg1_masked_access_type,
                                               arg2_direct_access_type,
                                               arg3_masked_access_type,
                                               arg4_masked_access_type,
                                               arg5_masked_access_type>
                                vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
                            dispatchTask(vop,len);
                        }
                        else
                        {
                            arg5_direct_access_type arg5Access =
                                getArrayAccess<arg5_direct_access_type> (arg5);

                            VectorizedOperation5<Op,result_access_type,
                                               arg1_masked_access_type,
                                               arg2_direct_access_type,
                                               arg3_masked_access_type,
                                               arg4_masked_access_type,
                                               arg5_direct_access_type>
                                vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
                            dispatchTask(vop,len);
                        }
                    }
                    else
                    {
                        arg4_direct_access_type arg4Access =
                            getArrayAccess<arg4_direct_access_type> (arg4);

                        if (any_masked(arg5))
                        {
                            arg5_masked_access_type arg5Access =
                                getArrayAccess<arg5_masked_access_type> (arg5);

                            VectorizedOperation5<Op,result_access_type,
                                               arg1_masked_access_type,
                                               arg2_direct_access_type,
                                               arg3_masked_access_type,
                                               arg4_direct_access_type,
                                               arg5_masked_access_type>
                                vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
                            dispatchTask(vop,len);
                        }
                        else
                        {
                            arg5_direct_access_type arg5Access =
                                getArrayAccess<arg5_direct_access_type> (arg5);

                            VectorizedOperation5<Op,result_access_type,
                                               arg1_masked_access_type,
                                               arg2_direct_access_type,
                                               arg3_masked_access_type,
                                               arg4_direct_access_type,
                                               arg5_direct_access_type>
                                vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
                            dispatchTask(vop,len);
                        }
                    }
                }
                else
                {
                    arg3_direct_access_type arg3Access =
                         getArrayAccess<arg3_direct_access_type> (arg3);

                    if (any_masked(arg4))
                    {
                        arg4_masked_access_type arg4Access =
                            getArrayAccess<arg4_masked_access_type> (arg4);

                        if (any_masked(arg5))
                        {
                            arg5_masked_access_type arg5Access =
                                getArrayAccess<arg5_masked_access_type> (arg5);

                            VectorizedOperation5<Op,result_access_type,
                                               arg1_masked_access_type,
                                               arg2_direct_access_type,
                                               arg3_direct_access_type,
                                               arg4_masked_access_type,
                                               arg5_masked_access_type>
                                vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
                            dispatchTask(vop,len);
                        }
                        else
                        {
                            arg5_direct_access_type arg5Access =
                                getArrayAccess<arg5_direct_access_type> (arg5);

                            VectorizedOperation5<Op,result_access_type,
                                               arg1_masked_access_type,
                                               arg2_direct_access_type,
                                               arg3_direct_access_type,
                                               arg4_masked_access_type,
                                               arg5_direct_access_type>
                                vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
                            dispatchTask(vop,len);
                        }
                    }
                    else
                    {
                        arg4_direct_access_type arg4Access =
                            getArrayAccess<arg4_direct_access_type> (arg4);

                        if (any_masked(arg5))
                        {
                            arg5_masked_access_type arg5Access =
                                getArrayAccess<arg5_masked_access_type> (arg5);

                            VectorizedOperation5<Op,result_access_type,
                                               arg1_masked_access_type,
                                               arg2_direct_access_type,
                                               arg3_direct_access_type,
                                               arg4_direct_access_type,
                                               arg5_masked_access_type>
                                vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
                            dispatchTask(vop,len);
                        }
                        else
                        {
                            arg5_direct_access_type arg5Access =
                                getArrayAccess<arg5_direct_access_type> (arg5);

                            VectorizedOperation5<Op,result_access_type,
                                               arg1_masked_access_type,
                                               arg2_direct_access_type,
                                               arg3_direct_access_type,
                                               arg4_direct_access_type,
                                               arg5_direct_access_type>
                                vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
                            dispatchTask(vop,len);
                        }
                    }
                }
            }
        }
        else
        {
            arg1_direct_access_type arg1Access =
                 getArrayAccess<arg1_direct_access_type> (arg1);

            if (any_masked(arg2))
            {
                arg2_masked_access_type arg2Access =
                     getArrayAccess<arg2_masked_access_type> (arg2);

                if (any_masked(arg3))
                {
                    arg3_masked_access_type arg3Access =
                         getArrayAccess<arg3_masked_access_type> (arg3);

                    if (any_masked(arg4))
                    {
                        arg4_masked_access_type arg4Access =
                            getArrayAccess<arg4_masked_access_type> (arg4);

                        if (any_masked(arg5))
                        {
                            arg5_masked_access_type arg5Access =
                                getArrayAccess<arg5_masked_access_type> (arg5);

                            VectorizedOperation5<Op,result_access_type,
                                               arg1_direct_access_type,
                                               arg2_masked_access_type,
                                               arg3_masked_access_type,
                                               arg4_masked_access_type,
                                               arg5_masked_access_type>
                                vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
                            dispatchTask(vop,len);
                        }
                        else
                        {
                            arg5_direct_access_type arg5Access =
                                getArrayAccess<arg5_direct_access_type> (arg5);

                            VectorizedOperation5<Op,result_access_type,
                                               arg1_direct_access_type,
                                               arg2_masked_access_type,
                                               arg3_masked_access_type,
                                               arg4_masked_access_type,
                                               arg5_direct_access_type>
                                vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
                            dispatchTask(vop,len);
                        }
                    }
                    else
                    {
                        arg4_direct_access_type arg4Access =
                            getArrayAccess<arg4_direct_access_type> (arg4);

                        if (any_masked(arg5))
                        {
                            arg5_masked_access_type arg5Access =
                                getArrayAccess<arg5_masked_access_type> (arg5);

                            VectorizedOperation5<Op,result_access_type,
                                               arg1_direct_access_type,
                                               arg2_masked_access_type,
                                               arg3_masked_access_type,
                                               arg4_direct_access_type,
                                               arg5_masked_access_type>
                                vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
                            dispatchTask(vop,len);
                        }
                        else
                        {
                            arg5_direct_access_type arg5Access =
                                getArrayAccess<arg5_direct_access_type> (arg5);

                            VectorizedOperation5<Op,result_access_type,
                                               arg1_direct_access_type,
                                               arg2_masked_access_type,
                                               arg3_masked_access_type,
                                               arg4_direct_access_type,
                                               arg5_direct_access_type>
                                vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
                            dispatchTask(vop,len);
                        }
                    }
                }
                else
                {
                    arg3_direct_access_type arg3Access =
                         getArrayAccess<arg3_direct_access_type> (arg3);

                    if (any_masked(arg4))
                    {
                        arg4_masked_access_type arg4Access =
                            getArrayAccess<arg4_masked_access_type> (arg4);

                        if (any_masked(arg5))
                        {
                            arg5_masked_access_type arg5Access =
                                getArrayAccess<arg5_masked_access_type> (arg5);

                            VectorizedOperation5<Op,result_access_type,
                                               arg1_direct_access_type,
                                               arg2_masked_access_type,
                                               arg3_direct_access_type,
                                               arg4_masked_access_type,
                                               arg5_masked_access_type>
                                vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
                            dispatchTask(vop,len);
                        }
                        else
                        {
                            arg5_direct_access_type arg5Access =
                                getArrayAccess<arg5_direct_access_type> (arg5);

                            VectorizedOperation5<Op,result_access_type,
                                               arg1_direct_access_type,
                                               arg2_masked_access_type,
                                               arg3_direct_access_type,
                                               arg4_masked_access_type,
                                               arg5_direct_access_type>
                                vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
                            dispatchTask(vop,len);
                        }
                    }
                    else
                    {
                        arg4_direct_access_type arg4Access =
                            getArrayAccess<arg4_direct_access_type> (arg4);

                        if (any_masked(arg5))
                        {
                            arg5_masked_access_type arg5Access =
                                getArrayAccess<arg5_masked_access_type> (arg5);

                            VectorizedOperation5<Op,result_access_type,
                                               arg1_direct_access_type,
                                               arg2_masked_access_type,
                                               arg3_direct_access_type,
                                               arg4_direct_access_type,
                                               arg5_masked_access_type>
                                vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
                            dispatchTask(vop,len);
                        }
                        else
                        {
                            arg5_direct_access_type arg5Access =
                                getArrayAccess<arg5_direct_access_type> (arg5);

                            VectorizedOperation5<Op,result_access_type,
                                               arg1_direct_access_type,
                                               arg2_masked_access_type,
                                               arg3_direct_access_type,
                                               arg4_direct_access_type,
                                               arg5_direct_access_type>
                                vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
                            dispatchTask(vop,len);
                        }
                    }
                }
            }
            else
            {
                arg2_direct_access_type arg2Access =
                     getArrayAccess<arg2_direct_access_type> (arg2);

                if (any_masked(arg3))
                {
                    arg3_masked_access_type arg3Access =
                         getArrayAccess<arg3_masked_access_type> (arg3);

                    if (any_masked(arg4))
                    {
                        arg4_masked_access_type arg4Access =
                            getArrayAccess<arg4_masked_access_type> (arg4);

                        if (any_masked(arg5))
                        {
                            arg5_masked_access_type arg5Access =
                                getArrayAccess<arg5_masked_access_type> (arg5);

                            VectorizedOperation5<Op,result_access_type,
                                               arg1_direct_access_type,
                                               arg2_direct_access_type,
                                               arg3_masked_access_type,
                                               arg4_masked_access_type,
                                               arg5_masked_access_type>
                                vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
                            dispatchTask(vop,len);
                        }
                        else
                        {
                            arg5_direct_access_type arg5Access =
                                getArrayAccess<arg5_direct_access_type> (arg5);

                            VectorizedOperation5<Op,result_access_type,
                                               arg1_direct_access_type,
                                               arg2_direct_access_type,
                                               arg3_masked_access_type,
                                               arg4_masked_access_type,
                                               arg5_direct_access_type>
                                vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
                            dispatchTask(vop,len);
                        }
                    }
                    else
                    {
                        arg4_direct_access_type arg4Access =
                            getArrayAccess<arg4_direct_access_type> (arg4);

                        if (any_masked(arg5))
                        {
                            arg5_masked_access_type arg5Access =
                                getArrayAccess<arg5_masked_access_type> (arg5);

                            VectorizedOperation5<Op,result_access_type,
                                               arg1_direct_access_type,
                                               arg2_direct_access_type,
                                               arg3_masked_access_type,
                                               arg4_direct_access_type,
                                               arg5_masked_access_type>
                                vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
                            dispatchTask(vop,len);
                        }
                        else
                        {
                            arg5_direct_access_type arg5Access =
                                getArrayAccess<arg5_direct_access_type> (arg5);

                            VectorizedOperation5<Op,result_access_type,
                                               arg1_direct_access_type,
                                               arg2_direct_access_type,
                                               arg3_masked_access_type,
                                               arg4_direct_access_type,
                                               arg5_direct_access_type>
                                vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
                            dispatchTask(vop,len);
                        }
                    }
                }
                else
                {
                    arg3_direct_access_type arg3Access =
                         getArrayAccess<arg3_direct_access_type> (arg3);

                    if (any_masked(arg4))
                    {
                        arg4_masked_access_type arg4Access =
                            getArrayAccess<arg4_masked_access_type> (arg4);

                        if (any_masked(arg5))
                        {
                            arg5_masked_access_type arg5Access =
                                getArrayAccess<arg5_masked_access_type> (arg5);

                            VectorizedOperation5<Op,result_access_type,
                                               arg1_direct_access_type,
                                               arg2_direct_access_type,
                                               arg3_direct_access_type,
                                               arg4_masked_access_type,
                                               arg5_masked_access_type>
                                vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
                            dispatchTask(vop,len);
                        }
                        else
                        {
                            arg5_direct_access_type arg5Access =
                                getArrayAccess<arg5_direct_access_type> (arg5);

                            VectorizedOperation5<Op,result_access_type,
                                               arg1_direct_access_type,
                                               arg2_direct_access_type,
                                               arg3_direct_access_type,
                                               arg4_masked_access_type,
                                               arg5_direct_access_type>
                                vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
                            dispatchTask(vop,len);
                        }
                    }
                    else
                    {
                        arg4_direct_access_type arg4Access =
                            getArrayAccess<arg4_direct_access_type> (arg4);

                        if (any_masked(arg5))
                        {
                            arg5_masked_access_type arg5Access =
                                getArrayAccess<arg5_masked_access_type> (arg5);

                            VectorizedOperation5<Op,result_access_type,
                                               arg1_direct_access_type,
                                               arg2_direct_access_type,
                                               arg3_direct_access_type,
                                               arg4_direct_access_type,
                                               arg5_masked_access_type>
                                vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
                            dispatchTask(vop,len);
                        }
                        else
                        {
                            arg5_direct_access_type arg5Access =
                                getArrayAccess<arg5_direct_access_type> (arg5);

                            VectorizedOperation5<Op,result_access_type,
                                               arg1_direct_access_type,
                                               arg2_direct_access_type,
                                               arg3_direct_access_type,
                                               arg4_direct_access_type,
                                               arg5_direct_access_type>
                                vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
                            dispatchTask(vop,len);
                        }
                    }
                }
            }
        }

        PY_IMATH_RETURN_PYTHON;
        return retval;
    }

    static std::string
    format_arguments(const boost::python::detail::keywords<5> &args)
    {
        // TODO: add types here
        return std::string("(")+args.elements[0].name+","+args.elements[1].name+","+args.elements[2].name+","+args.elements[3].name+","+args.elements[4].name+") - ";
    }
};

template <class Op, class Func, class Keywords>
struct function_binding
{
    std::string _name, _doc;
    const Keywords &_args;


    function_binding(const std::string &name, const std::string &doc,const Keywords &args)
        : _name(name), _doc(doc), _args(args)
    {}

    template <class Vectorize>
    void operator()(Vectorize) const
    {
        typedef typename at<vector<
             int,  // unused, arity 0
             VectorizedFunction1<Op,Vectorize,Func>,
             VectorizedFunction2<Op,Vectorize,Func>,
             VectorizedFunction3<Op,Vectorize,Func>,
             VectorizedFunction4<Op,Vectorize,Func>,
             VectorizedFunction5<Op,Vectorize,Func>
            >,
            long_<function_traits<Func>::arity> >::type vectorized_function_type;
        std::string doc = _name + vectorized_function_type::format_arguments(_args) + _doc;
        boost::python::def(_name.c_str(),&vectorized_function_type::apply,doc.c_str(),_args);
    }
};

template <class Op,class Func,class Keywords>
function_binding<Op,Func,Keywords>
build_function_binding(Func *func,const std::string &name,const std::string &doc,const Keywords &args)
{
    return function_binding<Op,Func,Keywords>(name,doc,args);
}

template <class Op,class Vectorizable,class Keywords>
struct generate_bindings_struct
{
    //BOOST_STATIC_ASSERT(size<Vectorizable>::value == function_traits<Op::apply>::arity);
    static void apply(const std::string &name,const std::string &doc,const Keywords &args) {
        for_each<typename allowable_vectorizations<Vectorizable>::type>(build_function_binding<Op>(Op::apply,name,doc,args));
    }
};


template <class Op, class access_type>
struct VectorizedVoidOperation0 : public Task
{
    access_type access;

    VectorizedVoidOperation0 (access_type a) : access(a) {}

    void execute (size_t start, size_t end)
    {
        for (size_t i = start; i < end; ++i)
        {
            Op::apply (access[i]);
        }
    }
};

template <class Op, class access_type, class arg1_access_type>
struct VectorizedVoidOperation1 : public Task
{
    access_type      access;
    arg1_access_type arg1;

    VectorizedVoidOperation1(access_type a, arg1_access_type a1) : access(a), arg1(a1) {}

    void execute(size_t start, size_t end)
    {
        for (size_t i = start; i < end; ++i)
        {
            Op::apply (access[i], arg1[i]);
        }
    }
};

template <class Op, class access_type, class arg1_access_type, class array_type>
struct VectorizedMaskedVoidOperation1 : public Task
{
    access_type      access;
    arg1_access_type arg1;
    array_type       array;

    VectorizedMaskedVoidOperation1(access_type a, arg1_access_type a1, array_type arr)
        : access(a), arg1(a1), array(arr) {}

    void execute(size_t start, size_t end)
    {
        for (size_t i = start; i < end; ++i)
        {
            const size_t ri = array.raw_ptr_index(i);
            Op::apply (access[i], arg1[ri]);
        }
    }
};

template <class Op, class access_type, class arg1_access_type, class arg2_access_type>
struct VectorizedVoidOperation2 : public Task
{
    access_type      access;
    arg1_access_type arg1;
    arg2_access_type arg2;

    VectorizedVoidOperation2(access_type a, arg1_access_type a1, arg2_access_type a2)
        : access(a), arg1(a1), arg2(a2) {}

    void execute(size_t start, size_t end)
    {
        for (size_t i = start; i < end; ++i)
        {
            Op::apply (access[i], arg1[i], arg2[i]);
        }
    }
};


template <class Op, class Vectorize, class Func>
struct VectorizedVoidMemberFunction0 {
    BOOST_STATIC_ASSERT((size<Vectorize>::value+1 == function_traits<Func>::arity));

    typedef function_traits<Func> traits;

    typedef typename access_type<typename traits::arg1_type>::reference_type reference_type;
    typedef typename access_type<typename traits::arg1_type>::direct direct_access_type;
    typedef typename access_type<typename traits::arg1_type>::masked masked_access_type;

    static reference_type
    apply(reference_type array)
    {
        PY_IMATH_LEAVE_PYTHON;
        size_t len = measure_arguments(array);
        op_precompute<Op>::apply(len);

        if (any_masked(array))
        {
            masked_access_type access (array);
            VectorizedVoidOperation0<Op,masked_access_type> vop (access);
            dispatchTask(vop,len);
        }
        else
        {
            direct_access_type access (array);
            VectorizedVoidOperation0<Op,direct_access_type> vop (access);
            dispatchTask(vop,len);
        }

        PY_IMATH_RETURN_PYTHON;
        return array;
    }
};

template <class Op, class Vectorize, class Func>
struct VectorizedVoidMemberFunction1 {
    BOOST_STATIC_ASSERT((size<Vectorize>::value+1 == function_traits<Func>::arity));

    typedef function_traits<Func> traits;

    typedef typename access_type<typename traits::arg1_type>::reference_type reference_type;
    typedef typename access_type<typename traits::arg1_type>::direct direct_access_type;
    typedef typename access_type<typename traits::arg1_type>::masked masked_access_type;

    typedef typename argument_access_type<typename traits::arg2_type,
                              typename at<Vectorize,long_<0> >::type>::type arg1_type;
    typedef typename argument_access_type<typename traits::arg2_type,
                              typename at<Vectorize,long_<0> >::type>::direct arg1_direct_access_type;
    typedef typename argument_access_type<typename traits::arg2_type,
                              typename at<Vectorize,long_<0> >::type>::masked arg1_masked_access_type;

    static reference_type
    apply(reference_type array, arg1_type arg1)
    {
        PY_IMATH_LEAVE_PYTHON;
        size_t len = measure_arguments(array,arg1);
        op_precompute<Op>::apply(len);

        if (any_masked(array))
        {
            masked_access_type arrayAccess (array);

            if (any_masked(arg1))
            {
                arg1_masked_access_type argAccess =
                     getArrayAccess<arg1_masked_access_type> (arg1);

                VectorizedVoidOperation1<Op,masked_access_type,arg1_masked_access_type>
                    vop (arrayAccess, argAccess);
                dispatchTask(vop,len);
            }
            else
            {
                arg1_direct_access_type argAccess =
                     getArrayAccess<arg1_direct_access_type> (arg1);

                VectorizedVoidOperation1<Op,masked_access_type,arg1_direct_access_type>
                    vop (arrayAccess, argAccess);
                dispatchTask(vop,len);
            }
        }
        else
        {
            direct_access_type arrayAccess (array);

            if (any_masked(arg1))
            {
                arg1_masked_access_type argAccess =
                     getArrayAccess<arg1_masked_access_type> (arg1);

                VectorizedVoidOperation1<Op,direct_access_type,arg1_masked_access_type>
                    vop (arrayAccess, argAccess);
                dispatchTask(vop,len);
            }
            else
            {
                arg1_direct_access_type argAccess =
                     getArrayAccess<arg1_direct_access_type> (arg1);

                VectorizedVoidOperation1<Op,direct_access_type,arg1_direct_access_type>
                    vop (arrayAccess, argAccess);
                dispatchTask(vop,len);
            }
        }

        PY_IMATH_RETURN_PYTHON;
        return array;
    }

    static std::string
    format_arguments(const boost::python::detail::keywords<1> &args)
    {
        // TODO: add types here
        return std::string("(")+args.elements[0].name+") - ";
    }
};

//
// special class to handle single argument void memberfunctions, such as those
// used for the inplace operators like +=, -=, etc.  In this case we allow additional
// compatibilty between a masked class and an unmasked right hand side, using the
// mask to select results.
//
template <class Op, class Func>
struct VectorizedVoidMaskableMemberFunction1 {
    BOOST_STATIC_ASSERT((2 == function_traits<Func>::arity));

    typedef function_traits<Func> traits;

    typedef typename access_type<typename traits::arg1_type>::reference_type reference_type;
    typedef typename access_type<typename traits::arg1_type>::direct direct_access_type;
    typedef typename access_type<typename traits::arg1_type>::masked masked_access_type;

    typedef typename argument_access_type<typename traits::arg2_type,
                                                   boost::mpl::true_>::type arg1_type;
    typedef typename argument_access_type<typename traits::arg2_type,
                                                   boost::mpl::true_>::direct arg1_direct_access_type;
    typedef typename argument_access_type<typename traits::arg2_type,
                                                   boost::mpl::true_>::masked arg1_masked_access_type;

    static reference_type
    apply(reference_type array, arg1_type arg1)
    {
        PY_IMATH_LEAVE_PYTHON;
        size_t len = array.match_dimension(arg1, false);
        op_precompute<Op>::apply(len);

        if (array.isMaskedReference() && (size_t) arg1.len() == array.unmaskedLength())
        {
            // class is masked, and the unmasked length matches the right hand side

            masked_access_type arrayAccess (array);

            if (any_masked(arg1))
            {
                arg1_masked_access_type argAccess =
                     getArrayAccess<arg1_masked_access_type> (arg1);

                VectorizedMaskedVoidOperation1<Op,masked_access_type,
                                             arg1_masked_access_type,
                                                      reference_type>
                    vop (arrayAccess, argAccess, array);
                dispatchTask(vop,len);
            }
            else
            {
                arg1_direct_access_type argAccess =
                     getArrayAccess<arg1_direct_access_type> (arg1);

                VectorizedMaskedVoidOperation1<Op,masked_access_type,
                                             arg1_direct_access_type,
                                                      reference_type>
                    vop (arrayAccess, argAccess, array);
                dispatchTask(vop,len);
            }
        }
        else
        {
            // the two arrays match length (masked or otherwise), use the standard path.

            if (any_masked(array))
            {
                masked_access_type arrayAccess (array);

                if (any_masked(arg1))
                {
                    arg1_masked_access_type argAccess =
                         getArrayAccess<arg1_masked_access_type> (arg1);

                    VectorizedVoidOperation1<Op,masked_access_type,arg1_masked_access_type>
                        vop (arrayAccess, argAccess);
                    dispatchTask(vop,len);
                }
                else
                {
                    arg1_direct_access_type argAccess =
                         getArrayAccess<arg1_direct_access_type> (arg1);

                    VectorizedVoidOperation1<Op,masked_access_type,arg1_direct_access_type>
                        vop (arrayAccess, argAccess);
                    dispatchTask(vop,len);
                }
            }
            else
            {
                direct_access_type arrayAccess (array);

                if (any_masked(arg1))
                {
                    arg1_masked_access_type argAccess =
                         getArrayAccess<arg1_masked_access_type> (arg1);

                    VectorizedVoidOperation1<Op,direct_access_type,arg1_masked_access_type>
                        vop (arrayAccess, argAccess);
                    dispatchTask(vop,len);
                }
                else
                {
                    arg1_direct_access_type argAccess =
                         getArrayAccess<arg1_direct_access_type> (arg1);

                    VectorizedVoidOperation1<Op,direct_access_type,arg1_direct_access_type>
                        vop (arrayAccess, argAccess);
                    dispatchTask(vop,len);
                }
            }
        }
           
        PY_IMATH_RETURN_PYTHON;
        return array;
    }

    static std::string
    format_arguments(const boost::python::detail::keywords<1> &args)
    {
        // TODO: add types here
        return std::string("(")+args.elements[0].name+") - ";
    }
};

template <class Op, class Vectorize, class Func>
struct VectorizedVoidMemberFunction2 {
    BOOST_STATIC_ASSERT((size<Vectorize>::value+1 == function_traits<Func>::arity));

    typedef function_traits<Func> traits;

    typedef typename access_type<typename traits::arg1_type>::reference_type reference_type;
    typedef typename access_type<typename traits::arg1_type>::direct direct_access_type;
    typedef typename access_type<typename traits::arg1_type>::masked masked_access_type;

    typedef typename argument_access_type<typename traits::arg2_type,
                              typename at<Vectorize,long_<0> >::type>::type arg1_type;
    typedef typename argument_access_type<typename traits::arg2_type,
                              typename at<Vectorize,long_<0> >::type>::direct arg1_direct_access_type;
    typedef typename argument_access_type<typename traits::arg2_type,
                              typename at<Vectorize,long_<0> >::type>::masked arg1_masked_access_type;

    typedef typename argument_access_type<typename traits::arg3_type,
                              typename at<Vectorize,long_<1> >::type>::type arg2_type;
    typedef typename argument_access_type<typename traits::arg3_type,
                              typename at<Vectorize,long_<1> >::type>::direct arg2_direct_access_type;
    typedef typename argument_access_type<typename traits::arg3_type,
                              typename at<Vectorize,long_<1> >::type>::masked arg2_masked_access_type;

    static reference_type
    apply(reference_type array, arg1_type arg1, arg2_type arg2)
    {
        PY_IMATH_LEAVE_PYTHON;
        size_t len = measure_arguments(array,arg1,arg2);
        op_precompute<Op>::apply(len);

        if (any_masked(array))
        {
            masked_access_type arrayAccess (array);

            if (any_masked(arg1))
            {
                arg1_masked_access_type arg1Access =
                     getArrayAccess<arg1_masked_access_type> (arg1);

                if (any_masked(arg2))
                {
                    arg2_masked_access_type arg2Access =
                         getArrayAccess<arg2_masked_access_type> (arg2);

                    VectorizedVoidOperation2<Op,masked_access_type,
                                           arg1_masked_access_type,
                                           arg2_masked_access_type>
                          vop (arrayAccess, arg1Access, arg2Access);
                    dispatchTask(vop,len);
                }
                else
                {
                    arg2_direct_access_type arg2Access =
                         getArrayAccess<arg2_direct_access_type> (arg2);

                    VectorizedVoidOperation2<Op,masked_access_type,
                                           arg1_masked_access_type,
                                           arg2_direct_access_type>
                          vop (arrayAccess, arg1Access, arg2Access);
                    dispatchTask(vop,len);
                }
            }
            else
            {
                arg1_direct_access_type arg1Access =
                     getArrayAccess<arg1_direct_access_type> (arg1);

                if (any_masked(arg2))
                {
                    arg2_masked_access_type arg2Access =
                         getArrayAccess<arg2_masked_access_type> (arg2);

                    VectorizedVoidOperation2<Op,masked_access_type,
                                           arg1_direct_access_type,
                                           arg2_masked_access_type>
                          vop (arrayAccess, arg1Access, arg2Access);
                    dispatchTask(vop,len);
                }
                else
                {
                    arg2_direct_access_type arg2Access =
                         getArrayAccess<arg2_direct_access_type> (arg2);

                    VectorizedVoidOperation2<Op,masked_access_type,
                                           arg1_direct_access_type,
                                           arg2_direct_access_type>
                          vop (arrayAccess, arg1Access, arg2Access);
                    dispatchTask(vop,len);
                }
            }
        }
        else
        {
            direct_access_type arrayAccess (array);

            if (any_masked(arg1))
            {
                arg1_masked_access_type arg1Access =
                     getArrayAccess<arg1_masked_access_type> (arg1);

                if (any_masked(arg2))
                {
                    arg2_masked_access_type arg2Access =
                         getArrayAccess<arg2_masked_access_type> (arg2);

                    VectorizedVoidOperation2<Op,direct_access_type,
                                           arg1_masked_access_type,
                                           arg2_masked_access_type>
                          vop (arrayAccess, arg1Access, arg2Access);
                    dispatchTask(vop,len);
                }
                else
                {
                    arg2_direct_access_type arg2Access =
                         getArrayAccess<arg2_direct_access_type> (arg2);

                    VectorizedVoidOperation2<Op,direct_access_type,
                                           arg1_masked_access_type,
                                           arg2_direct_access_type>
                          vop (arrayAccess, arg1Access, arg2Access);
                    dispatchTask(vop,len);
                }
            }
            else
            {
                arg1_direct_access_type arg1Access =
                     getArrayAccess<arg1_direct_access_type> (arg1);

                if (any_masked(arg2))
                {
                    arg2_masked_access_type arg2Access =
                         getArrayAccess<arg2_masked_access_type> (arg2);

                    VectorizedVoidOperation2<Op,direct_access_type,
                                           arg1_direct_access_type,
                                           arg2_masked_access_type>
                          vop (arrayAccess, arg1Access, arg2Access);
                    dispatchTask(vop,len);
                }
                else
                {
                    arg2_direct_access_type arg2Access =
                         getArrayAccess<arg2_direct_access_type> (arg2);

                    VectorizedVoidOperation2<Op,direct_access_type,
                                           arg1_direct_access_type,
                                           arg2_direct_access_type>
                          vop (arrayAccess, arg1Access, arg2Access);
                    dispatchTask(vop,len);
                }
            }
        }

        PY_IMATH_RETURN_PYTHON;
        return array;
    }

    static std::string
    format_arguments(const boost::python::detail::keywords<2> &args)
    {
        // TODO: add types here
        return std::string("(")+args.elements[0].name+","+args.elements[1].name+") - ";
    }
};


template <class Op, class Vectorize, class Func>
struct VectorizedMemberFunction0 {
    BOOST_STATIC_ASSERT((size<Vectorize>::value+1 == function_traits<Func>::arity));

    typedef function_traits<Func> traits;

    typedef typename vectorized_result_type<typename traits::result_type,true_>::type result_type;

    typedef typename access_type<typename traits::arg1_type>::reference_type reference_type;
    typedef typename access_type<typename traits::arg1_type>::direct direct_access_type;
    typedef typename access_type<typename traits::arg1_type>::masked masked_access_type;

    // The return value can't be const or masked.  Verify that condition.
    BOOST_STATIC_ASSERT( !is_const<result_type>::value );
    typedef typename result_type::WritableDirectAccess result_access_type;

    static result_type
    apply(reference_type array)
    {
        PY_IMATH_LEAVE_PYTHON;
        size_t len = measure_arguments(array);
        op_precompute<Op>::apply(len);
        result_type retval = create_uninitalized_return_value<result_type>::apply(len);

        result_access_type returnAccess (retval);

        if (any_masked(array))
        {
            masked_access_type access (array);
            VectorizedOperation1<Op,result_access_type,masked_access_type> vop(returnAccess,access);
            dispatchTask(vop,len);
        }
        else
        {
            direct_access_type access (array);
            VectorizedOperation1<Op,result_access_type,direct_access_type> vop(returnAccess,access);
            dispatchTask(vop,len);
        }

        PY_IMATH_RETURN_PYTHON;
        return retval;
    }
};

template <class Op, class Vectorize, class Func>
struct VectorizedMemberFunction1 {
    BOOST_STATIC_ASSERT((size<Vectorize>::value+1 == function_traits<Func>::arity));

    typedef function_traits<Func> traits;

    typedef typename vectorized_result_type<typename traits::result_type,true_>::type result_type;

    typedef typename access_type<typename traits::arg1_type>::reference_type reference_type;
    typedef typename access_type<typename traits::arg1_type>::direct direct_access_type;
    typedef typename access_type<typename traits::arg1_type>::masked masked_access_type;

    typedef typename argument_access_type<typename traits::arg2_type,
                              typename at<Vectorize,long_<0> >::type>::type arg1_type;
    typedef typename argument_access_type<typename traits::arg2_type,
                              typename at<Vectorize,long_<0> >::type>::direct arg1_direct_access_type;
    typedef typename argument_access_type<typename traits::arg2_type,
                              typename at<Vectorize,long_<0> >::type>::masked arg1_masked_access_type;

    // The return value can't be const or masked.  Verify that condition.
    BOOST_STATIC_ASSERT( !is_const<result_type>::value );
    typedef typename result_type::WritableDirectAccess result_access_type;

    static result_type
    apply(reference_type array, arg1_type arg1)
    {
        PY_IMATH_LEAVE_PYTHON;
        size_t len = measure_arguments(array,arg1);
        op_precompute<Op>::apply(len);
        result_type retval = create_uninitalized_return_value<result_type>::apply(len);

        result_access_type returnAccess (retval);

        if (any_masked(array))
        {
            masked_access_type access (array);

            if (any_masked(arg1))
            {
                arg1_masked_access_type argAccess =
                     getArrayAccess<arg1_masked_access_type> (arg1);

                VectorizedOperation2<Op,result_access_type,
                                        masked_access_type,
                                   arg1_masked_access_type> vop (returnAccess, access, argAccess);
                dispatchTask(vop,len);
            }
            else
            {
                arg1_direct_access_type argAccess =
                     getArrayAccess<arg1_direct_access_type> (arg1);

                VectorizedOperation2<Op,result_access_type,
                                        masked_access_type,
                                   arg1_direct_access_type> vop (returnAccess, access, argAccess);
                dispatchTask(vop,len);
            }
        }
        else
        {
            direct_access_type access (array);

            if (any_masked(arg1))
            {
                arg1_masked_access_type argAccess =
                     getArrayAccess<arg1_masked_access_type> (arg1);

                VectorizedOperation2<Op,result_access_type,
                                        direct_access_type,
                                   arg1_masked_access_type> vop (returnAccess, access, argAccess);
                dispatchTask(vop,len);
            }
            else
            {
                arg1_direct_access_type argAccess =
                     getArrayAccess<arg1_direct_access_type> (arg1);

                VectorizedOperation2<Op,result_access_type,
                                        direct_access_type,
                                   arg1_direct_access_type> vop (returnAccess, access, argAccess);
                dispatchTask(vop,len);
            }
        }

        PY_IMATH_RETURN_PYTHON;
        return retval;
    }

    static std::string
    format_arguments(const boost::python::detail::keywords<1> &args)
    {
        // TODO: add types here
        return std::string("(")+args.elements[0].name+") - ";
    }
};

template <class Op, class Vectorize, class Func>
struct VectorizedMemberFunction2 {
    BOOST_STATIC_ASSERT((size<Vectorize>::value+1 == function_traits<Func>::arity));

    typedef function_traits<Func> traits;

    typedef typename vectorized_result_type<typename traits::result_type,true_>::type result_type;

    typedef typename access_type<typename traits::arg1_type>::reference_type reference_type;
    typedef typename access_type<typename traits::arg1_type>::direct direct_access_type;
    typedef typename access_type<typename traits::arg1_type>::masked masked_access_type;

    typedef typename argument_access_type<typename traits::arg2_type,
                              typename at<Vectorize,long_<0> >::type>::type arg1_type;
    typedef typename argument_access_type<typename traits::arg2_type,
                              typename at<Vectorize,long_<0> >::type>::direct arg1_direct_access_type;
    typedef typename argument_access_type<typename traits::arg2_type,
                              typename at<Vectorize,long_<0> >::type>::masked arg1_masked_access_type;

    typedef typename argument_access_type<typename traits::arg3_type,
                              typename at<Vectorize,long_<1> >::type>::type arg2_type;
    typedef typename argument_access_type<typename traits::arg3_type,
                              typename at<Vectorize,long_<1> >::type>::direct arg2_direct_access_type;
    typedef typename argument_access_type<typename traits::arg3_type,
                              typename at<Vectorize,long_<1> >::type>::masked arg2_masked_access_type;

    // The return value can't be const or masked.  Verify that condition.
    BOOST_STATIC_ASSERT( !is_const<result_type>::value );
    typedef typename result_type::WritableDirectAccess result_access_type;

    static result_type
    apply(reference_type array, arg1_type arg1, arg2_type arg2)
    {
        PY_IMATH_LEAVE_PYTHON;
        size_t len = measure_arguments(array,arg1,arg2);
        op_precompute<Op>::apply(len);
        result_type retval = create_uninitalized_return_value<result_type>::apply(len);

        result_access_type returnAccess (retval);

        if (any_masked(array))
        {
            masked_access_type access (array);

            if (any_masked(arg1))
            {
                arg1_masked_access_type arg1Access =
                     getArrayAccess<arg1_masked_access_type> (arg1);

                if (any_masked(arg2))
                {
                    arg2_masked_access_type arg2Access =
                         getArrayAccess<arg2_masked_access_type> (arg2);

                    VectorizedOperation3<Op,result_access_type,
                                            masked_access_type,
                                       arg1_masked_access_type,
                                       arg2_masked_access_type>
                        vop (returnAccess, access, arg1Access, arg2Access);
                    dispatchTask(vop,len);
                }
                else
                {
                    arg2_direct_access_type arg2Access =
                         getArrayAccess<arg2_direct_access_type> (arg2);

                    VectorizedOperation3<Op,result_access_type,
                                            masked_access_type,
                                       arg1_masked_access_type,
                                       arg2_direct_access_type>
                        vop (returnAccess, access, arg1Access, arg2Access);
                    dispatchTask(vop,len);
                }
            }
            else
            {
                arg1_direct_access_type arg1Access =
                     getArrayAccess<arg1_direct_access_type> (arg1);

                if (any_masked(arg2))
                {
                    arg2_masked_access_type arg2Access =
                         getArrayAccess<arg2_masked_access_type> (arg2);

                    VectorizedOperation3<Op,result_access_type,
                                            masked_access_type,
                                       arg1_direct_access_type,
                                       arg2_masked_access_type>
                        vop (returnAccess, access, arg1Access, arg2Access);
                    dispatchTask(vop,len);
                }
                else
                {
                    arg2_direct_access_type arg2Access =
                         getArrayAccess<arg2_direct_access_type> (arg2);

                    VectorizedOperation3<Op,result_access_type,
                                            masked_access_type,
                                       arg1_direct_access_type,
                                       arg2_direct_access_type>
                        vop (returnAccess, access, arg1Access, arg2Access);
                    dispatchTask(vop,len);
                }
            }
        }
        else
        {
            direct_access_type access (array);

            if (any_masked(arg1))
            {
                arg1_masked_access_type arg1Access =
                     getArrayAccess<arg1_masked_access_type> (arg1);

                if (any_masked(arg2))
                {
                    arg2_masked_access_type arg2Access =
                         getArrayAccess<arg2_masked_access_type> (arg2);

                    VectorizedOperation3<Op,result_access_type,
                                            direct_access_type,
                                       arg1_masked_access_type,
                                       arg2_masked_access_type>
                        vop (returnAccess, access, arg1Access, arg2Access);
                    dispatchTask(vop,len);
                }
                else
                {
                    arg2_direct_access_type arg2Access =
                         getArrayAccess<arg2_direct_access_type> (arg2);

                    VectorizedOperation3<Op,result_access_type,
                                            direct_access_type,
                                       arg1_masked_access_type,
                                       arg2_direct_access_type>
                        vop (returnAccess, access, arg1Access, arg2Access);
                    dispatchTask(vop,len);
                }
            }
            else
            {
                arg1_direct_access_type arg1Access =
                     getArrayAccess<arg1_direct_access_type> (arg1);

                if (any_masked(arg2))
                {
                    arg2_masked_access_type arg2Access =
                         getArrayAccess<arg2_masked_access_type> (arg2);

                    VectorizedOperation3<Op,result_access_type,
                                            direct_access_type,
                                       arg1_direct_access_type,
                                       arg2_masked_access_type>
                        vop (returnAccess, access, arg1Access, arg2Access);
                    dispatchTask(vop,len);
                }
                else
                {
                    arg2_direct_access_type arg2Access =
                         getArrayAccess<arg2_direct_access_type> (arg2);

                    VectorizedOperation3<Op,result_access_type,
                                            direct_access_type,
                                       arg1_direct_access_type,
                                       arg2_direct_access_type>
                        vop (returnAccess, access, arg1Access, arg2Access);
                    dispatchTask(vop,len);
                }
            }
        }

        PY_IMATH_RETURN_PYTHON;
        return retval;
    }

    static std::string
    format_arguments(const boost::python::detail::keywords<2> &args)
    {
        // TODO: add types here
        return std::string("(")+args.elements[0].name+","+args.elements[1].name+") - ";
    }
};

template <class Op, class Cls, class Func, class Keywords>
struct member_function_binding
{
    Cls &_cls;
    std::string _name, _doc;
    const Keywords &_args;

    member_function_binding(Cls &cls,const std::string &name, const std::string &doc,const Keywords &args)
        : _cls(cls), _name(name), _doc(doc), _args(args)
    {}

    template <class Vectorize>
    void operator()(Vectorize) const
    {
        typedef typename if_<is_same<void,typename function_traits<Func>::result_type>,
                             typename if_<boost::mpl::equal<Vectorize,boost::mpl::vector<boost::mpl::true_> >,
                                 VectorizedVoidMaskableMemberFunction1<Op,Func>,
                                 VectorizedVoidMemberFunction1<Op,Vectorize,Func> >::type,
                             VectorizedMemberFunction1<Op,Vectorize,Func>
                         >::type member_func1_type;

        typedef typename if_<is_same<void,typename function_traits<Func>::result_type>,
                         VectorizedVoidMemberFunction2<Op,Vectorize,Func>,
                         VectorizedMemberFunction2<Op,Vectorize,Func> >::type member_func2_type;

        typedef typename if_<is_same<void,typename function_traits<Func>::result_type>,
                         boost::python::return_internal_reference<>,  // the void vectorizations return a reference to self
                         boost::python::default_call_policies>::type call_policies;

        typedef typename at<vector<
            int,  // unused, arity 0
            int,  // unused, arity 1 - first argument corresponds to the class type
            member_func1_type,
            member_func2_type
            >,
            long_<function_traits<Func>::arity> >::type vectorized_function_type;
        std::string doc = _name + vectorized_function_type::format_arguments(_args) + _doc;
        _cls.def(_name.c_str(),&vectorized_function_type::apply,doc.c_str(),_args,call_policies());
    }
};

template <class Op,class Cls,class Func,class Keywords>
member_function_binding<Op,Cls,Func,Keywords>
build_member_function_binding(Cls &cls,Func *func,const std::string &name,const std::string &doc,const Keywords &args)
{
    return member_function_binding<Op,Cls,Func,Keywords>(cls,name,doc,args);
}

template <class Op,class Cls,class Vectorizable,class Keywords>
struct generate_member_bindings_struct
{
    //BOOST_STATIC_ASSERT(size<Vectorizable>::value+1 == function_traits<Op::apply>::arity);
    static void apply(Cls &cls,const std::string &name,const std::string &doc,const Keywords &args) {
        for_each<typename allowable_vectorizations<Vectorizable>::type>(build_member_function_binding<Op>(cls,Op::apply,name,doc,args));
    }
};

template <class Op,class Cls,class Func>
void
generate_single_member_binding(Cls &cls,Func *func,const std::string &name,const std::string &doc)
{
    typedef typename if_<is_same<void,typename function_traits<Func>::result_type>,
                         VectorizedVoidMemberFunction0<Op,boost::mpl::vector<>,Func>,
                         VectorizedMemberFunction0<Op,boost::mpl::vector<>,Func> >::type vectorized_function_type;

    typedef typename if_<is_same<void,typename function_traits<Func>::result_type>,
                         boost::python::return_internal_reference<>,  // the void vectorizations return a reference to self
                         boost::python::default_call_policies>::type call_policies;

    cls.def(name.c_str(),&vectorized_function_type::apply,doc.c_str(),call_policies());
}

} // namespace detail

// TODO: update for arg("name")=default_value syntax
template <class Op,class Vectorizable0>
void generate_bindings(const std::string &name,const std::string &doc,const boost::python::detail::keywords<1> &args) {
    using namespace detail;
    generate_bindings_struct<Op,vector<Vectorizable0>,boost::python::detail::keywords<1> >::apply(name,doc,args);
}

template <class Op,class Vectorizable0, class Vectorizable1>
void generate_bindings(const std::string &name,const std::string &doc,const boost::python::detail::keywords<2> &args) {
    using namespace detail;
    generate_bindings_struct<Op,vector<Vectorizable0,Vectorizable1>,boost::python::detail::keywords<2> >::apply(name,doc,args);
}

template <class Op,class Vectorizable0, class Vectorizable1, class Vectorizable2>
void generate_bindings(const std::string &name,const std::string &doc,const boost::python::detail::keywords<3> &args) {
    using namespace detail;
    generate_bindings_struct<Op,vector<Vectorizable0,Vectorizable1,Vectorizable2>,boost::python::detail::keywords<3> >::apply(name,doc,args);
}

template <class Op,class Vectorizable0, class Vectorizable1, class Vectorizable2, class Vectorizable3>
void generate_bindings(const std::string &name,const std::string &doc,const boost::python::detail::keywords<4> &args) {
    using namespace detail;
    generate_bindings_struct<Op,vector<Vectorizable0,Vectorizable1,Vectorizable2,Vectorizable3>,boost::python::detail::keywords<4> >::apply(name,doc,args);
}

template <class Op,class Vectorizable0, class Vectorizable1, class Vectorizable2, class Vectorizable3, class Vectorizable4>
void generate_bindings(const std::string &name,const std::string &doc,const boost::python::detail::keywords<5> &args) {
    using namespace detail;
    generate_bindings_struct<Op,vector<Vectorizable0,Vectorizable1,Vectorizable2,Vectorizable3,Vectorizable4>,boost::python::detail::keywords<5> >::apply(name,doc,args);
}

template <class Op,class Cls>
void
generate_member_bindings(Cls &cls,const std::string &name,const std::string &doc)
{
    using namespace detail;
    generate_single_member_binding<Op>(cls,&Op::apply,name,doc);
}

template <class Op,class Vectorizable0,class Cls>
void
generate_member_bindings(Cls &cls,const std::string &name,const std::string &doc,
                         const boost::python::detail::keywords<1> &args)
{
    using boost::mpl::vector;
    detail::generate_member_bindings_struct<Op,Cls,vector<Vectorizable0>,
                                            boost::python::detail::keywords<1> >::apply(cls,name,doc,args);
}

template <class Op,class Vectorizable0,class Vectorizable1,class Cls>
void
generate_member_bindings(Cls &cls,const std::string &name,const std::string &doc,
                         const boost::python::detail::keywords<2> &args)
{
    using boost::mpl::vector;
    detail::generate_member_bindings_struct<Op,Cls,vector<Vectorizable0,Vectorizable1>,
                                            boost::python::detail::keywords<2> >::apply(cls,name,doc,args);
}

} // namespace PyImath

#endif // _PyImathAutovectorize_h_
