elementwise_dense_scalar.hpp

Go to the documentation of this file.
00001 /****
00002 ***** Copyright 2010 Intel Corporation All Rights Reserved.
00003 *****
00004 ***** The source code, information and material contained herein are owned by Intel Corporation or its suppliers  *****
00005 ***** or licensors, and title to such Material remains with Intel Corporation or its suppliers or licensors.      *****
00006 ***** The Material contains proprietary information of Intel or its suppliers and licensors. The Material is      *****
00007 ***** protected by worldwide copyright laws and treaty provisions. No part of the Material may be used, copied,   *****
00008 ***** reproduced, modified, published, uploaded, posted, transmitted, distributed or disclosed in any way without *****
00009 ***** Intel's prior express written permission.
00010 *****
00011 ***** No license under any patent, copyright or other intellectual property rights in the material is granted to  *****
00012 ***** or conferred upon you, either expressly, by implication, inducement, estoppel or otherwise. Any license     *****
00013 ***** under such intellectual property rights must be express and approved by Intel in writing.
00014 ****/
00015 
00016 /**** Copyright Ends ****/
00017 
00018 //
00019 // This file was automatically generated and should not be edited directly.
00020 //
00021 
00022 #ifndef ARBB_CPP_ELEMENTWISE_DENSE_SCALAR_HPP
00023 #define ARBB_CPP_ELEMENTWISE_DENSE_SCALAR_HPP
00024 
00025 #include "namespace.hpp"
00026 #include <arbb_vmapi.h>
00027 #include "detail/error_details.hpp"
00028 #include "detail/enable_if.hpp"
00029 #include "detail/function.hpp"
00030 #include "detail/operators.hpp"
00031 #include "detail/scalar_traits.hpp"
00032 #include "dense.hpp"
00033 #include "scalar.hpp"
00034 
00035 
00036 
00037 namespace ARBB_CPP_NS {
00038 
00039 
00042 
00050 template <arbb_scalar_type_t S, std::size_t D>
00051 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D> >::type
00052 abs(const dense<scalar<S>, D>& value)
00053 {
00054   dense<scalar<S>, D> result;
00055   const arbb_variable_t outputs[] = {result.vm_variable()};
00056 
00057   const arbb_variable_t inputs[] = {value.vm_variable()};
00058   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
00059   arbb_op(detail::function::current(), arbb_op_abs, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
00060 
00061   return result;
00062 }
00063 
00065 
00068 
00076 template <arbb_scalar_type_t S, std::size_t D>
00077 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, dense<scalar<S>, D> >::type
00078 acos(const dense<scalar<S>, D>& value)
00079 {
00080   dense<scalar<S>, D> result;
00081   const arbb_variable_t outputs[] = {result.vm_variable()};
00082 
00083   const arbb_variable_t inputs[] = {value.vm_variable()};
00084   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
00085   arbb_op(detail::function::current(), arbb_op_acos, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
00086 
00087   return result;
00088 }
00089 
00091 
00094 
00102 template <arbb_scalar_type_t S, std::size_t D>
00103 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, dense<scalar<S>, D> >::type
00104 asin(const dense<scalar<S>, D>& value)
00105 {
00106   dense<scalar<S>, D> result;
00107   const arbb_variable_t outputs[] = {result.vm_variable()};
00108 
00109   const arbb_variable_t inputs[] = {value.vm_variable()};
00110   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
00111   arbb_op(detail::function::current(), arbb_op_asin, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
00112 
00113   return result;
00114 }
00115 
00117 
00120 
00128 template <arbb_scalar_type_t S, std::size_t D>
00129 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, dense<scalar<S>, D> >::type
00130 atan(const dense<scalar<S>, D>& value)
00131 {
00132   dense<scalar<S>, D> result;
00133   const arbb_variable_t outputs[] = {result.vm_variable()};
00134 
00135   const arbb_variable_t inputs[] = {value.vm_variable()};
00136   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
00137   arbb_op(detail::function::current(), arbb_op_atan, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
00138 
00139   return result;
00140 }
00141 
00143 
00146 
00162 template <arbb_scalar_type_t S, std::size_t D>
00163 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D> >::type
00164 clamp(const typename uncaptured<scalar<S> >::type& value, const dense<scalar<S>, D>& minimum, const dense<scalar<S>, D>& maximum)
00165 {
00166   const scalar<S> captured_value = value;
00167   dense<scalar<S>, D> result;
00168 
00169   detail::clamp(result, captured_value, minimum, maximum);
00170 
00171   return result;
00172 }
00173 
00175 
00178 
00194 template <arbb_scalar_type_t S, std::size_t D>
00195 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D> >::type
00196 clamp(const dense<scalar<S>, D>& value, const typename uncaptured<scalar<S> >::type& minimum, const dense<scalar<S>, D>& maximum)
00197 {
00198   const scalar<S> captured_minimum = minimum;
00199   dense<scalar<S>, D> result;
00200 
00201   detail::clamp(result, value, captured_minimum, maximum);
00202 
00203   return result;
00204 }
00205 
00207 
00210 
00229 template <arbb_scalar_type_t S, std::size_t D>
00230 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D> >::type
00231 clamp(const typename uncaptured<scalar<S> >::type& value, const typename uncaptured<scalar<S> >::type& minimum, const dense<scalar<S>, D>& maximum)
00232 {
00233   const scalar<S> captured_value = value;
00234   const scalar<S> captured_minimum = minimum;
00235   dense<scalar<S>, D> result;
00236 
00237   detail::clamp(result, captured_value, captured_minimum, maximum);
00238 
00239   return result;
00240 }
00241 
00243 
00246 
00259 template <arbb_scalar_type_t S, std::size_t D>
00260 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D> >::type
00261 clamp(const dense<scalar<S>, D>& value, const dense<scalar<S>, D>& minimum, const typename uncaptured<scalar<S> >::type& maximum)
00262 {
00263   const scalar<S> captured_maximum = maximum;
00264   dense<scalar<S>, D> result;
00265 
00266   detail::clamp(result, value, minimum, captured_maximum);
00267 
00268   return result;
00269 }
00270 
00272 
00275 
00291 template <arbb_scalar_type_t S, std::size_t D>
00292 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D> >::type
00293 clamp(const typename uncaptured<scalar<S> >::type& value, const dense<scalar<S>, D>& minimum, const typename uncaptured<scalar<S> >::type& maximum)
00294 {
00295   const scalar<S> captured_value = value;
00296   const scalar<S> captured_maximum = maximum;
00297   dense<scalar<S>, D> result;
00298 
00299   detail::clamp(result, captured_value, minimum, captured_maximum);
00300 
00301   return result;
00302 }
00303 
00305 
00308 
00324 template <arbb_scalar_type_t S, std::size_t D>
00325 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D> >::type
00326 clamp(const dense<scalar<S>, D>& value, const typename uncaptured<scalar<S> >::type& minimum, const typename uncaptured<scalar<S> >::type& maximum)
00327 {
00328   const scalar<S> captured_minimum = minimum;
00329   const scalar<S> captured_maximum = maximum;
00330   dense<scalar<S>, D> result;
00331 
00332   detail::clamp(result, value, captured_minimum, captured_maximum);
00333 
00334   return result;
00335 }
00336 
00338 
00341 
00351 template <arbb_scalar_type_t S, std::size_t D>
00352 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D> >::type
00353 clamp(const dense<scalar<S>, D>& value, const dense<scalar<S>, D>& minimum, const dense<scalar<S>, D>& maximum)
00354 {
00355   dense<scalar<S>, D> result;
00356 
00357   detail::clamp(result, value, minimum, maximum);
00358 
00359   return result;
00360 }
00361 
00363 
00366 
00382 template <arbb_scalar_type_t S, std::size_t D>
00383 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D> >::type
00384 clamp(const scalar<S>& value, const dense<scalar<S>, D>& minimum, const dense<scalar<S>, D>& maximum)
00385 {
00386   dense<scalar<S>, D> result;
00387 
00388   detail::clamp(result, value, minimum, maximum);
00389 
00390   return result;
00391 }
00392 
00394 
00397 
00413 template <arbb_scalar_type_t S, std::size_t D>
00414 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D> >::type
00415 clamp(const dense<scalar<S>, D>& value, const scalar<S>& minimum, const dense<scalar<S>, D>& maximum)
00416 {
00417   dense<scalar<S>, D> result;
00418 
00419   detail::clamp(result, value, minimum, maximum);
00420 
00421   return result;
00422 }
00423 
00425 
00428 
00447 template <arbb_scalar_type_t S, std::size_t D>
00448 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D> >::type
00449 clamp(const scalar<S>& value, const scalar<S>& minimum, const dense<scalar<S>, D>& maximum)
00450 {
00451   dense<scalar<S>, D> result;
00452 
00453   detail::clamp(result, value, minimum, maximum);
00454 
00455   return result;
00456 }
00457 
00459 
00462 
00475 template <arbb_scalar_type_t S, std::size_t D>
00476 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D> >::type
00477 clamp(const dense<scalar<S>, D>& value, const dense<scalar<S>, D>& minimum, const scalar<S>& maximum)
00478 {
00479   dense<scalar<S>, D> result;
00480 
00481   detail::clamp(result, value, minimum, maximum);
00482 
00483   return result;
00484 }
00485 
00487 
00490 
00506 template <arbb_scalar_type_t S, std::size_t D>
00507 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D> >::type
00508 clamp(const scalar<S>& value, const dense<scalar<S>, D>& minimum, const scalar<S>& maximum)
00509 {
00510   dense<scalar<S>, D> result;
00511 
00512   detail::clamp(result, value, minimum, maximum);
00513 
00514   return result;
00515 }
00516 
00518 
00521 
00537 template <arbb_scalar_type_t S, std::size_t D>
00538 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D> >::type
00539 clamp(const dense<scalar<S>, D>& value, const scalar<S>& minimum, const scalar<S>& maximum)
00540 {
00541   dense<scalar<S>, D> result;
00542 
00543   detail::clamp(result, value, minimum, maximum);
00544 
00545   return result;
00546 }
00547 
00549 
00552 
00560 template <arbb_scalar_type_t S, std::size_t D>
00561 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, dense<scalar<S>, D> >::type
00562 cos(const dense<scalar<S>, D>& value)
00563 {
00564   dense<scalar<S>, D> result;
00565   const arbb_variable_t outputs[] = {result.vm_variable()};
00566 
00567   const arbb_variable_t inputs[] = {value.vm_variable()};
00568   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
00569   arbb_op(detail::function::current(), arbb_op_cos, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
00570 
00571   return result;
00572 }
00573 
00575 
00578 
00586 template <arbb_scalar_type_t S, std::size_t D>
00587 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, dense<scalar<S>, D> >::type
00588 cosh(const dense<scalar<S>, D>& value)
00589 {
00590   dense<scalar<S>, D> result;
00591   const arbb_variable_t outputs[] = {result.vm_variable()};
00592 
00593   const arbb_variable_t inputs[] = {value.vm_variable()};
00594   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
00595   arbb_op(detail::function::current(), arbb_op_cosh, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
00596 
00597   return result;
00598 }
00599 
00601 
00604 
00612 template <arbb_scalar_type_t S, std::size_t D>
00613 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, dense<scalar<S>, D> >::type
00614 exp(const dense<scalar<S>, D>& value)
00615 {
00616   dense<scalar<S>, D> result;
00617   const arbb_variable_t outputs[] = {result.vm_variable()};
00618 
00619   const arbb_variable_t inputs[] = {value.vm_variable()};
00620   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
00621   arbb_op(detail::function::current(), arbb_op_exp, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
00622 
00623   return result;
00624 }
00625 
00627 
00630 
00638 template <arbb_scalar_type_t S, std::size_t D>
00639 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, dense<scalar<S>, D> >::type
00640 exp10(const dense<scalar<S>, D>& value)
00641 {
00642   dense<scalar<S>, D> result;
00643   const arbb_variable_t outputs[] = {result.vm_variable()};
00644 
00645   const arbb_variable_t inputs[] = {value.vm_variable()};
00646   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
00647   arbb_op(detail::function::current(), arbb_op_exp10, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
00648 
00649   return result;
00650 }
00651 
00653 
00656 
00664 template <arbb_scalar_type_t S, std::size_t D>
00665 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, dense<scalar<S>, D> >::type
00666 floor(const dense<scalar<S>, D>& value)
00667 {
00668   dense<scalar<S>, D> result;
00669   const arbb_variable_t outputs[] = {result.vm_variable()};
00670 
00671   const arbb_variable_t inputs[] = {value.vm_variable()};
00672   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
00673   arbb_op(detail::function::current(), arbb_op_floor, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
00674 
00675   return result;
00676 }
00677 
00679 
00682 
00690 template <arbb_scalar_type_t S, std::size_t D>
00691 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, dense<scalar<S>, D> >::type
00692 ceil(const dense<scalar<S>, D>& value)
00693 {
00694   dense<scalar<S>, D> result;
00695   const arbb_variable_t outputs[] = {result.vm_variable()};
00696 
00697   const arbb_variable_t inputs[] = {value.vm_variable()};
00698   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
00699   arbb_op(detail::function::current(), arbb_op_ceil, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
00700 
00701   return result;
00702 }
00703 
00705 
00708 
00716 template <arbb_scalar_type_t S, std::size_t D>
00717 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, dense<scalar<S>, D> >::type
00718 log(const dense<scalar<S>, D>& value)
00719 {
00720   dense<scalar<S>, D> result;
00721   const arbb_variable_t outputs[] = {result.vm_variable()};
00722 
00723   const arbb_variable_t inputs[] = {value.vm_variable()};
00724   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
00725   arbb_op(detail::function::current(), arbb_op_ln, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
00726 
00727   return result;
00728 }
00729 
00731 
00734 
00742 template <arbb_scalar_type_t S, std::size_t D>
00743 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, dense<scalar<S>, D> >::type
00744 log10(const dense<scalar<S>, D>& value)
00745 {
00746   dense<scalar<S>, D> result;
00747   const arbb_variable_t outputs[] = {result.vm_variable()};
00748 
00749   const arbb_variable_t inputs[] = {value.vm_variable()};
00750   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
00751   arbb_op(detail::function::current(), arbb_op_log10, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
00752 
00753   return result;
00754 }
00755 
00757 
00760 
00768 template <arbb_scalar_type_t S, std::size_t D>
00769 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, dense<scalar<S>, D> >::type
00770 rcp(const dense<scalar<S>, D>& value)
00771 {
00772   dense<scalar<S>, D> result;
00773   const arbb_variable_t outputs[] = {result.vm_variable()};
00774 
00775   const arbb_variable_t inputs[] = {value.vm_variable()};
00776   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
00777   arbb_op(detail::function::current(), arbb_op_rcp, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
00778 
00779   return result;
00780 }
00781 
00783 
00786 
00794 template <arbb_scalar_type_t S, std::size_t D>
00795 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, dense<scalar<S>, D> >::type
00796 round(const dense<scalar<S>, D>& value)
00797 {
00798   dense<scalar<S>, D> result;
00799   const arbb_variable_t outputs[] = {result.vm_variable()};
00800 
00801   const arbb_variable_t inputs[] = {value.vm_variable()};
00802   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
00803   arbb_op(detail::function::current(), arbb_op_round, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
00804 
00805   return result;
00806 }
00807 
00809 
00812 
00820 template <arbb_scalar_type_t S, std::size_t D>
00821 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, dense<scalar<S>, D> >::type
00822 rsqrt(const dense<scalar<S>, D>& value)
00823 {
00824   dense<scalar<S>, D> result;
00825   const arbb_variable_t outputs[] = {result.vm_variable()};
00826 
00827   const arbb_variable_t inputs[] = {value.vm_variable()};
00828   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
00829   arbb_op(detail::function::current(), arbb_op_rsqrt, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
00830 
00831   return result;
00832 }
00833 
00835 
00838 
00846 template <arbb_scalar_type_t S, std::size_t D>
00847 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, dense<scalar<S>, D> >::type
00848 sin(const dense<scalar<S>, D>& value)
00849 {
00850   dense<scalar<S>, D> result;
00851   const arbb_variable_t outputs[] = {result.vm_variable()};
00852 
00853   const arbb_variable_t inputs[] = {value.vm_variable()};
00854   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
00855   arbb_op(detail::function::current(), arbb_op_sin, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
00856 
00857   return result;
00858 }
00859 
00861 
00864 
00872 template <arbb_scalar_type_t S, std::size_t D>
00873 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, dense<scalar<S>, D> >::type
00874 sinh(const dense<scalar<S>, D>& value)
00875 {
00876   dense<scalar<S>, D> result;
00877   const arbb_variable_t outputs[] = {result.vm_variable()};
00878 
00879   const arbb_variable_t inputs[] = {value.vm_variable()};
00880   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
00881   arbb_op(detail::function::current(), arbb_op_sinh, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
00882 
00883   return result;
00884 }
00885 
00887 
00890 
00898 template <arbb_scalar_type_t S, std::size_t D>
00899 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, dense<scalar<S>, D> >::type
00900 sqrt(const dense<scalar<S>, D>& value)
00901 {
00902   dense<scalar<S>, D> result;
00903   const arbb_variable_t outputs[] = {result.vm_variable()};
00904 
00905   const arbb_variable_t inputs[] = {value.vm_variable()};
00906   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
00907   arbb_op(detail::function::current(), arbb_op_sqrt, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
00908 
00909   return result;
00910 }
00911 
00913 
00916 
00924 template <arbb_scalar_type_t S, std::size_t D>
00925 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, dense<scalar<S>, D> >::type
00926 tan(const dense<scalar<S>, D>& value)
00927 {
00928   dense<scalar<S>, D> result;
00929   const arbb_variable_t outputs[] = {result.vm_variable()};
00930 
00931   const arbb_variable_t inputs[] = {value.vm_variable()};
00932   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
00933   arbb_op(detail::function::current(), arbb_op_tan, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
00934 
00935   return result;
00936 }
00937 
00939 
00942 
00950 template <arbb_scalar_type_t S, std::size_t D>
00951 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, dense<scalar<S>, D> >::type
00952 tanh(const dense<scalar<S>, D>& value)
00953 {
00954   dense<scalar<S>, D> result;
00955   const arbb_variable_t outputs[] = {result.vm_variable()};
00956 
00957   const arbb_variable_t inputs[] = {value.vm_variable()};
00958   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
00959   arbb_op(detail::function::current(), arbb_op_tanh, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
00960 
00961   return result;
00962 }
00963 
00965 
00968 
00975 template <std::size_t D>
00976 dense<boolean, D>
00977 operator!(const dense<boolean, D>& value)
00978 {
00979   dense<boolean, D> result;
00980   const arbb_variable_t outputs[] = {result.vm_variable()};
00981 
00982   const arbb_variable_t inputs[] = {value.vm_variable()};
00983   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
00984   arbb_op(detail::function::current(), arbb_op_log_not, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
00985 
00986   return result;
00987 }
00988 
00990 
00993 
01002 template <arbb_scalar_type_t S, std::size_t D>
01003 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D> >::type
01004 operator~(const dense<scalar<S>, D>& value)
01005 {
01006   dense<scalar<S>, D> result;
01007   const arbb_variable_t outputs[] = {result.vm_variable()};
01008 
01009   const arbb_variable_t inputs[] = {value.vm_variable()};
01010   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
01011   arbb_op(detail::function::current(), arbb_op_bit_not, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
01012 
01013   return result;
01014 }
01015 
01017 
01020 
01029 template <arbb_scalar_type_t S, std::size_t D>
01030 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_signed< scalar<S> >::value, dense<scalar<S>, D> >::type
01031 operator-(const dense<scalar<S>, D>& value)
01032 {
01033   dense<scalar<S>, D> result;
01034   const arbb_variable_t outputs[] = {result.vm_variable()};
01035 
01036   const arbb_variable_t inputs[] = {value.vm_variable()};
01037   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
01038   arbb_op(detail::function::current(), arbb_op_neg, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
01039 
01040   return result;
01041 }
01042 
01044 
01047 
01062 template <arbb_scalar_type_t S, std::size_t D>
01063 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D> >::type
01064 operator+(const typename uncaptured<scalar<S> >::type& a, const dense<scalar<S>, D>& b)
01065 {
01066   const scalar<S> captured_a = a;
01067   dense<scalar<S>, D> result;
01068   const arbb_variable_t outputs[] = {result.vm_variable()};
01069 
01070   const arbb_variable_t inputs[] = {captured_a.vm_variable(), b.vm_variable()};
01071   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
01072   arbb_op(detail::function::current(), arbb_op_add, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
01073 
01074   return result;
01075 }
01076 
01078 
01081 
01093 template <arbb_scalar_type_t S, std::size_t D>
01094 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D> >::type
01095 operator+(const dense<scalar<S>, D>& a, const typename uncaptured<scalar<S> >::type& b)
01096 {
01097   const scalar<S> captured_b = b;
01098   dense<scalar<S>, D> result;
01099   const arbb_variable_t outputs[] = {result.vm_variable()};
01100 
01101   const arbb_variable_t inputs[] = {a.vm_variable(), captured_b.vm_variable()};
01102   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
01103   arbb_op(detail::function::current(), arbb_op_add, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
01104 
01105   return result;
01106 }
01107 
01109 
01112 
01121 template <arbb_scalar_type_t S, std::size_t D>
01122 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D> >::type
01123 operator+(const dense<scalar<S>, D>& a, const dense<scalar<S>, D>& b)
01124 {
01125   dense<scalar<S>, D> result;
01126   const arbb_variable_t outputs[] = {result.vm_variable()};
01127 
01128   const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()};
01129   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
01130   arbb_op(detail::function::current(), arbb_op_add, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
01131 
01132   return result;
01133 }
01134 
01136 
01139 
01154 template <arbb_scalar_type_t S, std::size_t D>
01155 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D> >::type
01156 operator+(const scalar<S>& a, const dense<scalar<S>, D>& b)
01157 {
01158   dense<scalar<S>, D> result;
01159   const arbb_variable_t outputs[] = {result.vm_variable()};
01160 
01161   const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()};
01162   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
01163   arbb_op(detail::function::current(), arbb_op_add, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
01164 
01165   return result;
01166 }
01167 
01169 
01172 
01184 template <arbb_scalar_type_t S, std::size_t D>
01185 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D> >::type
01186 operator+(const dense<scalar<S>, D>& a, const scalar<S>& b)
01187 {
01188   dense<scalar<S>, D> result;
01189   const arbb_variable_t outputs[] = {result.vm_variable()};
01190 
01191   const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()};
01192   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
01193   arbb_op(detail::function::current(), arbb_op_add, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
01194 
01195   return result;
01196 }
01197 
01199 
01202 
01214 template <arbb_scalar_type_t S, std::size_t D>
01215 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D>& >::type
01216 operator+=(dense<scalar<S>, D>& value, const typename uncaptured<scalar<S> >::type& increment)
01217 {
01218   const scalar<S> captured_increment = increment;
01219   const arbb_variable_t outputs[] = {value.vm_variable()};
01220 
01221   const arbb_variable_t inputs[] = {value.vm_variable(), captured_increment.vm_variable()};
01222   void* debug_data_ptrs[] = {value.containers_begin()->get_debug_data_ptr()};
01223   arbb_op(detail::function::current(), arbb_op_add, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
01224 
01225   return value;
01226 }
01227 
01229 
01232 
01241 template <arbb_scalar_type_t S, std::size_t D>
01242 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D>& >::type
01243 operator+=(dense<scalar<S>, D>& value, const dense<scalar<S>, D>& increment)
01244 {
01245   const arbb_variable_t outputs[] = {value.vm_variable()};
01246 
01247   const arbb_variable_t inputs[] = {value.vm_variable(), increment.vm_variable()};
01248   void* debug_data_ptrs[] = {value.containers_begin()->get_debug_data_ptr()};
01249   arbb_op(detail::function::current(), arbb_op_add, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
01250 
01251   return value;
01252 }
01253 
01255 
01258 
01270 template <arbb_scalar_type_t S, std::size_t D>
01271 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D>& >::type
01272 operator+=(dense<scalar<S>, D>& value, const scalar<S>& increment)
01273 {
01274   const arbb_variable_t outputs[] = {value.vm_variable()};
01275 
01276   const arbb_variable_t inputs[] = {value.vm_variable(), increment.vm_variable()};
01277   void* debug_data_ptrs[] = {value.containers_begin()->get_debug_data_ptr()};
01278   arbb_op(detail::function::current(), arbb_op_add, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
01279 
01280   return value;
01281 }
01282 
01284 
01287 
01303 template <arbb_scalar_type_t S, std::size_t D>
01304 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D> >::type
01305 operator&(const typename uncaptured<scalar<S> >::type& value, const dense<scalar<S>, D>& mask)
01306 {
01307   const scalar<S> captured_value = value;
01308   dense<scalar<S>, D> result;
01309   const arbb_variable_t outputs[] = {result.vm_variable()};
01310 
01311   const arbb_variable_t inputs[] = {captured_value.vm_variable(), mask.vm_variable()};
01312   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
01313   arbb_op(detail::function::current(), arbb_op_bit_and, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
01314 
01315   return result;
01316 }
01317 
01319 
01322 
01335 template <arbb_scalar_type_t S, std::size_t D>
01336 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D> >::type
01337 operator&(const dense<scalar<S>, D>& value, const typename uncaptured<scalar<S> >::type& mask)
01338 {
01339   const scalar<S> captured_mask = mask;
01340   dense<scalar<S>, D> result;
01341   const arbb_variable_t outputs[] = {result.vm_variable()};
01342 
01343   const arbb_variable_t inputs[] = {value.vm_variable(), captured_mask.vm_variable()};
01344   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
01345   arbb_op(detail::function::current(), arbb_op_bit_and, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
01346 
01347   return result;
01348 }
01349 
01351 
01354 
01364 template <arbb_scalar_type_t S, std::size_t D>
01365 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D> >::type
01366 operator&(const dense<scalar<S>, D>& value, const dense<scalar<S>, D>& mask)
01367 {
01368   dense<scalar<S>, D> result;
01369   const arbb_variable_t outputs[] = {result.vm_variable()};
01370 
01371   const arbb_variable_t inputs[] = {value.vm_variable(), mask.vm_variable()};
01372   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
01373   arbb_op(detail::function::current(), arbb_op_bit_and, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
01374 
01375   return result;
01376 }
01377 
01379 
01382 
01398 template <arbb_scalar_type_t S, std::size_t D>
01399 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D> >::type
01400 operator&(const scalar<S>& value, const dense<scalar<S>, D>& mask)
01401 {
01402   dense<scalar<S>, D> result;
01403   const arbb_variable_t outputs[] = {result.vm_variable()};
01404 
01405   const arbb_variable_t inputs[] = {value.vm_variable(), mask.vm_variable()};
01406   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
01407   arbb_op(detail::function::current(), arbb_op_bit_and, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
01408 
01409   return result;
01410 }
01411 
01413 
01416 
01429 template <arbb_scalar_type_t S, std::size_t D>
01430 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D> >::type
01431 operator&(const dense<scalar<S>, D>& value, const scalar<S>& mask)
01432 {
01433   dense<scalar<S>, D> result;
01434   const arbb_variable_t outputs[] = {result.vm_variable()};
01435 
01436   const arbb_variable_t inputs[] = {value.vm_variable(), mask.vm_variable()};
01437   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
01438   arbb_op(detail::function::current(), arbb_op_bit_and, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
01439 
01440   return result;
01441 }
01442 
01444 
01447 
01460 template <arbb_scalar_type_t S, std::size_t D>
01461 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D>& >::type
01462 operator&=(dense<scalar<S>, D>& value, const typename uncaptured<scalar<S> >::type& mask)
01463 {
01464   const scalar<S> captured_mask = mask;
01465   const arbb_variable_t outputs[] = {value.vm_variable()};
01466 
01467   const arbb_variable_t inputs[] = {value.vm_variable(), captured_mask.vm_variable()};
01468   void* debug_data_ptrs[] = {value.containers_begin()->get_debug_data_ptr()};
01469   arbb_op(detail::function::current(), arbb_op_bit_and, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
01470 
01471   return value;
01472 }
01473 
01475 
01478 
01488 template <arbb_scalar_type_t S, std::size_t D>
01489 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D>& >::type
01490 operator&=(dense<scalar<S>, D>& value, const dense<scalar<S>, D>& mask)
01491 {
01492   const arbb_variable_t outputs[] = {value.vm_variable()};
01493 
01494   const arbb_variable_t inputs[] = {value.vm_variable(), mask.vm_variable()};
01495   void* debug_data_ptrs[] = {value.containers_begin()->get_debug_data_ptr()};
01496   arbb_op(detail::function::current(), arbb_op_bit_and, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
01497 
01498   return value;
01499 }
01500 
01502 
01505 
01518 template <arbb_scalar_type_t S, std::size_t D>
01519 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D>& >::type
01520 operator&=(dense<scalar<S>, D>& value, const scalar<S>& mask)
01521 {
01522   const arbb_variable_t outputs[] = {value.vm_variable()};
01523 
01524   const arbb_variable_t inputs[] = {value.vm_variable(), mask.vm_variable()};
01525   void* debug_data_ptrs[] = {value.containers_begin()->get_debug_data_ptr()};
01526   arbb_op(detail::function::current(), arbb_op_bit_and, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
01527 
01528   return value;
01529 }
01530 
01532 
01535 
01550 template <arbb_scalar_type_t S, std::size_t D>
01551 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, dense<scalar<S>, D> >::type
01552 atan2(const typename uncaptured<scalar<S> >::type& x, const dense<scalar<S>, D>& y)
01553 {
01554   const scalar<S> captured_x = x;
01555   dense<scalar<S>, D> result;
01556   const arbb_variable_t outputs[] = {result.vm_variable()};
01557 
01558   const arbb_variable_t inputs[] = {captured_x.vm_variable(), y.vm_variable()};
01559   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
01560   arbb_op(detail::function::current(), arbb_op_atan2, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
01561 
01562   return result;
01563 }
01564 
01566 
01569 
01581 template <arbb_scalar_type_t S, std::size_t D>
01582 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, dense<scalar<S>, D> >::type
01583 atan2(const dense<scalar<S>, D>& x, const typename uncaptured<scalar<S> >::type& y)
01584 {
01585   const scalar<S> captured_y = y;
01586   dense<scalar<S>, D> result;
01587   const arbb_variable_t outputs[] = {result.vm_variable()};
01588 
01589   const arbb_variable_t inputs[] = {x.vm_variable(), captured_y.vm_variable()};
01590   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
01591   arbb_op(detail::function::current(), arbb_op_atan2, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
01592 
01593   return result;
01594 }
01595 
01597 
01600 
01609 template <arbb_scalar_type_t S, std::size_t D>
01610 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, dense<scalar<S>, D> >::type
01611 atan2(const dense<scalar<S>, D>& x, const dense<scalar<S>, D>& y)
01612 {
01613   dense<scalar<S>, D> result;
01614   const arbb_variable_t outputs[] = {result.vm_variable()};
01615 
01616   const arbb_variable_t inputs[] = {x.vm_variable(), y.vm_variable()};
01617   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
01618   arbb_op(detail::function::current(), arbb_op_atan2, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
01619 
01620   return result;
01621 }
01622 
01624 
01627 
01642 template <arbb_scalar_type_t S, std::size_t D>
01643 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, dense<scalar<S>, D> >::type
01644 atan2(const scalar<S>& x, const dense<scalar<S>, D>& y)
01645 {
01646   dense<scalar<S>, D> result;
01647   const arbb_variable_t outputs[] = {result.vm_variable()};
01648 
01649   const arbb_variable_t inputs[] = {x.vm_variable(), y.vm_variable()};
01650   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
01651   arbb_op(detail::function::current(), arbb_op_atan2, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
01652 
01653   return result;
01654 }
01655 
01657 
01660 
01672 template <arbb_scalar_type_t S, std::size_t D>
01673 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, dense<scalar<S>, D> >::type
01674 atan2(const dense<scalar<S>, D>& x, const scalar<S>& y)
01675 {
01676   dense<scalar<S>, D> result;
01677   const arbb_variable_t outputs[] = {result.vm_variable()};
01678 
01679   const arbb_variable_t inputs[] = {x.vm_variable(), y.vm_variable()};
01680   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
01681   arbb_op(detail::function::current(), arbb_op_atan2, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
01682 
01683   return result;
01684 }
01685 
01687 
01690 
01704 template <arbb_scalar_type_t S, std::size_t D>
01705 dense<isize, D>
01706 compare(const typename uncaptured<scalar<S> >::type& a, const dense<scalar<S>, D>& b)
01707 {
01708   const scalar<S> captured_a = a;
01709   dense<isize, D> result;
01710   const arbb_variable_t outputs[] = {result.vm_variable()};
01711 
01712   const arbb_variable_t inputs[] = {captured_a.vm_variable(), b.vm_variable()};
01713   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
01714   arbb_op(detail::function::current(), arbb_op_compare, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
01715 
01716   return result;
01717 }
01718 
01720 
01723 
01734 template <arbb_scalar_type_t S, std::size_t D>
01735 dense<isize, D>
01736 compare(const dense<scalar<S>, D>& a, const typename uncaptured<scalar<S> >::type& b)
01737 {
01738   const scalar<S> captured_b = b;
01739   dense<isize, D> result;
01740   const arbb_variable_t outputs[] = {result.vm_variable()};
01741 
01742   const arbb_variable_t inputs[] = {a.vm_variable(), captured_b.vm_variable()};
01743   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
01744   arbb_op(detail::function::current(), arbb_op_compare, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
01745 
01746   return result;
01747 }
01748 
01750 
01753 
01761 template <arbb_scalar_type_t S, std::size_t D>
01762 dense<isize, D>
01763 compare(const dense<scalar<S>, D>& a, const dense<scalar<S>, D>& b)
01764 {
01765   dense<isize, D> result;
01766   const arbb_variable_t outputs[] = {result.vm_variable()};
01767 
01768   const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()};
01769   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
01770   arbb_op(detail::function::current(), arbb_op_compare, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
01771 
01772   return result;
01773 }
01774 
01776 
01779 
01793 template <arbb_scalar_type_t S, std::size_t D>
01794 dense<isize, D>
01795 compare(const scalar<S>& a, const dense<scalar<S>, D>& b)
01796 {
01797   dense<isize, D> result;
01798   const arbb_variable_t outputs[] = {result.vm_variable()};
01799 
01800   const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()};
01801   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
01802   arbb_op(detail::function::current(), arbb_op_compare, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
01803 
01804   return result;
01805 }
01806 
01808 
01811 
01822 template <arbb_scalar_type_t S, std::size_t D>
01823 dense<isize, D>
01824 compare(const dense<scalar<S>, D>& a, const scalar<S>& b)
01825 {
01826   dense<isize, D> result;
01827   const arbb_variable_t outputs[] = {result.vm_variable()};
01828 
01829   const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()};
01830   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
01831   arbb_op(detail::function::current(), arbb_op_compare, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
01832 
01833   return result;
01834 }
01835 
01837 
01840 
01855 template <arbb_scalar_type_t S, std::size_t D>
01856 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D> >::type
01857 operator/(const typename uncaptured<scalar<S> >::type& numerator, const dense<scalar<S>, D>& denominator)
01858 {
01859   const scalar<S> captured_numerator = numerator;
01860   dense<scalar<S>, D> result;
01861   const arbb_variable_t outputs[] = {result.vm_variable()};
01862 
01863   const arbb_variable_t inputs[] = {captured_numerator.vm_variable(), denominator.vm_variable()};
01864   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
01865   arbb_op(detail::function::current(), arbb_op_div, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
01866 
01867   return result;
01868 }
01869 
01871 
01874 
01886 template <arbb_scalar_type_t S, std::size_t D>
01887 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D> >::type
01888 operator/(const dense<scalar<S>, D>& numerator, const typename uncaptured<scalar<S> >::type& denominator)
01889 {
01890   const scalar<S> captured_denominator = denominator;
01891   dense<scalar<S>, D> result;
01892   const arbb_variable_t outputs[] = {result.vm_variable()};
01893 
01894   const arbb_variable_t inputs[] = {numerator.vm_variable(), captured_denominator.vm_variable()};
01895   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
01896   arbb_op(detail::function::current(), arbb_op_div, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
01897 
01898   return result;
01899 }
01900 
01902 
01905 
01914 template <arbb_scalar_type_t S, std::size_t D>
01915 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D> >::type
01916 operator/(const dense<scalar<S>, D>& numerator, const dense<scalar<S>, D>& denominator)
01917 {
01918   dense<scalar<S>, D> result;
01919   const arbb_variable_t outputs[] = {result.vm_variable()};
01920 
01921   const arbb_variable_t inputs[] = {numerator.vm_variable(), denominator.vm_variable()};
01922   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
01923   arbb_op(detail::function::current(), arbb_op_div, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
01924 
01925   return result;
01926 }
01927 
01929 
01932 
01947 template <arbb_scalar_type_t S, std::size_t D>
01948 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D> >::type
01949 operator/(const scalar<S>& numerator, const dense<scalar<S>, D>& denominator)
01950 {
01951   dense<scalar<S>, D> result;
01952   const arbb_variable_t outputs[] = {result.vm_variable()};
01953 
01954   const arbb_variable_t inputs[] = {numerator.vm_variable(), denominator.vm_variable()};
01955   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
01956   arbb_op(detail::function::current(), arbb_op_div, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
01957 
01958   return result;
01959 }
01960 
01962 
01965 
01977 template <arbb_scalar_type_t S, std::size_t D>
01978 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D> >::type
01979 operator/(const dense<scalar<S>, D>& numerator, const scalar<S>& denominator)
01980 {
01981   dense<scalar<S>, D> result;
01982   const arbb_variable_t outputs[] = {result.vm_variable()};
01983 
01984   const arbb_variable_t inputs[] = {numerator.vm_variable(), denominator.vm_variable()};
01985   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
01986   arbb_op(detail::function::current(), arbb_op_div, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
01987 
01988   return result;
01989 }
01990 
01992 
01995 
02007 template <arbb_scalar_type_t S, std::size_t D>
02008 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D>& >::type
02009 operator/=(dense<scalar<S>, D>& value, const typename uncaptured<scalar<S> >::type& denominator)
02010 {
02011   const scalar<S> captured_denominator = denominator;
02012   const arbb_variable_t outputs[] = {value.vm_variable()};
02013 
02014   const arbb_variable_t inputs[] = {value.vm_variable(), captured_denominator.vm_variable()};
02015   void* debug_data_ptrs[] = {value.containers_begin()->get_debug_data_ptr()};
02016   arbb_op(detail::function::current(), arbb_op_div, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
02017 
02018   return value;
02019 }
02020 
02022 
02025 
02034 template <arbb_scalar_type_t S, std::size_t D>
02035 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D>& >::type
02036 operator/=(dense<scalar<S>, D>& value, const dense<scalar<S>, D>& denominator)
02037 {
02038   const arbb_variable_t outputs[] = {value.vm_variable()};
02039 
02040   const arbb_variable_t inputs[] = {value.vm_variable(), denominator.vm_variable()};
02041   void* debug_data_ptrs[] = {value.containers_begin()->get_debug_data_ptr()};
02042   arbb_op(detail::function::current(), arbb_op_div, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
02043 
02044   return value;
02045 }
02046 
02048 
02051 
02063 template <arbb_scalar_type_t S, std::size_t D>
02064 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D>& >::type
02065 operator/=(dense<scalar<S>, D>& value, const scalar<S>& denominator)
02066 {
02067   const arbb_variable_t outputs[] = {value.vm_variable()};
02068 
02069   const arbb_variable_t inputs[] = {value.vm_variable(), denominator.vm_variable()};
02070   void* debug_data_ptrs[] = {value.containers_begin()->get_debug_data_ptr()};
02071   arbb_op(detail::function::current(), arbb_op_div, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
02072 
02073   return value;
02074 }
02075 
02077 
02080 
02095 template <arbb_scalar_type_t S, std::size_t D>
02096 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, dense<scalar<S>, D> >::type
02097 div_tan(const typename uncaptured<scalar<S> >::type& x, const dense<scalar<S>, D>& y)
02098 {
02099   const scalar<S> captured_x = x;
02100   dense<scalar<S>, D> result;
02101   const arbb_variable_t outputs[] = {result.vm_variable()};
02102 
02103   const arbb_variable_t inputs[] = {captured_x.vm_variable(), y.vm_variable()};
02104   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
02105   arbb_op(detail::function::current(), arbb_op_div_tan, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
02106 
02107   return result;
02108 }
02109 
02111 
02114 
02126 template <arbb_scalar_type_t S, std::size_t D>
02127 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, dense<scalar<S>, D> >::type
02128 div_tan(const dense<scalar<S>, D>& x, const typename uncaptured<scalar<S> >::type& y)
02129 {
02130   const scalar<S> captured_y = y;
02131   dense<scalar<S>, D> result;
02132   const arbb_variable_t outputs[] = {result.vm_variable()};
02133 
02134   const arbb_variable_t inputs[] = {x.vm_variable(), captured_y.vm_variable()};
02135   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
02136   arbb_op(detail::function::current(), arbb_op_div_tan, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
02137 
02138   return result;
02139 }
02140 
02142 
02145 
02154 template <arbb_scalar_type_t S, std::size_t D>
02155 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, dense<scalar<S>, D> >::type
02156 div_tan(const dense<scalar<S>, D>& x, const dense<scalar<S>, D>& y)
02157 {
02158   dense<scalar<S>, D> result;
02159   const arbb_variable_t outputs[] = {result.vm_variable()};
02160 
02161   const arbb_variable_t inputs[] = {x.vm_variable(), y.vm_variable()};
02162   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
02163   arbb_op(detail::function::current(), arbb_op_div_tan, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
02164 
02165   return result;
02166 }
02167 
02169 
02172 
02187 template <arbb_scalar_type_t S, std::size_t D>
02188 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, dense<scalar<S>, D> >::type
02189 div_tan(const scalar<S>& x, const dense<scalar<S>, D>& y)
02190 {
02191   dense<scalar<S>, D> result;
02192   const arbb_variable_t outputs[] = {result.vm_variable()};
02193 
02194   const arbb_variable_t inputs[] = {x.vm_variable(), y.vm_variable()};
02195   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
02196   arbb_op(detail::function::current(), arbb_op_div_tan, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
02197 
02198   return result;
02199 }
02200 
02202 
02205 
02217 template <arbb_scalar_type_t S, std::size_t D>
02218 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, dense<scalar<S>, D> >::type
02219 div_tan(const dense<scalar<S>, D>& x, const scalar<S>& y)
02220 {
02221   dense<scalar<S>, D> result;
02222   const arbb_variable_t outputs[] = {result.vm_variable()};
02223 
02224   const arbb_variable_t inputs[] = {x.vm_variable(), y.vm_variable()};
02225   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
02226   arbb_op(detail::function::current(), arbb_op_div_tan, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
02227 
02228   return result;
02229 }
02230 
02232 
02235 
02249 template <arbb_scalar_type_t S, std::size_t D>
02250 dense<boolean, D>
02251 operator==(const typename uncaptured<scalar<S> >::type& a, const dense<scalar<S>, D>& b)
02252 {
02253   const scalar<S> captured_a = a;
02254   dense<boolean, D> result;
02255   const arbb_variable_t outputs[] = {result.vm_variable()};
02256 
02257   const arbb_variable_t inputs[] = {captured_a.vm_variable(), b.vm_variable()};
02258   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
02259   arbb_op(detail::function::current(), arbb_op_equal, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
02260 
02261   return result;
02262 }
02263 
02265 
02268 
02279 template <arbb_scalar_type_t S, std::size_t D>
02280 dense<boolean, D>
02281 operator==(const dense<scalar<S>, D>& a, const typename uncaptured<scalar<S> >::type& b)
02282 {
02283   const scalar<S> captured_b = b;
02284   dense<boolean, D> result;
02285   const arbb_variable_t outputs[] = {result.vm_variable()};
02286 
02287   const arbb_variable_t inputs[] = {a.vm_variable(), captured_b.vm_variable()};
02288   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
02289   arbb_op(detail::function::current(), arbb_op_equal, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
02290 
02291   return result;
02292 }
02293 
02295 
02298 
02306 template <arbb_scalar_type_t S, std::size_t D>
02307 dense<boolean, D>
02308 operator==(const dense<scalar<S>, D>& a, const dense<scalar<S>, D>& b)
02309 {
02310   dense<boolean, D> result;
02311   const arbb_variable_t outputs[] = {result.vm_variable()};
02312 
02313   const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()};
02314   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
02315   arbb_op(detail::function::current(), arbb_op_equal, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
02316 
02317   return result;
02318 }
02319 
02321 
02324 
02338 template <arbb_scalar_type_t S, std::size_t D>
02339 dense<boolean, D>
02340 operator==(const scalar<S>& a, const dense<scalar<S>, D>& b)
02341 {
02342   dense<boolean, D> result;
02343   const arbb_variable_t outputs[] = {result.vm_variable()};
02344 
02345   const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()};
02346   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
02347   arbb_op(detail::function::current(), arbb_op_equal, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
02348 
02349   return result;
02350 }
02351 
02353 
02356 
02367 template <arbb_scalar_type_t S, std::size_t D>
02368 dense<boolean, D>
02369 operator==(const dense<scalar<S>, D>& a, const scalar<S>& b)
02370 {
02371   dense<boolean, D> result;
02372   const arbb_variable_t outputs[] = {result.vm_variable()};
02373 
02374   const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()};
02375   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
02376   arbb_op(detail::function::current(), arbb_op_equal, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
02377 
02378   return result;
02379 }
02380 
02382 
02385 
02399 template <arbb_scalar_type_t S, std::size_t D>
02400 dense<boolean, D>
02401 operator>=(const typename uncaptured<scalar<S> >::type& a, const dense<scalar<S>, D>& b)
02402 {
02403   const scalar<S> captured_a = a;
02404   dense<boolean, D> result;
02405   const arbb_variable_t outputs[] = {result.vm_variable()};
02406 
02407   const arbb_variable_t inputs[] = {captured_a.vm_variable(), b.vm_variable()};
02408   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
02409   arbb_op(detail::function::current(), arbb_op_geq, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
02410 
02411   return result;
02412 }
02413 
02415 
02418 
02429 template <arbb_scalar_type_t S, std::size_t D>
02430 dense<boolean, D>
02431 operator>=(const dense<scalar<S>, D>& a, const typename uncaptured<scalar<S> >::type& b)
02432 {
02433   const scalar<S> captured_b = b;
02434   dense<boolean, D> result;
02435   const arbb_variable_t outputs[] = {result.vm_variable()};
02436 
02437   const arbb_variable_t inputs[] = {a.vm_variable(), captured_b.vm_variable()};
02438   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
02439   arbb_op(detail::function::current(), arbb_op_geq, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
02440 
02441   return result;
02442 }
02443 
02445 
02448 
02456 template <arbb_scalar_type_t S, std::size_t D>
02457 dense<boolean, D>
02458 operator>=(const dense<scalar<S>, D>& a, const dense<scalar<S>, D>& b)
02459 {
02460   dense<boolean, D> result;
02461   const arbb_variable_t outputs[] = {result.vm_variable()};
02462 
02463   const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()};
02464   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
02465   arbb_op(detail::function::current(), arbb_op_geq, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
02466 
02467   return result;
02468 }
02469 
02471 
02474 
02488 template <arbb_scalar_type_t S, std::size_t D>
02489 dense<boolean, D>
02490 operator>=(const scalar<S>& a, const dense<scalar<S>, D>& b)
02491 {
02492   dense<boolean, D> result;
02493   const arbb_variable_t outputs[] = {result.vm_variable()};
02494 
02495   const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()};
02496   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
02497   arbb_op(detail::function::current(), arbb_op_geq, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
02498 
02499   return result;
02500 }
02501 
02503 
02506 
02517 template <arbb_scalar_type_t S, std::size_t D>
02518 dense<boolean, D>
02519 operator>=(const dense<scalar<S>, D>& a, const scalar<S>& b)
02520 {
02521   dense<boolean, D> result;
02522   const arbb_variable_t outputs[] = {result.vm_variable()};
02523 
02524   const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()};
02525   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
02526   arbb_op(detail::function::current(), arbb_op_geq, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
02527 
02528   return result;
02529 }
02530 
02532 
02535 
02549 template <arbb_scalar_type_t S, std::size_t D>
02550 dense<boolean, D>
02551 operator>(const typename uncaptured<scalar<S> >::type& a, const dense<scalar<S>, D>& b)
02552 {
02553   const scalar<S> captured_a = a;
02554   dense<boolean, D> result;
02555   const arbb_variable_t outputs[] = {result.vm_variable()};
02556 
02557   const arbb_variable_t inputs[] = {captured_a.vm_variable(), b.vm_variable()};
02558   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
02559   arbb_op(detail::function::current(), arbb_op_greater, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
02560 
02561   return result;
02562 }
02563 
02565 
02568 
02579 template <arbb_scalar_type_t S, std::size_t D>
02580 dense<boolean, D>
02581 operator>(const dense<scalar<S>, D>& a, const typename uncaptured<scalar<S> >::type& b)
02582 {
02583   const scalar<S> captured_b = b;
02584   dense<boolean, D> result;
02585   const arbb_variable_t outputs[] = {result.vm_variable()};
02586 
02587   const arbb_variable_t inputs[] = {a.vm_variable(), captured_b.vm_variable()};
02588   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
02589   arbb_op(detail::function::current(), arbb_op_greater, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
02590 
02591   return result;
02592 }
02593 
02595 
02598 
02606 template <arbb_scalar_type_t S, std::size_t D>
02607 dense<boolean, D>
02608 operator>(const dense<scalar<S>, D>& a, const dense<scalar<S>, D>& b)
02609 {
02610   dense<boolean, D> result;
02611   const arbb_variable_t outputs[] = {result.vm_variable()};
02612 
02613   const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()};
02614   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
02615   arbb_op(detail::function::current(), arbb_op_greater, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
02616 
02617   return result;
02618 }
02619 
02621 
02624 
02638 template <arbb_scalar_type_t S, std::size_t D>
02639 dense<boolean, D>
02640 operator>(const scalar<S>& a, const dense<scalar<S>, D>& b)
02641 {
02642   dense<boolean, D> result;
02643   const arbb_variable_t outputs[] = {result.vm_variable()};
02644 
02645   const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()};
02646   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
02647   arbb_op(detail::function::current(), arbb_op_greater, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
02648 
02649   return result;
02650 }
02651 
02653 
02656 
02667 template <arbb_scalar_type_t S, std::size_t D>
02668 dense<boolean, D>
02669 operator>(const dense<scalar<S>, D>& a, const scalar<S>& b)
02670 {
02671   dense<boolean, D> result;
02672   const arbb_variable_t outputs[] = {result.vm_variable()};
02673 
02674   const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()};
02675   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
02676   arbb_op(detail::function::current(), arbb_op_greater, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
02677 
02678   return result;
02679 }
02680 
02682 
02685 
02701 template <arbb_scalar_type_t S, std::size_t D>
02702 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D> >::type
02703 operator|(const typename uncaptured<scalar<S> >::type& value, const dense<scalar<S>, D>& mask)
02704 {
02705   const scalar<S> captured_value = value;
02706   dense<scalar<S>, D> result;
02707   const arbb_variable_t outputs[] = {result.vm_variable()};
02708 
02709   const arbb_variable_t inputs[] = {captured_value.vm_variable(), mask.vm_variable()};
02710   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
02711   arbb_op(detail::function::current(), arbb_op_bit_or, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
02712 
02713   return result;
02714 }
02715 
02717 
02720 
02733 template <arbb_scalar_type_t S, std::size_t D>
02734 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D> >::type
02735 operator|(const dense<scalar<S>, D>& value, const typename uncaptured<scalar<S> >::type& mask)
02736 {
02737   const scalar<S> captured_mask = mask;
02738   dense<scalar<S>, D> result;
02739   const arbb_variable_t outputs[] = {result.vm_variable()};
02740 
02741   const arbb_variable_t inputs[] = {value.vm_variable(), captured_mask.vm_variable()};
02742   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
02743   arbb_op(detail::function::current(), arbb_op_bit_or, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
02744 
02745   return result;
02746 }
02747 
02749 
02752 
02762 template <arbb_scalar_type_t S, std::size_t D>
02763 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D> >::type
02764 operator|(const dense<scalar<S>, D>& value, const dense<scalar<S>, D>& mask)
02765 {
02766   dense<scalar<S>, D> result;
02767   const arbb_variable_t outputs[] = {result.vm_variable()};
02768 
02769   const arbb_variable_t inputs[] = {value.vm_variable(), mask.vm_variable()};
02770   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
02771   arbb_op(detail::function::current(), arbb_op_bit_or, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
02772 
02773   return result;
02774 }
02775 
02777 
02780 
02796 template <arbb_scalar_type_t S, std::size_t D>
02797 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D> >::type
02798 operator|(const scalar<S>& value, const dense<scalar<S>, D>& mask)
02799 {
02800   dense<scalar<S>, D> result;
02801   const arbb_variable_t outputs[] = {result.vm_variable()};
02802 
02803   const arbb_variable_t inputs[] = {value.vm_variable(), mask.vm_variable()};
02804   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
02805   arbb_op(detail::function::current(), arbb_op_bit_or, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
02806 
02807   return result;
02808 }
02809 
02811 
02814 
02827 template <arbb_scalar_type_t S, std::size_t D>
02828 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D> >::type
02829 operator|(const dense<scalar<S>, D>& value, const scalar<S>& mask)
02830 {
02831   dense<scalar<S>, D> result;
02832   const arbb_variable_t outputs[] = {result.vm_variable()};
02833 
02834   const arbb_variable_t inputs[] = {value.vm_variable(), mask.vm_variable()};
02835   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
02836   arbb_op(detail::function::current(), arbb_op_bit_or, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
02837 
02838   return result;
02839 }
02840 
02842 
02845 
02858 template <arbb_scalar_type_t S, std::size_t D>
02859 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D>& >::type
02860 operator|=(dense<scalar<S>, D>& value, const typename uncaptured<scalar<S> >::type& mask)
02861 {
02862   const scalar<S> captured_mask = mask;
02863   const arbb_variable_t outputs[] = {value.vm_variable()};
02864 
02865   const arbb_variable_t inputs[] = {value.vm_variable(), captured_mask.vm_variable()};
02866   void* debug_data_ptrs[] = {value.containers_begin()->get_debug_data_ptr()};
02867   arbb_op(detail::function::current(), arbb_op_bit_or, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
02868 
02869   return value;
02870 }
02871 
02873 
02876 
02886 template <arbb_scalar_type_t S, std::size_t D>
02887 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D>& >::type
02888 operator|=(dense<scalar<S>, D>& value, const dense<scalar<S>, D>& mask)
02889 {
02890   const arbb_variable_t outputs[] = {value.vm_variable()};
02891 
02892   const arbb_variable_t inputs[] = {value.vm_variable(), mask.vm_variable()};
02893   void* debug_data_ptrs[] = {value.containers_begin()->get_debug_data_ptr()};
02894   arbb_op(detail::function::current(), arbb_op_bit_or, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
02895 
02896   return value;
02897 }
02898 
02900 
02903 
02916 template <arbb_scalar_type_t S, std::size_t D>
02917 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D>& >::type
02918 operator|=(dense<scalar<S>, D>& value, const scalar<S>& mask)
02919 {
02920   const arbb_variable_t outputs[] = {value.vm_variable()};
02921 
02922   const arbb_variable_t inputs[] = {value.vm_variable(), mask.vm_variable()};
02923   void* debug_data_ptrs[] = {value.containers_begin()->get_debug_data_ptr()};
02924   arbb_op(detail::function::current(), arbb_op_bit_or, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
02925 
02926   return value;
02927 }
02928 
02930 
02933 
02947 template <arbb_scalar_type_t S, std::size_t D>
02948 dense<boolean, D>
02949 operator<=(const typename uncaptured<scalar<S> >::type& a, const dense<scalar<S>, D>& b)
02950 {
02951   const scalar<S> captured_a = a;
02952   dense<boolean, D> result;
02953   const arbb_variable_t outputs[] = {result.vm_variable()};
02954 
02955   const arbb_variable_t inputs[] = {captured_a.vm_variable(), b.vm_variable()};
02956   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
02957   arbb_op(detail::function::current(), arbb_op_leq, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
02958 
02959   return result;
02960 }
02961 
02963 
02966 
02977 template <arbb_scalar_type_t S, std::size_t D>
02978 dense<boolean, D>
02979 operator<=(const dense<scalar<S>, D>& a, const typename uncaptured<scalar<S> >::type& b)
02980 {
02981   const scalar<S> captured_b = b;
02982   dense<boolean, D> result;
02983   const arbb_variable_t outputs[] = {result.vm_variable()};
02984 
02985   const arbb_variable_t inputs[] = {a.vm_variable(), captured_b.vm_variable()};
02986   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
02987   arbb_op(detail::function::current(), arbb_op_leq, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
02988 
02989   return result;
02990 }
02991 
02993 
02996 
03004 template <arbb_scalar_type_t S, std::size_t D>
03005 dense<boolean, D>
03006 operator<=(const dense<scalar<S>, D>& a, const dense<scalar<S>, D>& b)
03007 {
03008   dense<boolean, D> result;
03009   const arbb_variable_t outputs[] = {result.vm_variable()};
03010 
03011   const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()};
03012   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
03013   arbb_op(detail::function::current(), arbb_op_leq, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
03014 
03015   return result;
03016 }
03017 
03019 
03022 
03036 template <arbb_scalar_type_t S, std::size_t D>
03037 dense<boolean, D>
03038 operator<=(const scalar<S>& a, const dense<scalar<S>, D>& b)
03039 {
03040   dense<boolean, D> result;
03041   const arbb_variable_t outputs[] = {result.vm_variable()};
03042 
03043   const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()};
03044   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
03045   arbb_op(detail::function::current(), arbb_op_leq, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
03046 
03047   return result;
03048 }
03049 
03051 
03054 
03065 template <arbb_scalar_type_t S, std::size_t D>
03066 dense<boolean, D>
03067 operator<=(const dense<scalar<S>, D>& a, const scalar<S>& b)
03068 {
03069   dense<boolean, D> result;
03070   const arbb_variable_t outputs[] = {result.vm_variable()};
03071 
03072   const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()};
03073   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
03074   arbb_op(detail::function::current(), arbb_op_leq, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
03075 
03076   return result;
03077 }
03078 
03080 
03083 
03097 template <arbb_scalar_type_t S, std::size_t D>
03098 dense<boolean, D>
03099 operator<(const typename uncaptured<scalar<S> >::type& a, const dense<scalar<S>, D>& b)
03100 {
03101   const scalar<S> captured_a = a;
03102   dense<boolean, D> result;
03103   const arbb_variable_t outputs[] = {result.vm_variable()};
03104 
03105   const arbb_variable_t inputs[] = {captured_a.vm_variable(), b.vm_variable()};
03106   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
03107   arbb_op(detail::function::current(), arbb_op_less, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
03108 
03109   return result;
03110 }
03111 
03113 
03116 
03127 template <arbb_scalar_type_t S, std::size_t D>
03128 dense<boolean, D>
03129 operator<(const dense<scalar<S>, D>& a, const typename uncaptured<scalar<S> >::type& b)
03130 {
03131   const scalar<S> captured_b = b;
03132   dense<boolean, D> result;
03133   const arbb_variable_t outputs[] = {result.vm_variable()};
03134 
03135   const arbb_variable_t inputs[] = {a.vm_variable(), captured_b.vm_variable()};
03136   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
03137   arbb_op(detail::function::current(), arbb_op_less, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
03138 
03139   return result;
03140 }
03141 
03143 
03146 
03154 template <arbb_scalar_type_t S, std::size_t D>
03155 dense<boolean, D>
03156 operator<(const dense<scalar<S>, D>& a, const dense<scalar<S>, D>& b)
03157 {
03158   dense<boolean, D> result;
03159   const arbb_variable_t outputs[] = {result.vm_variable()};
03160 
03161   const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()};
03162   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
03163   arbb_op(detail::function::current(), arbb_op_less, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
03164 
03165   return result;
03166 }
03167 
03169 
03172 
03186 template <arbb_scalar_type_t S, std::size_t D>
03187 dense<boolean, D>
03188 operator<(const scalar<S>& a, const dense<scalar<S>, D>& b)
03189 {
03190   dense<boolean, D> result;
03191   const arbb_variable_t outputs[] = {result.vm_variable()};
03192 
03193   const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()};
03194   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
03195   arbb_op(detail::function::current(), arbb_op_less, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
03196 
03197   return result;
03198 }
03199 
03201 
03204 
03215 template <arbb_scalar_type_t S, std::size_t D>
03216 dense<boolean, D>
03217 operator<(const dense<scalar<S>, D>& a, const scalar<S>& b)
03218 {
03219   dense<boolean, D> result;
03220   const arbb_variable_t outputs[] = {result.vm_variable()};
03221 
03222   const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()};
03223   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
03224   arbb_op(detail::function::current(), arbb_op_less, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
03225 
03226   return result;
03227 }
03228 
03230 
03233 
03247 template <std::size_t D>
03248 dense<boolean, D>
03249 operator&&(const typename uncaptured<boolean >::type& a, const dense<boolean, D>& b)
03250 {
03251   const boolean captured_a = a;
03252   dense<boolean, D> result;
03253   const arbb_variable_t outputs[] = {result.vm_variable()};
03254 
03255   const arbb_variable_t inputs[] = {captured_a.vm_variable(), b.vm_variable()};
03256   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
03257   arbb_op(detail::function::current(), arbb_op_log_and, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
03258 
03259   return result;
03260 }
03261 
03263 
03266 
03277 template <std::size_t D>
03278 dense<boolean, D>
03279 operator&&(const dense<boolean, D>& a, const typename uncaptured<boolean >::type& b)
03280 {
03281   const boolean captured_b = b;
03282   dense<boolean, D> result;
03283   const arbb_variable_t outputs[] = {result.vm_variable()};
03284 
03285   const arbb_variable_t inputs[] = {a.vm_variable(), captured_b.vm_variable()};
03286   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
03287   arbb_op(detail::function::current(), arbb_op_log_and, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
03288 
03289   return result;
03290 }
03291 
03293 
03296 
03304 template <std::size_t D>
03305 dense<boolean, D>
03306 operator&&(const dense<boolean, D>& a, const dense<boolean, D>& b)
03307 {
03308   dense<boolean, D> result;
03309   const arbb_variable_t outputs[] = {result.vm_variable()};
03310 
03311   const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()};
03312   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
03313   arbb_op(detail::function::current(), arbb_op_log_and, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
03314 
03315   return result;
03316 }
03317 
03319 
03322 
03336 template <std::size_t D>
03337 dense<boolean, D>
03338 operator&&(const boolean& a, const dense<boolean, D>& b)
03339 {
03340   dense<boolean, D> result;
03341   const arbb_variable_t outputs[] = {result.vm_variable()};
03342 
03343   const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()};
03344   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
03345   arbb_op(detail::function::current(), arbb_op_log_and, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
03346 
03347   return result;
03348 }
03349 
03351 
03354 
03365 template <std::size_t D>
03366 dense<boolean, D>
03367 operator&&(const dense<boolean, D>& a, const boolean& b)
03368 {
03369   dense<boolean, D> result;
03370   const arbb_variable_t outputs[] = {result.vm_variable()};
03371 
03372   const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()};
03373   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
03374   arbb_op(detail::function::current(), arbb_op_log_and, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
03375 
03376   return result;
03377 }
03378 
03380 
03383 
03397 template <std::size_t D>
03398 dense<boolean, D>
03399 operator||(const typename uncaptured<boolean >::type& a, const dense<boolean, D>& b)
03400 {
03401   const boolean captured_a = a;
03402   dense<boolean, D> result;
03403   const arbb_variable_t outputs[] = {result.vm_variable()};
03404 
03405   const arbb_variable_t inputs[] = {captured_a.vm_variable(), b.vm_variable()};
03406   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
03407   arbb_op(detail::function::current(), arbb_op_log_or, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
03408 
03409   return result;
03410 }
03411 
03413 
03416 
03427 template <std::size_t D>
03428 dense<boolean, D>
03429 operator||(const dense<boolean, D>& a, const typename uncaptured<boolean >::type& b)
03430 {
03431   const boolean captured_b = b;
03432   dense<boolean, D> result;
03433   const arbb_variable_t outputs[] = {result.vm_variable()};
03434 
03435   const arbb_variable_t inputs[] = {a.vm_variable(), captured_b.vm_variable()};
03436   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
03437   arbb_op(detail::function::current(), arbb_op_log_or, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
03438 
03439   return result;
03440 }
03441 
03443 
03446 
03454 template <std::size_t D>
03455 dense<boolean, D>
03456 operator||(const dense<boolean, D>& a, const dense<boolean, D>& b)
03457 {
03458   dense<boolean, D> result;
03459   const arbb_variable_t outputs[] = {result.vm_variable()};
03460 
03461   const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()};
03462   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
03463   arbb_op(detail::function::current(), arbb_op_log_or, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
03464 
03465   return result;
03466 }
03467 
03469 
03472 
03486 template <std::size_t D>
03487 dense<boolean, D>
03488 operator||(const boolean& a, const dense<boolean, D>& b)
03489 {
03490   dense<boolean, D> result;
03491   const arbb_variable_t outputs[] = {result.vm_variable()};
03492 
03493   const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()};
03494   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
03495   arbb_op(detail::function::current(), arbb_op_log_or, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
03496 
03497   return result;
03498 }
03499 
03501 
03504 
03515 template <std::size_t D>
03516 dense<boolean, D>
03517 operator||(const dense<boolean, D>& a, const boolean& b)
03518 {
03519   dense<boolean, D> result;
03520   const arbb_variable_t outputs[] = {result.vm_variable()};
03521 
03522   const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()};
03523   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
03524   arbb_op(detail::function::current(), arbb_op_log_or, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
03525 
03526   return result;
03527 }
03528 
03530 
03533 
03549 template <arbb_scalar_type_t S, std::size_t D>
03550 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D> >::type
03551 operator<<(const typename uncaptured<scalar<S> >::type& value, const dense<scalar<S>, D>& shift_amount)
03552 {
03553   const scalar<S> captured_value = value;
03554   dense<scalar<S>, D> result;
03555 
03556   detail::operator_lsh(result, captured_value, shift_amount);
03557 
03558   return result;
03559 }
03560 
03562 
03565 
03578 template <arbb_scalar_type_t S, std::size_t D>
03579 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D> >::type
03580 operator<<(const dense<scalar<S>, D>& value, const typename uncaptured<scalar<S> >::type& shift_amount)
03581 {
03582   const scalar<S> captured_shift_amount = shift_amount;
03583   dense<scalar<S>, D> result;
03584 
03585   detail::operator_lsh(result, value, captured_shift_amount);
03586 
03587   return result;
03588 }
03589 
03591 
03594 
03604 template <arbb_scalar_type_t S, std::size_t D>
03605 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D> >::type
03606 operator<<(const dense<scalar<S>, D>& value, const dense<scalar<S>, D>& shift_amount)
03607 {
03608   dense<scalar<S>, D> result;
03609 
03610   detail::operator_lsh(result, value, shift_amount);
03611 
03612   return result;
03613 }
03614 
03616 
03619 
03635 template <arbb_scalar_type_t S, std::size_t D>
03636 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D> >::type
03637 operator<<(const scalar<S>& value, const dense<scalar<S>, D>& shift_amount)
03638 {
03639   dense<scalar<S>, D> result;
03640 
03641   detail::operator_lsh(result, value, shift_amount);
03642 
03643   return result;
03644 }
03645 
03647 
03650 
03663 template <arbb_scalar_type_t S, std::size_t D>
03664 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D> >::type
03665 operator<<(const dense<scalar<S>, D>& value, const scalar<S>& shift_amount)
03666 {
03667   dense<scalar<S>, D> result;
03668 
03669   detail::operator_lsh(result, value, shift_amount);
03670 
03671   return result;
03672 }
03673 
03675 
03678 
03691 template <arbb_scalar_type_t S, std::size_t D>
03692 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D>& >::type
03693 operator<<=(dense<scalar<S>, D>& value, const typename uncaptured<scalar<S> >::type& shift_amount)
03694 {
03695   const scalar<S> captured_shift_amount = shift_amount;
03696 
03697   detail::operator_lsh(value, value, captured_shift_amount);
03698 
03699   return value;
03700 }
03701 
03703 
03706 
03716 template <arbb_scalar_type_t S, std::size_t D>
03717 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D>& >::type
03718 operator<<=(dense<scalar<S>, D>& value, const dense<scalar<S>, D>& shift_amount)
03719 {
03720 
03721   detail::operator_lsh(value, value, shift_amount);
03722 
03723   return value;
03724 }
03725 
03727 
03730 
03743 template <arbb_scalar_type_t S, std::size_t D>
03744 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D>& >::type
03745 operator<<=(dense<scalar<S>, D>& value, const scalar<S>& shift_amount)
03746 {
03747 
03748   detail::operator_lsh(value, value, shift_amount);
03749 
03750   return value;
03751 }
03752 
03754 
03757 
03771 template <arbb_scalar_type_t S, std::size_t D>
03772 dense<scalar<S>, D>
03773 max(const typename uncaptured<scalar<S> >::type& a, const dense<scalar<S>, D>& b)
03774 {
03775   const scalar<S> captured_a = a;
03776   dense<scalar<S>, D> result;
03777   const arbb_variable_t outputs[] = {result.vm_variable()};
03778 
03779   const arbb_variable_t inputs[] = {captured_a.vm_variable(), b.vm_variable()};
03780   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
03781   arbb_op(detail::function::current(), arbb_op_max, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
03782 
03783   return result;
03784 }
03785 
03787 
03790 
03801 template <arbb_scalar_type_t S, std::size_t D>
03802 dense<scalar<S>, D>
03803 max(const dense<scalar<S>, D>& a, const typename uncaptured<scalar<S> >::type& b)
03804 {
03805   const scalar<S> captured_b = b;
03806   dense<scalar<S>, D> result;
03807   const arbb_variable_t outputs[] = {result.vm_variable()};
03808 
03809   const arbb_variable_t inputs[] = {a.vm_variable(), captured_b.vm_variable()};
03810   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
03811   arbb_op(detail::function::current(), arbb_op_max, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
03812 
03813   return result;
03814 }
03815 
03817 
03820 
03828 template <arbb_scalar_type_t S, std::size_t D>
03829 dense<scalar<S>, D>
03830 max(const dense<scalar<S>, D>& a, const dense<scalar<S>, D>& b)
03831 {
03832   dense<scalar<S>, D> result;
03833   const arbb_variable_t outputs[] = {result.vm_variable()};
03834 
03835   const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()};
03836   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
03837   arbb_op(detail::function::current(), arbb_op_max, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
03838 
03839   return result;
03840 }
03841 
03843 
03846 
03860 template <arbb_scalar_type_t S, std::size_t D>
03861 dense<scalar<S>, D>
03862 max(const scalar<S>& a, const dense<scalar<S>, D>& b)
03863 {
03864   dense<scalar<S>, D> result;
03865   const arbb_variable_t outputs[] = {result.vm_variable()};
03866 
03867   const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()};
03868   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
03869   arbb_op(detail::function::current(), arbb_op_max, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
03870 
03871   return result;
03872 }
03873 
03875 
03878 
03889 template <arbb_scalar_type_t S, std::size_t D>
03890 dense<scalar<S>, D>
03891 max(const dense<scalar<S>, D>& a, const scalar<S>& b)
03892 {
03893   dense<scalar<S>, D> result;
03894   const arbb_variable_t outputs[] = {result.vm_variable()};
03895 
03896   const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()};
03897   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
03898   arbb_op(detail::function::current(), arbb_op_max, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
03899 
03900   return result;
03901 }
03902 
03904 
03907 
03921 template <arbb_scalar_type_t S, std::size_t D>
03922 dense<scalar<S>, D>
03923 min(const typename uncaptured<scalar<S> >::type& a, const dense<scalar<S>, D>& b)
03924 {
03925   const scalar<S> captured_a = a;
03926   dense<scalar<S>, D> result;
03927   const arbb_variable_t outputs[] = {result.vm_variable()};
03928 
03929   const arbb_variable_t inputs[] = {captured_a.vm_variable(), b.vm_variable()};
03930   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
03931   arbb_op(detail::function::current(), arbb_op_min, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
03932 
03933   return result;
03934 }
03935 
03937 
03940 
03951 template <arbb_scalar_type_t S, std::size_t D>
03952 dense<scalar<S>, D>
03953 min(const dense<scalar<S>, D>& a, const typename uncaptured<scalar<S> >::type& b)
03954 {
03955   const scalar<S> captured_b = b;
03956   dense<scalar<S>, D> result;
03957   const arbb_variable_t outputs[] = {result.vm_variable()};
03958 
03959   const arbb_variable_t inputs[] = {a.vm_variable(), captured_b.vm_variable()};
03960   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
03961   arbb_op(detail::function::current(), arbb_op_min, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
03962 
03963   return result;
03964 }
03965 
03967 
03970 
03978 template <arbb_scalar_type_t S, std::size_t D>
03979 dense<scalar<S>, D>
03980 min(const dense<scalar<S>, D>& a, const dense<scalar<S>, D>& b)
03981 {
03982   dense<scalar<S>, D> result;
03983   const arbb_variable_t outputs[] = {result.vm_variable()};
03984 
03985   const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()};
03986   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
03987   arbb_op(detail::function::current(), arbb_op_min, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
03988 
03989   return result;
03990 }
03991 
03993 
03996 
04010 template <arbb_scalar_type_t S, std::size_t D>
04011 dense<scalar<S>, D>
04012 min(const scalar<S>& a, const dense<scalar<S>, D>& b)
04013 {
04014   dense<scalar<S>, D> result;
04015   const arbb_variable_t outputs[] = {result.vm_variable()};
04016 
04017   const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()};
04018   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
04019   arbb_op(detail::function::current(), arbb_op_min, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
04020 
04021   return result;
04022 }
04023 
04025 
04028 
04039 template <arbb_scalar_type_t S, std::size_t D>
04040 dense<scalar<S>, D>
04041 min(const dense<scalar<S>, D>& a, const scalar<S>& b)
04042 {
04043   dense<scalar<S>, D> result;
04044   const arbb_variable_t outputs[] = {result.vm_variable()};
04045 
04046   const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()};
04047   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
04048   arbb_op(detail::function::current(), arbb_op_min, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
04049 
04050   return result;
04051 }
04052 
04054 
04057 
04073 template <arbb_scalar_type_t S, std::size_t D>
04074 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D> >::type
04075 operator%(const typename uncaptured<scalar<S> >::type& dividend, const dense<scalar<S>, D>& divisor)
04076 {
04077   const scalar<S> captured_dividend = dividend;
04078   dense<scalar<S>, D> result;
04079   const arbb_variable_t outputs[] = {result.vm_variable()};
04080 
04081   const arbb_variable_t inputs[] = {captured_dividend.vm_variable(), divisor.vm_variable()};
04082   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
04083   arbb_op(detail::function::current(), arbb_op_mod, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
04084 
04085   return result;
04086 }
04087 
04089 
04092 
04105 template <arbb_scalar_type_t S, std::size_t D>
04106 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D> >::type
04107 operator%(const dense<scalar<S>, D>& dividend, const typename uncaptured<scalar<S> >::type& divisor)
04108 {
04109   const scalar<S> captured_divisor = divisor;
04110   dense<scalar<S>, D> result;
04111   const arbb_variable_t outputs[] = {result.vm_variable()};
04112 
04113   const arbb_variable_t inputs[] = {dividend.vm_variable(), captured_divisor.vm_variable()};
04114   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
04115   arbb_op(detail::function::current(), arbb_op_mod, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
04116 
04117   return result;
04118 }
04119 
04121 
04124 
04134 template <arbb_scalar_type_t S, std::size_t D>
04135 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D> >::type
04136 operator%(const dense<scalar<S>, D>& dividend, const dense<scalar<S>, D>& divisor)
04137 {
04138   dense<scalar<S>, D> result;
04139   const arbb_variable_t outputs[] = {result.vm_variable()};
04140 
04141   const arbb_variable_t inputs[] = {dividend.vm_variable(), divisor.vm_variable()};
04142   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
04143   arbb_op(detail::function::current(), arbb_op_mod, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
04144 
04145   return result;
04146 }
04147 
04149 
04152 
04168 template <arbb_scalar_type_t S, std::size_t D>
04169 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D> >::type
04170 operator%(const scalar<S>& dividend, const dense<scalar<S>, D>& divisor)
04171 {
04172   dense<scalar<S>, D> result;
04173   const arbb_variable_t outputs[] = {result.vm_variable()};
04174 
04175   const arbb_variable_t inputs[] = {dividend.vm_variable(), divisor.vm_variable()};
04176   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
04177   arbb_op(detail::function::current(), arbb_op_mod, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
04178 
04179   return result;
04180 }
04181 
04183 
04186 
04199 template <arbb_scalar_type_t S, std::size_t D>
04200 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D> >::type
04201 operator%(const dense<scalar<S>, D>& dividend, const scalar<S>& divisor)
04202 {
04203   dense<scalar<S>, D> result;
04204   const arbb_variable_t outputs[] = {result.vm_variable()};
04205 
04206   const arbb_variable_t inputs[] = {dividend.vm_variable(), divisor.vm_variable()};
04207   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
04208   arbb_op(detail::function::current(), arbb_op_mod, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
04209 
04210   return result;
04211 }
04212 
04214 
04217 
04230 template <arbb_scalar_type_t S, std::size_t D>
04231 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D>& >::type
04232 operator%=(dense<scalar<S>, D>& value, const typename uncaptured<scalar<S> >::type& divisor)
04233 {
04234   const scalar<S> captured_divisor = divisor;
04235   const arbb_variable_t outputs[] = {value.vm_variable()};
04236 
04237   const arbb_variable_t inputs[] = {value.vm_variable(), captured_divisor.vm_variable()};
04238   void* debug_data_ptrs[] = {value.containers_begin()->get_debug_data_ptr()};
04239   arbb_op(detail::function::current(), arbb_op_mod, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
04240 
04241   return value;
04242 }
04243 
04245 
04248 
04258 template <arbb_scalar_type_t S, std::size_t D>
04259 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D>& >::type
04260 operator%=(dense<scalar<S>, D>& value, const dense<scalar<S>, D>& divisor)
04261 {
04262   const arbb_variable_t outputs[] = {value.vm_variable()};
04263 
04264   const arbb_variable_t inputs[] = {value.vm_variable(), divisor.vm_variable()};
04265   void* debug_data_ptrs[] = {value.containers_begin()->get_debug_data_ptr()};
04266   arbb_op(detail::function::current(), arbb_op_mod, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
04267 
04268   return value;
04269 }
04270 
04272 
04275 
04288 template <arbb_scalar_type_t S, std::size_t D>
04289 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D>& >::type
04290 operator%=(dense<scalar<S>, D>& value, const scalar<S>& divisor)
04291 {
04292   const arbb_variable_t outputs[] = {value.vm_variable()};
04293 
04294   const arbb_variable_t inputs[] = {value.vm_variable(), divisor.vm_variable()};
04295   void* debug_data_ptrs[] = {value.containers_begin()->get_debug_data_ptr()};
04296   arbb_op(detail::function::current(), arbb_op_mod, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
04297 
04298   return value;
04299 }
04300 
04302 
04305 
04320 template <arbb_scalar_type_t S, std::size_t D>
04321 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D> >::type
04322 operator*(const typename uncaptured<scalar<S> >::type& a, const dense<scalar<S>, D>& b)
04323 {
04324   const scalar<S> captured_a = a;
04325   dense<scalar<S>, D> result;
04326   const arbb_variable_t outputs[] = {result.vm_variable()};
04327 
04328   const arbb_variable_t inputs[] = {captured_a.vm_variable(), b.vm_variable()};
04329   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
04330   arbb_op(detail::function::current(), arbb_op_mul, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
04331 
04332   return result;
04333 }
04334 
04336 
04339 
04351 template <arbb_scalar_type_t S, std::size_t D>
04352 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D> >::type
04353 operator*(const dense<scalar<S>, D>& a, const typename uncaptured<scalar<S> >::type& b)
04354 {
04355   const scalar<S> captured_b = b;
04356   dense<scalar<S>, D> result;
04357   const arbb_variable_t outputs[] = {result.vm_variable()};
04358 
04359   const arbb_variable_t inputs[] = {a.vm_variable(), captured_b.vm_variable()};
04360   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
04361   arbb_op(detail::function::current(), arbb_op_mul, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
04362 
04363   return result;
04364 }
04365 
04367 
04370 
04379 template <arbb_scalar_type_t S, std::size_t D>
04380 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D> >::type
04381 operator*(const dense<scalar<S>, D>& a, const dense<scalar<S>, D>& b)
04382 {
04383   dense<scalar<S>, D> result;
04384   const arbb_variable_t outputs[] = {result.vm_variable()};
04385 
04386   const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()};
04387   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
04388   arbb_op(detail::function::current(), arbb_op_mul, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
04389 
04390   return result;
04391 }
04392 
04394 
04397 
04412 template <arbb_scalar_type_t S, std::size_t D>
04413 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D> >::type
04414 operator*(const scalar<S>& a, const dense<scalar<S>, D>& b)
04415 {
04416   dense<scalar<S>, D> result;
04417   const arbb_variable_t outputs[] = {result.vm_variable()};
04418 
04419   const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()};
04420   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
04421   arbb_op(detail::function::current(), arbb_op_mul, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
04422 
04423   return result;
04424 }
04425 
04427 
04430 
04442 template <arbb_scalar_type_t S, std::size_t D>
04443 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D> >::type
04444 operator*(const dense<scalar<S>, D>& a, const scalar<S>& b)
04445 {
04446   dense<scalar<S>, D> result;
04447   const arbb_variable_t outputs[] = {result.vm_variable()};
04448 
04449   const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()};
04450   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
04451   arbb_op(detail::function::current(), arbb_op_mul, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
04452 
04453   return result;
04454 }
04455 
04457 
04460 
04472 template <arbb_scalar_type_t S, std::size_t D>
04473 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D>& >::type
04474 operator*=(dense<scalar<S>, D>& value, const typename uncaptured<scalar<S> >::type& multiplicand)
04475 {
04476   const scalar<S> captured_multiplicand = multiplicand;
04477   const arbb_variable_t outputs[] = {value.vm_variable()};
04478 
04479   const arbb_variable_t inputs[] = {value.vm_variable(), captured_multiplicand.vm_variable()};
04480   void* debug_data_ptrs[] = {value.containers_begin()->get_debug_data_ptr()};
04481   arbb_op(detail::function::current(), arbb_op_mul, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
04482 
04483   return value;
04484 }
04485 
04487 
04490 
04499 template <arbb_scalar_type_t S, std::size_t D>
04500 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D>& >::type
04501 operator*=(dense<scalar<S>, D>& value, const dense<scalar<S>, D>& multiplicand)
04502 {
04503   const arbb_variable_t outputs[] = {value.vm_variable()};
04504 
04505   const arbb_variable_t inputs[] = {value.vm_variable(), multiplicand.vm_variable()};
04506   void* debug_data_ptrs[] = {value.containers_begin()->get_debug_data_ptr()};
04507   arbb_op(detail::function::current(), arbb_op_mul, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
04508 
04509   return value;
04510 }
04511 
04513 
04516 
04528 template <arbb_scalar_type_t S, std::size_t D>
04529 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D>& >::type
04530 operator*=(dense<scalar<S>, D>& value, const scalar<S>& multiplicand)
04531 {
04532   const arbb_variable_t outputs[] = {value.vm_variable()};
04533 
04534   const arbb_variable_t inputs[] = {value.vm_variable(), multiplicand.vm_variable()};
04535   void* debug_data_ptrs[] = {value.containers_begin()->get_debug_data_ptr()};
04536   arbb_op(detail::function::current(), arbb_op_mul, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
04537 
04538   return value;
04539 }
04540 
04542 
04545 
04559 template <arbb_scalar_type_t S, std::size_t D>
04560 dense<boolean, D>
04561 operator!=(const typename uncaptured<scalar<S> >::type& a, const dense<scalar<S>, D>& b)
04562 {
04563   const scalar<S> captured_a = a;
04564   dense<boolean, D> result;
04565   const arbb_variable_t outputs[] = {result.vm_variable()};
04566 
04567   const arbb_variable_t inputs[] = {captured_a.vm_variable(), b.vm_variable()};
04568   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
04569   arbb_op(detail::function::current(), arbb_op_neq, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
04570 
04571   return result;
04572 }
04573 
04575 
04578 
04589 template <arbb_scalar_type_t S, std::size_t D>
04590 dense<boolean, D>
04591 operator!=(const dense<scalar<S>, D>& a, const typename uncaptured<scalar<S> >::type& b)
04592 {
04593   const scalar<S> captured_b = b;
04594   dense<boolean, D> result;
04595   const arbb_variable_t outputs[] = {result.vm_variable()};
04596 
04597   const arbb_variable_t inputs[] = {a.vm_variable(), captured_b.vm_variable()};
04598   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
04599   arbb_op(detail::function::current(), arbb_op_neq, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
04600 
04601   return result;
04602 }
04603 
04605 
04608 
04616 template <arbb_scalar_type_t S, std::size_t D>
04617 dense<boolean, D>
04618 operator!=(const dense<scalar<S>, D>& a, const dense<scalar<S>, D>& b)
04619 {
04620   dense<boolean, D> result;
04621   const arbb_variable_t outputs[] = {result.vm_variable()};
04622 
04623   const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()};
04624   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
04625   arbb_op(detail::function::current(), arbb_op_neq, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
04626 
04627   return result;
04628 }
04629 
04631 
04634 
04648 template <arbb_scalar_type_t S, std::size_t D>
04649 dense<boolean, D>
04650 operator!=(const scalar<S>& a, const dense<scalar<S>, D>& b)
04651 {
04652   dense<boolean, D> result;
04653   const arbb_variable_t outputs[] = {result.vm_variable()};
04654 
04655   const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()};
04656   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
04657   arbb_op(detail::function::current(), arbb_op_neq, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
04658 
04659   return result;
04660 }
04661 
04663 
04666 
04677 template <arbb_scalar_type_t S, std::size_t D>
04678 dense<boolean, D>
04679 operator!=(const dense<scalar<S>, D>& a, const scalar<S>& b)
04680 {
04681   dense<boolean, D> result;
04682   const arbb_variable_t outputs[] = {result.vm_variable()};
04683 
04684   const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()};
04685   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
04686   arbb_op(detail::function::current(), arbb_op_neq, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
04687 
04688   return result;
04689 }
04690 
04692 
04695 
04710 template <arbb_scalar_type_t S, std::size_t D>
04711 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, dense<scalar<S>, D> >::type
04712 pow(const typename uncaptured<scalar<S> >::type& base, const dense<scalar<S>, D>& exponent)
04713 {
04714   const scalar<S> captured_base = base;
04715   dense<scalar<S>, D> result;
04716   const arbb_variable_t outputs[] = {result.vm_variable()};
04717 
04718   const arbb_variable_t inputs[] = {captured_base.vm_variable(), exponent.vm_variable()};
04719   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
04720   arbb_op(detail::function::current(), arbb_op_pow, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
04721 
04722   return result;
04723 }
04724 
04726 
04729 
04741 template <arbb_scalar_type_t S, std::size_t D>
04742 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, dense<scalar<S>, D> >::type
04743 pow(const dense<scalar<S>, D>& base, const typename uncaptured<scalar<S> >::type& exponent)
04744 {
04745   const scalar<S> captured_exponent = exponent;
04746   dense<scalar<S>, D> result;
04747   const arbb_variable_t outputs[] = {result.vm_variable()};
04748 
04749   const arbb_variable_t inputs[] = {base.vm_variable(), captured_exponent.vm_variable()};
04750   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
04751   arbb_op(detail::function::current(), arbb_op_pow, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
04752 
04753   return result;
04754 }
04755 
04757 
04760 
04769 template <arbb_scalar_type_t S, std::size_t D>
04770 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, dense<scalar<S>, D> >::type
04771 pow(const dense<scalar<S>, D>& base, const dense<scalar<S>, D>& exponent)
04772 {
04773   dense<scalar<S>, D> result;
04774   const arbb_variable_t outputs[] = {result.vm_variable()};
04775 
04776   const arbb_variable_t inputs[] = {base.vm_variable(), exponent.vm_variable()};
04777   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
04778   arbb_op(detail::function::current(), arbb_op_pow, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
04779 
04780   return result;
04781 }
04782 
04784 
04787 
04802 template <arbb_scalar_type_t S, std::size_t D>
04803 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, dense<scalar<S>, D> >::type
04804 pow(const scalar<S>& base, const dense<scalar<S>, D>& exponent)
04805 {
04806   dense<scalar<S>, D> result;
04807   const arbb_variable_t outputs[] = {result.vm_variable()};
04808 
04809   const arbb_variable_t inputs[] = {base.vm_variable(), exponent.vm_variable()};
04810   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
04811   arbb_op(detail::function::current(), arbb_op_pow, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
04812 
04813   return result;
04814 }
04815 
04817 
04820 
04832 template <arbb_scalar_type_t S, std::size_t D>
04833 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, dense<scalar<S>, D> >::type
04834 pow(const dense<scalar<S>, D>& base, const scalar<S>& exponent)
04835 {
04836   dense<scalar<S>, D> result;
04837   const arbb_variable_t outputs[] = {result.vm_variable()};
04838 
04839   const arbb_variable_t inputs[] = {base.vm_variable(), exponent.vm_variable()};
04840   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
04841   arbb_op(detail::function::current(), arbb_op_pow, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
04842 
04843   return result;
04844 }
04845 
04847 
04850 
04866 template <arbb_scalar_type_t S, std::size_t D>
04867 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D> >::type
04868 operator>>(const typename uncaptured<scalar<S> >::type& value, const dense<scalar<S>, D>& shift_amount)
04869 {
04870   const scalar<S> captured_value = value;
04871   dense<scalar<S>, D> result;
04872 
04873   detail::operator_rsh(result, captured_value, shift_amount);
04874 
04875   return result;
04876 }
04877 
04879 
04882 
04895 template <arbb_scalar_type_t S, std::size_t D>
04896 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D> >::type
04897 operator>>(const dense<scalar<S>, D>& value, const typename uncaptured<scalar<S> >::type& shift_amount)
04898 {
04899   const scalar<S> captured_shift_amount = shift_amount;
04900   dense<scalar<S>, D> result;
04901 
04902   detail::operator_rsh(result, value, captured_shift_amount);
04903 
04904   return result;
04905 }
04906 
04908 
04911 
04921 template <arbb_scalar_type_t S, std::size_t D>
04922 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D> >::type
04923 operator>>(const dense<scalar<S>, D>& value, const dense<scalar<S>, D>& shift_amount)
04924 {
04925   dense<scalar<S>, D> result;
04926 
04927   detail::operator_rsh(result, value, shift_amount);
04928 
04929   return result;
04930 }
04931 
04933 
04936 
04952 template <arbb_scalar_type_t S, std::size_t D>
04953 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D> >::type
04954 operator>>(const scalar<S>& value, const dense<scalar<S>, D>& shift_amount)
04955 {
04956   dense<scalar<S>, D> result;
04957 
04958   detail::operator_rsh(result, value, shift_amount);
04959 
04960   return result;
04961 }
04962 
04964 
04967 
04980 template <arbb_scalar_type_t S, std::size_t D>
04981 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D> >::type
04982 operator>>(const dense<scalar<S>, D>& value, const scalar<S>& shift_amount)
04983 {
04984   dense<scalar<S>, D> result;
04985 
04986   detail::operator_rsh(result, value, shift_amount);
04987 
04988   return result;
04989 }
04990 
04992 
04995 
05008 template <arbb_scalar_type_t S, std::size_t D>
05009 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D>& >::type
05010 operator>>=(dense<scalar<S>, D>& value, const typename uncaptured<scalar<S> >::type& shift_amount)
05011 {
05012   const scalar<S> captured_shift_amount = shift_amount;
05013 
05014   detail::operator_rsh(value, value, captured_shift_amount);
05015 
05016   return value;
05017 }
05018 
05020 
05023 
05033 template <arbb_scalar_type_t S, std::size_t D>
05034 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D>& >::type
05035 operator>>=(dense<scalar<S>, D>& value, const dense<scalar<S>, D>& shift_amount)
05036 {
05037 
05038   detail::operator_rsh(value, value, shift_amount);
05039 
05040   return value;
05041 }
05042 
05044 
05047 
05060 template <arbb_scalar_type_t S, std::size_t D>
05061 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D>& >::type
05062 operator>>=(dense<scalar<S>, D>& value, const scalar<S>& shift_amount)
05063 {
05064 
05065   detail::operator_rsh(value, value, shift_amount);
05066 
05067   return value;
05068 }
05069 
05071 
05074 
05089 template <arbb_scalar_type_t S, std::size_t D>
05090 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D> >::type
05091 operator-(const typename uncaptured<scalar<S> >::type& value, const dense<scalar<S>, D>& amount)
05092 {
05093   const scalar<S> captured_value = value;
05094   dense<scalar<S>, D> result;
05095   const arbb_variable_t outputs[] = {result.vm_variable()};
05096 
05097   const arbb_variable_t inputs[] = {captured_value.vm_variable(), amount.vm_variable()};
05098   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
05099   arbb_op(detail::function::current(), arbb_op_sub, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
05100 
05101   return result;
05102 }
05103 
05105 
05108 
05120 template <arbb_scalar_type_t S, std::size_t D>
05121 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D> >::type
05122 operator-(const dense<scalar<S>, D>& value, const typename uncaptured<scalar<S> >::type& amount)
05123 {
05124   const scalar<S> captured_amount = amount;
05125   dense<scalar<S>, D> result;
05126   const arbb_variable_t outputs[] = {result.vm_variable()};
05127 
05128   const arbb_variable_t inputs[] = {value.vm_variable(), captured_amount.vm_variable()};
05129   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
05130   arbb_op(detail::function::current(), arbb_op_sub, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
05131 
05132   return result;
05133 }
05134 
05136 
05139 
05148 template <arbb_scalar_type_t S, std::size_t D>
05149 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D> >::type
05150 operator-(const dense<scalar<S>, D>& value, const dense<scalar<S>, D>& amount)
05151 {
05152   dense<scalar<S>, D> result;
05153   const arbb_variable_t outputs[] = {result.vm_variable()};
05154 
05155   const arbb_variable_t inputs[] = {value.vm_variable(), amount.vm_variable()};
05156   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
05157   arbb_op(detail::function::current(), arbb_op_sub, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
05158 
05159   return result;
05160 }
05161 
05163 
05166 
05181 template <arbb_scalar_type_t S, std::size_t D>
05182 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D> >::type
05183 operator-(const scalar<S>& value, const dense<scalar<S>, D>& amount)
05184 {
05185   dense<scalar<S>, D> result;
05186   const arbb_variable_t outputs[] = {result.vm_variable()};
05187 
05188   const arbb_variable_t inputs[] = {value.vm_variable(), amount.vm_variable()};
05189   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
05190   arbb_op(detail::function::current(), arbb_op_sub, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
05191 
05192   return result;
05193 }
05194 
05196 
05199 
05211 template <arbb_scalar_type_t S, std::size_t D>
05212 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D> >::type
05213 operator-(const dense<scalar<S>, D>& value, const scalar<S>& amount)
05214 {
05215   dense<scalar<S>, D> result;
05216   const arbb_variable_t outputs[] = {result.vm_variable()};
05217 
05218   const arbb_variable_t inputs[] = {value.vm_variable(), amount.vm_variable()};
05219   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
05220   arbb_op(detail::function::current(), arbb_op_sub, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
05221 
05222   return result;
05223 }
05224 
05226 
05229 
05241 template <arbb_scalar_type_t S, std::size_t D>
05242 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D>& >::type
05243 operator-=(dense<scalar<S>, D>& value, const typename uncaptured<scalar<S> >::type& amount)
05244 {
05245   const scalar<S> captured_amount = amount;
05246   const arbb_variable_t outputs[] = {value.vm_variable()};
05247 
05248   const arbb_variable_t inputs[] = {value.vm_variable(), captured_amount.vm_variable()};
05249   void* debug_data_ptrs[] = {value.containers_begin()->get_debug_data_ptr()};
05250   arbb_op(detail::function::current(), arbb_op_sub, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
05251 
05252   return value;
05253 }
05254 
05256 
05259 
05268 template <arbb_scalar_type_t S, std::size_t D>
05269 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D>& >::type
05270 operator-=(dense<scalar<S>, D>& value, const dense<scalar<S>, D>& amount)
05271 {
05272   const arbb_variable_t outputs[] = {value.vm_variable()};
05273 
05274   const arbb_variable_t inputs[] = {value.vm_variable(), amount.vm_variable()};
05275   void* debug_data_ptrs[] = {value.containers_begin()->get_debug_data_ptr()};
05276   arbb_op(detail::function::current(), arbb_op_sub, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
05277 
05278   return value;
05279 }
05280 
05282 
05285 
05297 template <arbb_scalar_type_t S, std::size_t D>
05298 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D>& >::type
05299 operator-=(dense<scalar<S>, D>& value, const scalar<S>& amount)
05300 {
05301   const arbb_variable_t outputs[] = {value.vm_variable()};
05302 
05303   const arbb_variable_t inputs[] = {value.vm_variable(), amount.vm_variable()};
05304   void* debug_data_ptrs[] = {value.containers_begin()->get_debug_data_ptr()};
05305   arbb_op(detail::function::current(), arbb_op_sub, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
05306 
05307   return value;
05308 }
05309 
05311 
05314 
05330 template <arbb_scalar_type_t S, std::size_t D>
05331 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D> >::type
05332 operator^(const typename uncaptured<scalar<S> >::type& value, const dense<scalar<S>, D>& mask)
05333 {
05334   const scalar<S> captured_value = value;
05335   dense<scalar<S>, D> result;
05336   const arbb_variable_t outputs[] = {result.vm_variable()};
05337 
05338   const arbb_variable_t inputs[] = {captured_value.vm_variable(), mask.vm_variable()};
05339   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
05340   arbb_op(detail::function::current(), arbb_op_bit_xor, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
05341 
05342   return result;
05343 }
05344 
05346 
05349 
05362 template <arbb_scalar_type_t S, std::size_t D>
05363 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D> >::type
05364 operator^(const dense<scalar<S>, D>& value, const typename uncaptured<scalar<S> >::type& mask)
05365 {
05366   const scalar<S> captured_mask = mask;
05367   dense<scalar<S>, D> result;
05368   const arbb_variable_t outputs[] = {result.vm_variable()};
05369 
05370   const arbb_variable_t inputs[] = {value.vm_variable(), captured_mask.vm_variable()};
05371   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
05372   arbb_op(detail::function::current(), arbb_op_bit_xor, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
05373 
05374   return result;
05375 }
05376 
05378 
05381 
05391 template <arbb_scalar_type_t S, std::size_t D>
05392 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D> >::type
05393 operator^(const dense<scalar<S>, D>& value, const dense<scalar<S>, D>& mask)
05394 {
05395   dense<scalar<S>, D> result;
05396   const arbb_variable_t outputs[] = {result.vm_variable()};
05397 
05398   const arbb_variable_t inputs[] = {value.vm_variable(), mask.vm_variable()};
05399   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
05400   arbb_op(detail::function::current(), arbb_op_bit_xor, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
05401 
05402   return result;
05403 }
05404 
05406 
05409 
05425 template <arbb_scalar_type_t S, std::size_t D>
05426 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D> >::type
05427 operator^(const scalar<S>& value, const dense<scalar<S>, D>& mask)
05428 {
05429   dense<scalar<S>, D> result;
05430   const arbb_variable_t outputs[] = {result.vm_variable()};
05431 
05432   const arbb_variable_t inputs[] = {value.vm_variable(), mask.vm_variable()};
05433   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
05434   arbb_op(detail::function::current(), arbb_op_bit_xor, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
05435 
05436   return result;
05437 }
05438 
05440 
05443 
05456 template <arbb_scalar_type_t S, std::size_t D>
05457 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D> >::type
05458 operator^(const dense<scalar<S>, D>& value, const scalar<S>& mask)
05459 {
05460   dense<scalar<S>, D> result;
05461   const arbb_variable_t outputs[] = {result.vm_variable()};
05462 
05463   const arbb_variable_t inputs[] = {value.vm_variable(), mask.vm_variable()};
05464   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
05465   arbb_op(detail::function::current(), arbb_op_bit_xor, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
05466 
05467   return result;
05468 }
05469 
05471 
05474 
05487 template <arbb_scalar_type_t S, std::size_t D>
05488 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D>& >::type
05489 operator^=(dense<scalar<S>, D>& value, const typename uncaptured<scalar<S> >::type& mask)
05490 {
05491   const scalar<S> captured_mask = mask;
05492   const arbb_variable_t outputs[] = {value.vm_variable()};
05493 
05494   const arbb_variable_t inputs[] = {value.vm_variable(), captured_mask.vm_variable()};
05495   void* debug_data_ptrs[] = {value.containers_begin()->get_debug_data_ptr()};
05496   arbb_op(detail::function::current(), arbb_op_bit_xor, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
05497 
05498   return value;
05499 }
05500 
05502 
05505 
05515 template <arbb_scalar_type_t S, std::size_t D>
05516 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D>& >::type
05517 operator^=(dense<scalar<S>, D>& value, const dense<scalar<S>, D>& mask)
05518 {
05519   const arbb_variable_t outputs[] = {value.vm_variable()};
05520 
05521   const arbb_variable_t inputs[] = {value.vm_variable(), mask.vm_variable()};
05522   void* debug_data_ptrs[] = {value.containers_begin()->get_debug_data_ptr()};
05523   arbb_op(detail::function::current(), arbb_op_bit_xor, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
05524 
05525   return value;
05526 }
05527 
05529 
05532 
05545 template <arbb_scalar_type_t S, std::size_t D>
05546 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, dense<scalar<S>, D>& >::type
05547 operator^=(dense<scalar<S>, D>& value, const scalar<S>& mask)
05548 {
05549   const arbb_variable_t outputs[] = {value.vm_variable()};
05550 
05551   const arbb_variable_t inputs[] = {value.vm_variable(), mask.vm_variable()};
05552   void* debug_data_ptrs[] = {value.containers_begin()->get_debug_data_ptr()};
05553   arbb_op(detail::function::current(), arbb_op_bit_xor, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
05554 
05555   return value;
05556 }
05557 
05559 
05562 
05577 template <arbb_scalar_type_t S, std::size_t D>
05578 dense<scalar<S>, D>
05579 select(const typename uncaptured<boolean >::type& condition, const dense<scalar<S>, D>& true_case, const dense<scalar<S>, D>& false_case)
05580 {
05581   const boolean captured_condition = condition;
05582   dense<scalar<S>, D> result;
05583   const arbb_variable_t outputs[] = {result.vm_variable()};
05584 
05585   const arbb_variable_t inputs[] = {captured_condition.vm_variable(), true_case.vm_variable(), false_case.vm_variable()};
05586   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
05587   arbb_op(detail::function::current(), arbb_op_select, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
05588 
05589   return result;
05590 }
05591 
05593 
05596 
05611 template <arbb_scalar_type_t S, std::size_t D>
05612 dense<scalar<S>, D>
05613 select(const dense<boolean, D>& condition, const typename uncaptured<scalar<S> >::type& true_case, const dense<scalar<S>, D>& false_case)
05614 {
05615   const scalar<S> captured_true_case = true_case;
05616   dense<scalar<S>, D> result;
05617   const arbb_variable_t outputs[] = {result.vm_variable()};
05618 
05619   const arbb_variable_t inputs[] = {condition.vm_variable(), captured_true_case.vm_variable(), false_case.vm_variable()};
05620   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
05621   arbb_op(detail::function::current(), arbb_op_select, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
05622 
05623   return result;
05624 }
05625 
05627 
05630 
05648 template <arbb_scalar_type_t S, std::size_t D>
05649 dense<scalar<S>, D>
05650 select(const typename uncaptured<boolean >::type& condition, const typename uncaptured<scalar<S> >::type& true_case, const dense<scalar<S>, D>& false_case)
05651 {
05652   const boolean captured_condition = condition;
05653   const scalar<S> captured_true_case = true_case;
05654   dense<scalar<S>, D> result;
05655   const arbb_variable_t outputs[] = {result.vm_variable()};
05656 
05657   const arbb_variable_t inputs[] = {captured_condition.vm_variable(), captured_true_case.vm_variable(), false_case.vm_variable()};
05658   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
05659   arbb_op(detail::function::current(), arbb_op_select, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
05660 
05661   return result;
05662 }
05663 
05665 
05668 
05680 template <arbb_scalar_type_t S, std::size_t D>
05681 dense<scalar<S>, D>
05682 select(const dense<boolean, D>& condition, const dense<scalar<S>, D>& true_case, const typename uncaptured<scalar<S> >::type& false_case)
05683 {
05684   const scalar<S> captured_false_case = false_case;
05685   dense<scalar<S>, D> result;
05686   const arbb_variable_t outputs[] = {result.vm_variable()};
05687 
05688   const arbb_variable_t inputs[] = {condition.vm_variable(), true_case.vm_variable(), captured_false_case.vm_variable()};
05689   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
05690   arbb_op(detail::function::current(), arbb_op_select, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
05691 
05692   return result;
05693 }
05694 
05696 
05699 
05714 template <arbb_scalar_type_t S, std::size_t D>
05715 dense<scalar<S>, D>
05716 select(const typename uncaptured<boolean >::type& condition, const dense<scalar<S>, D>& true_case, const typename uncaptured<scalar<S> >::type& false_case)
05717 {
05718   const boolean captured_condition = condition;
05719   const scalar<S> captured_false_case = false_case;
05720   dense<scalar<S>, D> result;
05721   const arbb_variable_t outputs[] = {result.vm_variable()};
05722 
05723   const arbb_variable_t inputs[] = {captured_condition.vm_variable(), true_case.vm_variable(), captured_false_case.vm_variable()};
05724   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
05725   arbb_op(detail::function::current(), arbb_op_select, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
05726 
05727   return result;
05728 }
05729 
05731 
05734 
05743 template <arbb_scalar_type_t S, std::size_t D>
05744 dense<scalar<S>, D>
05745 select(const dense<boolean, D>& condition, const dense<scalar<S>, D>& true_case, const dense<scalar<S>, D>& false_case)
05746 {
05747   dense<scalar<S>, D> result;
05748   const arbb_variable_t outputs[] = {result.vm_variable()};
05749 
05750   const arbb_variable_t inputs[] = {condition.vm_variable(), true_case.vm_variable(), false_case.vm_variable()};
05751   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
05752   arbb_op(detail::function::current(), arbb_op_select, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
05753 
05754   return result;
05755 }
05756 
05758 
05761 
05776 template <arbb_scalar_type_t S, std::size_t D>
05777 dense<scalar<S>, D>
05778 select(const boolean& condition, const dense<scalar<S>, D>& true_case, const dense<scalar<S>, D>& false_case)
05779 {
05780   dense<scalar<S>, D> result;
05781   const arbb_variable_t outputs[] = {result.vm_variable()};
05782 
05783   const arbb_variable_t inputs[] = {condition.vm_variable(), true_case.vm_variable(), false_case.vm_variable()};
05784   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
05785   arbb_op(detail::function::current(), arbb_op_select, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
05786 
05787   return result;
05788 }
05789 
05791 
05794 
05809 template <arbb_scalar_type_t S, std::size_t D>
05810 dense<scalar<S>, D>
05811 select(const dense<boolean, D>& condition, const scalar<S>& true_case, const dense<scalar<S>, D>& false_case)
05812 {
05813   dense<scalar<S>, D> result;
05814   const arbb_variable_t outputs[] = {result.vm_variable()};
05815 
05816   const arbb_variable_t inputs[] = {condition.vm_variable(), true_case.vm_variable(), false_case.vm_variable()};
05817   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
05818   arbb_op(detail::function::current(), arbb_op_select, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
05819 
05820   return result;
05821 }
05822 
05824 
05827 
05845 template <arbb_scalar_type_t S, std::size_t D>
05846 dense<scalar<S>, D>
05847 select(const boolean& condition, const scalar<S>& true_case, const dense<scalar<S>, D>& false_case)
05848 {
05849   dense<scalar<S>, D> result;
05850   const arbb_variable_t outputs[] = {result.vm_variable()};
05851 
05852   const arbb_variable_t inputs[] = {condition.vm_variable(), true_case.vm_variable(), false_case.vm_variable()};
05853   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
05854   arbb_op(detail::function::current(), arbb_op_select, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
05855 
05856   return result;
05857 }
05858 
05860 
05863 
05875 template <arbb_scalar_type_t S, std::size_t D>
05876 dense<scalar<S>, D>
05877 select(const dense<boolean, D>& condition, const dense<scalar<S>, D>& true_case, const scalar<S>& false_case)
05878 {
05879   dense<scalar<S>, D> result;
05880   const arbb_variable_t outputs[] = {result.vm_variable()};
05881 
05882   const arbb_variable_t inputs[] = {condition.vm_variable(), true_case.vm_variable(), false_case.vm_variable()};
05883   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
05884   arbb_op(detail::function::current(), arbb_op_select, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
05885 
05886   return result;
05887 }
05888 
05890 
05893 
05908 template <arbb_scalar_type_t S, std::size_t D>
05909 dense<scalar<S>, D>
05910 select(const boolean& condition, const dense<scalar<S>, D>& true_case, const scalar<S>& false_case)
05911 {
05912   dense<scalar<S>, D> result;
05913   const arbb_variable_t outputs[] = {result.vm_variable()};
05914 
05915   const arbb_variable_t inputs[] = {condition.vm_variable(), true_case.vm_variable(), false_case.vm_variable()};
05916   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
05917   arbb_op(detail::function::current(), arbb_op_select, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
05918 
05919   return result;
05920 }
05921 
05923 
05926 
05941 template <arbb_scalar_type_t S, std::size_t D>
05942 dense<scalar<S>, D>
05943 select(const dense<boolean, D>& condition, const scalar<S>& true_case, const scalar<S>& false_case)
05944 {
05945   dense<scalar<S>, D> result;
05946   const arbb_variable_t outputs[] = {result.vm_variable()};
05947 
05948   const arbb_variable_t inputs[] = {condition.vm_variable(), true_case.vm_variable(), false_case.vm_variable()};
05949   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
05950   arbb_op(detail::function::current(), arbb_op_select, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
05951 
05952   return result;
05953 }
05954 
05956 
05959 
05967 template <arbb_scalar_type_t S, std::size_t D>
05968 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D>& >::type
05969 operator++(dense<scalar<S>, D>& value)
05970 {
05971   const arbb_variable_t outputs[] = {value.vm_variable()};
05972 
05973   scalar<S> constant_one(1);
05974 
05975   const arbb_variable_t inputs[] = {value.vm_variable(), constant_one.vm_variable()};
05976   void* debug_data_ptrs[] = {value.containers_begin()->get_debug_data_ptr()};
05977   arbb_op(detail::function::current(), arbb_op_add, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
05978 
05979   return value;
05980 }
05981 
05983 
05986 
05994 template <arbb_scalar_type_t S, std::size_t D>
05995 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D> >::type
05996 operator++(dense<scalar<S>, D>& value, int)
05997 {
05998   dense<scalar<S>, D> original_value = value;
05999 
06000   const arbb_variable_t outputs[] = {value.vm_variable()};
06001 
06002   scalar<S> constant_one(1);
06003 
06004   const arbb_variable_t inputs[] = {value.vm_variable(), constant_one.vm_variable()};
06005   void* debug_data_ptrs[] = {value.containers_begin()->get_debug_data_ptr()};
06006   arbb_op(detail::function::current(), arbb_op_add, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
06007 
06008   return original_value;
06009 }
06010 
06012 
06015 
06023 template <arbb_scalar_type_t S, std::size_t D>
06024 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D>& >::type
06025 operator--(dense<scalar<S>, D>& value)
06026 {
06027   const arbb_variable_t outputs[] = {value.vm_variable()};
06028 
06029   scalar<S> constant_one(1);
06030 
06031   const arbb_variable_t inputs[] = {value.vm_variable(), constant_one.vm_variable()};
06032   void* debug_data_ptrs[] = {value.containers_begin()->get_debug_data_ptr()};
06033   arbb_op(detail::function::current(), arbb_op_sub, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
06034 
06035   return value;
06036 }
06037 
06039 
06042 
06050 template <arbb_scalar_type_t S, std::size_t D>
06051 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, dense<scalar<S>, D> >::type
06052 operator--(dense<scalar<S>, D>& value, int)
06053 {
06054   dense<scalar<S>, D> original_value = value;
06055 
06056   const arbb_variable_t outputs[] = {value.vm_variable()};
06057 
06058   scalar<S> constant_one(1);
06059 
06060   const arbb_variable_t inputs[] = {value.vm_variable(), constant_one.vm_variable()};
06061   void* debug_data_ptrs[] = {value.containers_begin()->get_debug_data_ptr()};
06062   arbb_op(detail::function::current(), arbb_op_sub, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
06063 
06064   return original_value;
06065 }
06066 
06068 
06069 
06072 
06087 template <typename U, std::size_t D>
06088 typename detail::disable_if<!detail::is_uncaptured_scalar<U>::value, dense<typename captured<U>::type, D> >::type
06089 select(const dense<boolean, D>& condition, const U& true_case, const U& false_case)
06090 {
06091   typename captured<U>::type captured_true_case = true_case;
06092   typename captured<U>::type captured_false_case = false_case;
06093   dense<typename captured<U>::type, D> result;
06094   const arbb_variable_t outputs[] = {result.vm_variable()};
06095 
06096   const arbb_variable_t inputs[] = {condition.vm_variable(), captured_true_case.vm_variable(), captured_false_case.vm_variable()};
06097   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
06098   arbb_op(detail::function::current(), arbb_op_select, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
06099 
06100   return result;
06101 }
06102 
06104 
06107 
06113 template <typename T, arbb_scalar_type_t S, std::size_t D>
06114 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar<T>::value, dense<T, D> >::type
06115 bitwise_cast(const dense<scalar<S>, D>& value)
06116 {
06117   dense<T, D> result;
06118   const arbb_variable_t outputs[] = {result.vm_variable()};
06119   const arbb_variable_t inputs[] = {value.vm_variable()};
06120 
06121   void* debug_data_ptrs[] = {result.containers_begin()->get_debug_data_ptr()};
06122 
06123   arbb_op(detail::function::current(), arbb_op_bitwise_cast, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details());
06124 
06125   return result;
06126 }
06127 
06129 
06132 
06140 template <arbb_scalar_type_t S, std::size_t D>
06141 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_unsigned_int< scalar<S> >::value, dense<typename detail::signed_type< scalar<S> >::type, D> >::type
06142 operator-(dense<scalar<S>, D>& value)
06143 {
06144   dense<typename detail::signed_type<scalar<S> >::type, D> result(value);
06145   return -result;
06146 }
06147 
06149 
06150 
06151 
06152 } // namespace ARBB_CPP_NS
06153 
06154 
06155 
06156 #endif // ARBB_CPP_ELEMENTWISE_DENSE_SCALAR_HPP
06157 
06158 

Submit feedback on this help topic

Copyright © 2010, Intel Corporation. All rights reserved.