scalar_funcs.hpp

Go to the documentation of this file.
00001 /****
00002 ***** Copyright 2010 Intel Corporation All Rights Reserved.
00003 *****
00004 ***** The source code, information and material contained herein are owned by Intel Corporation or its suppliers  *****
00005 ***** or licensors, and title to such Material remains with Intel Corporation or its suppliers or licensors.      *****
00006 ***** The Material contains proprietary information of Intel or its suppliers and licensors. The Material is      *****
00007 ***** protected by worldwide copyright laws and treaty provisions. No part of the Material may be used, copied,   *****
00008 ***** reproduced, modified, published, uploaded, posted, transmitted, distributed or disclosed in any way without *****
00009 ***** Intel's prior express written permission.
00010 *****
00011 ***** No license under any patent, copyright or other intellectual property rights in the material is granted to  *****
00012 ***** or conferred upon you, either expressly, by implication, inducement, estoppel or otherwise. Any license     *****
00013 ***** under such intellectual property rights must be express and approved by Intel in writing.
00014 ****/
00015 
00016 /**** Copyright Ends ****/
00017 
00018 //
00019 // This file was automatically generated and should not be edited directly.
00020 //
00021 
00022 #ifndef ARBB_CPP_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 

Submit feedback on this help topic

Copyright © 2010, Intel Corporation. All rights reserved.