00001 /**** 00002 ***** Copyright 2010 Intel Corporation All Rights Reserved. 00003 ***** 00004 ***** The source code, information and material contained herein are owned by Intel Corporation or its suppliers ***** 00005 ***** or licensors, and title to such Material remains with Intel Corporation or its suppliers or licensors. ***** 00006 ***** The Material contains proprietary information of Intel or its suppliers and licensors. The Material is ***** 00007 ***** protected by worldwide copyright laws and treaty provisions. No part of the Material may be used, copied, ***** 00008 ***** reproduced, modified, published, uploaded, posted, transmitted, distributed or disclosed in any way without ***** 00009 ***** Intel's prior express written permission. 00010 ***** 00011 ***** No license under any patent, copyright or other intellectual property rights in the material is granted to ***** 00012 ***** or conferred upon you, either expressly, by implication, inducement, estoppel or otherwise. Any license ***** 00013 ***** under such intellectual property rights must be express and approved by Intel in writing. 00014 ****/ 00015 00016 /**** Copyright Ends ****/ 00017 00018 // 00019 // This file was automatically generated and should not be edited directly. 00020 // 00021 00022 #ifndef ARBB_CPP_ELEMENTWISE_DENSE_USERDEFINED_HPP 00023 #define ARBB_CPP_ELEMENTWISE_DENSE_USERDEFINED_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 "scalar_funcs.hpp" 00032 #include "closure.hpp" 00033 #include "call.hpp" 00034 #include "dense.hpp" 00035 #include "map.hpp" 00036 00037 00038 00039 namespace ARBB_CPP_NS { 00040 00041 00042 00044 00045 namespace detail { 00046 00047 template <typename T> 00048 void user_defined_elemental_abs_regular(T& result, const T& value) 00049 { 00050 result = abs(value); 00051 } 00052 00053 template <typename T, std::size_t D> 00054 void user_defined_mapped_abs_regular_dense(dense<T, D>& result, const dense<T, D>& value) 00055 { 00056 ARBB_CPP_NS::map(user_defined_elemental_abs_regular<T>)(result, value); 00057 } 00058 00059 } // namespace detail 00060 00062 00065 00072 template <typename T, std::size_t D> 00073 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 00074 abs(const dense<T, D>& value) 00075 { 00076 dense<T, D> result; 00077 ARBB_CPP_NS::call(detail::user_defined_mapped_abs_regular_dense<T, D>)(result, value); 00078 return result; 00079 } 00080 00082 00083 00085 00086 namespace detail { 00087 00088 template <typename T> 00089 void user_defined_elemental_acos_regular(T& result, const T& value) 00090 { 00091 result = acos(value); 00092 } 00093 00094 template <typename T, std::size_t D> 00095 void user_defined_mapped_acos_regular_dense(dense<T, D>& result, const dense<T, D>& value) 00096 { 00097 ARBB_CPP_NS::map(user_defined_elemental_acos_regular<T>)(result, value); 00098 } 00099 00100 } // namespace detail 00101 00103 00106 00113 template <typename T, std::size_t D> 00114 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 00115 acos(const dense<T, D>& value) 00116 { 00117 dense<T, D> result; 00118 ARBB_CPP_NS::call(detail::user_defined_mapped_acos_regular_dense<T, D>)(result, value); 00119 return result; 00120 } 00121 00123 00124 00126 00127 namespace detail { 00128 00129 template <typename T> 00130 void user_defined_elemental_asin_regular(T& result, const T& value) 00131 { 00132 result = asin(value); 00133 } 00134 00135 template <typename T, std::size_t D> 00136 void user_defined_mapped_asin_regular_dense(dense<T, D>& result, const dense<T, D>& value) 00137 { 00138 ARBB_CPP_NS::map(user_defined_elemental_asin_regular<T>)(result, value); 00139 } 00140 00141 } // namespace detail 00142 00144 00147 00154 template <typename T, std::size_t D> 00155 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 00156 asin(const dense<T, D>& value) 00157 { 00158 dense<T, D> result; 00159 ARBB_CPP_NS::call(detail::user_defined_mapped_asin_regular_dense<T, D>)(result, value); 00160 return result; 00161 } 00162 00164 00165 00167 00168 namespace detail { 00169 00170 template <typename T> 00171 void user_defined_elemental_atan_regular(T& result, const T& value) 00172 { 00173 result = atan(value); 00174 } 00175 00176 template <typename T, std::size_t D> 00177 void user_defined_mapped_atan_regular_dense(dense<T, D>& result, const dense<T, D>& value) 00178 { 00179 ARBB_CPP_NS::map(user_defined_elemental_atan_regular<T>)(result, value); 00180 } 00181 00182 } // namespace detail 00183 00185 00188 00195 template <typename T, std::size_t D> 00196 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 00197 atan(const dense<T, D>& value) 00198 { 00199 dense<T, D> result; 00200 ARBB_CPP_NS::call(detail::user_defined_mapped_atan_regular_dense<T, D>)(result, value); 00201 return result; 00202 } 00203 00205 00206 00208 00209 namespace detail { 00210 00211 template <typename T> 00212 void user_defined_elemental_clamp_regular(T& result, const T& value, const T& minimum, const T& maximum) 00213 { 00214 result = clamp(value, minimum, maximum); 00215 } 00216 00217 template <typename T, std::size_t D> 00218 void user_defined_mapped_clamp_regular_dense_dense_dense(dense<T, D>& result, const dense<T, D>& value, const dense<T, D>& minimum, const dense<T, D>& maximum) 00219 { 00220 ARBB_CPP_NS::map(user_defined_elemental_clamp_regular<T>)(result, value, minimum, maximum); 00221 } 00222 00223 template <typename T, std::size_t D> 00224 void user_defined_mapped_clamp_regular_scalar_dense_dense(dense<T, D>& result, const T& value, const dense<T, D>& minimum, const dense<T, D>& maximum) 00225 { 00226 ARBB_CPP_NS::map(user_defined_elemental_clamp_regular<T>)(result, value, minimum, maximum); 00227 } 00228 00229 template <typename T, std::size_t D> 00230 void user_defined_mapped_clamp_regular_dense_scalar_dense(dense<T, D>& result, const dense<T, D>& value, const T& minimum, const dense<T, D>& maximum) 00231 { 00232 ARBB_CPP_NS::map(user_defined_elemental_clamp_regular<T>)(result, value, minimum, maximum); 00233 } 00234 00235 template <typename T, std::size_t D> 00236 void user_defined_mapped_clamp_regular_scalar_scalar_dense(dense<T, D>& result, const T& value, const T& minimum, const dense<T, D>& maximum) 00237 { 00238 ARBB_CPP_NS::map(user_defined_elemental_clamp_regular<T>)(result, value, minimum, maximum); 00239 } 00240 00241 template <typename T, std::size_t D> 00242 void user_defined_mapped_clamp_regular_dense_dense_scalar(dense<T, D>& result, const dense<T, D>& value, const dense<T, D>& minimum, const T& maximum) 00243 { 00244 ARBB_CPP_NS::map(user_defined_elemental_clamp_regular<T>)(result, value, minimum, maximum); 00245 } 00246 00247 template <typename T, std::size_t D> 00248 void user_defined_mapped_clamp_regular_scalar_dense_scalar(dense<T, D>& result, const T& value, const dense<T, D>& minimum, const T& maximum) 00249 { 00250 ARBB_CPP_NS::map(user_defined_elemental_clamp_regular<T>)(result, value, minimum, maximum); 00251 } 00252 00253 template <typename T, std::size_t D> 00254 void user_defined_mapped_clamp_regular_dense_scalar_scalar(dense<T, D>& result, const dense<T, D>& value, const T& minimum, const T& maximum) 00255 { 00256 ARBB_CPP_NS::map(user_defined_elemental_clamp_regular<T>)(result, value, minimum, maximum); 00257 } 00258 00259 } // namespace detail 00260 00262 00265 00274 template <typename T, std::size_t D> 00275 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 00276 clamp(const dense<T, D>& value, const dense<T, D>& minimum, const dense<T, D>& maximum) 00277 { 00278 dense<T, D> result; 00279 ARBB_CPP_NS::call(detail::user_defined_mapped_clamp_regular_dense_dense_dense<T, D>)(result, value, minimum, maximum); 00280 return result; 00281 } 00282 00284 00293 template <typename T, std::size_t D> 00294 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 00295 clamp(const T& value, const dense<T, D>& minimum, const dense<T, D>& maximum) 00296 { 00297 dense<T, D> result; 00298 ARBB_CPP_NS::call(detail::user_defined_mapped_clamp_regular_scalar_dense_dense<T, D>)(result, value, minimum, maximum); 00299 return result; 00300 } 00301 00303 00312 template <typename T, std::size_t D> 00313 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 00314 clamp(const dense<T, D>& value, const T& minimum, const dense<T, D>& maximum) 00315 { 00316 dense<T, D> result; 00317 ARBB_CPP_NS::call(detail::user_defined_mapped_clamp_regular_dense_scalar_dense<T, D>)(result, value, minimum, maximum); 00318 return result; 00319 } 00320 00322 00331 template <typename T, std::size_t D> 00332 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 00333 clamp(const T& value, const T& minimum, const dense<T, D>& maximum) 00334 { 00335 dense<T, D> result; 00336 ARBB_CPP_NS::call(detail::user_defined_mapped_clamp_regular_scalar_scalar_dense<T, D>)(result, value, minimum, maximum); 00337 return result; 00338 } 00339 00341 00350 template <typename T, std::size_t D> 00351 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 00352 clamp(const dense<T, D>& value, const dense<T, D>& minimum, const T& maximum) 00353 { 00354 dense<T, D> result; 00355 ARBB_CPP_NS::call(detail::user_defined_mapped_clamp_regular_dense_dense_scalar<T, D>)(result, value, minimum, maximum); 00356 return result; 00357 } 00358 00360 00369 template <typename T, std::size_t D> 00370 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 00371 clamp(const T& value, const dense<T, D>& minimum, const T& maximum) 00372 { 00373 dense<T, D> result; 00374 ARBB_CPP_NS::call(detail::user_defined_mapped_clamp_regular_scalar_dense_scalar<T, D>)(result, value, minimum, maximum); 00375 return result; 00376 } 00377 00379 00388 template <typename T, std::size_t D> 00389 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 00390 clamp(const dense<T, D>& value, const T& minimum, const T& maximum) 00391 { 00392 dense<T, D> result; 00393 ARBB_CPP_NS::call(detail::user_defined_mapped_clamp_regular_dense_scalar_scalar<T, D>)(result, value, minimum, maximum); 00394 return result; 00395 } 00396 00398 00399 00401 00402 namespace detail { 00403 00404 template <typename T> 00405 void user_defined_elemental_cos_regular(T& result, const T& value) 00406 { 00407 result = cos(value); 00408 } 00409 00410 template <typename T, std::size_t D> 00411 void user_defined_mapped_cos_regular_dense(dense<T, D>& result, const dense<T, D>& value) 00412 { 00413 ARBB_CPP_NS::map(user_defined_elemental_cos_regular<T>)(result, value); 00414 } 00415 00416 } // namespace detail 00417 00419 00422 00429 template <typename T, std::size_t D> 00430 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 00431 cos(const dense<T, D>& value) 00432 { 00433 dense<T, D> result; 00434 ARBB_CPP_NS::call(detail::user_defined_mapped_cos_regular_dense<T, D>)(result, value); 00435 return result; 00436 } 00437 00439 00440 00442 00443 namespace detail { 00444 00445 template <typename T> 00446 void user_defined_elemental_cosh_regular(T& result, const T& value) 00447 { 00448 result = cosh(value); 00449 } 00450 00451 template <typename T, std::size_t D> 00452 void user_defined_mapped_cosh_regular_dense(dense<T, D>& result, const dense<T, D>& value) 00453 { 00454 ARBB_CPP_NS::map(user_defined_elemental_cosh_regular<T>)(result, value); 00455 } 00456 00457 } // namespace detail 00458 00460 00463 00470 template <typename T, std::size_t D> 00471 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 00472 cosh(const dense<T, D>& value) 00473 { 00474 dense<T, D> result; 00475 ARBB_CPP_NS::call(detail::user_defined_mapped_cosh_regular_dense<T, D>)(result, value); 00476 return result; 00477 } 00478 00480 00481 00483 00484 namespace detail { 00485 00486 template <typename T> 00487 void user_defined_elemental_exp_regular(T& result, const T& value) 00488 { 00489 result = exp(value); 00490 } 00491 00492 template <typename T, std::size_t D> 00493 void user_defined_mapped_exp_regular_dense(dense<T, D>& result, const dense<T, D>& value) 00494 { 00495 ARBB_CPP_NS::map(user_defined_elemental_exp_regular<T>)(result, value); 00496 } 00497 00498 } // namespace detail 00499 00501 00504 00511 template <typename T, std::size_t D> 00512 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 00513 exp(const dense<T, D>& value) 00514 { 00515 dense<T, D> result; 00516 ARBB_CPP_NS::call(detail::user_defined_mapped_exp_regular_dense<T, D>)(result, value); 00517 return result; 00518 } 00519 00521 00522 00524 00525 namespace detail { 00526 00527 template <typename T> 00528 void user_defined_elemental_exp10_regular(T& result, const T& value) 00529 { 00530 result = exp10(value); 00531 } 00532 00533 template <typename T, std::size_t D> 00534 void user_defined_mapped_exp10_regular_dense(dense<T, D>& result, const dense<T, D>& value) 00535 { 00536 ARBB_CPP_NS::map(user_defined_elemental_exp10_regular<T>)(result, value); 00537 } 00538 00539 } // namespace detail 00540 00542 00545 00552 template <typename T, std::size_t D> 00553 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 00554 exp10(const dense<T, D>& value) 00555 { 00556 dense<T, D> result; 00557 ARBB_CPP_NS::call(detail::user_defined_mapped_exp10_regular_dense<T, D>)(result, value); 00558 return result; 00559 } 00560 00562 00563 00565 00566 namespace detail { 00567 00568 template <typename T> 00569 void user_defined_elemental_floor_regular(T& result, const T& value) 00570 { 00571 result = floor(value); 00572 } 00573 00574 template <typename T, std::size_t D> 00575 void user_defined_mapped_floor_regular_dense(dense<T, D>& result, const dense<T, D>& value) 00576 { 00577 ARBB_CPP_NS::map(user_defined_elemental_floor_regular<T>)(result, value); 00578 } 00579 00580 } // namespace detail 00581 00583 00586 00593 template <typename T, std::size_t D> 00594 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 00595 floor(const dense<T, D>& value) 00596 { 00597 dense<T, D> result; 00598 ARBB_CPP_NS::call(detail::user_defined_mapped_floor_regular_dense<T, D>)(result, value); 00599 return result; 00600 } 00601 00603 00604 00606 00607 namespace detail { 00608 00609 template <typename T> 00610 void user_defined_elemental_ceil_regular(T& result, const T& value) 00611 { 00612 result = ceil(value); 00613 } 00614 00615 template <typename T, std::size_t D> 00616 void user_defined_mapped_ceil_regular_dense(dense<T, D>& result, const dense<T, D>& value) 00617 { 00618 ARBB_CPP_NS::map(user_defined_elemental_ceil_regular<T>)(result, value); 00619 } 00620 00621 } // namespace detail 00622 00624 00627 00634 template <typename T, std::size_t D> 00635 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 00636 ceil(const dense<T, D>& value) 00637 { 00638 dense<T, D> result; 00639 ARBB_CPP_NS::call(detail::user_defined_mapped_ceil_regular_dense<T, D>)(result, value); 00640 return result; 00641 } 00642 00644 00645 00647 00648 namespace detail { 00649 00650 template <typename T> 00651 void user_defined_elemental_ln_regular(T& result, const T& value) 00652 { 00653 result = log(value); 00654 } 00655 00656 template <typename T, std::size_t D> 00657 void user_defined_mapped_ln_regular_dense(dense<T, D>& result, const dense<T, D>& value) 00658 { 00659 ARBB_CPP_NS::map(user_defined_elemental_ln_regular<T>)(result, value); 00660 } 00661 00662 } // namespace detail 00663 00665 00668 00675 template <typename T, std::size_t D> 00676 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 00677 log(const dense<T, D>& value) 00678 { 00679 dense<T, D> result; 00680 ARBB_CPP_NS::call(detail::user_defined_mapped_ln_regular_dense<T, D>)(result, value); 00681 return result; 00682 } 00683 00685 00686 00688 00689 namespace detail { 00690 00691 template <typename T> 00692 void user_defined_elemental_log10_regular(T& result, const T& value) 00693 { 00694 result = log10(value); 00695 } 00696 00697 template <typename T, std::size_t D> 00698 void user_defined_mapped_log10_regular_dense(dense<T, D>& result, const dense<T, D>& value) 00699 { 00700 ARBB_CPP_NS::map(user_defined_elemental_log10_regular<T>)(result, value); 00701 } 00702 00703 } // namespace detail 00704 00706 00709 00716 template <typename T, std::size_t D> 00717 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 00718 log10(const dense<T, D>& value) 00719 { 00720 dense<T, D> result; 00721 ARBB_CPP_NS::call(detail::user_defined_mapped_log10_regular_dense<T, D>)(result, value); 00722 return result; 00723 } 00724 00726 00727 00729 00730 namespace detail { 00731 00732 template <typename T> 00733 void user_defined_elemental_rcp_regular(T& result, const T& value) 00734 { 00735 result = rcp(value); 00736 } 00737 00738 template <typename T, std::size_t D> 00739 void user_defined_mapped_rcp_regular_dense(dense<T, D>& result, const dense<T, D>& value) 00740 { 00741 ARBB_CPP_NS::map(user_defined_elemental_rcp_regular<T>)(result, value); 00742 } 00743 00744 } // namespace detail 00745 00747 00750 00757 template <typename T, std::size_t D> 00758 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 00759 rcp(const dense<T, D>& value) 00760 { 00761 dense<T, D> result; 00762 ARBB_CPP_NS::call(detail::user_defined_mapped_rcp_regular_dense<T, D>)(result, value); 00763 return result; 00764 } 00765 00767 00768 00770 00771 namespace detail { 00772 00773 template <typename T> 00774 void user_defined_elemental_round_regular(T& result, const T& value) 00775 { 00776 result = round(value); 00777 } 00778 00779 template <typename T, std::size_t D> 00780 void user_defined_mapped_round_regular_dense(dense<T, D>& result, const dense<T, D>& value) 00781 { 00782 ARBB_CPP_NS::map(user_defined_elemental_round_regular<T>)(result, value); 00783 } 00784 00785 } // namespace detail 00786 00788 00791 00798 template <typename T, std::size_t D> 00799 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 00800 round(const dense<T, D>& value) 00801 { 00802 dense<T, D> result; 00803 ARBB_CPP_NS::call(detail::user_defined_mapped_round_regular_dense<T, D>)(result, value); 00804 return result; 00805 } 00806 00808 00809 00811 00812 namespace detail { 00813 00814 template <typename T> 00815 void user_defined_elemental_rsqrt_regular(T& result, const T& value) 00816 { 00817 result = rsqrt(value); 00818 } 00819 00820 template <typename T, std::size_t D> 00821 void user_defined_mapped_rsqrt_regular_dense(dense<T, D>& result, const dense<T, D>& value) 00822 { 00823 ARBB_CPP_NS::map(user_defined_elemental_rsqrt_regular<T>)(result, value); 00824 } 00825 00826 } // namespace detail 00827 00829 00832 00839 template <typename T, std::size_t D> 00840 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 00841 rsqrt(const dense<T, D>& value) 00842 { 00843 dense<T, D> result; 00844 ARBB_CPP_NS::call(detail::user_defined_mapped_rsqrt_regular_dense<T, D>)(result, value); 00845 return result; 00846 } 00847 00849 00850 00852 00853 namespace detail { 00854 00855 template <typename T> 00856 void user_defined_elemental_sin_regular(T& result, const T& value) 00857 { 00858 result = sin(value); 00859 } 00860 00861 template <typename T, std::size_t D> 00862 void user_defined_mapped_sin_regular_dense(dense<T, D>& result, const dense<T, D>& value) 00863 { 00864 ARBB_CPP_NS::map(user_defined_elemental_sin_regular<T>)(result, value); 00865 } 00866 00867 } // namespace detail 00868 00870 00873 00880 template <typename T, std::size_t D> 00881 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 00882 sin(const dense<T, D>& value) 00883 { 00884 dense<T, D> result; 00885 ARBB_CPP_NS::call(detail::user_defined_mapped_sin_regular_dense<T, D>)(result, value); 00886 return result; 00887 } 00888 00890 00891 00893 00894 namespace detail { 00895 00896 template <typename T> 00897 void user_defined_elemental_sinh_regular(T& result, const T& value) 00898 { 00899 result = sinh(value); 00900 } 00901 00902 template <typename T, std::size_t D> 00903 void user_defined_mapped_sinh_regular_dense(dense<T, D>& result, const dense<T, D>& value) 00904 { 00905 ARBB_CPP_NS::map(user_defined_elemental_sinh_regular<T>)(result, value); 00906 } 00907 00908 } // namespace detail 00909 00911 00914 00921 template <typename T, std::size_t D> 00922 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 00923 sinh(const dense<T, D>& value) 00924 { 00925 dense<T, D> result; 00926 ARBB_CPP_NS::call(detail::user_defined_mapped_sinh_regular_dense<T, D>)(result, value); 00927 return result; 00928 } 00929 00931 00932 00934 00935 namespace detail { 00936 00937 template <typename T> 00938 void user_defined_elemental_sqrt_regular(T& result, const T& value) 00939 { 00940 result = sqrt(value); 00941 } 00942 00943 template <typename T, std::size_t D> 00944 void user_defined_mapped_sqrt_regular_dense(dense<T, D>& result, const dense<T, D>& value) 00945 { 00946 ARBB_CPP_NS::map(user_defined_elemental_sqrt_regular<T>)(result, value); 00947 } 00948 00949 } // namespace detail 00950 00952 00955 00962 template <typename T, std::size_t D> 00963 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 00964 sqrt(const dense<T, D>& value) 00965 { 00966 dense<T, D> result; 00967 ARBB_CPP_NS::call(detail::user_defined_mapped_sqrt_regular_dense<T, D>)(result, value); 00968 return result; 00969 } 00970 00972 00973 00975 00976 namespace detail { 00977 00978 template <typename T> 00979 void user_defined_elemental_tan_regular(T& result, const T& value) 00980 { 00981 result = tan(value); 00982 } 00983 00984 template <typename T, std::size_t D> 00985 void user_defined_mapped_tan_regular_dense(dense<T, D>& result, const dense<T, D>& value) 00986 { 00987 ARBB_CPP_NS::map(user_defined_elemental_tan_regular<T>)(result, value); 00988 } 00989 00990 } // namespace detail 00991 00993 00996 01003 template <typename T, std::size_t D> 01004 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 01005 tan(const dense<T, D>& value) 01006 { 01007 dense<T, D> result; 01008 ARBB_CPP_NS::call(detail::user_defined_mapped_tan_regular_dense<T, D>)(result, value); 01009 return result; 01010 } 01011 01013 01014 01016 01017 namespace detail { 01018 01019 template <typename T> 01020 void user_defined_elemental_tanh_regular(T& result, const T& value) 01021 { 01022 result = tanh(value); 01023 } 01024 01025 template <typename T, std::size_t D> 01026 void user_defined_mapped_tanh_regular_dense(dense<T, D>& result, const dense<T, D>& value) 01027 { 01028 ARBB_CPP_NS::map(user_defined_elemental_tanh_regular<T>)(result, value); 01029 } 01030 01031 } // namespace detail 01032 01034 01037 01044 template <typename T, std::size_t D> 01045 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 01046 tanh(const dense<T, D>& value) 01047 { 01048 dense<T, D> result; 01049 ARBB_CPP_NS::call(detail::user_defined_mapped_tanh_regular_dense<T, D>)(result, value); 01050 return result; 01051 } 01052 01054 01055 01057 01058 namespace detail { 01059 01060 template <typename T> 01061 void user_defined_elemental_log_not_regular(boolean& result, const T& value) 01062 { 01063 result = ! value; 01064 } 01065 01066 template <typename T, std::size_t D> 01067 void user_defined_mapped_log_not_regular_dense(dense<boolean, D>& result, const dense<T, D>& value) 01068 { 01069 ARBB_CPP_NS::map(user_defined_elemental_log_not_regular<T>)(result, value); 01070 } 01071 01072 } // namespace detail 01073 01075 01078 01085 template <typename T, std::size_t D> 01086 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<boolean, D> >::type 01087 operator!(const dense<T, D>& value) 01088 { 01089 dense<boolean, D> result; 01090 ARBB_CPP_NS::call(detail::user_defined_mapped_log_not_regular_dense<T, D>)(result, value); 01091 return result; 01092 } 01093 01095 01096 01098 01099 namespace detail { 01100 01101 template <typename T> 01102 void user_defined_elemental_bit_not_regular(T& result, const T& value) 01103 { 01104 result = ~ value; 01105 } 01106 01107 template <typename T, std::size_t D> 01108 void user_defined_mapped_bit_not_regular_dense(dense<T, D>& result, const dense<T, D>& value) 01109 { 01110 ARBB_CPP_NS::map(user_defined_elemental_bit_not_regular<T>)(result, value); 01111 } 01112 01113 } // namespace detail 01114 01116 01119 01126 template <typename T, std::size_t D> 01127 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 01128 operator~(const dense<T, D>& value) 01129 { 01130 dense<T, D> result; 01131 ARBB_CPP_NS::call(detail::user_defined_mapped_bit_not_regular_dense<T, D>)(result, value); 01132 return result; 01133 } 01134 01136 01137 01139 01140 namespace detail { 01141 01142 template <typename T> 01143 void user_defined_elemental_neg_regular(T& result, const T& value) 01144 { 01145 result = - value; 01146 } 01147 01148 template <typename T, std::size_t D> 01149 void user_defined_mapped_neg_regular_dense(dense<T, D>& result, const dense<T, D>& value) 01150 { 01151 ARBB_CPP_NS::map(user_defined_elemental_neg_regular<T>)(result, value); 01152 } 01153 01154 } // namespace detail 01155 01157 01160 01167 template <typename T, std::size_t D> 01168 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 01169 operator-(const dense<T, D>& value) 01170 { 01171 dense<T, D> result; 01172 ARBB_CPP_NS::call(detail::user_defined_mapped_neg_regular_dense<T, D>)(result, value); 01173 return result; 01174 } 01175 01177 01178 01180 01181 namespace detail { 01182 01183 template <typename T> 01184 void user_defined_elemental_add_regular(T& result, const T& a, const T& b) 01185 { 01186 result = a + b; 01187 } 01188 01189 template <typename T, std::size_t D> 01190 void user_defined_mapped_add_regular_dense_dense(dense<T, D>& result, const dense<T, D>& a, const dense<T, D>& b) 01191 { 01192 ARBB_CPP_NS::map(user_defined_elemental_add_regular<T>)(result, a, b); 01193 } 01194 01195 template <typename T, std::size_t D> 01196 void user_defined_mapped_add_regular_scalar_dense(dense<T, D>& result, const T& a, const dense<T, D>& b) 01197 { 01198 ARBB_CPP_NS::map(user_defined_elemental_add_regular<T>)(result, a, b); 01199 } 01200 01201 template <typename T, std::size_t D> 01202 void user_defined_mapped_add_regular_dense_scalar(dense<T, D>& result, const dense<T, D>& a, const T& b) 01203 { 01204 ARBB_CPP_NS::map(user_defined_elemental_add_regular<T>)(result, a, b); 01205 } 01206 01207 } // namespace detail 01208 01210 01213 01221 template <typename T, std::size_t D> 01222 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 01223 operator+(const dense<T, D>& a, const dense<T, D>& b) 01224 { 01225 dense<T, D> result; 01226 ARBB_CPP_NS::call(detail::user_defined_mapped_add_regular_dense_dense<T, D>)(result, a, b); 01227 return result; 01228 } 01229 01231 01239 template <typename T, std::size_t D> 01240 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 01241 operator+(const T& a, const dense<T, D>& b) 01242 { 01243 dense<T, D> result; 01244 ARBB_CPP_NS::call(detail::user_defined_mapped_add_regular_scalar_dense<T, D>)(result, a, b); 01245 return result; 01246 } 01247 01249 01257 template <typename T, std::size_t D> 01258 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 01259 operator+(const dense<T, D>& a, const T& b) 01260 { 01261 dense<T, D> result; 01262 ARBB_CPP_NS::call(detail::user_defined_mapped_add_regular_dense_scalar<T, D>)(result, a, b); 01263 return result; 01264 } 01265 01267 01268 01270 01271 namespace detail { 01272 01273 template <typename T> 01274 void user_defined_elemental_add_modifying(T& value, const T& increment) 01275 { 01276 value += increment; 01277 } 01278 01279 template <typename T, std::size_t D> 01280 void user_defined_mapped_add_modifying_dense_dense(dense<T, D>& value, const dense<T, D>& increment) 01281 { 01282 ARBB_CPP_NS::map(user_defined_elemental_add_modifying<T>)(value, increment); 01283 } 01284 01285 template <typename T, std::size_t D> 01286 void user_defined_mapped_add_modifying_dense_scalar(dense<T, D>& value, const T& increment) 01287 { 01288 ARBB_CPP_NS::map(user_defined_elemental_add_modifying<T>)(value, increment); 01289 } 01290 01291 } // namespace detail 01292 01294 01297 01305 template <typename T, std::size_t D> 01306 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D>& >::type 01307 operator+=(dense<T, D>& value, const dense<T, D>& increment) 01308 { 01309 ARBB_CPP_NS::call(detail::user_defined_mapped_add_modifying_dense_dense<T, D>)(value, increment); 01310 return value; 01311 } 01312 01314 01322 template <typename T, std::size_t D> 01323 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D>& >::type 01324 operator+=(dense<T, D>& value, const T& increment) 01325 { 01326 ARBB_CPP_NS::call(detail::user_defined_mapped_add_modifying_dense_scalar<T, D>)(value, increment); 01327 return value; 01328 } 01329 01331 01332 01334 01335 namespace detail { 01336 01337 template <typename T> 01338 void user_defined_elemental_bit_and_regular(T& result, const T& value, const T& mask) 01339 { 01340 result = value & mask; 01341 } 01342 01343 template <typename T, std::size_t D> 01344 void user_defined_mapped_bit_and_regular_dense_dense(dense<T, D>& result, const dense<T, D>& value, const dense<T, D>& mask) 01345 { 01346 ARBB_CPP_NS::map(user_defined_elemental_bit_and_regular<T>)(result, value, mask); 01347 } 01348 01349 template <typename T, std::size_t D> 01350 void user_defined_mapped_bit_and_regular_scalar_dense(dense<T, D>& result, const T& value, const dense<T, D>& mask) 01351 { 01352 ARBB_CPP_NS::map(user_defined_elemental_bit_and_regular<T>)(result, value, mask); 01353 } 01354 01355 template <typename T, std::size_t D> 01356 void user_defined_mapped_bit_and_regular_dense_scalar(dense<T, D>& result, const dense<T, D>& value, const T& mask) 01357 { 01358 ARBB_CPP_NS::map(user_defined_elemental_bit_and_regular<T>)(result, value, mask); 01359 } 01360 01361 } // namespace detail 01362 01364 01367 01375 template <typename T, std::size_t D> 01376 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 01377 operator&(const dense<T, D>& value, const dense<T, D>& mask) 01378 { 01379 dense<T, D> result; 01380 ARBB_CPP_NS::call(detail::user_defined_mapped_bit_and_regular_dense_dense<T, D>)(result, value, mask); 01381 return result; 01382 } 01383 01385 01393 template <typename T, std::size_t D> 01394 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 01395 operator&(const T& value, const dense<T, D>& mask) 01396 { 01397 dense<T, D> result; 01398 ARBB_CPP_NS::call(detail::user_defined_mapped_bit_and_regular_scalar_dense<T, D>)(result, value, mask); 01399 return result; 01400 } 01401 01403 01411 template <typename T, std::size_t D> 01412 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 01413 operator&(const dense<T, D>& value, const T& mask) 01414 { 01415 dense<T, D> result; 01416 ARBB_CPP_NS::call(detail::user_defined_mapped_bit_and_regular_dense_scalar<T, D>)(result, value, mask); 01417 return result; 01418 } 01419 01421 01422 01424 01425 namespace detail { 01426 01427 template <typename T> 01428 void user_defined_elemental_bit_and_modifying(T& value, const T& mask) 01429 { 01430 value &= mask; 01431 } 01432 01433 template <typename T, std::size_t D> 01434 void user_defined_mapped_bit_and_modifying_dense_dense(dense<T, D>& value, const dense<T, D>& mask) 01435 { 01436 ARBB_CPP_NS::map(user_defined_elemental_bit_and_modifying<T>)(value, mask); 01437 } 01438 01439 template <typename T, std::size_t D> 01440 void user_defined_mapped_bit_and_modifying_dense_scalar(dense<T, D>& value, const T& mask) 01441 { 01442 ARBB_CPP_NS::map(user_defined_elemental_bit_and_modifying<T>)(value, mask); 01443 } 01444 01445 } // namespace detail 01446 01448 01451 01459 template <typename T, std::size_t D> 01460 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D>& >::type 01461 operator&=(dense<T, D>& value, const dense<T, D>& mask) 01462 { 01463 ARBB_CPP_NS::call(detail::user_defined_mapped_bit_and_modifying_dense_dense<T, D>)(value, mask); 01464 return value; 01465 } 01466 01468 01476 template <typename T, std::size_t D> 01477 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D>& >::type 01478 operator&=(dense<T, D>& value, const T& mask) 01479 { 01480 ARBB_CPP_NS::call(detail::user_defined_mapped_bit_and_modifying_dense_scalar<T, D>)(value, mask); 01481 return value; 01482 } 01483 01485 01486 01488 01489 namespace detail { 01490 01491 template <typename T> 01492 void user_defined_elemental_atan2_regular(T& result, const T& x, const T& y) 01493 { 01494 result = atan2(x, y); 01495 } 01496 01497 template <typename T, std::size_t D> 01498 void user_defined_mapped_atan2_regular_dense_dense(dense<T, D>& result, const dense<T, D>& x, const dense<T, D>& y) 01499 { 01500 ARBB_CPP_NS::map(user_defined_elemental_atan2_regular<T>)(result, x, y); 01501 } 01502 01503 template <typename T, std::size_t D> 01504 void user_defined_mapped_atan2_regular_scalar_dense(dense<T, D>& result, const T& x, const dense<T, D>& y) 01505 { 01506 ARBB_CPP_NS::map(user_defined_elemental_atan2_regular<T>)(result, x, y); 01507 } 01508 01509 template <typename T, std::size_t D> 01510 void user_defined_mapped_atan2_regular_dense_scalar(dense<T, D>& result, const dense<T, D>& x, const T& y) 01511 { 01512 ARBB_CPP_NS::map(user_defined_elemental_atan2_regular<T>)(result, x, y); 01513 } 01514 01515 } // namespace detail 01516 01518 01521 01529 template <typename T, std::size_t D> 01530 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 01531 atan2(const dense<T, D>& x, const dense<T, D>& y) 01532 { 01533 dense<T, D> result; 01534 ARBB_CPP_NS::call(detail::user_defined_mapped_atan2_regular_dense_dense<T, D>)(result, x, y); 01535 return result; 01536 } 01537 01539 01547 template <typename T, std::size_t D> 01548 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 01549 atan2(const T& x, const dense<T, D>& y) 01550 { 01551 dense<T, D> result; 01552 ARBB_CPP_NS::call(detail::user_defined_mapped_atan2_regular_scalar_dense<T, D>)(result, x, y); 01553 return result; 01554 } 01555 01557 01565 template <typename T, std::size_t D> 01566 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 01567 atan2(const dense<T, D>& x, const T& y) 01568 { 01569 dense<T, D> result; 01570 ARBB_CPP_NS::call(detail::user_defined_mapped_atan2_regular_dense_scalar<T, D>)(result, x, y); 01571 return result; 01572 } 01573 01575 01576 01578 01579 namespace detail { 01580 01581 template <typename T> 01582 void user_defined_elemental_compare_regular(isize& result, const T& a, const T& b) 01583 { 01584 result = compare(a, b); 01585 } 01586 01587 template <typename T, std::size_t D> 01588 void user_defined_mapped_compare_regular_dense_dense(dense<isize, D>& result, const dense<T, D>& a, const dense<T, D>& b) 01589 { 01590 ARBB_CPP_NS::map(user_defined_elemental_compare_regular<T>)(result, a, b); 01591 } 01592 01593 template <typename T, std::size_t D> 01594 void user_defined_mapped_compare_regular_scalar_dense(dense<isize, D>& result, const T& a, const dense<T, D>& b) 01595 { 01596 ARBB_CPP_NS::map(user_defined_elemental_compare_regular<T>)(result, a, b); 01597 } 01598 01599 template <typename T, std::size_t D> 01600 void user_defined_mapped_compare_regular_dense_scalar(dense<isize, D>& result, const dense<T, D>& a, const T& b) 01601 { 01602 ARBB_CPP_NS::map(user_defined_elemental_compare_regular<T>)(result, a, b); 01603 } 01604 01605 } // namespace detail 01606 01608 01611 01619 template <typename T, std::size_t D> 01620 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<isize, D> >::type 01621 compare(const dense<T, D>& a, const dense<T, D>& b) 01622 { 01623 dense<isize, D> result; 01624 ARBB_CPP_NS::call(detail::user_defined_mapped_compare_regular_dense_dense<T, D>)(result, a, b); 01625 return result; 01626 } 01627 01629 01637 template <typename T, std::size_t D> 01638 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<isize, D> >::type 01639 compare(const T& a, const dense<T, D>& b) 01640 { 01641 dense<isize, D> result; 01642 ARBB_CPP_NS::call(detail::user_defined_mapped_compare_regular_scalar_dense<T, D>)(result, a, b); 01643 return result; 01644 } 01645 01647 01655 template <typename T, std::size_t D> 01656 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<isize, D> >::type 01657 compare(const dense<T, D>& a, const T& b) 01658 { 01659 dense<isize, D> result; 01660 ARBB_CPP_NS::call(detail::user_defined_mapped_compare_regular_dense_scalar<T, D>)(result, a, b); 01661 return result; 01662 } 01663 01665 01666 01668 01669 namespace detail { 01670 01671 template <typename T> 01672 void user_defined_elemental_div_regular(T& result, const T& numerator, const T& denominator) 01673 { 01674 result = numerator / denominator; 01675 } 01676 01677 template <typename T, std::size_t D> 01678 void user_defined_mapped_div_regular_dense_dense(dense<T, D>& result, const dense<T, D>& numerator, const dense<T, D>& denominator) 01679 { 01680 ARBB_CPP_NS::map(user_defined_elemental_div_regular<T>)(result, numerator, denominator); 01681 } 01682 01683 template <typename T, std::size_t D> 01684 void user_defined_mapped_div_regular_scalar_dense(dense<T, D>& result, const T& numerator, const dense<T, D>& denominator) 01685 { 01686 ARBB_CPP_NS::map(user_defined_elemental_div_regular<T>)(result, numerator, denominator); 01687 } 01688 01689 template <typename T, std::size_t D> 01690 void user_defined_mapped_div_regular_dense_scalar(dense<T, D>& result, const dense<T, D>& numerator, const T& denominator) 01691 { 01692 ARBB_CPP_NS::map(user_defined_elemental_div_regular<T>)(result, numerator, denominator); 01693 } 01694 01695 } // namespace detail 01696 01698 01701 01709 template <typename T, std::size_t D> 01710 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 01711 operator/(const dense<T, D>& numerator, const dense<T, D>& denominator) 01712 { 01713 dense<T, D> result; 01714 ARBB_CPP_NS::call(detail::user_defined_mapped_div_regular_dense_dense<T, D>)(result, numerator, denominator); 01715 return result; 01716 } 01717 01719 01727 template <typename T, std::size_t D> 01728 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 01729 operator/(const T& numerator, const dense<T, D>& denominator) 01730 { 01731 dense<T, D> result; 01732 ARBB_CPP_NS::call(detail::user_defined_mapped_div_regular_scalar_dense<T, D>)(result, numerator, denominator); 01733 return result; 01734 } 01735 01737 01745 template <typename T, std::size_t D> 01746 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 01747 operator/(const dense<T, D>& numerator, const T& denominator) 01748 { 01749 dense<T, D> result; 01750 ARBB_CPP_NS::call(detail::user_defined_mapped_div_regular_dense_scalar<T, D>)(result, numerator, denominator); 01751 return result; 01752 } 01753 01755 01756 01758 01759 namespace detail { 01760 01761 template <typename T> 01762 void user_defined_elemental_div_modifying(T& value, const T& denominator) 01763 { 01764 value /= denominator; 01765 } 01766 01767 template <typename T, std::size_t D> 01768 void user_defined_mapped_div_modifying_dense_dense(dense<T, D>& value, const dense<T, D>& denominator) 01769 { 01770 ARBB_CPP_NS::map(user_defined_elemental_div_modifying<T>)(value, denominator); 01771 } 01772 01773 template <typename T, std::size_t D> 01774 void user_defined_mapped_div_modifying_dense_scalar(dense<T, D>& value, const T& denominator) 01775 { 01776 ARBB_CPP_NS::map(user_defined_elemental_div_modifying<T>)(value, denominator); 01777 } 01778 01779 } // namespace detail 01780 01782 01785 01793 template <typename T, std::size_t D> 01794 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D>& >::type 01795 operator/=(dense<T, D>& value, const dense<T, D>& denominator) 01796 { 01797 ARBB_CPP_NS::call(detail::user_defined_mapped_div_modifying_dense_dense<T, D>)(value, denominator); 01798 return value; 01799 } 01800 01802 01810 template <typename T, std::size_t D> 01811 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D>& >::type 01812 operator/=(dense<T, D>& value, const T& denominator) 01813 { 01814 ARBB_CPP_NS::call(detail::user_defined_mapped_div_modifying_dense_scalar<T, D>)(value, denominator); 01815 return value; 01816 } 01817 01819 01820 01822 01823 namespace detail { 01824 01825 template <typename T> 01826 void user_defined_elemental_div_tan_regular(T& result, const T& x, const T& y) 01827 { 01828 result = div_tan(x, y); 01829 } 01830 01831 template <typename T, std::size_t D> 01832 void user_defined_mapped_div_tan_regular_dense_dense(dense<T, D>& result, const dense<T, D>& x, const dense<T, D>& y) 01833 { 01834 ARBB_CPP_NS::map(user_defined_elemental_div_tan_regular<T>)(result, x, y); 01835 } 01836 01837 template <typename T, std::size_t D> 01838 void user_defined_mapped_div_tan_regular_scalar_dense(dense<T, D>& result, const T& x, const dense<T, D>& y) 01839 { 01840 ARBB_CPP_NS::map(user_defined_elemental_div_tan_regular<T>)(result, x, y); 01841 } 01842 01843 template <typename T, std::size_t D> 01844 void user_defined_mapped_div_tan_regular_dense_scalar(dense<T, D>& result, const dense<T, D>& x, const T& y) 01845 { 01846 ARBB_CPP_NS::map(user_defined_elemental_div_tan_regular<T>)(result, x, y); 01847 } 01848 01849 } // namespace detail 01850 01852 01855 01863 template <typename T, std::size_t D> 01864 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 01865 div_tan(const dense<T, D>& x, const dense<T, D>& y) 01866 { 01867 dense<T, D> result; 01868 ARBB_CPP_NS::call(detail::user_defined_mapped_div_tan_regular_dense_dense<T, D>)(result, x, y); 01869 return result; 01870 } 01871 01873 01881 template <typename T, std::size_t D> 01882 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 01883 div_tan(const T& x, const dense<T, D>& y) 01884 { 01885 dense<T, D> result; 01886 ARBB_CPP_NS::call(detail::user_defined_mapped_div_tan_regular_scalar_dense<T, D>)(result, x, y); 01887 return result; 01888 } 01889 01891 01899 template <typename T, std::size_t D> 01900 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 01901 div_tan(const dense<T, D>& x, const T& y) 01902 { 01903 dense<T, D> result; 01904 ARBB_CPP_NS::call(detail::user_defined_mapped_div_tan_regular_dense_scalar<T, D>)(result, x, y); 01905 return result; 01906 } 01907 01909 01910 01912 01913 namespace detail { 01914 01915 template <typename T> 01916 void user_defined_elemental_equal_regular(boolean& result, const T& a, const T& b) 01917 { 01918 result = a == b; 01919 } 01920 01921 template <typename T, std::size_t D> 01922 void user_defined_mapped_equal_regular_dense_dense(dense<boolean, D>& result, const dense<T, D>& a, const dense<T, D>& b) 01923 { 01924 ARBB_CPP_NS::map(user_defined_elemental_equal_regular<T>)(result, a, b); 01925 } 01926 01927 template <typename T, std::size_t D> 01928 void user_defined_mapped_equal_regular_scalar_dense(dense<boolean, D>& result, const T& a, const dense<T, D>& b) 01929 { 01930 ARBB_CPP_NS::map(user_defined_elemental_equal_regular<T>)(result, a, b); 01931 } 01932 01933 template <typename T, std::size_t D> 01934 void user_defined_mapped_equal_regular_dense_scalar(dense<boolean, D>& result, const dense<T, D>& a, const T& b) 01935 { 01936 ARBB_CPP_NS::map(user_defined_elemental_equal_regular<T>)(result, a, b); 01937 } 01938 01939 } // namespace detail 01940 01942 01945 01953 template <typename T, std::size_t D> 01954 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<boolean, D> >::type 01955 operator==(const dense<T, D>& a, const dense<T, D>& b) 01956 { 01957 dense<boolean, D> result; 01958 ARBB_CPP_NS::call(detail::user_defined_mapped_equal_regular_dense_dense<T, D>)(result, a, b); 01959 return result; 01960 } 01961 01963 01971 template <typename T, std::size_t D> 01972 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<boolean, D> >::type 01973 operator==(const T& a, const dense<T, D>& b) 01974 { 01975 dense<boolean, D> result; 01976 ARBB_CPP_NS::call(detail::user_defined_mapped_equal_regular_scalar_dense<T, D>)(result, a, b); 01977 return result; 01978 } 01979 01981 01989 template <typename T, std::size_t D> 01990 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<boolean, D> >::type 01991 operator==(const dense<T, D>& a, const T& b) 01992 { 01993 dense<boolean, D> result; 01994 ARBB_CPP_NS::call(detail::user_defined_mapped_equal_regular_dense_scalar<T, D>)(result, a, b); 01995 return result; 01996 } 01997 01999 02000 02002 02003 namespace detail { 02004 02005 template <typename T> 02006 void user_defined_elemental_geq_regular(boolean& result, const T& a, const T& b) 02007 { 02008 result = a >= b; 02009 } 02010 02011 template <typename T, std::size_t D> 02012 void user_defined_mapped_geq_regular_dense_dense(dense<boolean, D>& result, const dense<T, D>& a, const dense<T, D>& b) 02013 { 02014 ARBB_CPP_NS::map(user_defined_elemental_geq_regular<T>)(result, a, b); 02015 } 02016 02017 template <typename T, std::size_t D> 02018 void user_defined_mapped_geq_regular_scalar_dense(dense<boolean, D>& result, const T& a, const dense<T, D>& b) 02019 { 02020 ARBB_CPP_NS::map(user_defined_elemental_geq_regular<T>)(result, a, b); 02021 } 02022 02023 template <typename T, std::size_t D> 02024 void user_defined_mapped_geq_regular_dense_scalar(dense<boolean, D>& result, const dense<T, D>& a, const T& b) 02025 { 02026 ARBB_CPP_NS::map(user_defined_elemental_geq_regular<T>)(result, a, b); 02027 } 02028 02029 } // namespace detail 02030 02032 02035 02043 template <typename T, std::size_t D> 02044 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<boolean, D> >::type 02045 operator>=(const dense<T, D>& a, const dense<T, D>& b) 02046 { 02047 dense<boolean, D> result; 02048 ARBB_CPP_NS::call(detail::user_defined_mapped_geq_regular_dense_dense<T, D>)(result, a, b); 02049 return result; 02050 } 02051 02053 02061 template <typename T, std::size_t D> 02062 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<boolean, D> >::type 02063 operator>=(const T& a, const dense<T, D>& b) 02064 { 02065 dense<boolean, D> result; 02066 ARBB_CPP_NS::call(detail::user_defined_mapped_geq_regular_scalar_dense<T, D>)(result, a, b); 02067 return result; 02068 } 02069 02071 02079 template <typename T, std::size_t D> 02080 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<boolean, D> >::type 02081 operator>=(const dense<T, D>& a, const T& b) 02082 { 02083 dense<boolean, D> result; 02084 ARBB_CPP_NS::call(detail::user_defined_mapped_geq_regular_dense_scalar<T, D>)(result, a, b); 02085 return result; 02086 } 02087 02089 02090 02092 02093 namespace detail { 02094 02095 template <typename T> 02096 void user_defined_elemental_greater_regular(boolean& result, const T& a, const T& b) 02097 { 02098 result = a > b; 02099 } 02100 02101 template <typename T, std::size_t D> 02102 void user_defined_mapped_greater_regular_dense_dense(dense<boolean, D>& result, const dense<T, D>& a, const dense<T, D>& b) 02103 { 02104 ARBB_CPP_NS::map(user_defined_elemental_greater_regular<T>)(result, a, b); 02105 } 02106 02107 template <typename T, std::size_t D> 02108 void user_defined_mapped_greater_regular_scalar_dense(dense<boolean, D>& result, const T& a, const dense<T, D>& b) 02109 { 02110 ARBB_CPP_NS::map(user_defined_elemental_greater_regular<T>)(result, a, b); 02111 } 02112 02113 template <typename T, std::size_t D> 02114 void user_defined_mapped_greater_regular_dense_scalar(dense<boolean, D>& result, const dense<T, D>& a, const T& b) 02115 { 02116 ARBB_CPP_NS::map(user_defined_elemental_greater_regular<T>)(result, a, b); 02117 } 02118 02119 } // namespace detail 02120 02122 02125 02133 template <typename T, std::size_t D> 02134 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<boolean, D> >::type 02135 operator>(const dense<T, D>& a, const dense<T, D>& b) 02136 { 02137 dense<boolean, D> result; 02138 ARBB_CPP_NS::call(detail::user_defined_mapped_greater_regular_dense_dense<T, D>)(result, a, b); 02139 return result; 02140 } 02141 02143 02151 template <typename T, std::size_t D> 02152 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<boolean, D> >::type 02153 operator>(const T& a, const dense<T, D>& b) 02154 { 02155 dense<boolean, D> result; 02156 ARBB_CPP_NS::call(detail::user_defined_mapped_greater_regular_scalar_dense<T, D>)(result, a, b); 02157 return result; 02158 } 02159 02161 02169 template <typename T, std::size_t D> 02170 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<boolean, D> >::type 02171 operator>(const dense<T, D>& a, const T& b) 02172 { 02173 dense<boolean, D> result; 02174 ARBB_CPP_NS::call(detail::user_defined_mapped_greater_regular_dense_scalar<T, D>)(result, a, b); 02175 return result; 02176 } 02177 02179 02180 02182 02183 namespace detail { 02184 02185 template <typename T> 02186 void user_defined_elemental_bit_or_regular(T& result, const T& value, const T& mask) 02187 { 02188 result = value | mask; 02189 } 02190 02191 template <typename T, std::size_t D> 02192 void user_defined_mapped_bit_or_regular_dense_dense(dense<T, D>& result, const dense<T, D>& value, const dense<T, D>& mask) 02193 { 02194 ARBB_CPP_NS::map(user_defined_elemental_bit_or_regular<T>)(result, value, mask); 02195 } 02196 02197 template <typename T, std::size_t D> 02198 void user_defined_mapped_bit_or_regular_scalar_dense(dense<T, D>& result, const T& value, const dense<T, D>& mask) 02199 { 02200 ARBB_CPP_NS::map(user_defined_elemental_bit_or_regular<T>)(result, value, mask); 02201 } 02202 02203 template <typename T, std::size_t D> 02204 void user_defined_mapped_bit_or_regular_dense_scalar(dense<T, D>& result, const dense<T, D>& value, const T& mask) 02205 { 02206 ARBB_CPP_NS::map(user_defined_elemental_bit_or_regular<T>)(result, value, mask); 02207 } 02208 02209 } // namespace detail 02210 02212 02215 02223 template <typename T, std::size_t D> 02224 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 02225 operator|(const dense<T, D>& value, const dense<T, D>& mask) 02226 { 02227 dense<T, D> result; 02228 ARBB_CPP_NS::call(detail::user_defined_mapped_bit_or_regular_dense_dense<T, D>)(result, value, mask); 02229 return result; 02230 } 02231 02233 02241 template <typename T, std::size_t D> 02242 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 02243 operator|(const T& value, const dense<T, D>& mask) 02244 { 02245 dense<T, D> result; 02246 ARBB_CPP_NS::call(detail::user_defined_mapped_bit_or_regular_scalar_dense<T, D>)(result, value, mask); 02247 return result; 02248 } 02249 02251 02259 template <typename T, std::size_t D> 02260 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 02261 operator|(const dense<T, D>& value, const T& mask) 02262 { 02263 dense<T, D> result; 02264 ARBB_CPP_NS::call(detail::user_defined_mapped_bit_or_regular_dense_scalar<T, D>)(result, value, mask); 02265 return result; 02266 } 02267 02269 02270 02272 02273 namespace detail { 02274 02275 template <typename T> 02276 void user_defined_elemental_bit_or_modifying(T& value, const T& mask) 02277 { 02278 value |= mask; 02279 } 02280 02281 template <typename T, std::size_t D> 02282 void user_defined_mapped_bit_or_modifying_dense_dense(dense<T, D>& value, const dense<T, D>& mask) 02283 { 02284 ARBB_CPP_NS::map(user_defined_elemental_bit_or_modifying<T>)(value, mask); 02285 } 02286 02287 template <typename T, std::size_t D> 02288 void user_defined_mapped_bit_or_modifying_dense_scalar(dense<T, D>& value, const T& mask) 02289 { 02290 ARBB_CPP_NS::map(user_defined_elemental_bit_or_modifying<T>)(value, mask); 02291 } 02292 02293 } // namespace detail 02294 02296 02299 02307 template <typename T, std::size_t D> 02308 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D>& >::type 02309 operator|=(dense<T, D>& value, const dense<T, D>& mask) 02310 { 02311 ARBB_CPP_NS::call(detail::user_defined_mapped_bit_or_modifying_dense_dense<T, D>)(value, mask); 02312 return value; 02313 } 02314 02316 02324 template <typename T, std::size_t D> 02325 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D>& >::type 02326 operator|=(dense<T, D>& value, const T& mask) 02327 { 02328 ARBB_CPP_NS::call(detail::user_defined_mapped_bit_or_modifying_dense_scalar<T, D>)(value, mask); 02329 return value; 02330 } 02331 02333 02334 02336 02337 namespace detail { 02338 02339 template <typename T> 02340 void user_defined_elemental_leq_regular(boolean& result, const T& a, const T& b) 02341 { 02342 result = a <= b; 02343 } 02344 02345 template <typename T, std::size_t D> 02346 void user_defined_mapped_leq_regular_dense_dense(dense<boolean, D>& result, const dense<T, D>& a, const dense<T, D>& b) 02347 { 02348 ARBB_CPP_NS::map(user_defined_elemental_leq_regular<T>)(result, a, b); 02349 } 02350 02351 template <typename T, std::size_t D> 02352 void user_defined_mapped_leq_regular_scalar_dense(dense<boolean, D>& result, const T& a, const dense<T, D>& b) 02353 { 02354 ARBB_CPP_NS::map(user_defined_elemental_leq_regular<T>)(result, a, b); 02355 } 02356 02357 template <typename T, std::size_t D> 02358 void user_defined_mapped_leq_regular_dense_scalar(dense<boolean, D>& result, const dense<T, D>& a, const T& b) 02359 { 02360 ARBB_CPP_NS::map(user_defined_elemental_leq_regular<T>)(result, a, b); 02361 } 02362 02363 } // namespace detail 02364 02366 02369 02377 template <typename T, std::size_t D> 02378 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<boolean, D> >::type 02379 operator<=(const dense<T, D>& a, const dense<T, D>& b) 02380 { 02381 dense<boolean, D> result; 02382 ARBB_CPP_NS::call(detail::user_defined_mapped_leq_regular_dense_dense<T, D>)(result, a, b); 02383 return result; 02384 } 02385 02387 02395 template <typename T, std::size_t D> 02396 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<boolean, D> >::type 02397 operator<=(const T& a, const dense<T, D>& b) 02398 { 02399 dense<boolean, D> result; 02400 ARBB_CPP_NS::call(detail::user_defined_mapped_leq_regular_scalar_dense<T, D>)(result, a, b); 02401 return result; 02402 } 02403 02405 02413 template <typename T, std::size_t D> 02414 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<boolean, D> >::type 02415 operator<=(const dense<T, D>& a, const T& b) 02416 { 02417 dense<boolean, D> result; 02418 ARBB_CPP_NS::call(detail::user_defined_mapped_leq_regular_dense_scalar<T, D>)(result, a, b); 02419 return result; 02420 } 02421 02423 02424 02426 02427 namespace detail { 02428 02429 template <typename T> 02430 void user_defined_elemental_less_regular(boolean& result, const T& a, const T& b) 02431 { 02432 result = a < b; 02433 } 02434 02435 template <typename T, std::size_t D> 02436 void user_defined_mapped_less_regular_dense_dense(dense<boolean, D>& result, const dense<T, D>& a, const dense<T, D>& b) 02437 { 02438 ARBB_CPP_NS::map(user_defined_elemental_less_regular<T>)(result, a, b); 02439 } 02440 02441 template <typename T, std::size_t D> 02442 void user_defined_mapped_less_regular_scalar_dense(dense<boolean, D>& result, const T& a, const dense<T, D>& b) 02443 { 02444 ARBB_CPP_NS::map(user_defined_elemental_less_regular<T>)(result, a, b); 02445 } 02446 02447 template <typename T, std::size_t D> 02448 void user_defined_mapped_less_regular_dense_scalar(dense<boolean, D>& result, const dense<T, D>& a, const T& b) 02449 { 02450 ARBB_CPP_NS::map(user_defined_elemental_less_regular<T>)(result, a, b); 02451 } 02452 02453 } // namespace detail 02454 02456 02459 02467 template <typename T, std::size_t D> 02468 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<boolean, D> >::type 02469 operator<(const dense<T, D>& a, const dense<T, D>& b) 02470 { 02471 dense<boolean, D> result; 02472 ARBB_CPP_NS::call(detail::user_defined_mapped_less_regular_dense_dense<T, D>)(result, a, b); 02473 return result; 02474 } 02475 02477 02485 template <typename T, std::size_t D> 02486 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<boolean, D> >::type 02487 operator<(const T& a, const dense<T, D>& b) 02488 { 02489 dense<boolean, D> result; 02490 ARBB_CPP_NS::call(detail::user_defined_mapped_less_regular_scalar_dense<T, D>)(result, a, b); 02491 return result; 02492 } 02493 02495 02503 template <typename T, std::size_t D> 02504 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<boolean, D> >::type 02505 operator<(const dense<T, D>& a, const T& b) 02506 { 02507 dense<boolean, D> result; 02508 ARBB_CPP_NS::call(detail::user_defined_mapped_less_regular_dense_scalar<T, D>)(result, a, b); 02509 return result; 02510 } 02511 02513 02514 02516 02517 namespace detail { 02518 02519 template <typename T> 02520 void user_defined_elemental_log_and_regular(boolean& result, const T& a, const T& b) 02521 { 02522 result = a && b; 02523 } 02524 02525 template <typename T, std::size_t D> 02526 void user_defined_mapped_log_and_regular_dense_dense(dense<boolean, D>& result, const dense<T, D>& a, const dense<T, D>& b) 02527 { 02528 ARBB_CPP_NS::map(user_defined_elemental_log_and_regular<T>)(result, a, b); 02529 } 02530 02531 template <typename T, std::size_t D> 02532 void user_defined_mapped_log_and_regular_scalar_dense(dense<boolean, D>& result, const T& a, const dense<T, D>& b) 02533 { 02534 ARBB_CPP_NS::map(user_defined_elemental_log_and_regular<T>)(result, a, b); 02535 } 02536 02537 template <typename T, std::size_t D> 02538 void user_defined_mapped_log_and_regular_dense_scalar(dense<boolean, D>& result, const dense<T, D>& a, const T& b) 02539 { 02540 ARBB_CPP_NS::map(user_defined_elemental_log_and_regular<T>)(result, a, b); 02541 } 02542 02543 } // namespace detail 02544 02546 02549 02557 template <typename T, std::size_t D> 02558 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<boolean, D> >::type 02559 operator&&(const dense<T, D>& a, const dense<T, D>& b) 02560 { 02561 dense<boolean, D> result; 02562 ARBB_CPP_NS::call(detail::user_defined_mapped_log_and_regular_dense_dense<T, D>)(result, a, b); 02563 return result; 02564 } 02565 02567 02575 template <typename T, std::size_t D> 02576 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<boolean, D> >::type 02577 operator&&(const T& a, const dense<T, D>& b) 02578 { 02579 dense<boolean, D> result; 02580 ARBB_CPP_NS::call(detail::user_defined_mapped_log_and_regular_scalar_dense<T, D>)(result, a, b); 02581 return result; 02582 } 02583 02585 02593 template <typename T, std::size_t D> 02594 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<boolean, D> >::type 02595 operator&&(const dense<T, D>& a, const T& b) 02596 { 02597 dense<boolean, D> result; 02598 ARBB_CPP_NS::call(detail::user_defined_mapped_log_and_regular_dense_scalar<T, D>)(result, a, b); 02599 return result; 02600 } 02601 02603 02604 02606 02607 namespace detail { 02608 02609 template <typename T> 02610 void user_defined_elemental_log_or_regular(boolean& result, const T& a, const T& b) 02611 { 02612 result = a || b; 02613 } 02614 02615 template <typename T, std::size_t D> 02616 void user_defined_mapped_log_or_regular_dense_dense(dense<boolean, D>& result, const dense<T, D>& a, const dense<T, D>& b) 02617 { 02618 ARBB_CPP_NS::map(user_defined_elemental_log_or_regular<T>)(result, a, b); 02619 } 02620 02621 template <typename T, std::size_t D> 02622 void user_defined_mapped_log_or_regular_scalar_dense(dense<boolean, D>& result, const T& a, const dense<T, D>& b) 02623 { 02624 ARBB_CPP_NS::map(user_defined_elemental_log_or_regular<T>)(result, a, b); 02625 } 02626 02627 template <typename T, std::size_t D> 02628 void user_defined_mapped_log_or_regular_dense_scalar(dense<boolean, D>& result, const dense<T, D>& a, const T& b) 02629 { 02630 ARBB_CPP_NS::map(user_defined_elemental_log_or_regular<T>)(result, a, b); 02631 } 02632 02633 } // namespace detail 02634 02636 02639 02647 template <typename T, std::size_t D> 02648 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<boolean, D> >::type 02649 operator||(const dense<T, D>& a, const dense<T, D>& b) 02650 { 02651 dense<boolean, D> result; 02652 ARBB_CPP_NS::call(detail::user_defined_mapped_log_or_regular_dense_dense<T, D>)(result, a, b); 02653 return result; 02654 } 02655 02657 02665 template <typename T, std::size_t D> 02666 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<boolean, D> >::type 02667 operator||(const T& a, const dense<T, D>& b) 02668 { 02669 dense<boolean, D> result; 02670 ARBB_CPP_NS::call(detail::user_defined_mapped_log_or_regular_scalar_dense<T, D>)(result, a, b); 02671 return result; 02672 } 02673 02675 02683 template <typename T, std::size_t D> 02684 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<boolean, D> >::type 02685 operator||(const dense<T, D>& a, const T& b) 02686 { 02687 dense<boolean, D> result; 02688 ARBB_CPP_NS::call(detail::user_defined_mapped_log_or_regular_dense_scalar<T, D>)(result, a, b); 02689 return result; 02690 } 02691 02693 02694 02696 02697 namespace detail { 02698 02699 template <typename T> 02700 void user_defined_elemental_lsh_regular(T& result, const T& value, const T& shift_amount) 02701 { 02702 result = value << shift_amount; 02703 } 02704 02705 template <typename T, std::size_t D> 02706 void user_defined_mapped_lsh_regular_dense_dense(dense<T, D>& result, const dense<T, D>& value, const dense<T, D>& shift_amount) 02707 { 02708 ARBB_CPP_NS::map(user_defined_elemental_lsh_regular<T>)(result, value, shift_amount); 02709 } 02710 02711 template <typename T, std::size_t D> 02712 void user_defined_mapped_lsh_regular_scalar_dense(dense<T, D>& result, const T& value, const dense<T, D>& shift_amount) 02713 { 02714 ARBB_CPP_NS::map(user_defined_elemental_lsh_regular<T>)(result, value, shift_amount); 02715 } 02716 02717 template <typename T, std::size_t D> 02718 void user_defined_mapped_lsh_regular_dense_scalar(dense<T, D>& result, const dense<T, D>& value, const T& shift_amount) 02719 { 02720 ARBB_CPP_NS::map(user_defined_elemental_lsh_regular<T>)(result, value, shift_amount); 02721 } 02722 02723 } // namespace detail 02724 02726 02729 02737 template <typename T, std::size_t D> 02738 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 02739 operator<<(const dense<T, D>& value, const dense<T, D>& shift_amount) 02740 { 02741 dense<T, D> result; 02742 ARBB_CPP_NS::call(detail::user_defined_mapped_lsh_regular_dense_dense<T, D>)(result, value, shift_amount); 02743 return result; 02744 } 02745 02747 02755 template <typename T, std::size_t D> 02756 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 02757 operator<<(const T& value, const dense<T, D>& shift_amount) 02758 { 02759 dense<T, D> result; 02760 ARBB_CPP_NS::call(detail::user_defined_mapped_lsh_regular_scalar_dense<T, D>)(result, value, shift_amount); 02761 return result; 02762 } 02763 02765 02773 template <typename T, std::size_t D> 02774 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 02775 operator<<(const dense<T, D>& value, const T& shift_amount) 02776 { 02777 dense<T, D> result; 02778 ARBB_CPP_NS::call(detail::user_defined_mapped_lsh_regular_dense_scalar<T, D>)(result, value, shift_amount); 02779 return result; 02780 } 02781 02783 02784 02786 02787 namespace detail { 02788 02789 template <typename T> 02790 void user_defined_elemental_lsh_modifying(T& value, const T& shift_amount) 02791 { 02792 value <<= shift_amount; 02793 } 02794 02795 template <typename T, std::size_t D> 02796 void user_defined_mapped_lsh_modifying_dense_dense(dense<T, D>& value, const dense<T, D>& shift_amount) 02797 { 02798 ARBB_CPP_NS::map(user_defined_elemental_lsh_modifying<T>)(value, shift_amount); 02799 } 02800 02801 template <typename T, std::size_t D> 02802 void user_defined_mapped_lsh_modifying_dense_scalar(dense<T, D>& value, const T& shift_amount) 02803 { 02804 ARBB_CPP_NS::map(user_defined_elemental_lsh_modifying<T>)(value, shift_amount); 02805 } 02806 02807 } // namespace detail 02808 02810 02813 02821 template <typename T, std::size_t D> 02822 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D>& >::type 02823 operator<<=(dense<T, D>& value, const dense<T, D>& shift_amount) 02824 { 02825 ARBB_CPP_NS::call(detail::user_defined_mapped_lsh_modifying_dense_dense<T, D>)(value, shift_amount); 02826 return value; 02827 } 02828 02830 02838 template <typename T, std::size_t D> 02839 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D>& >::type 02840 operator<<=(dense<T, D>& value, const T& shift_amount) 02841 { 02842 ARBB_CPP_NS::call(detail::user_defined_mapped_lsh_modifying_dense_scalar<T, D>)(value, shift_amount); 02843 return value; 02844 } 02845 02847 02848 02850 02851 namespace detail { 02852 02853 template <typename T> 02854 void user_defined_elemental_max_regular(T& result, const T& a, const T& b) 02855 { 02856 result = max(a, b); 02857 } 02858 02859 template <typename T, std::size_t D> 02860 void user_defined_mapped_max_regular_dense_dense(dense<T, D>& result, const dense<T, D>& a, const dense<T, D>& b) 02861 { 02862 ARBB_CPP_NS::map(user_defined_elemental_max_regular<T>)(result, a, b); 02863 } 02864 02865 template <typename T, std::size_t D> 02866 void user_defined_mapped_max_regular_scalar_dense(dense<T, D>& result, const T& a, const dense<T, D>& b) 02867 { 02868 ARBB_CPP_NS::map(user_defined_elemental_max_regular<T>)(result, a, b); 02869 } 02870 02871 template <typename T, std::size_t D> 02872 void user_defined_mapped_max_regular_dense_scalar(dense<T, D>& result, const dense<T, D>& a, const T& b) 02873 { 02874 ARBB_CPP_NS::map(user_defined_elemental_max_regular<T>)(result, a, b); 02875 } 02876 02877 } // namespace detail 02878 02880 02883 02891 template <typename T, std::size_t D> 02892 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 02893 max(const dense<T, D>& a, const dense<T, D>& b) 02894 { 02895 dense<T, D> result; 02896 ARBB_CPP_NS::call(detail::user_defined_mapped_max_regular_dense_dense<T, D>)(result, a, b); 02897 return result; 02898 } 02899 02901 02909 template <typename T, std::size_t D> 02910 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 02911 max(const T& a, const dense<T, D>& b) 02912 { 02913 dense<T, D> result; 02914 ARBB_CPP_NS::call(detail::user_defined_mapped_max_regular_scalar_dense<T, D>)(result, a, b); 02915 return result; 02916 } 02917 02919 02927 template <typename T, std::size_t D> 02928 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 02929 max(const dense<T, D>& a, const T& b) 02930 { 02931 dense<T, D> result; 02932 ARBB_CPP_NS::call(detail::user_defined_mapped_max_regular_dense_scalar<T, D>)(result, a, b); 02933 return result; 02934 } 02935 02937 02938 02940 02941 namespace detail { 02942 02943 template <typename T> 02944 void user_defined_elemental_min_regular(T& result, const T& a, const T& b) 02945 { 02946 result = min(a, b); 02947 } 02948 02949 template <typename T, std::size_t D> 02950 void user_defined_mapped_min_regular_dense_dense(dense<T, D>& result, const dense<T, D>& a, const dense<T, D>& b) 02951 { 02952 ARBB_CPP_NS::map(user_defined_elemental_min_regular<T>)(result, a, b); 02953 } 02954 02955 template <typename T, std::size_t D> 02956 void user_defined_mapped_min_regular_scalar_dense(dense<T, D>& result, const T& a, const dense<T, D>& b) 02957 { 02958 ARBB_CPP_NS::map(user_defined_elemental_min_regular<T>)(result, a, b); 02959 } 02960 02961 template <typename T, std::size_t D> 02962 void user_defined_mapped_min_regular_dense_scalar(dense<T, D>& result, const dense<T, D>& a, const T& b) 02963 { 02964 ARBB_CPP_NS::map(user_defined_elemental_min_regular<T>)(result, a, b); 02965 } 02966 02967 } // namespace detail 02968 02970 02973 02981 template <typename T, std::size_t D> 02982 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 02983 min(const dense<T, D>& a, const dense<T, D>& b) 02984 { 02985 dense<T, D> result; 02986 ARBB_CPP_NS::call(detail::user_defined_mapped_min_regular_dense_dense<T, D>)(result, a, b); 02987 return result; 02988 } 02989 02991 02999 template <typename T, std::size_t D> 03000 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 03001 min(const T& a, const dense<T, D>& b) 03002 { 03003 dense<T, D> result; 03004 ARBB_CPP_NS::call(detail::user_defined_mapped_min_regular_scalar_dense<T, D>)(result, a, b); 03005 return result; 03006 } 03007 03009 03017 template <typename T, std::size_t D> 03018 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 03019 min(const dense<T, D>& a, const T& b) 03020 { 03021 dense<T, D> result; 03022 ARBB_CPP_NS::call(detail::user_defined_mapped_min_regular_dense_scalar<T, D>)(result, a, b); 03023 return result; 03024 } 03025 03027 03028 03030 03031 namespace detail { 03032 03033 template <typename T> 03034 void user_defined_elemental_mod_regular(T& result, const T& dividend, const T& divisor) 03035 { 03036 result = dividend % divisor; 03037 } 03038 03039 template <typename T, std::size_t D> 03040 void user_defined_mapped_mod_regular_dense_dense(dense<T, D>& result, const dense<T, D>& dividend, const dense<T, D>& divisor) 03041 { 03042 ARBB_CPP_NS::map(user_defined_elemental_mod_regular<T>)(result, dividend, divisor); 03043 } 03044 03045 template <typename T, std::size_t D> 03046 void user_defined_mapped_mod_regular_scalar_dense(dense<T, D>& result, const T& dividend, const dense<T, D>& divisor) 03047 { 03048 ARBB_CPP_NS::map(user_defined_elemental_mod_regular<T>)(result, dividend, divisor); 03049 } 03050 03051 template <typename T, std::size_t D> 03052 void user_defined_mapped_mod_regular_dense_scalar(dense<T, D>& result, const dense<T, D>& dividend, const T& divisor) 03053 { 03054 ARBB_CPP_NS::map(user_defined_elemental_mod_regular<T>)(result, dividend, divisor); 03055 } 03056 03057 } // namespace detail 03058 03060 03063 03071 template <typename T, std::size_t D> 03072 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 03073 operator%(const dense<T, D>& dividend, const dense<T, D>& divisor) 03074 { 03075 dense<T, D> result; 03076 ARBB_CPP_NS::call(detail::user_defined_mapped_mod_regular_dense_dense<T, D>)(result, dividend, divisor); 03077 return result; 03078 } 03079 03081 03089 template <typename T, std::size_t D> 03090 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 03091 operator%(const T& dividend, const dense<T, D>& divisor) 03092 { 03093 dense<T, D> result; 03094 ARBB_CPP_NS::call(detail::user_defined_mapped_mod_regular_scalar_dense<T, D>)(result, dividend, divisor); 03095 return result; 03096 } 03097 03099 03107 template <typename T, std::size_t D> 03108 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 03109 operator%(const dense<T, D>& dividend, const T& divisor) 03110 { 03111 dense<T, D> result; 03112 ARBB_CPP_NS::call(detail::user_defined_mapped_mod_regular_dense_scalar<T, D>)(result, dividend, divisor); 03113 return result; 03114 } 03115 03117 03118 03120 03121 namespace detail { 03122 03123 template <typename T> 03124 void user_defined_elemental_mod_modifying(T& value, const T& divisor) 03125 { 03126 value %= divisor; 03127 } 03128 03129 template <typename T, std::size_t D> 03130 void user_defined_mapped_mod_modifying_dense_dense(dense<T, D>& value, const dense<T, D>& divisor) 03131 { 03132 ARBB_CPP_NS::map(user_defined_elemental_mod_modifying<T>)(value, divisor); 03133 } 03134 03135 template <typename T, std::size_t D> 03136 void user_defined_mapped_mod_modifying_dense_scalar(dense<T, D>& value, const T& divisor) 03137 { 03138 ARBB_CPP_NS::map(user_defined_elemental_mod_modifying<T>)(value, divisor); 03139 } 03140 03141 } // namespace detail 03142 03144 03147 03155 template <typename T, std::size_t D> 03156 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D>& >::type 03157 operator%=(dense<T, D>& value, const dense<T, D>& divisor) 03158 { 03159 ARBB_CPP_NS::call(detail::user_defined_mapped_mod_modifying_dense_dense<T, D>)(value, divisor); 03160 return value; 03161 } 03162 03164 03172 template <typename T, std::size_t D> 03173 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D>& >::type 03174 operator%=(dense<T, D>& value, const T& divisor) 03175 { 03176 ARBB_CPP_NS::call(detail::user_defined_mapped_mod_modifying_dense_scalar<T, D>)(value, divisor); 03177 return value; 03178 } 03179 03181 03182 03184 03185 namespace detail { 03186 03187 template <typename T> 03188 void user_defined_elemental_mul_regular(T& result, const T& a, const T& b) 03189 { 03190 result = a * b; 03191 } 03192 03193 template <typename T, std::size_t D> 03194 void user_defined_mapped_mul_regular_dense_dense(dense<T, D>& result, const dense<T, D>& a, const dense<T, D>& b) 03195 { 03196 ARBB_CPP_NS::map(user_defined_elemental_mul_regular<T>)(result, a, b); 03197 } 03198 03199 template <typename T, std::size_t D> 03200 void user_defined_mapped_mul_regular_scalar_dense(dense<T, D>& result, const T& a, const dense<T, D>& b) 03201 { 03202 ARBB_CPP_NS::map(user_defined_elemental_mul_regular<T>)(result, a, b); 03203 } 03204 03205 template <typename T, std::size_t D> 03206 void user_defined_mapped_mul_regular_dense_scalar(dense<T, D>& result, const dense<T, D>& a, const T& b) 03207 { 03208 ARBB_CPP_NS::map(user_defined_elemental_mul_regular<T>)(result, a, b); 03209 } 03210 03211 } // namespace detail 03212 03214 03217 03225 template <typename T, std::size_t D> 03226 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 03227 operator*(const dense<T, D>& a, const dense<T, D>& b) 03228 { 03229 dense<T, D> result; 03230 ARBB_CPP_NS::call(detail::user_defined_mapped_mul_regular_dense_dense<T, D>)(result, a, b); 03231 return result; 03232 } 03233 03235 03243 template <typename T, std::size_t D> 03244 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 03245 operator*(const T& a, const dense<T, D>& b) 03246 { 03247 dense<T, D> result; 03248 ARBB_CPP_NS::call(detail::user_defined_mapped_mul_regular_scalar_dense<T, D>)(result, a, b); 03249 return result; 03250 } 03251 03253 03261 template <typename T, std::size_t D> 03262 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 03263 operator*(const dense<T, D>& a, const T& b) 03264 { 03265 dense<T, D> result; 03266 ARBB_CPP_NS::call(detail::user_defined_mapped_mul_regular_dense_scalar<T, D>)(result, a, b); 03267 return result; 03268 } 03269 03271 03272 03274 03275 namespace detail { 03276 03277 template <typename T> 03278 void user_defined_elemental_mul_modifying(T& value, const T& multiplicand) 03279 { 03280 value *= multiplicand; 03281 } 03282 03283 template <typename T, std::size_t D> 03284 void user_defined_mapped_mul_modifying_dense_dense(dense<T, D>& value, const dense<T, D>& multiplicand) 03285 { 03286 ARBB_CPP_NS::map(user_defined_elemental_mul_modifying<T>)(value, multiplicand); 03287 } 03288 03289 template <typename T, std::size_t D> 03290 void user_defined_mapped_mul_modifying_dense_scalar(dense<T, D>& value, const T& multiplicand) 03291 { 03292 ARBB_CPP_NS::map(user_defined_elemental_mul_modifying<T>)(value, multiplicand); 03293 } 03294 03295 } // namespace detail 03296 03298 03301 03309 template <typename T, std::size_t D> 03310 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D>& >::type 03311 operator*=(dense<T, D>& value, const dense<T, D>& multiplicand) 03312 { 03313 ARBB_CPP_NS::call(detail::user_defined_mapped_mul_modifying_dense_dense<T, D>)(value, multiplicand); 03314 return value; 03315 } 03316 03318 03326 template <typename T, std::size_t D> 03327 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D>& >::type 03328 operator*=(dense<T, D>& value, const T& multiplicand) 03329 { 03330 ARBB_CPP_NS::call(detail::user_defined_mapped_mul_modifying_dense_scalar<T, D>)(value, multiplicand); 03331 return value; 03332 } 03333 03335 03336 03338 03339 namespace detail { 03340 03341 template <typename T> 03342 void user_defined_elemental_neq_regular(boolean& result, const T& a, const T& b) 03343 { 03344 result = a != b; 03345 } 03346 03347 template <typename T, std::size_t D> 03348 void user_defined_mapped_neq_regular_dense_dense(dense<boolean, D>& result, const dense<T, D>& a, const dense<T, D>& b) 03349 { 03350 ARBB_CPP_NS::map(user_defined_elemental_neq_regular<T>)(result, a, b); 03351 } 03352 03353 template <typename T, std::size_t D> 03354 void user_defined_mapped_neq_regular_scalar_dense(dense<boolean, D>& result, const T& a, const dense<T, D>& b) 03355 { 03356 ARBB_CPP_NS::map(user_defined_elemental_neq_regular<T>)(result, a, b); 03357 } 03358 03359 template <typename T, std::size_t D> 03360 void user_defined_mapped_neq_regular_dense_scalar(dense<boolean, D>& result, const dense<T, D>& a, const T& b) 03361 { 03362 ARBB_CPP_NS::map(user_defined_elemental_neq_regular<T>)(result, a, b); 03363 } 03364 03365 } // namespace detail 03366 03368 03371 03379 template <typename T, std::size_t D> 03380 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<boolean, D> >::type 03381 operator!=(const dense<T, D>& a, const dense<T, D>& b) 03382 { 03383 dense<boolean, D> result; 03384 ARBB_CPP_NS::call(detail::user_defined_mapped_neq_regular_dense_dense<T, D>)(result, a, b); 03385 return result; 03386 } 03387 03389 03397 template <typename T, std::size_t D> 03398 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<boolean, D> >::type 03399 operator!=(const T& a, const dense<T, D>& b) 03400 { 03401 dense<boolean, D> result; 03402 ARBB_CPP_NS::call(detail::user_defined_mapped_neq_regular_scalar_dense<T, D>)(result, a, b); 03403 return result; 03404 } 03405 03407 03415 template <typename T, std::size_t D> 03416 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<boolean, D> >::type 03417 operator!=(const dense<T, D>& a, const T& b) 03418 { 03419 dense<boolean, D> result; 03420 ARBB_CPP_NS::call(detail::user_defined_mapped_neq_regular_dense_scalar<T, D>)(result, a, b); 03421 return result; 03422 } 03423 03425 03426 03428 03429 namespace detail { 03430 03431 template <typename T> 03432 void user_defined_elemental_pow_regular(T& result, const T& base, const T& exponent) 03433 { 03434 result = pow(base, exponent); 03435 } 03436 03437 template <typename T, std::size_t D> 03438 void user_defined_mapped_pow_regular_dense_dense(dense<T, D>& result, const dense<T, D>& base, const dense<T, D>& exponent) 03439 { 03440 ARBB_CPP_NS::map(user_defined_elemental_pow_regular<T>)(result, base, exponent); 03441 } 03442 03443 template <typename T, std::size_t D> 03444 void user_defined_mapped_pow_regular_scalar_dense(dense<T, D>& result, const T& base, const dense<T, D>& exponent) 03445 { 03446 ARBB_CPP_NS::map(user_defined_elemental_pow_regular<T>)(result, base, exponent); 03447 } 03448 03449 template <typename T, std::size_t D> 03450 void user_defined_mapped_pow_regular_dense_scalar(dense<T, D>& result, const dense<T, D>& base, const T& exponent) 03451 { 03452 ARBB_CPP_NS::map(user_defined_elemental_pow_regular<T>)(result, base, exponent); 03453 } 03454 03455 } // namespace detail 03456 03458 03461 03469 template <typename T, std::size_t D> 03470 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 03471 pow(const dense<T, D>& base, const dense<T, D>& exponent) 03472 { 03473 dense<T, D> result; 03474 ARBB_CPP_NS::call(detail::user_defined_mapped_pow_regular_dense_dense<T, D>)(result, base, exponent); 03475 return result; 03476 } 03477 03479 03487 template <typename T, std::size_t D> 03488 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 03489 pow(const T& base, const dense<T, D>& exponent) 03490 { 03491 dense<T, D> result; 03492 ARBB_CPP_NS::call(detail::user_defined_mapped_pow_regular_scalar_dense<T, D>)(result, base, exponent); 03493 return result; 03494 } 03495 03497 03505 template <typename T, std::size_t D> 03506 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 03507 pow(const dense<T, D>& base, const T& exponent) 03508 { 03509 dense<T, D> result; 03510 ARBB_CPP_NS::call(detail::user_defined_mapped_pow_regular_dense_scalar<T, D>)(result, base, exponent); 03511 return result; 03512 } 03513 03515 03516 03518 03519 namespace detail { 03520 03521 template <typename T> 03522 void user_defined_elemental_rsh_regular(T& result, const T& value, const T& shift_amount) 03523 { 03524 result = value >> shift_amount; 03525 } 03526 03527 template <typename T, std::size_t D> 03528 void user_defined_mapped_rsh_regular_dense_dense(dense<T, D>& result, const dense<T, D>& value, const dense<T, D>& shift_amount) 03529 { 03530 ARBB_CPP_NS::map(user_defined_elemental_rsh_regular<T>)(result, value, shift_amount); 03531 } 03532 03533 template <typename T, std::size_t D> 03534 void user_defined_mapped_rsh_regular_scalar_dense(dense<T, D>& result, const T& value, const dense<T, D>& shift_amount) 03535 { 03536 ARBB_CPP_NS::map(user_defined_elemental_rsh_regular<T>)(result, value, shift_amount); 03537 } 03538 03539 template <typename T, std::size_t D> 03540 void user_defined_mapped_rsh_regular_dense_scalar(dense<T, D>& result, const dense<T, D>& value, const T& shift_amount) 03541 { 03542 ARBB_CPP_NS::map(user_defined_elemental_rsh_regular<T>)(result, value, shift_amount); 03543 } 03544 03545 } // namespace detail 03546 03548 03551 03559 template <typename T, std::size_t D> 03560 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 03561 operator>>(const dense<T, D>& value, const dense<T, D>& shift_amount) 03562 { 03563 dense<T, D> result; 03564 ARBB_CPP_NS::call(detail::user_defined_mapped_rsh_regular_dense_dense<T, D>)(result, value, shift_amount); 03565 return result; 03566 } 03567 03569 03577 template <typename T, std::size_t D> 03578 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 03579 operator>>(const T& value, const dense<T, D>& shift_amount) 03580 { 03581 dense<T, D> result; 03582 ARBB_CPP_NS::call(detail::user_defined_mapped_rsh_regular_scalar_dense<T, D>)(result, value, shift_amount); 03583 return result; 03584 } 03585 03587 03595 template <typename T, std::size_t D> 03596 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 03597 operator>>(const dense<T, D>& value, const T& shift_amount) 03598 { 03599 dense<T, D> result; 03600 ARBB_CPP_NS::call(detail::user_defined_mapped_rsh_regular_dense_scalar<T, D>)(result, value, shift_amount); 03601 return result; 03602 } 03603 03605 03606 03608 03609 namespace detail { 03610 03611 template <typename T> 03612 void user_defined_elemental_rsh_modifying(T& value, const T& shift_amount) 03613 { 03614 value >>= shift_amount; 03615 } 03616 03617 template <typename T, std::size_t D> 03618 void user_defined_mapped_rsh_modifying_dense_dense(dense<T, D>& value, const dense<T, D>& shift_amount) 03619 { 03620 ARBB_CPP_NS::map(user_defined_elemental_rsh_modifying<T>)(value, shift_amount); 03621 } 03622 03623 template <typename T, std::size_t D> 03624 void user_defined_mapped_rsh_modifying_dense_scalar(dense<T, D>& value, const T& shift_amount) 03625 { 03626 ARBB_CPP_NS::map(user_defined_elemental_rsh_modifying<T>)(value, shift_amount); 03627 } 03628 03629 } // namespace detail 03630 03632 03635 03643 template <typename T, std::size_t D> 03644 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D>& >::type 03645 operator>>=(dense<T, D>& value, const dense<T, D>& shift_amount) 03646 { 03647 ARBB_CPP_NS::call(detail::user_defined_mapped_rsh_modifying_dense_dense<T, D>)(value, shift_amount); 03648 return value; 03649 } 03650 03652 03660 template <typename T, std::size_t D> 03661 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D>& >::type 03662 operator>>=(dense<T, D>& value, const T& shift_amount) 03663 { 03664 ARBB_CPP_NS::call(detail::user_defined_mapped_rsh_modifying_dense_scalar<T, D>)(value, shift_amount); 03665 return value; 03666 } 03667 03669 03670 03672 03673 namespace detail { 03674 03675 template <typename T> 03676 void user_defined_elemental_sub_regular(T& result, const T& value, const T& amount) 03677 { 03678 result = value - amount; 03679 } 03680 03681 template <typename T, std::size_t D> 03682 void user_defined_mapped_sub_regular_dense_dense(dense<T, D>& result, const dense<T, D>& value, const dense<T, D>& amount) 03683 { 03684 ARBB_CPP_NS::map(user_defined_elemental_sub_regular<T>)(result, value, amount); 03685 } 03686 03687 template <typename T, std::size_t D> 03688 void user_defined_mapped_sub_regular_scalar_dense(dense<T, D>& result, const T& value, const dense<T, D>& amount) 03689 { 03690 ARBB_CPP_NS::map(user_defined_elemental_sub_regular<T>)(result, value, amount); 03691 } 03692 03693 template <typename T, std::size_t D> 03694 void user_defined_mapped_sub_regular_dense_scalar(dense<T, D>& result, const dense<T, D>& value, const T& amount) 03695 { 03696 ARBB_CPP_NS::map(user_defined_elemental_sub_regular<T>)(result, value, amount); 03697 } 03698 03699 } // namespace detail 03700 03702 03705 03713 template <typename T, std::size_t D> 03714 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 03715 operator-(const dense<T, D>& value, const dense<T, D>& amount) 03716 { 03717 dense<T, D> result; 03718 ARBB_CPP_NS::call(detail::user_defined_mapped_sub_regular_dense_dense<T, D>)(result, value, amount); 03719 return result; 03720 } 03721 03723 03731 template <typename T, std::size_t D> 03732 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 03733 operator-(const T& value, const dense<T, D>& amount) 03734 { 03735 dense<T, D> result; 03736 ARBB_CPP_NS::call(detail::user_defined_mapped_sub_regular_scalar_dense<T, D>)(result, value, amount); 03737 return result; 03738 } 03739 03741 03749 template <typename T, std::size_t D> 03750 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 03751 operator-(const dense<T, D>& value, const T& amount) 03752 { 03753 dense<T, D> result; 03754 ARBB_CPP_NS::call(detail::user_defined_mapped_sub_regular_dense_scalar<T, D>)(result, value, amount); 03755 return result; 03756 } 03757 03759 03760 03762 03763 namespace detail { 03764 03765 template <typename T> 03766 void user_defined_elemental_sub_modifying(T& value, const T& amount) 03767 { 03768 value -= amount; 03769 } 03770 03771 template <typename T, std::size_t D> 03772 void user_defined_mapped_sub_modifying_dense_dense(dense<T, D>& value, const dense<T, D>& amount) 03773 { 03774 ARBB_CPP_NS::map(user_defined_elemental_sub_modifying<T>)(value, amount); 03775 } 03776 03777 template <typename T, std::size_t D> 03778 void user_defined_mapped_sub_modifying_dense_scalar(dense<T, D>& value, const T& amount) 03779 { 03780 ARBB_CPP_NS::map(user_defined_elemental_sub_modifying<T>)(value, amount); 03781 } 03782 03783 } // namespace detail 03784 03786 03789 03797 template <typename T, std::size_t D> 03798 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D>& >::type 03799 operator-=(dense<T, D>& value, const dense<T, D>& amount) 03800 { 03801 ARBB_CPP_NS::call(detail::user_defined_mapped_sub_modifying_dense_dense<T, D>)(value, amount); 03802 return value; 03803 } 03804 03806 03814 template <typename T, std::size_t D> 03815 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D>& >::type 03816 operator-=(dense<T, D>& value, const T& amount) 03817 { 03818 ARBB_CPP_NS::call(detail::user_defined_mapped_sub_modifying_dense_scalar<T, D>)(value, amount); 03819 return value; 03820 } 03821 03823 03824 03826 03827 namespace detail { 03828 03829 template <typename T> 03830 void user_defined_elemental_bit_xor_regular(T& result, const T& value, const T& mask) 03831 { 03832 result = value ^ mask; 03833 } 03834 03835 template <typename T, std::size_t D> 03836 void user_defined_mapped_bit_xor_regular_dense_dense(dense<T, D>& result, const dense<T, D>& value, const dense<T, D>& mask) 03837 { 03838 ARBB_CPP_NS::map(user_defined_elemental_bit_xor_regular<T>)(result, value, mask); 03839 } 03840 03841 template <typename T, std::size_t D> 03842 void user_defined_mapped_bit_xor_regular_scalar_dense(dense<T, D>& result, const T& value, const dense<T, D>& mask) 03843 { 03844 ARBB_CPP_NS::map(user_defined_elemental_bit_xor_regular<T>)(result, value, mask); 03845 } 03846 03847 template <typename T, std::size_t D> 03848 void user_defined_mapped_bit_xor_regular_dense_scalar(dense<T, D>& result, const dense<T, D>& value, const T& mask) 03849 { 03850 ARBB_CPP_NS::map(user_defined_elemental_bit_xor_regular<T>)(result, value, mask); 03851 } 03852 03853 } // namespace detail 03854 03856 03859 03867 template <typename T, std::size_t D> 03868 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 03869 operator^(const dense<T, D>& value, const dense<T, D>& mask) 03870 { 03871 dense<T, D> result; 03872 ARBB_CPP_NS::call(detail::user_defined_mapped_bit_xor_regular_dense_dense<T, D>)(result, value, mask); 03873 return result; 03874 } 03875 03877 03885 template <typename T, std::size_t D> 03886 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 03887 operator^(const T& value, const dense<T, D>& mask) 03888 { 03889 dense<T, D> result; 03890 ARBB_CPP_NS::call(detail::user_defined_mapped_bit_xor_regular_scalar_dense<T, D>)(result, value, mask); 03891 return result; 03892 } 03893 03895 03903 template <typename T, std::size_t D> 03904 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 03905 operator^(const dense<T, D>& value, const T& mask) 03906 { 03907 dense<T, D> result; 03908 ARBB_CPP_NS::call(detail::user_defined_mapped_bit_xor_regular_dense_scalar<T, D>)(result, value, mask); 03909 return result; 03910 } 03911 03913 03914 03916 03917 namespace detail { 03918 03919 template <typename T> 03920 void user_defined_elemental_bit_xor_modifying(T& value, const T& mask) 03921 { 03922 value ^= mask; 03923 } 03924 03925 template <typename T, std::size_t D> 03926 void user_defined_mapped_bit_xor_modifying_dense_dense(dense<T, D>& value, const dense<T, D>& mask) 03927 { 03928 ARBB_CPP_NS::map(user_defined_elemental_bit_xor_modifying<T>)(value, mask); 03929 } 03930 03931 template <typename T, std::size_t D> 03932 void user_defined_mapped_bit_xor_modifying_dense_scalar(dense<T, D>& value, const T& mask) 03933 { 03934 ARBB_CPP_NS::map(user_defined_elemental_bit_xor_modifying<T>)(value, mask); 03935 } 03936 03937 } // namespace detail 03938 03940 03943 03951 template <typename T, std::size_t D> 03952 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D>& >::type 03953 operator^=(dense<T, D>& value, const dense<T, D>& mask) 03954 { 03955 ARBB_CPP_NS::call(detail::user_defined_mapped_bit_xor_modifying_dense_dense<T, D>)(value, mask); 03956 return value; 03957 } 03958 03960 03968 template <typename T, std::size_t D> 03969 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D>& >::type 03970 operator^=(dense<T, D>& value, const T& mask) 03971 { 03972 ARBB_CPP_NS::call(detail::user_defined_mapped_bit_xor_modifying_dense_scalar<T, D>)(value, mask); 03973 return value; 03974 } 03975 03977 03978 03980 03981 namespace detail { 03982 03983 template <typename T> 03984 void user_defined_elemental_select_regular(T& result, const boolean& condition, const T& true_case, const T& false_case) 03985 { 03986 result = select(condition, true_case, false_case); 03987 } 03988 03989 template <typename T, std::size_t D> 03990 void user_defined_mapped_select_regular_dense_dense_dense(dense<T, D>& result, const dense<boolean, D>& condition, const dense<T, D>& true_case, const dense<T, D>& false_case) 03991 { 03992 ARBB_CPP_NS::map(user_defined_elemental_select_regular<T>)(result, condition, true_case, false_case); 03993 } 03994 03995 template <typename T, std::size_t D> 03996 void user_defined_mapped_select_regular_scalar_dense_dense(dense<T, D>& result, const boolean& condition, const dense<T, D>& true_case, const dense<T, D>& false_case) 03997 { 03998 ARBB_CPP_NS::map(user_defined_elemental_select_regular<T>)(result, condition, true_case, false_case); 03999 } 04000 04001 template <typename T, std::size_t D> 04002 void user_defined_mapped_select_regular_dense_scalar_dense(dense<T, D>& result, const dense<boolean, D>& condition, const T& true_case, const dense<T, D>& false_case) 04003 { 04004 ARBB_CPP_NS::map(user_defined_elemental_select_regular<T>)(result, condition, true_case, false_case); 04005 } 04006 04007 template <typename T, std::size_t D> 04008 void user_defined_mapped_select_regular_scalar_scalar_dense(dense<T, D>& result, const boolean& condition, const T& true_case, const dense<T, D>& false_case) 04009 { 04010 ARBB_CPP_NS::map(user_defined_elemental_select_regular<T>)(result, condition, true_case, false_case); 04011 } 04012 04013 template <typename T, std::size_t D> 04014 void user_defined_mapped_select_regular_dense_dense_scalar(dense<T, D>& result, const dense<boolean, D>& condition, const dense<T, D>& true_case, const T& false_case) 04015 { 04016 ARBB_CPP_NS::map(user_defined_elemental_select_regular<T>)(result, condition, true_case, false_case); 04017 } 04018 04019 template <typename T, std::size_t D> 04020 void user_defined_mapped_select_regular_scalar_dense_scalar(dense<T, D>& result, const boolean& condition, const dense<T, D>& true_case, const T& false_case) 04021 { 04022 ARBB_CPP_NS::map(user_defined_elemental_select_regular<T>)(result, condition, true_case, false_case); 04023 } 04024 04025 template <typename T, std::size_t D> 04026 void user_defined_mapped_select_regular_dense_scalar_scalar(dense<T, D>& result, const dense<boolean, D>& condition, const T& true_case, const T& false_case) 04027 { 04028 ARBB_CPP_NS::map(user_defined_elemental_select_regular<T>)(result, condition, true_case, false_case); 04029 } 04030 04031 } // namespace detail 04032 04034 04037 04046 template <typename T, std::size_t D> 04047 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 04048 select(const dense<boolean, D>& condition, const dense<T, D>& true_case, const dense<T, D>& false_case) 04049 { 04050 dense<T, D> result; 04051 ARBB_CPP_NS::call(detail::user_defined_mapped_select_regular_dense_dense_dense<T, D>)(result, condition, true_case, false_case); 04052 return result; 04053 } 04054 04056 04065 template <typename T, std::size_t D> 04066 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 04067 select(const boolean& condition, const dense<T, D>& true_case, const dense<T, D>& false_case) 04068 { 04069 dense<T, D> result; 04070 ARBB_CPP_NS::call(detail::user_defined_mapped_select_regular_scalar_dense_dense<T, D>)(result, condition, true_case, false_case); 04071 return result; 04072 } 04073 04075 04084 template <typename T, std::size_t D> 04085 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 04086 select(const dense<boolean, D>& condition, const T& true_case, const dense<T, D>& false_case) 04087 { 04088 dense<T, D> result; 04089 ARBB_CPP_NS::call(detail::user_defined_mapped_select_regular_dense_scalar_dense<T, D>)(result, condition, true_case, false_case); 04090 return result; 04091 } 04092 04094 04103 template <typename T, std::size_t D> 04104 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 04105 select(const boolean& condition, const T& true_case, const dense<T, D>& false_case) 04106 { 04107 dense<T, D> result; 04108 ARBB_CPP_NS::call(detail::user_defined_mapped_select_regular_scalar_scalar_dense<T, D>)(result, condition, true_case, false_case); 04109 return result; 04110 } 04111 04113 04122 template <typename T, std::size_t D> 04123 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 04124 select(const dense<boolean, D>& condition, const dense<T, D>& true_case, const T& false_case) 04125 { 04126 dense<T, D> result; 04127 ARBB_CPP_NS::call(detail::user_defined_mapped_select_regular_dense_dense_scalar<T, D>)(result, condition, true_case, false_case); 04128 return result; 04129 } 04130 04132 04141 template <typename T, std::size_t D> 04142 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 04143 select(const boolean& condition, const dense<T, D>& true_case, const T& false_case) 04144 { 04145 dense<T, D> result; 04146 ARBB_CPP_NS::call(detail::user_defined_mapped_select_regular_scalar_dense_scalar<T, D>)(result, condition, true_case, false_case); 04147 return result; 04148 } 04149 04151 04160 template <typename T, std::size_t D> 04161 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 04162 select(const dense<boolean, D>& condition, const T& true_case, const T& false_case) 04163 { 04164 dense<T, D> result; 04165 ARBB_CPP_NS::call(detail::user_defined_mapped_select_regular_dense_scalar_scalar<T, D>)(result, condition, true_case, false_case); 04166 return result; 04167 } 04168 04170 04171 04173 04174 namespace detail { 04175 04176 template <typename T> 04177 void user_defined_elemental_add_prefix(T& value) 04178 { 04179 ++value; 04180 } 04181 04182 template <typename T, std::size_t D> 04183 void user_defined_mapped_add_prefix_dense(dense<T, D>& value) 04184 { 04185 ARBB_CPP_NS::map(user_defined_elemental_add_prefix<T>)(value); 04186 } 04187 04188 } // namespace detail 04189 04191 04194 04201 template <typename T, std::size_t D> 04202 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D>& >::type 04203 operator++(dense<T, D>& value) 04204 { 04205 ARBB_CPP_NS::call(detail::user_defined_mapped_add_prefix_dense<T, D>)(value); 04206 return value; 04207 } 04208 04210 04211 04213 04214 namespace detail { 04215 04216 template <typename T> 04217 void user_defined_elemental_add_postfix(T& value) 04218 { 04219 value++; 04220 } 04221 04222 template <typename T, std::size_t D> 04223 void user_defined_mapped_add_postfix_dense(dense<T, D>& value) 04224 { 04225 ARBB_CPP_NS::map(user_defined_elemental_add_postfix<T>)(value); 04226 } 04227 04228 } // namespace detail 04229 04231 04234 04241 template <typename T, std::size_t D> 04242 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 04243 operator++(dense<T, D>& value, int) 04244 { 04245 dense<T, D> original_value = value; 04246 ARBB_CPP_NS::call(detail::user_defined_mapped_add_postfix_dense<T, D>)(value); 04247 return original_value; 04248 } 04249 04251 04252 04254 04255 namespace detail { 04256 04257 template <typename T> 04258 void user_defined_elemental_sub_prefix(T& value) 04259 { 04260 --value; 04261 } 04262 04263 template <typename T, std::size_t D> 04264 void user_defined_mapped_sub_prefix_dense(dense<T, D>& value) 04265 { 04266 ARBB_CPP_NS::map(user_defined_elemental_sub_prefix<T>)(value); 04267 } 04268 04269 } // namespace detail 04270 04272 04275 04282 template <typename T, std::size_t D> 04283 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D>& >::type 04284 operator--(dense<T, D>& value) 04285 { 04286 ARBB_CPP_NS::call(detail::user_defined_mapped_sub_prefix_dense<T, D>)(value); 04287 return value; 04288 } 04289 04291 04292 04294 04295 namespace detail { 04296 04297 template <typename T> 04298 void user_defined_elemental_sub_postfix(T& value) 04299 { 04300 value--; 04301 } 04302 04303 template <typename T, std::size_t D> 04304 void user_defined_mapped_sub_postfix_dense(dense<T, D>& value) 04305 { 04306 ARBB_CPP_NS::map(user_defined_elemental_sub_postfix<T>)(value); 04307 } 04308 04309 } // namespace detail 04310 04312 04315 04322 template <typename T, std::size_t D> 04323 typename ARBB_CPP_NS::detail::disable_if<detail::is_scalar< T >::value || detail::is_uncaptured_scalar< T >::value, dense<T, D> >::type 04324 operator--(dense<T, D>& value, int) 04325 { 04326 dense<T, D> original_value = value; 04327 ARBB_CPP_NS::call(detail::user_defined_mapped_sub_postfix_dense<T, D>)(value); 04328 return original_value; 04329 } 04330 04332 04333 04334 04335 04336 } // namespace ARBB_CPP_NS 04337 04338 04339 04340 #endif // ARBB_CPP_ELEMENTWISE_DENSE_USERDEFINED_HPP 04341 04342
Copyright © 2010, Intel Corporation. All rights reserved.