Mercurial > hg > octave-lyh

comparison liboctave/Array.cc @ 9773:01f897d8a130

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
optimize memory manipulation by arrays & indexing
author Jaroslav Hajek <highegg@gmail.com>
date Tue, 03 Nov 2009 11:35:59 +0100
parents b4fdfee405b5
children 6dafc60dde31
comparison
equal deleted inserted replaced
9772:3ac8ea48279b 9773:01f897d8a130
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 std::fill (slice_data, slice_data + slice_len, val); 80 octave_fill (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)
566 { 566 {
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 dest = std::copy (src, src + len, dest); 571 {
572 octave_ucopy (len, src, dest);
573 dest += len;
574 }
572 else 575 else
573 { 576 {
574 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)
575 dest[i] = src[j]; 578 dest[i] = src[j];
576 579
827 template <class T> 830 template <class T>
828 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
829 { 832 {
830 if (lev == 0) 833 if (lev == 0)
831 { 834 {
832 T* destc = std::copy (src, src + cext[0], dest); 835 octave_ucopy (cext[0], src, dest);
833 std::fill (destc, dest + dext[0], rfv); 836 octave_fill (dext[0] - cext[0], rfv, dest + cext[0]);
834 } 837 }
835 else 838 else
836 { 839 {
837 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;
838 for (k = 0; k < cext[lev]; k++) 841 for (k = 0; k < cext[lev]; k++)
839 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);
840 843
841 std::fill (dest + k * dd, dest + dext[lev], rfv); 844 octave_fill (dext[lev] - k * dd, rfv, dest + k * dd);
842 } 845 }
843 } 846 }
844 public: 847 public:
845 template <class T> 848 template <class T>
846 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
1112 static const octave_idx_type max_stack_chunk = 1024; 1115 static const octave_idx_type max_stack_chunk = 1024;
1113 octave_idx_type nn = n + std::min (nx, max_stack_chunk); 1116 octave_idx_type nn = n + std::min (nx, max_stack_chunk);
1114 Array<T> tmp (Array<T> (nn), dv, 0, n); 1117 Array<T> tmp (Array<T> (nn), dv, 0, n);
1115 T *dest = tmp.fortran_vec (); 1118 T *dest = tmp.fortran_vec ();
1116 1119
1117 std::copy (data (), data () + nx, dest); 1120 octave_ucopy (nx, data (), dest);
1118 dest[nx] = rfv; 1121 dest[nx] = rfv;
1119 1122
1120 *this = tmp; 1123 *this = tmp;
1121 } 1124 }
1122 } 1125 }
1124 { 1127 {
1125 Array<T> tmp = Array<T> (dv); 1128 Array<T> tmp = Array<T> (dv);
1126 T *dest = tmp.fortran_vec (); 1129 T *dest = tmp.fortran_vec ();
1127 1130
1128 octave_idx_type n0 = std::min (n, nx), n1 = n - n0; 1131 octave_idx_type n0 = std::min (n, nx), n1 = n - n0;
1129 dest = std::copy (data (), data () + n0, dest); 1132 octave_ucopy (n0, data (), dest);
1130 std::fill (dest, dest + n1, rfv); 1133 octave_fill (n1, rfv, dest + n0);
1131 1134
1132 *this = tmp; 1135 *this = tmp;
1133 } 1136 }
1134 } 1137 }
1135 } 1138 }
1151 1154
1152 octave_idx_type r0 = std::min (r, rx), r1 = r - r0; 1155 octave_idx_type r0 = std::min (r, rx), r1 = r - r0;
1153 octave_idx_type c0 = std::min (c, cx), c1 = c - c0; 1156 octave_idx_type c0 = std::min (c, cx), c1 = c - c0;
1154 const T *src = data (); 1157 const T *src = data ();
1155 if (r == rx) 1158 if (r == rx)
1156 dest = std::copy (src, src + r * c0, dest); 1159 {
1160 octave_ucopy (r * c0, src, dest);
1161 dest += r * c0;
1162 }
1157 else 1163 else
1158 { 1164 {
1159 for (octave_idx_type k = 0; k < c0; k++) 1165 for (octave_idx_type k = 0; k < c0; k++)
1160 { 1166 {
1161 dest = std::copy (src, src + r0, dest); 1167 octave_ucopy (r0, src, dest);
1162 src += rx; 1168 src += rx;
1163 std::fill (dest, dest + r1, rfv); 1169 dest += r0;
1170 octave_fill (r1, rfv, dest);
1164 dest += r1; 1171 dest += r1;
1165 } 1172 }
1166 } 1173 }
1167 1174
1168 std::fill (dest, dest + r * c1, rfv); 1175 octave_fill (r * c1, rfv, dest);
1169 1176
1170 *this = tmp; 1177 *this = tmp;
1171 } 1178 }
1172 } 1179 }
1173 else 1180 else
1548 // Special case deleting a contiguous range. 1555 // Special case deleting a contiguous range.
1549 octave_idx_type m = n + l - u; 1556 octave_idx_type m = n + l - u;
1550 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));
1551 const T *src = data (); 1558 const T *src = data ();
1552 T *dest = tmp.fortran_vec (); 1559 T *dest = tmp.fortran_vec ();
1553 dest = std::copy (src, src + l, dest); 1560 octave_ucopy (l, src, dest);
1554 dest = std::copy (src + u, src + n, dest); 1561 octave_ucopy (n - u, src + u, dest + l);
1555 *this = tmp; 1562 *this = tmp;
1556 } 1563 }
1557 else 1564 else
1558 { 1565 {
1559 // Use index. 1566 // Use index.
1600 const T *src = data (); 1607 const T *src = data ();
1601 T *dest = tmp.fortran_vec (); 1608 T *dest = tmp.fortran_vec ();
1602 l *= dl; u *= dl; n *= dl; 1609 l *= dl; u *= dl; n *= dl;
1603 for (octave_idx_type k = 0; k < du; k++) 1610 for (octave_idx_type k = 0; k < du; k++)
1604 { 1611 {
1605 dest = std::copy (src, src + l, dest); 1612 octave_ucopy (l, src, dest);
1606 dest = std::copy (src + u, src + n, dest); 1613 dest += l;
1614 octave_ucopy (n - u, src + u, dest);
1615 dest += n - u;
1607 src += n; 1616 src += n;
1608 } 1617 }
1609 1618
1610 *this = tmp; 1619 *this = tmp;
1611 } 1620 }