D7net
Home
Console
Upload
information
Create File
Create Folder
About
Tools
:
/
usr
/
include
/
Imath
/
Filename :
PyImathAutovectorize.h
back
Copy
// // 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_