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
Copyright © 2010, Intel Corporation. All rights reserved.