dense_funcs.hpp

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

Submit feedback on this help topic

Copyright © 2010, Intel Corporation. All rights reserved.