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 #ifndef ARBB_CPP_DENSE_FUNCS_HPP 00019 #define ARBB_CPP_DENSE_FUNCS_HPP 00020 00021 #include "namespace.hpp" 00022 #include "scalar_funcs.hpp" 00023 #include "dense.hpp" 00024 #include "type_traits.hpp" 00025 #include "detail/error_details.hpp" 00026 #include "detail/enable_if.hpp" 00027 #include "detail/function.hpp" 00028 #include "detail/scalar_traits.hpp" 00029 #include "detail/type_traits.hpp" 00030 #include <arbb_vmapi.h> 00031 00032 namespace ARBB_CPP_NS { 00033 00036 00047 template <typename T> 00048 dense<T, 1> 00049 shift(const dense<T, 1>& source, const isize& distance, const T& value) 00050 { 00051 dense<T, 1> result; 00052 typename dense<T, 1>::container_iterator I = result.containers_begin(); 00053 typename dense<T, 1>::container_const_iterator J = source.containers_begin(); 00054 detail::contents_iterator K = detail::contents_begin(value); 00055 for ( ; I != result.containers_end(); ++I, ++J, ++K) { 00056 arbb_variable_t dst[] = { *I }; 00057 arbb_variable_t src[] = { *J, distance.detail_object(), *K }; 00058 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 00059 arbb_op_dynamic(detail::function::current(), arbb_op_shift_constant, 1, dst, 3, src, debug_data_ptrs, detail::throw_on_error_details()); 00060 } 00061 return result; 00062 } 00063 00074 template <typename T> 00075 typename detail::enable_if<detail::is_scalar<T>::value, dense<T, 1> >::type 00076 shift(const dense<T, 1>& source, const isize& distance, const typename uncaptured<T>::type& svalue) 00077 { 00078 const T value = svalue; 00079 00080 return shift(source, distance, value); 00081 } 00082 00093 template <typename T> 00094 dense<T, 1> 00095 shift(const dense<T, 1>& source, const isize& distance) 00096 { 00097 T zero; 00098 00099 return shift(source, distance, zero); 00100 } 00101 00111 template <typename T> 00112 dense<T, 1> 00113 shift_sticky(const dense<T, 1>& source, const isize& distance) 00114 { 00115 dense<T, 1> result; 00116 typename dense<T, 1>::container_iterator I = result.containers_begin(); 00117 typename dense<T, 1>::container_const_iterator J = source.containers_begin(); 00118 for ( ; I != result.containers_end(); ++I, ++J) { 00119 arbb_variable_t dst[] = { *I }; 00120 arbb_variable_t src[] = { *J, distance.detail_object() }; 00121 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 00122 arbb_op_dynamic(detail::function::current(), arbb_op_shift_clamp, 1, dst, 2, src, debug_data_ptrs, detail::throw_on_error_details()); 00123 } 00124 return result; 00125 } 00126 00137 template <typename T> 00138 dense<T, 2> 00139 shift(const dense<T, 2>& source, const isize& ncol, const isize& nrow, const T& value) 00140 { 00141 dense<T, 2> result; 00142 typename dense<T, 2>::container_iterator I = result.containers_begin(); 00143 typename dense<T, 2>::container_const_iterator J = source.containers_begin(); 00144 detail::contents_iterator K = detail::contents_begin(value); 00145 for ( ; I != result.containers_end(); ++I, ++J, ++K) { 00146 arbb_variable_t dst[] = { *I }; 00147 arbb_variable_t src[] = { *J, nrow.detail_object(), ncol.detail_object(), *K }; 00148 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 00149 arbb_op_dynamic(detail::function::current(), arbb_op_shift_constant, 1, dst, 4, src, debug_data_ptrs, detail::throw_on_error_details()); 00150 } 00151 return result; 00152 } 00153 00164 template <typename T> 00165 typename detail::enable_if<detail::is_scalar<T>::value, dense<T, 2> >::type 00166 shift(const dense<T, 2>& source, const isize& ncol, const isize& nrow, const typename uncaptured<T>::type& svalue) 00167 { 00168 const T value = svalue; 00169 00170 return shift(source, ncol, nrow, value); 00171 } 00172 00183 template <typename T> 00184 dense<T, 2> 00185 shift(const dense<T, 2>& source, const isize& ncol, const isize& nrow) 00186 { 00187 T zero; 00188 00189 return shift(source, ncol, nrow, zero); 00190 } 00191 00201 template <typename T> 00202 dense<T, 2> 00203 shift_sticky(const dense<T, 2>& source, const isize& ncol, const isize& nrow) 00204 { 00205 dense<T, 2> result; 00206 typename dense<T, 2>::container_iterator I = result.containers_begin(); 00207 typename dense<T, 2>::container_const_iterator J = source.containers_begin(); 00208 for ( ; I != result.containers_end(); ++I, ++J) { 00209 arbb_variable_t dst[] = { *I }; 00210 arbb_variable_t src[] = { *J, nrow.detail_object(), ncol.detail_object() }; 00211 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 00212 arbb_op_dynamic(detail::function::current(), arbb_op_shift_clamp, 1, dst, 3, src, debug_data_ptrs, detail::throw_on_error_details()); 00213 } 00214 return result; 00215 } 00216 00227 template <typename T> 00228 dense<T, 3> 00229 shift(const dense<T, 3>& source, const isize& ncol, const isize& nrow, const isize& npage, const T& value) 00230 { 00231 dense<T, 3> result; 00232 typename dense<T, 3>::container_iterator I = result.containers_begin(); 00233 typename dense<T, 3>::container_const_iterator J = source.containers_begin(); 00234 detail::contents_iterator K = detail::contents_begin(value); 00235 for ( ; I != result.containers_end(); ++I, ++J, ++K) { 00236 arbb_variable_t dst[] = { *I }; 00237 arbb_variable_t src[] = { *J, npage.detail_object(), nrow.detail_object(), ncol.detail_object(), *K }; 00238 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 00239 arbb_op_dynamic(detail::function::current(), arbb_op_shift_constant, 1, dst, 5, src, debug_data_ptrs, detail::throw_on_error_details()); 00240 } 00241 return result; 00242 } 00243 00254 template <typename T> 00255 typename detail::enable_if<detail::is_scalar<T>::value, dense<T, 3> >::type 00256 shift(const dense<T, 3>& source, const isize& ncol, const isize& nrow, const isize& npage, const typename uncaptured<T>::type& svalue) 00257 { 00258 const T value = svalue; 00259 00260 return shift(source, ncol, nrow, npage, value); 00261 } 00262 00273 template <typename T> 00274 dense<T, 3> 00275 shift(const dense<T, 3>& source, const isize& ncol, const isize& nrow, const isize& npage) 00276 { 00277 T zero; 00278 00279 return shift(source, ncol, nrow, npage, zero); 00280 } 00281 00291 template <typename T> 00292 dense<T, 3> 00293 shift_sticky(const dense<T, 3>& source, const isize& ncol, const isize& nrow, const isize& npage) 00294 { 00295 dense<T, 3> result; 00296 typename dense<T, 3>::container_iterator I = result.containers_begin(); 00297 typename dense<T, 3>::container_const_iterator J = source.containers_begin(); 00298 for ( ; I != result.containers_end(); ++I, ++J) { 00299 arbb_variable_t dst[] = { *I }; 00300 arbb_variable_t src[] = { *J, npage.detail_object(), nrow.detail_object(), ncol.detail_object() }; 00301 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 00302 arbb_op_dynamic(detail::function::current(), arbb_op_shift_clamp, 1, dst, 4, src, debug_data_ptrs, detail::throw_on_error_details()); 00303 } 00304 return result; 00305 } 00306 00308 template <typename T> 00309 dense<T, 2> 00310 shift_row(const dense<T, 2>& source, const isize& distance, const T& value) 00311 { 00312 return shift(source, isize(0), distance, value); 00313 } 00314 00316 template <typename T> 00317 typename detail::enable_if<detail::is_scalar<T>::value, dense<T, 2> >::type 00318 shift_row(const dense<T, 2>& source, const isize& distance, const typename uncaptured<T>::type& svalue) 00319 { 00320 const T value = svalue; 00321 00322 return shift_row(source, distance, value); 00323 } 00324 00326 template <typename T> 00327 dense<T, 2> 00328 shift_row(const dense<T, 2>& source, const isize& distance) 00329 { 00330 T zero; 00331 00332 return shift_row(source, distance, zero); 00333 } 00334 00336 template <typename T> 00337 dense<T, 3> 00338 shift_row(const dense<T, 3>& source, const isize& distance, const T& value) 00339 { 00340 return shift(source, isize(0), distance, isize(0), value); 00341 } 00342 00344 template <typename T> 00345 typename detail::enable_if<detail::is_scalar<T>::value, dense<T, 3> >::type 00346 shift_row(const dense<T, 3>& source, const isize& distance, const typename uncaptured<T>::type& svalue) 00347 { 00348 const T value = svalue; 00349 00350 return shift_row(source, distance, value); 00351 } 00352 00354 template <typename T> 00355 dense<T, 3> 00356 shift_row(const dense<T, 3>& source, const isize& distance) 00357 { 00358 T zero; 00359 00360 return shift_row(source, distance, zero); 00361 } 00362 00364 template <typename T> 00365 dense<T, 2> 00366 shift_row_sticky(const dense<T, 2>& source, const isize& distance) 00367 { 00368 return shift_sticky(source, isize(0), distance); 00369 } 00370 00372 template <typename T> 00373 dense<T, 3> 00374 shift_row_sticky(const dense<T, 3>& source, const isize& distance) 00375 { 00376 return shift_sticky(source, isize(0), distance, isize(0)); 00377 } 00378 00380 template <typename T> 00381 dense<T, 2> 00382 shift_col(const dense<T, 2>& source, const isize& distance, const T& value) 00383 { 00384 return shift(source, distance, isize(0), value); 00385 } 00386 00388 template <typename T> 00389 typename detail::enable_if<detail::is_scalar<T>::value, dense<T, 2> >::type 00390 shift_col(const dense<T, 2>& source, const isize& distance, const typename uncaptured<T>::type& svalue) 00391 { 00392 const T value = svalue; 00393 00394 return shift_col(source, distance, value); 00395 } 00396 00398 template <typename T> 00399 dense<T, 2> 00400 shift_col(const dense<T, 2>& source, const isize& distance) 00401 { 00402 T zero; 00403 00404 return shift_col(source, distance, zero); 00405 } 00406 00408 template <typename T> 00409 dense<T, 3> 00410 shift_col(const dense<T, 3>& source, const isize& distance, const T& value) 00411 { 00412 return shift(source, distance, isize(0), isize(0), value); 00413 } 00414 00416 template <typename T> 00417 typename detail::enable_if<detail::is_scalar<T>::value, dense<T, 3> >::type 00418 shift_col(const dense<T, 3>& source, const isize& distance, const typename uncaptured<T>::type& svalue) 00419 { 00420 const T value = svalue; 00421 00422 return shift_col(source, distance, value); 00423 } 00424 00426 template <typename T> 00427 dense<T, 3> 00428 shift_col(const dense<T, 3>& source, const isize& distance) 00429 { 00430 T zero; 00431 00432 return shift_col(source, distance, zero); 00433 } 00434 00436 template <typename T> 00437 dense<T, 2> 00438 shift_col_sticky(const dense<T, 2>& source, const isize& distance) 00439 { 00440 return shift_sticky(source, distance, isize(0)); 00441 } 00442 00444 template <typename T> 00445 dense<T, 3> 00446 shift_col_sticky(const dense<T, 3>& source, const isize& distance) 00447 { 00448 return shift_sticky(source, distance, isize(0), isize(0)); 00449 } 00450 00452 template <typename T> 00453 dense<T, 3> 00454 shift_page(const dense<T, 3>& source, const isize& distance, const T& value) 00455 { 00456 return shift(source, isize(0), isize(0), distance, value); 00457 } 00458 00460 template <typename T> 00461 typename detail::enable_if<detail::is_scalar<T>::value, dense<T, 3> >::type 00462 shift_page(const dense<T, 3>& source, const isize& distance, const typename uncaptured<T>::type& svalue) 00463 { 00464 const T value = svalue; 00465 00466 return shift_page(source, distance, value); 00467 } 00468 00470 template <typename T> 00471 dense<T, 3> 00472 shift_page(const dense<T, 3>& source, const isize& distance) 00473 { 00474 T zero; 00475 00476 return shift_page(source, distance, zero); 00477 } 00478 00480 template <typename T> 00481 dense<T, 3> 00482 shift_page_sticky(const dense<T, 3>& source, const isize& distance) 00483 { 00484 return shift_sticky(source, isize(0), isize(0), distance); 00485 } 00486 00496 template <typename T> 00497 dense<T, 1> 00498 rotate(const dense<T, 1>& source, const isize& distance) 00499 { 00500 dense<T, 1> result; 00501 typename dense<T, 1>::container_iterator I = result.containers_begin(); 00502 typename dense<T, 1>::container_const_iterator J = source.containers_begin(); 00503 for ( ; I != result.containers_end(); ++I, ++J) { 00504 arbb_variable_t dst[] = { *I }; 00505 arbb_variable_t src[] = { *J, distance.detail_object() }; 00506 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 00507 arbb_op_dynamic(detail::function::current(), arbb_op_rotate, 1, dst, 2, src, debug_data_ptrs, detail::throw_on_error_details()); 00508 } 00509 return result; 00510 } 00511 00521 template <typename T> 00522 dense<T, 2> 00523 rotate(const dense<T, 2>& source, const isize& ncol, const isize& nrow) 00524 { 00525 dense<T, 2> result; 00526 typename dense<T, 1>::container_iterator I = result.containers_begin(); 00527 typename dense<T, 1>::container_const_iterator J = source.containers_begin(); 00528 for ( ; I != result.containers_end(); ++I, ++J) { 00529 arbb_variable_t dst[] = { *I }; 00530 arbb_variable_t src[] = { *J, nrow.detail_object(), ncol.detail_object() }; 00531 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 00532 arbb_op_dynamic(detail::function::current(), arbb_op_rotate, 1, dst, 3, src, debug_data_ptrs, detail::throw_on_error_details()); 00533 } 00534 return result; 00535 } 00536 00546 template <typename T> 00547 dense<T, 3> 00548 rotate(const dense<T, 3>& source, const isize& ncol, const isize& nrow, const isize& npage) 00549 { 00550 dense<T, 3> result; 00551 typename dense<T, 3>::container_iterator I = result.containers_begin(); 00552 typename dense<T, 3>::container_const_iterator J = source.containers_begin(); 00553 for ( ; I != result.containers_end(); ++I, ++J) { 00554 arbb_variable_t dst[] = { *I }; 00555 arbb_variable_t src[] = { *J, npage.detail_object(), nrow.detail_object(), ncol.detail_object() }; 00556 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 00557 arbb_op_dynamic(detail::function::current(), arbb_op_rotate, 1, dst, 4, src, debug_data_ptrs, detail::throw_on_error_details()); 00558 } 00559 return result; 00560 } 00561 00563 template <typename T> 00564 typename detail::disable_if<detail::is_uncaptured_scalar<T>::value, dense<T, 1> >::type 00565 fill(const T& value, const usize& length) 00566 { 00567 dense<T, 1> result; 00568 typename dense<T, 1>::container_iterator I = result.containers_begin(); 00569 detail::contents_iterator J = detail::contents_begin(value); 00570 for ( ; I != result.containers_end(); ++I, ++J) { 00571 arbb_variable_t dst[] = { *I }; 00572 arbb_variable_t src[] = { *J, length.detail_object() }; 00573 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 00574 arbb_op(detail::function::current(), arbb_op_const_vector, dst, src, debug_data_ptrs, detail::throw_on_error_details()); 00575 } 00576 return result; 00577 } 00578 00581 template <typename T> 00582 typename detail::disable_if<detail::is_uncaptured_scalar<T>::value, dense<T, 2> >::type 00583 fill(const T& value, const usize& width, const usize& height) 00584 { 00585 return reshape(fill(value, width * height), width, height); 00586 } 00587 00590 template <typename T> 00591 typename detail::disable_if<detail::is_uncaptured_scalar<T>::value, dense<T, 3> >::type 00592 fill(const T& value, const usize& width, const usize& height, const usize& depth) 00593 { 00594 return reshape(fill(value, width * height * depth), width, height, depth); 00595 } 00596 00598 template <typename T> 00599 typename detail::enable_if<detail::is_uncaptured_scalar<T>::value, dense<typename captured<T>::type, 1> >::type 00600 fill(const T& value, const usize& length) 00601 { 00602 return fill(typename captured<T>::type(value), length); 00603 } 00604 00607 template <typename T> 00608 typename detail::enable_if<detail::is_uncaptured_scalar<T>::value, dense<typename captured<T>::type, 2> >::type 00609 fill(const T& value, const usize& width, const usize& height) 00610 { 00611 return fill(typename captured<T>::type(value), width, height); 00612 } 00613 00616 template <typename T> 00617 typename detail::enable_if<detail::is_uncaptured_scalar<T>::value, dense<typename captured<T>::type, 3> >::type 00618 fill(const T& value, const usize& width, const usize& height, const usize& depth) 00619 { 00620 return fill(typename captured<T>::type(value), width, height, depth); 00621 } 00622 00625 template <typename T> 00626 typename detail::enable_if<detail::is_uncaptured_scalar<T>::value, dense<typename captured<T>::type, 1> >::type 00627 fill(const T& value, const array<usize, 1>& size) 00628 { 00629 return fill(typename captured<T>::type(value), size[0]); 00630 } 00631 00634 template <typename T> 00635 typename detail::enable_if<detail::is_uncaptured_scalar<T>::value, dense<typename captured<T>::type, 2> >::type 00636 fill(const T& value, const array<usize, 2>& size) 00637 { 00638 return fill(typename captured<T>::type(value), size[0], size[1]); 00639 } 00640 00643 template <typename T> 00644 typename detail::enable_if<detail::is_uncaptured_scalar<T>::value, dense<typename captured<T>::type, 3> >::type 00645 fill(const T& value, const array<usize, 3>& size) 00646 { 00647 return fill(typename captured<T>::type(value), size[0], size[1], size[2]); 00648 } 00649 00652 template <typename T> 00653 typename detail::disable_if<detail::is_uncaptured_scalar<T>::value, dense<T, 1> >::type 00654 fill(const T& value, const array<usize, 1>& size) 00655 { 00656 return fill(value, size[0]); 00657 } 00658 00661 template <typename T> 00662 typename detail::disable_if<detail::is_uncaptured_scalar<T>::value, dense<T, 2> >::type 00663 fill(const T& value, const array<usize, 2>& size) 00664 { 00665 return fill(value, size[0], size[1]); 00666 } 00667 00670 template <typename T> 00671 typename detail::disable_if<detail::is_uncaptured_scalar<T>::value, dense<T, 3> >::type 00672 fill(const T& value, const array<usize, 3>& size) 00673 { 00674 return fill(value, size[0], size[1], size[2]); 00675 } 00676 00681 template <typename T> 00682 dense<T, 1> 00683 scatter(const dense<T, 1>& source, const dense<usize, 1>& index, const dense<T, 1>& defaults) 00684 { 00685 dense<T, 1> result; 00686 typename dense<T, 1>::container_iterator I = result.containers_begin(); 00687 typename dense<T, 1>::container_const_iterator J = source.containers_begin(); 00688 typename dense<T, 1>::container_const_iterator K = defaults.containers_begin(); 00689 for ( ; I != result.containers_end(); ++I, ++J, ++K) { 00690 arbb_variable_t dst[] = { *I }; 00691 arbb_variable_t src[] = { *J, *index.containers_begin(), *K }; 00692 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 00693 arbb_op_dynamic(detail::function::current(), arbb_op_scatter, 1, dst, 3, src, debug_data_ptrs, detail::throw_on_error_details()); 00694 } 00695 return result; 00696 } 00697 00701 template <typename T> 00702 dense<T, 1> 00703 scatter(const dense<T, 1>& source, const dense<usize, 1>& index, const usize& sparse_length, const T& value) 00704 { 00705 return scatter(source, index, fill(value, sparse_length)); 00706 } 00707 00711 template <typename T> 00712 typename detail::enable_if<detail::is_scalar<T>::value, dense<T, 1> >::type 00713 scatter(const dense<T, 1>& source, const dense<usize, 1>& index, const usize& sparse_length, const typename uncaptured<T>::type& svalue) 00714 { 00715 const T value = svalue; 00716 00717 return scatter(source, index, sparse_length, value); 00718 } 00719 00723 template <typename T> 00724 dense<T, 1> 00725 scatter(const dense<T, 1>& source, const dense<usize, 1>& index, const usize& sparse_length) 00726 { 00727 T zero; 00728 00729 return scatter(source, index, sparse_length, zero); 00730 } 00731 00736 template <typename T> 00737 dense<T, 2> 00738 scatter(const dense<T, 2>& source, const dense<array<usize, 2>, 2>& index, const dense<T, 2>& defaults) 00739 { 00740 dense<T, 2> result; 00741 typename dense<T, 2>::container_iterator I = result.containers_begin(); 00742 typename dense<T, 2>::container_const_iterator J = source.containers_begin(); 00743 typename dense<T, 2>::container_const_iterator K = defaults.containers_begin(); 00744 dense<array<usize, 2>, 2>::container_const_iterator L = index.containers_begin(); 00745 const detail::container& index0 = *L++; 00746 const detail::container& index1 = *L++; 00747 for ( ; I != result.containers_end(); ++I, ++J, ++K) { 00748 arbb_variable_t dst[] = { *I }; 00749 arbb_variable_t src[] = { *J, index0, index1, *K }; 00750 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 00751 arbb_op_dynamic(detail::function::current(), arbb_op_scatter, 1, dst, 4, src, debug_data_ptrs, detail::throw_on_error_details()); 00752 } 00753 return result; 00754 } 00755 00759 template <typename T> 00760 dense<T, 2> 00761 scatter(const dense<T, 2>& source, const dense<array<usize, 2>, 2>& index, 00762 const usize& ncols, const usize& nrows, 00763 const T& value) 00764 { 00765 return scatter(source, index, fill(value, ncols, nrows)); 00766 } 00767 00771 template <typename T> 00772 typename detail::enable_if<detail::is_scalar<T>::value, dense<T, 2> >::type 00773 scatter(const dense<T, 2>& source, const dense<array<usize, 2>, 2>& index, 00774 const usize& ncols, const usize& nrows, 00775 const typename uncaptured<T>::type& svalue) 00776 { 00777 const T value = svalue; 00778 00779 return scatter(source, index, ncols, nrows, value); 00780 } 00781 00785 template <typename T> 00786 dense<T, 2> 00787 scatter(const dense<T, 2>& source, const dense<array<usize, 2>, 2>& index, 00788 const usize& ncols, const usize& nrows) 00789 { 00790 T zero; 00791 00792 return scatter(source, index, ncols, nrows, zero); 00793 } 00794 00799 template <typename T> 00800 dense<T, 3> 00801 scatter(const dense<T, 3>& source, const dense<array<usize, 3>, 3>& index, const dense<T, 3>& defaults) 00802 { 00803 dense<T, 3> result; 00804 typename dense<T, 3>::container_iterator I = result.containers_begin(); 00805 typename dense<T, 3>::container_const_iterator J = source.containers_begin(); 00806 typename dense<T, 3>::container_const_iterator K = defaults.containers_begin(); 00807 dense<array<usize, 3>, 3>::container_const_iterator L = index.containers_begin(); 00808 const detail::container& index0 = *L++; 00809 const detail::container& index1 = *L++; 00810 const detail::container& index2 = *L++; 00811 for ( ; I != result.containers_end(); ++I, ++J, ++K) { 00812 arbb_variable_t dst[] = { *I }; 00813 arbb_variable_t src[] = { *J, index0, index1, index2, *K }; 00814 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 00815 arbb_op_dynamic(detail::function::current(), arbb_op_scatter, 1, dst, 5, src, debug_data_ptrs, detail::throw_on_error_details()); 00816 } 00817 return result; 00818 } 00819 00824 template <typename T> 00825 dense<T, 3> 00826 scatter(const dense<T, 3>& source, const dense<array<usize, 3>, 3>& index, 00827 const usize& ncols, const usize& nrows, const usize& npages, 00828 const T& value) 00829 { 00830 return scatter(source, index, fill(value, ncols, nrows, npages)); 00831 } 00832 00837 template <typename T> 00838 typename detail::enable_if<detail::is_scalar<T>::value, dense<T, 3> >::type 00839 scatter(const dense<T, 3>& source, const dense<array<usize, 3>, 3>& index, 00840 const usize& ncols, const usize& nrows, const usize& npages, 00841 const typename uncaptured<T>::type& svalue) 00842 { 00843 const T value = svalue; 00844 00845 return scatter(source, index, ncols, nrows, npages, value); 00846 } 00847 00852 template <typename T> 00853 dense<T, 3> 00854 scatter(const dense<T, 3>& source, const dense<array<usize, 3>, 3>& index, 00855 const usize& ncols, const usize& nrows, const usize& npages) 00856 { 00857 T zero; 00858 00859 return scatter(source, index, ncols, nrows, npages, zero); 00860 } 00861 00863 template <typename T> 00864 dense<T, 1> 00865 unpack(const dense<T, 1>& source, const dense<boolean, 1>& mask, const T& value) 00866 { 00867 dense<T, 1> result; 00868 typename dense<T, 1>::container_iterator I = result.containers_begin(); 00869 typename dense<T, 1>::container_const_iterator J = source.containers_begin(); 00870 detail::contents_iterator K = detail::contents_begin(value); 00871 for ( ; I != result.containers_end(); ++I, ++J, ++K) { 00872 arbb_variable_t dst[] = { *I }; 00873 arbb_variable_t src[] = { *J, *mask.containers_begin(), *K }; 00874 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 00875 arbb_op(detail::function::current(), arbb_op_unpack, dst, src, debug_data_ptrs, detail::throw_on_error_details()); 00876 } 00877 return result; 00878 } 00879 00881 template <typename T> 00882 typename detail::enable_if<detail::is_scalar<T>::value, dense<T, 1> >::type 00883 unpack(const dense<T, 1>& source, const dense<boolean, 1>& mask, const typename uncaptured<T>::type& svalue) 00884 { 00885 const T value = svalue; 00886 00887 return unpack(source, mask, value); 00888 } 00889 00891 template <typename T> 00892 dense<T, 1> 00893 unpack(const dense<T, 1>& source, const dense<boolean, 1>& mask) 00894 { 00895 T zero; 00896 00897 return unpack(source, mask, zero); 00898 } 00899 00903 template <typename T> 00904 dense<T, 1> 00905 pack(const dense<T, 1>& source, const dense<boolean, 1>& mask) 00906 { 00907 dense<T, 1> result; 00908 typename dense<T, 1>::container_iterator I = result.containers_begin(); 00909 typename dense<T, 1>::container_const_iterator J = source.containers_begin(); 00910 for ( ; I != result.containers_end(); ++I, ++J) { 00911 arbb_variable_t dst[] = { *I }; 00912 arbb_variable_t src[] = { *J, *mask.containers_begin() }; 00913 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 00914 arbb_op(detail::function::current(), arbb_op_pack, dst, src, debug_data_ptrs, detail::throw_on_error_details()); 00915 } 00916 return result; 00917 } 00918 00923 template <typename T> 00924 dense<T, 1> 00925 repeat(const dense<T, 1>& source, const usize& times, bool collate = true) 00926 { 00927 arbb_opcode_t op = collate ? arbb_op_repeat : arbb_op_distribute; 00928 dense<T, 1> result; 00929 usize zero(0); 00930 typename dense<T, 1>::container_iterator I = result.containers_begin(); 00931 typename dense<T, 1>::container_const_iterator J = source.containers_begin(); 00932 for ( ; I != result.containers_end(); ++I, ++J) { 00933 arbb_variable_t dst[] = { *I }; 00934 arbb_variable_t src[] = { *J, times.detail_object(), zero.detail_object() }; 00935 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 00936 arbb_op(detail::function::current(), op, dst, src, debug_data_ptrs, detail::throw_on_error_details()); 00937 } 00938 return result; 00939 } 00940 00944 template <typename T> 00945 dense<T, 1> 00946 repeat(const dense<T, 1>& source, const dense<usize, 1>& times) 00947 { 00948 dense<T, 1> result; 00949 usize zero(0); 00950 typename dense<T, 1>::container_iterator I = result.containers_begin(); 00951 typename dense<T, 1>::container_const_iterator J = source.containers_begin(); 00952 typename dense<T, 1>::container_const_iterator K = times.containers_begin(); 00953 for ( ; I != result.containers_end(); ++I, ++J) { 00954 arbb_variable_t dst[] = { *I }; 00955 arbb_variable_t src[] = { *J, *K, zero.detail_object() }; 00956 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 00957 arbb_op(detail::function::current(), arbb_op_distribute, dst, src, debug_data_ptrs, detail::throw_on_error_details()); 00958 } 00959 return result; 00960 } 00961 00964 template <typename T> 00965 dense<T, 2> 00966 repeat_row(const dense<T, 1>& source, const usize& nrows) 00967 { 00968 dense<T, 2> result; 00969 typename dense<T, 2>::container_iterator I = result.containers_begin(); 00970 typename dense<T, 1>::container_const_iterator J = source.containers_begin(); 00971 for ( ; I != result.containers_end(); ++I, ++J) { 00972 arbb_variable_t dst[] = { *I }; 00973 arbb_variable_t src[] = { *J, nrows.detail_object() }; 00974 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 00975 arbb_op(detail::function::current(), arbb_op_repeat_row, dst, src, debug_data_ptrs, detail::throw_on_error_details()); 00976 } 00977 return result; 00978 } 00979 00982 template <typename T> 00983 dense<T, 2> 00984 repeat_col(const dense<T, 1>& source, const usize& ncols) 00985 { 00986 dense<T, 2> result; 00987 typename dense<T, 2>::container_iterator I = result.containers_begin(); 00988 typename dense<T, 1>::container_const_iterator J = source.containers_begin(); 00989 for ( ; I != result.containers_end(); ++I, ++J) { 00990 arbb_variable_t dst[] = { *I }; 00991 arbb_variable_t src[] = { *J, ncols.detail_object() }; 00992 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 00993 arbb_op(detail::function::current(), arbb_op_repeat_col, dst, src, debug_data_ptrs, detail::throw_on_error_details()); 00994 } 00995 return result; 00996 } 00997 01000 template <typename T> 01001 dense<T, 3> 01002 repeat_page(const dense<T, 2>& source, const usize& npages) 01003 { 01004 dense<T, 3> result; 01005 typename dense<T, 3>::container_iterator I = result.containers_begin(); 01006 typename dense<T, 3>::container_const_iterator J = source.containers_begin(); 01007 for ( ; I != result.containers_end(); ++I, ++J) { 01008 arbb_variable_t dst[] = { *I }; 01009 arbb_variable_t src[] = { *J, npages.detail_object() }; 01010 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 01011 arbb_op(detail::function::current(), arbb_op_repeat_page, dst, src, debug_data_ptrs, detail::throw_on_error_details()); 01012 } 01013 return result; 01014 } 01015 01018 template <typename T> 01019 dense<T, 1> 01020 shuffle(const dense<T, 1>& source1, const dense<T, 1>& source2, const usize& grain) 01021 { 01022 dense<T, 1> result; 01023 usize zero(0); 01024 typename dense<T, 1>::container_iterator I = result.containers_begin(); 01025 typename dense<T, 1>::container_const_iterator J = source1.containers_begin(); 01026 typename dense<T, 1>::container_const_iterator K = source2.containers_begin(); 01027 for ( ; I != result.containers_end(); ++I, ++J, ++K) { 01028 arbb_variable_t dst[] = { *I }; 01029 arbb_variable_t src[] = { *J, *K, grain.detail_object(), zero.detail_object() }; 01030 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 01031 arbb_op(detail::function::current(), arbb_op_shuffle, dst, src, debug_data_ptrs, detail::throw_on_error_details()); 01032 } 01033 return result; 01034 } 01035 01039 template <typename T> 01040 dense<T, 1> 01041 unshuffle(const dense<T, 1>& source, const usize& grain) 01042 { 01043 dense<T, 1> result; 01044 usize zero(0); 01045 typename dense<T, 1>::container_iterator I = result.containers_begin(); 01046 typename dense<T, 1>::container_const_iterator J = source.containers_begin(); 01047 for ( ; I != result.containers_end(); ++I, ++J) { 01048 arbb_variable_t dst[] = { *I }; 01049 arbb_variable_t src[] = { *J, grain.detail_object(), zero.detail_object() }; 01050 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 01051 arbb_op(detail::function::current(), arbb_op_unshuffle, dst, src, debug_data_ptrs, detail::throw_on_error_details()); 01052 } 01053 return result; 01054 } 01055 01058 template <typename T> 01059 dense<T, 1> 01060 reverse(const dense<T, 1>& source) 01061 { 01062 dense<T, 1> result; 01063 typename dense<T, 1>::container_iterator I = result.containers_begin(); 01064 typename dense<T, 1>::container_const_iterator J = source.containers_begin(); 01065 for ( ; I != result.containers_end(); ++I, ++J) { 01066 arbb_variable_t dst[] = { *I }; 01067 arbb_variable_t src[] = { *J }; 01068 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 01069 arbb_op(detail::function::current(), arbb_op_reverse, dst, src, debug_data_ptrs, detail::throw_on_error_details()); 01070 } 01071 return result; 01072 } 01073 01077 template <typename T> 01078 dense<T, 1> 01079 gather(const dense<T, 1>& source, const dense<usize, 1>& index, const T& value) 01080 { 01081 dense<T, 1> result; 01082 typename dense<T, 1>::container_iterator I = result.containers_begin(); 01083 typename dense<T, 1>::container_const_iterator J = source.containers_begin(); 01084 detail::contents_iterator K = detail::contents_begin(value); 01085 const detail::container& index0 = *index.containers_begin(); 01086 for ( ; I != result.containers_end(); ++I, ++J, ++K) { 01087 arbb_variable_t dst[] = { *I }; 01088 arbb_variable_t src[] = { *J, index0, *K }; 01089 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 01090 arbb_op_dynamic(detail::function::current(), arbb_op_gather, 1, dst, 3, src, debug_data_ptrs, detail::throw_on_error_details()); 01091 } 01092 return result; 01093 } 01094 01098 template <typename T> 01099 typename detail::enable_if<detail::is_scalar<T>::value, dense<T, 1> >::type 01100 gather(const dense<T, 1>& source, const dense<usize, 1>& index, const typename uncaptured<T>::type& svalue) 01101 { 01102 const T value = svalue; 01103 01104 return gather(source, index, value); 01105 } 01106 01110 template <typename T> 01111 dense<T, 1> 01112 gather(const dense<T, 1>& source, const dense<usize, 1>& index) 01113 { 01114 T zero; 01115 01116 return gather(source, index, zero); 01117 } 01118 01122 template <typename T> 01123 dense<T, 2> 01124 gather(const dense<T, 2>& source, const dense<array<usize, 2>, 2>& index, const T& value) 01125 { 01126 dense<T, 2> result; 01127 typename dense<T, 2>::container_iterator I = result.containers_begin(); 01128 typename dense<T, 2>::container_const_iterator J = source.containers_begin(); 01129 detail::contents_iterator K = detail::contents_begin(value); 01130 dense<array<usize, 2>, 2>::container_const_iterator L = index.containers_begin(); 01131 const detail::container& index0 = *L++; 01132 const detail::container& index1 = *L++; 01133 for ( ; I != result.containers_end(); ++I, ++J, ++K) { 01134 arbb_variable_t dst[] = { *I }; 01135 arbb_variable_t src[] = { *J, index0, index1, *K }; 01136 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 01137 arbb_op_dynamic(detail::function::current(), arbb_op_gather, 1, dst, 4, src, debug_data_ptrs, detail::throw_on_error_details()); 01138 } 01139 return result; 01140 } 01141 01145 template <typename T> 01146 typename detail::enable_if<detail::is_scalar<T>::value, dense<T, 2> >::type 01147 gather(const dense<T, 2>& source, const dense<array<usize, 2>, 2>& index, const typename uncaptured<T>::type& svalue) 01148 { 01149 const T value = svalue; 01150 01151 return gather(source, index, value); 01152 } 01153 01157 template <typename T> 01158 dense<T, 2> 01159 gather(const dense<T, 2>& source, const dense<array<usize, 2>, 2>& index) 01160 { 01161 T zero; 01162 01163 return gather(source, index, zero); 01164 } 01165 01169 template <typename T> 01170 dense<T, 3> 01171 gather(const dense<T, 3>& source, const dense<array<usize, 3>, 3>& index, const T& value) 01172 { 01173 dense<T, 3> result; 01174 typename dense<T, 3>::container_iterator I = result.containers_begin(); 01175 typename dense<T, 3>::container_const_iterator J = source.containers_begin(); 01176 detail::contents_iterator K = detail::contents_begin(value); 01177 dense<array<usize, 3>, 3>::container_const_iterator L = index.containers_begin(); 01178 const detail::container& index0 = *L++; 01179 const detail::container& index1 = *L++; 01180 const detail::container& index2 = *L++; 01181 for ( ; I != result.containers_end(); ++I, ++J, ++K) { 01182 arbb_variable_t dst[] = { *I }; 01183 arbb_variable_t src[] = { *J, index0, index1, index2, *K }; 01184 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 01185 arbb_op_dynamic(detail::function::current(), arbb_op_gather, 1, dst, 5, src, debug_data_ptrs, detail::throw_on_error_details()); 01186 } 01187 return result; 01188 } 01189 01193 template <typename T> 01194 typename detail::enable_if<detail::is_scalar<T>::value, dense<T, 3> >::type 01195 gather(const dense<T, 3>& source, const dense<array<usize, 3>, 3>& index, const typename uncaptured<T>::type& svalue) 01196 { 01197 const T value = svalue; 01198 01199 return gather(source, index, value); 01200 } 01201 01205 template <typename T> 01206 dense<T, 3> 01207 gather(const dense<T, 3>& source, const dense<array<usize, 3>, 3>& index) 01208 { 01209 T zero; 01210 01211 return gather(source, index, zero); 01212 } 01213 01215 template <typename T> 01216 dense<T, 1> 01217 cat(const dense<T, 1>& source1, const dense<T, 1>& source2) 01218 { 01219 dense<T, 1> result; 01220 typename dense<T, 1>::container_iterator I = result.containers_begin(); 01221 typename dense<T, 1>::container_const_iterator J = source1.containers_begin(); 01222 typename dense<T, 1>::container_const_iterator K = source2.containers_begin(); 01223 for ( ; I != result.containers_end(); ++I, ++J, ++K) { 01224 arbb_variable_t dst[] = { *I }; 01225 arbb_variable_t src[] = { *J, *K }; 01226 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 01227 arbb_op(detail::function::current(), arbb_op_cat, dst, src, debug_data_ptrs, detail::throw_on_error_details()); 01228 } 01229 return result; 01230 } 01231 01235 template <typename T> 01236 typename detail::enable_if<detail::is_scalar<T>::value, dense<T, 1> >::type 01237 indices(const T& start, const usize& nelts, const T& stride) 01238 { 01239 dense<T, 1> result; 01240 const arbb_variable_t outputs[] = { result.vm_variable() }; 01241 const arbb_variable_t inputs[] = { start.vm_variable(), nelts.vm_variable(), stride.vm_variable() }; 01242 void* debug_data_ptrs[] = { result.containers_begin()->get_debug_data_ptr() }; 01243 arbb_op_dynamic(detail::function::current(), arbb_op_index, 1, outputs, 3, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01244 return result; 01245 } 01246 01248 01250 template <typename T> 01251 typename detail::enable_if<detail::is_scalar<T>::value, dense<T, 2> >::type 01252 indices(const T& start, const usize& nelts, const T& stride, const usize& times, const boolean& along_row) 01253 { 01254 dense<T, 2> result; 01255 const arbb_variable_t outputs[] = { result.vm_variable() }; 01256 const arbb_variable_t inputs[] = { start.vm_variable(), nelts.vm_variable(), stride.vm_variable(), 01257 times.vm_variable(), along_row.vm_variable() }; 01258 void* debug_data_ptrs[] = { result.containers_begin()->get_debug_data_ptr() }; 01259 arbb_op_dynamic(detail::function::current(), arbb_op_index, 1, outputs, 5, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01260 return result; 01261 } 01262 01264 01267 template <typename T> 01268 dense<T, 1> 01269 replace(const dense<T, 1>& source, const usize& index, const T& value) 01270 { 01271 dense<T, 1> result; 01272 typename dense<T, 1>::container_iterator I = result.containers_begin(); 01273 typename dense<T, 1>::container_const_iterator J = source.containers_begin(); 01274 detail::contents_iterator K = detail::contents_begin(value); 01275 for ( ; I != result.containers_end(); ++I, ++J, ++K) { 01276 arbb_variable_t dst[] = { *I }; 01277 arbb_variable_t src[] = { *J, index.detail_object(), *K }; 01278 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 01279 arbb_op_dynamic(detail::function::current(), arbb_op_replace_element, 1, dst, 3, src, debug_data_ptrs, detail::throw_on_error_details()); 01280 } 01281 return result; 01282 } 01283 01286 template <typename T> 01287 typename detail::enable_if<detail::is_scalar<T>::value, dense<T, 1> >::type 01288 replace(const dense<T, 1>& source, const usize& index, const typename uncaptured<T>::type& svalue) 01289 { 01290 const T value = svalue; 01291 01292 return replace(source, index, value); 01293 } 01294 01298 template <typename T> 01299 dense<T, 1> 01300 replace(const dense<T, 1>& source, const usize& start, const usize& nelts, const usize& stride, const T& value) 01301 { 01302 dense<T, 1> values = fill(value, nelts); 01303 return replace(source, start, nelts, stride, values); 01304 } 01305 01309 template <typename T> 01310 typename detail::enable_if<detail::is_scalar<T>::value, dense<T, 1> >::type 01311 replace(const dense<T, 1>& source, const usize& start, const usize& nelts, const usize& stride, const typename uncaptured<T>::type& svalue) 01312 { 01313 const T value = svalue; 01314 01315 return replace(source, start, nelts, stride, value); 01316 } 01317 01322 template <typename T> 01323 dense<T, 1> 01324 replace(const dense<T, 1>& source, const usize& start, const usize& nelts, const usize& stride, const dense<T, 1>& value) 01325 { 01326 dense<T, 1> result; 01327 typename dense<T, 1>::container_iterator I = result.containers_begin(); 01328 typename dense<T, 1>::container_const_iterator J = source.containers_begin(); 01329 typename dense<T, 1>::container_const_iterator K = value.containers_begin(); 01330 for ( ; I != result.containers_end(); ++I, ++J, ++K) { 01331 arbb_variable_t dst[] = { *I }; 01332 arbb_variable_t src[] = { *J, start.detail_object(), nelts.detail_object(), stride.detail_object(), *K }; 01333 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 01334 arbb_op_dynamic(detail::function::current(), arbb_op_replace, 1, dst, 5, src, debug_data_ptrs, detail::throw_on_error_details()); 01335 } 01336 return result; 01337 } 01338 01342 template <typename T> 01343 dense<T, 2> 01344 replace_row(const dense<T, 2>& source, const usize& row, const dense<T, 1>& value) 01345 { 01346 dense<T, 2> result; 01347 typename dense<T, 2>::container_iterator I = result.containers_begin(); 01348 typename dense<T, 2>::container_const_iterator J = source.containers_begin(); 01349 typename dense<T, 1>::container_const_iterator K = value.containers_begin(); 01350 for ( ; I != result.containers_end(); ++I, ++J, ++K) { 01351 arbb_variable_t dst[] = { *I }; 01352 arbb_variable_t src[] = { *J, row.detail_object(), *K }; 01353 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 01354 arbb_op(detail::function::current(), arbb_op_replace_row, dst, src, debug_data_ptrs, detail::throw_on_error_details()); 01355 } 01356 return result; 01357 } 01358 01362 template <typename T> 01363 dense<T, 2> 01364 replace_col(const dense<T, 2>& source, const usize& col, const dense<T, 1>& value) 01365 { 01366 dense<T, 2> result; 01367 typename dense<T, 2>::container_iterator I = result.containers_begin(); 01368 typename dense<T, 2>::container_const_iterator J = source.containers_begin(); 01369 typename dense<T, 1>::container_const_iterator K = value.containers_begin(); 01370 for ( ; I != result.containers_end(); ++I, ++J, ++K) { 01371 arbb_variable_t dst[] = { *I }; 01372 arbb_variable_t src[] = { *J, col.detail_object(), *K }; 01373 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 01374 arbb_op(detail::function::current(), arbb_op_replace_col, dst, src, debug_data_ptrs, detail::throw_on_error_details()); 01375 } 01376 return result; 01377 } 01378 01382 template <typename T> 01383 dense<T, 2> 01384 replace(const dense<T, 2>& source, const usize& col, const usize& row, const T& value) 01385 { 01386 dense<T, 2> result; 01387 typename dense<T, 2>::container_iterator I = result.containers_begin(); 01388 typename dense<T, 2>::container_const_iterator J = source.containers_begin(); 01389 detail::contents_iterator K = detail::contents_begin(value); 01390 for ( ; I != result.containers_end(); ++I, ++J, ++K) { 01391 arbb_variable_t dst[] = { *I }; 01392 arbb_variable_t src[] = { *J, row.detail_object(), col.detail_object(), *K }; 01393 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 01394 arbb_op_dynamic(detail::function::current(), arbb_op_replace_element, 1, dst, 4, src, debug_data_ptrs, detail::throw_on_error_details()); 01395 } 01396 return result; 01397 } 01398 01402 template <typename T> 01403 typename detail::enable_if<detail::is_scalar<T>::value, dense<T, 2> >::type 01404 replace(const dense<T, 2>& source, const usize& col, const usize& row, const typename uncaptured<T>::type& svalue) 01405 { 01406 const T value = svalue; 01407 01408 return replace(source, col, row, value); 01409 } 01410 01414 template <typename T> 01415 dense<T, 2> 01416 replace(const dense<T, 2>& source, const usize& start_col, const usize& ncols, const usize& start_row, const usize& nrows, const dense<T, 2>& values) 01417 { 01418 usize row_pitch = source.num_cols(); 01419 usize col_pitch = usize(0); 01420 return replace(source, start_col, ncols, col_pitch, start_row, nrows, row_pitch, values); 01421 } 01422 01427 template <typename T> 01428 dense<T, 2> 01429 replace(const dense<T, 2>& source, 01430 const usize& start_col, const usize& ncols, const usize& col_pitch, 01431 const usize& start_row, const usize& nrows, const usize& row_pitch, 01432 const dense<T, 2>& values) 01433 { 01434 dense<T, 2> result; 01435 typename dense<T, 2>::container_iterator I = result.containers_begin(); 01436 typename dense<T, 2>::container_const_iterator J = source.containers_begin(); 01437 typename dense<T, 2>::container_const_iterator K = values.containers_begin(); 01438 for ( ; I != result.containers_end(); ++I, ++J, ++K) { 01439 arbb_variable_t dst[] = { *I }; 01440 arbb_variable_t src[] = { *J, 01441 start_row.detail_object(), nrows.detail_object(), row_pitch.detail_object(), 01442 start_col.detail_object(), ncols.detail_object(), col_pitch.detail_object(), 01443 *K }; 01444 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 01445 arbb_op_dynamic(detail::function::current(), arbb_op_replace, 1, dst, 8, src, debug_data_ptrs, detail::throw_on_error_details()); 01446 } 01447 return result; 01448 } 01449 01453 template <typename T> 01454 dense<T, 3> 01455 replace(const dense<T, 3>& source, const usize& col, const usize& row, const usize& page, const T& value) 01456 { 01457 dense<T, 3> result; 01458 typename dense<T, 3>::container_iterator I = result.containers_begin(); 01459 typename dense<T, 3>::container_const_iterator J = source.containers_begin(); 01460 detail::contents_iterator K = detail::contents_begin(value); 01461 for ( ; I != result.containers_end(); ++I, ++J, ++K) { 01462 arbb_variable_t dst[] = { *I }; 01463 arbb_variable_t src[] = { *J, page.detail_object(), row.detail_object(), col.detail_object(), *K }; 01464 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 01465 arbb_op_dynamic(detail::function::current(), arbb_op_replace_element, 1, dst, 5, src, debug_data_ptrs, detail::throw_on_error_details()); 01466 } 01467 return result; 01468 } 01469 01473 template <typename T> 01474 typename detail::enable_if<detail::is_scalar<T>::value, dense<T, 3> >::type 01475 replace(const dense<T, 3>& source, const usize& col, const usize& row, const usize& page, const typename uncaptured<T>::type& svalue) 01476 { 01477 const T value = svalue; 01478 01479 return replace(source, col, row, page, value); 01480 } 01481 01485 template <typename T> 01486 dense<T, 3> 01487 replace_row(const dense<T, 3>& source, const usize& row, const usize& page, const dense<T, 1>& values) 01488 { 01489 return replace_page(source, page, replace_row(source.page(page), row, values)); 01490 } 01491 01495 template <typename T> 01496 dense<T, 3> 01497 replace_col(const dense<T, 3>& source, const usize& col, const usize& page, const dense<T, 1>& values) 01498 { 01499 return replace_page(source, page, replace_col(source.page(page), col, values)); 01500 } 01501 01505 template <typename T> 01506 dense<T, 3> 01507 replace_dim3(const dense<T, 3>& source, const usize& col, const usize& row, const dense<T, 1>& values) 01508 { 01509 usize width = source.num_cols(); 01510 usize height = source.num_rows(); 01511 usize depth = source.num_pages(); 01512 dense<usize, 1> i = indices(row * width + col, depth, width * height); 01513 return reshape(scatter(values, i, source.flatten()), width, height, depth); 01514 } 01515 01518 template <typename T> 01519 dense<T, 3> 01520 replace_page(const dense<T, 3>& source, const usize& page, const dense<T, 2>& value) 01521 { 01522 dense<T, 3> result; 01523 typename dense<T, 3>::container_iterator I = result.containers_begin(); 01524 typename dense<T, 3>::container_const_iterator J = source.containers_begin(); 01525 typename dense<T, 2>::container_const_iterator K = value.containers_begin(); 01526 for ( ; I != result.containers_end(); ++I, ++J, ++K) { 01527 arbb_variable_t dst[] = { *I }; 01528 arbb_variable_t src[] = { *J, page.detail_object(), *K }; 01529 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 01530 arbb_op(detail::function::current(), arbb_op_replace_page, dst, src, debug_data_ptrs, detail::throw_on_error_details()); 01531 } 01532 return result; 01533 } 01534 01537 template <typename T> 01538 dense<T, 2> 01539 swap_rows(const dense<T, 2>& source, const usize& row1, const usize& row2) 01540 { 01541 dense<T, 2> result; 01542 typename dense<T, 2>::container_iterator I = result.containers_begin(); 01543 typename dense<T, 2>::container_const_iterator J = source.containers_begin(); 01544 for ( ; I != result.containers_end(); ++I, ++J) { 01545 arbb_variable_t dst[] = { *I }; 01546 arbb_variable_t src[] = { *J, row1.detail_object(), row2.detail_object() }; 01547 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 01548 arbb_op(detail::function::current(), arbb_op_swap_row, dst, src, debug_data_ptrs, detail::throw_on_error_details()); 01549 } 01550 return result; 01551 } 01552 01555 template <typename T> 01556 dense<T, 3> 01557 swap_rows(const dense<T, 3>& source, const usize& row1, const usize& row2) 01558 { 01559 dense<T, 3> result; 01560 typename dense<T, 3>::container_iterator I = result.containers_begin(); 01561 typename dense<T, 3>::container_const_iterator J = source.containers_begin(); 01562 for ( ; I != result.containers_end(); ++I, ++J) { 01563 arbb_variable_t dst[] = { *I }; 01564 arbb_variable_t src[] = { *J, row1.detail_object(), row2.detail_object() }; 01565 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 01566 arbb_op(detail::function::current(), arbb_op_swap_row, dst, src, debug_data_ptrs, detail::throw_on_error_details()); 01567 } 01568 return result; 01569 } 01570 01573 template <typename T> 01574 dense<T, 2> 01575 swap_cols(const dense<T, 2>& source, const usize& col1, const usize& col2) 01576 { 01577 return replace_col(replace_col(source, col1, source.col(col2)), col2, source.col(col1)); 01578 } 01579 01582 template <typename T> 01583 dense<T, 3> 01584 swap_cols(const dense<T, 3>& source, const usize& col1, const usize& col2) 01585 { 01586 dense<T, 3> result; 01587 typename dense<T, 3>::container_iterator I = result.containers_begin(); 01588 typename dense<T, 3>::container_const_iterator J = source.containers_begin(); 01589 for ( ; I != result.containers_end(); ++I, ++J) { 01590 arbb_variable_t dst[] = { *I }; 01591 arbb_variable_t src[] = { *J, col1.detail_object(), col2.detail_object() }; 01592 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 01593 arbb_op(detail::function::current(), arbb_op_swap_col, dst, src, debug_data_ptrs, detail::throw_on_error_details()); 01594 } 01595 return result; 01596 } 01597 01600 template <typename T> 01601 dense<T, 3> 01602 swap_pages(const dense<T, 3>& source, const usize& page1, const usize& page2) 01603 { 01604 dense<T, 3> result; 01605 typename dense<T, 3>::container_iterator I = result.containers_begin(); 01606 typename dense<T, 3>::container_const_iterator J = source.containers_begin(); 01607 for ( ; I != result.containers_end(); ++I, ++J) { 01608 arbb_variable_t dst[] = { *I }; 01609 arbb_variable_t src[] = { *J, page1.detail_object(), page2.detail_object() }; 01610 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 01611 arbb_op(detail::function::current(), arbb_op_swap_page, dst, src, debug_data_ptrs, detail::throw_on_error_details()); 01612 } 01613 return result; 01614 } 01615 01618 template <typename T> 01619 dense<T, 2> 01620 transpose(const dense<T, 2>& source) 01621 { 01622 dense<usize, 1> i = indices(usize(0), source.num_rows(), source.num_cols()); 01623 01624 dense<T, 2> result; 01625 typename dense<T, 2>::container_iterator I = result.containers_begin(); 01626 typename dense<T, 2>::container_const_iterator J = source.containers_begin(); 01627 for ( ; I != result.containers_end(); ++I, ++J) { 01628 arbb_variable_t dst[] = { *I }; 01629 arbb_variable_t src[] = { *J, *i.containers_begin() }; 01630 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 01631 arbb_op(detail::function::current(), arbb_op_transpose, dst, src, debug_data_ptrs, detail::throw_on_error_details()); 01632 } 01633 return result; 01634 } 01635 01638 template <typename T> 01639 dense<T, 3> 01640 transpose(const dense<T, 3>& source) 01641 { 01642 dense<usize, 1> i = indices(usize(0), source.num_rows(), source.num_cols()); 01643 01644 dense<T, 3> result; 01645 typename dense<T, 3>::container_iterator I = result.containers_begin(); 01646 typename dense<T, 3>::container_const_iterator J = source.containers_begin(); 01647 for ( ; I != result.containers_end(); ++I, ++J) { 01648 arbb_variable_t dst[] = { *I }; 01649 arbb_variable_t src[] = { *J, *i.containers_begin() }; 01650 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 01651 arbb_op(detail::function::current(), arbb_op_transpose, dst, src, debug_data_ptrs, detail::throw_on_error_details()); 01652 } 01653 return result; 01654 } 01655 01659 template <typename T> 01660 dense<T, 1> 01661 section(const dense<T, 1>& source, const usize& first, const usize& nelts, const usize& stride = 1) 01662 { 01663 dense<T, 1> result; 01664 typename dense<T, 1>::container_iterator I = result.containers_begin(); 01665 typename dense<T, 1>::container_const_iterator J = source.containers_begin(); 01666 for ( ; I != result.containers_end(); ++I, ++J) { 01667 arbb_variable_t dst[] = { *I }; 01668 arbb_variable_t src[] = { *J, first.detail_object(), nelts.detail_object(), stride.detail_object() }; 01669 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 01670 arbb_op_dynamic(detail::function::current(), arbb_op_section, 1, dst, 4, src, debug_data_ptrs, detail::throw_on_error_details()); 01671 } 01672 return result; 01673 } 01674 01678 template <typename T> 01679 dense<T, 2> 01680 section(const dense<T, 2>& source, const usize& start_col, const usize& ncols, const usize& start_row, const usize& nrows) 01681 { 01682 const usize row_pitch = source.num_cols(); 01683 return section(source, start_col, ncols, usize(1), start_row, nrows, row_pitch); 01684 } 01685 01690 template <typename T> 01691 dense<T, 2> 01692 section(const dense<T, 2>& source, 01693 const usize& start_col, const usize& ncols, const usize& col_pitch, 01694 const usize& start_row, const usize& nrows, const usize& row_pitch) 01695 { 01696 dense<T, 2> result; 01697 typename dense<T, 2>::container_iterator I = result.containers_begin(); 01698 typename dense<T, 2>::container_const_iterator J = source.containers_begin(); 01699 for ( ; I != result.containers_end(); ++I, ++J) { 01700 arbb_variable_t dst[] = { *I }; 01701 arbb_variable_t src[] = { *J, start_row.detail_object(), nrows.detail_object(), row_pitch.detail_object(), 01702 start_col.detail_object(), ncols.detail_object(), col_pitch.detail_object() }; 01703 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 01704 arbb_op_dynamic(detail::function::current(), arbb_op_section, 1, dst, 7, src, debug_data_ptrs, detail::throw_on_error_details()); 01705 } 01706 return result; 01707 } 01708 01712 template <typename T> 01713 dense<T, 3> 01714 section(const dense<T, 3>& source, 01715 const usize& start_col, const usize& ncols, 01716 const usize& start_row, const usize& nrows, 01717 const usize& start_page, const usize& npages) 01718 { 01719 const usize row_pitch = source.num_cols(); 01720 const usize page_pitch = source.num_rows() * row_pitch; 01721 return section(source, start_col, ncols, usize(1), start_row, nrows, row_pitch, start_page, npages, page_pitch); 01722 } 01723 01729 template <typename T> 01730 dense<T, 3> 01731 section(const dense<T, 3>& source, 01732 const usize& start_col, const usize& ncols, const usize& col_pitch, 01733 const usize& start_row, const usize& nrows, const usize& row_pitch, 01734 const usize& start_page, const usize& npages, const usize& page_pitch) 01735 { 01736 dense<T, 3> result; 01737 typename dense<T, 3>::container_iterator I = result.containers_begin(); 01738 typename dense<T, 3>::container_const_iterator J = source.containers_begin(); 01739 for ( ; I != result.containers_end(); ++I, ++J) { 01740 arbb_variable_t dst[] = { *I }; 01741 arbb_variable_t src[] = { *J, start_page.detail_object(), npages.detail_object(), page_pitch.detail_object(), 01742 start_row.detail_object(), nrows.detail_object(), row_pitch.detail_object(), 01743 start_col.detail_object(), ncols.detail_object(), col_pitch.detail_object() }; 01744 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 01745 arbb_op_dynamic(detail::function::current(), arbb_op_section, 1, dst, 10, src, debug_data_ptrs, detail::throw_on_error_details()); 01746 } 01747 return result; 01748 } 01749 01751 enum sort_direction { 01752 sort_ascending = 0, 01753 sort_descending = 1 01754 }; 01755 01759 template <typename T> 01760 typename detail::enable_if<detail::is_scalar<T>::value, dense<T, 1> >::type 01761 sort(const dense<T, 1>& source, dense<usize, 1>& rank, sort_direction direction = sort_ascending) 01762 { 01763 const usize _direction(direction); 01764 dense<T, 1> result; 01765 const arbb_variable_t outputs[] = { result.vm_variable(), rank.vm_variable() }; 01766 const arbb_variable_t inputs[] = { source.vm_variable(), _direction.vm_variable() }; 01767 void* debug_data_ptrs[] = { result.containers_begin()->get_debug_data_ptr(), rank.containers_begin()->get_debug_data_ptr() }; 01768 arbb_op(detail::function::current(), arbb_op_sort_rank, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01769 return result; 01770 } 01771 01773 template <typename T> 01774 typename detail::enable_if<detail::is_scalar<T>::value, dense<T, 1> >::type 01775 sort(const dense<T, 1>& source, sort_direction direction = sort_ascending) 01776 { 01777 const usize _direction(direction); 01778 dense<T, 1> result; 01779 const arbb_variable_t outputs[] = { result.vm_variable() }; 01780 const arbb_variable_t inputs[] = { source.vm_variable(), _direction.vm_variable() }; 01781 void* debug_data_ptrs[] = { result.containers_begin()->get_debug_data_ptr() }; 01782 arbb_op(detail::function::current(), arbb_op_sort, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01783 return result; 01784 } 01785 01787 inline u64 wall_clock() 01788 { 01789 u64 result; 01790 const arbb_variable_t outputs[] = { result.vm_variable() }; 01791 void* debug_data_ptrs[] = { result.get_debug_data_ptr() }; 01792 arbb_op(detail::function::current(), arbb_op_wall_clock, outputs, 0, debug_data_ptrs, detail::throw_on_error_details()); 01793 return result; 01794 } 01795 01799 inline dense<boolean, 1> mask(const usize& result_size, const usize& start, const usize& true_count, const usize& stride) 01800 { 01801 dense<boolean, 1> result; 01802 const arbb_variable_t outputs[] = { result.vm_variable() }; 01803 const arbb_variable_t inputs[] = { result_size.vm_variable(), start.vm_variable(), true_count.vm_variable(), stride.vm_variable() }; 01804 void* debug_data_ptrs[] = { result.containers_begin()->get_debug_data_ptr() }; 01805 arbb_op(detail::function::current(), arbb_op_mask, outputs, inputs, debug_data_ptrs, detail::throw_on_error_details()); 01806 return result; 01807 } 01808 01811 template <typename T> 01812 dense<T, 2> 01813 reshape(const dense<T, 1>& source, const usize& ncols, const usize& nrows) 01814 { 01815 dense<T, 2> result; 01816 typename dense<T, 2>::container_iterator I = result.containers_begin(); 01817 typename dense<T, 2>::container_const_iterator J = source.containers_begin(); 01818 for ( ; I != result.containers_end(); ++I, ++J) { 01819 arbb_variable_t dst[] = { *I }; 01820 arbb_variable_t src[] = { *J, nrows.detail_object(), ncols.detail_object() }; 01821 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 01822 arbb_op_dynamic(detail::function::current(), arbb_op_set_regular_nesting, 1, dst, 3, src, debug_data_ptrs, detail::throw_on_error_details()); 01823 } 01824 return result; 01825 } 01826 01828 template <typename T, typename U> 01829 dense<T, 2> 01830 reshape_as(const dense<T, 1>& source, const dense<U, 2>& shape) 01831 { 01832 return reshape(source, shape.num_cols(), shape.num_rows()); 01833 } 01834 01837 template <typename T> 01838 dense<T, 3> 01839 reshape(const dense<T, 1>& source, const usize& ncols, const usize& nrows, const usize& npages) 01840 { 01841 dense<T, 3> result; 01842 typename dense<T, 3>::container_iterator I = result.containers_begin(); 01843 typename dense<T, 3>::container_const_iterator J = source.containers_begin(); 01844 for ( ; I != result.containers_end(); ++I, ++J) { 01845 arbb_variable_t dst[] = { *I }; 01846 arbb_variable_t src[] = { *J, npages.detail_object(), nrows.detail_object(), ncols.detail_object() }; 01847 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 01848 arbb_op_dynamic(detail::function::current(), arbb_op_set_regular_nesting, 1, dst, 4, src, debug_data_ptrs, detail::throw_on_error_details()); 01849 } 01850 return result; 01851 } 01852 01854 template <typename T, typename U> 01855 dense<T, 3> 01856 reshape_as(const dense<T, 1>& source, const dense<U, 3>& shape) 01857 { 01858 return reshape(source, shape.num_cols(), shape.num_rows(), shape.num_pages()); 01859 } 01860 01864 template<typename T, std::size_t D> 01865 dense<T> 01866 add_merge(const dense<T, D>& source, const dense<isize>& indices) 01867 { 01868 dense<T> result; 01869 typename dense<T>::container_iterator I = result.containers_begin(); 01870 typename dense<T, D>::container_const_iterator J = source.containers_begin(); 01871 typename dense<isize>::container_const_iterator K = indices.containers_begin(); 01872 for ( ; I != result.containers_end(); ++I, ++J) { 01873 arbb_variable_t dst[] = { *I }; 01874 arbb_variable_t src[] = { *J, *K }; 01875 void* debug_data_ptrs[] = { I->get_debug_data_ptr() }; 01876 01877 arbb_op(detail::function::current(), arbb_op_add_merge, dst, src, debug_data_ptrs, detail::throw_on_error_details()); 01878 } 01879 01880 return result; 01881 } 01882 01884 01885 } // namespace ARBB_CPP_NS 01886 01887 #endif // ARBB_CPP_DENSE_FUNCS_HPP
Copyright © 2010, Intel Corporation. All rights reserved.