octave: liboctave/Array.cc comparison

comparison liboctave/Array.cc @ 10350:12884915a8e4

merge MArray classes & improve Array interface

author	Jaroslav Hajek <highegg@gmail.com>
date	Sat, 23 Jan 2010 21:41:03 +0100
parents	07ebe522dac2
children	a3635bc1ea19

comparison

equal deleted inserted replaced

-:d4d13389c957
+:12884915a8e4
 }
 // The default fill value.  Override if you want a different one.
 template <class T>
-T Array<T>::resize_fill_value ()
+const T& Array<T>::resize_fill_value ()
 {
-return T ();
+static T zero = T ();
+return zero;
 }
 // Yes, we could do resize using index & assign.  However, that would
 // possibly involve a lot more memory traffic than we actually need.
 template <class T>
 void
-Array<T>::resize_fill (octave_idx_type n, const T& rfv)
+Array<T>::resize1 (octave_idx_type n, const T& rfv)
 {
 if (n >= 0 && ndims () == 2)
 {
 dim_vector dv;
 // This is driven by Matlab's behaviour of giving a *row* vector
 }
 else
 {
 static const octave_idx_type max_stack_chunk = 1024;
 octave_idx_type nn = n + std::min (nx, max_stack_chunk);
-Array<T> tmp (Array<T> (nn), dv, 0, n);
+Array<T> tmp (Array<T> (nn, 1), dv, 0, n);
 T *dest = tmp.fortran_vec ();
 copy_or_memcpy (nx, data (), dest);
 dest[nx] = rfv;
 gripe_invalid_resize ();
 }
 template <class T>
 void
-Array<T>::resize_fill (octave_idx_type r, octave_idx_type c, const T& rfv)
+Array<T>::resize (octave_idx_type r, octave_idx_type c, const T& rfv)
 {
 if (r >= 0 && c >= 0 && ndims () == 2)
 {
 octave_idx_type rx = rows (), cx = columns ();
 if (r != rx || c != cx)
 }
 template<class T>
 void
-Array<T>::resize_fill (const dim_vector& dv, const T& rfv)
+Array<T>::resize (const dim_vector& dv, const T& rfv)
 {
 int dvl = dv.length ();
 if (dvl == 2)
 resize (dv(0), dv(1), rfv);
 else if (dimensions != dv)
 {
 octave_idx_type n = numel (), nx = i.extent (n);
 if (n != nx)
 {
 if (i.is_scalar ())
-return Array<T> (1, rfv);
+return Array<T> (1, 1, rfv);
 else
-tmp.resize_fill (nx, rfv);
+tmp.resize1 (nx, rfv);
 }
 if (tmp.numel () != nx)
 return Array<T> ();
 }
 octave_idx_type r = dv(0), c = dv(1);
 octave_idx_type rx = i.extent (r), cx = j.extent (c);
 if (r != rx || c != cx)
 {
 if (i.is_scalar () && j.is_scalar ())
-return Array<T> (1, rfv);
+return Array<T> (1, 1, rfv);
 else
-tmp.resize_fill (rx, cx, rfv);
+tmp.resize (rx, cx, rfv);
 }
 if (tmp.rows () != rx || tmp.columns () != cx)
 return Array<T> ();
 }
 {
 bool all_scalars = true;
 for (int i = 0; i < ial; i++)
 all_scalars = all_scalars && ia(i).is_scalar ();
 if (all_scalars)
-return Array<T> (1, rfv);
+return Array<T> (1, 1, rfv);
 else
-tmp.resize_fill (dvx, rfv);
+tmp.resize (dvx, rfv);
 }
 if (tmp.dimensions != dvx)
 return Array<T> ();
 }
 else
 *this = Array<T> (rhs, dim_vector (1, nx));
 return;
 }
-resize_fill (nx, rfv);
+resize1 (nx, rfv);
 n = numel ();
 }
 if (colon)
 {
 else
 *this = Array<T> (rhs, rdv);
 return;
 }
-resize_fill (rdv, rfv);
+resize (rdv, rfv);
 dv = rdv;
 }
 if (all_colons)
 {
 octave_idx_type l, u;
 bool col_vec = ndims () == 2 && columns () == 1 && rows () != 1;
 if (i.is_scalar () && i(0) == n-1)
 {
 // Stack "pop" operation.
-resize (n-1);
+resize1 (n-1);
 }
 else if (i.is_cont_range (n, l, u))
 {
 // Special case deleting a contiguous range.
 octave_idx_type m = n + l - u;
 *this = tmp;
 }
 else
 {
 // Use index.
-Array<idx_vector> ia (ndims (), idx_vector::colon);
+Array<idx_vector> ia (ndims (), 1, idx_vector::colon);
 ia (dim) = i.complement (n);
 *this = index (ia);
 }
 }
 }
 idx_vector j (c, c + a.columns ());
 if (ndims () == 2 && a.ndims () == 2)
 assign (i, j, a);
 else
 {
-Array<idx_vector> idx (a.ndims ());
+Array<idx_vector> idx (a.ndims (), 1);
 idx(0) = i;
 idx(1) = j;
 for (int k = 0; k < a.ndims (); k++)
 idx(k) = idx_vector (0, a.dimensions(k));
 assign (idx, a);
 template <class T>
 Array<T>&
 Array<T>::insert (const Array<T>& a, const Array<octave_idx_type>& ra_idx)
 {
 octave_idx_type n = ra_idx.length ();
-Array<idx_vector> idx (n);
+Array<idx_vector> idx (n, 1);
 const dim_vector dva = a.dims ().redim (n);
 for (octave_idx_type k = 0; k < n; k++)
 idx(k) = idx_vector (ra_idx (k), ra_idx (k) + dva(k));
 assign (idx, a);
 octave_sort<T> lsort (safe_comparator (mode, *this, true));
 octave_idx_type r = rows (), c = cols ();
-idx = Array<octave_idx_type> (r);
+idx = Array<octave_idx_type> (r, 1);
 lsort.sort_rows (data (), idx.fortran_vec (), r, c);
 return idx;
 }
 // to resize. So count first, then allocate array of exact size.
 octave_idx_type cnt = 0;
 for (octave_idx_type i = 0; i < nel; i++)
 cnt += src[i] != zero;
-retval = Array<octave_idx_type> (cnt);
+retval.clear (cnt, 1);
 octave_idx_type *dest = retval.fortran_vec ();
 for (octave_idx_type i = 0; i < nel; i++)
 if (src[i] != zero) *dest++ = i;
 }
 else
 {
 // We want a fixed max number of elements, usually small. So be
 // optimistic, alloc the array in advance, and then resize if
 // needed.
-retval = Array<octave_idx_type> (n);
+retval.clear (n, 1);
 if (backward)
 {
 // Do the search as a series of successive single-element searches.
 octave_idx_type k = 0, l = nel - 1;
 for (; k < n; k++)
 retval(k) = l--;
 else
 break;
 }
 if (k < n)
-retval.resize (k);
+retval.resize (k, 1);
 octave_idx_type *rdata = retval.fortran_vec ();
 std::reverse (rdata, rdata + k);
 }
 else
 {
 retval(k) = l++;
 else
 break;
 }
 if (k < n)
-retval.resize (k);
+retval.resize (k, 1);
 }
 }
 // Fixup return dimensions, for Matlab compatibility.
 // find(zeros(0,0)) -> zeros(0,0)
 if (n_dims)
 {
 os << "data:";
-Array<octave_idx_type> ra_idx (n_dims, 0);
+Array<octave_idx_type> ra_idx (n_dims, 1, 0);
 // Number of times the first 2d-array is to be displayed.
 octave_idx_type m = 1;
 for (int i = 2; i < n_dims; i++)

Mercurial > octave

comparison liboctave/Array.cc @ 10350:12884915a8e4