octave-lyh: liboctave/Sparse.h comparison

comparison liboctave/Sparse.h @ 14792:8483286c0a13

Update Sparse sources to GNU standards (whitespace changes only) * Sparse.cc: Fix whitespace * Sparse.h: Ditto

author	Jordi Gutiérrez Hermoso <jordigh@octave.org>
date	Thu, 21 Jun 2012 14:29:21 -0400
parents	72c96de7a403
children	cda76da34693

comparison

equal deleted inserted replaced

-:90c131272396
+:8483286c0a13
 octave_idx_type nzmx;
 octave_idx_type nrows;
 octave_idx_type ncols;
 octave_refcount<int> count;
-SparseRep (void) : d (0), r (0), c (new octave_idx_type [1]), nzmx (0), nrows (0),
+SparseRep (void)
-ncols (0), count (1) { c[0] = 0; }
+: d (0), r (0), c (new octave_idx_type [1]), nzmx (0), nrows (0),
+ncols (0), count (1)
-SparseRep (octave_idx_type n) : d (0), r (0), c (new octave_idx_type [n+1]), nzmx (0), nrows (n),
+{
+c[0] = 0;
+}
+SparseRep (octave_idx_type n)
+: d (0), r (0), c (new octave_idx_type [n+1]), nzmx (0), nrows (n),
 ncols (n), count (1)
 {
 for (octave_idx_type i = 0; i < n + 1; i++)
 c[i] = 0;
 }
 for (octave_idx_type i = 0; i < nc + 1; i++)
 c[i] = 0;
 }
 SparseRep (const SparseRep& a)
-: d (new T [a.nzmx]), r (new octave_idx_type [a.nzmx]), c (new octave_idx_type [a.ncols + 1]),
+: d (new T [a.nzmx]), r (new octave_idx_type [a.nzmx]),
+c (new octave_idx_type [a.ncols + 1]),
 nzmx (a.nzmx), nrows (a.nrows), ncols (a.ncols), count (1)
 {
 octave_idx_type nz = a.nnz ();
 copy_or_memcpy (nz, a.d, d);
 copy_or_memcpy (nz, a.r, r);
 };
 //--------------------------------------------------------------------
 void make_unique (void)
 {
 if (rep->count > 1)
 {
 SparseRep *r = new SparseRep (*rep);
 if (--rep->count == 0)
 delete rep;
 rep = r;
 }
 }
 public:
 // !!! WARNING !!! -- these should be protected, not public.  You
 // should not access these data members directly!
 dim_vector dimensions;
 private:
 typename Sparse<T>::SparseRep *nil_rep (void) const
 {
 static typename Sparse<T>::SparseRep nr;
 return &nr;
 }
 public:
 Sparse (void)
 : rep (nil_rep ()), dimensions (dim_vector(0,0))
 {
 rep->count++;
 }
 explicit Sparse (octave_idx_type n)
 : rep (new typename Sparse<T>::SparseRep (n)),
 dimensions (dim_vector (n, n)) { }
 explicit Sparse (octave_idx_type nr, octave_idx_type nc, T val);
 Sparse (const dim_vector& dv, octave_idx_type nz)
 : rep (new typename Sparse<T>::SparseRep (dv(0), dv(1), nz)),
 dimensions (dv) { }
 Sparse (octave_idx_type nr, octave_idx_type nc, octave_idx_type nz)
 : rep (new typename Sparse<T>::SparseRep (nr, nc, nz)),
 dimensions (dim_vector (nr, nc)) { }
 // Type conversion case. Preserves capacity ().
 template <class U>
 Sparse (const Sparse<U>& a)
 : rep (new typename Sparse<T>::SparseRep (a.rep->nrows, a.rep->ncols, a.rep->nzmx)),
 dimensions (a.dimensions)
 {
 octave_idx_type nz = a.nnz ();
 std::copy (a.rep->d, a.rep->d + nz, rep->d);
 copy_or_memcpy (nz, a.rep->r, rep->r);
 copy_or_memcpy (rep->ncols + 1, a.rep->c, rep->c);
 }
 // No type conversion case.
 Sparse (const Sparse<T>& a)
 : rep (a.rep), dimensions (a.dimensions)
 {
 rep->count++;
 }
 public:
 Sparse (const dim_vector& dv);
 octave_idx_type nnz (void) const { return rep->nnz (); }
 // Querying the number of elements (incl. zeros) may overflow the index type,
 // so don't do it unless you really need it.
 octave_idx_type numel (void) const
 {
 return dimensions.safe_numel ();
 }
 octave_idx_type nelem (void) const { return capacity (); }
 octave_idx_type length (void) const { return numel (); }
 octave_idx_type dim1 (void) const { return dimensions(0); }
 octave_idx_type cols (void) const { return dim2 (); }
 octave_idx_type columns (void) const { return dim2 (); }
 octave_idx_type get_row_index (octave_idx_type k) { return ridx (k); }
 octave_idx_type get_col_index (octave_idx_type k)
 {
 octave_idx_type ret = 0;
 while (cidx(ret+1) < k)
 ret++;
 return ret;
 }
 size_t byte_size (void) const
 {
 return (static_cast<size_t>(cols () + 1) * sizeof (octave_idx_type)
-+ static_cast<size_t> (capacity ()) * (sizeof (T) + sizeof (octave_idx_type)));
++ static_cast<size_t> (capacity ())
-}
+* (sizeof (T) + sizeof (octave_idx_type)));
+}
 dim_vector dims (void) const { return dimensions; }
 Sparse<T> squeeze (void) const { return *this; }
 T& range_error (const char *fcn, const Array<octave_idx_type>& ra_idx);
 // No checking, even for multiple references, ever.
 T& xelem (octave_idx_type n)
 {
 octave_idx_type i = n % rows (), j = n / rows();
 return xelem (i, j);
 }
 T xelem (octave_idx_type n) const
 {
 octave_idx_type i = n % rows (), j = n / rows();
 return xelem (i, j);
 }
 T& xelem (octave_idx_type i, octave_idx_type j) { return rep->elem (i, j); }
-T xelem (octave_idx_type i, octave_idx_type j) const { return rep->celem (i, j); }
+T xelem (octave_idx_type i, octave_idx_type j) const
+{
+return rep->celem (i, j);
+}
 T& xelem (const Array<octave_idx_type>& ra_idx)
 { return xelem (compute_index (ra_idx)); }
 T xelem (const Array<octave_idx_type>& ra_idx) const
 { return xelem (compute_index (ra_idx)); }
 // FIXME -- would be nice to fix this so that we don't
 // unnecessarily force a copy, but that is not so easy, and I see no
 // clean way to do it.
 T& checkelem (octave_idx_type n)
 {
 if (n < 0 || n >= numel ())
 return range_error ("T& Sparse<T>::checkelem", n);
 else
 {
 make_unique ();
 return xelem (n);
 }
 }
 T& checkelem (octave_idx_type i, octave_idx_type j)
 {
 if (i < 0 || j < 0 || i >= dim1 () || j >= dim2 ())
 return range_error ("T& Sparse<T>::checkelem", i, j);
 else
 {
 make_unique ();
 return xelem (i, j);
 }
 }
 T& checkelem (const Array<octave_idx_type>& ra_idx)
 {
 octave_idx_type i = compute_index (ra_idx);
 if (i < 0)
 return range_error ("T& Sparse<T>::checkelem", ra_idx);
 else
 return elem (i);
 }
 T& elem (octave_idx_type n)
 {
 make_unique ();
+return xelem (n);
+}
+T& elem (octave_idx_type i, octave_idx_type j)
+{
+make_unique ();
+return xelem (i, j);
+}
+T& elem (const Array<octave_idx_type>& ra_idx)
+{ return Sparse<T>::elem (compute_index (ra_idx)); }
+#if defined (BOUNDS_CHECKING)
+T& operator () (octave_idx_type n)
+{
+return checkelem (n);
+}
+T& operator () (octave_idx_type i, octave_idx_type j)
+{
+return checkelem (i, j);
+}
+T& operator () (const Array<octave_idx_type>& ra_idx)
+{
+return checkelem (ra_idx);
+}
+#else
+T& operator () (octave_idx_type n)
+{
+return elem (n);
+}
+T& operator () (octave_idx_type i, octave_idx_type j)
+{
+return elem (i, j);
+}
+T& operator () (const Array<octave_idx_type>& ra_idx)
+{
+return elem (ra_idx);
+}
+#endif
+T checkelem (octave_idx_type n) const
+{
+if (n < 0 || n >= numel ())
+return range_error ("T Sparse<T>::checkelem", n);
+else
 return xelem (n);
 }
-T& elem (octave_idx_type i, octave_idx_type j)
+T checkelem (octave_idx_type i, octave_idx_type j) const
 {
-make_unique ();
+if (i < 0 || j < 0 || i >= dim1 () || j >= dim2 ())
+return range_error ("T Sparse<T>::checkelem", i, j);
+else
 return xelem (i, j);
 }
-T& elem (const Array<octave_idx_type>& ra_idx)
-{ return Sparse<T>::elem (compute_index (ra_idx)); }
-#if defined (BOUNDS_CHECKING)
-T& operator () (octave_idx_type n) { return checkelem (n); }
-T& operator () (octave_idx_type i, octave_idx_type j) { return checkelem (i, j); }
-T& operator () (const Array<octave_idx_type>& ra_idx) { return checkelem (ra_idx); }
-#else
-T& operator () (octave_idx_type n) { return elem (n); }
-T& operator () (octave_idx_type i, octave_idx_type j) { return elem (i, j); }
-T& operator () (const Array<octave_idx_type>& ra_idx) { return elem (ra_idx); }
-#endif
-T checkelem (octave_idx_type n) const
-{
-if (n < 0 || n >= numel ())
-return range_error ("T Sparse<T>::checkelem", n);
-else
-return xelem (n);
-}
-T checkelem (octave_idx_type i, octave_idx_type j) const
-{
-if (i < 0 || j < 0 || i >= dim1 () || j >= dim2 ())
-return range_error ("T Sparse<T>::checkelem", i, j);
-else
-return xelem (i, j);
-}
 T checkelem (const Array<octave_idx_type>& ra_idx) const
 {
 octave_idx_type i = compute_index (ra_idx);
 if (i < 0)
 return range_error ("T Sparse<T>::checkelem", ra_idx);
 else
 return Sparse<T>::elem (i);
 }
 T elem (octave_idx_type n) const { return xelem (n); }
 T elem (octave_idx_type i, octave_idx_type j) const { return xelem (i, j); }
 T elem (const Array<octave_idx_type>& ra_idx) const
 { return Sparse<T>::elem (compute_index (ra_idx)); }
 #if defined (BOUNDS_CHECKING)
 T operator () (octave_idx_type n) const { return checkelem (n); }
-T operator () (octave_idx_type i, octave_idx_type j) const { return checkelem (i, j); }
+T operator () (octave_idx_type i, octave_idx_type j) const
-T operator () (const Array<octave_idx_type>& ra_idx) const { return checkelem (ra_idx); }
+{
+return checkelem (i, j);
+}
+T operator () (const Array<octave_idx_type>& ra_idx) const
+{
+return checkelem (ra_idx);
+}
 #else
 T operator () (octave_idx_type n) const { return elem (n); }
-T operator () (octave_idx_type i, octave_idx_type j) const { return elem (i, j); }
+T operator () (octave_idx_type i, octave_idx_type j) const
-T operator () (const Array<octave_idx_type>& ra_idx) const { return elem (ra_idx); }
+{
+return elem (i, j);
+}
+T operator () (const Array<octave_idx_type>& ra_idx) const
+{
+return elem (ra_idx);
+}
 #endif
 Sparse<T> maybe_compress (bool remove_zeros = false)
 {
 if (remove_zeros)
 make_unique (); // Needs to unshare because elements are removed.
 rep->maybe_compress (remove_zeros);
 return (*this);
 }
 Sparse<T> reshape (const dim_vector& new_dims) const;
 Sparse<T> permute (const Array<octave_idx_type>& vec, bool inv = false) const;
 Sparse<T> ipermute (const Array<octave_idx_type>& vec) const
-{ return permute (vec, true); }
+{
+return permute (vec, true);
+}
 void resize1 (octave_idx_type n);
 void resize (octave_idx_type r, octave_idx_type c);
 void resize (const dim_vector& dv);
 void change_capacity (octave_idx_type nz)
 {
 if (nz < nnz ())
 make_unique (); // Unshare now because elements will be truncated.
 rep->change_length (nz);
 }
 Sparse<T>& insert (const Sparse<T>& a, octave_idx_type r, octave_idx_type c);
 Sparse<T>& insert (const Sparse<T>& a, const Array<octave_idx_type>& idx);
 bool is_square (void) const { return (dim1 () == dim2 ()); }
 T data (octave_idx_type i) const { return rep->data (i); }
 // FIXME -- shouldn't this be returning const T*?
 T* data (void) const { return rep->d; }
 octave_idx_type* ridx (void) { make_unique (); return rep->r; }
-octave_idx_type& ridx (octave_idx_type i) { make_unique (); return rep->ridx (i); }
+octave_idx_type& ridx (octave_idx_type i)
+{
+make_unique (); return rep->ridx (i);
+}
 octave_idx_type* xridx (void) { return rep->r; }
 octave_idx_type& xridx (octave_idx_type i) { return rep->ridx (i); }
 octave_idx_type ridx (octave_idx_type i) const { return rep->cridx (i); }
 // FIXME -- shouldn't this be returning const octave_idx_type*?
 octave_idx_type* ridx (void) const { return rep->r; }
 octave_idx_type* cidx (void) { make_unique (); return rep->c; }
-octave_idx_type& cidx (octave_idx_type i) { make_unique (); return rep->cidx (i); }
+octave_idx_type& cidx (octave_idx_type i)
+{
+make_unique (); return rep->cidx (i);
+}
 octave_idx_type* xcidx (void) { return rep->c; }
 octave_idx_type& xcidx (octave_idx_type i) { return rep->cidx (i); }
 octave_idx_type cidx (octave_idx_type i) const { return rep->ccidx (i); }
 // FIXME -- shouldn't this be returning const octave_idx_type*?
 void delete_elements (const idx_vector& i, const idx_vector& j);
 Sparse<T> index (const idx_vector& i, bool resize_ok = false) const;
-Sparse<T> index (const idx_vector& i, const idx_vector& j, bool resize_ok = false) const;
+Sparse<T> index (const idx_vector& i, const idx_vector& j,
+bool resize_ok = false) const;
 void assign (const idx_vector& i, const Sparse<T>& rhs);
 void assign (const idx_vector& i, const idx_vector& j, const Sparse<T>& rhs);
 // Unsafe.  These functions exist to support the MEX interface.
 // You should not use them anywhere else.
 void *mex_get_data (void) const { return const_cast<T *> (data ()); }
-octave_idx_type *mex_get_ir (void) const { return const_cast<octave_idx_type *> (ridx ()); }
+octave_idx_type *mex_get_ir (void) const
+{
-octave_idx_type *mex_get_jc (void) const { return const_cast<octave_idx_type *> (cidx ()); }
+return const_cast<octave_idx_type *> (ridx ());
+}
+octave_idx_type *mex_get_jc (void) const
+{
+return const_cast<octave_idx_type *> (cidx ());
+}
 Sparse<T> sort (octave_idx_type dim = 0, sortmode mode = ASCENDING) const;
 Sparse<T> sort (Array<octave_idx_type> &sidx, octave_idx_type dim = 0,
 sortmode mode = ASCENDING) const;
 Sparse<T> diag (octave_idx_type k = 0) const;
 // dim = -1 and dim = -2 are special; see Array<T>::cat description.
 static Sparse<T>

Mercurial > hg > octave-lyh

comparison liboctave/Sparse.h @ 14792:8483286c0a13