Mercurial > octave-nkf
view liboctave/array/dim-vector.h @ 17769:49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
* liboctave/array/Array-C.cc, liboctave/array/Array-b.cc,
liboctave/array/Array-ch.cc, liboctave/array/Array-d.cc,
liboctave/array/Array-f.cc, liboctave/array/Array-fC.cc,
liboctave/array/Array-util.cc, liboctave/array/Array-util.h,
liboctave/array/Array.cc, liboctave/array/Array.h, liboctave/array/Array3.h,
liboctave/array/CColVector.cc, liboctave/array/CColVector.h,
liboctave/array/CDiagMatrix.cc, liboctave/array/CDiagMatrix.h,
liboctave/array/CMatrix.cc, liboctave/array/CMatrix.h,
liboctave/array/CNDArray.cc, liboctave/array/CNDArray.h,
liboctave/array/CRowVector.cc, liboctave/array/CRowVector.h,
liboctave/array/CSparse.cc, liboctave/array/CSparse.h,
liboctave/array/DiagArray2.h, liboctave/array/MArray.cc,
liboctave/array/MArray.h, liboctave/array/MDiagArray2.cc,
liboctave/array/MDiagArray2.h, liboctave/array/MSparse.cc,
liboctave/array/MSparse.h, liboctave/array/MatrixType.cc,
liboctave/array/MatrixType.h, liboctave/array/PermMatrix.h,
liboctave/array/Range.cc, liboctave/array/Range.h, liboctave/array/Sparse.cc,
liboctave/array/Sparse.h, liboctave/array/boolMatrix.cc,
liboctave/array/boolMatrix.h, liboctave/array/boolNDArray.cc,
liboctave/array/boolNDArray.h, liboctave/array/boolSparse.cc,
liboctave/array/boolSparse.h, liboctave/array/chMatrix.cc,
liboctave/array/chMatrix.h, liboctave/array/chNDArray.cc,
liboctave/array/chNDArray.h, liboctave/array/dColVector.h,
liboctave/array/dDiagMatrix.cc, liboctave/array/dDiagMatrix.h,
liboctave/array/dMatrix.cc, liboctave/array/dMatrix.h,
liboctave/array/dNDArray.cc, liboctave/array/dNDArray.h,
liboctave/array/dRowVector.h, liboctave/array/dSparse.cc,
liboctave/array/dSparse.h, liboctave/array/dim-vector.cc,
liboctave/array/dim-vector.h, liboctave/array/fCColVector.cc,
liboctave/array/fCColVector.h, liboctave/array/fCDiagMatrix.cc,
liboctave/array/fCDiagMatrix.h, liboctave/array/fCMatrix.cc,
liboctave/array/fCMatrix.h, liboctave/array/fCNDArray.cc,
liboctave/array/fCNDArray.h, liboctave/array/fCRowVector.cc,
liboctave/array/fCRowVector.h, liboctave/array/fColVector.h,
liboctave/array/fDiagMatrix.cc, liboctave/array/fDiagMatrix.h,
liboctave/array/fMatrix.cc, liboctave/array/fMatrix.h,
liboctave/array/fNDArray.cc, liboctave/array/fNDArray.h,
liboctave/array/fRowVector.h, liboctave/array/idx-vector.cc,
liboctave/array/idx-vector.h, liboctave/array/intNDArray.cc,
liboctave/array/intNDArray.h, liboctave/cruft/misc/blaswrap.c,
liboctave/cruft/misc/quit.cc, liboctave/numeric/CmplxCHOL.cc,
liboctave/numeric/CmplxCHOL.h, liboctave/numeric/CmplxGEPBAL.cc,
liboctave/numeric/CmplxGEPBAL.h, liboctave/numeric/CmplxHESS.h,
liboctave/numeric/CmplxLU.cc, liboctave/numeric/CmplxLU.h,
liboctave/numeric/CmplxQR.cc, liboctave/numeric/CmplxQRP.cc,
liboctave/numeric/CmplxQRP.h, liboctave/numeric/CmplxSCHUR.h,
liboctave/numeric/CmplxSVD.cc, liboctave/numeric/CmplxSVD.h,
liboctave/numeric/CollocWt.h, liboctave/numeric/DAE.h,
liboctave/numeric/DAEFunc.h, liboctave/numeric/DAERT.h,
liboctave/numeric/DAERTFunc.h, liboctave/numeric/DASPK.cc,
liboctave/numeric/DASRT.cc, liboctave/numeric/DASRT.h,
liboctave/numeric/DASSL.cc, liboctave/numeric/DET.h, liboctave/numeric/EIG.cc,
liboctave/numeric/EIG.h, liboctave/numeric/LSODE.cc, liboctave/numeric/ODE.h,
liboctave/numeric/ODEFunc.h, liboctave/numeric/ODES.h,
liboctave/numeric/ODESFunc.h, liboctave/numeric/Quad.cc,
liboctave/numeric/Quad.h, liboctave/numeric/SparseCmplxCHOL.h,
liboctave/numeric/SparseCmplxLU.cc, liboctave/numeric/SparseCmplxLU.h,
liboctave/numeric/SparseCmplxQR.cc, liboctave/numeric/SparseCmplxQR.h,
liboctave/numeric/SparseQR.cc, liboctave/numeric/SparseQR.h,
liboctave/numeric/SparsedbleCHOL.h, liboctave/numeric/SparsedbleLU.cc,
liboctave/numeric/SparsedbleLU.h, liboctave/numeric/base-aepbal.h,
liboctave/numeric/base-dae.h, liboctave/numeric/base-de.h,
liboctave/numeric/base-lu.cc, liboctave/numeric/base-lu.h,
liboctave/numeric/base-min.h, liboctave/numeric/base-qr.h,
liboctave/numeric/bsxfun.h, liboctave/numeric/dbleCHOL.cc,
liboctave/numeric/dbleCHOL.h, liboctave/numeric/dbleGEPBAL.h,
liboctave/numeric/dbleHESS.h, liboctave/numeric/dbleLU.cc,
liboctave/numeric/dbleLU.h, liboctave/numeric/dbleQR.cc,
liboctave/numeric/dbleQRP.cc, liboctave/numeric/dbleQRP.h,
liboctave/numeric/dbleSCHUR.cc, liboctave/numeric/dbleSCHUR.h,
liboctave/numeric/dbleSVD.cc, liboctave/numeric/dbleSVD.h,
liboctave/numeric/eigs-base.cc, liboctave/numeric/fCmplxAEPBAL.cc,
liboctave/numeric/fCmplxAEPBAL.h, liboctave/numeric/fCmplxCHOL.cc,
liboctave/numeric/fCmplxCHOL.h, liboctave/numeric/fCmplxGEPBAL.cc,
liboctave/numeric/fCmplxGEPBAL.h, liboctave/numeric/fCmplxHESS.h,
liboctave/numeric/fCmplxLU.cc, liboctave/numeric/fCmplxLU.h,
liboctave/numeric/fCmplxQR.cc, liboctave/numeric/fCmplxQR.h,
liboctave/numeric/fCmplxQRP.cc, liboctave/numeric/fCmplxQRP.h,
liboctave/numeric/fCmplxSCHUR.cc, liboctave/numeric/fCmplxSCHUR.h,
liboctave/numeric/fCmplxSVD.h, liboctave/numeric/fEIG.cc,
liboctave/numeric/fEIG.h, liboctave/numeric/floatCHOL.cc,
liboctave/numeric/floatCHOL.h, liboctave/numeric/floatGEPBAL.cc,
liboctave/numeric/floatGEPBAL.h, liboctave/numeric/floatHESS.h,
liboctave/numeric/floatLU.cc, liboctave/numeric/floatLU.h,
liboctave/numeric/floatQR.cc, liboctave/numeric/floatQRP.cc,
liboctave/numeric/floatQRP.h, liboctave/numeric/floatSCHUR.cc,
liboctave/numeric/floatSCHUR.h, liboctave/numeric/floatSVD.cc,
liboctave/numeric/floatSVD.h, liboctave/numeric/lo-mappers.cc,
liboctave/numeric/lo-mappers.h, liboctave/numeric/lo-specfun.cc,
liboctave/numeric/lo-specfun.h, liboctave/numeric/oct-convn.cc,
liboctave/numeric/oct-fftw.cc, liboctave/numeric/oct-fftw.h,
liboctave/numeric/oct-norm.cc, liboctave/numeric/oct-rand.cc,
liboctave/numeric/oct-rand.h, liboctave/numeric/randgamma.c,
liboctave/numeric/randgamma.h, liboctave/numeric/randmtzig.c,
liboctave/numeric/randpoisson.c, liboctave/numeric/randpoisson.h,
liboctave/numeric/sparse-base-chol.h, liboctave/numeric/sparse-base-lu.h,
liboctave/numeric/sparse-dmsolve.cc, liboctave/operators/Sparse-diag-op-defs.h,
liboctave/operators/Sparse-op-defs.h, liboctave/operators/mx-inlines.cc,
liboctave/system/dir-ops.h, liboctave/system/file-ops.cc,
liboctave/system/file-stat.cc, liboctave/system/file-stat.h,
liboctave/system/lo-sysdep.cc, liboctave/system/lo-sysdep.h,
liboctave/system/mach-info.cc, liboctave/system/mach-info.h,
liboctave/system/oct-env.cc, liboctave/system/oct-group.cc,
liboctave/system/oct-syscalls.cc, liboctave/system/oct-syscalls.h,
liboctave/system/oct-time.h, liboctave/system/tempname.c,
liboctave/util/action-container.h, liboctave/util/base-list.h,
liboctave/util/cmd-edit.cc, liboctave/util/cmd-edit.h,
liboctave/util/cmd-hist.cc, liboctave/util/cmd-hist.h,
liboctave/util/data-conv.cc, liboctave/util/data-conv.h,
liboctave/util/kpse.cc, liboctave/util/lo-array-gripes.cc,
liboctave/util/lo-cieee.c, liboctave/util/lo-regexp.cc,
liboctave/util/lo-utils.cc, liboctave/util/oct-alloc.cc,
liboctave/util/oct-base64.cc, liboctave/util/oct-binmap.h,
liboctave/util/oct-cmplx.h, liboctave/util/oct-glob.cc,
liboctave/util/oct-inttypes.cc, liboctave/util/oct-inttypes.h,
liboctave/util/oct-locbuf.cc, liboctave/util/oct-locbuf.h,
liboctave/util/oct-mem.h, liboctave/util/oct-mutex.cc,
liboctave/util/oct-refcount.h, liboctave/util/oct-shlib.cc,
liboctave/util/oct-shlib.h, liboctave/util/oct-sort.cc,
liboctave/util/oct-sort.h, liboctave/util/pathsearch.cc,
liboctave/util/pathsearch.h, liboctave/util/sparse-util.cc,
liboctave/util/str-vec.cc, liboctave/util/str-vec.h,
liboctave/util/unwind-prot.h, liboctave/util/url-transfer.cc,
liboctave/util/url-transfer.h: Use GNU style coding conventions.
author | Rik <rik@octave.org> |
---|---|
date | Sat, 26 Oct 2013 18:57:05 -0700 |
parents | d63878346099 |
children | 3a6fd52e1458 |
line wrap: on
line source
/* Copyright (C) 2003-2013 John W. Eaton Copyirght (C) 2009, 2010 VZLU Prague This file is part of Octave. Octave is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. Octave is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with Octave; see the file COPYING. If not, see <http://www.gnu.org/licenses/>. */ #if !defined (octave_dim_vector_h) #define octave_dim_vector_h 1 #include <cassert> #include <limits> #include <sstream> #include <string> #include "lo-error.h" #include "lo-macros.h" #include "oct-refcount.h" // Rationale: This implementation is more tricky than Array, but the // big plus is that dim_vector requires only one allocation instead of // two. It is (slightly) patterned after GCC's basic_string // implementation. rep is a pointer to an array of memory, comprising // count, length, and the data: // // <count> // <ndims> // rep --> <dims[0]> // <dims[1]> // ... // // The inlines count(), ndims() recover this data from the rep. Note // that rep points to the beginning of dims to grant faster access // (reinterpret_cast is assumed to be an inexpensive operation). class OCTAVE_API dim_vector { private: octave_idx_type *rep; octave_idx_type& ndims (void) const { return rep[-1]; } octave_idx_type& count (void) const { return rep[-2]; } // Construct a new rep with count = 1 and ndims given. static octave_idx_type *newrep (int ndims) { octave_idx_type *r = new octave_idx_type [ndims + 2]; *r++ = 1; *r++ = ndims; return r; } // Clone this->rep. octave_idx_type *clonerep (void) { int l = ndims (); octave_idx_type *r = new octave_idx_type [l + 2]; *r++ = 1; *r++ = l; for (int i = 0; i < l; i++) r[i] = rep[i]; return r; } // Clone and resize this->rep to length n, filling by given value. octave_idx_type *resizerep (int n, octave_idx_type fill_value) { int l = ndims (); if (n < 2) n = 2; octave_idx_type *r = new octave_idx_type [n + 2]; *r++ = 1; *r++ = n; if (l > n) l = n; int j; for (j = 0; j < l; j++) r[j] = rep[j]; for (; j < n; j++) r[j] = fill_value; return r; } // Free the rep. void freerep (void) { assert (count () == 0); delete [] (rep - 2); } void make_unique (void) { if (count () > 1) { octave_idx_type *new_rep = clonerep (); if (OCTREFCOUNT_ATOMIC_DECREMENT(&(count())) == 0) freerep (); rep = new_rep; } } public: // The constructor // // dim_vector (n) // // creates an dimension vector with N rows and 1 column. It is // deprecated because of the potentiol for confusion that it causes. // Additional constructors of the form // // dim_vector (r, c) // dim_vector (r, c, p) // dim_vector (d1, d2, d3, d4, ...) // // are available for up to 7 dimensions. explicit dim_vector (octave_idx_type n) GCC_ATTR_DEPRECATED : rep (newrep (2)) { rep[0] = n; rep[1] = 1; } #define ASSIGN_REP(i) rep[i] = d ## i; #define DIM_VECTOR_CTOR(N) \ dim_vector (OCT_MAKE_DECL_LIST (octave_idx_type, d, N)) \ : rep (newrep (N)) \ { \ OCT_ITERATE_MACRO (ASSIGN_REP, N) \ } // Add more if needed. DIM_VECTOR_CTOR (2) DIM_VECTOR_CTOR (3) DIM_VECTOR_CTOR (4) DIM_VECTOR_CTOR (5) DIM_VECTOR_CTOR (6) DIM_VECTOR_CTOR (7) #undef ASSIGN_REP #undef DIM_VECTOR_CTOR octave_idx_type& elem (int i) { #ifdef BOUNDS_CHECKING assert (i >= 0 && i < ndims ()); #endif make_unique (); return rep[i]; } octave_idx_type elem (int i) const { #ifdef BOUNDS_CHECKING assert (i >= 0 && i < ndims ()); #endif return rep[i]; } void chop_trailing_singletons (void) { int l = ndims (); if (l > 2 && rep[l-1] == 1) { make_unique (); do l--; while (l > 2 && rep[l-1] == 1); ndims () = l; } } void chop_all_singletons (void); // WARNING: Only call by jit octave_idx_type *to_jit (void) const { return rep; } private: static octave_idx_type *nil_rep (void) { static dim_vector zv (0, 0); return zv.rep; } public: static octave_idx_type dim_max (void); explicit dim_vector (void) : rep (nil_rep ()) { OCTREFCOUNT_ATOMIC_INCREMENT (&(count())); } dim_vector (const dim_vector& dv) : rep (dv.rep) { OCTREFCOUNT_ATOMIC_INCREMENT (&(count())); } // FIXME: Should be private, but required by array constructor for jit explicit dim_vector (octave_idx_type *r) : rep (r) { } static dim_vector alloc (int n) { return dim_vector (newrep (n < 2 ? 2 : n)); } dim_vector& operator = (const dim_vector& dv) { if (&dv != this) { if (OCTREFCOUNT_ATOMIC_DECREMENT (&(count())) == 0) freerep (); rep = dv.rep; OCTREFCOUNT_ATOMIC_INCREMENT (&(count())); } return *this; } ~dim_vector (void) { if (OCTREFCOUNT_ATOMIC_DECREMENT (&(count())) == 0) freerep (); } int length (void) const { return ndims (); } octave_idx_type& operator () (int i) { return elem (i); } octave_idx_type operator () (int i) const { return elem (i); } void resize (int n, int fill_value = 0) { int len = length (); if (n != len) { octave_idx_type *r = resizerep (n, fill_value); if (OCTREFCOUNT_ATOMIC_DECREMENT (&(count())) == 0) freerep (); rep = r; } } std::string str (char sep = 'x') const; bool all_zero (void) const { bool retval = true; for (int i = 0; i < length (); i++) { if (elem (i) != 0) { retval = false; break; } } return retval; } bool empty_2d (void) const { return length () == 2 && (elem (0) == 0 || elem (1) == 0); } bool zero_by_zero (void) const { return length () == 2 && elem (0) == 0 && elem (1) == 0; } bool any_zero (void) const { bool retval = false; for (int i = 0; i < length (); i++) { if (elem (i) == 0) { retval = true; break; } } return retval; } int num_ones (void) const; bool all_ones (void) const { return (num_ones () == length ()); } // Return the number of elements that a matrix with this dimension // vector would have, NOT the number of dimensions (elements in the // dimension vector). octave_idx_type numel (int n = 0) const { int n_dims = length (); octave_idx_type retval = 1; for (int i = n; i < n_dims; i++) retval *= elem (i); return retval; } // The following function will throw a std::bad_alloc () // exception if the requested size is larger than can be indexed by // octave_idx_type. This may be smaller than the actual amount of // memory that can be safely allocated on a system. However, if we // don't fail here, we can end up with a mysterious crash inside a // function that is iterating over an array using octave_idx_type // indices. octave_idx_type safe_numel (void) const; bool any_neg (void) const { int n_dims = length (); int i; for (i = 0; i < n_dims; i++) if (elem (i) < 0) break; return i < n_dims; } dim_vector squeeze (void) const; // This corresponds to cat(). bool concat (const dim_vector& dvb, int dim); // This corresponds to [,] (horzcat, dim = 0) and [;] (vertcat, dim = 1). // The rules are more relaxed here. bool hvcat (const dim_vector& dvb, int dim); // Force certain dimensionality, preserving numel (). Missing // dimensions are set to 1, redundant are folded into the trailing // one. If n = 1, the result is 2d and the second dim is 1 // (dim_vectors are always at least 2D). dim_vector redim (int n) const; dim_vector as_column (void) const { if (length () == 2 && elem (1) == 1) return *this; else return dim_vector (numel (), 1); } dim_vector as_row (void) const { if (length () == 2 && elem (0) == 1) return *this; else return dim_vector (1, numel ()); } bool is_vector (void) const { return (length () == 2 && (elem (0) == 1 || elem (1) == 1)); } int first_non_singleton (int def = 0) const { for (int i = 0; i < length (); i++) { if (elem (i) != 1) return i; } return def; } // Compute a linear index from an index tuple. octave_idx_type compute_index (const octave_idx_type *idx) const { octave_idx_type k = 0; for (int i = length () - 1; i >= 0; i--) k = k * rep[i] + idx[i]; return k; } // Ditto, but the tuple may be incomplete (nidx < length ()). octave_idx_type compute_index (const octave_idx_type *idx, int nidx) const { octave_idx_type k = 0; for (int i = nidx - 1; i >= 0; i--) k = k * rep[i] + idx[i]; return k; } // Increment a multi-dimensional index tuple, optionally starting // from an offset position and return the index of the last index // position that was changed, or length () if just cycled over. int increment_index (octave_idx_type *idx, int start = 0) const { int i; for (i = start; i < length (); i++) { if (++(*idx) == rep[i]) *idx++ = 0; else break; } return i; } // Return cumulative dimensions. dim_vector cumulative (void) const { int nd = length (); dim_vector retval = alloc (nd); octave_idx_type k = 1; for (int i = 0; i < nd; i++) retval.rep[i] = k *= rep[i]; return retval; } // Compute a linear index from an index tuple. Dimensions are // required to be cumulative. octave_idx_type cum_compute_index (const octave_idx_type *idx) const { octave_idx_type k = idx[0]; for (int i = 1; i < length (); i++) k += rep[i-1] * idx[i]; return k; } friend bool operator == (const dim_vector& a, const dim_vector& b); }; inline bool operator == (const dim_vector& a, const dim_vector& b) { // Fast case. if (a.rep == b.rep) return true; bool retval = true; int a_len = a.length (); int b_len = b.length (); if (a_len != b_len) retval = false; else { for (int i = 0; i < a_len; i++) { if (a(i) != b(i)) { retval = false; break; } } } return retval; } inline bool operator != (const dim_vector& a, const dim_vector& b) { return ! operator == (a, b); } #endif