elementwise_dense_userdefined.hpp

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

Submit feedback on this help topic

Copyright © 2010, Intel Corporation. All rights reserved.