octave-nkf: liboctave/Array.cc comparison

comparison liboctave/Array.cc @ 11586:12df7854fa7c

strip trailing whitespace from source files

author	John W. Eaton <jwe@octave.org>
date	Thu, 20 Jan 2011 17:24:59 -0500
parents	a83bad07f7e3
children	4ced6b90fffb

comparison

equal deleted inserted replaced

-:1473d0cf86d2
+:12df7854fa7c
 // Template array classes
 /*
 Copyright (C) 1993-2011 John W. Eaton
 Copyright (C) 2008-2009 Jaroslav Hajek
 Copyright (C) 2009 VZLU Prague
 This file is part of Octave.
 {
 if (--rep->count <= 0)
 delete rep;
 rep = nil_rep ();
 rep->count++;
 slice_data = rep->data;
 slice_len = rep->len;
 dimensions = dim_vector ();
 }
 {
 return ::compute_index (ra_idx, dimensions);
 }
 template <class T>
 T&
 Array<T>::checkelem (octave_idx_type n)
 {
 // Do checks directly to avoid recomputing slice_len.
 if (n < 0)
 gripe_invalid_index ();
 return elem (n);
 }
 template <class T>
 T&
 Array<T>::checkelem (octave_idx_type i, octave_idx_type j)
 {
 return elem (compute_index (i, j));
 }
 template <class T>
 T&
 Array<T>::checkelem (octave_idx_type i, octave_idx_type j, octave_idx_type k)
 {
 return elem (compute_index (i, j, k));
 }
 template <class T>
 T&
 Array<T>::checkelem (const Array<octave_idx_type>& ra_idx)
 {
 return elem (compute_index (ra_idx));
 }
 dest = do_permute (src + i * step, dest, lev-1);
 }
 return dest;
 }
 public:
 template <class T>
 void permute (const T *src, T *dest) const { do_permute (src, dest, top); }
 }
 // Helper class for multi-d index reduction and recursive
 // indexing/indexed assignment.  Rationale: we could avoid recursion
 // using a state machine instead.  However, using recursion is much
 // more amenable to possible parallelization in the future.
 // Also, the recursion solution is cleaner and more understandable.
 class rec_index_helper
 {
 // CDIM occupies the last half of the space allocated for dim to
 // Unsuccessful, store index & cumulative dim.
 top++;
 idx[top] = ia(i);
 dim[top] = dv(i);
 cdim[top] = cdim[top-1] * dim[top-1];
 }
 }
 }
 ~rec_index_helper (void) { delete [] idx; delete [] dim; }
 dest = do_index (src + d*idx[lev].xelem (i), dest, lev-1);
 }
 return dest;
 }
 // Recursive N-d indexed assignment
 template <class T>
 const T *do_assign (const T *src, T *dest, int lev) const
 {
 if (lev == 0)
 void assign (const T *src, T *dest) const { do_assign (src, dest, top); }
 template <class T>
 void fill (const T& val, T *dest) const { do_fill (val, dest, top); }
 bool is_cont_range (octave_idx_type& l,
 octave_idx_type& u) const
 {
 return top == 0 && idx[0].is_cont_range (dim[0], l, u);
 }
 };
 fill_or_memset (dext[lev] - k * dd, rfv, dest + k * dd);
 }
 }
 public:
 template <class T>
 void resize_fill (const T* src, T *dest, const T& rfv) const
 { do_resize_fill (src, dest, rfv, n-1); }
 };
 template <class T>
 {
 // A(:,:,...,:) produces a shallow copy.
 dv.chop_trailing_singletons ();
 retval = Array<T> (*this, dv);
 }
 else
 {
 // Form result dimensions.
 dim_vector rdv = dim_vector::alloc (ial);
 for (int i = 0; i < ial; i++) rdv(i) = ia(i).length (dv(i));
 rdv.chop_trailing_singletons ();
 // last one, search me why).  Giving a column vector would make
 // much more sense (given the way trailing singleton dims are
 // treated).
 bool invalid = false;
 if (rows () == 0 || rows () == 1)
 dv = dim_vector (1, n);
 else if (columns () == 1)
 dv = dim_vector (n, 1);
 else
 invalid = true;
 if (invalid)
 gripe_invalid_resize ();
 else
 {
 octave_idx_type nx = numel ();
 Array<T> tmp (dv);
 // Prepare for recursive resizing.
 rec_resize_helper rh (dv, dimensions.redim (dvl));
 // Do it.
 rh.resize_fill (data (), tmp.fortran_vec (), rfv);
 *this = tmp;
 }
 else
 gripe_invalid_resize ();
 }
 }
 template <class T>
 Array<T>
 Array<T>::index (const idx_vector& i, bool resize_ok, const T& rfv) const
 {
 Array<T> tmp = *this;
 if (resize_ok)
 {
 return tmp.index (i);
 }
 template <class T>
 Array<T>
 Array<T>::index (const idx_vector& i, const idx_vector& j,
 bool resize_ok, const T& rfv) const
 {
 Array<T> tmp = *this;
 if (resize_ok)
 {
 if (tmp.rows () != rx || tmp.columns () != cx)
 return Array<T> ();
 }
 return tmp.index (i, j);
 }
 template <class T>
 Array<T>
 Array<T>::index (const Array<idx_vector>& ia,
 bool resize_ok, const T& rfv) const
 {
 Array<T> tmp = *this;
 if (resize_ok)
 dim_vector dvx = dim_vector::alloc (ial);
 for (int i = 0; i < ial; i++) dvx(i) = ia(i).extent (dv (i));
 if (! (dvx == dv))
 {
 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> (dim_vector (1, 1), rfv);
 else
 tmp.resize (dvx, rfv);
 if (tmp.dimensions != dvx)
 return Array<T> ();
 }
 return tmp.index (ia);
 }
 template <class T>
 void
 if (rhl == 1 || i.length (n) == rhl)
 {
 octave_idx_type nx = i.extent (n);
 bool colon = i.is_colon_equiv (nx);
 // Try to resize first if necessary.
 if (nx != n)
 {
 // Optimize case A = []; A(1:n) = X with A empty.
 if (dimensions.zero_by_zero () && colon)
 {
 if (rhl == 1)
 *this = Array<T> (dim_vector (1, nx), rhs(0));
 else
 *this = Array<T> (rhs, dim_vector (1, nx));
 return;
 }
 resize1 (nx, rfv);
 n = numel ();
 }
 if (colon)
 {
 void
 Array<T>::assign (const idx_vector& i, const idx_vector& j,
 const Array<T>& rhs, const T& rfv)
 {
 // Get RHS extents, discarding singletons.
 dim_vector rhdv = rhs.dims ();
 // Get LHS extents, allowing Fortran indexing in the second dim.
 dim_vector dv = dimensions.redim (2);
 // Check for out-of-bounds and form resizing dimensions.
 dim_vector rdv;
 // In the special when all dimensions are zero, colons are allowed
 // to inquire the shape of RHS.  The rules are more obscure, so we
 // solve that elsewhere.
 if (dv.all_zero ())
 rdv = zero_dims_inquire (i, j, rhdv);
 || (rhdv.length () == 2 && il == rhdv(0) && jl == rhdv(1)));
 match = match || (il == 1 && jl == rhdv(0) && rhdv(1) == 1);
 if (match)
 {
 bool all_colons = (i.is_colon_equiv (rdv(0))
 && j.is_colon_equiv (rdv(1)));
 // Resize if requested.
 if (rdv != dv)
 {
 // Optimize case A = []; A(1:m, 1:n) = X
 // Get RHS extents, discarding singletons.
 dim_vector rhdv = rhs.dims ();
 // Get LHS extents, allowing Fortran indexing in the second dim.
 dim_vector dv = dimensions.redim (ial);
 // Get the extents forced by indexing.
 dim_vector rdv;
 // In the special when all dimensions are zero, colons are
 // allowed to inquire the shape of RHS.  The rules are more
 // obscure, so we solve that elsewhere.
 match = match && j < rhdvl && l == rhdv(j++);
 }
 match = match && (j == rhdvl || rhdv(j) == 1);
 match = match || isfill;
 if (match)
 {
 // Resize first if necessary.
 if (rdv != dv)
 {
 rh.fill (rhs(0), fortran_vec ());
 else
 rh.assign (rhs.data (), fortran_vec ());
 }
 }
 else
 gripe_assignment_dimension_mismatch ();
 }
 }
 template <class T>
 void
 Array<T>::delete_elements (const idx_vector& i)
 {
 octave_idx_type n = numel ();
 if (i.is_colon ())
 {
 *this = Array<T> ();
 }
 else if (i.length (n) != 0)
 {
 if (i.extent (n) != n)
 }
 }
 }
 template <class T>
 void
 Array<T>::delete_elements (int dim, const idx_vector& i)
 {
 if (dim < 0 || dim >= ndims ())
 {
 (*current_liboctave_error_handler)
 return;
 }
 octave_idx_type n = dimensions (dim);
 if (i.is_colon ())
 {
 *this = Array<T> ();
 }
 else if (i.length (n) != 0)
 {
 if (i.extent (n) != n)
 }
 }
 }
 template <class T>
 void
 Array<T>::delete_elements (const Array<idx_vector>& ia)
 {
 if (ia.length () == 1)
 delete_elements (ia(0));
 else
 for (jj = 0; jj < (nc - 8 + 1); jj += 8)
 {
 for (ii = 0; ii < (nr - 8 + 1); ii += 8)
 {
 // Copy to buffer
 for (octave_idx_type j = jj, k = 0, idxj = jj * nr;
 j < jj + 8; j++, idxj += nr)
 for (octave_idx_type i = ii; i < ii + 8; i++)
 buf[k++] = xelem (i + idxj);
 // Copy from buffer
 for (octave_idx_type i = ii, idxi = ii * nc; i < ii + 8;
 i++, idxi += nc)
 for (octave_idx_type j = jj, k = i - ii; j < jj + 8;
 j++, k+=8)
 result.xelem (j + idxi) = fcn (buf[k]);
 }
 if (ii < nr)
 for (octave_idx_type j = jj; j < jj + 8; j++)
 for (octave_idx_type i = ii; i < nr; i++)
 result.xelem (j, i) = fcn (xelem (i, j));
 }
 for (octave_idx_type j = jj; j < nc; j++)
 for (octave_idx_type i = 0; i < nr; i++)
 result.xelem (j, i) = fcn (xelem (i, j));
 T *v = m.fortran_vec ();
 const T *ov = data ();
 octave_sort<T> lsort;
 if (mode != UNSORTED)
 lsort.set_compare (mode);
 else
 return m;
 if (stride == 1)
 {
 for (octave_idx_type j = 0; j < iter; j++)
 {
 // copy and partition out NaNs.
 // FIXME: impact on integer types noticeable?
 octave_idx_type kl = 0, ku = ns;
 for (octave_idx_type i = 0; i < ns; i++)
 {
 T tmp = ov[i];
 }
 else
 {
 OCTAVE_LOCAL_BUFFER (T, buf, ns);
 for (octave_idx_type j = 0; j < iter; j++)
 {
 octave_idx_type offset = j;
 octave_idx_type offset2 = 0;
 while (offset >= stride)
 offset -= stride;
 offset2++;
 }
 offset += offset2 * stride * ns;
 // gather and partition out NaNs.
 // FIXME: impact on integer types noticeable?
 octave_idx_type kl = 0, ku = ns;
 for (octave_idx_type i = 0; i < ns; i++)
 {
 T tmp = ov[i*stride + offset];
 return m;
 }
 template <class T>
 Array<T>
 Array<T>::sort (Array<octave_idx_type> &sidx, int dim,
 sortmode mode) const
 {
 if (dim < 0 || dim >= ndims ())
 {
 (*current_liboctave_error_handler)
 octave_sort<T> lsort;
 sidx = Array<octave_idx_type> (dv);
 octave_idx_type *vi = sidx.fortran_vec ();
 if (mode != UNSORTED)
 lsort.set_compare (mode);
 else
 return m;
 if (stride == 1)
 {
 for (octave_idx_type j = 0; j < iter; j++)
 {
 // copy and partition out NaNs.
 // FIXME: impact on integer types noticeable?
 octave_idx_type kl = 0, ku = ns;
 for (octave_idx_type i = 0; i < ns; i++)
 {
 T tmp = ov[i];
 else
 {
 OCTAVE_LOCAL_BUFFER (T, buf, ns);
 OCTAVE_LOCAL_BUFFER (octave_idx_type, bufi, ns);
 for (octave_idx_type j = 0; j < iter; j++)
 {
 octave_idx_type offset = j;
 octave_idx_type offset2 = 0;
 while (offset >= stride)
 offset -= stride;
 offset2++;
 }
 offset += offset2 * stride * ns;
 // gather and partition out NaNs.
 // FIXME: impact on integer types noticeable?
 octave_idx_type kl = 0, ku = ns;
 for (octave_idx_type i = 0; i < ns; i++)
 {
 T tmp = ov[i*stride + offset];
 return idx;
 }
 template <class T>
 sortmode
 Array<T>::is_sorted_rows (sortmode mode) const
 {
 octave_sort<T> lsort;
 octave_idx_type r = rows (), c = cols ();
 }
 // Do a binary lookup in a sorted array.
 template <class T>
 octave_idx_type
 Array<T>::lookup (const T& value, sortmode mode) const
 {
 octave_idx_type n = numel ();
 octave_sort<T> lsort;
 return lsort.lookup (data (), n, value);
 }
 template <class T>
 Array<octave_idx_type>
 Array<T>::lookup (const Array<T>& values, sortmode mode) const
 {
 octave_idx_type n = numel (), nval = values.numel ();
 octave_sort<T> lsort;
 Array<octave_idx_type> idx (values.dims ());
 return idx;
 }
 template <class T>
 octave_idx_type
 Array<T>::nnz (void) const
 {
 const T *src = data ();
 octave_idx_type nel = nelem (), retval = 0;
 const T zero = T ();
 return retval;
 }
 template <class T>
 Array<octave_idx_type>
 Array<T>::find (octave_idx_type n, bool backward) const
 {
 Array<octave_idx_type> retval;
 const T *src = data ();
 octave_idx_type nel = nelem ();
 {
 octave_idx_type kl = 0, ku = ns;
 if (stride == 1)
 {
 // copy without NaNs.
 // FIXME: impact on integer types noticeable?
 for (octave_idx_type i = 0; i < ns; i++)
 {
 T tmp = ov[i];
 if (sort_isnan<T> (tmp))
 ov += ns;
 }
 else
 {
 octave_idx_type offset = j % stride;
 // copy without NaNs.
 // FIXME: impact on integer types noticeable?
 for (octave_idx_type i = 0; i < ns; i++)
 {
 T tmp = ov[offset + i*stride];
 if (sort_isnan<T> (tmp))
 dim_vector dv = dims ();
 octave_idx_type nd = dv.length ();
 Array<T> d;
 if (nd > 2)
 (*current_liboctave_error_handler) ("Matrix must be 2-dimensional");
 else
 {
 octave_idx_type nnr = dv (0);
 octave_idx_type nnc = dv (1);
 bool Array<T>::optimize_dimensions (const dim_vector& dv)
 {
 bool retval = dimensions == dv;
 if (retval)
 dimensions = dv;
 return retval;
 }
 template <class T>
 void Array<T>::instantiation_guard ()

Mercurial > octave-nkf

comparison liboctave/Array.cc @ 11586:12df7854fa7c