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_SCALAR_FUNCS_HPP 00023 #define ARBB_CPP_SCALAR_FUNCS_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/scalar_traits.hpp" 00031 #include "detail/operators.hpp" 00032 #include "scalar.hpp" 00033 00034 00035 00036 namespace ARBB_CPP_NS { 00037 00040 00046 template <arbb_scalar_type_t S> 00047 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, scalar<S> >::type 00048 abs(const scalar<S>& value) 00049 { 00050 scalar<S> result; 00051 const arbb_variable_t outputs[] = {result.vm_variable()}; 00052 00053 const arbb_variable_t inputs[] = {value.vm_variable()}; 00054 00055 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 00056 arbb_op(detail::function::current(), arbb_op_abs, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 00057 00058 return result; 00059 } 00060 00062 00063 00066 00072 template <arbb_scalar_type_t S> 00073 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, scalar<S> >::type 00074 acos(const scalar<S>& value) 00075 { 00076 scalar<S> result; 00077 const arbb_variable_t outputs[] = {result.vm_variable()}; 00078 00079 const arbb_variable_t inputs[] = {value.vm_variable()}; 00080 00081 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 00082 arbb_op(detail::function::current(), arbb_op_acos, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 00083 00084 return result; 00085 } 00086 00088 00089 00092 00098 template <arbb_scalar_type_t S> 00099 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, scalar<S> >::type 00100 asin(const scalar<S>& value) 00101 { 00102 scalar<S> result; 00103 const arbb_variable_t outputs[] = {result.vm_variable()}; 00104 00105 const arbb_variable_t inputs[] = {value.vm_variable()}; 00106 00107 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 00108 arbb_op(detail::function::current(), arbb_op_asin, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 00109 00110 return result; 00111 } 00112 00114 00115 00118 00124 template <arbb_scalar_type_t S> 00125 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, scalar<S> >::type 00126 atan(const scalar<S>& value) 00127 { 00128 scalar<S> result; 00129 const arbb_variable_t outputs[] = {result.vm_variable()}; 00130 00131 const arbb_variable_t inputs[] = {value.vm_variable()}; 00132 00133 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 00134 arbb_op(detail::function::current(), arbb_op_atan, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 00135 00136 return result; 00137 } 00138 00140 00141 00144 00152 template <arbb_scalar_type_t S> 00153 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, scalar<S> >::type 00154 clamp(const scalar<S>& value, const scalar<S>& minimum, const scalar<S>& maximum) 00155 { 00156 scalar<S> result; 00157 00158 detail::clamp(result, value, minimum, maximum); 00159 00160 return result; 00161 } 00162 00164 00167 00175 template <arbb_scalar_type_t S> 00176 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, scalar<S> >::type 00177 clamp(const scalar<S>& value, const scalar<S>& minimum, const typename uncaptured<scalar<S> >::type& maximum) 00178 { 00179 scalar<S> scalar_maximum(maximum); 00180 scalar<S> result; 00181 00182 detail::clamp(result, value, minimum, scalar_maximum); 00183 00184 return result; 00185 } 00186 00188 00191 00199 template <arbb_scalar_type_t S> 00200 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, scalar<S> >::type 00201 clamp(const scalar<S>& value, const typename uncaptured<scalar<S> >::type& minimum, const scalar<S>& maximum) 00202 { 00203 scalar<S> scalar_minimum(minimum); 00204 scalar<S> result; 00205 00206 detail::clamp(result, value, scalar_minimum, maximum); 00207 00208 return result; 00209 } 00210 00212 00215 00223 template <arbb_scalar_type_t S> 00224 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, scalar<S> >::type 00225 clamp(const scalar<S>& value, const typename uncaptured<scalar<S> >::type& minimum, const typename uncaptured<scalar<S> >::type& maximum) 00226 { 00227 scalar<S> scalar_minimum(minimum); 00228 scalar<S> scalar_maximum(maximum); 00229 scalar<S> result; 00230 00231 detail::clamp(result, value, scalar_minimum, scalar_maximum); 00232 00233 return result; 00234 } 00235 00237 00240 00248 template <arbb_scalar_type_t S> 00249 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, scalar<S> >::type 00250 clamp(const typename uncaptured<scalar<S> >::type& value, const scalar<S>& minimum, const scalar<S>& maximum) 00251 { 00252 scalar<S> scalar_value(value); 00253 scalar<S> result; 00254 00255 detail::clamp(result, scalar_value, minimum, maximum); 00256 00257 return result; 00258 } 00259 00261 00264 00272 template <arbb_scalar_type_t S> 00273 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, scalar<S> >::type 00274 clamp(const typename uncaptured<scalar<S> >::type& value, const scalar<S>& minimum, const typename uncaptured<scalar<S> >::type& maximum) 00275 { 00276 scalar<S> scalar_value(value); 00277 scalar<S> scalar_maximum(maximum); 00278 scalar<S> result; 00279 00280 detail::clamp(result, scalar_value, minimum, scalar_maximum); 00281 00282 return result; 00283 } 00284 00286 00289 00297 template <arbb_scalar_type_t S> 00298 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, scalar<S> >::type 00299 clamp(const typename uncaptured<scalar<S> >::type& value, const typename uncaptured<scalar<S> >::type& minimum, const scalar<S>& maximum) 00300 { 00301 scalar<S> scalar_value(value); 00302 scalar<S> scalar_minimum(minimum); 00303 scalar<S> result; 00304 00305 detail::clamp(result, scalar_value, scalar_minimum, maximum); 00306 00307 return result; 00308 } 00309 00311 00312 00315 00321 template <arbb_scalar_type_t S> 00322 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, scalar<S> >::type 00323 cos(const scalar<S>& value) 00324 { 00325 scalar<S> result; 00326 const arbb_variable_t outputs[] = {result.vm_variable()}; 00327 00328 const arbb_variable_t inputs[] = {value.vm_variable()}; 00329 00330 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 00331 arbb_op(detail::function::current(), arbb_op_cos, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 00332 00333 return result; 00334 } 00335 00337 00338 00341 00347 template <arbb_scalar_type_t S> 00348 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, scalar<S> >::type 00349 cosh(const scalar<S>& value) 00350 { 00351 scalar<S> result; 00352 const arbb_variable_t outputs[] = {result.vm_variable()}; 00353 00354 const arbb_variable_t inputs[] = {value.vm_variable()}; 00355 00356 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 00357 arbb_op(detail::function::current(), arbb_op_cosh, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 00358 00359 return result; 00360 } 00361 00363 00364 00367 00373 template <arbb_scalar_type_t S> 00374 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, scalar<S> >::type 00375 exp(const scalar<S>& value) 00376 { 00377 scalar<S> result; 00378 const arbb_variable_t outputs[] = {result.vm_variable()}; 00379 00380 const arbb_variable_t inputs[] = {value.vm_variable()}; 00381 00382 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 00383 arbb_op(detail::function::current(), arbb_op_exp, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 00384 00385 return result; 00386 } 00387 00389 00390 00393 00399 template <arbb_scalar_type_t S> 00400 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, scalar<S> >::type 00401 exp10(const scalar<S>& value) 00402 { 00403 scalar<S> result; 00404 const arbb_variable_t outputs[] = {result.vm_variable()}; 00405 00406 const arbb_variable_t inputs[] = {value.vm_variable()}; 00407 00408 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 00409 arbb_op(detail::function::current(), arbb_op_exp10, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 00410 00411 return result; 00412 } 00413 00415 00416 00419 00425 template <arbb_scalar_type_t S> 00426 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, scalar<S> >::type 00427 floor(const scalar<S>& value) 00428 { 00429 scalar<S> result; 00430 const arbb_variable_t outputs[] = {result.vm_variable()}; 00431 00432 const arbb_variable_t inputs[] = {value.vm_variable()}; 00433 00434 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 00435 arbb_op(detail::function::current(), arbb_op_floor, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 00436 00437 return result; 00438 } 00439 00441 00442 00445 00451 template <arbb_scalar_type_t S> 00452 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, scalar<S> >::type 00453 ceil(const scalar<S>& value) 00454 { 00455 scalar<S> result; 00456 const arbb_variable_t outputs[] = {result.vm_variable()}; 00457 00458 const arbb_variable_t inputs[] = {value.vm_variable()}; 00459 00460 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 00461 arbb_op(detail::function::current(), arbb_op_ceil, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 00462 00463 return result; 00464 } 00465 00467 00468 00471 00477 template <arbb_scalar_type_t S> 00478 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, scalar<S> >::type 00479 log(const scalar<S>& value) 00480 { 00481 scalar<S> result; 00482 const arbb_variable_t outputs[] = {result.vm_variable()}; 00483 00484 const arbb_variable_t inputs[] = {value.vm_variable()}; 00485 00486 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 00487 arbb_op(detail::function::current(), arbb_op_ln, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 00488 00489 return result; 00490 } 00491 00493 00494 00497 00503 template <arbb_scalar_type_t S> 00504 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, scalar<S> >::type 00505 log10(const scalar<S>& value) 00506 { 00507 scalar<S> result; 00508 const arbb_variable_t outputs[] = {result.vm_variable()}; 00509 00510 const arbb_variable_t inputs[] = {value.vm_variable()}; 00511 00512 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 00513 arbb_op(detail::function::current(), arbb_op_log10, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 00514 00515 return result; 00516 } 00517 00519 00520 00523 00529 template <arbb_scalar_type_t S> 00530 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, scalar<S> >::type 00531 rcp(const scalar<S>& value) 00532 { 00533 scalar<S> result; 00534 const arbb_variable_t outputs[] = {result.vm_variable()}; 00535 00536 const arbb_variable_t inputs[] = {value.vm_variable()}; 00537 00538 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 00539 arbb_op(detail::function::current(), arbb_op_rcp, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 00540 00541 return result; 00542 } 00543 00545 00546 00549 00555 template <arbb_scalar_type_t S> 00556 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, scalar<S> >::type 00557 round(const scalar<S>& value) 00558 { 00559 scalar<S> result; 00560 const arbb_variable_t outputs[] = {result.vm_variable()}; 00561 00562 const arbb_variable_t inputs[] = {value.vm_variable()}; 00563 00564 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 00565 arbb_op(detail::function::current(), arbb_op_round, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 00566 00567 return result; 00568 } 00569 00571 00572 00575 00581 template <arbb_scalar_type_t S> 00582 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, scalar<S> >::type 00583 rsqrt(const scalar<S>& value) 00584 { 00585 scalar<S> result; 00586 const arbb_variable_t outputs[] = {result.vm_variable()}; 00587 00588 const arbb_variable_t inputs[] = {value.vm_variable()}; 00589 00590 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 00591 arbb_op(detail::function::current(), arbb_op_rsqrt, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 00592 00593 return result; 00594 } 00595 00597 00598 00601 00607 template <arbb_scalar_type_t S> 00608 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, scalar<S> >::type 00609 sin(const scalar<S>& value) 00610 { 00611 scalar<S> result; 00612 const arbb_variable_t outputs[] = {result.vm_variable()}; 00613 00614 const arbb_variable_t inputs[] = {value.vm_variable()}; 00615 00616 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 00617 arbb_op(detail::function::current(), arbb_op_sin, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 00618 00619 return result; 00620 } 00621 00623 00624 00627 00633 template <arbb_scalar_type_t S> 00634 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, scalar<S> >::type 00635 sinh(const scalar<S>& value) 00636 { 00637 scalar<S> result; 00638 const arbb_variable_t outputs[] = {result.vm_variable()}; 00639 00640 const arbb_variable_t inputs[] = {value.vm_variable()}; 00641 00642 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 00643 arbb_op(detail::function::current(), arbb_op_sinh, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 00644 00645 return result; 00646 } 00647 00649 00650 00653 00659 template <arbb_scalar_type_t S> 00660 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, scalar<S> >::type 00661 sqrt(const scalar<S>& value) 00662 { 00663 scalar<S> result; 00664 const arbb_variable_t outputs[] = {result.vm_variable()}; 00665 00666 const arbb_variable_t inputs[] = {value.vm_variable()}; 00667 00668 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 00669 arbb_op(detail::function::current(), arbb_op_sqrt, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 00670 00671 return result; 00672 } 00673 00675 00676 00679 00685 template <arbb_scalar_type_t S> 00686 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, scalar<S> >::type 00687 tan(const scalar<S>& value) 00688 { 00689 scalar<S> result; 00690 const arbb_variable_t outputs[] = {result.vm_variable()}; 00691 00692 const arbb_variable_t inputs[] = {value.vm_variable()}; 00693 00694 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 00695 arbb_op(detail::function::current(), arbb_op_tan, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 00696 00697 return result; 00698 } 00699 00701 00702 00705 00711 template <arbb_scalar_type_t S> 00712 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, scalar<S> >::type 00713 tanh(const scalar<S>& value) 00714 { 00715 scalar<S> result; 00716 const arbb_variable_t outputs[] = {result.vm_variable()}; 00717 00718 const arbb_variable_t inputs[] = {value.vm_variable()}; 00719 00720 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 00721 arbb_op(detail::function::current(), arbb_op_tanh, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 00722 00723 return result; 00724 } 00725 00727 00728 00731 00736 inline boolean 00737 operator!(const boolean& value) 00738 { 00739 boolean result; 00740 const arbb_variable_t outputs[] = {result.vm_variable()}; 00741 00742 const arbb_variable_t inputs[] = {value.vm_variable()}; 00743 00744 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 00745 arbb_op(detail::function::current(), arbb_op_log_not, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 00746 00747 return result; 00748 } 00749 00751 00752 00755 00762 template <arbb_scalar_type_t S> 00763 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, scalar<S> >::type 00764 operator~(const scalar<S>& value) 00765 { 00766 scalar<S> result; 00767 const arbb_variable_t outputs[] = {result.vm_variable()}; 00768 00769 const arbb_variable_t inputs[] = {value.vm_variable()}; 00770 00771 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 00772 arbb_op(detail::function::current(), arbb_op_bit_not, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 00773 00774 return result; 00775 } 00776 00778 00779 00782 00789 template <arbb_scalar_type_t S> 00790 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_signed< scalar<S> >::value, scalar<S> >::type 00791 operator-(const scalar<S>& value) 00792 { 00793 scalar<S> result; 00794 const arbb_variable_t outputs[] = {result.vm_variable()}; 00795 00796 const arbb_variable_t inputs[] = {value.vm_variable()}; 00797 00798 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 00799 arbb_op(detail::function::current(), arbb_op_neg, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 00800 00801 return result; 00802 } 00803 00805 00806 00809 00816 template <arbb_scalar_type_t S> 00817 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, scalar<S> >::type 00818 operator+(const scalar<S>& a, const scalar<S>& b) 00819 { 00820 scalar<S> result; 00821 const arbb_variable_t outputs[] = {result.vm_variable()}; 00822 00823 const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()}; 00824 00825 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 00826 arbb_op(detail::function::current(), arbb_op_add, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 00827 00828 return result; 00829 } 00830 00832 00835 00842 template <arbb_scalar_type_t S> 00843 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, scalar<S> >::type 00844 operator+(const scalar<S>& a, const typename uncaptured<scalar<S> >::type& b) 00845 { 00846 scalar<S> scalar_b(b); 00847 scalar<S> result; 00848 const arbb_variable_t outputs[] = {result.vm_variable()}; 00849 00850 const arbb_variable_t inputs[] = {a.vm_variable(), scalar_b.vm_variable()}; 00851 00852 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 00853 arbb_op(detail::function::current(), arbb_op_add, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 00854 00855 return result; 00856 } 00857 00859 00862 00869 template <arbb_scalar_type_t S> 00870 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, scalar<S> >::type 00871 operator+(const typename uncaptured<scalar<S> >::type& a, const scalar<S>& b) 00872 { 00873 scalar<S> scalar_a(a); 00874 scalar<S> result; 00875 const arbb_variable_t outputs[] = {result.vm_variable()}; 00876 00877 const arbb_variable_t inputs[] = {scalar_a.vm_variable(), b.vm_variable()}; 00878 00879 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 00880 arbb_op(detail::function::current(), arbb_op_add, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 00881 00882 return result; 00883 } 00884 00886 00887 00890 00897 template <arbb_scalar_type_t S> 00898 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, scalar<S>& >::type 00899 operator+=(scalar<S>& value, const scalar<S>& increment) 00900 { 00901 const arbb_variable_t outputs[] = {value.vm_variable()}; 00902 00903 const arbb_variable_t inputs[] = {value.vm_variable(), increment.vm_variable()}; 00904 00905 void* debug_data_ptrs[] = {value.get_debug_data_ptr()}; 00906 arbb_op(detail::function::current(), arbb_op_add, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 00907 00908 return value; 00909 } 00910 00912 00915 00922 template <arbb_scalar_type_t S> 00923 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, scalar<S>& >::type 00924 operator+=(scalar<S>& value, const typename uncaptured<scalar<S> >::type& increment) 00925 { 00926 scalar<S> scalar_increment(increment); 00927 const arbb_variable_t outputs[] = {value.vm_variable()}; 00928 00929 const arbb_variable_t inputs[] = {value.vm_variable(), scalar_increment.vm_variable()}; 00930 00931 void* debug_data_ptrs[] = {value.get_debug_data_ptr()}; 00932 arbb_op(detail::function::current(), arbb_op_add, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 00933 00934 return value; 00935 } 00936 00938 00941 00948 template <arbb_scalar_type_t S> 00949 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, scalar<S>& >::type 00950 operator+=(typename uncaptured<scalar<S> >::type& value, const scalar<S>& increment) 00951 { 00952 scalar<S> scalar_value(value); 00953 const arbb_variable_t outputs[] = {value.vm_variable()}; 00954 00955 const arbb_variable_t inputs[] = {scalar_value.vm_variable(), increment.vm_variable()}; 00956 00957 void* debug_data_ptrs[] = {value.get_debug_data_ptr()}; 00958 arbb_op(detail::function::current(), arbb_op_add, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 00959 00960 return value; 00961 } 00962 00964 00965 00968 00976 template <arbb_scalar_type_t S> 00977 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, scalar<S> >::type 00978 operator&(const scalar<S>& value, const scalar<S>& mask) 00979 { 00980 scalar<S> result; 00981 const arbb_variable_t outputs[] = {result.vm_variable()}; 00982 00983 const arbb_variable_t inputs[] = {value.vm_variable(), mask.vm_variable()}; 00984 00985 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 00986 arbb_op(detail::function::current(), arbb_op_bit_and, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 00987 00988 return result; 00989 } 00990 00992 00995 01003 template <arbb_scalar_type_t S> 01004 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, scalar<S> >::type 01005 operator&(const scalar<S>& value, const typename uncaptured<scalar<S> >::type& mask) 01006 { 01007 scalar<S> scalar_mask(mask); 01008 scalar<S> result; 01009 const arbb_variable_t outputs[] = {result.vm_variable()}; 01010 01011 const arbb_variable_t inputs[] = {value.vm_variable(), scalar_mask.vm_variable()}; 01012 01013 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 01014 arbb_op(detail::function::current(), arbb_op_bit_and, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01015 01016 return result; 01017 } 01018 01020 01023 01031 template <arbb_scalar_type_t S> 01032 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, scalar<S> >::type 01033 operator&(const typename uncaptured<scalar<S> >::type& value, const scalar<S>& mask) 01034 { 01035 scalar<S> scalar_value(value); 01036 scalar<S> result; 01037 const arbb_variable_t outputs[] = {result.vm_variable()}; 01038 01039 const arbb_variable_t inputs[] = {scalar_value.vm_variable(), mask.vm_variable()}; 01040 01041 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 01042 arbb_op(detail::function::current(), arbb_op_bit_and, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01043 01044 return result; 01045 } 01046 01048 01049 01052 01060 template <arbb_scalar_type_t S> 01061 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, scalar<S>& >::type 01062 operator&=(scalar<S>& value, const scalar<S>& mask) 01063 { 01064 const arbb_variable_t outputs[] = {value.vm_variable()}; 01065 01066 const arbb_variable_t inputs[] = {value.vm_variable(), mask.vm_variable()}; 01067 01068 void* debug_data_ptrs[] = {value.get_debug_data_ptr()}; 01069 arbb_op(detail::function::current(), arbb_op_bit_and, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01070 01071 return value; 01072 } 01073 01075 01078 01086 template <arbb_scalar_type_t S> 01087 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, scalar<S>& >::type 01088 operator&=(scalar<S>& value, const typename uncaptured<scalar<S> >::type& mask) 01089 { 01090 scalar<S> scalar_mask(mask); 01091 const arbb_variable_t outputs[] = {value.vm_variable()}; 01092 01093 const arbb_variable_t inputs[] = {value.vm_variable(), scalar_mask.vm_variable()}; 01094 01095 void* debug_data_ptrs[] = {value.get_debug_data_ptr()}; 01096 arbb_op(detail::function::current(), arbb_op_bit_and, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01097 01098 return value; 01099 } 01100 01102 01105 01113 template <arbb_scalar_type_t S> 01114 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, scalar<S>& >::type 01115 operator&=(typename uncaptured<scalar<S> >::type& value, const scalar<S>& mask) 01116 { 01117 scalar<S> scalar_value(value); 01118 const arbb_variable_t outputs[] = {value.vm_variable()}; 01119 01120 const arbb_variable_t inputs[] = {scalar_value.vm_variable(), mask.vm_variable()}; 01121 01122 void* debug_data_ptrs[] = {value.get_debug_data_ptr()}; 01123 arbb_op(detail::function::current(), arbb_op_bit_and, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01124 01125 return value; 01126 } 01127 01129 01130 01133 01140 template <arbb_scalar_type_t S> 01141 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, scalar<S> >::type 01142 atan2(const scalar<S>& x, const scalar<S>& y) 01143 { 01144 scalar<S> result; 01145 const arbb_variable_t outputs[] = {result.vm_variable()}; 01146 01147 const arbb_variable_t inputs[] = {x.vm_variable(), y.vm_variable()}; 01148 01149 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 01150 arbb_op(detail::function::current(), arbb_op_atan2, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01151 01152 return result; 01153 } 01154 01156 01159 01166 template <arbb_scalar_type_t S> 01167 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, scalar<S> >::type 01168 atan2(const scalar<S>& x, const typename uncaptured<scalar<S> >::type& y) 01169 { 01170 scalar<S> scalar_y(y); 01171 scalar<S> result; 01172 const arbb_variable_t outputs[] = {result.vm_variable()}; 01173 01174 const arbb_variable_t inputs[] = {x.vm_variable(), scalar_y.vm_variable()}; 01175 01176 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 01177 arbb_op(detail::function::current(), arbb_op_atan2, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01178 01179 return result; 01180 } 01181 01183 01186 01193 template <arbb_scalar_type_t S> 01194 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, scalar<S> >::type 01195 atan2(const typename uncaptured<scalar<S> >::type& x, const scalar<S>& y) 01196 { 01197 scalar<S> scalar_x(x); 01198 scalar<S> result; 01199 const arbb_variable_t outputs[] = {result.vm_variable()}; 01200 01201 const arbb_variable_t inputs[] = {scalar_x.vm_variable(), y.vm_variable()}; 01202 01203 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 01204 arbb_op(detail::function::current(), arbb_op_atan2, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01205 01206 return result; 01207 } 01208 01210 01211 01214 01220 template <arbb_scalar_type_t S> 01221 isize 01222 compare(const scalar<S>& a, const scalar<S>& b) 01223 { 01224 isize result; 01225 const arbb_variable_t outputs[] = {result.vm_variable()}; 01226 01227 const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()}; 01228 01229 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 01230 arbb_op(detail::function::current(), arbb_op_compare, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01231 01232 return result; 01233 } 01234 01236 01239 01245 template <arbb_scalar_type_t S> 01246 isize 01247 compare(const scalar<S>& a, const typename uncaptured<scalar<S> >::type& b) 01248 { 01249 scalar<S> scalar_b(b); 01250 isize result; 01251 const arbb_variable_t outputs[] = {result.vm_variable()}; 01252 01253 const arbb_variable_t inputs[] = {a.vm_variable(), scalar_b.vm_variable()}; 01254 01255 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 01256 arbb_op(detail::function::current(), arbb_op_compare, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01257 01258 return result; 01259 } 01260 01262 01265 01271 template <arbb_scalar_type_t S> 01272 isize 01273 compare(const typename uncaptured<scalar<S> >::type& a, const scalar<S>& b) 01274 { 01275 scalar<S> scalar_a(a); 01276 isize result; 01277 const arbb_variable_t outputs[] = {result.vm_variable()}; 01278 01279 const arbb_variable_t inputs[] = {scalar_a.vm_variable(), b.vm_variable()}; 01280 01281 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 01282 arbb_op(detail::function::current(), arbb_op_compare, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01283 01284 return result; 01285 } 01286 01288 01289 01292 01299 template <arbb_scalar_type_t S> 01300 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, scalar<S> >::type 01301 operator/(const scalar<S>& numerator, const scalar<S>& denominator) 01302 { 01303 scalar<S> result; 01304 const arbb_variable_t outputs[] = {result.vm_variable()}; 01305 01306 const arbb_variable_t inputs[] = {numerator.vm_variable(), denominator.vm_variable()}; 01307 01308 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 01309 arbb_op(detail::function::current(), arbb_op_div, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01310 01311 return result; 01312 } 01313 01315 01318 01325 template <arbb_scalar_type_t S> 01326 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, scalar<S> >::type 01327 operator/(const scalar<S>& numerator, const typename uncaptured<scalar<S> >::type& denominator) 01328 { 01329 scalar<S> scalar_denominator(denominator); 01330 scalar<S> result; 01331 const arbb_variable_t outputs[] = {result.vm_variable()}; 01332 01333 const arbb_variable_t inputs[] = {numerator.vm_variable(), scalar_denominator.vm_variable()}; 01334 01335 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 01336 arbb_op(detail::function::current(), arbb_op_div, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01337 01338 return result; 01339 } 01340 01342 01345 01352 template <arbb_scalar_type_t S> 01353 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, scalar<S> >::type 01354 operator/(const typename uncaptured<scalar<S> >::type& numerator, const scalar<S>& denominator) 01355 { 01356 scalar<S> scalar_numerator(numerator); 01357 scalar<S> result; 01358 const arbb_variable_t outputs[] = {result.vm_variable()}; 01359 01360 const arbb_variable_t inputs[] = {scalar_numerator.vm_variable(), denominator.vm_variable()}; 01361 01362 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 01363 arbb_op(detail::function::current(), arbb_op_div, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01364 01365 return result; 01366 } 01367 01369 01370 01373 01380 template <arbb_scalar_type_t S> 01381 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, scalar<S>& >::type 01382 operator/=(scalar<S>& value, const scalar<S>& denominator) 01383 { 01384 const arbb_variable_t outputs[] = {value.vm_variable()}; 01385 01386 const arbb_variable_t inputs[] = {value.vm_variable(), denominator.vm_variable()}; 01387 01388 void* debug_data_ptrs[] = {value.get_debug_data_ptr()}; 01389 arbb_op(detail::function::current(), arbb_op_div, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01390 01391 return value; 01392 } 01393 01395 01398 01405 template <arbb_scalar_type_t S> 01406 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, scalar<S>& >::type 01407 operator/=(scalar<S>& value, const typename uncaptured<scalar<S> >::type& denominator) 01408 { 01409 scalar<S> scalar_denominator(denominator); 01410 const arbb_variable_t outputs[] = {value.vm_variable()}; 01411 01412 const arbb_variable_t inputs[] = {value.vm_variable(), scalar_denominator.vm_variable()}; 01413 01414 void* debug_data_ptrs[] = {value.get_debug_data_ptr()}; 01415 arbb_op(detail::function::current(), arbb_op_div, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01416 01417 return value; 01418 } 01419 01421 01424 01431 template <arbb_scalar_type_t S> 01432 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, scalar<S>& >::type 01433 operator/=(typename uncaptured<scalar<S> >::type& value, const scalar<S>& denominator) 01434 { 01435 scalar<S> scalar_value(value); 01436 const arbb_variable_t outputs[] = {value.vm_variable()}; 01437 01438 const arbb_variable_t inputs[] = {scalar_value.vm_variable(), denominator.vm_variable()}; 01439 01440 void* debug_data_ptrs[] = {value.get_debug_data_ptr()}; 01441 arbb_op(detail::function::current(), arbb_op_div, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01442 01443 return value; 01444 } 01445 01447 01448 01451 01458 template <arbb_scalar_type_t S> 01459 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, scalar<S> >::type 01460 div_tan(const scalar<S>& x, const scalar<S>& y) 01461 { 01462 scalar<S> result; 01463 const arbb_variable_t outputs[] = {result.vm_variable()}; 01464 01465 const arbb_variable_t inputs[] = {x.vm_variable(), y.vm_variable()}; 01466 01467 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 01468 arbb_op(detail::function::current(), arbb_op_div_tan, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01469 01470 return result; 01471 } 01472 01474 01477 01484 template <arbb_scalar_type_t S> 01485 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, scalar<S> >::type 01486 div_tan(const scalar<S>& x, const typename uncaptured<scalar<S> >::type& y) 01487 { 01488 scalar<S> scalar_y(y); 01489 scalar<S> result; 01490 const arbb_variable_t outputs[] = {result.vm_variable()}; 01491 01492 const arbb_variable_t inputs[] = {x.vm_variable(), scalar_y.vm_variable()}; 01493 01494 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 01495 arbb_op(detail::function::current(), arbb_op_div_tan, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01496 01497 return result; 01498 } 01499 01501 01504 01511 template <arbb_scalar_type_t S> 01512 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, scalar<S> >::type 01513 div_tan(const typename uncaptured<scalar<S> >::type& x, const scalar<S>& y) 01514 { 01515 scalar<S> scalar_x(x); 01516 scalar<S> result; 01517 const arbb_variable_t outputs[] = {result.vm_variable()}; 01518 01519 const arbb_variable_t inputs[] = {scalar_x.vm_variable(), y.vm_variable()}; 01520 01521 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 01522 arbb_op(detail::function::current(), arbb_op_div_tan, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01523 01524 return result; 01525 } 01526 01528 01529 01532 01538 template <arbb_scalar_type_t S> 01539 boolean 01540 operator==(const scalar<S>& a, const scalar<S>& b) 01541 { 01542 boolean result; 01543 const arbb_variable_t outputs[] = {result.vm_variable()}; 01544 01545 const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()}; 01546 01547 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 01548 arbb_op(detail::function::current(), arbb_op_equal, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01549 01550 return result; 01551 } 01552 01554 01557 01563 template <arbb_scalar_type_t S> 01564 boolean 01565 operator==(const scalar<S>& a, const typename uncaptured<scalar<S> >::type& b) 01566 { 01567 scalar<S> scalar_b(b); 01568 boolean result; 01569 const arbb_variable_t outputs[] = {result.vm_variable()}; 01570 01571 const arbb_variable_t inputs[] = {a.vm_variable(), scalar_b.vm_variable()}; 01572 01573 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 01574 arbb_op(detail::function::current(), arbb_op_equal, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01575 01576 return result; 01577 } 01578 01580 01583 01589 template <arbb_scalar_type_t S> 01590 boolean 01591 operator==(const typename uncaptured<scalar<S> >::type& a, const scalar<S>& b) 01592 { 01593 scalar<S> scalar_a(a); 01594 boolean result; 01595 const arbb_variable_t outputs[] = {result.vm_variable()}; 01596 01597 const arbb_variable_t inputs[] = {scalar_a.vm_variable(), b.vm_variable()}; 01598 01599 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 01600 arbb_op(detail::function::current(), arbb_op_equal, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01601 01602 return result; 01603 } 01604 01606 01607 01610 01616 template <arbb_scalar_type_t S> 01617 boolean 01618 operator>=(const scalar<S>& a, const scalar<S>& b) 01619 { 01620 boolean result; 01621 const arbb_variable_t outputs[] = {result.vm_variable()}; 01622 01623 const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()}; 01624 01625 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 01626 arbb_op(detail::function::current(), arbb_op_geq, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01627 01628 return result; 01629 } 01630 01632 01635 01641 template <arbb_scalar_type_t S> 01642 boolean 01643 operator>=(const scalar<S>& a, const typename uncaptured<scalar<S> >::type& b) 01644 { 01645 scalar<S> scalar_b(b); 01646 boolean result; 01647 const arbb_variable_t outputs[] = {result.vm_variable()}; 01648 01649 const arbb_variable_t inputs[] = {a.vm_variable(), scalar_b.vm_variable()}; 01650 01651 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 01652 arbb_op(detail::function::current(), arbb_op_geq, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01653 01654 return result; 01655 } 01656 01658 01661 01667 template <arbb_scalar_type_t S> 01668 boolean 01669 operator>=(const typename uncaptured<scalar<S> >::type& a, const scalar<S>& b) 01670 { 01671 scalar<S> scalar_a(a); 01672 boolean result; 01673 const arbb_variable_t outputs[] = {result.vm_variable()}; 01674 01675 const arbb_variable_t inputs[] = {scalar_a.vm_variable(), b.vm_variable()}; 01676 01677 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 01678 arbb_op(detail::function::current(), arbb_op_geq, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01679 01680 return result; 01681 } 01682 01684 01685 01688 01694 template <arbb_scalar_type_t S> 01695 boolean 01696 operator>(const scalar<S>& a, const scalar<S>& b) 01697 { 01698 boolean result; 01699 const arbb_variable_t outputs[] = {result.vm_variable()}; 01700 01701 const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()}; 01702 01703 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 01704 arbb_op(detail::function::current(), arbb_op_greater, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01705 01706 return result; 01707 } 01708 01710 01713 01719 template <arbb_scalar_type_t S> 01720 boolean 01721 operator>(const scalar<S>& a, const typename uncaptured<scalar<S> >::type& b) 01722 { 01723 scalar<S> scalar_b(b); 01724 boolean result; 01725 const arbb_variable_t outputs[] = {result.vm_variable()}; 01726 01727 const arbb_variable_t inputs[] = {a.vm_variable(), scalar_b.vm_variable()}; 01728 01729 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 01730 arbb_op(detail::function::current(), arbb_op_greater, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01731 01732 return result; 01733 } 01734 01736 01739 01745 template <arbb_scalar_type_t S> 01746 boolean 01747 operator>(const typename uncaptured<scalar<S> >::type& a, const scalar<S>& b) 01748 { 01749 scalar<S> scalar_a(a); 01750 boolean result; 01751 const arbb_variable_t outputs[] = {result.vm_variable()}; 01752 01753 const arbb_variable_t inputs[] = {scalar_a.vm_variable(), b.vm_variable()}; 01754 01755 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 01756 arbb_op(detail::function::current(), arbb_op_greater, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01757 01758 return result; 01759 } 01760 01762 01763 01766 01774 template <arbb_scalar_type_t S> 01775 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, scalar<S> >::type 01776 operator|(const scalar<S>& value, const scalar<S>& mask) 01777 { 01778 scalar<S> result; 01779 const arbb_variable_t outputs[] = {result.vm_variable()}; 01780 01781 const arbb_variable_t inputs[] = {value.vm_variable(), mask.vm_variable()}; 01782 01783 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 01784 arbb_op(detail::function::current(), arbb_op_bit_or, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01785 01786 return result; 01787 } 01788 01790 01793 01801 template <arbb_scalar_type_t S> 01802 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, scalar<S> >::type 01803 operator|(const scalar<S>& value, const typename uncaptured<scalar<S> >::type& mask) 01804 { 01805 scalar<S> scalar_mask(mask); 01806 scalar<S> result; 01807 const arbb_variable_t outputs[] = {result.vm_variable()}; 01808 01809 const arbb_variable_t inputs[] = {value.vm_variable(), scalar_mask.vm_variable()}; 01810 01811 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 01812 arbb_op(detail::function::current(), arbb_op_bit_or, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01813 01814 return result; 01815 } 01816 01818 01821 01829 template <arbb_scalar_type_t S> 01830 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, scalar<S> >::type 01831 operator|(const typename uncaptured<scalar<S> >::type& value, const scalar<S>& mask) 01832 { 01833 scalar<S> scalar_value(value); 01834 scalar<S> result; 01835 const arbb_variable_t outputs[] = {result.vm_variable()}; 01836 01837 const arbb_variable_t inputs[] = {scalar_value.vm_variable(), mask.vm_variable()}; 01838 01839 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 01840 arbb_op(detail::function::current(), arbb_op_bit_or, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01841 01842 return result; 01843 } 01844 01846 01847 01850 01858 template <arbb_scalar_type_t S> 01859 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, scalar<S>& >::type 01860 operator|=(scalar<S>& value, const scalar<S>& mask) 01861 { 01862 const arbb_variable_t outputs[] = {value.vm_variable()}; 01863 01864 const arbb_variable_t inputs[] = {value.vm_variable(), mask.vm_variable()}; 01865 01866 void* debug_data_ptrs[] = {value.get_debug_data_ptr()}; 01867 arbb_op(detail::function::current(), arbb_op_bit_or, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01868 01869 return value; 01870 } 01871 01873 01876 01884 template <arbb_scalar_type_t S> 01885 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, scalar<S>& >::type 01886 operator|=(scalar<S>& value, const typename uncaptured<scalar<S> >::type& mask) 01887 { 01888 scalar<S> scalar_mask(mask); 01889 const arbb_variable_t outputs[] = {value.vm_variable()}; 01890 01891 const arbb_variable_t inputs[] = {value.vm_variable(), scalar_mask.vm_variable()}; 01892 01893 void* debug_data_ptrs[] = {value.get_debug_data_ptr()}; 01894 arbb_op(detail::function::current(), arbb_op_bit_or, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01895 01896 return value; 01897 } 01898 01900 01903 01911 template <arbb_scalar_type_t S> 01912 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, scalar<S>& >::type 01913 operator|=(typename uncaptured<scalar<S> >::type& value, const scalar<S>& mask) 01914 { 01915 scalar<S> scalar_value(value); 01916 const arbb_variable_t outputs[] = {value.vm_variable()}; 01917 01918 const arbb_variable_t inputs[] = {scalar_value.vm_variable(), mask.vm_variable()}; 01919 01920 void* debug_data_ptrs[] = {value.get_debug_data_ptr()}; 01921 arbb_op(detail::function::current(), arbb_op_bit_or, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01922 01923 return value; 01924 } 01925 01927 01928 01931 01937 template <arbb_scalar_type_t S> 01938 boolean 01939 operator<=(const scalar<S>& a, const scalar<S>& b) 01940 { 01941 boolean result; 01942 const arbb_variable_t outputs[] = {result.vm_variable()}; 01943 01944 const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()}; 01945 01946 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 01947 arbb_op(detail::function::current(), arbb_op_leq, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01948 01949 return result; 01950 } 01951 01953 01956 01962 template <arbb_scalar_type_t S> 01963 boolean 01964 operator<=(const scalar<S>& a, const typename uncaptured<scalar<S> >::type& b) 01965 { 01966 scalar<S> scalar_b(b); 01967 boolean result; 01968 const arbb_variable_t outputs[] = {result.vm_variable()}; 01969 01970 const arbb_variable_t inputs[] = {a.vm_variable(), scalar_b.vm_variable()}; 01971 01972 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 01973 arbb_op(detail::function::current(), arbb_op_leq, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01974 01975 return result; 01976 } 01977 01979 01982 01988 template <arbb_scalar_type_t S> 01989 boolean 01990 operator<=(const typename uncaptured<scalar<S> >::type& a, const scalar<S>& b) 01991 { 01992 scalar<S> scalar_a(a); 01993 boolean result; 01994 const arbb_variable_t outputs[] = {result.vm_variable()}; 01995 01996 const arbb_variable_t inputs[] = {scalar_a.vm_variable(), b.vm_variable()}; 01997 01998 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 01999 arbb_op(detail::function::current(), arbb_op_leq, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 02000 02001 return result; 02002 } 02003 02005 02006 02009 02015 template <arbb_scalar_type_t S> 02016 boolean 02017 operator<(const scalar<S>& a, const scalar<S>& b) 02018 { 02019 boolean result; 02020 const arbb_variable_t outputs[] = {result.vm_variable()}; 02021 02022 const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()}; 02023 02024 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 02025 arbb_op(detail::function::current(), arbb_op_less, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 02026 02027 return result; 02028 } 02029 02031 02034 02040 template <arbb_scalar_type_t S> 02041 boolean 02042 operator<(const scalar<S>& a, const typename uncaptured<scalar<S> >::type& b) 02043 { 02044 scalar<S> scalar_b(b); 02045 boolean result; 02046 const arbb_variable_t outputs[] = {result.vm_variable()}; 02047 02048 const arbb_variable_t inputs[] = {a.vm_variable(), scalar_b.vm_variable()}; 02049 02050 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 02051 arbb_op(detail::function::current(), arbb_op_less, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 02052 02053 return result; 02054 } 02055 02057 02060 02066 template <arbb_scalar_type_t S> 02067 boolean 02068 operator<(const typename uncaptured<scalar<S> >::type& a, const scalar<S>& b) 02069 { 02070 scalar<S> scalar_a(a); 02071 boolean result; 02072 const arbb_variable_t outputs[] = {result.vm_variable()}; 02073 02074 const arbb_variable_t inputs[] = {scalar_a.vm_variable(), b.vm_variable()}; 02075 02076 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 02077 arbb_op(detail::function::current(), arbb_op_less, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 02078 02079 return result; 02080 } 02081 02083 02084 02087 02093 inline boolean 02094 operator&&(const boolean& a, const boolean& b) 02095 { 02096 boolean result; 02097 const arbb_variable_t outputs[] = {result.vm_variable()}; 02098 02099 const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()}; 02100 02101 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 02102 arbb_op(detail::function::current(), arbb_op_log_and, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 02103 02104 return result; 02105 } 02106 02108 02111 02117 inline boolean 02118 operator&&(const boolean& a, const uncaptured<boolean >::type& b) 02119 { 02120 boolean scalar_b(b); 02121 boolean result; 02122 const arbb_variable_t outputs[] = {result.vm_variable()}; 02123 02124 const arbb_variable_t inputs[] = {a.vm_variable(), scalar_b.vm_variable()}; 02125 02126 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 02127 arbb_op(detail::function::current(), arbb_op_log_and, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 02128 02129 return result; 02130 } 02131 02133 02136 02142 inline boolean 02143 operator&&(const uncaptured<boolean >::type& a, const boolean& b) 02144 { 02145 boolean scalar_a(a); 02146 boolean result; 02147 const arbb_variable_t outputs[] = {result.vm_variable()}; 02148 02149 const arbb_variable_t inputs[] = {scalar_a.vm_variable(), b.vm_variable()}; 02150 02151 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 02152 arbb_op(detail::function::current(), arbb_op_log_and, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 02153 02154 return result; 02155 } 02156 02158 02159 02162 02168 inline boolean 02169 operator||(const boolean& a, const boolean& b) 02170 { 02171 boolean result; 02172 const arbb_variable_t outputs[] = {result.vm_variable()}; 02173 02174 const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()}; 02175 02176 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 02177 arbb_op(detail::function::current(), arbb_op_log_or, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 02178 02179 return result; 02180 } 02181 02183 02186 02192 inline boolean 02193 operator||(const boolean& a, const uncaptured<boolean >::type& b) 02194 { 02195 boolean scalar_b(b); 02196 boolean result; 02197 const arbb_variable_t outputs[] = {result.vm_variable()}; 02198 02199 const arbb_variable_t inputs[] = {a.vm_variable(), scalar_b.vm_variable()}; 02200 02201 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 02202 arbb_op(detail::function::current(), arbb_op_log_or, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 02203 02204 return result; 02205 } 02206 02208 02211 02217 inline boolean 02218 operator||(const uncaptured<boolean >::type& a, const boolean& b) 02219 { 02220 boolean scalar_a(a); 02221 boolean result; 02222 const arbb_variable_t outputs[] = {result.vm_variable()}; 02223 02224 const arbb_variable_t inputs[] = {scalar_a.vm_variable(), b.vm_variable()}; 02225 02226 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 02227 arbb_op(detail::function::current(), arbb_op_log_or, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 02228 02229 return result; 02230 } 02231 02233 02234 02237 02245 template <arbb_scalar_type_t S> 02246 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, scalar<S> >::type 02247 operator<<(const scalar<S>& value, const scalar<S>& shift_amount) 02248 { 02249 scalar<S> result; 02250 02251 detail::operator_lsh(result, value, shift_amount); 02252 02253 return result; 02254 } 02255 02257 02260 02268 template <arbb_scalar_type_t S> 02269 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, scalar<S> >::type 02270 operator<<(const scalar<S>& value, const typename uncaptured<scalar<S> >::type& shift_amount) 02271 { 02272 scalar<S> scalar_shift_amount(shift_amount); 02273 scalar<S> result; 02274 02275 detail::operator_lsh(result, value, scalar_shift_amount); 02276 02277 return result; 02278 } 02279 02281 02284 02292 template <arbb_scalar_type_t S> 02293 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, scalar<S> >::type 02294 operator<<(const typename uncaptured<scalar<S> >::type& value, const scalar<S>& shift_amount) 02295 { 02296 scalar<S> scalar_value(value); 02297 scalar<S> result; 02298 02299 detail::operator_lsh(result, scalar_value, shift_amount); 02300 02301 return result; 02302 } 02303 02305 02306 02309 02317 template <arbb_scalar_type_t S> 02318 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, scalar<S>& >::type 02319 operator<<=(scalar<S>& value, const scalar<S>& shift_amount) 02320 { 02321 02322 detail::operator_lsh(value, value, shift_amount); 02323 02324 return value; 02325 } 02326 02328 02331 02339 template <arbb_scalar_type_t S> 02340 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, scalar<S>& >::type 02341 operator<<=(scalar<S>& value, const typename uncaptured<scalar<S> >::type& shift_amount) 02342 { 02343 scalar<S> scalar_shift_amount(shift_amount); 02344 02345 detail::operator_lsh(value, value, scalar_shift_amount); 02346 02347 return value; 02348 } 02349 02351 02354 02362 template <arbb_scalar_type_t S> 02363 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, scalar<S>& >::type 02364 operator<<=(typename uncaptured<scalar<S> >::type& value, const scalar<S>& shift_amount) 02365 { 02366 scalar<S> scalar_value(value); 02367 02368 detail::operator_lsh(value, scalar_value, shift_amount); 02369 02370 return value; 02371 } 02372 02374 02375 02378 02384 template <arbb_scalar_type_t S> 02385 scalar<S> 02386 max(const scalar<S>& a, const scalar<S>& b) 02387 { 02388 scalar<S> result; 02389 const arbb_variable_t outputs[] = {result.vm_variable()}; 02390 02391 const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()}; 02392 02393 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 02394 arbb_op(detail::function::current(), arbb_op_max, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 02395 02396 return result; 02397 } 02398 02400 02403 02409 template <arbb_scalar_type_t S> 02410 scalar<S> 02411 max(const scalar<S>& a, const typename uncaptured<scalar<S> >::type& b) 02412 { 02413 scalar<S> scalar_b(b); 02414 scalar<S> result; 02415 const arbb_variable_t outputs[] = {result.vm_variable()}; 02416 02417 const arbb_variable_t inputs[] = {a.vm_variable(), scalar_b.vm_variable()}; 02418 02419 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 02420 arbb_op(detail::function::current(), arbb_op_max, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 02421 02422 return result; 02423 } 02424 02426 02429 02435 template <arbb_scalar_type_t S> 02436 scalar<S> 02437 max(const typename uncaptured<scalar<S> >::type& a, const scalar<S>& b) 02438 { 02439 scalar<S> scalar_a(a); 02440 scalar<S> result; 02441 const arbb_variable_t outputs[] = {result.vm_variable()}; 02442 02443 const arbb_variable_t inputs[] = {scalar_a.vm_variable(), b.vm_variable()}; 02444 02445 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 02446 arbb_op(detail::function::current(), arbb_op_max, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 02447 02448 return result; 02449 } 02450 02452 02453 02456 02462 template <arbb_scalar_type_t S> 02463 scalar<S> 02464 min(const scalar<S>& a, const scalar<S>& b) 02465 { 02466 scalar<S> result; 02467 const arbb_variable_t outputs[] = {result.vm_variable()}; 02468 02469 const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()}; 02470 02471 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 02472 arbb_op(detail::function::current(), arbb_op_min, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 02473 02474 return result; 02475 } 02476 02478 02481 02487 template <arbb_scalar_type_t S> 02488 scalar<S> 02489 min(const scalar<S>& a, const typename uncaptured<scalar<S> >::type& b) 02490 { 02491 scalar<S> scalar_b(b); 02492 scalar<S> result; 02493 const arbb_variable_t outputs[] = {result.vm_variable()}; 02494 02495 const arbb_variable_t inputs[] = {a.vm_variable(), scalar_b.vm_variable()}; 02496 02497 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 02498 arbb_op(detail::function::current(), arbb_op_min, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 02499 02500 return result; 02501 } 02502 02504 02507 02513 template <arbb_scalar_type_t S> 02514 scalar<S> 02515 min(const typename uncaptured<scalar<S> >::type& a, const scalar<S>& b) 02516 { 02517 scalar<S> scalar_a(a); 02518 scalar<S> result; 02519 const arbb_variable_t outputs[] = {result.vm_variable()}; 02520 02521 const arbb_variable_t inputs[] = {scalar_a.vm_variable(), b.vm_variable()}; 02522 02523 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 02524 arbb_op(detail::function::current(), arbb_op_min, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 02525 02526 return result; 02527 } 02528 02530 02531 02534 02542 template <arbb_scalar_type_t S> 02543 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, scalar<S> >::type 02544 operator%(const scalar<S>& dividend, const scalar<S>& divisor) 02545 { 02546 scalar<S> result; 02547 const arbb_variable_t outputs[] = {result.vm_variable()}; 02548 02549 const arbb_variable_t inputs[] = {dividend.vm_variable(), divisor.vm_variable()}; 02550 02551 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 02552 arbb_op(detail::function::current(), arbb_op_mod, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 02553 02554 return result; 02555 } 02556 02558 02561 02569 template <arbb_scalar_type_t S> 02570 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, scalar<S> >::type 02571 operator%(const scalar<S>& dividend, const typename uncaptured<scalar<S> >::type& divisor) 02572 { 02573 scalar<S> scalar_divisor(divisor); 02574 scalar<S> result; 02575 const arbb_variable_t outputs[] = {result.vm_variable()}; 02576 02577 const arbb_variable_t inputs[] = {dividend.vm_variable(), scalar_divisor.vm_variable()}; 02578 02579 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 02580 arbb_op(detail::function::current(), arbb_op_mod, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 02581 02582 return result; 02583 } 02584 02586 02589 02597 template <arbb_scalar_type_t S> 02598 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, scalar<S> >::type 02599 operator%(const typename uncaptured<scalar<S> >::type& dividend, const scalar<S>& divisor) 02600 { 02601 scalar<S> scalar_dividend(dividend); 02602 scalar<S> result; 02603 const arbb_variable_t outputs[] = {result.vm_variable()}; 02604 02605 const arbb_variable_t inputs[] = {scalar_dividend.vm_variable(), divisor.vm_variable()}; 02606 02607 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 02608 arbb_op(detail::function::current(), arbb_op_mod, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 02609 02610 return result; 02611 } 02612 02614 02615 02618 02626 template <arbb_scalar_type_t S> 02627 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, scalar<S>& >::type 02628 operator%=(scalar<S>& value, const scalar<S>& divisor) 02629 { 02630 const arbb_variable_t outputs[] = {value.vm_variable()}; 02631 02632 const arbb_variable_t inputs[] = {value.vm_variable(), divisor.vm_variable()}; 02633 02634 void* debug_data_ptrs[] = {value.get_debug_data_ptr()}; 02635 arbb_op(detail::function::current(), arbb_op_mod, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 02636 02637 return value; 02638 } 02639 02641 02644 02652 template <arbb_scalar_type_t S> 02653 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, scalar<S>& >::type 02654 operator%=(scalar<S>& value, const typename uncaptured<scalar<S> >::type& divisor) 02655 { 02656 scalar<S> scalar_divisor(divisor); 02657 const arbb_variable_t outputs[] = {value.vm_variable()}; 02658 02659 const arbb_variable_t inputs[] = {value.vm_variable(), scalar_divisor.vm_variable()}; 02660 02661 void* debug_data_ptrs[] = {value.get_debug_data_ptr()}; 02662 arbb_op(detail::function::current(), arbb_op_mod, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 02663 02664 return value; 02665 } 02666 02668 02671 02679 template <arbb_scalar_type_t S> 02680 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, scalar<S>& >::type 02681 operator%=(typename uncaptured<scalar<S> >::type& value, const scalar<S>& divisor) 02682 { 02683 scalar<S> scalar_value(value); 02684 const arbb_variable_t outputs[] = {value.vm_variable()}; 02685 02686 const arbb_variable_t inputs[] = {scalar_value.vm_variable(), divisor.vm_variable()}; 02687 02688 void* debug_data_ptrs[] = {value.get_debug_data_ptr()}; 02689 arbb_op(detail::function::current(), arbb_op_mod, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 02690 02691 return value; 02692 } 02693 02695 02696 02699 02706 template <arbb_scalar_type_t S> 02707 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, scalar<S> >::type 02708 operator*(const scalar<S>& a, const scalar<S>& b) 02709 { 02710 scalar<S> result; 02711 const arbb_variable_t outputs[] = {result.vm_variable()}; 02712 02713 const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()}; 02714 02715 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 02716 arbb_op(detail::function::current(), arbb_op_mul, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 02717 02718 return result; 02719 } 02720 02722 02725 02732 template <arbb_scalar_type_t S> 02733 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, scalar<S> >::type 02734 operator*(const scalar<S>& a, const typename uncaptured<scalar<S> >::type& b) 02735 { 02736 scalar<S> scalar_b(b); 02737 scalar<S> result; 02738 const arbb_variable_t outputs[] = {result.vm_variable()}; 02739 02740 const arbb_variable_t inputs[] = {a.vm_variable(), scalar_b.vm_variable()}; 02741 02742 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 02743 arbb_op(detail::function::current(), arbb_op_mul, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 02744 02745 return result; 02746 } 02747 02749 02752 02759 template <arbb_scalar_type_t S> 02760 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, scalar<S> >::type 02761 operator*(const typename uncaptured<scalar<S> >::type& a, const scalar<S>& b) 02762 { 02763 scalar<S> scalar_a(a); 02764 scalar<S> result; 02765 const arbb_variable_t outputs[] = {result.vm_variable()}; 02766 02767 const arbb_variable_t inputs[] = {scalar_a.vm_variable(), b.vm_variable()}; 02768 02769 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 02770 arbb_op(detail::function::current(), arbb_op_mul, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 02771 02772 return result; 02773 } 02774 02776 02777 02780 02787 template <arbb_scalar_type_t S> 02788 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, scalar<S>& >::type 02789 operator*=(scalar<S>& value, const scalar<S>& multiplicand) 02790 { 02791 const arbb_variable_t outputs[] = {value.vm_variable()}; 02792 02793 const arbb_variable_t inputs[] = {value.vm_variable(), multiplicand.vm_variable()}; 02794 02795 void* debug_data_ptrs[] = {value.get_debug_data_ptr()}; 02796 arbb_op(detail::function::current(), arbb_op_mul, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 02797 02798 return value; 02799 } 02800 02802 02805 02812 template <arbb_scalar_type_t S> 02813 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, scalar<S>& >::type 02814 operator*=(scalar<S>& value, const typename uncaptured<scalar<S> >::type& multiplicand) 02815 { 02816 scalar<S> scalar_multiplicand(multiplicand); 02817 const arbb_variable_t outputs[] = {value.vm_variable()}; 02818 02819 const arbb_variable_t inputs[] = {value.vm_variable(), scalar_multiplicand.vm_variable()}; 02820 02821 void* debug_data_ptrs[] = {value.get_debug_data_ptr()}; 02822 arbb_op(detail::function::current(), arbb_op_mul, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 02823 02824 return value; 02825 } 02826 02828 02831 02838 template <arbb_scalar_type_t S> 02839 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, scalar<S>& >::type 02840 operator*=(typename uncaptured<scalar<S> >::type& value, const scalar<S>& multiplicand) 02841 { 02842 scalar<S> scalar_value(value); 02843 const arbb_variable_t outputs[] = {value.vm_variable()}; 02844 02845 const arbb_variable_t inputs[] = {scalar_value.vm_variable(), multiplicand.vm_variable()}; 02846 02847 void* debug_data_ptrs[] = {value.get_debug_data_ptr()}; 02848 arbb_op(detail::function::current(), arbb_op_mul, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 02849 02850 return value; 02851 } 02852 02854 02855 02858 02864 template <arbb_scalar_type_t S> 02865 boolean 02866 operator!=(const scalar<S>& a, const scalar<S>& b) 02867 { 02868 boolean result; 02869 const arbb_variable_t outputs[] = {result.vm_variable()}; 02870 02871 const arbb_variable_t inputs[] = {a.vm_variable(), b.vm_variable()}; 02872 02873 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 02874 arbb_op(detail::function::current(), arbb_op_neq, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 02875 02876 return result; 02877 } 02878 02880 02883 02889 template <arbb_scalar_type_t S> 02890 boolean 02891 operator!=(const scalar<S>& a, const typename uncaptured<scalar<S> >::type& b) 02892 { 02893 scalar<S> scalar_b(b); 02894 boolean result; 02895 const arbb_variable_t outputs[] = {result.vm_variable()}; 02896 02897 const arbb_variable_t inputs[] = {a.vm_variable(), scalar_b.vm_variable()}; 02898 02899 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 02900 arbb_op(detail::function::current(), arbb_op_neq, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 02901 02902 return result; 02903 } 02904 02906 02909 02915 template <arbb_scalar_type_t S> 02916 boolean 02917 operator!=(const typename uncaptured<scalar<S> >::type& a, const scalar<S>& b) 02918 { 02919 scalar<S> scalar_a(a); 02920 boolean result; 02921 const arbb_variable_t outputs[] = {result.vm_variable()}; 02922 02923 const arbb_variable_t inputs[] = {scalar_a.vm_variable(), b.vm_variable()}; 02924 02925 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 02926 arbb_op(detail::function::current(), arbb_op_neq, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 02927 02928 return result; 02929 } 02930 02932 02933 02936 02943 template <arbb_scalar_type_t S> 02944 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, scalar<S> >::type 02945 pow(const scalar<S>& base, const scalar<S>& exponent) 02946 { 02947 scalar<S> result; 02948 const arbb_variable_t outputs[] = {result.vm_variable()}; 02949 02950 const arbb_variable_t inputs[] = {base.vm_variable(), exponent.vm_variable()}; 02951 02952 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 02953 arbb_op(detail::function::current(), arbb_op_pow, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 02954 02955 return result; 02956 } 02957 02959 02962 02969 template <arbb_scalar_type_t S> 02970 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, scalar<S> >::type 02971 pow(const scalar<S>& base, const typename uncaptured<scalar<S> >::type& exponent) 02972 { 02973 scalar<S> scalar_exponent(exponent); 02974 scalar<S> result; 02975 const arbb_variable_t outputs[] = {result.vm_variable()}; 02976 02977 const arbb_variable_t inputs[] = {base.vm_variable(), scalar_exponent.vm_variable()}; 02978 02979 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 02980 arbb_op(detail::function::current(), arbb_op_pow, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 02981 02982 return result; 02983 } 02984 02986 02989 02996 template <arbb_scalar_type_t S> 02997 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_fp< scalar<S> >::value, scalar<S> >::type 02998 pow(const typename uncaptured<scalar<S> >::type& base, const scalar<S>& exponent) 02999 { 03000 scalar<S> scalar_base(base); 03001 scalar<S> result; 03002 const arbb_variable_t outputs[] = {result.vm_variable()}; 03003 03004 const arbb_variable_t inputs[] = {scalar_base.vm_variable(), exponent.vm_variable()}; 03005 03006 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 03007 arbb_op(detail::function::current(), arbb_op_pow, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 03008 03009 return result; 03010 } 03011 03013 03014 03017 03025 template <arbb_scalar_type_t S> 03026 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, scalar<S> >::type 03027 operator>>(const scalar<S>& value, const scalar<S>& shift_amount) 03028 { 03029 scalar<S> result; 03030 03031 detail::operator_rsh(result, value, shift_amount); 03032 03033 return result; 03034 } 03035 03037 03040 03048 template <arbb_scalar_type_t S> 03049 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, scalar<S> >::type 03050 operator>>(const scalar<S>& value, const typename uncaptured<scalar<S> >::type& shift_amount) 03051 { 03052 scalar<S> scalar_shift_amount(shift_amount); 03053 scalar<S> result; 03054 03055 detail::operator_rsh(result, value, scalar_shift_amount); 03056 03057 return result; 03058 } 03059 03061 03064 03072 template <arbb_scalar_type_t S> 03073 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, scalar<S> >::type 03074 operator>>(const typename uncaptured<scalar<S> >::type& value, const scalar<S>& shift_amount) 03075 { 03076 scalar<S> scalar_value(value); 03077 scalar<S> result; 03078 03079 detail::operator_rsh(result, scalar_value, shift_amount); 03080 03081 return result; 03082 } 03083 03085 03086 03089 03097 template <arbb_scalar_type_t S> 03098 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, scalar<S>& >::type 03099 operator>>=(scalar<S>& value, const scalar<S>& shift_amount) 03100 { 03101 03102 detail::operator_rsh(value, value, shift_amount); 03103 03104 return value; 03105 } 03106 03108 03111 03119 template <arbb_scalar_type_t S> 03120 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, scalar<S>& >::type 03121 operator>>=(scalar<S>& value, const typename uncaptured<scalar<S> >::type& shift_amount) 03122 { 03123 scalar<S> scalar_shift_amount(shift_amount); 03124 03125 detail::operator_rsh(value, value, scalar_shift_amount); 03126 03127 return value; 03128 } 03129 03131 03134 03142 template <arbb_scalar_type_t S> 03143 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, scalar<S>& >::type 03144 operator>>=(typename uncaptured<scalar<S> >::type& value, const scalar<S>& shift_amount) 03145 { 03146 scalar<S> scalar_value(value); 03147 03148 detail::operator_rsh(value, scalar_value, shift_amount); 03149 03150 return value; 03151 } 03152 03154 03155 03158 03165 template <arbb_scalar_type_t S> 03166 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, scalar<S> >::type 03167 operator-(const scalar<S>& value, const scalar<S>& amount) 03168 { 03169 scalar<S> result; 03170 const arbb_variable_t outputs[] = {result.vm_variable()}; 03171 03172 const arbb_variable_t inputs[] = {value.vm_variable(), amount.vm_variable()}; 03173 03174 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 03175 arbb_op(detail::function::current(), arbb_op_sub, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 03176 03177 return result; 03178 } 03179 03181 03184 03191 template <arbb_scalar_type_t S> 03192 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, scalar<S> >::type 03193 operator-(const scalar<S>& value, const typename uncaptured<scalar<S> >::type& amount) 03194 { 03195 scalar<S> scalar_amount(amount); 03196 scalar<S> result; 03197 const arbb_variable_t outputs[] = {result.vm_variable()}; 03198 03199 const arbb_variable_t inputs[] = {value.vm_variable(), scalar_amount.vm_variable()}; 03200 03201 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 03202 arbb_op(detail::function::current(), arbb_op_sub, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 03203 03204 return result; 03205 } 03206 03208 03211 03218 template <arbb_scalar_type_t S> 03219 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, scalar<S> >::type 03220 operator-(const typename uncaptured<scalar<S> >::type& value, const scalar<S>& amount) 03221 { 03222 scalar<S> scalar_value(value); 03223 scalar<S> result; 03224 const arbb_variable_t outputs[] = {result.vm_variable()}; 03225 03226 const arbb_variable_t inputs[] = {scalar_value.vm_variable(), amount.vm_variable()}; 03227 03228 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 03229 arbb_op(detail::function::current(), arbb_op_sub, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 03230 03231 return result; 03232 } 03233 03235 03236 03239 03246 template <arbb_scalar_type_t S> 03247 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, scalar<S>& >::type 03248 operator-=(scalar<S>& value, const scalar<S>& amount) 03249 { 03250 const arbb_variable_t outputs[] = {value.vm_variable()}; 03251 03252 const arbb_variable_t inputs[] = {value.vm_variable(), amount.vm_variable()}; 03253 03254 void* debug_data_ptrs[] = {value.get_debug_data_ptr()}; 03255 arbb_op(detail::function::current(), arbb_op_sub, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 03256 03257 return value; 03258 } 03259 03261 03264 03271 template <arbb_scalar_type_t S> 03272 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, scalar<S>& >::type 03273 operator-=(scalar<S>& value, const typename uncaptured<scalar<S> >::type& amount) 03274 { 03275 scalar<S> scalar_amount(amount); 03276 const arbb_variable_t outputs[] = {value.vm_variable()}; 03277 03278 const arbb_variable_t inputs[] = {value.vm_variable(), scalar_amount.vm_variable()}; 03279 03280 void* debug_data_ptrs[] = {value.get_debug_data_ptr()}; 03281 arbb_op(detail::function::current(), arbb_op_sub, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 03282 03283 return value; 03284 } 03285 03287 03290 03297 template <arbb_scalar_type_t S> 03298 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, scalar<S>& >::type 03299 operator-=(typename uncaptured<scalar<S> >::type& value, const scalar<S>& amount) 03300 { 03301 scalar<S> scalar_value(value); 03302 const arbb_variable_t outputs[] = {value.vm_variable()}; 03303 03304 const arbb_variable_t inputs[] = {scalar_value.vm_variable(), amount.vm_variable()}; 03305 03306 void* debug_data_ptrs[] = {value.get_debug_data_ptr()}; 03307 arbb_op(detail::function::current(), arbb_op_sub, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 03308 03309 return value; 03310 } 03311 03313 03314 03317 03325 template <arbb_scalar_type_t S> 03326 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, scalar<S> >::type 03327 operator^(const scalar<S>& value, const scalar<S>& mask) 03328 { 03329 scalar<S> result; 03330 const arbb_variable_t outputs[] = {result.vm_variable()}; 03331 03332 const arbb_variable_t inputs[] = {value.vm_variable(), mask.vm_variable()}; 03333 03334 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 03335 arbb_op(detail::function::current(), arbb_op_bit_xor, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 03336 03337 return result; 03338 } 03339 03341 03344 03352 template <arbb_scalar_type_t S> 03353 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, scalar<S> >::type 03354 operator^(const scalar<S>& value, const typename uncaptured<scalar<S> >::type& mask) 03355 { 03356 scalar<S> scalar_mask(mask); 03357 scalar<S> result; 03358 const arbb_variable_t outputs[] = {result.vm_variable()}; 03359 03360 const arbb_variable_t inputs[] = {value.vm_variable(), scalar_mask.vm_variable()}; 03361 03362 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 03363 arbb_op(detail::function::current(), arbb_op_bit_xor, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 03364 03365 return result; 03366 } 03367 03369 03372 03380 template <arbb_scalar_type_t S> 03381 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, scalar<S> >::type 03382 operator^(const typename uncaptured<scalar<S> >::type& value, const scalar<S>& mask) 03383 { 03384 scalar<S> scalar_value(value); 03385 scalar<S> result; 03386 const arbb_variable_t outputs[] = {result.vm_variable()}; 03387 03388 const arbb_variable_t inputs[] = {scalar_value.vm_variable(), mask.vm_variable()}; 03389 03390 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 03391 arbb_op(detail::function::current(), arbb_op_bit_xor, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 03392 03393 return result; 03394 } 03395 03397 03398 03401 03409 template <arbb_scalar_type_t S> 03410 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, scalar<S>& >::type 03411 operator^=(scalar<S>& value, const scalar<S>& mask) 03412 { 03413 const arbb_variable_t outputs[] = {value.vm_variable()}; 03414 03415 const arbb_variable_t inputs[] = {value.vm_variable(), mask.vm_variable()}; 03416 03417 void* debug_data_ptrs[] = {value.get_debug_data_ptr()}; 03418 arbb_op(detail::function::current(), arbb_op_bit_xor, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 03419 03420 return value; 03421 } 03422 03424 03427 03435 template <arbb_scalar_type_t S> 03436 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, scalar<S>& >::type 03437 operator^=(scalar<S>& value, const typename uncaptured<scalar<S> >::type& mask) 03438 { 03439 scalar<S> scalar_mask(mask); 03440 const arbb_variable_t outputs[] = {value.vm_variable()}; 03441 03442 const arbb_variable_t inputs[] = {value.vm_variable(), scalar_mask.vm_variable()}; 03443 03444 void* debug_data_ptrs[] = {value.get_debug_data_ptr()}; 03445 arbb_op(detail::function::current(), arbb_op_bit_xor, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 03446 03447 return value; 03448 } 03449 03451 03454 03462 template <arbb_scalar_type_t S> 03463 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_int< scalar<S> >::value, scalar<S>& >::type 03464 operator^=(typename uncaptured<scalar<S> >::type& value, const scalar<S>& mask) 03465 { 03466 scalar<S> scalar_value(value); 03467 const arbb_variable_t outputs[] = {value.vm_variable()}; 03468 03469 const arbb_variable_t inputs[] = {scalar_value.vm_variable(), mask.vm_variable()}; 03470 03471 void* debug_data_ptrs[] = {value.get_debug_data_ptr()}; 03472 arbb_op(detail::function::current(), arbb_op_bit_xor, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 03473 03474 return value; 03475 } 03476 03478 03479 03482 03489 template <arbb_scalar_type_t S> 03490 scalar<S> 03491 select(const boolean& condition, const scalar<S>& true_case, const scalar<S>& false_case) 03492 { 03493 scalar<S> result; 03494 const arbb_variable_t outputs[] = {result.vm_variable()}; 03495 03496 const arbb_variable_t inputs[] = {condition.vm_variable(), true_case.vm_variable(), false_case.vm_variable()}; 03497 03498 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 03499 arbb_op(detail::function::current(), arbb_op_select, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 03500 03501 return result; 03502 } 03503 03505 03508 03515 template <arbb_scalar_type_t S> 03516 scalar<S> 03517 select(const typename uncaptured<boolean >::type& condition, const scalar<S>& true_case, const scalar<S>& false_case) 03518 { 03519 boolean scalar_condition(condition); 03520 scalar<S> result; 03521 const arbb_variable_t outputs[] = {result.vm_variable()}; 03522 03523 const arbb_variable_t inputs[] = {scalar_condition.vm_variable(), true_case.vm_variable(), false_case.vm_variable()}; 03524 03525 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 03526 arbb_op(detail::function::current(), arbb_op_select, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 03527 03528 return result; 03529 } 03530 03532 03535 03542 template <arbb_scalar_type_t S> 03543 scalar<S> 03544 select(const boolean& condition, const scalar<S>& true_case, const typename uncaptured<scalar<S> >::type& false_case) 03545 { 03546 scalar<S> scalar_false_case(false_case); 03547 scalar<S> result; 03548 const arbb_variable_t outputs[] = {result.vm_variable()}; 03549 03550 const arbb_variable_t inputs[] = {condition.vm_variable(), true_case.vm_variable(), scalar_false_case.vm_variable()}; 03551 03552 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 03553 arbb_op(detail::function::current(), arbb_op_select, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 03554 03555 return result; 03556 } 03557 03559 03562 03569 template <arbb_scalar_type_t S> 03570 scalar<S> 03571 select(const typename uncaptured<boolean >::type& condition, const scalar<S>& true_case, const typename uncaptured<scalar<S> >::type& false_case) 03572 { 03573 boolean scalar_condition(condition); 03574 scalar<S> scalar_false_case(false_case); 03575 scalar<S> result; 03576 const arbb_variable_t outputs[] = {result.vm_variable()}; 03577 03578 const arbb_variable_t inputs[] = {scalar_condition.vm_variable(), true_case.vm_variable(), scalar_false_case.vm_variable()}; 03579 03580 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 03581 arbb_op(detail::function::current(), arbb_op_select, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 03582 03583 return result; 03584 } 03585 03587 03590 03597 template <arbb_scalar_type_t S> 03598 scalar<S> 03599 select(const boolean& condition, const typename uncaptured<scalar<S> >::type& true_case, const scalar<S>& false_case) 03600 { 03601 scalar<S> scalar_true_case(true_case); 03602 scalar<S> result; 03603 const arbb_variable_t outputs[] = {result.vm_variable()}; 03604 03605 const arbb_variable_t inputs[] = {condition.vm_variable(), scalar_true_case.vm_variable(), false_case.vm_variable()}; 03606 03607 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 03608 arbb_op(detail::function::current(), arbb_op_select, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 03609 03610 return result; 03611 } 03612 03614 03617 03624 template <arbb_scalar_type_t S> 03625 scalar<S> 03626 select(const typename uncaptured<boolean >::type& condition, const typename uncaptured<scalar<S> >::type& true_case, const scalar<S>& false_case) 03627 { 03628 boolean scalar_condition(condition); 03629 scalar<S> scalar_true_case(true_case); 03630 scalar<S> result; 03631 const arbb_variable_t outputs[] = {result.vm_variable()}; 03632 03633 const arbb_variable_t inputs[] = {scalar_condition.vm_variable(), scalar_true_case.vm_variable(), false_case.vm_variable()}; 03634 03635 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 03636 arbb_op(detail::function::current(), arbb_op_select, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 03637 03638 return result; 03639 } 03640 03642 03643 03646 03652 template <arbb_scalar_type_t S> 03653 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, scalar<S>& >::type 03654 operator++(scalar<S>& value) 03655 { 03656 const arbb_variable_t outputs[] = {value.vm_variable()}; 03657 03658 scalar<S> constant_one(1); 03659 const arbb_variable_t inputs[] = {value.vm_variable(), constant_one.vm_variable()}; 03660 03661 void* debug_data_ptrs[] = {value.get_debug_data_ptr()}; 03662 arbb_op(detail::function::current(), arbb_op_add, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 03663 03664 return value; 03665 } 03666 03668 03669 03672 03678 template <arbb_scalar_type_t S> 03679 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, scalar<S> >::type 03680 operator++(scalar<S>& value, int) 03681 { 03682 scalar<S> original_value = value; 03683 03684 const arbb_variable_t outputs[] = {value.vm_variable()}; 03685 03686 scalar<S> constant_one(1); 03687 const arbb_variable_t inputs[] = {value.vm_variable(), constant_one.vm_variable()}; 03688 03689 void* debug_data_ptrs[] = {value.get_debug_data_ptr()}; 03690 arbb_op(detail::function::current(), arbb_op_add, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 03691 03692 return original_value; 03693 } 03694 03696 03697 03700 03706 template <arbb_scalar_type_t S> 03707 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, scalar<S>& >::type 03708 operator--(scalar<S>& value) 03709 { 03710 const arbb_variable_t outputs[] = {value.vm_variable()}; 03711 03712 scalar<S> constant_one(1); 03713 const arbb_variable_t inputs[] = {value.vm_variable(), constant_one.vm_variable()}; 03714 03715 void* debug_data_ptrs[] = {value.get_debug_data_ptr()}; 03716 arbb_op(detail::function::current(), arbb_op_sub, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 03717 03718 return value; 03719 } 03720 03722 03723 03726 03732 template <arbb_scalar_type_t S> 03733 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar_boolean< scalar<S> >::value, scalar<S> >::type 03734 operator--(scalar<S>& value, int) 03735 { 03736 scalar<S> original_value = value; 03737 03738 const arbb_variable_t outputs[] = {value.vm_variable()}; 03739 03740 scalar<S> constant_one(1); 03741 const arbb_variable_t inputs[] = {value.vm_variable(), constant_one.vm_variable()}; 03742 03743 void* debug_data_ptrs[] = {value.get_debug_data_ptr()}; 03744 arbb_op(detail::function::current(), arbb_op_sub, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 03745 03746 return original_value; 03747 } 03748 03750 03751 03754 03761 template <typename U> 03762 typename detail::disable_if<!detail::is_uncaptured_scalar<U>::value, typename captured<U>::type>::type 03763 select(const boolean& condition, const U& true_case, const U& false_case) 03764 { 03765 typename captured<U>::type scalar_true_case(true_case); 03766 typename captured<U>::type scalar_false_case(false_case); 03767 typename captured<U>::type result; 03768 const arbb_variable_t outputs[] = {result.vm_variable()}; 03769 03770 const arbb_variable_t inputs[] = {condition.vm_variable(), scalar_true_case.vm_variable(), scalar_false_case.vm_variable()}; 03771 03772 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 03773 arbb_op(detail::function::current(), arbb_op_select, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 03774 03775 return result; 03776 } 03777 03779 03782 03786 template <typename T, arbb_scalar_type_t S> 03787 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar<T>::value, T >::type 03788 bitwise_cast(const scalar<S>& value) 03789 { 03790 T result; 03791 const arbb_variable_t outputs[] = {result.vm_variable()}; 03792 const arbb_variable_t inputs[] = {value.vm_variable()}; 03793 03794 void* debug_data_ptrs[] = {result.get_debug_data_ptr()}; 03795 arbb_op(detail::function::current(), arbb_op_bitwise_cast, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 03796 03797 return result; 03798 } 03799 03801 03804 03810 template <arbb_scalar_type_t S> 03811 typename ARBB_CPP_NS::detail::disable_if<!detail::is_scalar_unsigned_int< scalar<S> >::value, typename detail::signed_type< scalar<S> >::type>::type 03812 operator-(scalar<S>& value) 03813 { 03814 typename detail::signed_type<scalar<S> >::type result(value); 03815 return -result; 03816 } 03817 03819 03820 03821 } // namespace ARBB_CPP_NS 03822 03823 03824 03825 #endif // ARBB_CPP_SCALAR_FUNCS_HPP 03826 03827
Copyright © 2010, Intel Corporation. All rights reserved.