octave-nkf: liboctave/idx-vector.cc comparison

comparison liboctave/idx-vector.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	57632dea2446
children	4ced6b90fffb

comparison

equal deleted inserted replaced

-:1473d0cf86d2
+:12df7854fa7c
 count++;
 return this;
 }
 std::ostream&
 idx_vector::idx_colon_rep::print (std::ostream& os) const
 {
 return os << ":";
 }
 err = true;
 }
 else if (len > 0)
 {
 if (r.all_elements_are_ints ())
 {
 start = static_cast<octave_idx_type> (r.base ()) - 1;
 step = static_cast<octave_idx_type> (r.inc ());
 if (start < 0 || (step < 0 && start + (len-1)*step < 0))
 {
 gripe_invalid_index ();
 count++;
 return this;
 }
 }
 std::ostream&
 idx_vector::idx_range_rep::print (std::ostream& os) const
 {
 os << start << ':' << step << ':' << start + len*step;
 return os;
 }
 Range
 idx_vector::idx_range_rep::unconvert (void) const
 {
 return Range (static_cast<double> (start+1),
 static_cast<double> (step), len);
 }
 Array<octave_idx_type>
 idx_vector::idx_range_rep::as_array (void)
 return retval;
 }
 inline octave_idx_type
 convert_index (octave_idx_type i, bool& conv_error,
 octave_idx_type& ext)
 {
 if (i <= 0)
 conv_error = true;
 if (ext < i)
 ext = i;
 return convert_index (static_cast<double> (x), conv_error, ext);
 }
 template <class T>
 inline octave_idx_type
 convert_index (octave_int<T> x, bool& conv_error,
 octave_idx_type& ext)
 {
 octave_idx_type i = octave_int<octave_idx_type> (x).value ();
 return convert_index (i, conv_error, ext);
 if (err)
 gripe_invalid_index ();
 }
 idx_vector::idx_scalar_rep::idx_scalar_rep (octave_idx_type i)
 : data (i)
 {
 if (data < 0)
 {
 gripe_invalid_index ();
 err = true;
 }
 }
 }
 // Note that this makes a shallow copy of the index array.
 idx_vector::idx_vector_rep::idx_vector_rep (const Array<octave_idx_type>& inda)
 : data (inda.data ()), len (inda.numel ()), ext (0),
 aowner (new Array<octave_idx_type> (inda)), orig_dims (inda.dims ())
 {
 if (len != 0)
 {
 octave_idx_type max = -1;
 for (octave_idx_type i = 0; i < len; i++)
 {
 octave_idx_type k = inda.xelem (i);
 if (k < 0)
 err = true;
 else if (k > max)
 max = k;
 }
 ext = max + 1;
 }
 }
 idx_vector::idx_vector_rep::idx_vector_rep (const Array<octave_idx_type>& inda,
 octave_idx_type _ext, direct)
 : data (inda.data ()), len (inda.numel ()), ext (_ext),
 aowner (new Array<octave_idx_type> (inda)), orig_dims (inda.dims ())
 {
 // No checking.
 if (ext < 0)
 {
 len = bnda.nnz ();
 const dim_vector dv = bnda.dims ();
 if (! dv.all_zero ())
 orig_dims = ((dv.length () == 2 && dv(0) == 1)
 ? dim_vector (1, len) : dim_vector (len, 1));
 if (len != 0)
 {
 octave_idx_type *d = new octave_idx_type [len];
 octave_idx_type k = 0;
 // FIXME: I hope this is OK, i.e. the element iterated this way are correctly ordered.
 for (octave_idx_type i = 0; i < nnz; i++)
 {
 if (bnda.data (i))
 d[k++] = bnda.cidx (i) + bnda.rows () * bnda.ridx (i);
 }
 data = d;
 ext = d[k-1] + 1;
 }
 }
 idx_vector::idx_vector_rep::~idx_vector_rep (void)
 {
 if (aowner)
 delete aowner;
 else
 delete [] data;
 }
 octave_idx_type
 idx_vector::idx_vector_rep::checkelem (octave_idx_type n) const
 {
 count++;
 return this;
 }
 // This is wrapped in auto_ptr so that we don't leak on out-of-memory.
 std::auto_ptr<idx_vector_rep> new_rep (
 new idx_vector_rep (0, len, ext, orig_dims, DIRECT));
 if (ext > len*xlog2 (1.0 + len))
 {
 // Use standard sort via octave_sort.
 }
 return new_rep.release ();
 }
 std::ostream&
 idx_vector::idx_vector_rep::print (std::ostream& os) const
 {
 os << '[';
 for (octave_idx_type ii = 0; ii < len - 1; ii++)
 ext--;
 const dim_vector dv = bnda.dims ();
 if (! dv.all_zero ())
 orig_dims = ((dv.length () == 2 && dv(0) == 1)
 ? dim_vector (1, len) : dim_vector (len, 1));
 aowner = new Array<bool> (bnda);
 data = bnda.data ();
 }
 idx_vector::idx_mask_rep::~idx_mask_rep (void)
 {
 if (aowner)
 delete aowner;
 else
 delete [] data;
 }
 octave_idx_type
 idx_vector::idx_mask_rep::xelem (octave_idx_type n) const
 {
 }
 return xelem (n);
 }
 std::ostream&
 idx_vector::idx_mask_rep::print (std::ostream& os) const
 {
 os << '[';
 for (octave_idx_type ii = 0; ii < ext - 1; ii++)
 OCTAVE_LOCAL_BUFFER_INIT (bool, left, n, true);
 retval = true;
 for (octave_idx_type i = 0, len = length (); i < len; i++)
 {
 octave_idx_type k = xelem (i);
 if (left[k])
 left[k] = false;
 else
 {
 const bool *data = r->get_data ();
 octave_idx_type ext = r->extent (0), len = r->length (0);
 octave_idx_type *idata = new octave_idx_type [len];
 for (octave_idx_type i = 0, j = 0; i < ext; i++)
 if (data[i])
 idata[j++] = i;
 ext = len > 0 ? idata[len - 1] + 1 : 0;
 return new idx_vector_rep (idata, len, ext, r->orig_dimensions (),
 else
 return *this;
 }
 void idx_vector::unconvert (idx_class_type& iclass,
 double& scalar, Range& range,
 Array<double>& array, Array<bool>& mask) const
 {
 iclass = idx_class ();
 switch (iclass)
 {
 assert (false);
 break;
 }
 }
 Array<octave_idx_type>
 idx_vector::as_array (void) const
 {
 return rep->as_array ();
 }
 bool
 idx_vector::is_vector (void) const
 {
 return idx_class () != class_vector || orig_dimensions ().is_vector ();
 }
 octave_idx_type
 idx_vector::freeze (octave_idx_type z_len, const char *, bool resize_ok)
 {
 if (! resize_ok && extent (z_len) > z_len)
 {
 (*current_liboctave_error_handler)
 }
 return length (z_len);
 }
 octave_idx_type
 idx_vector::ones_count () const
 {
 octave_idx_type n = 0;
 if (is_colon ())

Mercurial > octave-nkf

comparison liboctave/idx-vector.cc @ 11586:12df7854fa7c