Mercurial > hg > octave-nkf
annotate liboctave/array/dim-vector.h @ 19519:5b263e517c95
Remove liboctave methods and classes deprecated for longer than 3 years.
* Array2.h, Array3.h, ArrayN.h, MArray2.h, MArrayN.h: remove these files
with their corresponding classes which have been deprecated.
* numeric/lo-mappers.h, numeric/lo-mappers.cc (octave_is_NaN_or_NA): remove
deprecated function for input of doubles and floats.
* util/lo-ieee.h, util/lo-ieee.cc (__lo_ieee_float_is_NaN_or_NA): remove
deprecated function for input of doubles and floats.
* array/Array.h (Array<T>::chop_trailing_singletons): remove deprecated method.
* array/Array.h (Array<T>::Array (octave_idx_type),
Array<T>::Array (octave_idx_type, T)): remove deprecated constructors which
casused confusions since there are no 1D arrays.
* dim-vector.h (dim_vector::dim_vector (octave_idx_type)): remove deprecated
constructor which caused confusion since there are no 1D arrays.
* liboctave/array/module.mk: update list of files.
| author | Carnë Draug <carandraug@octave.org> |
|---|---|
| date | Mon, 10 Nov 2014 12:37:04 +0000 |
| parents | 3a6fd52e1458 |
| children | 4197fc428c7d |
| rev | line source |
|---|---|
| 4513 | 1 /* |
| 2 | |
|
17744
d63878346099
maint: Update copyright notices for release.
John W. Eaton <jwe@octave.org>
parents:
15271
diff
changeset
|
3 Copyright (C) 2003-2013 John W. Eaton |
|
10521
4d1fc073fbb7
add some missing copyright stmts
Jaroslav Hajek <highegg@gmail.com>
parents:
10498
diff
changeset
|
4 Copyirght (C) 2009, 2010 VZLU Prague |
| 4513 | 5 |
| 6 This file is part of Octave. | |
| 7 | |
| 8 Octave is free software; you can redistribute it and/or modify it | |
| 9 under the terms of the GNU General Public License as published by the | |
| 7016 | 10 Free Software Foundation; either version 3 of the License, or (at your |
| 11 option) any later version. | |
| 4513 | 12 |
| 13 Octave is distributed in the hope that it will be useful, but WITHOUT | |
| 14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 16 for more details. | |
| 17 | |
| 18 You should have received a copy of the GNU General Public License | |
| 7016 | 19 along with Octave; see the file COPYING. If not, see |
| 20 <http://www.gnu.org/licenses/>. | |
| 4513 | 21 |
| 22 */ | |
| 23 | |
| 24 #if !defined (octave_dim_vector_h) | |
| 25 #define octave_dim_vector_h 1 | |
| 26 | |
| 27 #include <cassert> | |
|
9840
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
28 #include <limits> |
|
8950
d865363208d6
include <iosfwd> instead of <iostream> in header files
John W. Eaton <jwe@octave.org>
parents:
8920
diff
changeset
|
29 |
| 5765 | 30 #include <sstream> |
| 4543 | 31 #include <string> |
| 32 | |
| 6216 | 33 #include "lo-error.h" |
|
10419
afe44ee90cbd
implement generic macro magic for repeated decls
Jaroslav Hajek <highegg@gmail.com>
parents:
10418
diff
changeset
|
34 #include "lo-macros.h" |
|
13985
43cc49c7abd1
Use thread-safe atomic reference counting (GCC and MSVC).
Michael Goffioul <michael.goffioul@gmail.com>
parents:
11586
diff
changeset
|
35 #include "oct-refcount.h" |
| 4513 | 36 |
| 10150 | 37 // Rationale: This implementation is more tricky than Array, but the |
| 38 // big plus is that dim_vector requires only one allocation instead of | |
| 39 // two. It is (slightly) patterned after GCC's basic_string | |
| 40 // implementation. rep is a pointer to an array of memory, comprising | |
| 41 // count, length, and the data: | |
| 42 // | |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
43 // <count> |
|
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
44 // <ndims> |
|
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
45 // rep --> <dims[0]> |
|
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
46 // <dims[1]> |
| 10150 | 47 // ... |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
48 // |
| 10150 | 49 // The inlines count(), ndims() recover this data from the rep. Note |
| 50 // that rep points to the beginning of dims to grant faster access | |
| 51 // (reinterpret_cast is assumed to be an inexpensive operation). | |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
52 |
| 4513 | 53 class |
|
11173
298a75c128ad
Additional exported symbols [MSVC]
Michael Goffioul <michael.goffioul@gmail.com>
parents:
10830
diff
changeset
|
54 OCTAVE_API |
| 4513 | 55 dim_vector |
| 56 { | |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
57 private: |
| 4513 | 58 |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
59 octave_idx_type *rep; |
| 4548 | 60 |
| 10150 | 61 octave_idx_type& ndims (void) const { return rep[-1]; } |
| 4513 | 62 |
| 10150 | 63 octave_idx_type& count (void) const { return rep[-2]; } |
| 4513 | 64 |
|
19391
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
65 //! Construct a new rep with count = 1 and ndims given. |
| 10150 | 66 |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
67 static octave_idx_type *newrep (int ndims) |
| 10150 | 68 { |
|
15020
560317fd5977
maint: Cuddle open bracket used for indexing C++ arrays in source code.
Rik <rik@octave.org>
parents:
14951
diff
changeset
|
69 octave_idx_type *r = new octave_idx_type [ndims + 2]; |
| 10150 | 70 |
| 71 *r++ = 1; | |
| 72 *r++ = ndims; | |
| 4513 | 73 |
| 10150 | 74 return r; |
| 75 } | |
| 76 | |
|
19391
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
77 //! Clone this->rep. |
| 10150 | 78 |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
79 octave_idx_type *clonerep (void) |
| 10150 | 80 { |
| 81 int l = ndims (); | |
| 82 | |
|
15020
560317fd5977
maint: Cuddle open bracket used for indexing C++ arrays in source code.
Rik <rik@octave.org>
parents:
14951
diff
changeset
|
83 octave_idx_type *r = new octave_idx_type [l + 2]; |
| 10150 | 84 |
| 85 *r++ = 1; | |
| 86 *r++ = l; | |
| 4513 | 87 |
| 10150 | 88 for (int i = 0; i < l; i++) |
| 89 r[i] = rep[i]; | |
| 90 | |
| 91 return r; | |
| 92 } | |
| 93 | |
|
19391
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
94 //! Clone and resize this->rep to length n, filling by given value. |
| 10150 | 95 |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
96 octave_idx_type *resizerep (int n, octave_idx_type fill_value) |
| 10150 | 97 { |
| 98 int l = ndims (); | |
| 99 | |
| 100 if (n < 2) | |
| 101 n = 2; | |
| 102 | |
|
15020
560317fd5977
maint: Cuddle open bracket used for indexing C++ arrays in source code.
Rik <rik@octave.org>
parents:
14951
diff
changeset
|
103 octave_idx_type *r = new octave_idx_type [n + 2]; |
| 10150 | 104 |
| 105 *r++ = 1; | |
| 106 *r++ = n; | |
| 107 | |
| 108 if (l > n) | |
| 109 l = n; | |
| 4673 | 110 |
| 10150 | 111 int j; |
| 112 for (j = 0; j < l; j++) | |
| 113 r[j] = rep[j]; | |
| 114 for (; j < n; j++) | |
| 115 r[j] = fill_value; | |
| 116 | |
| 117 return r; | |
| 118 } | |
| 119 | |
|
19391
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
120 //! Free the rep. |
| 10150 | 121 |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
122 void freerep (void) |
| 10150 | 123 { |
| 124 assert (count () == 0); | |
| 125 delete [] (rep - 2); | |
| 126 } | |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
127 |
| 4548 | 128 void make_unique (void) |
| 129 { | |
| 10150 | 130 if (count () > 1) |
| 4548 | 131 { |
| 14445 | 132 octave_idx_type *new_rep = clonerep (); |
|
13985
43cc49c7abd1
Use thread-safe atomic reference counting (GCC and MSVC).
Michael Goffioul <michael.goffioul@gmail.com>
parents:
11586
diff
changeset
|
133 |
| 14445 | 134 if (OCTREFCOUNT_ATOMIC_DECREMENT(&(count())) == 0) |
| 135 freerep (); | |
|
13985
43cc49c7abd1
Use thread-safe atomic reference counting (GCC and MSVC).
Michael Goffioul <michael.goffioul@gmail.com>
parents:
11586
diff
changeset
|
136 |
|
43cc49c7abd1
Use thread-safe atomic reference counting (GCC and MSVC).
Michael Goffioul <michael.goffioul@gmail.com>
parents:
11586
diff
changeset
|
137 rep = new_rep; |
| 4548 | 138 } |
| 139 } | |
| 140 | |
| 141 public: | |
| 142 | |
|
10419
afe44ee90cbd
implement generic macro magic for repeated decls
Jaroslav Hajek <highegg@gmail.com>
parents:
10418
diff
changeset
|
143 #define ASSIGN_REP(i) rep[i] = d ## i; |
|
afe44ee90cbd
implement generic macro magic for repeated decls
Jaroslav Hajek <highegg@gmail.com>
parents:
10418
diff
changeset
|
144 #define DIM_VECTOR_CTOR(N) \ |
|
10420
3373fdc0b14a
use macro for 2 and 3 arg dim_vector constructors
John W. Eaton <jwe@octave.org>
parents:
10419
diff
changeset
|
145 dim_vector (OCT_MAKE_DECL_LIST (octave_idx_type, d, N)) \ |
|
10419
afe44ee90cbd
implement generic macro magic for repeated decls
Jaroslav Hajek <highegg@gmail.com>
parents:
10418
diff
changeset
|
146 : rep (newrep (N)) \ |
|
afe44ee90cbd
implement generic macro magic for repeated decls
Jaroslav Hajek <highegg@gmail.com>
parents:
10418
diff
changeset
|
147 { \ |
|
10420
3373fdc0b14a
use macro for 2 and 3 arg dim_vector constructors
John W. Eaton <jwe@octave.org>
parents:
10419
diff
changeset
|
148 OCT_ITERATE_MACRO (ASSIGN_REP, N) \ |
|
10418
6c19d6fcd7e5
up to 7th-order dim_vector constructors
Jaroslav Hajek <highegg@gmail.com>
parents:
10403
diff
changeset
|
149 } |
|
10419
afe44ee90cbd
implement generic macro magic for repeated decls
Jaroslav Hajek <highegg@gmail.com>
parents:
10418
diff
changeset
|
150 |
|
afe44ee90cbd
implement generic macro magic for repeated decls
Jaroslav Hajek <highegg@gmail.com>
parents:
10418
diff
changeset
|
151 // Add more if needed. |
|
10420
3373fdc0b14a
use macro for 2 and 3 arg dim_vector constructors
John W. Eaton <jwe@octave.org>
parents:
10419
diff
changeset
|
152 DIM_VECTOR_CTOR (2) |
|
3373fdc0b14a
use macro for 2 and 3 arg dim_vector constructors
John W. Eaton <jwe@octave.org>
parents:
10419
diff
changeset
|
153 DIM_VECTOR_CTOR (3) |
|
3373fdc0b14a
use macro for 2 and 3 arg dim_vector constructors
John W. Eaton <jwe@octave.org>
parents:
10419
diff
changeset
|
154 DIM_VECTOR_CTOR (4) |
|
3373fdc0b14a
use macro for 2 and 3 arg dim_vector constructors
John W. Eaton <jwe@octave.org>
parents:
10419
diff
changeset
|
155 DIM_VECTOR_CTOR (5) |
|
3373fdc0b14a
use macro for 2 and 3 arg dim_vector constructors
John W. Eaton <jwe@octave.org>
parents:
10419
diff
changeset
|
156 DIM_VECTOR_CTOR (6) |
|
3373fdc0b14a
use macro for 2 and 3 arg dim_vector constructors
John W. Eaton <jwe@octave.org>
parents:
10419
diff
changeset
|
157 DIM_VECTOR_CTOR (7) |
|
10419
afe44ee90cbd
implement generic macro magic for repeated decls
Jaroslav Hajek <highegg@gmail.com>
parents:
10418
diff
changeset
|
158 |
|
afe44ee90cbd
implement generic macro magic for repeated decls
Jaroslav Hajek <highegg@gmail.com>
parents:
10418
diff
changeset
|
159 #undef ASSIGN_REP |
|
afe44ee90cbd
implement generic macro magic for repeated decls
Jaroslav Hajek <highegg@gmail.com>
parents:
10418
diff
changeset
|
160 #undef DIM_VECTOR_CTOR |
|
afe44ee90cbd
implement generic macro magic for repeated decls
Jaroslav Hajek <highegg@gmail.com>
parents:
10418
diff
changeset
|
161 |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
162 octave_idx_type& elem (int i) |
| 10150 | 163 { |
|
10366
e5ae13b8b2c2
improve Array indexing error messages
Jaroslav Hajek <highegg@gmail.com>
parents:
10350
diff
changeset
|
164 #ifdef BOUNDS_CHECKING |
| 10150 | 165 assert (i >= 0 && i < ndims ()); |
|
10366
e5ae13b8b2c2
improve Array indexing error messages
Jaroslav Hajek <highegg@gmail.com>
parents:
10350
diff
changeset
|
166 #endif |
| 10150 | 167 make_unique (); |
| 168 return rep[i]; | |
| 169 } | |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
170 |
|
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
171 octave_idx_type elem (int i) const |
| 10150 | 172 { |
|
10366
e5ae13b8b2c2
improve Array indexing error messages
Jaroslav Hajek <highegg@gmail.com>
parents:
10350
diff
changeset
|
173 #ifdef BOUNDS_CHECKING |
| 10150 | 174 assert (i >= 0 && i < ndims ()); |
|
10366
e5ae13b8b2c2
improve Array indexing error messages
Jaroslav Hajek <highegg@gmail.com>
parents:
10350
diff
changeset
|
175 #endif |
| 10150 | 176 return rep[i]; |
| 177 } | |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
178 |
|
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
179 void chop_trailing_singletons (void) |
| 10150 | 180 { |
| 181 int l = ndims (); | |
| 182 if (l > 2 && rep[l-1] == 1) | |
| 183 { | |
| 184 make_unique (); | |
| 185 do | |
| 186 l--; | |
| 187 while (l > 2 && rep[l-1] == 1); | |
| 188 ndims () = l; | |
| 189 } | |
| 190 } | |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
191 |
|
10681
0ba9bd294421
make cat() (hopefully) more matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10645
diff
changeset
|
192 void chop_all_singletons (void); |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
193 |
|
14951
4c9fd3e31436
Start of jit support for double matricies
Max Brister <max@2bass.com>
parents:
14625
diff
changeset
|
194 // WARNING: Only call by jit |
|
4c9fd3e31436
Start of jit support for double matricies
Max Brister <max@2bass.com>
parents:
14625
diff
changeset
|
195 octave_idx_type *to_jit (void) const |
|
4c9fd3e31436
Start of jit support for double matricies
Max Brister <max@2bass.com>
parents:
14625
diff
changeset
|
196 { |
|
4c9fd3e31436
Start of jit support for double matricies
Max Brister <max@2bass.com>
parents:
14625
diff
changeset
|
197 return rep; |
|
4c9fd3e31436
Start of jit support for double matricies
Max Brister <max@2bass.com>
parents:
14625
diff
changeset
|
198 } |
|
4c9fd3e31436
Start of jit support for double matricies
Max Brister <max@2bass.com>
parents:
14625
diff
changeset
|
199 |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
200 private: |
|
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
201 |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
202 static octave_idx_type *nil_rep (void) |
|
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
203 { |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
204 static dim_vector zv (0, 0); |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
205 return zv.rep; |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
206 } |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
207 |
|
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
208 public: |
|
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
209 |
|
10830
b4ebfd675321
avoid static initialization disaster in dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
10810
diff
changeset
|
210 static octave_idx_type dim_max (void); |
|
10810
6683f0c9d742
make the maximum extent externally accessible
Jaroslav Hajek <highegg@gmail.com>
parents:
10715
diff
changeset
|
211 |
|
13985
43cc49c7abd1
Use thread-safe atomic reference counting (GCC and MSVC).
Michael Goffioul <michael.goffioul@gmail.com>
parents:
11586
diff
changeset
|
212 explicit dim_vector (void) : rep (nil_rep ()) |
|
43cc49c7abd1
Use thread-safe atomic reference counting (GCC and MSVC).
Michael Goffioul <michael.goffioul@gmail.com>
parents:
11586
diff
changeset
|
213 { OCTREFCOUNT_ATOMIC_INCREMENT (&(count())); } |
| 4548 | 214 |
|
13985
43cc49c7abd1
Use thread-safe atomic reference counting (GCC and MSVC).
Michael Goffioul <michael.goffioul@gmail.com>
parents:
11586
diff
changeset
|
215 dim_vector (const dim_vector& dv) : rep (dv.rep) |
|
43cc49c7abd1
Use thread-safe atomic reference counting (GCC and MSVC).
Michael Goffioul <michael.goffioul@gmail.com>
parents:
11586
diff
changeset
|
216 { OCTREFCOUNT_ATOMIC_INCREMENT (&(count())); } |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
217 |
|
14951
4c9fd3e31436
Start of jit support for double matricies
Max Brister <max@2bass.com>
parents:
14625
diff
changeset
|
218 // FIXME: Should be private, but required by array constructor for jit |
|
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
219 explicit dim_vector (octave_idx_type *r) : rep (r) { } |
|
14951
4c9fd3e31436
Start of jit support for double matricies
Max Brister <max@2bass.com>
parents:
14625
diff
changeset
|
220 |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
221 static dim_vector alloc (int n) |
| 10150 | 222 { |
| 223 return dim_vector (newrep (n < 2 ? 2 : n)); | |
| 224 } | |
| 4548 | 225 |
| 226 dim_vector& operator = (const dim_vector& dv) | |
| 227 { | |
| 228 if (&dv != this) | |
| 229 { | |
|
13985
43cc49c7abd1
Use thread-safe atomic reference counting (GCC and MSVC).
Michael Goffioul <michael.goffioul@gmail.com>
parents:
11586
diff
changeset
|
230 if (OCTREFCOUNT_ATOMIC_DECREMENT (&(count())) == 0) |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
231 freerep (); |
| 4548 | 232 |
| 10150 | 233 rep = dv.rep; |
|
13985
43cc49c7abd1
Use thread-safe atomic reference counting (GCC and MSVC).
Michael Goffioul <michael.goffioul@gmail.com>
parents:
11586
diff
changeset
|
234 OCTREFCOUNT_ATOMIC_INCREMENT (&(count())); |
| 4548 | 235 } |
| 236 | |
| 237 return *this; | |
| 238 } | |
| 239 | |
| 240 ~dim_vector (void) | |
| 241 { | |
|
13985
43cc49c7abd1
Use thread-safe atomic reference counting (GCC and MSVC).
Michael Goffioul <michael.goffioul@gmail.com>
parents:
11586
diff
changeset
|
242 if (OCTREFCOUNT_ATOMIC_DECREMENT (&(count())) == 0) |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
243 freerep (); |
| 4548 | 244 } |
| 245 | |
| 10150 | 246 int length (void) const { return ndims (); } |
| 4513 | 247 |
| 5275 | 248 octave_idx_type& operator () (int i) { return elem (i); } |
| 4513 | 249 |
| 5275 | 250 octave_idx_type operator () (int i) const { return elem (i); } |
| 4513 | 251 |
| 4887 | 252 void resize (int n, int fill_value = 0) |
| 4548 | 253 { |
| 254 int len = length (); | |
| 4513 | 255 |
| 4548 | 256 if (n != len) |
| 257 { | |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
258 octave_idx_type *r = resizerep (n, fill_value); |
| 4513 | 259 |
|
13985
43cc49c7abd1
Use thread-safe atomic reference counting (GCC and MSVC).
Michael Goffioul <michael.goffioul@gmail.com>
parents:
11586
diff
changeset
|
260 if (OCTREFCOUNT_ATOMIC_DECREMENT (&(count())) == 0) |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
261 freerep (); |
| 4513 | 262 |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
263 rep = r; |
| 4548 | 264 } |
| 265 } | |
| 4513 | 266 |
|
10681
0ba9bd294421
make cat() (hopefully) more matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10645
diff
changeset
|
267 std::string str (char sep = 'x') const; |
| 4543 | 268 |
| 269 bool all_zero (void) const | |
| 4548 | 270 { |
| 271 bool retval = true; | |
| 4543 | 272 |
| 4548 | 273 for (int i = 0; i < length (); i++) |
| 274 { | |
| 10150 | 275 if (elem (i) != 0) |
| 276 { | |
| 277 retval = false; | |
| 278 break; | |
| 279 } | |
| 4548 | 280 } |
| 4543 | 281 |
| 4548 | 282 return retval; |
| 283 } | |
| 4559 | 284 |
|
10715
53253f796351
make [] (hopefully) more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10681
diff
changeset
|
285 bool empty_2d (void) const |
|
53253f796351
make [] (hopefully) more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10681
diff
changeset
|
286 { |
|
53253f796351
make [] (hopefully) more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10681
diff
changeset
|
287 return length () == 2 && (elem (0) == 0 || elem (1) == 0); |
|
53253f796351
make [] (hopefully) more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10681
diff
changeset
|
288 } |
|
53253f796351
make [] (hopefully) more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10681
diff
changeset
|
289 |
|
53253f796351
make [] (hopefully) more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10681
diff
changeset
|
290 |
|
9886
cddd5c3d5f04
fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
9840
diff
changeset
|
291 bool zero_by_zero (void) const |
|
cddd5c3d5f04
fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
9840
diff
changeset
|
292 { |
|
cddd5c3d5f04
fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
9840
diff
changeset
|
293 return length () == 2 && elem (0) == 0 && elem (1) == 0; |
|
cddd5c3d5f04
fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
9840
diff
changeset
|
294 } |
|
cddd5c3d5f04
fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
9840
diff
changeset
|
295 |
| 4559 | 296 bool any_zero (void) const |
| 297 { | |
| 298 bool retval = false; | |
| 299 | |
| 300 for (int i = 0; i < length (); i++) | |
| 301 { | |
| 10150 | 302 if (elem (i) == 0) |
| 303 { | |
| 304 retval = true; | |
| 305 break; | |
| 306 } | |
| 4559 | 307 } |
| 308 | |
| 309 return retval; | |
| 310 } | |
| 4567 | 311 |
|
10681
0ba9bd294421
make cat() (hopefully) more matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10645
diff
changeset
|
312 int num_ones (void) const; |
| 4635 | 313 |
| 10150 | 314 bool all_ones (void) const |
| 4655 | 315 { |
| 316 return (num_ones () == length ()); | |
| 317 } | |
| 318 | |
|
19391
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
319 //! Number of elements that a matrix with this dimensions would have. |
|
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
320 /*! |
|
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
321 Return the number of elements that a matrix with this dimension |
|
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
322 vector would have, NOT the number of dimensions (elements in the |
|
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
323 dimension vector). |
|
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
324 */ |
| 4567 | 325 |
|
9027
9a46ba093db4
generalize dim_vector::numel
Jaroslav Hajek <highegg@gmail.com>
parents:
8950
diff
changeset
|
326 octave_idx_type numel (int n = 0) const |
| 4567 | 327 { |
| 328 int n_dims = length (); | |
| 329 | |
|
9027
9a46ba093db4
generalize dim_vector::numel
Jaroslav Hajek <highegg@gmail.com>
parents:
8950
diff
changeset
|
330 octave_idx_type retval = 1; |
| 4567 | 331 |
|
9027
9a46ba093db4
generalize dim_vector::numel
Jaroslav Hajek <highegg@gmail.com>
parents:
8950
diff
changeset
|
332 for (int i = n; i < n_dims; i++) |
| 4567 | 333 retval *= elem (i); |
| 334 | |
| 335 return retval; | |
| 336 } | |
| 4673 | 337 |
|
19391
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
338 /*! |
|
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
339 The following function will throw a std::bad_alloc () |
|
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
340 exception if the requested size is larger than can be indexed by |
|
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
341 octave_idx_type. This may be smaller than the actual amount of |
|
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
342 memory that can be safely allocated on a system. However, if we |
|
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
343 don't fail here, we can end up with a mysterious crash inside a |
|
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
344 function that is iterating over an array using octave_idx_type |
|
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
345 indices. |
|
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
346 */ |
|
9840
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
347 |
|
10681
0ba9bd294421
make cat() (hopefully) more matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10645
diff
changeset
|
348 octave_idx_type safe_numel (void) const; |
|
9840
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
349 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
350 bool any_neg (void) const |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
351 { |
| 10150 | 352 int n_dims = length (); |
| 353 int i; | |
| 354 | |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
355 for (i = 0; i < n_dims; i++) |
| 10150 | 356 if (elem (i) < 0) |
| 357 break; | |
| 358 | |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
359 return i < n_dims; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
360 } |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
361 |
|
10681
0ba9bd294421
make cat() (hopefully) more matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10645
diff
changeset
|
362 dim_vector squeeze (void) const; |
|
10498
8615b55b5caf
fix & improve cat (bug #29465)
Jaroslav Hajek <highegg@gmail.com>
parents:
10420
diff
changeset
|
363 |
|
19391
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
364 //! This corresponds to cat(). |
|
10715
53253f796351
make [] (hopefully) more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10681
diff
changeset
|
365 bool concat (const dim_vector& dvb, int dim); |
|
53253f796351
make [] (hopefully) more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10681
diff
changeset
|
366 |
|
19391
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
367 //! This corresponds to [,] (horzcat, dim = 0) and [;] (vertcat, dim = 1). |
|
10715
53253f796351
make [] (hopefully) more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10681
diff
changeset
|
368 // The rules are more relaxed here. |
|
53253f796351
make [] (hopefully) more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10681
diff
changeset
|
369 bool hvcat (const dim_vector& dvb, int dim); |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
370 |
|
19391
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
371 /*! |
|
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
372 Force certain dimensionality, preserving numel (). Missing |
|
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
373 dimensions are set to 1, redundant are folded into the trailing |
|
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
374 one. If n = 1, the result is 2d and the second dim is 1 |
|
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
375 (dim_vectors are always at least 2D). |
|
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
376 */ |
|
10681
0ba9bd294421
make cat() (hopefully) more matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10645
diff
changeset
|
377 dim_vector redim (int n) const; |
|
8721
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
378 |
|
10350
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10150
diff
changeset
|
379 dim_vector as_column (void) const |
|
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
380 { |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
381 if (length () == 2 && elem (1) == 1) |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
382 return *this; |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
383 else |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
384 return dim_vector (numel (), 1); |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
385 } |
|
10350
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10150
diff
changeset
|
386 |
|
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10150
diff
changeset
|
387 dim_vector as_row (void) const |
|
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
388 { |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
389 if (length () == 2 && elem (0) == 1) |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
390 return *this; |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
391 else |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
392 return dim_vector (1, numel ()); |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
393 } |
|
10350
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10150
diff
changeset
|
394 |
|
8721
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
395 bool is_vector (void) const |
|
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
396 { |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
397 return (length () == 2 && (elem (0) == 1 || elem (1) == 1)); |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
398 } |
|
8721
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
399 |
|
9511
cc1fd3084cb2
implement dim_vector::first_non_singleton
Jaroslav Hajek <highegg@gmail.com>
parents:
9507
diff
changeset
|
400 int first_non_singleton (int def = 0) const |
|
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
401 { |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
402 for (int i = 0; i < length (); i++) |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
403 { |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
404 if (elem (i) != 1) |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
405 return i; |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
406 } |
|
9511
cc1fd3084cb2
implement dim_vector::first_non_singleton
Jaroslav Hajek <highegg@gmail.com>
parents:
9507
diff
changeset
|
407 |
|
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
408 return def; |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
409 } |
|
9511
cc1fd3084cb2
implement dim_vector::first_non_singleton
Jaroslav Hajek <highegg@gmail.com>
parents:
9507
diff
changeset
|
410 |
|
19391
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
411 //! Compute a linear index from an index tuple. |
| 10150 | 412 |
|
10645
8645b7087859
abstract scalar index checking off Array<T> (prep for struct optimizations)
Jaroslav Hajek <highegg@gmail.com>
parents:
10586
diff
changeset
|
413 octave_idx_type compute_index (const octave_idx_type *idx) const |
|
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
414 { |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
415 octave_idx_type k = 0; |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
416 for (int i = length () - 1; i >= 0; i--) |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
417 k = k * rep[i] + idx[i]; |
|
9739
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
418 |
|
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
419 return k; |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
420 } |
|
9739
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
421 |
|
19391
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
422 //! Ditto, but the tuple may be incomplete (nidx < length ()). |
|
10645
8645b7087859
abstract scalar index checking off Array<T> (prep for struct optimizations)
Jaroslav Hajek <highegg@gmail.com>
parents:
10586
diff
changeset
|
423 |
|
8645b7087859
abstract scalar index checking off Array<T> (prep for struct optimizations)
Jaroslav Hajek <highegg@gmail.com>
parents:
10586
diff
changeset
|
424 octave_idx_type compute_index (const octave_idx_type *idx, int nidx) const |
|
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
425 { |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
426 octave_idx_type k = 0; |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
427 for (int i = nidx - 1; i >= 0; i--) |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
428 k = k * rep[i] + idx[i]; |
|
10645
8645b7087859
abstract scalar index checking off Array<T> (prep for struct optimizations)
Jaroslav Hajek <highegg@gmail.com>
parents:
10586
diff
changeset
|
429 |
|
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
430 return k; |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
431 } |
|
10645
8645b7087859
abstract scalar index checking off Array<T> (prep for struct optimizations)
Jaroslav Hajek <highegg@gmail.com>
parents:
10586
diff
changeset
|
432 |
|
19391
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
433 /*/! |
|
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
434 Increment a multi-dimensional index tuple, optionally starting |
|
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
435 from an offset position and return the index of the last index |
|
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
436 position that was changed, or length () if just cycled over. |
|
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
437 */ |
| 10150 | 438 |
|
10645
8645b7087859
abstract scalar index checking off Array<T> (prep for struct optimizations)
Jaroslav Hajek <highegg@gmail.com>
parents:
10586
diff
changeset
|
439 int increment_index (octave_idx_type *idx, int start = 0) const |
|
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
440 { |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
441 int i; |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
442 for (i = start; i < length (); i++) |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
443 { |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
444 if (++(*idx) == rep[i]) |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
445 *idx++ = 0; |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
446 else |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
447 break; |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
448 } |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
449 return i; |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
450 } |
|
9739
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
451 |
|
19391
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
452 //! Return cumulative dimensions. |
| 10150 | 453 |
|
9739
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
454 dim_vector cumulative (void) const |
|
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
455 { |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
456 int nd = length (); |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
457 dim_vector retval = alloc (nd); |
|
9739
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
458 |
|
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
459 octave_idx_type k = 1; |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
460 for (int i = 0; i < nd; i++) |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
461 retval.rep[i] = k *= rep[i]; |
|
9739
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
462 |
|
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
463 return retval; |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
464 } |
|
9739
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
465 |
|
19391
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
466 //! Compute a linear index from an index tuple. Dimensions are |
|
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
467 //! required to be cumulative. |
| 10150 | 468 |
|
10645
8645b7087859
abstract scalar index checking off Array<T> (prep for struct optimizations)
Jaroslav Hajek <highegg@gmail.com>
parents:
10586
diff
changeset
|
469 octave_idx_type cum_compute_index (const octave_idx_type *idx) const |
|
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
470 { |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
471 octave_idx_type k = idx[0]; |
|
9739
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
472 |
|
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
473 for (int i = 1; i < length (); i++) |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
474 k += rep[i-1] * idx[i]; |
|
9739
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
475 |
|
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
476 return k; |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
477 } |
|
9739
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
478 |
|
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
479 |
|
9694
50db3c5175b5
allow unpacked form of LU
Jaroslav Hajek <highegg@gmail.com>
parents:
9666
diff
changeset
|
480 friend bool operator == (const dim_vector& a, const dim_vector& b); |
| 4513 | 481 }; |
| 482 | |
|
9694
50db3c5175b5
allow unpacked form of LU
Jaroslav Hajek <highegg@gmail.com>
parents:
9666
diff
changeset
|
483 inline bool |
| 4543 | 484 operator == (const dim_vector& a, const dim_vector& b) |
| 485 { | |
|
9694
50db3c5175b5
allow unpacked form of LU
Jaroslav Hajek <highegg@gmail.com>
parents:
9666
diff
changeset
|
486 // Fast case. |
|
50db3c5175b5
allow unpacked form of LU
Jaroslav Hajek <highegg@gmail.com>
parents:
9666
diff
changeset
|
487 if (a.rep == b.rep) |
|
50db3c5175b5
allow unpacked form of LU
Jaroslav Hajek <highegg@gmail.com>
parents:
9666
diff
changeset
|
488 return true; |
|
50db3c5175b5
allow unpacked form of LU
Jaroslav Hajek <highegg@gmail.com>
parents:
9666
diff
changeset
|
489 |
| 4543 | 490 bool retval = true; |
| 491 | |
| 492 int a_len = a.length (); | |
| 493 int b_len = b.length (); | |
| 494 | |
| 495 if (a_len != b_len) | |
| 496 retval = false; | |
| 497 else | |
| 498 { | |
| 499 for (int i = 0; i < a_len; i++) | |
| 10150 | 500 { |
| 501 if (a(i) != b(i)) | |
| 502 { | |
| 503 retval = false; | |
| 504 break; | |
| 505 } | |
| 506 } | |
| 4543 | 507 } |
| 508 | |
| 509 return retval; | |
| 510 } | |
| 511 | |
|
9694
50db3c5175b5
allow unpacked form of LU
Jaroslav Hajek <highegg@gmail.com>
parents:
9666
diff
changeset
|
512 inline bool |
| 4543 | 513 operator != (const dim_vector& a, const dim_vector& b) |
| 514 { | |
| 515 return ! operator == (a, b); | |
| 516 } | |
| 517 | |
| 4513 | 518 #endif |