Mercurial > octave
changeset 29887:be669d935fb6
use m_prefix for data members in array classes
* dim-vector.h, dim-vector.cc, Array.h, Array.cc, Sparse.h, Sparse.cc,
DiagArray2.h, DiagArray2.cc, MDiagArray2.cc, CNDArray.cc,
fCNDArray.cc: Use m_prefix for class data members.
| author | John W. Eaton <jwe@octave.org> |
|---|---|
| date | Thu, 15 Jul 2021 16:12:24 -0400 |
| parents | ebd1ac75e99f |
| children | f2c6ea6c4abc |
| files | liboctave/array/Array.cc liboctave/array/Array.h liboctave/array/CNDArray.cc liboctave/array/DiagArray2.cc liboctave/array/DiagArray2.h liboctave/array/MDiagArray2.cc liboctave/array/Sparse.cc liboctave/array/Sparse.h liboctave/array/dim-vector.cc liboctave/array/dim-vector.h liboctave/array/fCNDArray.cc |
| diffstat | 11 files changed, 489 insertions(+), 485 deletions(-) [+] |
line wrap: on
line diff
--- a/liboctave/array/Array.cc Thu Jul 15 16:11:12 2021 -0400 +++ b/liboctave/array/Array.cc Thu Jul 15 16:12:24 2021 -0400 @@ -49,13 +49,13 @@ // Note we can't specialize a member without also specializing the class. template <typename T> Array<T>::Array (const Array<T>& a, const dim_vector& dv) - : dimensions (dv), rep (a.rep), - slice_data (a.slice_data), slice_len (a.slice_len) + : m_dimensions (dv), m_rep (a.m_rep), + m_slice_data (a.m_slice_data), m_slice_len (a.m_slice_len) { - if (dimensions.safe_numel () != a.numel ()) + if (m_dimensions.safe_numel () != a.numel ()) { - std::string dimensions_str = a.dimensions.str (); - std::string new_dims_str = dimensions.str (); + std::string dimensions_str = a.m_dimensions.str (); + std::string new_dims_str = m_dimensions.str (); (*current_liboctave_error_handler) ("reshape: can't reshape %s array to %s array", @@ -64,52 +64,52 @@ // This goes here because if an exception is thrown by the above, // destructor will be never called. - rep->count++; - dimensions.chop_trailing_singletons (); + m_rep->m_count++; + m_dimensions.chop_trailing_singletons (); } template <typename T> void Array<T>::fill (const T& val) { - if (rep->count > 1) + if (m_rep->m_count > 1) { - --rep->count; - rep = new ArrayRep (numel (), val); - slice_data = rep->data; + --m_rep->m_count; + m_rep = new ArrayRep (numel (), val); + m_slice_data = m_rep->m_data; } else - std::fill_n (slice_data, slice_len, val); + std::fill_n (m_slice_data, m_slice_len, val); } template <typename T> void Array<T>::clear (void) { - if (--rep->count == 0) - delete rep; - - rep = nil_rep (); - rep->count++; - slice_data = rep->data; - slice_len = rep->len; - - dimensions = dim_vector (); + if (--m_rep->m_count == 0) + delete m_rep; + + m_rep = nil_rep (); + m_rep->m_count++; + m_slice_data = m_rep->m_data; + m_slice_len = m_rep->m_len; + + m_dimensions = dim_vector (); } template <typename T> void Array<T>::clear (const dim_vector& dv) { - if (--rep->count == 0) - delete rep; - - rep = new ArrayRep (dv.safe_numel ()); - slice_data = rep->data; - slice_len = rep->len; - - dimensions = dv; - dimensions.chop_trailing_singletons (); + if (--m_rep->m_count == 0) + delete m_rep; + + m_rep = new ArrayRep (dv.safe_numel ()); + m_slice_data = m_rep->m_data; + m_slice_len = m_rep->m_len; + + m_dimensions = dv; + m_dimensions.chop_trailing_singletons (); } template <typename T> @@ -122,16 +122,16 @@ { bool dims_changed = false; - dim_vector new_dimensions = dimensions; + dim_vector new_dimensions = m_dimensions; int k = 0; for (int i = 0; i < ndims (); i++) { - if (dimensions(i) == 1) + if (m_dimensions(i) == 1) dims_changed = true; else - new_dimensions(k++) = dimensions(i); + new_dimensions(k++) = m_dimensions(i); } if (dims_changed) @@ -169,7 +169,7 @@ octave_idx_type Array<T>::compute_index (octave_idx_type i, octave_idx_type j) const { - return ::compute_index (i, j, dimensions); + return ::compute_index (i, j, m_dimensions); } template <typename T> @@ -177,25 +177,25 @@ Array<T>::compute_index (octave_idx_type i, octave_idx_type j, octave_idx_type k) const { - return ::compute_index (i, j, k, dimensions); + return ::compute_index (i, j, k, m_dimensions); } template <typename T> octave_idx_type Array<T>::compute_index (const Array<octave_idx_type>& ra_idx) const { - return ::compute_index (ra_idx, dimensions); + return ::compute_index (ra_idx, m_dimensions); } template <typename T> T& Array<T>::checkelem (octave_idx_type n) { - // Do checks directly to avoid recomputing slice_len. + // Do checks directly to avoid recomputing m_slice_len. if (n < 0) octave::err_invalid_index (n); - if (n >= slice_len) - octave::err_index_out_of_range (1, 1, n+1, slice_len, dimensions); + if (n >= m_slice_len) + octave::err_index_out_of_range (1, 1, n+1, m_slice_len, m_dimensions); return elem (n); } @@ -225,11 +225,11 @@ typename Array<T>::crefT Array<T>::checkelem (octave_idx_type n) const { - // Do checks directly to avoid recomputing slice_len. + // Do checks directly to avoid recomputing m_slice_len. if (n < 0) octave::err_invalid_index (n); - if (n >= slice_len) - octave::err_index_out_of_range (1, 1, n+1, slice_len, dimensions); + if (n >= m_slice_len) + octave::err_index_out_of_range (1, 1, n+1, m_slice_len, m_dimensions); return elem (n); } @@ -260,7 +260,7 @@ Array<T> Array<T>::column (octave_idx_type k) const { - octave_idx_type r = dimensions(0); + octave_idx_type r = m_dimensions(0); return Array<T> (*this, dim_vector (r, 1), k*r, k*r + r); } @@ -269,8 +269,8 @@ Array<T> Array<T>::page (octave_idx_type k) const { - octave_idx_type r = dimensions(0); - octave_idx_type c = dimensions(1); + octave_idx_type r = m_dimensions(0); + octave_idx_type c = m_dimensions(1); octave_idx_type p = r*c; return Array<T> (*this, dim_vector (r, c), k*p, k*p + p); @@ -726,7 +726,7 @@ else { if (i.extent (n) != n) - octave::err_index_out_of_range (1, 1, i.extent (n), n, dimensions); + octave::err_index_out_of_range (1, 1, i.extent (n), n, m_dimensions); dim_vector result_dims = i.orig_dimensions (); octave_idx_type idx_len = i.length (); @@ -765,7 +765,7 @@ Array<T>::index (const octave::idx_vector& i, const octave::idx_vector& j) const { // Get dimensions, allowing Fortran indexing in the 2nd dim. - dim_vector dv = dimensions.redim (2); + dim_vector dv = m_dimensions.redim (2); octave_idx_type r = dv(0); octave_idx_type c = dv(1); Array<T> retval; @@ -778,9 +778,9 @@ else { if (i.extent (r) != r) - octave::err_index_out_of_range (2, 1, i.extent (r), r, dimensions); // throws + octave::err_index_out_of_range (2, 1, i.extent (r), r, m_dimensions); // throws if (j.extent (c) != c) - octave::err_index_out_of_range (2, 2, j.extent (c), c, dimensions); // throws + octave::err_index_out_of_range (2, 2, j.extent (c), c, m_dimensions); // throws octave_idx_type n = numel (); octave_idx_type il = i.length (r); @@ -833,7 +833,7 @@ else if (ial > 0) { // Get dimensions, allowing Fortran indexing in the last dim. - dim_vector dv = dimensions.redim (ial); + dim_vector dv = m_dimensions.redim (ial); // Check for out of bounds conditions. bool all_colons = true; @@ -841,7 +841,7 @@ { if (ia(i).extent (dv(i)) != dv(i)) octave::err_index_out_of_range (ial, i+1, ia(i).extent (dv(i)), dv(i), - dimensions); // throws + m_dimensions); // throws all_colons = all_colons && ia(i).is_colon (); } @@ -923,19 +923,19 @@ if (n == nx - 1 && n > 0) { // Stack "pop" operation. - if (rep->count == 1) - slice_data[slice_len-1] = T (); - slice_len--; - dimensions = dv; + if (m_rep->m_count == 1) + m_slice_data[m_slice_len-1] = T (); + m_slice_len--; + m_dimensions = dv; } else if (n == nx + 1 && nx > 0) { // Stack "push" operation. - if (rep->count == 1 - && slice_data + slice_len < rep->data + rep->len) + if (m_rep->m_count == 1 + && m_slice_data + m_slice_len < m_rep->m_data + m_rep->m_len) { - slice_data[slice_len++] = rfv; - dimensions = dv; + m_slice_data[m_slice_len++] = rfv; + m_dimensions = dv; } else { @@ -1013,14 +1013,14 @@ int dvl = dv.ndims (); if (dvl == 2) resize2 (dv(0), dv(1), rfv); - else if (dimensions != dv) + else if (m_dimensions != dv) { - if (dimensions.ndims () > dvl || dv.any_neg ()) + if (m_dimensions.ndims () > dvl || dv.any_neg ()) octave::err_invalid_resize (); Array<T> tmp (dv); // Prepare for recursive resizing. - rec_resize_helper rh (dv, dimensions.redim (dvl)); + rec_resize_helper rh (dv, m_dimensions.redim (dvl)); // Do it. rh.resize_fill (data (), tmp.fortran_vec (), rfv); @@ -1060,7 +1060,7 @@ Array<T> tmp = *this; if (resize_ok) { - dim_vector dv = dimensions.redim (2); + dim_vector dv = m_dimensions.redim (2); octave_idx_type r = dv(0); octave_idx_type c = dv(1); octave_idx_type rx = i.extent (r); @@ -1089,7 +1089,7 @@ if (resize_ok) { int ial = ia.numel (); - dim_vector dv = dimensions.redim (ial); + dim_vector dv = m_dimensions.redim (ial); dim_vector dvx = dim_vector::alloc (ial); for (int i = 0; i < ial; i++) dvx(i) = ia(i).extent (dv(i)); @@ -1103,7 +1103,7 @@ else tmp.resize (dvx, rfv); - if (tmp.dimensions != dvx) + if (tmp.m_dimensions != dvx) return Array<T> (); } } @@ -1127,7 +1127,7 @@ if (nx != n) { // Optimize case A = []; A(1:n) = X with A empty. - if (dimensions.zero_by_zero () && colon) + if (m_dimensions.zero_by_zero () && colon) { if (rhl == 1) *this = Array<T> (dim_vector (1, nx), rhs(0)); @@ -1146,7 +1146,7 @@ if (rhl == 1) fill (rhs(0)); else - *this = rhs.reshape (dimensions); + *this = rhs.reshape (m_dimensions); } else { @@ -1163,15 +1163,15 @@ Array<T>::assign (const octave::idx_vector& i, const octave::idx_vector& j, const Array<T>& rhs, const T& rfv) { - bool initial_dims_all_zero = dimensions.all_zero (); + bool initial_dims_all_zero = m_dimensions.all_zero (); // 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 dv = m_dimensions.redim (2); + + // Check for out-of-bounds and form resizing m_dimensions. dim_vector rdv; // In the special when all dimensions are zero, colons are allowed @@ -1211,7 +1211,7 @@ } resize (rdv, rfv); - dv = dimensions; + dv = m_dimensions; } if (all_colons) @@ -1220,7 +1220,7 @@ if (isfill) fill (rhs(0)); else - *this = rhs.reshape (dimensions); + *this = rhs.reshape (m_dimensions); } else { @@ -1276,13 +1276,13 @@ assign (ia(0), ia(1), rhs, rfv); else if (ial > 0) { - bool initial_dims_all_zero = dimensions.all_zero (); + bool initial_dims_all_zero = m_dimensions.all_zero (); // 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); + dim_vector dv = m_dimensions.redim (ial); // Get the extents forced by indexing. dim_vector rdv; @@ -1344,7 +1344,7 @@ if (isfill) fill (rhs(0)); else - *this = rhs.reshape (dimensions); + *this = rhs.reshape (m_dimensions); } else { @@ -1406,7 +1406,7 @@ octave_idx_type l, u; bool col_vec = ndims () == 2 && columns () == 1 && rows () != 1; - if (i.is_scalar () && i(0) == n-1 && dimensions.isvector ()) + if (i.is_scalar () && i(0) == n-1 && m_dimensions.isvector ()) { // Stack "pop" operation. resize1 (n-1); @@ -1437,7 +1437,7 @@ if (dim < 0 || dim >= ndims ()) (*current_liboctave_error_handler) ("invalid dimension in delete_elements"); - octave_idx_type n = dimensions(dim); + octave_idx_type n = m_dimensions(dim); if (i.is_colon ()) { *this = Array<T> (); @@ -1455,10 +1455,10 @@ octave_idx_type nd = n + l - u; octave_idx_type dl = 1; octave_idx_type du = 1; - dim_vector rdv = dimensions; + dim_vector rdv = m_dimensions; rdv(dim) = nd; - for (int k = 0; k < dim; k++) dl *= dimensions(k); - for (int k = dim + 1; k < ndims (); k++) du *= dimensions(k); + for (int k = 0; k < dim; k++) dl *= m_dimensions(k); + for (int k = dim + 1; k < ndims (); k++) du *= m_dimensions(k); // Special case deleting a contiguous range. Array<T> tmp = Array<T> (rdv); @@ -1509,7 +1509,7 @@ } if (dim < 0) { - dim_vector dv = dimensions; + dim_vector dv = m_dimensions; dv(0) = 0; *this = Array<T> (dv); } @@ -1538,7 +1538,7 @@ for (int i = 0; i < ial; i++) { - octave_idx_type dim_len = (i >= nd ? 1 : dimensions(i)); + octave_idx_type dim_len = (i >= nd ? 1 : m_dimensions(i)); if (ia(i).length (dim_len) == 0) { @@ -1577,7 +1577,7 @@ idx(0) = i; idx(1) = j; for (int k = 2; k < a.ndims (); k++) - idx(k) = octave::idx_vector (0, a.dimensions(k)); + idx(k) = octave::idx_vector (0, a.m_dimensions(k)); assign (idx, a); } @@ -1746,7 +1746,7 @@ { make_unique (); - return slice_data; + return m_slice_data; } // Non-real types don't have NaNs. @@ -2299,9 +2299,9 @@ if ((numel () == 1 && retval.isempty ()) || (rows () == 0 && dims ().numel (1) == 0)) - retval.dimensions = dim_vector (); + retval.m_dimensions = dim_vector (); else if (rows () == 1 && ndims () == 2) - retval.dimensions = dim_vector (1, retval.numel ()); + retval.m_dimensions = dim_vector (1, retval.numel ()); return retval; } @@ -2740,12 +2740,12 @@ void Array<T>::print_info (std::ostream& os, const std::string& prefix) const { - os << prefix << "rep address: " << rep << '\n' - << prefix << "rep->len: " << rep->len << '\n' - << prefix << "rep->data: " << static_cast<void *> (rep->data) << '\n' - << prefix << "rep->count: " << rep->count << '\n' - << prefix << "slice_data: " << static_cast<void *> (slice_data) << '\n' - << prefix << "slice_len: " << slice_len << '\n'; + os << prefix << "m_rep address: " << m_rep << '\n' + << prefix << "m_rep->m_len: " << m_rep->m_len << '\n' + << prefix << "m_rep->m_data: " << static_cast<void *> (m_rep->m_data) << '\n' + << prefix << "m_rep->m_count: " << m_rep->m_count << '\n' + << prefix << "m_slice_data: " << static_cast<void *> (m_slice_data) << '\n' + << prefix << "m_slice_len: " << m_slice_len << '\n'; // 2D info: // @@ -2756,9 +2756,9 @@ template <typename T> bool Array<T>::optimize_dimensions (const dim_vector& dv) { - bool retval = dimensions == dv; + bool retval = m_dimensions == dv; if (retval) - dimensions = dv; + m_dimensions = dv; return retval; }
--- a/liboctave/array/Array.h Thu Jul 15 16:11:12 2021 -0400 +++ b/liboctave/array/Array.h Thu Jul 15 16:12:24 2021 -0400 @@ -136,46 +136,46 @@ { public: - T *data; - octave_idx_type len; - octave::refcount<octave_idx_type> count; + T *m_data; + octave_idx_type m_len; + octave::refcount<octave_idx_type> m_count; ArrayRep (T *d, octave_idx_type l) - : data (new T [l]), len (l), count (1) + : m_data (new T [l]), m_len (l), m_count (1) { - std::copy_n (d, l, data); + std::copy_n (d, l, m_data); } template <typename U> ArrayRep (U *d, octave_idx_type l) - : data (new T [l]), len (l), count (1) + : m_data (new T [l]), m_len (l), m_count (1) { - std::copy_n (d, l, data); + std::copy_n (d, l, m_data); } // Use new instead of setting data to 0 so that fortran_vec and // data always return valid addresses, even for zero-size arrays. - ArrayRep (void) : data (new T [0]), len (0), count (1) { } + ArrayRep (void) : m_data (new T [0]), m_len (0), m_count (1) { } explicit ArrayRep (octave_idx_type n) - : data (new T [n]), len (n), count (1) { } + : m_data (new T [n]), m_len (n), m_count (1) { } explicit ArrayRep (octave_idx_type n, const T& val) - : data (new T [n]), len (n), count (1) + : m_data (new T [n]), m_len (n), m_count (1) { - std::fill_n (data, n, val); + std::fill_n (m_data, n, val); } ArrayRep (const ArrayRep& a) - : data (new T [a.len]), len (a.len), count (1) + : m_data (new T [a.m_len]), m_len (a.m_len), m_count (1) { - std::copy_n (a.data, a.len, data); + std::copy_n (a.m_data, a.m_len, m_data); } - ~ArrayRep (void) { delete [] data; } + ~ArrayRep (void) { delete [] m_data; } - octave_idx_type numel (void) const { return len; } + octave_idx_type numel (void) const { return m_len; } private: @@ -190,15 +190,15 @@ void make_unique (void) { - if (rep->count > 1) + if (m_rep->m_count > 1) { - ArrayRep *r = new ArrayRep (slice_data, slice_len); + ArrayRep *r = new ArrayRep (m_slice_data, m_slice_len); - if (--rep->count == 0) - delete rep; + if (--m_rep->m_count == 0) + delete m_rep; - rep = r; - slice_data = rep->data; + m_rep = r; + m_slice_data = m_rep->m_data; } } @@ -217,27 +217,27 @@ protected: - dim_vector dimensions; + dim_vector m_dimensions; - typename Array<T>::ArrayRep *rep; + typename Array<T>::ArrayRep *m_rep; // Rationale: - // slice_data is a pointer to rep->data, denoting together with slice_len the + // m_slice_data is a pointer to m_rep->m_data, denoting together with m_slice_len the // actual portion of the data referenced by this Array<T> object. This // allows to make shallow copies not only of a whole array, but also of - // contiguous subranges. Every time rep is directly manipulated, slice_data - // and slice_len need to be properly updated. + // contiguous subranges. Every time m_rep is directly manipulated, m_slice_data + // and m_slice_len need to be properly updated. - T *slice_data; - octave_idx_type slice_len; + T *m_slice_data; + octave_idx_type m_slice_len; //! slice constructor Array (const Array<T>& a, const dim_vector& dv, octave_idx_type l, octave_idx_type u) - : dimensions (dv), rep(a.rep), slice_data (a.slice_data+l), slice_len (u-l) + : m_dimensions (dv), m_rep(a.m_rep), m_slice_data (a.m_slice_data+l), m_slice_len (u-l) { - rep->count++; - dimensions.chop_trailing_singletons (); + m_rep->m_count++; + m_dimensions.chop_trailing_singletons (); } private: @@ -248,37 +248,37 @@ //! For jit support Array (T *sdata, octave_idx_type slen, octave_idx_type *adims, void *arep) - : dimensions (adims), - rep (reinterpret_cast<typename Array<T>::ArrayRep *> (arep)), - slice_data (sdata), slice_len (slen) { } + : m_dimensions (adims), + m_rep (reinterpret_cast<typename Array<T>::ArrayRep *> (arep)), + m_slice_data (sdata), m_slice_len (slen) { } public: //! Empty ctor (0 by 0). Array (void) - : dimensions (), rep (nil_rep ()), slice_data (rep->data), - slice_len (rep->len) + : m_dimensions (), m_rep (nil_rep ()), m_slice_data (m_rep->m_data), + m_slice_len (m_rep->m_len) { - rep->count++; + m_rep->m_count++; } //! nD uninitialized ctor. explicit Array (const dim_vector& dv) - : dimensions (dv), - rep (new typename Array<T>::ArrayRep (dv.safe_numel ())), - slice_data (rep->data), slice_len (rep->len) + : m_dimensions (dv), + m_rep (new typename Array<T>::ArrayRep (dv.safe_numel ())), + m_slice_data (m_rep->m_data), m_slice_len (m_rep->m_len) { - dimensions.chop_trailing_singletons (); + m_dimensions.chop_trailing_singletons (); } //! nD initialized ctor. explicit Array (const dim_vector& dv, const T& val) - : dimensions (dv), - rep (new typename Array<T>::ArrayRep (dv.safe_numel ())), - slice_data (rep->data), slice_len (rep->len) + : m_dimensions (dv), + m_rep (new typename Array<T>::ArrayRep (dv.safe_numel ())), + m_slice_data (m_rep->m_data), m_slice_len (m_rep->m_len) { fill (val); - dimensions.chop_trailing_singletons (); + m_dimensions.chop_trailing_singletons (); } //! Reshape constructor. @@ -291,26 +291,26 @@ //! Type conversion case. template <typename U> Array (const Array<U>& a) - : dimensions (a.dims ()), - rep (new typename Array<T>::ArrayRep (a.data (), a.numel ())), - slice_data (rep->data), slice_len (rep->len) + : m_dimensions (a.dims ()), + m_rep (new typename Array<T>::ArrayRep (a.data (), a.numel ())), + m_slice_data (m_rep->m_data), m_slice_len (m_rep->m_len) { } //! No type conversion case. Array (const Array<T>& a) - : dimensions (a.dimensions), rep (a.rep), slice_data (a.slice_data), - slice_len (a.slice_len) + : m_dimensions (a.m_dimensions), m_rep (a.m_rep), m_slice_data (a.m_slice_data), + m_slice_len (a.m_slice_len) { - rep->count++; + m_rep->m_count++; } Array (Array<T>&& a) - : dimensions (std::move (a.dimensions)), rep (a.rep), - slice_data (a.slice_data), slice_len (a.slice_len) + : m_dimensions (std::move (a.m_dimensions)), m_rep (a.m_rep), + m_slice_data (a.m_slice_data), m_slice_len (a.m_slice_len) { - a.rep = nullptr; - a.slice_data = nullptr; - a.slice_len = 0; + a.m_rep = nullptr; + a.m_slice_data = nullptr; + a.m_slice_len = 0; } public: @@ -318,26 +318,26 @@ virtual ~Array (void) { // Because we define a move constructor and a move assignment - // operator, rep may be a nullptr here. We should only need to + // operator, m_rep may be a nullptr here. We should only need to // protect the move assignment operator in a similar way. - if (rep && --rep->count == 0) - delete rep; + if (m_rep && --m_rep->m_count == 0) + delete m_rep; } Array<T>& operator = (const Array<T>& a) { if (this != &a) { - if (--rep->count == 0) - delete rep; + if (--m_rep->m_count == 0) + delete m_rep; - rep = a.rep; - rep->count++; + m_rep = a.m_rep; + m_rep->m_count++; - dimensions = a.dimensions; - slice_data = a.slice_data; - slice_len = a.slice_len; + m_dimensions = a.m_dimensions; + m_slice_data = a.m_slice_data; + m_slice_len = a.m_slice_len; } return *this; @@ -347,22 +347,22 @@ { if (this != &a) { - dimensions = std::move (a.dimensions); + m_dimensions = std::move (a.m_dimensions); // Because we define a move constructor and a move assignment - // operator, rep may be a nullptr here. We should only need to + // operator, m_rep may be a nullptr here. We should only need to // protect the destructor in a similar way. - if (rep && --rep->count == 0) - delete rep; + if (m_rep && --m_rep->m_count == 0) + delete m_rep; - rep = a.rep; - slice_data = a.slice_data; - slice_len = a.slice_len; + m_rep = a.m_rep; + m_slice_data = a.m_slice_data; + m_slice_len = a.m_slice_len; - a.rep = nullptr; - a.slice_data = nullptr; - a.slice_len = 0; + a.m_rep = nullptr; + a.m_slice_data = nullptr; + a.m_slice_len = 0; } return *this; @@ -377,15 +377,15 @@ { clear (dim_vector (r, c)); } //! Number of elements in the array. - octave_idx_type numel (void) const { return slice_len; } + octave_idx_type numel (void) const { return m_slice_len; } //@} //! Return the array as a column vector. Array<T> as_column (void) const { Array<T> retval (*this); - if (dimensions.ndims () != 2 || dimensions(1) != 1) - retval.dimensions = dim_vector (numel (), 1); + if (m_dimensions.ndims () != 2 || m_dimensions(1) != 1) + retval.m_dimensions = dim_vector (numel (), 1); return retval; } @@ -394,8 +394,8 @@ Array<T> as_row (void) const { Array<T> retval (*this); - if (dimensions.ndims () != 2 || dimensions(0) != 1) - retval.dimensions = dim_vector (1, numel ()); + if (m_dimensions.ndims () != 2 || m_dimensions(0) != 1) + retval.m_dimensions = dim_vector (1, numel ()); return retval; } @@ -404,8 +404,8 @@ Array<T> as_matrix (void) const { Array<T> retval (*this); - if (dimensions.ndims () != 2) - retval.dimensions = dimensions.redim (2); + if (m_dimensions.ndims () != 2) + retval.m_dimensions = m_dimensions.redim (2); return retval; } @@ -414,7 +414,7 @@ //! //! Get the first dimension of the array (number of rows) //@{ - octave_idx_type dim1 (void) const { return dimensions(0); } + octave_idx_type dim1 (void) const { return m_dimensions(0); } octave_idx_type rows (void) const { return dim1 (); } //@} @@ -422,7 +422,7 @@ //! //! Get the second dimension of the array (number of columns) //@{ - octave_idx_type dim2 (void) const { return dimensions(1); } + octave_idx_type dim2 (void) const { return m_dimensions(1); } octave_idx_type cols (void) const { return dim2 (); } octave_idx_type columns (void) const { return dim2 (); } //@} @@ -431,7 +431,7 @@ //! //! Get the third dimension of the array (number of pages) //@{ - octave_idx_type dim3 (void) const { return dimensions(2); } + octave_idx_type dim3 (void) const { return m_dimensions(2); } octave_idx_type pages (void) const { return dim3 (); } //@} @@ -446,14 +446,14 @@ { // Should we throw for negative values? // Should >= ndims () be handled by dim_vector operator() instead ? - return d >= ndims () ? 1 : dimensions(d); + return d >= ndims () ? 1 : m_dimensions(d); } std::size_t byte_size (void) const { return static_cast<std::size_t> (numel ()) * sizeof (T); } //! Return a const-reference so that dims ()(i) works efficiently. - const dim_vector& dims (void) const { return dimensions; } + const dim_vector& dims (void) const { return m_dimensions; } //! Chop off leading singleton dimensions OCTARRAY_API Array<T> squeeze (void) const; @@ -465,12 +465,12 @@ octave_idx_type compute_index_unchecked (const Array<octave_idx_type>& ra_idx) const - { return dimensions.compute_index (ra_idx.data (), ra_idx.numel ()); } + { return m_dimensions.compute_index (ra_idx.data (), ra_idx.numel ()); } // No checking, even for multiple references, ever. - T& xelem (octave_idx_type n) { return slice_data[n]; } - crefT xelem (octave_idx_type n) const { return slice_data[n]; } + T& xelem (octave_idx_type n) { return m_slice_data[n]; } + crefT xelem (octave_idx_type n) const { return m_slice_data[n]; } T& xelem (octave_idx_type i, octave_idx_type j) { return xelem (dim1 ()*j+i); } @@ -574,22 +574,22 @@ bool isempty (void) const { return numel () == 0; } - bool isvector (void) const { return dimensions.isvector (); } + bool isvector (void) const { return m_dimensions.isvector (); } - bool is_nd_vector (void) const { return dimensions.is_nd_vector (); } + bool is_nd_vector (void) const { return m_dimensions.is_nd_vector (); } OCTARRAY_API Array<T> transpose (void) const; OCTARRAY_API Array<T> hermitian (T (*fcn) (const T&) = nullptr) const; - const T * data (void) const { return slice_data; } + const T * data (void) const { return m_slice_data; } const T * fortran_vec (void) const { return data (); } OCTARRAY_API T * fortran_vec (void); - bool is_shared (void) { return rep->count > 1; } + bool is_shared (void) { return m_rep->m_count > 1; } - int ndims (void) const { return dimensions.ndims (); } + int ndims (void) const { return m_dimensions.ndims (); } //@{ //! Indexing without resizing. @@ -691,12 +691,12 @@ void maybe_economize (void) { - if (rep->count == 1 && slice_len != rep->len) + if (m_rep->m_count == 1 && m_slice_len != m_rep->m_len) { - ArrayRep *new_rep = new ArrayRep (slice_data, slice_len); - delete rep; - rep = new_rep; - slice_data = rep->data; + ArrayRep *new_rep = new ArrayRep (m_slice_data, m_slice_len); + delete m_rep; + m_rep = new_rep; + m_slice_data = m_rep->m_data; } } @@ -835,7 +835,7 @@ template <typename U> friend class Array; - //! Returns true if this->dims () == dv, and if so, replaces this->dimensions + //! Returns true if this->dims () == dv, and if so, replaces this->m_dimensions //! by a shallow copy of dv. This is useful for maintaining several arrays //! with supposedly equal dimensions (e.g. structs in the interpreter). OCTARRAY_API bool optimize_dimensions (const dim_vector& dv); @@ -843,13 +843,13 @@ //@{ //! WARNING: Only call these functions from jit - int jit_ref_count (void) { return rep->count.value (); } + int jit_ref_count (void) { return m_rep->m_count.value (); } - T * jit_slice_data (void) const { return slice_data; } + T * jit_slice_data (void) const { return m_slice_data; } - octave_idx_type * jit_dimensions (void) const { return dimensions.to_jit (); } + octave_idx_type * jit_dimensions (void) const { return m_dimensions.to_jit (); } - void * jit_array_rep (void) const { return rep; } + void * jit_array_rep (void) const { return m_rep; } //@} private: @@ -862,12 +862,12 @@ template<typename T> template<template <typename...> class Container> Array<T>::Array (const Container<T>& a, const dim_vector& dv) - : dimensions (dv), rep (new typename Array<T>::ArrayRep (dv.safe_numel ())), - slice_data (rep->data), slice_len (rep->len) + : m_dimensions (dv), m_rep (new typename Array<T>::ArrayRep (dv.safe_numel ())), + m_slice_data (m_rep->m_data), m_slice_len (m_rep->m_len) { - if (dimensions.safe_numel () != octave_idx_type (a.size ())) + if (m_dimensions.safe_numel () != octave_idx_type (a.size ())) { - std::string new_dims_str = dimensions.str (); + std::string new_dims_str = m_dimensions.str (); (*current_liboctave_error_handler) ("reshape: can't reshape %zi elements into %s array", @@ -876,9 +876,9 @@ octave_idx_type i = 0; for (const T& x : a) - slice_data[i++] = x; + m_slice_data[i++] = x; - dimensions.chop_trailing_singletons (); + m_dimensions.chop_trailing_singletons (); } template <typename T>
--- a/liboctave/array/CNDArray.cc Thu Jul 15 16:11:12 2021 -0400 +++ b/liboctave/array/CNDArray.cc Thu Jul 15 16:12:24 2021 -0400 @@ -508,10 +508,11 @@ ComplexNDArray::insert (const NDArray& a, octave_idx_type r, octave_idx_type c) { dim_vector a_dv = a.dims (); + dim_vector dv = dims (); int n = a_dv.ndims (); - if (n != dimensions.ndims ()) + if (n != dv.ndims ()) (*current_liboctave_error_handler) ("Array<T>::insert: invalid indexing operation"); @@ -522,7 +523,7 @@ for (int i = 0; i < n; i++) { - if (a_ra_idx(i) < 0 || (a_ra_idx(i) + a_dv(i)) > dimensions(i)) + if (a_ra_idx(i) < 0 || (a_ra_idx(i) + a_dv(i)) > dv(i)) (*current_liboctave_error_handler) ("Array<T>::insert: range error for insert"); }
--- a/liboctave/array/DiagArray2.cc Thu Jul 15 16:11:12 2021 -0400 +++ b/liboctave/array/DiagArray2.cc Thu Jul 15 16:12:24 2021 -0400 @@ -38,7 +38,7 @@ template <typename T> DiagArray2<T>::DiagArray2 (const Array<T>& a, octave_idx_type r, octave_idx_type c) - : Array<T> (a.as_column ()), d1 (r), d2 (c) + : Array<T> (a.as_column ()), m_d1 (r), m_d2 (c) { octave_idx_type rcmin = std::min (r, c); if (rcmin != a.numel ()) @@ -68,14 +68,14 @@ DiagArray2<T> DiagArray2<T>::transpose (void) const { - return DiagArray2<T> (*this, d2, d1); + return DiagArray2<T> (*this, m_d2, m_d1); } template <typename T> DiagArray2<T> DiagArray2<T>::hermitian (T (* fcn) (const T&)) const { - return DiagArray2<T> (Array<T>::template map<T> (fcn), d2, d1); + return DiagArray2<T> (Array<T>::template map<T> (fcn), m_d2, m_d1); } // A two-dimensional array with diagonal elements only. @@ -107,7 +107,7 @@ if (r != dim1 () || c != dim2 ()) { Array<T>::resize (dim_vector (std::min (r, c), 1), rfv); - d1 = r; d2 = c; + m_d1 = r; m_d2 = c; } }
--- a/liboctave/array/DiagArray2.h Thu Jul 15 16:11:12 2021 -0400 +++ b/liboctave/array/DiagArray2.h Thu Jul 15 16:12:24 2021 -0400 @@ -42,32 +42,32 @@ DiagArray2 : protected Array<T> { protected: - octave_idx_type d1, d2; + octave_idx_type m_d1, m_d2; public: using typename Array<T>::element_type; DiagArray2 (void) - : Array<T> (), d1 (0), d2 (0) { } + : Array<T> (), m_d1 (0), m_d2 (0) { } DiagArray2 (octave_idx_type r, octave_idx_type c) - : Array<T> (dim_vector (std::min (r, c), 1)), d1 (r), d2 (c) { } + : Array<T> (dim_vector (std::min (r, c), 1)), m_d1 (r), m_d2 (c) { } DiagArray2 (octave_idx_type r, octave_idx_type c, const T& val) - : Array<T> (dim_vector (std::min (r, c), 1), val), d1 (r), d2 (c) { } + : Array<T> (dim_vector (std::min (r, c), 1), val), m_d1 (r), m_d2 (c) { } explicit DiagArray2 (const Array<T>& a) - : Array<T> (a.as_column ()), d1 (a.numel ()), d2 (a.numel ()) { } + : Array<T> (a.as_column ()), m_d1 (a.numel ()), m_d2 (a.numel ()) { } DiagArray2 (const Array<T>& a, octave_idx_type r, octave_idx_type c); DiagArray2 (const DiagArray2<T>& a) - : Array<T> (a), d1 (a.d1), d2 (a.d2) { } + : Array<T> (a), m_d1 (a.m_d1), m_d2 (a.m_d2) { } template <typename U> DiagArray2 (const DiagArray2<U>& a) - : Array<T> (a.extract_diag ()), d1 (a.dim1 ()), d2 (a.dim2 ()) { } + : Array<T> (a.extract_diag ()), m_d1 (a.dim1 ()), m_d2 (a.dim2 ()) { } ~DiagArray2 (void) = default; @@ -76,15 +76,15 @@ if (this != &a) { Array<T>::operator = (a); - d1 = a.d1; - d2 = a.d2; + m_d1 = a.m_d1; + m_d2 = a.m_d2; } return *this; } - octave_idx_type dim1 (void) const { return d1; } - octave_idx_type dim2 (void) const { return d2; } + octave_idx_type dim1 (void) const { return m_d1; } + octave_idx_type dim2 (void) const { return m_d2; } octave_idx_type rows (void) const { return dim1 (); } octave_idx_type cols (void) const { return dim2 (); } @@ -98,7 +98,7 @@ std::size_t byte_size (void) const { return Array<T>::byte_size (); } - dim_vector dims (void) const { return dim_vector (d1, d2); } + dim_vector dims (void) const { return dim_vector (m_d1, m_d2); } bool isempty (void) const { return numel () == 0; }
--- a/liboctave/array/MDiagArray2.cc Thu Jul 15 16:11:12 2021 -0400 +++ b/liboctave/array/MDiagArray2.cc Thu Jul 15 16:12:24 2021 -0400 @@ -54,12 +54,13 @@ // Element by element MDiagArray2 by scalar ops. -#define MARRAY_DAS_OP(OP, FN) \ - template <typename T> \ - MDiagArray2<T> \ - operator OP (const MDiagArray2<T>& a, const T& s) \ - { \ - return MDiagArray2<T> (do_ms_binary_op<T, T, T> (a, s, FN), a.d1, a.d2); \ +#define MARRAY_DAS_OP(OP, FN) \ + template <typename T> \ + MDiagArray2<T> \ + operator OP (const MDiagArray2<T>& a, const T& s) \ + { \ + return MDiagArray2<T> (do_ms_binary_op<T, T, T> (a, s, FN), \ + a.m_d1, a.m_d2); \ } MARRAY_DAS_OP (*, mx_inline_mul) @@ -72,7 +73,7 @@ operator * (const T& s, const MDiagArray2<T>& a) { return MDiagArray2<T> (do_sm_binary_op<T, T, T> (s, a, mx_inline_mul), - a.d1, a.d2); + a.m_d1, a.m_d2); } // Element by element MDiagArray2 by MDiagArray2 ops. @@ -82,10 +83,11 @@ MDiagArray2<T> \ FCN (const MDiagArray2<T>& a, const MDiagArray2<T>& b) \ { \ - if (a.d1 != b.d1 || a.d2 != b.d2) \ - octave::err_nonconformant (#FCN, a.d1, a.d2, b.d1, b.d2); \ + if (a.m_d1 != b.m_d1 || a.m_d2 != b.m_d2) \ + octave::err_nonconformant (#FCN, a.m_d1, a.m_d2, b.m_d1, b.m_d2); \ \ - return MDiagArray2<T> (do_mm_binary_op<T, T, T> (a, b, FN, FN, FN, #FCN), a.d1, a.d2); \ + return MDiagArray2<T> (do_mm_binary_op<T, T, T> (a, b, FN, FN, FN, #FCN), \ + a.m_d1, a.m_d2); \ } MARRAY_DADA_OP (operator +, +, mx_inline_add) @@ -106,5 +108,5 @@ operator - (const MDiagArray2<T>& a) { return MDiagArray2<T> (do_mx_unary_op<T, T> (a, mx_inline_uminus), - a.d1, a.d2); + a.m_d1, a.m_d2); }
--- a/liboctave/array/Sparse.cc Thu Jul 15 16:11:12 2021 -0400 +++ b/liboctave/array/Sparse.cc Thu Jul 15 16:12:24 2021 -0400 @@ -68,39 +68,39 @@ { octave_idx_type i; - if (nzmx <= 0) + if (m_nzmx <= 0) (*current_liboctave_error_handler) ("Sparse::SparseRep::elem (octave_idx_type, octave_idx_type): sparse matrix filled"); - for (i = c[_c]; i < c[_c + 1]; i++) - if (r[i] == _r) - return d[i]; - else if (r[i] > _r) + for (i = m_c[_c]; i < m_c[_c + 1]; i++) + if (m_r[i] == _r) + return m_d[i]; + else if (m_r[i] > _r) break; // Ok, If we've gotten here, we're in trouble. Have to create a // new element in the sparse array. This' gonna be slow!!! - if (c[ncols] == nzmx) + if (m_c[m_ncols] == m_nzmx) (*current_liboctave_error_handler) ("Sparse::SparseRep::elem (octave_idx_type, octave_idx_type): sparse matrix filled"); - octave_idx_type to_move = c[ncols] - i; + octave_idx_type to_move = m_c[m_ncols] - i; if (to_move != 0) { - for (octave_idx_type j = c[ncols]; j > i; j--) + for (octave_idx_type j = m_c[m_ncols]; j > i; j--) { - d[j] = d[j-1]; - r[j] = r[j-1]; + m_d[j] = m_d[j-1]; + m_r[j] = m_r[j-1]; } } - for (octave_idx_type j = _c + 1; j < ncols + 1; j++) - c[j] = c[j] + 1; - - d[i] = 0.; - r[i] = _r; - - return d[i]; + for (octave_idx_type j = _c + 1; j < m_ncols + 1; j++) + m_c[j] = m_c[j] + 1; + + m_d[i] = 0.; + m_r[i] = _r; + + return m_d[i]; } template <typename T> @@ -108,10 +108,10 @@ T Sparse<T>::SparseRep::celem (octave_idx_type _r, octave_idx_type _c) const { - if (nzmx > 0) - for (octave_idx_type i = c[_c]; i < c[_c + 1]; i++) - if (r[i] == _r) - return d[i]; + if (m_nzmx > 0) + for (octave_idx_type i = m_c[_c]; i < m_c[_c + 1]; i++) + if (m_r[i] == _r) + return m_d[i]; return T (); } @@ -124,20 +124,20 @@ { octave_idx_type i = 0; octave_idx_type k = 0; - for (octave_idx_type j = 1; j <= ncols; j++) + for (octave_idx_type j = 1; j <= m_ncols; j++) { - octave_idx_type u = c[j]; + octave_idx_type u = m_c[j]; for (; i < u; i++) - if (d[i] != T ()) + if (m_d[i] != T ()) { - d[k] = d[i]; - r[k++] = r[i]; + m_d[k] = m_d[i]; + m_r[k++] = m_r[i]; } - c[j] = k; + m_c[j] = k; } } - change_length (c[ncols]); + change_length (m_c[m_ncols]); } template <typename T> @@ -145,32 +145,32 @@ void Sparse<T>::SparseRep::change_length (octave_idx_type nz) { - for (octave_idx_type j = ncols; j > 0 && c[j] > nz; j--) - c[j] = nz; + for (octave_idx_type j = m_ncols; j > 0 && m_c[j] > nz; j--) + m_c[j] = nz; // Always preserve space for 1 element. nz = (nz > 0 ? nz : 1); // Skip reallocation if we have less than 1/frac extra elements to discard. static const int frac = 5; - if (nz > nzmx || nz < nzmx - nzmx/frac) + if (nz > m_nzmx || nz < m_nzmx - m_nzmx/frac) { // Reallocate. - octave_idx_type min_nzmx = std::min (nz, nzmx); + octave_idx_type min_nzmx = std::min (nz, m_nzmx); octave_idx_type *new_ridx = new octave_idx_type [nz]; - std::copy_n (r, min_nzmx, new_ridx); - - delete [] r; - r = new_ridx; + std::copy_n (m_r, min_nzmx, new_ridx); + + delete [] m_r; + m_r = new_ridx; T *new_data = new T [nz]; - std::copy_n (d, min_nzmx, new_data); - - delete [] d; - d = new_data; - - nzmx = nz; + std::copy_n (m_d, min_nzmx, new_data); + + delete [] m_d; + m_d = new_data; + + m_nzmx = nz; } } @@ -179,7 +179,7 @@ bool Sparse<T>::SparseRep::indices_ok (void) const { - return sparse_indices_ok (r, c, nrows, ncols, nnz ()); + return sparse_indices_ok (m_r, m_c, m_nrows, m_ncols, nnz ()); } template <typename T> @@ -190,7 +190,7 @@ octave_idx_type nz = nnz (); for (octave_idx_type i = 0; i < nz; i++) - if (octave::math::isnan (d[i])) + if (octave::math::isnan (m_d[i])) return true; return false; @@ -199,11 +199,11 @@ template <typename T> OCTAVE_API Sparse<T>::Sparse (octave_idx_type nr, octave_idx_type nc, T val) - : rep (nullptr), dimensions (dim_vector (nr, nc)) + : m_rep (nullptr), m_dimensions (dim_vector (nr, nc)) { if (val != T ()) { - rep = new typename Sparse<T>::SparseRep (nr, nc, dimensions.safe_numel ()); + m_rep = new typename Sparse<T>::SparseRep (nr, nc, m_dimensions.safe_numel ()); octave_idx_type ii = 0; xcidx (0) = 0; @@ -219,7 +219,7 @@ } else { - rep = new typename Sparse<T>::SparseRep (nr, nc, 0); + m_rep = new typename Sparse<T>::SparseRep (nr, nc, 0); for (octave_idx_type j = 0; j < nc+1; j++) xcidx (j) = 0; } @@ -228,8 +228,8 @@ template <typename T> OCTAVE_API Sparse<T>::Sparse (const PermMatrix& a) - : rep (new typename Sparse<T>::SparseRep (a.rows (), a.cols (), a.rows ())), - dimensions (dim_vector (a.rows (), a.cols ())) + : m_rep (new typename Sparse<T>::SparseRep (a.rows (), a.cols (), a.rows ())), + m_dimensions (dim_vector (a.rows (), a.cols ())) { octave_idx_type n = a.rows (); for (octave_idx_type i = 0; i <= n; i++) @@ -247,19 +247,19 @@ template <typename T> OCTAVE_API Sparse<T>::Sparse (const dim_vector& dv) - : rep (nullptr), dimensions (dv) + : m_rep (nullptr), m_dimensions (dv) { if (dv.ndims () != 2) (*current_liboctave_error_handler) ("Sparse::Sparse (const dim_vector&): dimension mismatch"); - rep = new typename Sparse<T>::SparseRep (dv(0), dv(1), 0); + m_rep = new typename Sparse<T>::SparseRep (dv(0), dv(1), 0); } template <typename T> OCTAVE_API Sparse<T>::Sparse (const Sparse<T>& a, const dim_vector& dv) - : rep (nullptr), dimensions (dv) + : m_rep (nullptr), m_dimensions (dv) { // Work in unsigned long long to avoid overflow issues with numel @@ -279,7 +279,7 @@ octave_idx_type old_nr = old_dims(0); octave_idx_type old_nc = old_dims(1); - rep = new typename Sparse<T>::SparseRep (new_nr, new_nc, new_nzmx); + m_rep = new typename Sparse<T>::SparseRep (new_nr, new_nc, new_nzmx); octave_idx_type kk = 0; xcidx (0) = 0; @@ -305,7 +305,7 @@ const octave::idx_vector& c, octave_idx_type nr, octave_idx_type nc, bool sum_terms, octave_idx_type nzm) - : rep (nullptr), dimensions () + : m_rep (nullptr), m_dimensions () { if (nr < 0) nr = r.extent (0); @@ -321,7 +321,7 @@ ("sparse: column index %" OCTAVE_IDX_TYPE_FORMAT " out of bound " "%" OCTAVE_IDX_TYPE_FORMAT, r.extent (nc), nc); - dimensions = dim_vector (nr, nc); + m_dimensions = dim_vector (nr, nc); octave_idx_type n = a.numel (); octave_idx_type rl = r.length (nr); @@ -338,8 +338,8 @@ if ((rl != 1 && rl != n) || (cl != 1 && cl != n)) (*current_liboctave_error_handler) ("sparse: dimension mismatch"); - // Only create rep after input validation to avoid memory leak. - rep = new typename Sparse<T>::SparseRep (nr, nc, (nzm > 0 ? nzm : 0)); + // Only create m_rep after input validation to avoid memory leak. + m_rep = new typename Sparse<T>::SparseRep (nr, nc, (nzm > 0 ? nzm : 0)); if (rl <= 1 && cl <= 1) { @@ -670,9 +670,9 @@ template <typename T> OCTAVE_API Sparse<T>::Sparse (const Array<T>& a) - : rep (nullptr), dimensions (a.dims ()) + : m_rep (nullptr), m_dimensions (a.dims ()) { - if (dimensions.ndims () > 2) + if (m_dimensions.ndims () > 2) (*current_liboctave_error_handler) ("Sparse::Sparse (const Array<T>&): dimension mismatch"); @@ -686,7 +686,7 @@ if (a(i) != T ()) new_nzmx++; - rep = new typename Sparse<T>::SparseRep (nr, nc, new_nzmx); + m_rep = new typename Sparse<T>::SparseRep (nr, nc, new_nzmx); octave_idx_type ii = 0; xcidx (0) = 0; @@ -706,8 +706,8 @@ OCTAVE_API Sparse<T>::~Sparse (void) { - if (--rep->count == 0) - delete rep; + if (--m_rep->m_count == 0) + delete m_rep; } template <typename T> @@ -716,13 +716,13 @@ { if (this != &a) { - if (--rep->count == 0) - delete rep; - - rep = a.rep; - rep->count++; - - dimensions = a.dimensions; + if (--m_rep->m_count == 0) + delete m_rep; + + m_rep = a.m_rep; + m_rep->m_count++; + + m_dimensions = a.m_dimensions; } return *this; @@ -733,7 +733,7 @@ octave_idx_type Sparse<T>::compute_index (const Array<octave_idx_type>& ra_idx) const { - octave_idx_type n = dimensions.ndims (); + octave_idx_type n = m_dimensions.ndims (); if (n <= 0 || n != ra_idx.numel ()) (*current_liboctave_error_handler) @@ -745,7 +745,7 @@ while (--n >= 0) { - retval *= dimensions(n); + retval *= m_dimensions(n); retval += ra_idx(n); } @@ -860,9 +860,9 @@ dims2.resize (2); } - if (dimensions != dims2) + if (m_dimensions != dims2) { - if (dimensions.numel () == dims2.numel ()) + if (m_dimensions.numel () == dims2.numel ()) { octave_idx_type new_nnz = nnz (); octave_idx_type new_nr = dims2 (0); @@ -906,7 +906,7 @@ } else { - std::string dimensions_str = dimensions.str (); + std::string dimensions_str = m_dimensions.str (); std::string new_dims_str = new_dims.str (); (*current_liboctave_error_handler) @@ -993,7 +993,7 @@ if (r == dim1 () && c == dim2 ()) return; - // This wouldn't be necessary for r >= rows () if nrows wasn't part of the + // This wouldn't be necessary for r >= rows () if m_nrows wasn't part of the // Sparse rep. It is not good for anything in there. make_unique (); @@ -1001,7 +1001,7 @@ { octave_idx_type i = 0; octave_idx_type k = 0; - for (octave_idx_type j = 1; j <= rep->ncols; j++) + for (octave_idx_type j = 1; j <= m_rep->m_ncols; j++) { octave_idx_type u = xcidx (j); for (; i < u; i++) @@ -1014,23 +1014,23 @@ } } - rep->nrows = dimensions(0) = r; - - if (c != rep->ncols) + m_rep->m_nrows = m_dimensions(0) = r; + + if (c != m_rep->m_ncols) { octave_idx_type *new_cidx = new octave_idx_type [c+1]; - std::copy_n (rep->c, std::min (c, rep->ncols) + 1, new_cidx); - delete [] rep->c; - rep->c = new_cidx; - - if (c > rep->ncols) - std::fill_n (rep->c + rep->ncols + 1, c - rep->ncols, - rep->c[rep->ncols]); + std::copy_n (m_rep->m_c, std::min (c, m_rep->m_ncols) + 1, new_cidx); + delete [] m_rep->m_c; + m_rep->m_c = new_cidx; + + if (c > m_rep->m_ncols) + std::fill_n (m_rep->m_c + m_rep->m_ncols + 1, c - m_rep->m_ncols, + m_rep->m_c[m_rep->m_ncols]); } - rep->ncols = dimensions(1) = c; - - rep->change_length (rep->nnz ()); + m_rep->m_ncols = m_dimensions(1) = c; + + m_rep->change_length (m_rep->nnz ()); } template <typename T> @@ -1058,8 +1058,8 @@ nel++; Sparse<T> tmp (*this); - --rep->count; - rep = new typename Sparse<T>::SparseRep (nr, nc, nel); + --m_rep->m_count; + m_rep = new typename Sparse<T>::SparseRep (nr, nc, nel); for (octave_idx_type i = 0; i < tmp.cidx (c); i++) { @@ -1901,7 +1901,7 @@ if (idx.is_colon ()) { - *this = rhs.reshape (dimensions); + *this = rhs.reshape (m_dimensions); } else if (nc == 1 && rhs.cols () == 1) { @@ -1999,7 +1999,7 @@ } else { - dim_vector save_dims = dimensions; + dim_vector save_dims = m_dimensions; *this = index (octave::idx_vector::colon); assign (idx, rhs.index (octave::idx_vector::colon)); *this = reshape (save_dims); @@ -3081,14 +3081,14 @@ void Sparse<T>::print_info (std::ostream& os, const std::string& prefix) const { - os << prefix << "rep address: " << rep << "\n" - << prefix << "rep->nzmx: " << rep->nzmx << "\n" - << prefix << "rep->nrows: " << rep->nrows << "\n" - << prefix << "rep->ncols: " << rep->ncols << "\n" - << prefix << "rep->data: " << static_cast<void *> (rep->d) << "\n" - << prefix << "rep->ridx: " << static_cast<void *> (rep->r) << "\n" - << prefix << "rep->cidx: " << static_cast<void *> (rep->c) << "\n" - << prefix << "rep->count: " << rep->count << "\n"; + os << prefix << "m_rep address: " << m_rep << "\n" + << prefix << "m_rep->m_nzmx: " << m_rep->m_nzmx << "\n" + << prefix << "m_rep->m_nrows: " << m_rep->m_nrows << "\n" + << prefix << "m_rep->m_ncols: " << m_rep->m_ncols << "\n" + << prefix << "m_rep->data: " << static_cast<void *> (m_rep->m_d) << "\n" + << prefix << "m_rep->ridx: " << static_cast<void *> (m_rep->m_r) << "\n" + << prefix << "m_rep->cidx: " << static_cast<void *> (m_rep->m_c) << "\n" + << prefix << "m_rep->m_count: " << m_rep->m_count << "\n"; } #if defined (__clang__)
--- a/liboctave/array/Sparse.h Thu Jul 15 16:11:12 2021 -0400 +++ b/liboctave/array/Sparse.h Thu Jul 15 16:12:24 2021 -0400 @@ -62,65 +62,65 @@ { public: - T *d; - octave_idx_type *r; - octave_idx_type *c; - octave_idx_type nzmx; - octave_idx_type nrows; - octave_idx_type ncols; - octave::refcount<octave_idx_type> count; + T *m_d; + octave_idx_type *m_r; + octave_idx_type *m_c; + octave_idx_type m_nzmx; + octave_idx_type m_nrows; + octave_idx_type m_ncols; + octave::refcount<octave_idx_type> m_count; SparseRep (void) - : d (new T [1]), r (new octave_idx_type [1] {}), - c (new octave_idx_type [1] {}), - nzmx (1), nrows (0), ncols (0), count (1) + : m_d (new T [1]), m_r (new octave_idx_type [1] {}), + m_c (new octave_idx_type [1] {}), + m_nzmx (1), m_nrows (0), m_ncols (0), m_count (1) { } SparseRep (octave_idx_type n) - : d (new T [1]), r (new octave_idx_type [1] {}), - c (new octave_idx_type [n+1] {}), - nzmx (1), nrows (n), ncols (n), count (1) + : m_d (new T [1]), m_r (new octave_idx_type [1] {}), + m_c (new octave_idx_type [n+1] {}), + m_nzmx (1), m_nrows (n), m_ncols (n), m_count (1) { } SparseRep (octave_idx_type nr, octave_idx_type nc, octave_idx_type nz = 1) - : d (nz > 0 ? new T [nz] : new T [1]), - r (nz > 0 ? new octave_idx_type [nz] {} : new octave_idx_type [1] {}), - c (new octave_idx_type [nc+1] {}), - nzmx (nz > 0 ? nz : 1), nrows (nr), ncols (nc), count (1) + : m_d (nz > 0 ? new T [nz] : new T [1]), + m_r (nz > 0 ? new octave_idx_type [nz] {} : new octave_idx_type [1] {}), + m_c (new octave_idx_type [nc+1] {}), + m_nzmx (nz > 0 ? nz : 1), m_nrows (nr), m_ncols (nc), m_count (1) { } SparseRep (const SparseRep& a) - : 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) + : m_d (new T [a.m_nzmx]), m_r (new octave_idx_type [a.m_nzmx]), + m_c (new octave_idx_type [a.m_ncols + 1]), + m_nzmx (a.m_nzmx), m_nrows (a.m_nrows), m_ncols (a.m_ncols), m_count (1) { octave_idx_type nz = a.nnz (); - std::copy_n (a.d, nz, d); - std::copy_n (a.r, nz, r); - std::copy_n (a.c, ncols + 1, c); + std::copy_n (a.m_d, nz, m_d); + std::copy_n (a.m_r, nz, m_r); + std::copy_n (a.m_c, m_ncols + 1, m_c); } - ~SparseRep (void) { delete [] d; delete [] r; delete [] c; } + ~SparseRep (void) { delete [] m_d; delete [] m_r; delete [] m_c; } - octave_idx_type length (void) const { return nzmx; } + octave_idx_type length (void) const { return m_nzmx; } - octave_idx_type nnz (void) const { return c[ncols]; } + octave_idx_type nnz (void) const { return m_c[m_ncols]; } OCTAVE_API T& elem (octave_idx_type _r, octave_idx_type _c); OCTAVE_API T celem (octave_idx_type _r, octave_idx_type _c) const; - T& data (octave_idx_type i) { return d[i]; } + T& data (octave_idx_type i) { return m_d[i]; } - T cdata (octave_idx_type i) const { return d[i]; } + T cdata (octave_idx_type i) const { return m_d[i]; } - octave_idx_type& ridx (octave_idx_type i) { return r[i]; } + octave_idx_type& ridx (octave_idx_type i) { return m_r[i]; } - octave_idx_type cridx (octave_idx_type i) const { return r[i]; } + octave_idx_type cridx (octave_idx_type i) const { return m_r[i]; } - octave_idx_type& cidx (octave_idx_type i) { return c[i]; } + octave_idx_type& cidx (octave_idx_type i) { return m_c[i]; } - octave_idx_type ccidx (octave_idx_type i) const { return c[i]; } + octave_idx_type ccidx (octave_idx_type i) const { return m_c[i]; } OCTAVE_API void maybe_compress (bool remove_zeros); @@ -141,14 +141,14 @@ void make_unique (void) { - if (rep->count > 1) + if (m_rep->m_count > 1) { - SparseRep *r = new SparseRep (*rep); + SparseRep *r = new SparseRep (*m_rep); - if (--rep->count == 0) - delete rep; + if (--m_rep->m_count == 0) + delete m_rep; - rep = r; + m_rep = r; } } @@ -157,9 +157,9 @@ // !!! WARNING !!! -- these should be protected, not public. You // should not access these data members directly! - typename Sparse<T>::SparseRep *rep; + typename Sparse<T>::SparseRep *m_rep; - dim_vector dimensions; + dim_vector m_dimensions; private: @@ -168,28 +168,28 @@ public: Sparse (void) - : rep (nil_rep ()), dimensions (dim_vector (0,0)) + : m_rep (nil_rep ()), m_dimensions (dim_vector (0,0)) { - rep->count++; + m_rep->m_count++; } explicit Sparse (octave_idx_type n) - : rep (new typename Sparse<T>::SparseRep (n)), - dimensions (dim_vector (n, n)) { } + : m_rep (new typename Sparse<T>::SparseRep (n)), + m_dimensions (dim_vector (n, n)) { } explicit Sparse (octave_idx_type nr, octave_idx_type nc) - : rep (new typename Sparse<T>::SparseRep (nr, nc)), - dimensions (dim_vector (nr, nc)) { } + : m_rep (new typename Sparse<T>::SparseRep (nr, nc)), + m_dimensions (dim_vector (nr, nc)) { } explicit OCTAVE_API 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) { } + : m_rep (new typename Sparse<T>::SparseRep (dv(0), dv(1), nz)), + m_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)) { } + : m_rep (new typename Sparse<T>::SparseRep (nr, nc, nz)), + m_dimensions (dim_vector (nr, nc)) { } // Both SparseMatrix and SparseBoolMatrix need this ctor, and this // is their only common ancestor. @@ -198,21 +198,21 @@ // Type conversion case. Preserves nzmax. template <typename U> Sparse (const Sparse<U>& a) - : rep (new typename Sparse<T>::SparseRep (a.rep->nrows, a.rep->ncols, - a.rep->nzmx)), - dimensions (a.dimensions) + : m_rep (new typename Sparse<T>::SparseRep (a.m_rep->m_nrows, a.m_rep->m_ncols, + a.m_rep->m_nzmx)), + m_dimensions (a.m_dimensions) { octave_idx_type nz = a.nnz (); - std::copy_n (a.rep->d, nz, rep->d); - std::copy_n (a.rep->r, nz, rep->r); - std::copy_n (a.rep->c, rep->ncols + 1, rep->c); + std::copy_n (a.m_rep->m_d, nz, m_rep->m_d); + std::copy_n (a.m_rep->m_r, nz, m_rep->m_r); + std::copy_n (a.m_rep->m_c, m_rep->m_ncols + 1, m_rep->m_c); } // No type conversion case. Sparse (const Sparse<T>& a) - : rep (a.rep), dimensions (a.dimensions) + : m_rep (a.m_rep), m_dimensions (a.m_dimensions) { - rep->count++; + m_rep->m_count++; } public: @@ -235,20 +235,20 @@ //! Amount of storage for nonzero elements. //! This may differ from the actual number of elements, see nnz(). - octave_idx_type nzmax (void) const { return rep->length (); } + octave_idx_type nzmax (void) const { return m_rep->length (); } //! Actual number of nonzero terms. - octave_idx_type nnz (void) const { return rep->nnz (); } + octave_idx_type nnz (void) const { return m_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 (); + return m_dimensions.safe_numel (); } - octave_idx_type dim1 (void) const { return dimensions(0); } - octave_idx_type dim2 (void) const { return dimensions(1); } + octave_idx_type dim1 (void) const { return m_dimensions(0); } + octave_idx_type dim2 (void) const { return m_dimensions(1); } octave_idx_type rows (void) const { return dim1 (); } octave_idx_type cols (void) const { return dim2 (); } @@ -270,7 +270,7 @@ * (sizeof (T) + sizeof (octave_idx_type))); } - dim_vector dims (void) const { return dimensions; } + dim_vector dims (void) const { return m_dimensions; } Sparse<T> squeeze (void) const { return *this; } @@ -308,10 +308,10 @@ 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) { return m_rep->elem (i, j); } T xelem (octave_idx_type i, octave_idx_type j) const { - return rep->celem (i, j); + return m_rep->celem (i, j); } T& xelem (const Array<octave_idx_type>& ra_idx) @@ -435,7 +435,7 @@ if (remove_zeros) make_unique (); // Need to unshare because elements are removed. - rep->maybe_compress (remove_zeros); + m_rep->maybe_compress (remove_zeros); return (*this); } @@ -459,7 +459,7 @@ { if (nz < nnz ()) make_unique (); // Unshare now because elements will be truncated. - rep->change_length (nz); + m_rep->change_length (nz); } OCTAVE_API Sparse<T>& @@ -473,42 +473,42 @@ OCTAVE_API Sparse<T> transpose (void) const; - T * data (void) { make_unique (); return rep->d; } - T& data (octave_idx_type i) { make_unique (); return rep->data (i); } - T * xdata (void) { return rep->d; } - T& xdata (octave_idx_type i) { return rep->data (i); } + T * data (void) { make_unique (); return m_rep->m_d; } + T& data (octave_idx_type i) { make_unique (); return m_rep->data (i); } + T * xdata (void) { return m_rep->m_d; } + T& xdata (octave_idx_type i) { return m_rep->data (i); } - T data (octave_idx_type i) const { return rep->data (i); } + T data (octave_idx_type i) const { return m_rep->data (i); } // FIXME: shouldn't this be returning const T*? - T * data (void) const { return rep->d; } + T * data (void) const { return m_rep->m_d; } - octave_idx_type * ridx (void) { make_unique (); return rep->r; } + octave_idx_type * ridx (void) { make_unique (); return m_rep->m_r; } octave_idx_type& ridx (octave_idx_type i) { - make_unique (); return rep->ridx (i); + make_unique (); return m_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 * xridx (void) { return m_rep->m_r; } + octave_idx_type& xridx (octave_idx_type i) { return m_rep->ridx (i); } - octave_idx_type ridx (octave_idx_type i) const { return rep->cridx (i); } + octave_idx_type ridx (octave_idx_type i) const { return m_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 * ridx (void) const { return m_rep->m_r; } - octave_idx_type * cidx (void) { make_unique (); return rep->c; } + octave_idx_type * cidx (void) { make_unique (); return m_rep->m_c; } octave_idx_type& cidx (octave_idx_type i) { - make_unique (); return rep->cidx (i); + make_unique (); return m_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 * xcidx (void) { return m_rep->m_c; } + octave_idx_type& xcidx (octave_idx_type i) { return m_rep->cidx (i); } - octave_idx_type cidx (octave_idx_type i) const { return rep->ccidx (i); } + octave_idx_type cidx (octave_idx_type i) const { return m_rep->ccidx (i); } // FIXME: shouldn't this be returning const octave_idx_type*? - octave_idx_type * cidx (void) const { return rep->c; } + octave_idx_type * cidx (void) const { return m_rep->m_c; } - octave_idx_type ndims (void) const { return dimensions.ndims (); } + octave_idx_type ndims (void) const { return m_dimensions.ndims (); } OCTAVE_API void delete_elements (const octave::idx_vector& i); @@ -659,10 +659,10 @@ map (U (&fcn) (const T&)) const { return map<U, U (&) (const T&)> (fcn); } - bool indices_ok (void) const { return rep->indices_ok (); } + bool indices_ok (void) const { return m_rep->indices_ok (); } bool any_element_is_nan (void) const - { return rep->any_element_is_nan (); } + { return m_rep->any_element_is_nan (); } }; template <typename T>
--- a/liboctave/array/dim-vector.cc Thu Jul 15 16:11:12 2021 -0400 +++ b/liboctave/array/dim-vector.cc Thu Jul 15 16:12:24 2021 -0400 @@ -71,14 +71,14 @@ for (int i = 0; i < nd; i++) { - if (rep[i] != 1) - rep[j++] = rep[i]; + if (m_rep[i] != 1) + m_rep[j++] = m_rep[i]; } if (j == 1) - rep[1] = 1; + m_rep[1] = 1; - rep[-1] = (j > 2 ? j : 2); + m_rep[-1] = (j > 2 ? j : 2); } std::string @@ -120,9 +120,9 @@ for (int i = 0; i < n_dims; i++) { - n *= rep[i]; - if (rep[i] != 0) - idx_max /= rep[i]; + n *= m_rep[i]; + if (m_rep[i] != 0) + idx_max /= m_rep[i]; if (idx_max <= 0) throw std::bad_alloc (); } @@ -170,7 +170,7 @@ for (int i = 0; i < ndb; i++) { - if (i != dim && rep[i] != dvb(i)) + if (i != dim && m_rep[i] != dvb(i)) { match = false; break; @@ -179,7 +179,7 @@ for (int i = ndb; i < new_nd; i++) { - if (i != dim && rep[i] != 1) + if (i != dim && m_rep[i] != 1) { match = false; break; @@ -187,13 +187,13 @@ } if (match) - rep[dim] += (dim < ndb ? dvb(dim) : 1); + m_rep[dim] += (dim < ndb ? dvb(dim) : 1); else { // Dimensions don't match. The only allowed fix is to omit 0x0. if (ndb == 2 && dvb(0) == 0 && dvb(1) == 0) match = true; - else if (orig_nd == 2 && rep[0] == 0 && rep[1] == 0) + else if (orig_nd == 2 && m_rep[0] == 0 && m_rep[1] == 0) { *this = dvb; match = true; @@ -223,7 +223,7 @@ return true; else if (ndims () == 2 && dvb.ndims () == 2) { - bool e2dv = rep[0] + rep[1] == 1; + bool e2dv = m_rep[0] + m_rep[1] == 1; bool e2dvb = dvb(0) + dvb(1) == 1; if (e2dvb) { @@ -252,8 +252,8 @@ { dim_vector retval = alloc (n); - std::copy_n (rep, n_dims, retval.rep); - std::fill_n (retval.rep + n_dims, n - n_dims, 1); + std::copy_n (m_rep, n_dims, retval.m_rep); + std::fill_n (retval.m_rep + n_dims, n - n_dims, 1); return retval; } @@ -264,18 +264,18 @@ dim_vector retval = alloc (n); - std::copy_n (rep, n-1, retval.rep); + std::copy_n (m_rep, n-1, retval.m_rep); // Accumulate overflow dimensions into last remaining dimension - int k = rep[n-1]; + int k = m_rep[n-1]; for (int i = n; i < n_dims; i++) - k *= rep[i]; + k *= m_rep[i]; - retval.rep[n-1] = k; + retval.m_rep[n-1] = k; // All dim_vectors are at least 2-D. Make Nx1 if necessary. if (n == 1) - retval.rep[1] = 1; + retval.m_rep[1] = 1; return retval; }
--- a/liboctave/array/dim-vector.h Thu Jul 15 16:11:12 2021 -0400 +++ b/liboctave/array/dim-vector.h Thu Jul 15 16:12:24 2021 -0400 @@ -95,9 +95,9 @@ { private: - octave_idx_type *rep; + octave_idx_type *m_rep; - octave_idx_type& count (void) const { return rep[-2]; } + octave_idx_type& count (void) const { return m_rep[-2]; } octave_idx_type increment_count (void) { @@ -121,7 +121,7 @@ return r; } - //! Clone this->rep. + //! Clone this->m_rep. octave_idx_type * clonerep (void) { @@ -129,12 +129,12 @@ octave_idx_type *r = newrep (nd); - std::copy_n (rep, nd, r); + std::copy_n (m_rep, nd, r); return r; } - //! Clone and resize this->rep to length n, filling by given value. + //! Clone and resize this->m_rep to length n, filling by given value. octave_idx_type * resizerep (int n, octave_idx_type fill_value) { @@ -148,7 +148,7 @@ if (nd > n) nd = n; - std::copy_n (rep, nd, r); + std::copy_n (m_rep, nd, r); std::fill_n (r + nd, n - nd, fill_value); return r; @@ -159,7 +159,7 @@ void freerep (void) { assert (count () == 0); - delete [] (rep - 2); + delete [] (m_rep - 2); } void make_unique (void) @@ -171,7 +171,7 @@ if (decrement_count () == 0) freerep (); - rep = new_rep; + m_rep = new_rep; } } @@ -214,19 +214,19 @@ template <typename... Ints> dim_vector (const octave_idx_type r, const octave_idx_type c, - Ints... lengths) : rep (newrep (2 + sizeof... (Ints))) + Ints... lengths) : m_rep (newrep (2 + sizeof... (Ints))) { std::initializer_list<octave_idx_type> all_lengths = {r, c, lengths...}; for (const octave_idx_type l: all_lengths) - *rep++ = l; - rep -= all_lengths.size (); + *m_rep++ = l; + m_rep -= all_lengths.size (); } // Fast access with absolutely no checking - octave_idx_type& xelem (int i) { return rep[i]; } + octave_idx_type& xelem (int i) { return m_rep[i]; } - octave_idx_type xelem (int i) const { return rep[i]; } + octave_idx_type xelem (int i) const { return m_rep[i]; } // Safe access to to elements @@ -241,13 +241,13 @@ void chop_trailing_singletons (void) { int nd = ndims (); - if (nd > 2 && rep[nd-1] == 1) + if (nd > 2 && m_rep[nd-1] == 1) { make_unique (); do nd--; - while (nd > 2 && rep[nd-1] == 1); - rep[-1] = nd; + while (nd > 2 && m_rep[nd-1] == 1); + m_rep[-1] = nd; } } @@ -256,7 +256,7 @@ // WARNING: Only call by jit octave_idx_type * to_jit (void) const { - return rep; + return m_rep; } private: @@ -267,16 +267,16 @@ static OCTAVE_API octave_idx_type dim_max (void); - explicit dim_vector (void) : rep (nil_rep ()) + explicit dim_vector (void) : m_rep (nil_rep ()) { increment_count (); } - dim_vector (const dim_vector& dv) : rep (dv.rep) + dim_vector (const dim_vector& dv) : m_rep (dv.m_rep) { increment_count (); } - dim_vector (dim_vector&& dv) : rep (dv.rep) { dv.rep = nullptr; } + dim_vector (dim_vector&& dv) : m_rep (dv.m_rep) { dv.m_rep = nullptr; } // FIXME: Should be private, but required by array constructor for jit - explicit dim_vector (octave_idx_type *r) : rep (r) { } + explicit dim_vector (octave_idx_type *r) : m_rep (r) { } static dim_vector alloc (int n) { @@ -290,7 +290,7 @@ if (decrement_count () == 0) freerep (); - rep = dv.rep; + m_rep = dv.m_rep; increment_count (); } @@ -302,14 +302,14 @@ if (&dv != this) { // Because we define a move constructor and a move assignment - // operator, rep may be a nullptr here. We should only need to + // operator, m_rep may be a nullptr here. We should only need to // protect the destructor in a similar way. - if (rep && decrement_count () == 0) + if (m_rep && decrement_count () == 0) freerep (); - rep = dv.rep; - dv.rep = nullptr; + m_rep = dv.m_rep; + dv.m_rep = nullptr; } return *this; @@ -318,10 +318,10 @@ ~dim_vector (void) { // Because we define a move constructor and a move assignment - // operator, rep may be a nullptr here. We should only need to + // operator, m_rep may be a nullptr here. We should only need to // protect the move assignment operator in a similar way. - if (rep && decrement_count () == 0) + if (m_rep && decrement_count () == 0) freerep (); } @@ -331,7 +331,7 @@ //! elements in the dim_vector including trailing singletons. It is also //! the number of dimensions an Array with this dim_vector would have. - octave_idx_type ndims (void) const { return rep[-1]; } + octave_idx_type ndims (void) const { return m_rep[-1]; } //! Number of dimensions. //! Synonymous with ndims(). @@ -357,7 +357,7 @@ if (decrement_count () == 0) freerep (); - rep = r; + m_rep = r; } } @@ -365,7 +365,7 @@ bool all_zero (void) const { - return std::all_of (rep, rep + ndims (), + return std::all_of (m_rep, m_rep + ndims (), [] (octave_idx_type dim) { return dim == 0; }); } @@ -381,7 +381,7 @@ bool any_zero (void) const { - return std::any_of (rep, rep + ndims (), + return std::any_of (m_rep, m_rep + ndims (), [] (octave_idx_type dim) { return dim == 0; }); } @@ -422,7 +422,7 @@ bool any_neg (void) const { - return std::any_of (rep, rep + ndims (), + return std::any_of (m_rep, m_rep + ndims (), [] (octave_idx_type dim) { return dim < 0; }); } @@ -527,7 +527,7 @@ { octave_idx_type k = 0; for (int i = nidx - 1; i >= 0; i--) - k = rep[i] * k + idx[i]; + k = m_rep[i] * k + idx[i]; return k; } @@ -541,7 +541,7 @@ int i; for (i = start; i < ndims (); i++) { - if (++(*idx) == rep[i]) + if (++(*idx) == m_rep[i]) *idx++ = 0; else break; @@ -558,7 +558,7 @@ octave_idx_type k = 1; for (int i = 0; i < nd; i++) - retval.rep[i] = (k *= rep[i]); + retval.m_rep[i] = (k *= m_rep[i]); return retval; } @@ -571,7 +571,7 @@ octave_idx_type k = idx[0]; for (int i = 1; i < ndims (); i++) - k += rep[i-1] * idx[i]; + k += m_rep[i-1] * idx[i]; return k; } @@ -586,7 +586,7 @@ operator == (const dim_vector& a, const dim_vector& b) { // Fast case. - if (a.rep == b.rep) + if (a.m_rep == b.m_rep) return true; int a_len = a.ndims (); @@ -595,7 +595,7 @@ if (a_len != b_len) return false; - return std::equal (a.rep, a.rep + a_len, b.rep); + return std::equal (a.m_rep, a.m_rep + a_len, b.m_rep); } inline bool
--- a/liboctave/array/fCNDArray.cc Thu Jul 15 16:11:12 2021 -0400 +++ b/liboctave/array/fCNDArray.cc Thu Jul 15 16:12:24 2021 -0400 @@ -521,10 +521,11 @@ octave_idx_type r, octave_idx_type c) { dim_vector a_dv = a.dims (); + dim_vector dv = dims (); int n = a_dv.ndims (); - if (n == dimensions.ndims ()) + if (n == dv.ndims ()) { Array<octave_idx_type> a_ra_idx (dim_vector (a_dv.ndims (), 1), 0); @@ -533,7 +534,7 @@ for (int i = 0; i < n; i++) { - if (a_ra_idx(i) < 0 || (a_ra_idx(i) + a_dv(i)) > dimensions(i)) + if (a_ra_idx(i) < 0 || (a_ra_idx(i) + a_dv(i)) > dv(i)) (*current_liboctave_error_handler) ("Array<T>::insert: range error for insert"); }