HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
PyImathAutovectorize.h
Go to the documentation of this file.
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 HBOOST_BIND_GLOBAL_PLACEHOLDERS
14 #include <hboost/python.hpp>
15 #include <hboost/mpl/size.hpp>
16 #include <hboost/mpl/pop_front.hpp>
17 #include <hboost/mpl/push_front.hpp>
18 #include <hboost/mpl/front.hpp>
19 #include <hboost/mpl/eval_if.hpp>
20 #include <hboost/mpl/bool.hpp>
21 #include <hboost/mpl/vector.hpp>
22 #include <hboost/mpl/transform.hpp>
23 #include <hboost/mpl/remove_if.hpp>
24 #include <hboost/mpl/equal.hpp>
25 #include <hboost/mpl/for_each.hpp>
26 #include <hboost/mpl/not.hpp>
27 //#include <hboost/mpl/count.hpp>
28 #include <hboost/mpl/or.hpp>
29 #include <hboost/type_traits/is_base_of.hpp>
30 #include <hboost/type_traits/function_traits.hpp>
31 #include <hboost/static_assert.hpp>
32 #include <hboost/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 hboost::is_base_of;
45 using hboost::is_same;
46 using hboost::is_const;
47 using hboost::remove_const;
48 using hboost::remove_reference;
49 using hboost::function_traits;
50 
51 using hboost::mpl::at;
52 using hboost::mpl::at_c;
53 using hboost::mpl::push_front;
54 using hboost::mpl::vector;
55 using hboost::mpl::push_back;
56 using hboost::mpl::transform;
57 using hboost::mpl::fold;
58 using hboost::mpl::_;
59 using hboost::mpl::_1;
60 using hboost::mpl::_2;
61 using hboost::mpl::long_;
62 using hboost::mpl::false_;
63 using hboost::mpl::true_;
64 using hboost::mpl::not_;
65 using hboost::mpl::or_;
66 using hboost::mpl::and_;
67 using hboost::mpl::size;
68 using hboost::mpl::remove_if;
69 using hboost::mpl::if_;
70 using hboost::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  HBOOST_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 hboost::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  HBOOST_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 hboost::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  HBOOST_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 hboost::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  HBOOST_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 hboost::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  HBOOST_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 hboost::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  hboost::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  //HBOOST_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  HBOOST_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  HBOOST_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 hboost::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  HBOOST_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  hboost::mpl::true_>::type arg1_type;
2135  typedef typename argument_access_type<typename traits::arg2_type,
2136  hboost::mpl::true_>::direct arg1_direct_access_type;
2137  typedef typename argument_access_type<typename traits::arg2_type,
2138  hboost::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 hboost::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  HBOOST_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 hboost::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  HBOOST_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  HBOOST_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  HBOOST_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  HBOOST_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 hboost::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  HBOOST_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  HBOOST_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 hboost::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_<hboost::mpl::equal<Vectorize,hboost::mpl::vector<hboost::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  hboost::python::return_internal_reference<>, // the void vectorizations return a reference to self
2757  hboost::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  //HBOOST_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,hboost::mpl::vector<>,Func>,
2793  VectorizedMemberFunction0<Op,hboost::mpl::vector<>,Func> >::type vectorized_function_type;
2794 
2795  typedef typename if_<is_same<void,typename function_traits<Func>::result_type>,
2796  hboost::python::return_internal_reference<>, // the void vectorizations return a reference to self
2797  hboost::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 hboost::python::detail::keywords<1> &args) {
2807  using namespace detail;
2808  generate_bindings_struct<Op,vector<Vectorizable0>,hboost::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 hboost::python::detail::keywords<2> &args) {
2813  using namespace detail;
2814  generate_bindings_struct<Op,vector<Vectorizable0,Vectorizable1>,hboost::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 hboost::python::detail::keywords<3> &args) {
2819  using namespace detail;
2820  generate_bindings_struct<Op,vector<Vectorizable0,Vectorizable1,Vectorizable2>,hboost::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 hboost::python::detail::keywords<4> &args) {
2825  using namespace detail;
2826  generate_bindings_struct<Op,vector<Vectorizable0,Vectorizable1,Vectorizable2,Vectorizable3>,hboost::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 hboost::python::detail::keywords<5> &args) {
2831  using namespace detail;
2832  generate_bindings_struct<Op,vector<Vectorizable0,Vectorizable1,Vectorizable2,Vectorizable3,Vectorizable4>,hboost::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 hboost::python::detail::keywords<1> &args)
2847 {
2848  using hboost::mpl::vector;
2849  detail::generate_member_bindings_struct<Op,Cls,vector<Vectorizable0>,
2850  hboost::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 hboost::python::detail::keywords<2> &args)
2857 {
2858  using hboost::mpl::vector;
2859  detail::generate_member_bindings_struct<Op,Cls,vector<Vectorizable0,Vectorizable1>,
2860  hboost::python::detail::keywords<2> >::apply(cls,name,doc,args);
2861 }
2862 
2863 } // namespace PyImath
2864 
2865 #endif // _PyImathAutovectorize_h_
PyImath::detail::VectorizedFunction5::any_vectorized
fold< Vectorize, false_, or_< _, _ > >::type any_vectorized
Definition: PyImathAutovectorize.h:1187
detail::type
type
Definition: core.h:556
PyImath::detail::VectorizedVoidMemberFunction1::arg1_masked_access_type
argument_access_type< typename traits::arg2_type, typename at< Vectorize, long_< 0 > >::type >::masked arg1_masked_access_type
Definition: PyImathAutovectorize.h:2049
PyImath::detail::argument_access_type::_class_type
if_< VectorizeArg, typename remove_reference< type >::type, SimpleNonArrayWrapper< base_type > >::type _class_type
Definition: PyImathAutovectorize.h:332
PyImath::detail::possible_vectorizations< 0 >::type
vector< vector<> > type
Definition: PyImathAutovectorize.h:101
PyImath::detail::possible_vectorizations::type
fold< typename possible_vectorizations< N-1 >::type, vector<>, push_back< push_back< _1, push_back< _2, false_ > >, push_back< _2, true_ > > >::type type
Definition: PyImathAutovectorize.h:95
PyImath::detail::VectorizedFunction4::arg1_type
argument_access_type< typename traits::arg1_type, typename at< Vectorize, long_< 0 > >::type >::type arg1_type
Definition: PyImathAutovectorize.h:841
PyImath::detail::VectorizedFunction2::arg1_masked_access_type
argument_access_type< typename traits::arg1_type, typename at< Vectorize, long_< 0 > >::type >::masked arg1_masked_access_type
Definition: PyImathAutovectorize.h:550
PyImath::detail::measure_arguments
size_t measure_arguments(const arg1_type &arg1)
Definition: PyImathAutovectorize.h:198
PyImath::detail::member_function_binding::_doc
std::string _doc
Definition: PyImathAutovectorize.h:2734
int
typedef int(APIENTRYP RE_PFNGLXSWAPINTERVALSGIPROC)(int)
PyImath::detail::VectorizedVoidOperation2::VectorizedVoidOperation2
VectorizedVoidOperation2(access_type a, arg1_access_type a1, arg2_access_type a2)
Definition: PyImathAutovectorize.h:1986
PyImath::detail::null_precomputation
Definition: PyImathAutovectorize.h:73
PyImath::detail::disallow_vectorization::apply
Definition: PyImathAutovectorize.h:108
PyImath::detail::VectorizedOperation1::VectorizedOperation1
VectorizedOperation1(result_access_type r, access_type a1)
Definition: PyImathAutovectorize.h:371
PyImath::detail::build_function_binding
function_binding< Op, Func, Keywords > build_function_binding(Func *func, const std::string &name, const std::string &doc, const Keywords &args)
Definition: PyImathAutovectorize.h:1911
PyImath::detail::result_access_type::masked
_class_type::WritableMaskedAccess masked
Definition: PyImathAutovectorize.h:347
PyImath::FixedArray::isMaskedReference
bool isMaskedReference() const
Definition: PyImathFixedArray.h:628
PyImath::detail::VectorizedFunction5::format_arguments
static std::string format_arguments(const hboost::python::detail::keywords< 5 > &args)
Definition: PyImathAutovectorize.h:1874
PyImath::detail::VectorizedFunction5::arg1_direct_access_type
argument_access_type< typename traits::arg1_type, typename at< Vectorize, long_< 0 > >::type >::direct arg1_direct_access_type
Definition: PyImathAutovectorize.h:1198
PyImath::FixedArray::len
Py_ssize_t len() const
Definition: PyImathFixedArray.h:576
PyImath::detail::VectorizedVoidOperation1::VectorizedVoidOperation1
VectorizedVoidOperation1(access_type a, arg1_access_type a1)
Definition: PyImathAutovectorize.h:1948
PyImath::detail::VectorizedMemberFunction1::masked_access_type
access_type< typename traits::arg1_type >::masked masked_access_type
Definition: PyImathAutovectorize.h:2461
PyImath::detail::access_type::masked
if_< is_const< prim_type >, typename class_type::ReadOnlyMaskedAccess, typename class_type::WritableMaskedAccess >::type masked
Definition: PyImathAutovectorize.h:318
PyImath::detail::VectorizedFunction1::result_access_type
result_access_type< typename traits::result_type, any_vectorized >::direct result_access_type
Definition: PyImathAutovectorize.h:481
PyImath::detail::VectorizedOperation1::execute
void execute(size_t start, size_t end)
Definition: PyImathAutovectorize.h:374
PyImath::detail::VectorizedVoidMemberFunction2::reference_type
access_type< typename traits::arg1_type >::reference_type reference_type
Definition: PyImathAutovectorize.h:2246
PyImath::detail::possible_vectorizations
Definition: PyImathAutovectorize.h:89
PyImath::detail::VectorizedFunction2::result_access_type
result_access_type< typename traits::result_type, any_vectorized >::direct result_access_type
Definition: PyImathAutovectorize.h:542
PyImath::detail::VectorizedMemberFunction2::apply
static result_type apply(reference_type array, arg1_type arg1, arg2_type arg2)
Definition: PyImathAutovectorize.h:2578
PyImath::detail::VectorizedFunction5::arg5_direct_access_type
argument_access_type< typename traits::arg5_type, typename at< Vectorize, long_< 4 > >::type >::direct arg5_direct_access_type
Definition: PyImathAutovectorize.h:1226
PyImath::detail::VectorizedVoidMemberFunction2::format_arguments
static std::string format_arguments(const hboost::python::detail::keywords< 2 > &args)
Definition: PyImathAutovectorize.h:2399
PyImath::detail::VectorizedMemberFunction2::arg1_masked_access_type
argument_access_type< typename traits::arg2_type, typename at< Vectorize, long_< 0 > >::type >::masked arg1_masked_access_type
Definition: PyImathAutovectorize.h:2564
PyImath::detail::member_function_binding::_cls
Cls & _cls
Definition: PyImathAutovectorize.h:2733
PyImath::detail::argument_access_type
Definition: PyImathAutovectorize.h:325
start
GLuint start
Definition: glcorearb.h:475
value
GLsizei const GLfloat * value
Definition: glcorearb.h:824
PyImath::detail::VectorizedFunction4::arg2_masked_access_type
argument_access_type< typename traits::arg2_type, typename at< Vectorize, long_< 1 > >::type >::masked arg2_masked_access_type
Definition: PyImathAutovectorize.h:852
PyImath::detail::allowable_vectorizations
Definition: PyImathAutovectorize.h:118
PyImath::detail::VectorizedFunction2::apply
static result_type apply(arg1_type arg1, arg2_type arg2)
Definition: PyImathAutovectorize.h:560
PyImath::detail::VectorizedFunction5::result_access_type
result_access_type< typename traits::result_type, any_vectorized >::direct result_access_type
Definition: PyImathAutovectorize.h:1192
PyImath::detail::disallow_vectorization::apply::DontVectorize
transform< Vectorize, not_< _ > >::type DontVectorize
Definition: PyImathAutovectorize.h:111
PyImath::generate_bindings
void generate_bindings(const std::string &name, const std::string &doc, const hboost::python::detail::keywords< 1 > &args)
Definition: PyImathAutovectorize.h:2806
PyImath::detail::VectorizedFunction5::result_type
result_access_type< typename traits::result_type, any_vectorized >::type result_type
Definition: PyImathAutovectorize.h:1190
PyImath::detail::VectorizedMemberFunction2::direct_access_type
access_type< typename traits::arg1_type >::direct direct_access_type
Definition: PyImathAutovectorize.h:2556
PyImath::detail::VectorizedFunction1::HBOOST_STATIC_ASSERT
HBOOST_STATIC_ASSERT((size< Vectorize >::value==function_traits< Func >::arity))
a
GLboolean GLboolean GLboolean GLboolean a
Definition: glcorearb.h:1222
PyImath::detail::VectorizedFunction1::result_type
result_access_type< typename traits::result_type, any_vectorized >::type result_type
Definition: PyImathAutovectorize.h:479
length
GLuint GLsizei GLsizei * length
Definition: glcorearb.h:795
PyImath::detail::VectorizedFunction3::format_arguments
static std::string format_arguments(const hboost::python::detail::keywords< 3 > &args)
Definition: PyImathAutovectorize.h:820
PyImath::detail::VectorizedMemberFunction1::result_access_type
result_type::WritableDirectAccess result_access_type
Definition: PyImathAutovectorize.h:2472
PyImath::detail::member_function_binding::member_function_binding
member_function_binding(Cls &cls, const std::string &name, const std::string &doc, const Keywords &args)
Definition: PyImathAutovectorize.h:2737
PyImath::detail::VectorizedFunction4::result_type
result_access_type< typename traits::result_type, any_vectorized >::type result_type
Definition: PyImathAutovectorize.h:835
PyImath::detail::VectorizedMemberFunction0::reference_type
access_type< typename traits::arg1_type >::reference_type reference_type
Definition: PyImathAutovectorize.h:2415
PyImath::detail::VectorizedFunction3::arg1_masked_access_type
argument_access_type< typename traits::arg1_type, typename at< Vectorize, long_< 0 > >::type >::masked arg1_masked_access_type
Definition: PyImathAutovectorize.h:656
PyImath::detail::VectorizedVoidMemberFunction0::HBOOST_STATIC_ASSERT
HBOOST_STATIC_ASSERT((size< Vectorize >::value+1==function_traits< Func >::arity))
PyImath::detail::VectorizedFunction5::apply
static result_type apply(arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, arg5_type arg5)
Definition: PyImathAutovectorize.h:1231
PyImath::detail::VectorizedVoidMemberFunction1::direct_access_type
access_type< typename traits::arg1_type >::direct direct_access_type
Definition: PyImathAutovectorize.h:2041
PyImathUtil.h
PyImath::detail::any_masked
bool any_masked(const T &value)
Definition: PyImathAutovectorize.h:125
PyImath::detail::vectorized_result_type
Definition: PyImathAutovectorize.h:267
PyImath::detail::VectorizedVoidMemberFunction2::arg2_type
argument_access_type< typename traits::arg3_type, typename at< Vectorize, long_< 1 > >::type >::type arg2_type
Definition: PyImathAutovectorize.h:2258
PyImath::detail::VectorizedFunction5::arg2_masked_access_type
argument_access_type< typename traits::arg2_type, typename at< Vectorize, long_< 1 > >::type >::masked arg2_masked_access_type
Definition: PyImathAutovectorize.h:1207
PyImath::detail::VectorizedOperation3::VectorizedOperation3
VectorizedOperation3(result_access_type r, access_type a, arg1_access_type a1, arg2_access_type a2)
Definition: PyImathAutovectorize.h:411
PY_IMATH_RETURN_PYTHON
#define PY_IMATH_RETURN_PYTHON
Definition: PyImathFixedArray.h:30
arg
auto arg(const Char *name, const T &arg) -> detail::named_arg< Char, T >
Definition: core.h:1859
PyImath::detail::VectorizedFunction2::HBOOST_STATIC_ASSERT
HBOOST_STATIC_ASSERT((size< Vectorize >::value==function_traits< Func >::arity))
PyImath::detail::VectorizedMemberFunction0::direct_access_type
access_type< typename traits::arg1_type >::direct direct_access_type
Definition: PyImathAutovectorize.h:2416
PyImath::detail::measure_argument::apply
static std::pair< size_t, bool > apply(T arg)
Definition: PyImathAutovectorize.h:164
PyImath::detail::VectorizedFunction5::arg3_masked_access_type
argument_access_type< typename traits::arg3_type, typename at< Vectorize, long_< 2 > >::type >::masked arg3_masked_access_type
Definition: PyImathAutovectorize.h:1214
PyImath::detail::op_precompute
Definition: PyImathAutovectorize.h:77
PyImath::detail::access_type::direct
if_< is_const< prim_type >, typename class_type::ReadOnlyDirectAccess, typename class_type::WritableDirectAccess >::type direct
Definition: PyImathAutovectorize.h:321
PyImath::detail::VectorizedFunction3::arg3_direct_access_type
argument_access_type< typename traits::arg3_type, typename at< Vectorize, long_< 2 > >::type >::direct arg3_direct_access_type
Definition: PyImathAutovectorize.h:668
PyImath::detail::member_function_binding::_name
std::string _name
Definition: PyImathAutovectorize.h:2734
PyImath::detail::VectorizedVoidMemberFunction0::masked_access_type
access_type< typename traits::arg1_type >::masked masked_access_type
Definition: PyImathAutovectorize.h:2007
PyImathTask.h
PyImath::detail::VectorizedFunction2::arg1_type
argument_access_type< typename traits::arg1_type, typename at< Vectorize, long_< 0 > >::type >::type arg1_type
Definition: PyImathAutovectorize.h:546
PyImath::detail::VectorizedFunction4::arg3_direct_access_type
argument_access_type< typename traits::arg3_type, typename at< Vectorize, long_< 2 > >::type >::direct arg3_direct_access_type
Definition: PyImathAutovectorize.h:857
PyImath::detail::argument_access_type::type
if_< VectorizeArg, const PyImath::FixedArray< base_type > &, T >::type type
Definition: PyImathAutovectorize.h:328
PyImath::detail::build_member_function_binding
member_function_binding< Op, Cls, Func, Keywords > build_member_function_binding(Cls &cls, Func *func, const std::string &name, const std::string &doc, const Keywords &args)
Definition: PyImathAutovectorize.h:2773
PyImath::detail::VectorizedVoidMemberFunction2::arg1_type
argument_access_type< typename traits::arg2_type, typename at< Vectorize, long_< 0 > >::type >::type arg1_type
Definition: PyImathAutovectorize.h:2251
PyImath::detail::vectorized_result_type::type
if_< VectorizeArg, PyImath::FixedArray< T >, T >::type type
Definition: PyImathAutovectorize.h:269
PyImath::detail::allowable_vectorizations::type
remove_if< possible, disallow_vectorization< Vectorizable > >::type type
Definition: PyImathAutovectorize.h:121
PyImath::detail::generate_member_bindings_struct::apply
static void apply(Cls &cls, const std::string &name, const std::string &doc, const Keywords &args)
Definition: PyImathAutovectorize.h:2782
PyImath::detail::VectorizedMemberFunction0::result_type
vectorized_result_type< typename traits::result_type, true_ >::type result_type
Definition: PyImathAutovectorize.h:2413
PyImath::detail::VectorizedVoidMemberFunction2::arg1_masked_access_type
argument_access_type< typename traits::arg2_type, typename at< Vectorize, long_< 0 > >::type >::masked arg1_masked_access_type
Definition: PyImathAutovectorize.h:2255
type
GLint GLint GLsizei GLint GLenum GLenum type
Definition: glcorearb.h:108
PyImath::detail::VectorizedMemberFunction2::arg1_direct_access_type
argument_access_type< typename traits::arg2_type, typename at< Vectorize, long_< 0 > >::type >::direct arg1_direct_access_type
Definition: PyImathAutovectorize.h:2562
PyImath::detail::create_uninitalized_return_value::apply
static T apply(size_t length)
Definition: PyImathAutovectorize.h:251
PyImath::detail::VectorizedFunction5::arg2_direct_access_type
argument_access_type< typename traits::arg2_type, typename at< Vectorize, long_< 1 > >::type >::direct arg2_direct_access_type
Definition: PyImathAutovectorize.h:1205
PyImath::detail::VectorizedFunction5::arg1_type
argument_access_type< typename traits::arg1_type, typename at< Vectorize, long_< 0 > >::type >::type arg1_type
Definition: PyImathAutovectorize.h:1196
PyImath::detail::VectorizedVoidMaskableMemberFunction1::arg1_type
argument_access_type< typename traits::arg2_type, hboost::mpl::true_ >::type arg1_type
Definition: PyImathAutovectorize.h:2134
PyImath::detail::VectorizedFunction5::HBOOST_STATIC_ASSERT
HBOOST_STATIC_ASSERT((size< Vectorize >::value==function_traits< Func >::arity))
PyImath::detail::function_binding
Definition: PyImathAutovectorize.h:1882
PyImath::detail::disallow_vectorization
Definition: PyImathAutovectorize.h:105
PyImath::detail::VectorizedVoidMemberFunction2::masked_access_type
access_type< typename traits::arg1_type >::masked masked_access_type
Definition: PyImathAutovectorize.h:2248
PyImath::detail::null_precomputation::precompute
static void precompute(size_t len)
Definition: PyImathAutovectorize.h:74
PyImath::detail::VectorizedMemberFunction0::apply
static result_type apply(reference_type array)
Definition: PyImathAutovectorize.h:2424
PyImath::generate_member_bindings
void generate_member_bindings(Cls &cls, const std::string &name, const std::string &doc)
Definition: PyImathAutovectorize.h:2837
PyImath::detail::access_type
Definition: PyImathAutovectorize.h:307
PyImath::detail::allowable_vectorizations::possible
possible_vectorizations< size< Vectorizable >::value >::type possible
Definition: PyImathAutovectorize.h:120
PyImath::detail::VectorizedOperation5::execute
void execute(size_t start, size_t end)
Definition: PyImathAutovectorize.h:462
PyImath::detail::create_uninitalized_return_value
Definition: PyImathAutovectorize.h:249
access
GLuint GLint GLboolean GLint GLenum access
Definition: glcorearb.h:2222
PyImath::detail::generate_single_member_binding
void generate_single_member_binding(Cls &cls, Func *func, const std::string &name, const std::string &doc)
Definition: PyImathAutovectorize.h:2789
PyImath::detail::VectorizedVoidMemberFunction2::arg2_masked_access_type
argument_access_type< typename traits::arg3_type, typename at< Vectorize, long_< 1 > >::type >::masked arg2_masked_access_type
Definition: PyImathAutovectorize.h:2262
PyImath::detail::argument_access_type::base_type
remove_const< typename remove_reference< T >::type >::type base_type
Definition: PyImathAutovectorize.h:327
PyImath::detail::VectorizedFunction4::result_access_type
result_access_type< typename traits::result_type, any_vectorized >::direct result_access_type
Definition: PyImathAutovectorize.h:837
PyImath::detail::VectorizedFunction4::arg4_direct_access_type
argument_access_type< typename traits::arg4_type, typename at< Vectorize, long_< 3 > >::type >::direct arg4_direct_access_type
Definition: PyImathAutovectorize.h:864
PyImath::detail::disallow_vectorization::apply::Valid
transform< DontVectorize, Vectorizable, or_< _, _ > >::type Valid
Definition: PyImathAutovectorize.h:112
end
GLuint GLuint end
Definition: glcorearb.h:475
PyImath::detail::VectorizedVoidMemberFunction0::apply
static reference_type apply(reference_type array)
Definition: PyImathAutovectorize.h:2010
PyImathFixedArray.h
PyImath::op_with_precomputation
Definition: PyImathAutovectorize.h:40
PyImath::detail::VectorizedVoidMemberFunction1::HBOOST_STATIC_ASSERT
HBOOST_STATIC_ASSERT((size< Vectorize >::value+1==function_traits< Func >::arity))
PyImath::detail::VectorizedFunction1::any_vectorized
fold< Vectorize, false_, or_< _, _ > >::type any_vectorized
Definition: PyImathAutovectorize.h:476
PyImath::detail::member_function_binding::operator()
void operator()(Vectorize) const
Definition: PyImathAutovectorize.h:2742
PyImath::detail::VectorizedOperation2::execute
void execute(size_t start, size_t end)
Definition: PyImathAutovectorize.h:393
PyImath::detail::VectorizedFunction5::arg5_masked_access_type
argument_access_type< typename traits::arg5_type, typename at< Vectorize, long_< 4 > >::type >::masked arg5_masked_access_type
Definition: PyImathAutovectorize.h:1228
PyImath::detail::VectorizedFunction3::arg1_direct_access_type
argument_access_type< typename traits::arg1_type, typename at< Vectorize, long_< 0 > >::type >::direct arg1_direct_access_type
Definition: PyImathAutovectorize.h:654
PyImath::detail::VectorizedVoidMaskableMemberFunction1::apply
static reference_type apply(reference_type array, arg1_type arg1)
Definition: PyImathAutovectorize.h:2141
PyImath::detail::VectorizedMemberFunction1::result_type
vectorized_result_type< typename traits::result_type, true_ >::type result_type
Definition: PyImathAutovectorize.h:2457
PyImath::detail::function_binding::_name
std::string _name
Definition: PyImathAutovectorize.h:1884
PyImath::detail::VectorizedOperation2::VectorizedOperation2
VectorizedOperation2(result_access_type r, access_type a1, arg1_access_type a2)
Definition: PyImathAutovectorize.h:390
PyImath::detail::VectorizedMemberFunction2::result_type
vectorized_result_type< typename traits::result_type, true_ >::type result_type
Definition: PyImathAutovectorize.h:2553
PyImath::detail::disallow_vectorization::apply::type
not_< fold< Valid, true_, and_< _, _ > > >::type type
Definition: PyImathAutovectorize.h:113
PyImath::detail::VectorizedMemberFunction0::result_access_type
result_type::WritableDirectAccess result_access_type
Definition: PyImathAutovectorize.h:2421
PyImath::detail::VectorizedVoidMaskableMemberFunction1::direct_access_type
access_type< typename traits::arg1_type >::direct direct_access_type
Definition: PyImathAutovectorize.h:2130
PyImath::detail::VectorizedVoidMemberFunction0::direct_access_type
access_type< typename traits::arg1_type >::direct direct_access_type
Definition: PyImathAutovectorize.h:2006
PyImath::detail::VectorizedMemberFunction2::arg2_type
argument_access_type< typename traits::arg3_type, typename at< Vectorize, long_< 1 > >::type >::type arg2_type
Definition: PyImathAutovectorize.h:2567
PyImath::detail::VectorizedFunction1::arg1_masked_access_type
argument_access_type< typename traits::arg1_type, typename at< Vectorize, long_< 0 > >::type >::masked arg1_masked_access_type
Definition: PyImathAutovectorize.h:489
PyImath::detail::VectorizedFunction4::HBOOST_STATIC_ASSERT
HBOOST_STATIC_ASSERT((size< Vectorize >::value==function_traits< Func >::arity))
PyImath::detail::VectorizedMemberFunction1::direct_access_type
access_type< typename traits::arg1_type >::direct direct_access_type
Definition: PyImathAutovectorize.h:2460
PyImath::detail::op_precompute::apply
static void apply(size_t len)
Definition: PyImathAutovectorize.h:80
PyImath::detail::VectorizedFunction3::arg3_masked_access_type
argument_access_type< typename traits::arg3_type, typename at< Vectorize, long_< 2 > >::type >::masked arg3_masked_access_type
Definition: PyImathAutovectorize.h:670
PyImath::detail::VectorizedOperation4::VectorizedOperation4
VectorizedOperation4(result_access_type r, access_type a, arg1_access_type a1, arg2_access_type a2, arg3_access_type a3)
Definition: PyImathAutovectorize.h:434
PyImath::detail::VectorizedVoidMemberFunction2::arg2_direct_access_type
argument_access_type< typename traits::arg3_type, typename at< Vectorize, long_< 1 > >::type >::direct arg2_direct_access_type
Definition: PyImathAutovectorize.h:2260
PyImath::detail::VectorizedOperation4::execute
void execute(size_t start, size_t end)
Definition: PyImathAutovectorize.h:438
PyImath::detail::VectorizedFunction3::HBOOST_STATIC_ASSERT
HBOOST_STATIC_ASSERT((size< Vectorize >::value==function_traits< Func >::arity))
PyImath::detail::VectorizedMemberFunction2::format_arguments
static std::string format_arguments(const hboost::python::detail::keywords< 2 > &args)
Definition: PyImathAutovectorize.h:2723
PyImath::detail::function_binding::_args
const Keywords & _args
Definition: PyImathAutovectorize.h:1885
name
GLuint const GLchar * name
Definition: glcorearb.h:786
PyImath::detail::result_access_type::_class_type
if_< VectorizeArg, type, SimpleNonArrayWrapper< base_type > >::type _class_type
Definition: PyImathAutovectorize.h:345
PyImath::dispatchTask
PYIMATH_EXPORT void dispatchTask(Task &task, size_t length)
PyImath::detail::VectorizedVoidMaskableMemberFunction1::reference_type
access_type< typename traits::arg1_type >::reference_type reference_type
Definition: PyImathAutovectorize.h:2129
b
GLboolean GLboolean GLboolean b
Definition: glcorearb.h:1222
PyImath::detail::VectorizedMemberFunction2::HBOOST_STATIC_ASSERT
HBOOST_STATIC_ASSERT((size< Vectorize >::value+1==function_traits< Func >::arity))
GA_Names::transform
GA_API const UT_StringHolder transform
PyImath::detail::VectorizedFunction3::result_access_type
result_access_type< typename traits::result_type, any_vectorized >::direct result_access_type
Definition: PyImathAutovectorize.h:648
PyImath::detail::access_type::base_type
remove_const< prim_type >::type base_type
Definition: PyImathAutovectorize.h:310
OBJ_MatchTransform::T
PyImath::detail::VectorizedMemberFunction2::reference_type
access_type< typename traits::arg1_type >::reference_type reference_type
Definition: PyImathAutovectorize.h:2555
PyImath::detail::VectorizedMemberFunction1::reference_type
access_type< typename traits::arg1_type >::reference_type reference_type
Definition: PyImathAutovectorize.h:2459
PyImath::detail::VectorizedVoidMemberFunction1::apply
static reference_type apply(reference_type array, arg1_type arg1)
Definition: PyImathAutovectorize.h:2052
PyImath::detail::VectorizedFunction2::arg1_direct_access_type
argument_access_type< typename traits::arg1_type, typename at< Vectorize, long_< 0 > >::type >::direct arg1_direct_access_type
Definition: PyImathAutovectorize.h:548
PyImath::detail::VectorizedVoidMaskableMemberFunction1::arg1_direct_access_type
argument_access_type< typename traits::arg2_type, hboost::mpl::true_ >::direct arg1_direct_access_type
Definition: PyImathAutovectorize.h:2136
PyImath::detail::member_function_binding::_args
const Keywords & _args
Definition: PyImathAutovectorize.h:2735
PyImath::detail::VectorizedVoidMemberFunction1::reference_type
access_type< typename traits::arg1_type >::reference_type reference_type
Definition: PyImathAutovectorize.h:2040
PyImath::detail::VectorizedFunction3::any_vectorized
fold< Vectorize, false_, or_< _, _ > >::type any_vectorized
Definition: PyImathAutovectorize.h:643
SOP_CreaseEnums::Op
Op
Definition: SOP_Crease.proto.h:25
PyImath::detail::function_binding::operator()
void operator()(Vectorize) const
Definition: PyImathAutovectorize.h:1893
PyImath::detail::getArrayAccess
AccessType getArrayAccess(T &value)
Definition: PyImathAutovectorize.h:352
PyImath::detail::VectorizedMemberFunction2::arg2_masked_access_type
argument_access_type< typename traits::arg3_type, typename at< Vectorize, long_< 1 > >::type >::masked arg2_masked_access_type
Definition: PyImathAutovectorize.h:2571
size
GLsizeiptr size
Definition: glcorearb.h:664
PyImath::detail::VectorizedMemberFunction1::format_arguments
static std::string format_arguments(const hboost::python::detail::keywords< 1 > &args)
Definition: PyImathAutovectorize.h:2540
PyImath::detail::access_type::reference_type
if_< is_const< prim_type >, const PyImath::FixedArray< base_type > &, PyImath::FixedArray< base_type > & >::type reference_type
Definition: PyImathAutovectorize.h:313
func
GLenum func
Definition: glcorearb.h:783
PyImath::detail::VectorizedFunction3::result_type
result_access_type< typename traits::result_type, any_vectorized >::type result_type
Definition: PyImathAutovectorize.h:646
PyImath::detail::VectorizedFunction1::arg1_direct_access_type
argument_access_type< typename traits::arg1_type, typename at< Vectorize, long_< 0 > >::type >::direct arg1_direct_access_type
Definition: PyImathAutovectorize.h:487
PY_IMATH_LEAVE_PYTHON
#define PY_IMATH_LEAVE_PYTHON
Definition: PyImathFixedArray.h:29
PyImath::detail::create_uninitalized_return_value< PyImath::FixedArray< T > >::apply
static PyImath::FixedArray< T > apply(size_t length)
Definition: PyImathAutovectorize.h:260
PyImath::detail::generate_bindings_struct
Definition: PyImathAutovectorize.h:1917
PyImath::detail::VectorizedFunction5::arg4_masked_access_type
argument_access_type< typename traits::arg4_type, typename at< Vectorize, long_< 3 > >::type >::masked arg4_masked_access_type
Definition: PyImathAutovectorize.h:1221
PyImath::detail::generate_bindings_struct::apply
static void apply(const std::string &name, const std::string &doc, const Keywords &args)
Definition: PyImathAutovectorize.h:1920
PyImath::detail::VectorizedFunction2::arg2_type
argument_access_type< typename traits::arg2_type, typename at< Vectorize, long_< 1 > >::type >::type arg2_type
Definition: PyImathAutovectorize.h:553
PyImath::detail::VectorizedVoidMemberFunction2::arg1_direct_access_type
argument_access_type< typename traits::arg2_type, typename at< Vectorize, long_< 0 > >::type >::direct arg1_direct_access_type
Definition: PyImathAutovectorize.h:2253
PyImath::detail::VectorizedMemberFunction1::arg1_type
argument_access_type< typename traits::arg2_type, typename at< Vectorize, long_< 0 > >::type >::type arg1_type
Definition: PyImathAutovectorize.h:2464
PyImath::detail::VectorizedFunction1::arg1_type
argument_access_type< typename traits::arg1_type, typename at< Vectorize, long_< 0 > >::type >::type arg1_type
Definition: PyImathAutovectorize.h:485
PyImath::detail::VectorizedFunction3::arg2_type
argument_access_type< typename traits::arg2_type, typename at< Vectorize, long_< 1 > >::type >::type arg2_type
Definition: PyImathAutovectorize.h:659
PyImath::detail::VectorizedFunction4::arg4_masked_access_type
argument_access_type< typename traits::arg4_type, typename at< Vectorize, long_< 3 > >::type >::masked arg4_masked_access_type
Definition: PyImathAutovectorize.h:866
PyImath::detail::access_type::prim_type
remove_reference< T >::type prim_type
Definition: PyImathAutovectorize.h:309
PyImath::detail::VectorizedVoidMemberFunction1::arg1_direct_access_type
argument_access_type< typename traits::arg2_type, typename at< Vectorize, long_< 0 > >::type >::direct arg1_direct_access_type
Definition: PyImathAutovectorize.h:2047
PyImath::detail::VectorizedFunction3::arg3_type
argument_access_type< typename traits::arg3_type, typename at< Vectorize, long_< 2 > >::type >::type arg3_type
Definition: PyImathAutovectorize.h:666
PyImath::detail::VectorizedFunction5::arg4_type
argument_access_type< typename traits::arg4_type, typename at< Vectorize, long_< 3 > >::type >::type arg4_type
Definition: PyImathAutovectorize.h:1217
PyImath::detail::VectorizedVoidMaskableMemberFunction1::format_arguments
static std::string format_arguments(const hboost::python::detail::keywords< 1 > &args)
Definition: PyImathAutovectorize.h:2233
PyImath::detail::generate_member_bindings_struct
Definition: PyImathAutovectorize.h:2779
PyImath::detail::VectorizedMemberFunction2::result_access_type
result_type::WritableDirectAccess result_access_type
Definition: PyImathAutovectorize.h:2575
PyImath::detail::VectorizedFunction5::arg5_type
argument_access_type< typename traits::arg5_type, typename at< Vectorize, long_< 4 > >::type >::type arg5_type
Definition: PyImathAutovectorize.h:1224
PyImath::detail::VectorizedMemberFunction0::HBOOST_STATIC_ASSERT
HBOOST_STATIC_ASSERT((size< Vectorize >::value+1==function_traits< Func >::arity))
PyImath::detail::VectorizedFunction5::arg4_direct_access_type
argument_access_type< typename traits::arg4_type, typename at< Vectorize, long_< 3 > >::type >::direct arg4_direct_access_type
Definition: PyImathAutovectorize.h:1219
PyImath::detail::VectorizedFunction1::format_arguments
static std::string format_arguments(const hboost::python::detail::keywords< 1 > &args)
Definition: PyImathAutovectorize.h:525
GA_Names::N
GA_API const UT_StringHolder N
PyImath::detail::VectorizedFunction3::arg1_type
argument_access_type< typename traits::arg1_type, typename at< Vectorize, long_< 0 > >::type >::type arg1_type
Definition: PyImathAutovectorize.h:652
PyImath::detail::VectorizedVoidMemberFunction2::apply
static reference_type apply(reference_type array, arg1_type arg1, arg2_type arg2)
Definition: PyImathAutovectorize.h:2265
PyImath::detail::VectorizedFunction4::arg2_direct_access_type
argument_access_type< typename traits::arg2_type, typename at< Vectorize, long_< 1 > >::type >::direct arg2_direct_access_type
Definition: PyImathAutovectorize.h:850
args
**If you just want to fire and args
Definition: thread.h:618
PyImath::detail::VectorizedFunction4::arg3_type
argument_access_type< typename traits::arg3_type, typename at< Vectorize, long_< 2 > >::type >::type arg3_type
Definition: PyImathAutovectorize.h:855
PyImath::detail::VectorizedFunction2::arg2_masked_access_type
argument_access_type< typename traits::arg2_type, typename at< Vectorize, long_< 1 > >::type >::masked arg2_masked_access_type
Definition: PyImathAutovectorize.h:557
PyImath::detail::member_function_binding
Definition: PyImathAutovectorize.h:2731
PyImath::detail::argument_access_type::masked
_class_type::ReadOnlyMaskedAccess masked
Definition: PyImathAutovectorize.h:334
PyImath::detail::access_type::class_type
remove_reference< reference_type >::type class_type
Definition: PyImathAutovectorize.h:314
PyImath::detail::measure_argument< PyImath::FixedArray< T > >::apply
static std::pair< size_t, bool > apply(const PyImath::FixedArray< T > &arg)
Definition: PyImathAutovectorize.h:170
PyImath::detail::VectorizedFunction5::arg2_type
argument_access_type< typename traits::arg2_type, typename at< Vectorize, long_< 1 > >::type >::type arg2_type
Definition: PyImathAutovectorize.h:1203
PyImath::detail::result_access_type
Definition: PyImathAutovectorize.h:339
PyImath::detail::function_binding::_doc
std::string _doc
Definition: PyImathAutovectorize.h:1884
PyImath::detail::VectorizedFunction2::any_vectorized
fold< Vectorize, false_, or_< _, _ > >::type any_vectorized
Definition: PyImathAutovectorize.h:537
PyImath::detail::result_access_type::direct
_class_type::WritableDirectAccess direct
Definition: PyImathAutovectorize.h:348
PyImath::detail::function_binding::function_binding
function_binding(const std::string &name, const std::string &doc, const Keywords &args)
Definition: PyImathAutovectorize.h:1888
PyImath::detail::VectorizedOperation3::execute
void execute(size_t start, size_t end)
Definition: PyImathAutovectorize.h:415
r
GLboolean r
Definition: glcorearb.h:1222
PyImath::detail::VectorizedFunction2::arg2_direct_access_type
argument_access_type< typename traits::arg2_type, typename at< Vectorize, long_< 1 > >::type >::direct arg2_direct_access_type
Definition: PyImathAutovectorize.h:555
PyImath::detail::VectorizedFunction3::arg2_masked_access_type
argument_access_type< typename traits::arg2_type, typename at< Vectorize, long_< 1 > >::type >::masked arg2_masked_access_type
Definition: PyImathAutovectorize.h:663
PyImath::detail::VectorizedOperation5::VectorizedOperation5
VectorizedOperation5(result_access_type r, access_type a, arg1_access_type a1, arg2_access_type a2, arg3_access_type a3, arg4_access_type a4)
Definition: PyImathAutovectorize.h:458
PyImath::detail::VectorizedFunction3::apply
static result_type apply(arg1_type arg1, arg2_type arg2, arg3_type arg3)
Definition: PyImathAutovectorize.h:673
PyImath::detail::VectorizedVoidMaskableMemberFunction1::masked_access_type
access_type< typename traits::arg1_type >::masked masked_access_type
Definition: PyImathAutovectorize.h:2131
PyImath::detail::VectorizedFunction2::result_type
result_access_type< typename traits::result_type, any_vectorized >::type result_type
Definition: PyImathAutovectorize.h:540
PyImath::detail::VectorizedFunction5::arg3_type
argument_access_type< typename traits::arg3_type, typename at< Vectorize, long_< 2 > >::type >::type arg3_type
Definition: PyImathAutovectorize.h:1210
PyImath::detail::VectorizedMaskedVoidOperation1::VectorizedMaskedVoidOperation1
VectorizedMaskedVoidOperation1(access_type a, arg1_access_type a1, array_type arr)
Definition: PyImathAutovectorize.h:1966
PyImath::detail::measure_argument
Definition: PyImathAutovectorize.h:162
PyImath::detail::VectorizedVoidMemberFunction2::HBOOST_STATIC_ASSERT
HBOOST_STATIC_ASSERT((size< Vectorize >::value+1==function_traits< Func >::arity))
PyImath::detail::VectorizedFunction4::apply
static result_type apply(arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4)
Definition: PyImathAutovectorize.h:869
PyImath::detail::argument_access_type::direct
_class_type::ReadOnlyDirectAccess direct
Definition: PyImathAutovectorize.h:335
PyImath::detail::VectorizedVoidMemberFunction2::direct_access_type
access_type< typename traits::arg1_type >::direct direct_access_type
Definition: PyImathAutovectorize.h:2247
PyImath::detail::VectorizedVoidMemberFunction1::format_arguments
static std::string format_arguments(const hboost::python::detail::keywords< 1 > &args)
Definition: PyImathAutovectorize.h:2110
PyImath::detail::VectorizedFunction4::arg4_type
argument_access_type< typename traits::arg4_type, typename at< Vectorize, long_< 3 > >::type >::type arg4_type
Definition: PyImathAutovectorize.h:862
PyImath::detail::VectorizedMemberFunction1::arg1_masked_access_type
argument_access_type< typename traits::arg2_type, typename at< Vectorize, long_< 0 > >::type >::masked arg1_masked_access_type
Definition: PyImathAutovectorize.h:2468
PyImath::detail::VectorizedVoidMaskableMemberFunction1::HBOOST_STATIC_ASSERT
HBOOST_STATIC_ASSERT((2==function_traits< Func >::arity))
PyImath::detail::VectorizedFunction4::arg2_type
argument_access_type< typename traits::arg2_type, typename at< Vectorize, long_< 1 > >::type >::type arg2_type
Definition: PyImathAutovectorize.h:848
PyImath::detail::VectorizedFunction1::apply
static result_type apply(arg1_type arg1)
Definition: PyImathAutovectorize.h:492
PyImath::detail::VectorizedMemberFunction2::arg1_type
argument_access_type< typename traits::arg2_type, typename at< Vectorize, long_< 0 > >::type >::type arg1_type
Definition: PyImathAutovectorize.h:2560
PyImath::detail::VectorizedFunction5::arg1_masked_access_type
argument_access_type< typename traits::arg1_type, typename at< Vectorize, long_< 0 > >::type >::masked arg1_masked_access_type
Definition: PyImathAutovectorize.h:1200
PyImath::detail::VectorizedMemberFunction2::arg2_direct_access_type
argument_access_type< typename traits::arg3_type, typename at< Vectorize, long_< 1 > >::type >::direct arg2_direct_access_type
Definition: PyImathAutovectorize.h:2569
PyImath::detail::VectorizedFunction4::arg1_masked_access_type
argument_access_type< typename traits::arg1_type, typename at< Vectorize, long_< 0 > >::type >::masked arg1_masked_access_type
Definition: PyImathAutovectorize.h:845
PyImath::detail::VectorizedFunction4::arg3_masked_access_type
argument_access_type< typename traits::arg3_type, typename at< Vectorize, long_< 2 > >::type >::masked arg3_masked_access_type
Definition: PyImathAutovectorize.h:859
PyImath::detail::VectorizedFunction3::arg2_direct_access_type
argument_access_type< typename traits::arg2_type, typename at< Vectorize, long_< 1 > >::type >::direct arg2_direct_access_type
Definition: PyImathAutovectorize.h:661
PyImath::detail::VectorizedFunction5::arg3_direct_access_type
argument_access_type< typename traits::arg3_type, typename at< Vectorize, long_< 2 > >::type >::direct arg3_direct_access_type
Definition: PyImathAutovectorize.h:1212
PyImath::detail::VectorizedFunction4::format_arguments
static std::string format_arguments(const hboost::python::detail::keywords< 4 > &args)
Definition: PyImathAutovectorize.h:1175
PyImath::detail::VectorizedVoidMemberFunction1::masked_access_type
access_type< typename traits::arg1_type >::masked masked_access_type
Definition: PyImathAutovectorize.h:2042
PyImath::detail::VectorizedMemberFunction0::masked_access_type
access_type< typename traits::arg1_type >::masked masked_access_type
Definition: PyImathAutovectorize.h:2417
PyImath::detail::VectorizedMemberFunction1::arg1_direct_access_type
argument_access_type< typename traits::arg2_type, typename at< Vectorize, long_< 0 > >::type >::direct arg1_direct_access_type
Definition: PyImathAutovectorize.h:2466
PyImath::detail::result_access_type::type
if_< VectorizeArg, PyImath::FixedArray< base_type >, T >::type type
Definition: PyImathAutovectorize.h:342
PyImath::detail::VectorizedVoidMaskableMemberFunction1::arg1_masked_access_type
argument_access_type< typename traits::arg2_type, hboost::mpl::true_ >::masked arg1_masked_access_type
Definition: PyImathAutovectorize.h:2138
PyImath::detail::result_access_type::base_type
remove_const< typename remove_reference< T >::type >::type base_type
Definition: PyImathAutovectorize.h:341
PyImath::detail::VectorizedMemberFunction1::apply
static result_type apply(reference_type array, arg1_type arg1)
Definition: PyImathAutovectorize.h:2475
PyImath::detail::VectorizedVoidMemberFunction0::reference_type
access_type< typename traits::arg1_type >::reference_type reference_type
Definition: PyImathAutovectorize.h:2005
PyImath::detail::VectorizedFunction4::any_vectorized
fold< Vectorize, false_, or_< _, _ > >::type any_vectorized
Definition: PyImathAutovectorize.h:832
PyImath::detail::VectorizedFunction2::format_arguments
static std::string format_arguments(const hboost::python::detail::keywords< 2 > &args)
Definition: PyImathAutovectorize.h:631
PyImath::detail::VectorizedMemberFunction1::HBOOST_STATIC_ASSERT
HBOOST_STATIC_ASSERT((size< Vectorize >::value+1==function_traits< Func >::arity))
PyImath::detail::VectorizedMemberFunction2::masked_access_type
access_type< typename traits::arg1_type >::masked masked_access_type
Definition: PyImathAutovectorize.h:2557
PyImath::detail::VectorizedVoidMemberFunction1::arg1_type
argument_access_type< typename traits::arg2_type, typename at< Vectorize, long_< 0 > >::type >::type arg1_type
Definition: PyImathAutovectorize.h:2045
PyImath::detail::VectorizedFunction4::arg1_direct_access_type
argument_access_type< typename traits::arg1_type, typename at< Vectorize, long_< 0 > >::type >::direct arg1_direct_access_type
Definition: PyImathAutovectorize.h:843