Debian Codegraph @

src/python/PyImath/PyImathAutovectorize.h

raw
1 //
2 // SPDX-License-Identifier: BSD-3-Clause
3 // Copyright Contributors to the OpenEXR Project.
4 //
5
6 // clang-format off
7
8
9 #ifndef _PyImathAutovectorize_h_
10 #define _PyImathAutovectorize_h_
11
12 #include <Python.h>
13 #define BOOST_BIND_GLOBAL_PLACEHOLDERS
14 #include <boost/python.hpp>
15 #include <boost/mpl/size.hpp>
16 #include <boost/mpl/pop_front.hpp>
17 #include <boost/mpl/push_front.hpp>
18 #include <boost/mpl/front.hpp>
19 #include <boost/mpl/eval_if.hpp>
20 #include <boost/mpl/bool.hpp>
21 #include <boost/mpl/vector.hpp>
22 #include <boost/mpl/transform.hpp>
23 #include <boost/mpl/remove_if.hpp>
24 #include <boost/mpl/equal.hpp>
25 #include <boost/mpl/for_each.hpp>
26 #include <boost/mpl/not.hpp>
27 #include <boost/mpl/count.hpp>
28 #include <boost/mpl/or.hpp>
29 #include <boost/type_traits/is_base_of.hpp>
30 #include <boost/type_traits/function_traits.hpp>
31 #include <boost/static_assert.hpp>
32 #include <boost/python/args.hpp>
33 #include <iostream>
34 #include "PyImathFixedArray.h"
35 #include "PyImathTask.h"
36 #include "PyImathUtil.h"
37
38 namespace PyImath {
39
40 struct op_with_precomputation {};
41
42 namespace detail {
43
44 using boost::is_base_of;
45 using boost::is_same;
46 using boost::is_const;
47 using boost::remove_const;
48 using boost::remove_reference;
49 using boost::function_traits;
50
51 using boost::mpl::at;
52 using boost::mpl::at_c;
53 using boost::mpl::push_front;
54 using boost::mpl::vector;
55 using boost::mpl::push_back;
56 using boost::mpl::transform;
57 using boost::mpl::fold;
58 using boost::mpl::_;
59 using boost::mpl::_1;
60 using boost::mpl::_2;
61 using boost::mpl::long_;
62 using boost::mpl::false_;
63 using boost::mpl::true_;
64 using boost::mpl::not_;
65 using boost::mpl::or_;
66 using boost::mpl::and_;
67 using boost::mpl::size;
68 using boost::mpl::remove_if;
69 using boost::mpl::if_;
70 using boost::mpl::for_each;
71
72
73 struct null_precomputation {
74 static void precompute(size_t len) { return; }
75 };
76
77 template <class T> struct op_precompute
78 {
79 static void
80 apply(size_t len)
81 {
82 if_<is_base_of<op_with_precomputation,T>,
83 T,
84 null_precomputation>::type::precompute(len);
85 }
86 };
87
88 template <int N>
89 struct possible_vectorizations
90 {
91 typedef typename fold<
92 typename possible_vectorizations<N-1>::type,
93 vector<>,
94 push_back<push_back<_1,push_back<_2,false_> >,push_back<_2,true_> >
95 >::type type;
96 };
97
98 template <>
99 struct possible_vectorizations<0>
100 {
101 typedef vector<vector<> > type;
102 };
103
104 template <class Vectorizable>
105 struct disallow_vectorization
106 {
107 template <class Vectorize>
108 struct apply
109 {
110 // Valid = !Vectorize || Vectorizable
111 typedef typename transform<Vectorize,not_<_> >::type DontVectorize;
112 typedef typename transform<DontVectorize,Vectorizable,or_<_,_> >::type Valid;
113 typedef typename not_<fold<Valid,true_,and_<_,_> > >::type type;
114 };
115 };
116
117 template <class Vectorizable>
118 struct allowable_vectorizations
119 {
120 typedef typename possible_vectorizations<size<Vectorizable>::value>::type possible;
121 typedef typename remove_if<possible,disallow_vectorization<Vectorizable> >::type type;
122 };
123
124 template <class T>
125 bool any_masked(const T &value)
126 {
127 return false;
128 };
129
130 template <class T>
131 bool any_masked(const PyImath::FixedArray<T> &value)
132 {
133 return value.isMaskedReference();
134 };
135
136 template <class T1, class T2>
137 bool any_masked(const T1 &a, const T2 &b)
138 {
139 return any_masked(a) || any_masked(b);
140 }
141
142 template <class T1, class T2, class T3>
143 bool any_masked(const T1 &a, const T2 &b, const T3 &c)
144 {
145 return any_masked(a,b) || any_masked(c);
146 }
147
148 template <class T1, class T2, class T3, class T4>
149 bool any_masked(const T1 &a, const T2 &b, const T3 &c, const T4 &d)
150 {
151 return any_masked(a,b) || any_masked(c,d);
152 }
153
154 //-----------------------------------------------------------------------------------------
155
156 //
157 // measure_argument returns a pair indicating the integral length of the argument
158 // (scalar arguments have implicit length 1), and a bool indicating whether the argument
159 // is a vectorized argument.
160 //
161 template <class T>
162 struct measure_argument
163 {
164 static inline std::pair<size_t,bool> apply(T arg) { return std::make_pair(1,false); }
165 };
166
167 template <class T>
168 struct measure_argument<PyImath::FixedArray<T> >
169 {
170 static inline std::pair<size_t,bool> apply(const PyImath::FixedArray<T> &arg) { return std::make_pair(arg.len(),true); }
171 };
172
173 //
174 // match_lengths returns the compatible length given two argument lengths
175 //
176 static inline std::pair<size_t,bool>
177 match_lengths(const std::pair<size_t,bool> &len1, const std::pair<size_t,bool> &len2)
178 {
179 // scalar arguemnts are always compatible with other arguments
180 if (len1.second == false) return len2;
181 if (len2.second == false) return len1;
182
183 // now both arguments are vectorized, check for dimension match
184 if (len1.first != len2.first)
185 throw std::invalid_argument("Array dimensions passed into function do not match");
186
187 return len1;
188 }
189
190
191 //
192 // measure_arguments finds the length that a return value from a given
193 // set of arguments should have, throwing an exception if the lengths
194 // are incompatible. If all arguments are scalar, length 1 is returned.
195 //
196 template <class arg1_type>
197 size_t
198 measure_arguments(const arg1_type &arg1)
199 {
200 std::pair<size_t,bool> len = measure_argument<arg1_type>::apply(arg1);
201 return len.first;
202 }
203
204 template <class arg1_type, class arg2_type>
205 size_t
206 measure_arguments(const arg1_type &arg1, const arg2_type &arg2)
207 {
208 std::pair<size_t,bool> len = measure_argument<arg1_type>::apply(arg1);
209 len = match_lengths(len,measure_argument<arg2_type>::apply(arg2));
210 return len.first;
211 }
212
213 template <class arg1_type, class arg2_type, class arg3_type>
214 size_t
215 measure_arguments(const arg1_type &arg1, const arg2_type &arg2, const arg3_type &arg3)
216 {
217 std::pair<size_t,bool> len = measure_argument<arg1_type>::apply(arg1);
218 len = match_lengths(len,measure_argument<arg2_type>::apply(arg2));
219 len = match_lengths(len,measure_argument<arg3_type>::apply(arg3));
220 return len.first;
221 }
222
223 template <class arg1_type, class arg2_type, class arg3_type, class arg4_type>
224 size_t
225 measure_arguments(const arg1_type &arg1, const arg2_type &arg2, const arg3_type &arg3, const arg4_type &arg4)
226 {
227 std::pair<size_t,bool> len = measure_argument<arg1_type>::apply(arg1);
228 len = match_lengths(len,measure_argument<arg2_type>::apply(arg2));
229 len = match_lengths(len,measure_argument<arg3_type>::apply(arg3));
230 len = match_lengths(len,measure_argument<arg4_type>::apply(arg4));
231 return len.first;
232 }
233
234 template <class arg1_type, class arg2_type, class arg3_type, class arg4_type, class arg5_type>
235 size_t
236 measure_arguments(const arg1_type &arg1, const arg2_type &arg2, const arg3_type &arg3, const arg4_type &arg4, const arg5_type &arg5)
237 {
238 std::pair<size_t,bool> len = measure_argument<arg1_type>::apply(arg1);
239 len = match_lengths(len,measure_argument<arg2_type>::apply(arg2));
240 len = match_lengths(len,measure_argument<arg3_type>::apply(arg3));
241 len = match_lengths(len,measure_argument<arg4_type>::apply(arg4));
242 len = match_lengths(len,measure_argument<arg5_type>::apply(arg5));
243 return len.first;
244 }
245
246 //-----------------------------------------------------------------------------------------
247
248 template <class T>
249 struct create_uninitalized_return_value
250 {
251 static T apply(size_t length)
252 {
253 return T();
254 }
255 };
256
257 template <class T>
258 struct create_uninitalized_return_value<PyImath::FixedArray<T> >
259 {
260 static PyImath::FixedArray<T> apply(size_t length)
261 {
262 return PyImath::FixedArray<T>(Py_ssize_t(length),PyImath::UNINITIALIZED);
263 }
264 };
265
266 template <class T, class VectorizeArg>
267 struct vectorized_result_type
268 {
269 typedef typename if_<VectorizeArg,PyImath::FixedArray<T>,T>::type type;
270 };
271
272 template <typename T>
273 struct SimpleNonArrayWrapper
274 {
275 struct ReadOnlyDirectAccess
276 {
277 ReadOnlyDirectAccess (const T& arg)
278 : _arg (arg) {}
279 ReadOnlyDirectAccess (const ReadOnlyDirectAccess& other)
280 : _arg (other._arg) {}
281
282 const T& operator[] (size_t) const { return _arg; }
283
284 private:
285 const T& _arg;
286 };
287
288 struct WritableDirectAccess : public ReadOnlyDirectAccess
289 {
290 WritableDirectAccess (T& arg)
291 : ReadOnlyDirectAccess (arg), _arg (arg) {}
292 WritableDirectAccess (const WritableDirectAccess& other)
293 : ReadOnlyDirectAccess (other), _arg (other._arg) {}
294
295 T& operator[] (size_t) { return _arg; }
296
297 private:
298 T& _arg;
299 };
300
301 typedef ReadOnlyDirectAccess ReadOnlyMaskedAccess;
302 typedef WritableDirectAccess WritableMaskedAccess;
303 };
304
305
306 template <class T>
307 struct access_type
308 {
309 typedef typename remove_reference<T>::type prim_type;
310 typedef typename remove_const<prim_type>::type base_type;
311 typedef typename if_<is_const<prim_type>,
312 const PyImath::FixedArray<base_type> &,
313 PyImath::FixedArray<base_type> &>::type reference_type;
314 typedef typename remove_reference<reference_type>::type class_type;
315
316 typedef typename if_<is_const<prim_type>,
317 typename class_type::ReadOnlyMaskedAccess,
318 typename class_type::WritableMaskedAccess>::type masked;
319 typedef typename if_<is_const<prim_type>,
320 typename class_type::ReadOnlyDirectAccess,
321 typename class_type::WritableDirectAccess>::type direct;
322 };
323
324 template <class T, class VectorizeArg>
325 struct argument_access_type
326 {
327 typedef typename remove_const<typename remove_reference<T>::type>::type base_type;
328 typedef typename if_<VectorizeArg,const PyImath::FixedArray<base_type> &,T>::type type;
329
330 typedef typename if_<VectorizeArg,
331 typename remove_reference<type>::type,
332 SimpleNonArrayWrapper<base_type> >::type _class_type;
333
334 typedef typename _class_type::ReadOnlyMaskedAccess masked;
335 typedef typename _class_type::ReadOnlyDirectAccess direct;
336 };
337
338 template <class T, class VectorizeArg>
339 struct result_access_type
340 {
341 typedef typename remove_const<typename remove_reference<T>::type>::type base_type;
342 typedef typename if_<VectorizeArg,PyImath::FixedArray<base_type>,T>::type type;
343
344 typedef typename if_<VectorizeArg, type,
345 SimpleNonArrayWrapper<base_type> >::type _class_type;
346
347 typedef typename _class_type::WritableMaskedAccess masked;
348 typedef typename _class_type::WritableDirectAccess direct;
349 };
350
351 template <class AccessType, class T>
352 AccessType getArrayAccess (T& value)
353 { return AccessType (value); }
354
355 template <class AccessType, class T>
356 AccessType getArrayAccess (const PyImath::FixedArray<T>& array)
357 { return AccessType (array); }
358
359 template <class AccessType, class T>
360 AccessType getArrayAccess (PyImath::FixedArray<T>& array)
361 { return AccessType (array); }
362
363 //
364
365 template <class Op, class result_access_type, class access_type>
366 struct VectorizedOperation1 : public Task
367 {
368 result_access_type retAccess;
369 access_type access;
370
371 VectorizedOperation1 (result_access_type r, access_type a1)
372 : retAccess (r), access (a1) {}
373
374 void execute(size_t start, size_t end)
375 {
376 for (size_t i = start; i < end; ++i)
377 {
378 retAccess[i] = Op::apply (access[i]);
379 }
380 }
381 };
382
383 template <class Op, class result_access_type, class access_type, class arg1_access_type>
384 struct VectorizedOperation2 : public Task
385 {
386 result_access_type retAccess;
387 access_type access;
388 arg1_access_type argAccess;
389
390 VectorizedOperation2(result_access_type r, access_type a1, arg1_access_type a2)
391 : retAccess (r), access (a1), argAccess (a2) {}
392
393 void execute(size_t start, size_t end)
394 {
395 for (size_t i = start; i < end; ++i)
396 {
397 retAccess[i] = Op::apply (access[i], argAccess[i]);
398 }
399 }
400 };
401
402 template <class Op, class result_access_type, class access_type,
403 class arg1_access_type, class arg2_access_type>
404 struct VectorizedOperation3 : public Task
405 {
406 result_access_type retAccess;
407 access_type access;
408 arg1_access_type arg1Access;
409 arg2_access_type arg2Access;
410
411 VectorizedOperation3(result_access_type r, access_type a,
412 arg1_access_type a1, arg2_access_type a2)
413 : retAccess(r), access(a), arg1Access(a1), arg2Access(a2) {}
414
415 void execute(size_t start, size_t end)
416 {
417 for (size_t i = start; i < end; ++i)
418 {
419 retAccess[i] = Op::apply(access[i], arg1Access[i], arg2Access[i]);
420 }
421 }
422 };
423
424 template <class Op, class result_access_type, class access_type,
425 class arg1_access_type, class arg2_access_type, class arg3_access_type>
426 struct VectorizedOperation4 : public Task
427 {
428 result_access_type retAccess;
429 access_type access;
430 arg1_access_type arg1Access;
431 arg2_access_type arg2Access;
432 arg3_access_type arg3Access;
433
434 VectorizedOperation4(result_access_type r, access_type a,
435 arg1_access_type a1, arg2_access_type a2, arg3_access_type a3)
436 : retAccess(r), access(a), arg1Access(a1), arg2Access(a2), arg3Access(a3) {}
437
438 void execute(size_t start, size_t end)
439 {
440 for (size_t i = start; i < end; ++i)
441 {
442 retAccess[i] = Op::apply(access[i], arg1Access[i], arg2Access[i], arg3Access[i]);
443 }
444 }
445 };
446
447 template <class Op, class result_access_type, class access_type,
448 class arg1_access_type, class arg2_access_type, class arg3_access_type, class arg4_access_type>
449 struct VectorizedOperation5 : public Task
450 {
451 result_access_type retAccess;
452 access_type access;
453 arg1_access_type arg1Access;
454 arg2_access_type arg2Access;
455 arg3_access_type arg3Access;
456 arg4_access_type arg4Access;
457
458 VectorizedOperation5(result_access_type r, access_type a,
459 arg1_access_type a1, arg2_access_type a2, arg3_access_type a3, arg4_access_type a4)
460 : retAccess(r), access(a), arg1Access(a1), arg2Access(a2), arg3Access(a3), arg4Access(a4) {}
461
462 void execute(size_t start, size_t end)
463 {
464 for (size_t i = start; i < end; ++i)
465 {
466 retAccess[i] = Op::apply(access[i], arg1Access[i], arg2Access[i], arg3Access[i], arg4Access[i]);
467 }
468 }
469 };
470
471 template <class Op, class Vectorize, class Func>
472 struct VectorizedFunction1 {
473 BOOST_STATIC_ASSERT((size<Vectorize>::value == function_traits<Func>::arity));
474
475 typedef function_traits<Func> traits;
476 typedef typename fold<Vectorize,false_,or_<_,_> >::type any_vectorized;
477
478 typedef typename result_access_type<typename traits::result_type,
479 any_vectorized>::type result_type;
480 typedef typename result_access_type<typename traits::result_type,
481 any_vectorized>::direct result_access_type;
482 // Result array is created here 'from scratch', so is always 'direct' access.
483
484 typedef typename argument_access_type<typename traits::arg1_type,
485 typename at<Vectorize,long_<0> >::type>::type arg1_type;
486 typedef typename argument_access_type<typename traits::arg1_type,
487 typename at<Vectorize,long_<0> >::type>::direct arg1_direct_access_type;
488 typedef typename argument_access_type<typename traits::arg1_type,
489 typename at<Vectorize,long_<0> >::type>::masked arg1_masked_access_type;
490
491 static result_type
492 apply(arg1_type arg1)
493 {
494 PY_IMATH_LEAVE_PYTHON;
495 size_t len = measure_arguments(arg1);
496 op_precompute<Op>::apply(len);
497 result_type retval = create_uninitalized_return_value<result_type>::apply(len);
498
499 result_access_type resultAccess = getArrayAccess<result_access_type> (retval);
500
501 if (any_masked(arg1))
502 {
503 arg1_masked_access_type argAccess =
504 getArrayAccess<arg1_masked_access_type> (arg1);
505
506 VectorizedOperation1<Op,result_access_type,arg1_masked_access_type>
507 vop (resultAccess, argAccess);
508 dispatchTask(vop,len);
509 }
510 else
511 {
512 arg1_direct_access_type argAccess =
513 getArrayAccess<arg1_direct_access_type> (arg1);
514
515 VectorizedOperation1<Op,result_access_type,arg1_direct_access_type>
516 vop (resultAccess, argAccess);
517 dispatchTask(vop,len);
518 }
519
520 PY_IMATH_RETURN_PYTHON;
521 return retval;
522 }
523
524 static std::string
525 format_arguments(const boost::python::detail::keywords<1> &args)
526 {
527 // TODO: add types here
528 return std::string("(")+args.elements[0].name+") - ";
529 }
530 };
531
532 template <class Op, class Vectorize, class Func>
533 struct VectorizedFunction2 {
534 BOOST_STATIC_ASSERT((size<Vectorize>::value == function_traits<Func>::arity));
535
536 typedef function_traits<Func> traits;
537 typedef typename fold<Vectorize,false_,or_<_,_> >::type any_vectorized;
538
539 typedef typename result_access_type<typename traits::result_type,
540 any_vectorized>::type result_type;
541 typedef typename result_access_type<typename traits::result_type,
542 any_vectorized>::direct result_access_type;
543 // Result array is created here 'from scratch', so is always 'direct' access.
544
545 typedef typename argument_access_type<typename traits::arg1_type,
546 typename at<Vectorize,long_<0> >::type>::type arg1_type;
547 typedef typename argument_access_type<typename traits::arg1_type,
548 typename at<Vectorize,long_<0> >::type>::direct arg1_direct_access_type;
549 typedef typename argument_access_type<typename traits::arg1_type,
550 typename at<Vectorize,long_<0> >::type>::masked arg1_masked_access_type;
551
552 typedef typename argument_access_type<typename traits::arg2_type,
553 typename at<Vectorize,long_<1> >::type>::type arg2_type;
554 typedef typename argument_access_type<typename traits::arg2_type,
555 typename at<Vectorize,long_<1> >::type>::direct arg2_direct_access_type;
556 typedef typename argument_access_type<typename traits::arg2_type,
557 typename at<Vectorize,long_<1> >::type>::masked arg2_masked_access_type;
558
559 static result_type
560 apply(arg1_type arg1, arg2_type arg2)
561 {
562 PY_IMATH_LEAVE_PYTHON;
563 size_t len = measure_arguments(arg1,arg2);
564 op_precompute<Op>::apply(len);
565 result_type retval = create_uninitalized_return_value<result_type>::apply(len);
566
567 result_access_type resultAccess = getArrayAccess<result_access_type> (retval);
568
569 if (any_masked(arg1))
570 {
571 arg1_masked_access_type arg1Access =
572 getArrayAccess<arg1_masked_access_type> (arg1);
573
574 if (any_masked(arg2))
575 {
576 arg2_masked_access_type arg2Access =
577 getArrayAccess<arg2_masked_access_type> (arg2);
578
579 VectorizedOperation2<Op,result_access_type,
580 arg1_masked_access_type,
581 arg2_masked_access_type>
582 vop (resultAccess, arg1Access, arg2Access);
583 dispatchTask(vop,len);
584 }
585 else
586 {
587 arg2_direct_access_type arg2Access =
588 getArrayAccess<arg2_direct_access_type> (arg2);
589
590 VectorizedOperation2<Op,result_access_type,
591 arg1_masked_access_type,
592 arg2_direct_access_type>
593 vop (resultAccess, arg1Access, arg2Access);
594 dispatchTask(vop,len);
595 }
596 }
597 else
598 {
599 arg1_direct_access_type arg1Access =
600 getArrayAccess<arg1_direct_access_type> (arg1);
601
602 if (any_masked(arg2))
603 {
604 arg2_masked_access_type arg2Access =
605 getArrayAccess<arg2_masked_access_type> (arg2);
606
607 VectorizedOperation2<Op,result_access_type,
608 arg1_direct_access_type,
609 arg2_masked_access_type>
610 vop (resultAccess, arg1Access, arg2Access);
611 dispatchTask(vop,len);
612 }
613 else
614 {
615 arg2_direct_access_type arg2Access =
616 getArrayAccess<arg2_direct_access_type> (arg2);
617
618 VectorizedOperation2<Op,result_access_type,
619 arg1_direct_access_type,
620 arg2_direct_access_type>
621 vop (resultAccess, arg1Access, arg2Access);
622 dispatchTask(vop,len);
623 }
624 }
625
626 PY_IMATH_RETURN_PYTHON;
627 return retval;
628 }
629
630 static std::string
631 format_arguments(const boost::python::detail::keywords<2> &args)
632 {
633 // TODO: add types here
634 return std::string("(")+args.elements[0].name+","+args.elements[1].name+") - ";
635 }
636 };
637
638 template <class Op, class Vectorize, class Func>
639 struct VectorizedFunction3 {
640 BOOST_STATIC_ASSERT((size<Vectorize>::value == function_traits<Func>::arity));
641
642 typedef function_traits<Func> traits;
643 typedef typename fold<Vectorize,false_,or_<_,_> >::type any_vectorized;
644
645 typedef typename result_access_type<typename traits::result_type,
646 any_vectorized>::type result_type;
647 typedef typename result_access_type<typename traits::result_type,
648 any_vectorized>::direct result_access_type;
649 // Result array is created here 'from scratch', so is always 'direct' access.
650
651 typedef typename argument_access_type<typename traits::arg1_type,
652 typename at<Vectorize,long_<0> >::type>::type arg1_type;
653 typedef typename argument_access_type<typename traits::arg1_type,
654 typename at<Vectorize,long_<0> >::type>::direct arg1_direct_access_type;
655 typedef typename argument_access_type<typename traits::arg1_type,
656 typename at<Vectorize,long_<0> >::type>::masked arg1_masked_access_type;
657
658 typedef typename argument_access_type<typename traits::arg2_type,
659 typename at<Vectorize,long_<1> >::type>::type arg2_type;
660 typedef typename argument_access_type<typename traits::arg2_type,
661 typename at<Vectorize,long_<1> >::type>::direct arg2_direct_access_type;
662 typedef typename argument_access_type<typename traits::arg2_type,
663 typename at<Vectorize,long_<1> >::type>::masked arg2_masked_access_type;
664
665 typedef typename argument_access_type<typename traits::arg3_type,
666 typename at<Vectorize,long_<2> >::type>::type arg3_type;
667 typedef typename argument_access_type<typename traits::arg3_type,
668 typename at<Vectorize,long_<2> >::type>::direct arg3_direct_access_type;
669 typedef typename argument_access_type<typename traits::arg3_type,
670 typename at<Vectorize,long_<2> >::type>::masked arg3_masked_access_type;
671
672 static result_type
673 apply(arg1_type arg1, arg2_type arg2, arg3_type arg3)
674 {
675 PY_IMATH_LEAVE_PYTHON;
676 size_t len = measure_arguments(arg1,arg2,arg3);
677 op_precompute<Op>::apply(len);
678 result_type retval = create_uninitalized_return_value<result_type>::apply(len);
679
680 result_access_type resultAccess = getArrayAccess<result_access_type> (retval);
681
682 if (any_masked(arg1))
683 {
684 arg1_masked_access_type arg1Access =
685 getArrayAccess<arg1_masked_access_type> (arg1);
686
687 if (any_masked(arg2))
688 {
689 arg2_masked_access_type arg2Access =
690 getArrayAccess<arg2_masked_access_type> (arg2);
691
692 if (any_masked(arg3))
693 {
694 arg3_masked_access_type arg3Access =
695 getArrayAccess<arg3_masked_access_type> (arg3);
696
697 VectorizedOperation3<Op,result_access_type,
698 arg1_masked_access_type,
699 arg2_masked_access_type,
700 arg3_masked_access_type>
701 vop (resultAccess, arg1Access, arg2Access, arg3Access);
702 dispatchTask(vop,len);
703 }
704 else
705 {
706 arg3_direct_access_type arg3Access =
707 getArrayAccess<arg3_direct_access_type> (arg3);
708
709 VectorizedOperation3<Op,result_access_type,
710 arg1_masked_access_type,
711 arg2_masked_access_type,
712 arg3_direct_access_type>
713 vop (resultAccess, arg1Access, arg2Access, arg3Access);
714 dispatchTask(vop,len);
715 }
716 }
717 else
718 {
719 arg2_direct_access_type arg2Access =
720 getArrayAccess<arg2_direct_access_type> (arg2);
721
722 if (any_masked(arg3))
723 {
724 arg3_masked_access_type arg3Access =
725 getArrayAccess<arg3_masked_access_type> (arg3);
726
727 VectorizedOperation3<Op,result_access_type,
728 arg1_masked_access_type,
729 arg2_direct_access_type,
730 arg3_masked_access_type>
731 vop (resultAccess, arg1Access, arg2Access, arg3Access);
732 dispatchTask(vop,len);
733 }
734 else
735 {
736 arg3_direct_access_type arg3Access =
737 getArrayAccess<arg3_direct_access_type> (arg3);
738
739 VectorizedOperation3<Op,result_access_type,
740 arg1_masked_access_type,
741 arg2_direct_access_type,
742 arg3_direct_access_type>
743 vop (resultAccess, arg1Access, arg2Access, arg3Access);
744 dispatchTask(vop,len);
745 }
746 }
747 }
748 else
749 {
750 arg1_direct_access_type arg1Access =
751 getArrayAccess<arg1_direct_access_type> (arg1);
752
753 if (any_masked(arg2))
754 {
755 arg2_masked_access_type arg2Access =
756 getArrayAccess<arg2_masked_access_type> (arg2);
757
758 if (any_masked(arg3))
759 {
760 arg3_masked_access_type arg3Access =
761 getArrayAccess<arg3_masked_access_type> (arg3);
762
763 VectorizedOperation3<Op,result_access_type,
764 arg1_direct_access_type,
765 arg2_masked_access_type,
766 arg3_masked_access_type>
767 vop (resultAccess, arg1Access, arg2Access, arg3Access);
768 dispatchTask(vop,len);
769 }
770 else
771 {
772 arg3_direct_access_type arg3Access =
773 getArrayAccess<arg3_direct_access_type> (arg3);
774
775 VectorizedOperation3<Op,result_access_type,
776 arg1_direct_access_type,
777 arg2_masked_access_type,
778 arg3_direct_access_type>
779 vop (resultAccess, arg1Access, arg2Access, arg3Access);
780 dispatchTask(vop,len);
781 }
782 }
783 else
784 {
785 arg2_direct_access_type arg2Access =
786 getArrayAccess<arg2_direct_access_type> (arg2);
787
788 if (any_masked(arg3))
789 {
790 arg3_masked_access_type arg3Access =
791 getArrayAccess<arg3_masked_access_type> (arg3);
792
793 VectorizedOperation3<Op,result_access_type,
794 arg1_direct_access_type,
795 arg2_direct_access_type,
796 arg3_masked_access_type>
797 vop (resultAccess, arg1Access, arg2Access, arg3Access);
798 dispatchTask(vop,len);
799 }
800 else
801 {
802 arg3_direct_access_type arg3Access =
803 getArrayAccess<arg3_direct_access_type> (arg3);
804
805 VectorizedOperation3<Op,result_access_type,
806 arg1_direct_access_type,
807 arg2_direct_access_type,
808 arg3_direct_access_type>
809 vop (resultAccess, arg1Access, arg2Access, arg3Access);
810 dispatchTask(vop,len);
811 }
812 }
813 }
814
815 PY_IMATH_RETURN_PYTHON;
816 return retval;
817 }
818
819 static std::string
820 format_arguments(const boost::python::detail::keywords<3> &args)
821 {
822 // TODO: add types here
823 return std::string("(")+args.elements[0].name+","+args.elements[1].name+","+args.elements[2].name+") - ";
824 }
825 };
826
827 template <class Op, class Vectorize, class Func>
828 struct VectorizedFunction4 {
829 BOOST_STATIC_ASSERT((size<Vectorize>::value == function_traits<Func>::arity));
830
831 typedef function_traits<Func> traits;
832 typedef typename fold<Vectorize,false_,or_<_,_> >::type any_vectorized;
833
834 typedef typename result_access_type<typename traits::result_type,
835 any_vectorized>::type result_type;
836 typedef typename result_access_type<typename traits::result_type,
837 any_vectorized>::direct result_access_type;
838 // Result array is created here 'from scratch', so is always 'direct' access.
839
840 typedef typename argument_access_type<typename traits::arg1_type,
841 typename at<Vectorize,long_<0> >::type>::type arg1_type;
842 typedef typename argument_access_type<typename traits::arg1_type,
843 typename at<Vectorize,long_<0> >::type>::direct arg1_direct_access_type;
844 typedef typename argument_access_type<typename traits::arg1_type,
845 typename at<Vectorize,long_<0> >::type>::masked arg1_masked_access_type;
846
847 typedef typename argument_access_type<typename traits::arg2_type,
848 typename at<Vectorize,long_<1> >::type>::type arg2_type;
849 typedef typename argument_access_type<typename traits::arg2_type,
850 typename at<Vectorize,long_<1> >::type>::direct arg2_direct_access_type;
851 typedef typename argument_access_type<typename traits::arg2_type,
852 typename at<Vectorize,long_<1> >::type>::masked arg2_masked_access_type;
853
854 typedef typename argument_access_type<typename traits::arg3_type,
855 typename at<Vectorize,long_<2> >::type>::type arg3_type;
856 typedef typename argument_access_type<typename traits::arg3_type,
857 typename at<Vectorize,long_<2> >::type>::direct arg3_direct_access_type;
858 typedef typename argument_access_type<typename traits::arg3_type,
859 typename at<Vectorize,long_<2> >::type>::masked arg3_masked_access_type;
860
861 typedef typename argument_access_type<typename traits::arg4_type,
862 typename at<Vectorize,long_<3> >::type>::type arg4_type;
863 typedef typename argument_access_type<typename traits::arg4_type,
864 typename at<Vectorize,long_<3> >::type>::direct arg4_direct_access_type;
865 typedef typename argument_access_type<typename traits::arg4_type,
866 typename at<Vectorize,long_<3> >::type>::masked arg4_masked_access_type;
867
868 static result_type
869 apply(arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4)
870 {
871 PY_IMATH_LEAVE_PYTHON;
872 size_t len = measure_arguments(arg1,arg2,arg3,arg4);
873 op_precompute<Op>::apply(len);
874 result_type retval = create_uninitalized_return_value<result_type>::apply(len);
875
876 result_access_type resultAccess = getArrayAccess<result_access_type> (retval);
877
878 if (any_masked(arg1))
879 {
880 arg1_masked_access_type arg1Access =
881 getArrayAccess<arg1_masked_access_type> (arg1);
882
883 if (any_masked(arg2))
884 {
885 arg2_masked_access_type arg2Access =
886 getArrayAccess<arg2_masked_access_type> (arg2);
887
888 if (any_masked(arg3))
889 {
890 arg3_masked_access_type arg3Access =
891 getArrayAccess<arg3_masked_access_type> (arg3);
892
893 if (any_masked(arg4))
894 {
895 arg4_masked_access_type arg4Access =
896 getArrayAccess<arg4_masked_access_type> (arg4);
897
898 VectorizedOperation4<Op,result_access_type,
899 arg1_masked_access_type,
900 arg2_masked_access_type,
901 arg3_masked_access_type,
902 arg4_masked_access_type>
903 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access);
904 dispatchTask(vop,len);
905 }
906 else
907 {
908 arg4_direct_access_type arg4Access =
909 getArrayAccess<arg4_direct_access_type> (arg4);
910
911 VectorizedOperation4<Op,result_access_type,
912 arg1_masked_access_type,
913 arg2_masked_access_type,
914 arg3_masked_access_type,
915 arg4_direct_access_type>
916 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access);
917 dispatchTask(vop,len);
918 }
919 }
920 else
921 {
922 arg3_direct_access_type arg3Access =
923 getArrayAccess<arg3_direct_access_type> (arg3);
924
925 if (any_masked(arg4))
926 {
927 arg4_masked_access_type arg4Access =
928 getArrayAccess<arg4_masked_access_type> (arg4);
929
930 VectorizedOperation4<Op,result_access_type,
931 arg1_masked_access_type,
932 arg2_masked_access_type,
933 arg3_direct_access_type,
934 arg4_masked_access_type>
935 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access);
936 }
937 else
938 {
939 arg4_direct_access_type arg4Access =
940 getArrayAccess<arg4_direct_access_type> (arg4);
941
942 VectorizedOperation4<Op,result_access_type,
943 arg1_masked_access_type,
944 arg2_masked_access_type,
945 arg3_direct_access_type,
946 arg4_direct_access_type>
947 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access);
948 dispatchTask(vop,len);
949 }
950 }
951 }
952 else
953 {
954 arg2_direct_access_type arg2Access =
955 getArrayAccess<arg2_direct_access_type> (arg2);
956
957 if (any_masked(arg3))
958 {
959 arg3_masked_access_type arg3Access =
960 getArrayAccess<arg3_masked_access_type> (arg3);
961
962 if (any_masked(arg4))
963 {
964 arg4_masked_access_type arg4Access =
965 getArrayAccess<arg4_masked_access_type> (arg4);
966
967 VectorizedOperation4<Op,result_access_type,
968 arg1_masked_access_type,
969 arg2_direct_access_type,
970 arg3_masked_access_type,
971 arg4_masked_access_type>
972 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access);
973 dispatchTask(vop,len);
974 }
975 else
976 {
977 arg4_direct_access_type arg4Access =
978 getArrayAccess<arg4_direct_access_type> (arg4);
979
980 VectorizedOperation4<Op,result_access_type,
981 arg1_masked_access_type,
982 arg2_direct_access_type,
983 arg3_masked_access_type,
984 arg4_direct_access_type>
985 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access);
986 dispatchTask(vop,len);
987 }
988 }
989 else
990 {
991 arg3_direct_access_type arg3Access =
992 getArrayAccess<arg3_direct_access_type> (arg3);
993
994 if (any_masked(arg4))
995 {
996 arg4_masked_access_type arg4Access =
997 getArrayAccess<arg4_masked_access_type> (arg4);
998
999 VectorizedOperation4<Op,result_access_type,
1000 arg1_masked_access_type,
1001 arg2_direct_access_type,
1002 arg3_direct_access_type,
1003 arg4_masked_access_type>
1004 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access);
1005 dispatchTask(vop,len);
1006 }
1007 else
1008 {
1009 arg4_direct_access_type arg4Access =
1010 getArrayAccess<arg4_direct_access_type> (arg4);
1011
1012 VectorizedOperation4<Op,result_access_type,
1013 arg1_masked_access_type,
1014 arg2_direct_access_type,
1015 arg3_direct_access_type,
1016 arg4_direct_access_type>
1017 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access);
1018 dispatchTask(vop,len);
1019 }
1020 }
1021 }
1022 }
1023 else
1024 {
1025 arg1_direct_access_type arg1Access =
1026 getArrayAccess<arg1_direct_access_type> (arg1);
1027
1028 if (any_masked(arg2))
1029 {
1030 arg2_masked_access_type arg2Access =
1031 getArrayAccess<arg2_masked_access_type> (arg2);
1032
1033 if (any_masked(arg3))
1034 {
1035 arg3_masked_access_type arg3Access =
1036 getArrayAccess<arg3_masked_access_type> (arg3);
1037
1038 if (any_masked(arg4))
1039 {
1040 arg4_masked_access_type arg4Access =
1041 getArrayAccess<arg4_masked_access_type> (arg4);
1042
1043 VectorizedOperation4<Op,result_access_type,
1044 arg1_direct_access_type,
1045 arg2_masked_access_type,
1046 arg3_masked_access_type,
1047 arg4_masked_access_type>
1048 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access);
1049 dispatchTask(vop,len);
1050 }
1051 else
1052 {
1053 arg4_direct_access_type arg4Access =
1054 getArrayAccess<arg4_direct_access_type> (arg4);
1055
1056 VectorizedOperation4<Op,result_access_type,
1057 arg1_direct_access_type,
1058 arg2_masked_access_type,
1059 arg3_masked_access_type,
1060 arg4_direct_access_type>
1061 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access);
1062 dispatchTask(vop,len);
1063 }
1064 }
1065 else
1066 {
1067 arg3_direct_access_type arg3Access =
1068 getArrayAccess<arg3_direct_access_type> (arg3);
1069
1070 if (any_masked(arg4))
1071 {
1072 arg4_masked_access_type arg4Access =
1073 getArrayAccess<arg4_masked_access_type> (arg4);
1074
1075 VectorizedOperation4<Op,result_access_type,
1076 arg1_direct_access_type,
1077 arg2_masked_access_type,
1078 arg3_direct_access_type,
1079 arg4_masked_access_type>
1080 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access);
1081 dispatchTask(vop,len);
1082 }
1083 else
1084 {
1085 arg4_direct_access_type arg4Access =
1086 getArrayAccess<arg4_direct_access_type> (arg4);
1087
1088 VectorizedOperation4<Op,result_access_type,
1089 arg1_direct_access_type,
1090 arg2_masked_access_type,
1091 arg3_direct_access_type,
1092 arg4_direct_access_type>
1093 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access);
1094 dispatchTask(vop,len);
1095 }
1096 }
1097 }
1098 else
1099 {
1100 arg2_direct_access_type arg2Access =
1101 getArrayAccess<arg2_direct_access_type> (arg2);
1102
1103 if (any_masked(arg3))
1104 {
1105 arg3_masked_access_type arg3Access =
1106 getArrayAccess<arg3_masked_access_type> (arg3);
1107
1108 if (any_masked(arg4))
1109 {
1110 arg4_masked_access_type arg4Access =
1111 getArrayAccess<arg4_masked_access_type> (arg4);
1112
1113 VectorizedOperation4<Op,result_access_type,
1114 arg1_direct_access_type,
1115 arg2_direct_access_type,
1116 arg3_masked_access_type,
1117 arg4_masked_access_type>
1118 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access);
1119 dispatchTask(vop,len);
1120 }
1121 else
1122 {
1123 arg4_direct_access_type arg4Access =
1124 getArrayAccess<arg4_direct_access_type> (arg4);
1125
1126 VectorizedOperation4<Op,result_access_type,
1127 arg1_direct_access_type,
1128 arg2_direct_access_type,
1129 arg3_masked_access_type,
1130 arg4_direct_access_type>
1131 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access);
1132 dispatchTask(vop,len);
1133 }
1134 }
1135 else
1136 {
1137 arg3_direct_access_type arg3Access =
1138 getArrayAccess<arg3_direct_access_type> (arg3);
1139
1140 if (any_masked(arg4))
1141 {
1142 arg4_masked_access_type arg4Access =
1143 getArrayAccess<arg4_masked_access_type> (arg4);
1144
1145 VectorizedOperation4<Op,result_access_type,
1146 arg1_direct_access_type,
1147 arg2_direct_access_type,
1148 arg3_direct_access_type,
1149 arg4_masked_access_type>
1150 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access);
1151 dispatchTask(vop,len);
1152 }
1153 else
1154 {
1155 arg4_direct_access_type arg4Access =
1156 getArrayAccess<arg4_direct_access_type> (arg4);
1157
1158 VectorizedOperation4<Op,result_access_type,
1159 arg1_direct_access_type,
1160 arg2_direct_access_type,
1161 arg3_direct_access_type,
1162 arg4_direct_access_type>
1163 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access);
1164 dispatchTask(vop,len);
1165 }
1166 }
1167 }
1168 }
1169
1170 PY_IMATH_RETURN_PYTHON;
1171 return retval;
1172 }
1173
1174 static std::string
1175 format_arguments(const boost::python::detail::keywords<4> &args)
1176 {
1177 // TODO: add types here
1178 return std::string("(")+args.elements[0].name+","+args.elements[1].name+","+args.elements[2].name+","+args.elements[3].name+") - ";
1179 }
1180 };
1181
1182 template <class Op, class Vectorize, class Func>
1183 struct VectorizedFunction5 {
1184 BOOST_STATIC_ASSERT((size<Vectorize>::value == function_traits<Func>::arity));
1185
1186 typedef function_traits<Func> traits;
1187 typedef typename fold<Vectorize,false_,or_<_,_> >::type any_vectorized;
1188
1189 typedef typename result_access_type<typename traits::result_type,
1190 any_vectorized>::type result_type;
1191 typedef typename result_access_type<typename traits::result_type,
1192 any_vectorized>::direct result_access_type;
1193 // Result array is created here 'from scratch', so is always 'direct' access.
1194
1195 typedef typename argument_access_type<typename traits::arg1_type,
1196 typename at<Vectorize,long_<0> >::type>::type arg1_type;
1197 typedef typename argument_access_type<typename traits::arg1_type,
1198 typename at<Vectorize,long_<0> >::type>::direct arg1_direct_access_type;
1199 typedef typename argument_access_type<typename traits::arg1_type,
1200 typename at<Vectorize,long_<0> >::type>::masked arg1_masked_access_type;
1201
1202 typedef typename argument_access_type<typename traits::arg2_type,
1203 typename at<Vectorize,long_<1> >::type>::type arg2_type;
1204 typedef typename argument_access_type<typename traits::arg2_type,
1205 typename at<Vectorize,long_<1> >::type>::direct arg2_direct_access_type;
1206 typedef typename argument_access_type<typename traits::arg2_type,
1207 typename at<Vectorize,long_<1> >::type>::masked arg2_masked_access_type;
1208
1209 typedef typename argument_access_type<typename traits::arg3_type,
1210 typename at<Vectorize,long_<2> >::type>::type arg3_type;
1211 typedef typename argument_access_type<typename traits::arg3_type,
1212 typename at<Vectorize,long_<2> >::type>::direct arg3_direct_access_type;
1213 typedef typename argument_access_type<typename traits::arg3_type,
1214 typename at<Vectorize,long_<2> >::type>::masked arg3_masked_access_type;
1215
1216 typedef typename argument_access_type<typename traits::arg4_type,
1217 typename at<Vectorize,long_<3> >::type>::type arg4_type;
1218 typedef typename argument_access_type<typename traits::arg4_type,
1219 typename at<Vectorize,long_<3> >::type>::direct arg4_direct_access_type;
1220 typedef typename argument_access_type<typename traits::arg4_type,
1221 typename at<Vectorize,long_<3> >::type>::masked arg4_masked_access_type;
1222
1223 typedef typename argument_access_type<typename traits::arg5_type,
1224 typename at<Vectorize,long_<4> >::type>::type arg5_type;
1225 typedef typename argument_access_type<typename traits::arg5_type,
1226 typename at<Vectorize,long_<4> >::type>::direct arg5_direct_access_type;
1227 typedef typename argument_access_type<typename traits::arg5_type,
1228 typename at<Vectorize,long_<4> >::type>::masked arg5_masked_access_type;
1229
1230 static result_type
1231 apply(arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, arg5_type arg5)
1232 {
1233 PY_IMATH_LEAVE_PYTHON;
1234 size_t len = measure_arguments(arg1,arg2,arg3,arg4,arg5);
1235 op_precompute<Op>::apply(len);
1236 result_type retval = create_uninitalized_return_value<result_type>::apply(len);
1237
1238 result_access_type resultAccess = getArrayAccess<result_access_type> (retval);
1239
1240 if (any_masked(arg1))
1241 {
1242 arg1_masked_access_type arg1Access =
1243 getArrayAccess<arg1_masked_access_type> (arg1);
1244
1245 if (any_masked(arg2))
1246 {
1247 arg2_masked_access_type arg2Access =
1248 getArrayAccess<arg2_masked_access_type> (arg2);
1249
1250 if (any_masked(arg3))
1251 {
1252 arg3_masked_access_type arg3Access =
1253 getArrayAccess<arg3_masked_access_type> (arg3);
1254
1255 if (any_masked(arg4))
1256 {
1257 arg4_masked_access_type arg4Access =
1258 getArrayAccess<arg4_masked_access_type> (arg4);
1259
1260 if (any_masked(arg5))
1261 {
1262 arg5_masked_access_type arg5Access =
1263 getArrayAccess<arg5_masked_access_type> (arg5);
1264
1265 VectorizedOperation5<Op,result_access_type,
1266 arg1_masked_access_type,
1267 arg2_masked_access_type,
1268 arg3_masked_access_type,
1269 arg4_masked_access_type,
1270 arg5_masked_access_type>
1271 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
1272 dispatchTask(vop,len);
1273 }
1274 else
1275 {
1276 arg5_direct_access_type arg5Access =
1277 getArrayAccess<arg5_direct_access_type> (arg5);
1278
1279 VectorizedOperation5<Op,result_access_type,
1280 arg1_masked_access_type,
1281 arg2_masked_access_type,
1282 arg3_masked_access_type,
1283 arg4_masked_access_type,
1284 arg5_direct_access_type>
1285 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
1286 dispatchTask(vop,len);
1287 }
1288 }
1289 else
1290 {
1291 arg4_direct_access_type arg4Access =
1292 getArrayAccess<arg4_direct_access_type> (arg4);
1293
1294 if (any_masked(arg5))
1295 {
1296 arg5_masked_access_type arg5Access =
1297 getArrayAccess<arg5_masked_access_type> (arg5);
1298
1299 VectorizedOperation5<Op,result_access_type,
1300 arg1_masked_access_type,
1301 arg2_masked_access_type,
1302 arg3_masked_access_type,
1303 arg4_direct_access_type,
1304 arg5_masked_access_type>
1305 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
1306 dispatchTask(vop,len);
1307 }
1308 else
1309 {
1310 arg5_direct_access_type arg5Access =
1311 getArrayAccess<arg5_direct_access_type> (arg5);
1312
1313 VectorizedOperation5<Op,result_access_type,
1314 arg1_masked_access_type,
1315 arg2_masked_access_type,
1316 arg3_masked_access_type,
1317 arg4_direct_access_type,
1318 arg5_direct_access_type>
1319 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
1320 dispatchTask(vop,len);
1321 }
1322 }
1323 }
1324 else
1325 {
1326 arg3_direct_access_type arg3Access =
1327 getArrayAccess<arg3_direct_access_type> (arg3);
1328
1329 if (any_masked(arg4))
1330 {
1331 arg4_masked_access_type arg4Access =
1332 getArrayAccess<arg4_masked_access_type> (arg4);
1333
1334 if (any_masked(arg5))
1335 {
1336 arg5_masked_access_type arg5Access =
1337 getArrayAccess<arg5_masked_access_type> (arg5);
1338
1339 VectorizedOperation5<Op,result_access_type,
1340 arg1_masked_access_type,
1341 arg2_masked_access_type,
1342 arg3_direct_access_type,
1343 arg4_masked_access_type,
1344 arg5_masked_access_type>
1345 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
1346 dispatchTask(vop,len);
1347 }
1348 else
1349 {
1350 arg5_direct_access_type arg5Access =
1351 getArrayAccess<arg5_direct_access_type> (arg5);
1352
1353 VectorizedOperation5<Op,result_access_type,
1354 arg1_masked_access_type,
1355 arg2_masked_access_type,
1356 arg3_direct_access_type,
1357 arg4_masked_access_type,
1358 arg5_direct_access_type>
1359 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
1360 dispatchTask(vop,len);
1361 }
1362 }
1363 else
1364 {
1365 arg4_direct_access_type arg4Access =
1366 getArrayAccess<arg4_direct_access_type> (arg4);
1367
1368 if (any_masked(arg5))
1369 {
1370 arg5_masked_access_type arg5Access =
1371 getArrayAccess<arg5_masked_access_type> (arg5);
1372
1373 VectorizedOperation5<Op,result_access_type,
1374 arg1_masked_access_type,
1375 arg2_masked_access_type,
1376 arg3_direct_access_type,
1377 arg4_direct_access_type,
1378 arg5_masked_access_type>
1379 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
1380 dispatchTask(vop,len);
1381 }
1382 else
1383 {
1384 arg5_direct_access_type arg5Access =
1385 getArrayAccess<arg5_direct_access_type> (arg5);
1386
1387 VectorizedOperation5<Op,result_access_type,
1388 arg1_masked_access_type,
1389 arg2_masked_access_type,
1390 arg3_direct_access_type,
1391 arg4_direct_access_type,
1392 arg5_direct_access_type>
1393 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
1394 dispatchTask(vop,len);
1395 }
1396 }
1397 }
1398 }
1399 else
1400 {
1401 arg2_direct_access_type arg2Access =
1402 getArrayAccess<arg2_direct_access_type> (arg2);
1403
1404 if (any_masked(arg3))
1405 {
1406 arg3_masked_access_type arg3Access =
1407 getArrayAccess<arg3_masked_access_type> (arg3);
1408
1409 if (any_masked(arg4))
1410 {
1411 arg4_masked_access_type arg4Access =
1412 getArrayAccess<arg4_masked_access_type> (arg4);
1413
1414 if (any_masked(arg5))
1415 {
1416 arg5_masked_access_type arg5Access =
1417 getArrayAccess<arg5_masked_access_type> (arg5);
1418
1419 VectorizedOperation5<Op,result_access_type,
1420 arg1_masked_access_type,
1421 arg2_direct_access_type,
1422 arg3_masked_access_type,
1423 arg4_masked_access_type,
1424 arg5_masked_access_type>
1425 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
1426 dispatchTask(vop,len);
1427 }
1428 else
1429 {
1430 arg5_direct_access_type arg5Access =
1431 getArrayAccess<arg5_direct_access_type> (arg5);
1432
1433 VectorizedOperation5<Op,result_access_type,
1434 arg1_masked_access_type,
1435 arg2_direct_access_type,
1436 arg3_masked_access_type,
1437 arg4_masked_access_type,
1438 arg5_direct_access_type>
1439 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
1440 dispatchTask(vop,len);
1441 }
1442 }
1443 else
1444 {
1445 arg4_direct_access_type arg4Access =
1446 getArrayAccess<arg4_direct_access_type> (arg4);
1447
1448 if (any_masked(arg5))
1449 {
1450 arg5_masked_access_type arg5Access =
1451 getArrayAccess<arg5_masked_access_type> (arg5);
1452
1453 VectorizedOperation5<Op,result_access_type,
1454 arg1_masked_access_type,
1455 arg2_direct_access_type,
1456 arg3_masked_access_type,
1457 arg4_direct_access_type,
1458 arg5_masked_access_type>
1459 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
1460 dispatchTask(vop,len);
1461 }
1462 else
1463 {
1464 arg5_direct_access_type arg5Access =
1465 getArrayAccess<arg5_direct_access_type> (arg5);
1466
1467 VectorizedOperation5<Op,result_access_type,
1468 arg1_masked_access_type,
1469 arg2_direct_access_type,
1470 arg3_masked_access_type,
1471 arg4_direct_access_type,
1472 arg5_direct_access_type>
1473 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
1474 dispatchTask(vop,len);
1475 }
1476 }
1477 }
1478 else
1479 {
1480 arg3_direct_access_type arg3Access =
1481 getArrayAccess<arg3_direct_access_type> (arg3);
1482
1483 if (any_masked(arg4))
1484 {
1485 arg4_masked_access_type arg4Access =
1486 getArrayAccess<arg4_masked_access_type> (arg4);
1487
1488 if (any_masked(arg5))
1489 {
1490 arg5_masked_access_type arg5Access =
1491 getArrayAccess<arg5_masked_access_type> (arg5);
1492
1493 VectorizedOperation5<Op,result_access_type,
1494 arg1_masked_access_type,
1495 arg2_direct_access_type,
1496 arg3_direct_access_type,
1497 arg4_masked_access_type,
1498 arg5_masked_access_type>
1499 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
1500 dispatchTask(vop,len);
1501 }
1502 else
1503 {
1504 arg5_direct_access_type arg5Access =
1505 getArrayAccess<arg5_direct_access_type> (arg5);
1506
1507 VectorizedOperation5<Op,result_access_type,
1508 arg1_masked_access_type,
1509 arg2_direct_access_type,
1510 arg3_direct_access_type,
1511 arg4_masked_access_type,
1512 arg5_direct_access_type>
1513 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
1514 dispatchTask(vop,len);
1515 }
1516 }
1517 else
1518 {
1519 arg4_direct_access_type arg4Access =
1520 getArrayAccess<arg4_direct_access_type> (arg4);
1521
1522 if (any_masked(arg5))
1523 {
1524 arg5_masked_access_type arg5Access =
1525 getArrayAccess<arg5_masked_access_type> (arg5);
1526
1527 VectorizedOperation5<Op,result_access_type,
1528 arg1_masked_access_type,
1529 arg2_direct_access_type,
1530 arg3_direct_access_type,
1531 arg4_direct_access_type,
1532 arg5_masked_access_type>
1533 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
1534 dispatchTask(vop,len);
1535 }
1536 else
1537 {
1538 arg5_direct_access_type arg5Access =
1539 getArrayAccess<arg5_direct_access_type> (arg5);
1540
1541 VectorizedOperation5<Op,result_access_type,
1542 arg1_masked_access_type,
1543 arg2_direct_access_type,
1544 arg3_direct_access_type,
1545 arg4_direct_access_type,
1546 arg5_direct_access_type>
1547 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
1548 dispatchTask(vop,len);
1549 }
1550 }
1551 }
1552 }
1553 }
1554 else
1555 {
1556 arg1_direct_access_type arg1Access =
1557 getArrayAccess<arg1_direct_access_type> (arg1);
1558
1559 if (any_masked(arg2))
1560 {
1561 arg2_masked_access_type arg2Access =
1562 getArrayAccess<arg2_masked_access_type> (arg2);
1563
1564 if (any_masked(arg3))
1565 {
1566 arg3_masked_access_type arg3Access =
1567 getArrayAccess<arg3_masked_access_type> (arg3);
1568
1569 if (any_masked(arg4))
1570 {
1571 arg4_masked_access_type arg4Access =
1572 getArrayAccess<arg4_masked_access_type> (arg4);
1573
1574 if (any_masked(arg5))
1575 {
1576 arg5_masked_access_type arg5Access =
1577 getArrayAccess<arg5_masked_access_type> (arg5);
1578
1579 VectorizedOperation5<Op,result_access_type,
1580 arg1_direct_access_type,
1581 arg2_masked_access_type,
1582 arg3_masked_access_type,
1583 arg4_masked_access_type,
1584 arg5_masked_access_type>
1585 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
1586 dispatchTask(vop,len);
1587 }
1588 else
1589 {
1590 arg5_direct_access_type arg5Access =
1591 getArrayAccess<arg5_direct_access_type> (arg5);
1592
1593 VectorizedOperation5<Op,result_access_type,
1594 arg1_direct_access_type,
1595 arg2_masked_access_type,
1596 arg3_masked_access_type,
1597 arg4_masked_access_type,
1598 arg5_direct_access_type>
1599 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
1600 dispatchTask(vop,len);
1601 }
1602 }
1603 else
1604 {
1605 arg4_direct_access_type arg4Access =
1606 getArrayAccess<arg4_direct_access_type> (arg4);
1607
1608 if (any_masked(arg5))
1609 {
1610 arg5_masked_access_type arg5Access =
1611 getArrayAccess<arg5_masked_access_type> (arg5);
1612
1613 VectorizedOperation5<Op,result_access_type,
1614 arg1_direct_access_type,
1615 arg2_masked_access_type,
1616 arg3_masked_access_type,
1617 arg4_direct_access_type,
1618 arg5_masked_access_type>
1619 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
1620 dispatchTask(vop,len);
1621 }
1622 else
1623 {
1624 arg5_direct_access_type arg5Access =
1625 getArrayAccess<arg5_direct_access_type> (arg5);
1626
1627 VectorizedOperation5<Op,result_access_type,
1628 arg1_direct_access_type,
1629 arg2_masked_access_type,
1630 arg3_masked_access_type,
1631 arg4_direct_access_type,
1632 arg5_direct_access_type>
1633 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
1634 dispatchTask(vop,len);
1635 }
1636 }
1637 }
1638 else
1639 {
1640 arg3_direct_access_type arg3Access =
1641 getArrayAccess<arg3_direct_access_type> (arg3);
1642
1643 if (any_masked(arg4))
1644 {
1645 arg4_masked_access_type arg4Access =
1646 getArrayAccess<arg4_masked_access_type> (arg4);
1647
1648 if (any_masked(arg5))
1649 {
1650 arg5_masked_access_type arg5Access =
1651 getArrayAccess<arg5_masked_access_type> (arg5);
1652
1653 VectorizedOperation5<Op,result_access_type,
1654 arg1_direct_access_type,
1655 arg2_masked_access_type,
1656 arg3_direct_access_type,
1657 arg4_masked_access_type,
1658 arg5_masked_access_type>
1659 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
1660 dispatchTask(vop,len);
1661 }
1662 else
1663 {
1664 arg5_direct_access_type arg5Access =
1665 getArrayAccess<arg5_direct_access_type> (arg5);
1666
1667 VectorizedOperation5<Op,result_access_type,
1668 arg1_direct_access_type,
1669 arg2_masked_access_type,
1670 arg3_direct_access_type,
1671 arg4_masked_access_type,
1672 arg5_direct_access_type>
1673 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
1674 dispatchTask(vop,len);
1675 }
1676 }
1677 else
1678 {
1679 arg4_direct_access_type arg4Access =
1680 getArrayAccess<arg4_direct_access_type> (arg4);
1681
1682 if (any_masked(arg5))
1683 {
1684 arg5_masked_access_type arg5Access =
1685 getArrayAccess<arg5_masked_access_type> (arg5);
1686
1687 VectorizedOperation5<Op,result_access_type,
1688 arg1_direct_access_type,
1689 arg2_masked_access_type,
1690 arg3_direct_access_type,
1691 arg4_direct_access_type,
1692 arg5_masked_access_type>
1693 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
1694 dispatchTask(vop,len);
1695 }
1696 else
1697 {
1698 arg5_direct_access_type arg5Access =
1699 getArrayAccess<arg5_direct_access_type> (arg5);
1700
1701 VectorizedOperation5<Op,result_access_type,
1702 arg1_direct_access_type,
1703 arg2_masked_access_type,
1704 arg3_direct_access_type,
1705 arg4_direct_access_type,
1706 arg5_direct_access_type>
1707 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
1708 dispatchTask(vop,len);
1709 }
1710 }
1711 }
1712 }
1713 else
1714 {
1715 arg2_direct_access_type arg2Access =
1716 getArrayAccess<arg2_direct_access_type> (arg2);
1717
1718 if (any_masked(arg3))
1719 {
1720 arg3_masked_access_type arg3Access =
1721 getArrayAccess<arg3_masked_access_type> (arg3);
1722
1723 if (any_masked(arg4))
1724 {
1725 arg4_masked_access_type arg4Access =
1726 getArrayAccess<arg4_masked_access_type> (arg4);
1727
1728 if (any_masked(arg5))
1729 {
1730 arg5_masked_access_type arg5Access =
1731 getArrayAccess<arg5_masked_access_type> (arg5);
1732
1733 VectorizedOperation5<Op,result_access_type,
1734 arg1_direct_access_type,
1735 arg2_direct_access_type,
1736 arg3_masked_access_type,
1737 arg4_masked_access_type,
1738 arg5_masked_access_type>
1739 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
1740 dispatchTask(vop,len);
1741 }
1742 else
1743 {
1744 arg5_direct_access_type arg5Access =
1745 getArrayAccess<arg5_direct_access_type> (arg5);
1746
1747 VectorizedOperation5<Op,result_access_type,
1748 arg1_direct_access_type,
1749 arg2_direct_access_type,
1750 arg3_masked_access_type,
1751 arg4_masked_access_type,
1752 arg5_direct_access_type>
1753 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
1754 dispatchTask(vop,len);
1755 }
1756 }
1757 else
1758 {
1759 arg4_direct_access_type arg4Access =
1760 getArrayAccess<arg4_direct_access_type> (arg4);
1761
1762 if (any_masked(arg5))
1763 {
1764 arg5_masked_access_type arg5Access =
1765 getArrayAccess<arg5_masked_access_type> (arg5);
1766
1767 VectorizedOperation5<Op,result_access_type,
1768 arg1_direct_access_type,
1769 arg2_direct_access_type,
1770 arg3_masked_access_type,
1771 arg4_direct_access_type,
1772 arg5_masked_access_type>
1773 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
1774 dispatchTask(vop,len);
1775 }
1776 else
1777 {
1778 arg5_direct_access_type arg5Access =
1779 getArrayAccess<arg5_direct_access_type> (arg5);
1780
1781 VectorizedOperation5<Op,result_access_type,
1782 arg1_direct_access_type,
1783 arg2_direct_access_type,
1784 arg3_masked_access_type,
1785 arg4_direct_access_type,
1786 arg5_direct_access_type>
1787 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
1788 dispatchTask(vop,len);
1789 }
1790 }
1791 }
1792 else
1793 {
1794 arg3_direct_access_type arg3Access =
1795 getArrayAccess<arg3_direct_access_type> (arg3);
1796
1797 if (any_masked(arg4))
1798 {
1799 arg4_masked_access_type arg4Access =
1800 getArrayAccess<arg4_masked_access_type> (arg4);
1801
1802 if (any_masked(arg5))
1803 {
1804 arg5_masked_access_type arg5Access =
1805 getArrayAccess<arg5_masked_access_type> (arg5);
1806
1807 VectorizedOperation5<Op,result_access_type,
1808 arg1_direct_access_type,
1809 arg2_direct_access_type,
1810 arg3_direct_access_type,
1811 arg4_masked_access_type,
1812 arg5_masked_access_type>
1813 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
1814 dispatchTask(vop,len);
1815 }
1816 else
1817 {
1818 arg5_direct_access_type arg5Access =
1819 getArrayAccess<arg5_direct_access_type> (arg5);
1820
1821 VectorizedOperation5<Op,result_access_type,
1822 arg1_direct_access_type,
1823 arg2_direct_access_type,
1824 arg3_direct_access_type,
1825 arg4_masked_access_type,
1826 arg5_direct_access_type>
1827 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
1828 dispatchTask(vop,len);
1829 }
1830 }
1831 else
1832 {
1833 arg4_direct_access_type arg4Access =
1834 getArrayAccess<arg4_direct_access_type> (arg4);
1835
1836 if (any_masked(arg5))
1837 {
1838 arg5_masked_access_type arg5Access =
1839 getArrayAccess<arg5_masked_access_type> (arg5);
1840
1841 VectorizedOperation5<Op,result_access_type,
1842 arg1_direct_access_type,
1843 arg2_direct_access_type,
1844 arg3_direct_access_type,
1845 arg4_direct_access_type,
1846 arg5_masked_access_type>
1847 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
1848 dispatchTask(vop,len);
1849 }
1850 else
1851 {
1852 arg5_direct_access_type arg5Access =
1853 getArrayAccess<arg5_direct_access_type> (arg5);
1854
1855 VectorizedOperation5<Op,result_access_type,
1856 arg1_direct_access_type,
1857 arg2_direct_access_type,
1858 arg3_direct_access_type,
1859 arg4_direct_access_type,
1860 arg5_direct_access_type>
1861 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access);
1862 dispatchTask(vop,len);
1863 }
1864 }
1865 }
1866 }
1867 }
1868
1869 PY_IMATH_RETURN_PYTHON;
1870 return retval;
1871 }
1872
1873 static std::string
1874 format_arguments(const boost::python::detail::keywords<5> &args)
1875 {
1876 // TODO: add types here
1877 return std::string("(")+args.elements[0].name+","+args.elements[1].name+","+args.elements[2].name+","+args.elements[3].name+","+args.elements[4].name+") - ";
1878 }
1879 };
1880
1881 template <class Op, class Func, class Keywords>
1882 struct function_binding
1883 {
1884 std::string _name, _doc;
1885 const Keywords &_args;
1886
1887
1888 function_binding(const std::string &name, const std::string &doc,const Keywords &args)
1889 : _name(name), _doc(doc), _args(args)
1890 {}
1891
1892 template <class Vectorize>
1893 void operator()(Vectorize) const
1894 {
1895 typedef typename at<vector<
1896 int, // unused, arity 0
1897 VectorizedFunction1<Op,Vectorize,Func>,
1898 VectorizedFunction2<Op,Vectorize,Func>,
1899 VectorizedFunction3<Op,Vectorize,Func>,
1900 VectorizedFunction4<Op,Vectorize,Func>,
1901 VectorizedFunction5<Op,Vectorize,Func>
1902 >,
1903 long_<function_traits<Func>::arity> >::type vectorized_function_type;
1904 std::string doc = _name + vectorized_function_type::format_arguments(_args) + _doc;
1905 boost::python::def(_name.c_str(),&vectorized_function_type::apply,doc.c_str(),_args);
1906 }
1907 };
1908
1909 template <class Op,class Func,class Keywords>
1910 function_binding<Op,Func,Keywords>
1911 build_function_binding(Func *func,const std::string &name,const std::string &doc,const Keywords &args)
1912 {
1913 return function_binding<Op,Func,Keywords>(name,doc,args);
1914 }
1915
1916 template <class Op,class Vectorizable,class Keywords>
1917 struct generate_bindings_struct
1918 {
1919 //BOOST_STATIC_ASSERT(size<Vectorizable>::value == function_traits<Op::apply>::arity);
1920 static void apply(const std::string &name,const std::string &doc,const Keywords &args) {
1921 for_each<typename allowable_vectorizations<Vectorizable>::type>(build_function_binding<Op>(Op::apply,name,doc,args));
1922 }
1923 };
1924
1925
1926 template <class Op, class access_type>
1927 struct VectorizedVoidOperation0 : public Task
1928 {
1929 access_type access;
1930
1931 VectorizedVoidOperation0 (access_type a) : access(a) {}
1932
1933 void execute (size_t start, size_t end)
1934 {
1935 for (size_t i = start; i < end; ++i)
1936 {
1937 Op::apply (access[i]);
1938 }
1939 }
1940 };
1941
1942 template <class Op, class access_type, class arg1_access_type>
1943 struct VectorizedVoidOperation1 : public Task
1944 {
1945 access_type access;
1946 arg1_access_type arg1;
1947
1948 VectorizedVoidOperation1(access_type a, arg1_access_type a1) : access(a), arg1(a1) {}
1949
1950 void execute(size_t start, size_t end)
1951 {
1952 for (size_t i = start; i < end; ++i)
1953 {
1954 Op::apply (access[i], arg1[i]);
1955 }
1956 }
1957 };
1958
1959 template <class Op, class access_type, class arg1_access_type, class array_type>
1960 struct VectorizedMaskedVoidOperation1 : public Task
1961 {
1962 access_type access;
1963 arg1_access_type arg1;
1964 array_type array;
1965
1966 VectorizedMaskedVoidOperation1(access_type a, arg1_access_type a1, array_type arr)
1967 : access(a), arg1(a1), array(arr) {}
1968
1969 void execute(size_t start, size_t end)
1970 {
1971 for (size_t i = start; i < end; ++i)
1972 {
1973 const size_t ri = array.raw_ptr_index(i);
1974 Op::apply (access[i], arg1[ri]);
1975 }
1976 }
1977 };
1978
1979 template <class Op, class access_type, class arg1_access_type, class arg2_access_type>
1980 struct VectorizedVoidOperation2 : public Task
1981 {
1982 access_type access;
1983 arg1_access_type arg1;
1984 arg2_access_type arg2;
1985
1986 VectorizedVoidOperation2(access_type a, arg1_access_type a1, arg2_access_type a2)
1987 : access(a), arg1(a1), arg2(a2) {}
1988
1989 void execute(size_t start, size_t end)
1990 {
1991 for (size_t i = start; i < end; ++i)
1992 {
1993 Op::apply (access[i], arg1[i], arg2[i]);
1994 }
1995 }
1996 };
1997
1998
1999 template <class Op, class Vectorize, class Func>
2000 struct VectorizedVoidMemberFunction0 {
2001 BOOST_STATIC_ASSERT((size<Vectorize>::value+1 == function_traits<Func>::arity));
2002
2003 typedef function_traits<Func> traits;
2004
2005 typedef typename access_type<typename traits::arg1_type>::reference_type reference_type;
2006 typedef typename access_type<typename traits::arg1_type>::direct direct_access_type;
2007 typedef typename access_type<typename traits::arg1_type>::masked masked_access_type;
2008
2009 static reference_type
2010 apply(reference_type array)
2011 {
2012 PY_IMATH_LEAVE_PYTHON;
2013 size_t len = measure_arguments(array);
2014 op_precompute<Op>::apply(len);
2015
2016 if (any_masked(array))
2017 {
2018 masked_access_type access (array);
2019 VectorizedVoidOperation0<Op,masked_access_type> vop (access);
2020 dispatchTask(vop,len);
2021 }
2022 else
2023 {
2024 direct_access_type access (array);
2025 VectorizedVoidOperation0<Op,direct_access_type> vop (access);
2026 dispatchTask(vop,len);
2027 }
2028
2029 PY_IMATH_RETURN_PYTHON;
2030 return array;
2031 }
2032 };
2033
2034 template <class Op, class Vectorize, class Func>
2035 struct VectorizedVoidMemberFunction1 {
2036 BOOST_STATIC_ASSERT((size<Vectorize>::value+1 == function_traits<Func>::arity));
2037
2038 typedef function_traits<Func> traits;
2039
2040 typedef typename access_type<typename traits::arg1_type>::reference_type reference_type;
2041 typedef typename access_type<typename traits::arg1_type>::direct direct_access_type;
2042 typedef typename access_type<typename traits::arg1_type>::masked masked_access_type;
2043
2044 typedef typename argument_access_type<typename traits::arg2_type,
2045 typename at<Vectorize,long_<0> >::type>::type arg1_type;
2046 typedef typename argument_access_type<typename traits::arg2_type,
2047 typename at<Vectorize,long_<0> >::type>::direct arg1_direct_access_type;
2048 typedef typename argument_access_type<typename traits::arg2_type,
2049 typename at<Vectorize,long_<0> >::type>::masked arg1_masked_access_type;
2050
2051 static reference_type
2052 apply(reference_type array, arg1_type arg1)
2053 {
2054 PY_IMATH_LEAVE_PYTHON;
2055 size_t len = measure_arguments(array,arg1);
2056 op_precompute<Op>::apply(len);
2057
2058 if (any_masked(array))
2059 {
2060 masked_access_type arrayAccess (array);
2061
2062 if (any_masked(arg1))
2063 {
2064 arg1_masked_access_type argAccess =
2065 getArrayAccess<arg1_masked_access_type> (arg1);
2066
2067 VectorizedVoidOperation1<Op,masked_access_type,arg1_masked_access_type>
2068 vop (arrayAccess, argAccess);
2069 dispatchTask(vop,len);
2070 }
2071 else
2072 {
2073 arg1_direct_access_type argAccess =
2074 getArrayAccess<arg1_direct_access_type> (arg1);
2075
2076 VectorizedVoidOperation1<Op,masked_access_type,arg1_direct_access_type>
2077 vop (arrayAccess, argAccess);
2078 dispatchTask(vop,len);
2079 }
2080 }
2081 else
2082 {
2083 direct_access_type arrayAccess (array);
2084
2085 if (any_masked(arg1))
2086 {
2087 arg1_masked_access_type argAccess =
2088 getArrayAccess<arg1_masked_access_type> (arg1);
2089
2090 VectorizedVoidOperation1<Op,direct_access_type,arg1_masked_access_type>
2091 vop (arrayAccess, argAccess);
2092 dispatchTask(vop,len);
2093 }
2094 else
2095 {
2096 arg1_direct_access_type argAccess =
2097 getArrayAccess<arg1_direct_access_type> (arg1);
2098
2099 VectorizedVoidOperation1<Op,direct_access_type,arg1_direct_access_type>
2100 vop (arrayAccess, argAccess);
2101 dispatchTask(vop,len);
2102 }
2103 }
2104
2105 PY_IMATH_RETURN_PYTHON;
2106 return array;
2107 }
2108
2109 static std::string
2110 format_arguments(const boost::python::detail::keywords<1> &args)
2111 {
2112 // TODO: add types here
2113 return std::string("(")+args.elements[0].name+") - ";
2114 }
2115 };
2116
2117 //
2118 // special class to handle single argument void memberfunctions, such as those
2119 // used for the inplace operators like +=, -=, etc. In this case we allow additional
2120 // compatibilty between a masked class and an unmasked right hand side, using the
2121 // mask to select results.
2122 //
2123 template <class Op, class Func>
2124 struct VectorizedVoidMaskableMemberFunction1 {
2125 BOOST_STATIC_ASSERT((2 == function_traits<Func>::arity));
2126
2127 typedef function_traits<Func> traits;
2128
2129 typedef typename access_type<typename traits::arg1_type>::reference_type reference_type;
2130 typedef typename access_type<typename traits::arg1_type>::direct direct_access_type;
2131 typedef typename access_type<typename traits::arg1_type>::masked masked_access_type;
2132
2133 typedef typename argument_access_type<typename traits::arg2_type,
2134 boost::mpl::true_>::type arg1_type;
2135 typedef typename argument_access_type<typename traits::arg2_type,
2136 boost::mpl::true_>::direct arg1_direct_access_type;
2137 typedef typename argument_access_type<typename traits::arg2_type,
2138 boost::mpl::true_>::masked arg1_masked_access_type;
2139
2140 static reference_type
2141 apply(reference_type array, arg1_type arg1)
2142 {
2143 PY_IMATH_LEAVE_PYTHON;
2144 size_t len = array.match_dimension(arg1, false);
2145 op_precompute<Op>::apply(len);
2146
2147 if (array.isMaskedReference() && (size_t) arg1.len() == array.unmaskedLength())
2148 {
2149 // class is masked, and the unmasked length matches the right hand side
2150
2151 masked_access_type arrayAccess (array);
2152
2153 if (any_masked(arg1))
2154 {
2155 arg1_masked_access_type argAccess =
2156 getArrayAccess<arg1_masked_access_type> (arg1);
2157
2158 VectorizedMaskedVoidOperation1<Op,masked_access_type,
2159 arg1_masked_access_type,
2160 reference_type>
2161 vop (arrayAccess, argAccess, array);
2162 dispatchTask(vop,len);
2163 }
2164 else
2165 {
2166 arg1_direct_access_type argAccess =
2167 getArrayAccess<arg1_direct_access_type> (arg1);
2168
2169 VectorizedMaskedVoidOperation1<Op,masked_access_type,
2170 arg1_direct_access_type,
2171 reference_type>
2172 vop (arrayAccess, argAccess, array);
2173 dispatchTask(vop,len);
2174 }
2175 }
2176 else
2177 {
2178 // the two arrays match length (masked or otherwise), use the standard path.
2179
2180 if (any_masked(array))
2181 {
2182 masked_access_type arrayAccess (array);
2183
2184 if (any_masked(arg1))
2185 {
2186 arg1_masked_access_type argAccess =
2187 getArrayAccess<arg1_masked_access_type> (arg1);
2188
2189 VectorizedVoidOperation1<Op,masked_access_type,arg1_masked_access_type>
2190 vop (arrayAccess, argAccess);
2191 dispatchTask(vop,len);
2192 }
2193 else
2194 {
2195 arg1_direct_access_type argAccess =
2196 getArrayAccess<arg1_direct_access_type> (arg1);
2197
2198 VectorizedVoidOperation1<Op,masked_access_type,arg1_direct_access_type>
2199 vop (arrayAccess, argAccess);
2200 dispatchTask(vop,len);
2201 }
2202 }
2203 else
2204 {
2205 direct_access_type arrayAccess (array);
2206
2207 if (any_masked(arg1))
2208 {
2209 arg1_masked_access_type argAccess =
2210 getArrayAccess<arg1_masked_access_type> (arg1);
2211
2212 VectorizedVoidOperation1<Op,direct_access_type,arg1_masked_access_type>
2213 vop (arrayAccess, argAccess);
2214 dispatchTask(vop,len);
2215 }
2216 else
2217 {
2218 arg1_direct_access_type argAccess =
2219 getArrayAccess<arg1_direct_access_type> (arg1);
2220
2221 VectorizedVoidOperation1<Op,direct_access_type,arg1_direct_access_type>
2222 vop (arrayAccess, argAccess);
2223 dispatchTask(vop,len);
2224 }
2225 }
2226 }
2227
2228 PY_IMATH_RETURN_PYTHON;
2229 return array;
2230 }
2231
2232 static std::string
2233 format_arguments(const boost::python::detail::keywords<1> &args)
2234 {
2235 // TODO: add types here
2236 return std::string("(")+args.elements[0].name+") - ";
2237 }
2238 };
2239
2240 template <class Op, class Vectorize, class Func>
2241 struct VectorizedVoidMemberFunction2 {
2242 BOOST_STATIC_ASSERT((size<Vectorize>::value+1 == function_traits<Func>::arity));
2243
2244 typedef function_traits<Func> traits;
2245
2246 typedef typename access_type<typename traits::arg1_type>::reference_type reference_type;
2247 typedef typename access_type<typename traits::arg1_type>::direct direct_access_type;
2248 typedef typename access_type<typename traits::arg1_type>::masked masked_access_type;
2249
2250 typedef typename argument_access_type<typename traits::arg2_type,
2251 typename at<Vectorize,long_<0> >::type>::type arg1_type;
2252 typedef typename argument_access_type<typename traits::arg2_type,
2253 typename at<Vectorize,long_<0> >::type>::direct arg1_direct_access_type;
2254 typedef typename argument_access_type<typename traits::arg2_type,
2255 typename at<Vectorize,long_<0> >::type>::masked arg1_masked_access_type;
2256
2257 typedef typename argument_access_type<typename traits::arg3_type,
2258 typename at<Vectorize,long_<1> >::type>::type arg2_type;
2259 typedef typename argument_access_type<typename traits::arg3_type,
2260 typename at<Vectorize,long_<1> >::type>::direct arg2_direct_access_type;
2261 typedef typename argument_access_type<typename traits::arg3_type,
2262 typename at<Vectorize,long_<1> >::type>::masked arg2_masked_access_type;
2263
2264 static reference_type
2265 apply(reference_type array, arg1_type arg1, arg2_type arg2)
2266 {
2267 PY_IMATH_LEAVE_PYTHON;
2268 size_t len = measure_arguments(array,arg1,arg2);
2269 op_precompute<Op>::apply(len);
2270
2271 if (any_masked(array))
2272 {
2273 masked_access_type arrayAccess (array);
2274
2275 if (any_masked(arg1))
2276 {
2277 arg1_masked_access_type arg1Access =
2278 getArrayAccess<arg1_masked_access_type> (arg1);
2279
2280 if (any_masked(arg2))
2281 {
2282 arg2_masked_access_type arg2Access =
2283 getArrayAccess<arg2_masked_access_type> (arg2);
2284
2285 VectorizedVoidOperation2<Op,masked_access_type,
2286 arg1_masked_access_type,
2287 arg2_masked_access_type>
2288 vop (arrayAccess, arg1Access, arg2Access);
2289 dispatchTask(vop,len);
2290 }
2291 else
2292 {
2293 arg2_direct_access_type arg2Access =
2294 getArrayAccess<arg2_direct_access_type> (arg2);
2295
2296 VectorizedVoidOperation2<Op,masked_access_type,
2297 arg1_masked_access_type,
2298 arg2_direct_access_type>
2299 vop (arrayAccess, arg1Access, arg2Access);
2300 dispatchTask(vop,len);
2301 }
2302 }
2303 else
2304 {
2305 arg1_direct_access_type arg1Access =
2306 getArrayAccess<arg1_direct_access_type> (arg1);
2307
2308 if (any_masked(arg2))
2309 {
2310 arg2_masked_access_type arg2Access =
2311 getArrayAccess<arg2_masked_access_type> (arg2);
2312
2313 VectorizedVoidOperation2<Op,masked_access_type,
2314 arg1_direct_access_type,
2315 arg2_masked_access_type>
2316 vop (arrayAccess, arg1Access, arg2Access);
2317 dispatchTask(vop,len);
2318 }
2319 else
2320 {
2321 arg2_direct_access_type arg2Access =
2322 getArrayAccess<arg2_direct_access_type> (arg2);
2323
2324 VectorizedVoidOperation2<Op,masked_access_type,
2325 arg1_direct_access_type,
2326 arg2_direct_access_type>
2327 vop (arrayAccess, arg1Access, arg2Access);
2328 dispatchTask(vop,len);
2329 }
2330 }
2331 }
2332 else
2333 {
2334 direct_access_type arrayAccess (array);
2335
2336 if (any_masked(arg1))
2337 {
2338 arg1_masked_access_type arg1Access =
2339 getArrayAccess<arg1_masked_access_type> (arg1);
2340
2341 if (any_masked(arg2))
2342 {
2343 arg2_masked_access_type arg2Access =
2344 getArrayAccess<arg2_masked_access_type> (arg2);
2345
2346 VectorizedVoidOperation2<Op,direct_access_type,
2347 arg1_masked_access_type,
2348 arg2_masked_access_type>
2349 vop (arrayAccess, arg1Access, arg2Access);
2350 dispatchTask(vop,len);
2351 }
2352 else
2353 {
2354 arg2_direct_access_type arg2Access =
2355 getArrayAccess<arg2_direct_access_type> (arg2);
2356
2357 VectorizedVoidOperation2<Op,direct_access_type,
2358 arg1_masked_access_type,
2359 arg2_direct_access_type>
2360 vop (arrayAccess, arg1Access, arg2Access);
2361 dispatchTask(vop,len);
2362 }
2363 }
2364 else
2365 {
2366 arg1_direct_access_type arg1Access =
2367 getArrayAccess<arg1_direct_access_type> (arg1);
2368
2369 if (any_masked(arg2))
2370 {
2371 arg2_masked_access_type arg2Access =
2372 getArrayAccess<arg2_masked_access_type> (arg2);
2373
2374 VectorizedVoidOperation2<Op,direct_access_type,
2375 arg1_direct_access_type,
2376 arg2_masked_access_type>
2377 vop (arrayAccess, arg1Access, arg2Access);
2378 dispatchTask(vop,len);
2379 }
2380 else
2381 {
2382 arg2_direct_access_type arg2Access =
2383 getArrayAccess<arg2_direct_access_type> (arg2);
2384
2385 VectorizedVoidOperation2<Op,direct_access_type,
2386 arg1_direct_access_type,
2387 arg2_direct_access_type>
2388 vop (arrayAccess, arg1Access, arg2Access);
2389 dispatchTask(vop,len);
2390 }
2391 }
2392 }
2393
2394 PY_IMATH_RETURN_PYTHON;
2395 return array;
2396 }
2397
2398 static std::string
2399 format_arguments(const boost::python::detail::keywords<2> &args)
2400 {
2401 // TODO: add types here
2402 return std::string("(")+args.elements[0].name+","+args.elements[1].name+") - ";
2403 }
2404 };
2405
2406
2407 template <class Op, class Vectorize, class Func>
2408 struct VectorizedMemberFunction0 {
2409 BOOST_STATIC_ASSERT((size<Vectorize>::value+1 == function_traits<Func>::arity));
2410
2411 typedef function_traits<Func> traits;
2412
2413 typedef typename vectorized_result_type<typename traits::result_type,true_>::type result_type;
2414
2415 typedef typename access_type<typename traits::arg1_type>::reference_type reference_type;
2416 typedef typename access_type<typename traits::arg1_type>::direct direct_access_type;
2417 typedef typename access_type<typename traits::arg1_type>::masked masked_access_type;
2418
2419 // The return value can't be const or masked. Verify that condition.
2420 BOOST_STATIC_ASSERT( !is_const<result_type>::value );
2421 typedef typename result_type::WritableDirectAccess result_access_type;
2422
2423 static result_type
2424 apply(reference_type array)
2425 {
2426 PY_IMATH_LEAVE_PYTHON;
2427 size_t len = measure_arguments(array);
2428 op_precompute<Op>::apply(len);
2429 result_type retval = create_uninitalized_return_value<result_type>::apply(len);
2430
2431 result_access_type returnAccess (retval);
2432
2433 if (any_masked(array))
2434 {
2435 masked_access_type access (array);
2436 VectorizedOperation1<Op,result_access_type,masked_access_type> vop(returnAccess,access);
2437 dispatchTask(vop,len);
2438 }
2439 else
2440 {
2441 direct_access_type access (array);
2442 VectorizedOperation1<Op,result_access_type,direct_access_type> vop(returnAccess,access);
2443 dispatchTask(vop,len);
2444 }
2445
2446 PY_IMATH_RETURN_PYTHON;
2447 return retval;
2448 }
2449 };
2450
2451 template <class Op, class Vectorize, class Func>
2452 struct VectorizedMemberFunction1 {
2453 BOOST_STATIC_ASSERT((size<Vectorize>::value+1 == function_traits<Func>::arity));
2454
2455 typedef function_traits<Func> traits;
2456
2457 typedef typename vectorized_result_type<typename traits::result_type,true_>::type result_type;
2458
2459 typedef typename access_type<typename traits::arg1_type>::reference_type reference_type;
2460 typedef typename access_type<typename traits::arg1_type>::direct direct_access_type;
2461 typedef typename access_type<typename traits::arg1_type>::masked masked_access_type;
2462
2463 typedef typename argument_access_type<typename traits::arg2_type,
2464 typename at<Vectorize,long_<0> >::type>::type arg1_type;
2465 typedef typename argument_access_type<typename traits::arg2_type,
2466 typename at<Vectorize,long_<0> >::type>::direct arg1_direct_access_type;
2467 typedef typename argument_access_type<typename traits::arg2_type,
2468 typename at<Vectorize,long_<0> >::type>::masked arg1_masked_access_type;
2469
2470 // The return value can't be const or masked. Verify that condition.
2471 BOOST_STATIC_ASSERT( !is_const<result_type>::value );
2472 typedef typename result_type::WritableDirectAccess result_access_type;
2473
2474 static result_type
2475 apply(reference_type array, arg1_type arg1)
2476 {
2477 PY_IMATH_LEAVE_PYTHON;
2478 size_t len = measure_arguments(array,arg1);
2479 op_precompute<Op>::apply(len);
2480 result_type retval = create_uninitalized_return_value<result_type>::apply(len);
2481
2482 result_access_type returnAccess (retval);
2483
2484 if (any_masked(array))
2485 {
2486 masked_access_type access (array);
2487
2488 if (any_masked(arg1))
2489 {
2490 arg1_masked_access_type argAccess =
2491 getArrayAccess<arg1_masked_access_type> (arg1);
2492
2493 VectorizedOperation2<Op,result_access_type,
2494 masked_access_type,
2495 arg1_masked_access_type> vop (returnAccess, access, argAccess);
2496 dispatchTask(vop,len);
2497 }
2498 else
2499 {
2500 arg1_direct_access_type argAccess =
2501 getArrayAccess<arg1_direct_access_type> (arg1);
2502
2503 VectorizedOperation2<Op,result_access_type,
2504 masked_access_type,
2505 arg1_direct_access_type> vop (returnAccess, access, argAccess);
2506 dispatchTask(vop,len);
2507 }
2508 }
2509 else
2510 {
2511 direct_access_type access (array);
2512
2513 if (any_masked(arg1))
2514 {
2515 arg1_masked_access_type argAccess =
2516 getArrayAccess<arg1_masked_access_type> (arg1);
2517
2518 VectorizedOperation2<Op,result_access_type,
2519 direct_access_type,
2520 arg1_masked_access_type> vop (returnAccess, access, argAccess);
2521 dispatchTask(vop,len);
2522 }
2523 else
2524 {
2525 arg1_direct_access_type argAccess =
2526 getArrayAccess<arg1_direct_access_type> (arg1);
2527
2528 VectorizedOperation2<Op,result_access_type,
2529 direct_access_type,
2530 arg1_direct_access_type> vop (returnAccess, access, argAccess);
2531 dispatchTask(vop,len);
2532 }
2533 }
2534
2535 PY_IMATH_RETURN_PYTHON;
2536 return retval;
2537 }
2538
2539 static std::string
2540 format_arguments(const boost::python::detail::keywords<1> &args)
2541 {
2542 // TODO: add types here
2543 return std::string("(")+args.elements[0].name+") - ";
2544 }
2545 };
2546
2547 template <class Op, class Vectorize, class Func>
2548 struct VectorizedMemberFunction2 {
2549 BOOST_STATIC_ASSERT((size<Vectorize>::value+1 == function_traits<Func>::arity));
2550
2551 typedef function_traits<Func> traits;
2552
2553 typedef typename vectorized_result_type<typename traits::result_type,true_>::type result_type;
2554
2555 typedef typename access_type<typename traits::arg1_type>::reference_type reference_type;
2556 typedef typename access_type<typename traits::arg1_type>::direct direct_access_type;
2557 typedef typename access_type<typename traits::arg1_type>::masked masked_access_type;
2558
2559 typedef typename argument_access_type<typename traits::arg2_type,
2560 typename at<Vectorize,long_<0> >::type>::type arg1_type;
2561 typedef typename argument_access_type<typename traits::arg2_type,
2562 typename at<Vectorize,long_<0> >::type>::direct arg1_direct_access_type;
2563 typedef typename argument_access_type<typename traits::arg2_type,
2564 typename at<Vectorize,long_<0> >::type>::masked arg1_masked_access_type;
2565
2566 typedef typename argument_access_type<typename traits::arg3_type,
2567 typename at<Vectorize,long_<1> >::type>::type arg2_type;
2568 typedef typename argument_access_type<typename traits::arg3_type,
2569 typename at<Vectorize,long_<1> >::type>::direct arg2_direct_access_type;
2570 typedef typename argument_access_type<typename traits::arg3_type,
2571 typename at<Vectorize,long_<1> >::type>::masked arg2_masked_access_type;
2572
2573 // The return value can't be const or masked. Verify that condition.
2574 BOOST_STATIC_ASSERT( !is_const<result_type>::value );
2575 typedef typename result_type::WritableDirectAccess result_access_type;
2576
2577 static result_type
2578 apply(reference_type array, arg1_type arg1, arg2_type arg2)
2579 {
2580 PY_IMATH_LEAVE_PYTHON;
2581 size_t len = measure_arguments(array,arg1,arg2);
2582 op_precompute<Op>::apply(len);
2583 result_type retval = create_uninitalized_return_value<result_type>::apply(len);
2584
2585 result_access_type returnAccess (retval);
2586
2587 if (any_masked(array))
2588 {
2589 masked_access_type access (array);
2590
2591 if (any_masked(arg1))
2592 {
2593 arg1_masked_access_type arg1Access =
2594 getArrayAccess<arg1_masked_access_type> (arg1);
2595
2596 if (any_masked(arg2))
2597 {
2598 arg2_masked_access_type arg2Access =
2599 getArrayAccess<arg2_masked_access_type> (arg2);
2600
2601 VectorizedOperation3<Op,result_access_type,
2602 masked_access_type,
2603 arg1_masked_access_type,
2604 arg2_masked_access_type>
2605 vop (returnAccess, access, arg1Access, arg2Access);
2606 dispatchTask(vop,len);
2607 }
2608 else
2609 {
2610 arg2_direct_access_type arg2Access =
2611 getArrayAccess<arg2_direct_access_type> (arg2);
2612
2613 VectorizedOperation3<Op,result_access_type,
2614 masked_access_type,
2615 arg1_masked_access_type,
2616 arg2_direct_access_type>
2617 vop (returnAccess, access, arg1Access, arg2Access);
2618 dispatchTask(vop,len);
2619 }
2620 }
2621 else
2622 {
2623 arg1_direct_access_type arg1Access =
2624 getArrayAccess<arg1_direct_access_type> (arg1);
2625
2626 if (any_masked(arg2))
2627 {
2628 arg2_masked_access_type arg2Access =
2629 getArrayAccess<arg2_masked_access_type> (arg2);
2630
2631 VectorizedOperation3<Op,result_access_type,
2632 masked_access_type,
2633 arg1_direct_access_type,
2634 arg2_masked_access_type>
2635 vop (returnAccess, access, arg1Access, arg2Access);
2636 dispatchTask(vop,len);
2637 }
2638 else
2639 {
2640 arg2_direct_access_type arg2Access =
2641 getArrayAccess<arg2_direct_access_type> (arg2);
2642
2643 VectorizedOperation3<Op,result_access_type,
2644 masked_access_type,
2645 arg1_direct_access_type,
2646 arg2_direct_access_type>
2647 vop (returnAccess, access, arg1Access, arg2Access);
2648 dispatchTask(vop,len);
2649 }
2650 }
2651 }
2652 else
2653 {
2654 direct_access_type access (array);
2655
2656 if (any_masked(arg1))
2657 {
2658 arg1_masked_access_type arg1Access =
2659 getArrayAccess<arg1_masked_access_type> (arg1);
2660
2661 if (any_masked(arg2))
2662 {
2663 arg2_masked_access_type arg2Access =
2664 getArrayAccess<arg2_masked_access_type> (arg2);
2665
2666 VectorizedOperation3<Op,result_access_type,
2667 direct_access_type,
2668 arg1_masked_access_type,
2669 arg2_masked_access_type>
2670 vop (returnAccess, access, arg1Access, arg2Access);
2671 dispatchTask(vop,len);
2672 }
2673 else
2674 {
2675 arg2_direct_access_type arg2Access =
2676 getArrayAccess<arg2_direct_access_type> (arg2);
2677
2678 VectorizedOperation3<Op,result_access_type,
2679 direct_access_type,
2680 arg1_masked_access_type,
2681 arg2_direct_access_type>
2682 vop (returnAccess, access, arg1Access, arg2Access);
2683 dispatchTask(vop,len);
2684 }
2685 }
2686 else
2687 {
2688 arg1_direct_access_type arg1Access =
2689 getArrayAccess<arg1_direct_access_type> (arg1);
2690
2691 if (any_masked(arg2))
2692 {
2693 arg2_masked_access_type arg2Access =
2694 getArrayAccess<arg2_masked_access_type> (arg2);
2695
2696 VectorizedOperation3<Op,result_access_type,
2697 direct_access_type,
2698 arg1_direct_access_type,
2699 arg2_masked_access_type>
2700 vop (returnAccess, access, arg1Access, arg2Access);
2701 dispatchTask(vop,len);
2702 }
2703 else
2704 {
2705 arg2_direct_access_type arg2Access =
2706 getArrayAccess<arg2_direct_access_type> (arg2);
2707
2708 VectorizedOperation3<Op,result_access_type,
2709 direct_access_type,
2710 arg1_direct_access_type,
2711 arg2_direct_access_type>
2712 vop (returnAccess, access, arg1Access, arg2Access);
2713 dispatchTask(vop,len);
2714 }
2715 }
2716 }
2717
2718 PY_IMATH_RETURN_PYTHON;
2719 return retval;
2720 }
2721
2722 static std::string
2723 format_arguments(const boost::python::detail::keywords<2> &args)
2724 {
2725 // TODO: add types here
2726 return std::string("(")+args.elements[0].name+","+args.elements[1].name+") - ";
2727 }
2728 };
2729
2730 template <class Op, class Cls, class Func, class Keywords>
2731 struct member_function_binding
2732 {
2733 Cls &_cls;
2734 std::string _name, _doc;
2735 const Keywords &_args;
2736
2737 member_function_binding(Cls &cls,const std::string &name, const std::string &doc,const Keywords &args)
2738 : _cls(cls), _name(name), _doc(doc), _args(args)
2739 {}
2740
2741 template <class Vectorize>
2742 void operator()(Vectorize) const
2743 {
2744 typedef typename if_<is_same<void,typename function_traits<Func>::result_type>,
2745 typename if_<boost::mpl::equal<Vectorize,boost::mpl::vector<boost::mpl::true_> >,
2746 VectorizedVoidMaskableMemberFunction1<Op,Func>,
2747 VectorizedVoidMemberFunction1<Op,Vectorize,Func> >::type,
2748 VectorizedMemberFunction1<Op,Vectorize,Func>
2749 >::type member_func1_type;
2750
2751 typedef typename if_<is_same<void,typename function_traits<Func>::result_type>,
2752 VectorizedVoidMemberFunction2<Op,Vectorize,Func>,
2753 VectorizedMemberFunction2<Op,Vectorize,Func> >::type member_func2_type;
2754
2755 typedef typename if_<is_same<void,typename function_traits<Func>::result_type>,
2756 boost::python::return_internal_reference<>, // the void vectorizations return a reference to self
2757 boost::python::default_call_policies>::type call_policies;
2758
2759 typedef typename at<vector<
2760 int, // unused, arity 0
2761 int, // unused, arity 1 - first argument corresponds to the class type
2762 member_func1_type,
2763 member_func2_type
2764 >,
2765 long_<function_traits<Func>::arity> >::type vectorized_function_type;
2766 std::string doc = _name + vectorized_function_type::format_arguments(_args) + _doc;
2767 _cls.def(_name.c_str(),&vectorized_function_type::apply,doc.c_str(),_args,call_policies());
2768 }
2769 };
2770
2771 template <class Op,class Cls,class Func,class Keywords>
2772 member_function_binding<Op,Cls,Func,Keywords>
2773 build_member_function_binding(Cls &cls,Func *func,const std::string &name,const std::string &doc,const Keywords &args)
2774 {
2775 return member_function_binding<Op,Cls,Func,Keywords>(cls,name,doc,args);
2776 }
2777
2778 template <class Op,class Cls,class Vectorizable,class Keywords>
2779 struct generate_member_bindings_struct
2780 {
2781 //BOOST_STATIC_ASSERT(size<Vectorizable>::value+1 == function_traits<Op::apply>::arity);
2782 static void apply(Cls &cls,const std::string &name,const std::string &doc,const Keywords &args) {
2783 for_each<typename allowable_vectorizations<Vectorizable>::type>(build_member_function_binding<Op>(cls,Op::apply,name,doc,args));
2784 }
2785 };
2786
2787 template <class Op,class Cls,class Func>
2788 void
2789 generate_single_member_binding(Cls &cls,Func *func,const std::string &name,const std::string &doc)
2790 {
2791 typedef typename if_<is_same<void,typename function_traits<Func>::result_type>,
2792 VectorizedVoidMemberFunction0<Op,boost::mpl::vector<>,Func>,
2793 VectorizedMemberFunction0<Op,boost::mpl::vector<>,Func> >::type vectorized_function_type;
2794
2795 typedef typename if_<is_same<void,typename function_traits<Func>::result_type>,
2796 boost::python::return_internal_reference<>, // the void vectorizations return a reference to self
2797 boost::python::default_call_policies>::type call_policies;
2798
2799 cls.def(name.c_str(),&vectorized_function_type::apply,doc.c_str(),call_policies());
2800 }
2801
2802 } // namespace detail
2803
2804 // TODO: update for arg("name")=default_value syntax
2805 template <class Op,class Vectorizable0>
2806 void generate_bindings(const std::string &name,const std::string &doc,const boost::python::detail::keywords<1> &args) {
2807 using namespace detail;
2808 generate_bindings_struct<Op,vector<Vectorizable0>,boost::python::detail::keywords<1> >::apply(name,doc,args);
2809 }
2810
2811 template <class Op,class Vectorizable0, class Vectorizable1>
2812 void generate_bindings(const std::string &name,const std::string &doc,const boost::python::detail::keywords<2> &args) {
2813 using namespace detail;
2814 generate_bindings_struct<Op,vector<Vectorizable0,Vectorizable1>,boost::python::detail::keywords<2> >::apply(name,doc,args);
2815 }
2816
2817 template <class Op,class Vectorizable0, class Vectorizable1, class Vectorizable2>
2818 void generate_bindings(const std::string &name,const std::string &doc,const boost::python::detail::keywords<3> &args) {
2819 using namespace detail;
2820 generate_bindings_struct<Op,vector<Vectorizable0,Vectorizable1,Vectorizable2>,boost::python::detail::keywords<3> >::apply(name,doc,args);
2821 }
2822
2823 template <class Op,class Vectorizable0, class Vectorizable1, class Vectorizable2, class Vectorizable3>
2824 void generate_bindings(const std::string &name,const std::string &doc,const boost::python::detail::keywords<4> &args) {
2825 using namespace detail;
2826 generate_bindings_struct<Op,vector<Vectorizable0,Vectorizable1,Vectorizable2,Vectorizable3>,boost::python::detail::keywords<4> >::apply(name,doc,args);
2827 }
2828
2829 template <class Op,class Vectorizable0, class Vectorizable1, class Vectorizable2, class Vectorizable3, class Vectorizable4>
2830 void generate_bindings(const std::string &name,const std::string &doc,const boost::python::detail::keywords<5> &args) {
2831 using namespace detail;
2832 generate_bindings_struct<Op,vector<Vectorizable0,Vectorizable1,Vectorizable2,Vectorizable3,Vectorizable4>,boost::python::detail::keywords<5> >::apply(name,doc,args);
2833 }
2834
2835 template <class Op,class Cls>
2836 void
2837 generate_member_bindings(Cls &cls,const std::string &name,const std::string &doc)
2838 {
2839 using namespace detail;
2840 generate_single_member_binding<Op>(cls,&Op::apply,name,doc);
2841 }
2842
2843 template <class Op,class Vectorizable0,class Cls>
2844 void
2845 generate_member_bindings(Cls &cls,const std::string &name,const std::string &doc,
2846 const boost::python::detail::keywords<1> &args)
2847 {
2848 using boost::mpl::vector;
2849 detail::generate_member_bindings_struct<Op,Cls,vector<Vectorizable0>,
2850 boost::python::detail::keywords<1> >::apply(cls,name,doc,args);
2851 }
2852
2853 template <class Op,class Vectorizable0,class Vectorizable1,class Cls>
2854 void
2855 generate_member_bindings(Cls &cls,const std::string &name,const std::string &doc,
2856 const boost::python::detail::keywords<2> &args)
2857 {
2858 using boost::mpl::vector;
2859 detail::generate_member_bindings_struct<Op,Cls,vector<Vectorizable0,Vectorizable1>,
2860 boost::python::detail::keywords<2> >::apply(cls,name,doc,args);
2861 }
2862
2863 } // namespace PyImath
2864
2865 #endif // _PyImathAutovectorize_h_