Mercurial > hg > octave-lyh

comparison liboctave/Array.cc @ 9780:6dafc60dde31

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
rename oct-mem functions
author Jaroslav Hajek <highegg@gmail.com>
date Thu, 05 Nov 2009 21:13:31 +0100
parents 01f897d8a130
children 3e8b4c80ae63
comparison
equal deleted inserted replaced
9779:2941c1daf509 9780:6dafc60dde31
75 --rep->count; 75 --rep->count;
76 rep = new ArrayRep (length (), val); 76 rep = new ArrayRep (length (), val);
77 slice_data = rep->data; 77 slice_data = rep->data;
78 } 78 }
79 else 79 else
80 octave_fill (slice_len, val, slice_data); 80 fill_or_memset (slice_len, val, slice_data);
81 } 81 }
82 82
83 template <class T> 83 template <class T>
84 void 84 void
85 Array<T>::clear (void) 85 Array<T>::clear (void)
567 if (lev == 0) 567 if (lev == 0)
568 { 568 {
569 octave_idx_type step = stride[0], len = dim[0]; 569 octave_idx_type step = stride[0], len = dim[0];
570 if (step == 1) 570 if (step == 1)
571 { 571 {
572 octave_ucopy (len, src, dest); 572 copy_or_memcpy (len, src, dest);
573 dest += len; 573 dest += len;
574 } 574 }
575 else 575 else
576 { 576 {
577 for (octave_idx_type i = 0, j = 0; i < len; i++, j += step) 577 for (octave_idx_type i = 0, j = 0; i < len; i++, j += step)
830 template <class T> 830 template <class T>
831 void do_resize_fill (const T* src, T *dest, const T& rfv, int lev) const 831 void do_resize_fill (const T* src, T *dest, const T& rfv, int lev) const
832 { 832 {
833 if (lev == 0) 833 if (lev == 0)
834 { 834 {
835 octave_ucopy (cext[0], src, dest); 835 copy_or_memcpy (cext[0], src, dest);
836 octave_fill (dext[0] - cext[0], rfv, dest + cext[0]); 836 fill_or_memset (dext[0] - cext[0], rfv, dest + cext[0]);
837 } 837 }
838 else 838 else
839 { 839 {
840 octave_idx_type sd = sext[lev-1], dd = dext[lev-1], k; 840 octave_idx_type sd = sext[lev-1], dd = dext[lev-1], k;
841 for (k = 0; k < cext[lev]; k++) 841 for (k = 0; k < cext[lev]; k++)
842 do_resize_fill (src + k * sd, dest + k * dd, rfv, lev - 1); 842 do_resize_fill (src + k * sd, dest + k * dd, rfv, lev - 1);
843 843
844 octave_fill (dext[lev] - k * dd, rfv, dest + k * dd); 844 fill_or_memset (dext[lev] - k * dd, rfv, dest + k * dd);
845 } 845 }
846 } 846 }
847 public: 847 public:
848 template <class T> 848 template <class T>
849 void resize_fill (const T* src, T *dest, const T& rfv) const 849 void resize_fill (const T* src, T *dest, const T& rfv) const
1115 static const octave_idx_type max_stack_chunk = 1024; 1115 static const octave_idx_type max_stack_chunk = 1024;
1116 octave_idx_type nn = n + std::min (nx, max_stack_chunk); 1116 octave_idx_type nn = n + std::min (nx, max_stack_chunk);
1117 Array<T> tmp (Array<T> (nn), dv, 0, n); 1117 Array<T> tmp (Array<T> (nn), dv, 0, n);
1118 T *dest = tmp.fortran_vec (); 1118 T *dest = tmp.fortran_vec ();
1119 1119
1120 octave_ucopy (nx, data (), dest); 1120 copy_or_memcpy (nx, data (), dest);
1121 dest[nx] = rfv; 1121 dest[nx] = rfv;
1122 1122
1123 *this = tmp; 1123 *this = tmp;
1124 } 1124 }
1125 } 1125 }
1127 { 1127 {
1128 Array<T> tmp = Array<T> (dv); 1128 Array<T> tmp = Array<T> (dv);
1129 T *dest = tmp.fortran_vec (); 1129 T *dest = tmp.fortran_vec ();
1130 1130
1131 octave_idx_type n0 = std::min (n, nx), n1 = n - n0; 1131 octave_idx_type n0 = std::min (n, nx), n1 = n - n0;
1132 octave_ucopy (n0, data (), dest); 1132 copy_or_memcpy (n0, data (), dest);
1133 octave_fill (n1, rfv, dest + n0); 1133 fill_or_memset (n1, rfv, dest + n0);
1134 1134
1135 *this = tmp; 1135 *this = tmp;
1136 } 1136 }
1137 } 1137 }
1138 } 1138 }
1155 octave_idx_type r0 = std::min (r, rx), r1 = r - r0; 1155 octave_idx_type r0 = std::min (r, rx), r1 = r - r0;
1156 octave_idx_type c0 = std::min (c, cx), c1 = c - c0; 1156 octave_idx_type c0 = std::min (c, cx), c1 = c - c0;
1157 const T *src = data (); 1157 const T *src = data ();
1158 if (r == rx) 1158 if (r == rx)
1159 { 1159 {
1160 octave_ucopy (r * c0, src, dest); 1160 copy_or_memcpy (r * c0, src, dest);
1161 dest += r * c0; 1161 dest += r * c0;
1162 } 1162 }
1163 else 1163 else
1164 { 1164 {
1165 for (octave_idx_type k = 0; k < c0; k++) 1165 for (octave_idx_type k = 0; k < c0; k++)
1166 { 1166 {
1167 octave_ucopy (r0, src, dest); 1167 copy_or_memcpy (r0, src, dest);
1168 src += rx; 1168 src += rx;
1169 dest += r0; 1169 dest += r0;
1170 octave_fill (r1, rfv, dest); 1170 fill_or_memset (r1, rfv, dest);
1171 dest += r1; 1171 dest += r1;
1172 } 1172 }
1173 } 1173 }
1174 1174
1175 octave_fill (r * c1, rfv, dest); 1175 fill_or_memset (r * c1, rfv, dest);
1176 1176
1177 *this = tmp; 1177 *this = tmp;
1178 } 1178 }
1179 } 1179 }
1180 else 1180 else
1555 // Special case deleting a contiguous range. 1555 // Special case deleting a contiguous range.
1556 octave_idx_type m = n + l - u; 1556 octave_idx_type m = n + l - u;
1557 Array<T> tmp (dim_vector (col_vec ? m : 1, !col_vec ? m : 1)); 1557 Array<T> tmp (dim_vector (col_vec ? m : 1, !col_vec ? m : 1));
1558 const T *src = data (); 1558 const T *src = data ();
1559 T *dest = tmp.fortran_vec (); 1559 T *dest = tmp.fortran_vec ();
1560 octave_ucopy (l, src, dest); 1560 copy_or_memcpy (l, src, dest);
1561 octave_ucopy (n - u, src + u, dest + l); 1561 copy_or_memcpy (n - u, src + u, dest + l);
1562 *this = tmp; 1562 *this = tmp;
1563 } 1563 }
1564 else 1564 else
1565 { 1565 {
1566 // Use index. 1566 // Use index.
1607 const T *src = data (); 1607 const T *src = data ();
1608 T *dest = tmp.fortran_vec (); 1608 T *dest = tmp.fortran_vec ();
1609 l *= dl; u *= dl; n *= dl; 1609 l *= dl; u *= dl; n *= dl;
1610 for (octave_idx_type k = 0; k < du; k++) 1610 for (octave_idx_type k = 0; k < du; k++)
1611 { 1611 {
1612 octave_ucopy (l, src, dest); 1612 copy_or_memcpy (l, src, dest);
1613 dest += l; 1613 dest += l;
1614 octave_ucopy (n - u, src + u, dest); 1614 copy_or_memcpy (n - u, src + u, dest);
1615 dest += n - u; 1615 dest += n - u;
1616 src += n; 1616 src += n;
1617 } 1617 }
1618 1618
1619 *this = tmp; 1619 *this = tmp;