Mercurial > octave-nkf
annotate liboctave/dim-vector.h @ 10403:69ecfbffcf4f
liboctave/dim-vector.h: New constructor accepting a C array of dimensions.
| author | Soren Hauberg <hauberg@gmail.com> |
|---|---|
| date | Sun, 07 Mar 2010 15:01:47 -0800 |
| parents | e5ae13b8b2c2 |
| children | 6c19d6fcd7e5 |
| rev | line source |
|---|---|
| 4513 | 1 /* |
| 2 | |
| 8920 | 3 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 John W. Eaton |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
4 Copyirght (C) 2009 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" |
| 4513 | 34 |
| 10150 | 35 // Rationale: This implementation is more tricky than Array, but the |
| 36 // big plus is that dim_vector requires only one allocation instead of | |
| 37 // two. It is (slightly) patterned after GCC's basic_string | |
| 38 // implementation. rep is a pointer to an array of memory, comprising | |
| 39 // count, length, and the data: | |
| 40 // | |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
41 // <count> |
|
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
42 // <ndims> |
|
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
43 // rep --> <dims[0]> |
|
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
44 // <dims[1]> |
| 10150 | 45 // ... |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
46 // |
| 10150 | 47 // The inlines count(), ndims() recover this data from the rep. Note |
| 48 // that rep points to the beginning of dims to grant faster access | |
| 49 // (reinterpret_cast is assumed to be an inexpensive operation). | |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
50 |
| 4513 | 51 class |
| 52 dim_vector | |
| 53 { | |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
54 private: |
| 4513 | 55 |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
56 octave_idx_type *rep; |
| 4548 | 57 |
| 10150 | 58 octave_idx_type& ndims (void) const { return rep[-1]; } |
| 4513 | 59 |
| 10150 | 60 octave_idx_type& count (void) const { return rep[-2]; } |
| 4513 | 61 |
| 10150 | 62 // Construct a new rep with count = 1 and ndims given. |
| 63 | |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
64 static octave_idx_type *newrep (int ndims) |
| 10150 | 65 { |
| 66 octave_idx_type *r = new octave_idx_type[ndims + 2]; | |
| 67 | |
| 68 *r++ = 1; | |
| 69 *r++ = ndims; | |
| 4513 | 70 |
| 10150 | 71 return r; |
| 72 } | |
| 73 | |
| 74 // Clone this->rep. | |
| 75 | |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
76 octave_idx_type *clonerep (void) |
| 10150 | 77 { |
| 78 int l = ndims (); | |
| 79 | |
| 80 octave_idx_type *r = new octave_idx_type[l + 2]; | |
| 81 | |
| 82 *r++ = 1; | |
| 83 *r++ = l; | |
| 4513 | 84 |
| 10150 | 85 for (int i = 0; i < l; i++) |
| 86 r[i] = rep[i]; | |
| 87 | |
| 88 return r; | |
| 89 } | |
| 90 | |
| 91 // Clone and resize this->rep to length n, filling by given value. | |
| 92 | |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
93 octave_idx_type *resizerep (int n, octave_idx_type fill_value) |
| 10150 | 94 { |
| 95 int l = ndims (); | |
| 96 | |
| 97 if (n < 2) | |
| 98 n = 2; | |
| 99 | |
| 100 octave_idx_type *r = new octave_idx_type[n + 2]; | |
| 101 | |
| 102 *r++ = 1; | |
| 103 *r++ = n; | |
| 104 | |
| 105 if (l > n) | |
| 106 l = n; | |
| 4673 | 107 |
| 10150 | 108 int j; |
| 109 for (j = 0; j < l; j++) | |
| 110 r[j] = rep[j]; | |
| 111 for (; j < n; j++) | |
| 112 r[j] = fill_value; | |
| 113 | |
| 114 return r; | |
| 115 } | |
| 116 | |
| 117 // Free the rep. | |
| 118 | |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
119 void freerep (void) |
| 10150 | 120 { |
| 121 assert (count () == 0); | |
| 122 delete [] (rep - 2); | |
| 123 } | |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
124 |
| 4548 | 125 void make_unique (void) |
| 126 { | |
| 10150 | 127 if (count () > 1) |
| 4548 | 128 { |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
129 --count(); |
|
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
130 rep = clonerep (); |
| 4548 | 131 } |
| 132 } | |
| 133 | |
| 134 public: | |
| 135 | |
|
10350
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10150
diff
changeset
|
136 explicit dim_vector (octave_idx_type n) GCC_ATTR_DEPRECATED |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
137 : rep (newrep (2)) |
| 10150 | 138 { |
| 139 rep[0] = n; | |
| 140 rep[1] = 1; | |
| 141 } | |
| 4548 | 142 |
| 5275 | 143 explicit dim_vector (octave_idx_type r, octave_idx_type c) |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
144 : rep (newrep (2)) |
| 10150 | 145 { |
| 146 rep[0] = r; | |
| 147 rep[1] = c; | |
| 148 } | |
| 4548 | 149 |
| 5275 | 150 explicit dim_vector (octave_idx_type r, octave_idx_type c, octave_idx_type p) |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
151 : rep (newrep (3)) |
| 10150 | 152 { |
| 153 rep[0] = r; | |
| 154 rep[1] = c; | |
| 155 rep[2] = p; | |
| 156 } | |
|
10403
69ecfbffcf4f
liboctave/dim-vector.h: New constructor accepting a C array of dimensions.
Soren Hauberg <hauberg@gmail.com>
parents:
10366
diff
changeset
|
157 |
|
69ecfbffcf4f
liboctave/dim-vector.h: New constructor accepting a C array of dimensions.
Soren Hauberg <hauberg@gmail.com>
parents:
10366
diff
changeset
|
158 dim_vector (const octave_idx_type *vec, size_t vec_size) |
|
69ecfbffcf4f
liboctave/dim-vector.h: New constructor accepting a C array of dimensions.
Soren Hauberg <hauberg@gmail.com>
parents:
10366
diff
changeset
|
159 : rep (newrep (vec_size)) |
|
69ecfbffcf4f
liboctave/dim-vector.h: New constructor accepting a C array of dimensions.
Soren Hauberg <hauberg@gmail.com>
parents:
10366
diff
changeset
|
160 { |
|
69ecfbffcf4f
liboctave/dim-vector.h: New constructor accepting a C array of dimensions.
Soren Hauberg <hauberg@gmail.com>
parents:
10366
diff
changeset
|
161 for (size_t k = 0; k < vec_size; k++) |
|
69ecfbffcf4f
liboctave/dim-vector.h: New constructor accepting a C array of dimensions.
Soren Hauberg <hauberg@gmail.com>
parents:
10366
diff
changeset
|
162 rep[k] = vec[k]; |
|
69ecfbffcf4f
liboctave/dim-vector.h: New constructor accepting a C array of dimensions.
Soren Hauberg <hauberg@gmail.com>
parents:
10366
diff
changeset
|
163 } |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
164 |
|
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
165 octave_idx_type& elem (int i) |
| 10150 | 166 { |
|
10366
e5ae13b8b2c2
improve Array indexing error messages
Jaroslav Hajek <highegg@gmail.com>
parents:
10350
diff
changeset
|
167 #ifdef BOUNDS_CHECKING |
| 10150 | 168 assert (i >= 0 && i < ndims ()); |
|
10366
e5ae13b8b2c2
improve Array indexing error messages
Jaroslav Hajek <highegg@gmail.com>
parents:
10350
diff
changeset
|
169 #endif |
| 10150 | 170 make_unique (); |
| 171 return rep[i]; | |
| 172 } | |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
173 |
|
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
174 octave_idx_type elem (int i) const |
| 10150 | 175 { |
|
10366
e5ae13b8b2c2
improve Array indexing error messages
Jaroslav Hajek <highegg@gmail.com>
parents:
10350
diff
changeset
|
176 #ifdef BOUNDS_CHECKING |
| 10150 | 177 assert (i >= 0 && i < ndims ()); |
|
10366
e5ae13b8b2c2
improve Array indexing error messages
Jaroslav Hajek <highegg@gmail.com>
parents:
10350
diff
changeset
|
178 #endif |
| 10150 | 179 return rep[i]; |
| 180 } | |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
181 |
|
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
182 void chop_trailing_singletons (void) |
| 10150 | 183 { |
| 184 int l = ndims (); | |
| 185 if (l > 2 && rep[l-1] == 1) | |
| 186 { | |
| 187 make_unique (); | |
| 188 do | |
| 189 l--; | |
| 190 while (l > 2 && rep[l-1] == 1); | |
| 191 ndims () = l; | |
| 192 } | |
| 193 } | |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
194 |
|
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
195 void chop_all_singletons (void) |
| 10150 | 196 { |
| 197 make_unique (); | |
| 198 | |
| 199 int j = 0; | |
| 200 int l = ndims(); | |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
201 |
| 10150 | 202 for (int i = 0; i < l; i++) |
| 203 { | |
| 204 if (rep[i] != 1) | |
| 205 rep[j++] = rep[i]; | |
| 206 } | |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
207 |
| 10150 | 208 if (j == 1) |
| 209 rep[1] = 1; | |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
210 |
| 10150 | 211 ndims () = j > 2 ? j : 2; |
| 212 } | |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
213 |
|
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
214 private: |
|
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
215 |
|
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
216 static octave_idx_type *nil_rep (void) |
|
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
217 { |
|
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
218 static dim_vector zv (0, 0); |
|
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
219 return zv.rep; |
|
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
220 } |
|
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
221 |
|
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
222 explicit dim_vector (octave_idx_type *r) |
|
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
223 : rep (r) { } |
|
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
224 |
|
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
225 public: |
|
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
226 |
| 10150 | 227 explicit dim_vector (void) : rep (nil_rep ()) { count()++; } |
| 4548 | 228 |
| 10150 | 229 dim_vector (const dim_vector& dv) : rep (dv.rep) { count()++; } |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
230 |
|
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
231 static dim_vector alloc (int n) |
| 10150 | 232 { |
| 233 return dim_vector (newrep (n < 2 ? 2 : n)); | |
| 234 } | |
| 4548 | 235 |
| 236 dim_vector& operator = (const dim_vector& dv) | |
| 237 { | |
| 238 if (&dv != this) | |
| 239 { | |
| 10150 | 240 if (--count() <= 0) |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
241 freerep (); |
| 4548 | 242 |
| 10150 | 243 rep = dv.rep; |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
244 count()++; |
| 4548 | 245 } |
| 246 | |
| 247 return *this; | |
| 248 } | |
| 249 | |
| 250 ~dim_vector (void) | |
| 251 { | |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
252 if (--count() <= 0) |
|
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
253 freerep (); |
| 4548 | 254 } |
| 255 | |
| 10150 | 256 int length (void) const { return ndims (); } |
| 4513 | 257 |
| 5275 | 258 octave_idx_type& operator () (int i) { return elem (i); } |
| 4513 | 259 |
| 5275 | 260 octave_idx_type operator () (int i) const { return elem (i); } |
| 4513 | 261 |
| 4887 | 262 void resize (int n, int fill_value = 0) |
| 4548 | 263 { |
| 264 int len = length (); | |
| 4513 | 265 |
| 4548 | 266 if (n != len) |
| 267 { | |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
268 octave_idx_type *r = resizerep (n, fill_value); |
| 4513 | 269 |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
270 if (--count() <= 0) |
|
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
271 freerep (); |
| 4513 | 272 |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
273 rep = r; |
| 4548 | 274 } |
| 275 } | |
| 4513 | 276 |
| 4559 | 277 std::string str (char sep = 'x') const |
| 4548 | 278 { |
| 5765 | 279 std::ostringstream buf; |
| 4543 | 280 |
| 4548 | 281 for (int i = 0; i < length (); i++) |
| 282 { | |
| 10150 | 283 buf << elem (i); |
| 4543 | 284 |
| 10150 | 285 if (i < length () - 1) |
| 286 buf << sep; | |
| 4548 | 287 } |
| 4543 | 288 |
| 5765 | 289 std::string retval = buf.str (); |
| 4543 | 290 |
| 4548 | 291 return retval; |
| 292 } | |
| 4543 | 293 |
| 294 bool all_zero (void) const | |
| 4548 | 295 { |
| 296 bool retval = true; | |
| 4543 | 297 |
| 4548 | 298 for (int i = 0; i < length (); i++) |
| 299 { | |
| 10150 | 300 if (elem (i) != 0) |
| 301 { | |
| 302 retval = false; | |
| 303 break; | |
| 304 } | |
| 4548 | 305 } |
| 4543 | 306 |
| 4548 | 307 return retval; |
| 308 } | |
| 4559 | 309 |
|
9886
cddd5c3d5f04
fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
9840
diff
changeset
|
310 bool zero_by_zero (void) const |
|
cddd5c3d5f04
fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
9840
diff
changeset
|
311 { |
|
cddd5c3d5f04
fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
9840
diff
changeset
|
312 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
|
313 } |
|
cddd5c3d5f04
fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
9840
diff
changeset
|
314 |
| 4559 | 315 bool any_zero (void) const |
| 316 { | |
| 317 bool retval = false; | |
| 318 | |
| 319 for (int i = 0; i < length (); i++) | |
| 320 { | |
| 10150 | 321 if (elem (i) == 0) |
| 322 { | |
| 323 retval = true; | |
| 324 break; | |
| 325 } | |
| 4559 | 326 } |
| 327 | |
| 328 return retval; | |
| 329 } | |
| 4567 | 330 |
| 10150 | 331 int num_ones (void) const |
| 4635 | 332 { |
| 333 int retval = 0; | |
| 334 | |
| 335 for (int i = 0; i < length (); i++) | |
| 336 if (elem (i) == 1) | |
| 10150 | 337 retval++; |
| 4635 | 338 |
| 339 return retval; | |
| 340 } | |
| 341 | |
| 10150 | 342 bool all_ones (void) const |
| 4655 | 343 { |
| 344 return (num_ones () == length ()); | |
| 345 } | |
| 346 | |
| 10150 | 347 // Return the number of elements that a matrix with this dimension |
| 4567 | 348 // vector would have, NOT the number of dimensions (elements in the |
| 349 // dimension vector). | |
| 350 | |
|
9027
9a46ba093db4
generalize dim_vector::numel
Jaroslav Hajek <highegg@gmail.com>
parents:
8950
diff
changeset
|
351 octave_idx_type numel (int n = 0) const |
| 4567 | 352 { |
| 353 int n_dims = length (); | |
| 354 | |
|
9027
9a46ba093db4
generalize dim_vector::numel
Jaroslav Hajek <highegg@gmail.com>
parents:
8950
diff
changeset
|
355 octave_idx_type retval = 1; |
| 4567 | 356 |
|
9027
9a46ba093db4
generalize dim_vector::numel
Jaroslav Hajek <highegg@gmail.com>
parents:
8950
diff
changeset
|
357 for (int i = n; i < n_dims; i++) |
| 4567 | 358 retval *= elem (i); |
| 359 | |
| 360 return retval; | |
| 361 } | |
| 4673 | 362 |
|
9840
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
363 // The following function will throw a std::bad_alloc () |
|
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
364 // exception if the requested size is larger than can be indexed by |
|
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
365 // octave_idx_type. This may be smaller than the actual amount of |
|
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
366 // memory that can be safely allocated on a system. However, if we |
|
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
367 // don't fail here, we can end up with a mysterious crash inside a |
|
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
368 // function that is iterating over an array using octave_idx_type |
|
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
369 // indices. |
|
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
370 |
|
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
371 octave_idx_type safe_numel (void) const |
|
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
372 { |
|
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
373 octave_idx_type idx_max = std::numeric_limits<octave_idx_type>::max () - 1; |
|
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
374 octave_idx_type n = 1; |
|
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
375 int n_dims = length (); |
| 10150 | 376 |
|
9840
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
377 for (int i = 0; i < n_dims; i++) |
|
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
378 { |
|
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
379 n *= rep[i]; |
|
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
380 if (rep[i] != 0) |
|
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
381 idx_max /= rep[i]; |
|
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
382 if (idx_max <= 0) |
|
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
383 throw std::bad_alloc (); |
|
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
384 } |
| 10150 | 385 |
|
9840
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
386 return n; |
|
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
387 } |
|
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
388 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
389 bool any_neg (void) const |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
390 { |
| 10150 | 391 int n_dims = length (); |
| 392 int i; | |
| 393 | |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
394 for (i = 0; i < n_dims; i++) |
| 10150 | 395 if (elem (i) < 0) |
| 396 break; | |
| 397 | |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
398 return i < n_dims; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
399 } |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
400 |
| 4735 | 401 dim_vector squeeze (void) const |
| 402 { | |
| 403 dim_vector new_dims = *this; | |
| 404 | |
| 405 bool dims_changed = 1; | |
| 406 | |
| 407 int k = 0; | |
| 408 | |
| 409 for (int i = 0; i < length (); i++) | |
| 410 { | |
| 10150 | 411 if (elem (i) == 1) |
| 412 dims_changed = true; | |
| 413 else | |
| 414 new_dims(k++) = elem (i); | |
| 4735 | 415 } |
| 416 | |
| 417 if (dims_changed) | |
| 418 { | |
| 10150 | 419 if (k == 0) |
| 420 new_dims = dim_vector (1, 1); | |
| 421 else if (k == 1) | |
| 422 { | |
| 423 // There is one non-singleton dimension, so we need | |
| 424 // to decide the correct orientation. | |
| 4735 | 425 |
| 10150 | 426 if (elem (0) == 1) |
| 427 { | |
| 428 // The original dimension vector had a leading | |
| 429 // singleton dimension. | |
| 4735 | 430 |
| 10150 | 431 octave_idx_type tmp = new_dims(0); |
| 432 | |
| 433 new_dims.resize (2); | |
| 4735 | 434 |
| 10150 | 435 new_dims(0) = 1; |
| 436 new_dims(1) = tmp; | |
| 437 } | |
| 438 else | |
| 439 { | |
| 440 // The first element of the original dimension vector | |
| 441 // was not a singleton dimension. | |
| 4735 | 442 |
| 10150 | 443 new_dims.resize (2); |
| 4735 | 444 |
| 10150 | 445 new_dims(1) = 1; |
| 446 } | |
| 447 } | |
| 448 else | |
| 449 new_dims.resize(k); | |
| 4735 | 450 } |
| 451 | |
| 452 return new_dims; | |
| 453 } | |
| 4915 | 454 |
| 455 bool concat (const dim_vector& dvb, int dim = 0) | |
| 456 { | |
| 457 if (all_zero ()) | |
| 458 { | |
| 10150 | 459 *this = dvb; |
| 460 return true; | |
| 4915 | 461 } |
| 462 | |
| 463 if (dvb.all_zero ()) | |
| 464 return true; | |
| 465 | |
| 466 int na = length (); | |
| 467 int nb = dvb.length (); | |
| 468 | |
| 469 // Find the max and min value of na and nb | |
| 470 int n_max = na > nb ? na : nb; | |
| 471 int n_min = na < nb ? na : nb; | |
| 472 | |
| 473 // The elements of the dimension vectors can only differ | |
| 474 // if the dim variable differs from the actual dimension | |
| 475 // they differ. | |
| 476 | |
| 477 for (int i = 0; i < n_min; i++) | |
| 478 { | |
| 10150 | 479 if (elem(i) != dvb(i) && dim != i) |
| 480 return false; | |
| 4915 | 481 } |
| 482 | |
| 483 // Ditto. | |
| 484 for (int i = n_min; i < n_max; i++) | |
| 485 { | |
| 10150 | 486 if (na > n_min) |
| 487 { | |
| 488 if (elem(i) != 1 && dim != i) | |
| 489 return false; | |
| 490 } | |
| 491 else | |
| 492 { | |
| 493 if (dvb(i) != 1 && dim != i) | |
| 494 return false; | |
| 495 } | |
| 4915 | 496 } |
| 497 | |
| 498 // If we want to add the dimension vectors at a dimension | |
| 499 // larger than both, then we need to set n_max to this number | |
| 500 // so that we resize *this to the right dimension. | |
| 501 | |
| 502 n_max = n_max > (dim + 1) ? n_max : (dim + 1); | |
| 503 | |
| 504 // Resize *this to the appropriate dimensions. | |
| 505 | |
| 506 if (n_max > na) | |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
507 resize (n_max, 1); |
| 4915 | 508 |
| 509 // Larger or equal since dim has been decremented by one. | |
| 510 | |
| 511 if (dim >= nb) | |
| 4940 | 512 elem (dim)++; |
| 4915 | 513 else |
| 514 elem (dim) += dvb(dim); | |
| 515 | |
| 516 return true; | |
| 517 } | |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
518 |
| 10150 | 519 // Force certain dimensionality, preserving numel (). Missing |
| 520 // dimensions are set to 1, redundant are folded into the trailing | |
| 521 // one. If n = 1, the result is 2d and the second dim is 1 | |
| 522 // (dim_vectors are always at least 2D). If the original dimensions | |
| 523 // were all zero, the padding value is zero. | |
| 524 | |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
525 dim_vector redim (int n) const |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
526 { |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
527 int n_dims = length (); |
| 10150 | 528 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
529 if (n_dims == n) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
530 return *this; |
|
9666
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
531 else if (n_dims < n) |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
532 { |
|
9666
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
533 dim_vector retval = alloc (n); |
|
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
534 |
|
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
535 int pad = 0; |
|
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
536 for (int i = 0; i < n_dims; i++) |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
537 { |
|
9666
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
538 retval.rep[i] = rep[i]; |
|
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
539 if (rep[i] != 0) |
|
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
540 pad = 1; |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
541 } |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
542 |
|
9666
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
543 for (int i = n_dims; i < n; i++) |
|
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
544 retval.rep[i] = pad; |
|
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
545 |
|
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
546 return retval; |
|
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
547 } |
|
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
548 else |
|
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
549 { |
|
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
550 if (n < 1) n = 1; |
|
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
551 |
|
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
552 dim_vector retval = alloc (n); |
|
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
553 |
|
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
554 retval.rep[1] = 1; |
|
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
555 |
|
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
556 for (int i = 0; i < n-1; i++) |
|
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
557 retval.rep[i] = rep[i]; |
|
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
558 |
|
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
559 int k = rep[n-1]; |
|
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
560 for (int i = n; i < n_dims; i++) |
|
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
561 k *= rep[i]; |
|
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
562 |
|
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
563 retval.rep[n-1] = k; |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
564 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
565 return retval; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
566 } |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
567 } |
|
8721
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
568 |
|
10350
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10150
diff
changeset
|
569 dim_vector as_column (void) const |
|
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10150
diff
changeset
|
570 { |
|
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10150
diff
changeset
|
571 if (length () == 2 && elem (1) == 1) |
|
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10150
diff
changeset
|
572 return *this; |
|
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10150
diff
changeset
|
573 else |
|
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10150
diff
changeset
|
574 return dim_vector (numel (), 1); |
|
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10150
diff
changeset
|
575 } |
|
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10150
diff
changeset
|
576 |
|
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10150
diff
changeset
|
577 dim_vector as_row (void) const |
|
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10150
diff
changeset
|
578 { |
|
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10150
diff
changeset
|
579 if (length () == 2 && elem (0) == 1) |
|
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10150
diff
changeset
|
580 return *this; |
|
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10150
diff
changeset
|
581 else |
|
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10150
diff
changeset
|
582 return dim_vector (1, numel ()); |
|
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10150
diff
changeset
|
583 } |
|
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10150
diff
changeset
|
584 |
|
8721
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
585 bool is_vector (void) const |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
586 { |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
587 return (length () == 2 && (elem (0) == 1 || elem (1) == 1)); |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
588 } |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
589 |
|
9511
cc1fd3084cb2
implement dim_vector::first_non_singleton
Jaroslav Hajek <highegg@gmail.com>
parents:
9507
diff
changeset
|
590 int first_non_singleton (int def = 0) const |
|
cc1fd3084cb2
implement dim_vector::first_non_singleton
Jaroslav Hajek <highegg@gmail.com>
parents:
9507
diff
changeset
|
591 { |
|
cc1fd3084cb2
implement dim_vector::first_non_singleton
Jaroslav Hajek <highegg@gmail.com>
parents:
9507
diff
changeset
|
592 for (int i = 0; i < length (); i++) |
|
cc1fd3084cb2
implement dim_vector::first_non_singleton
Jaroslav Hajek <highegg@gmail.com>
parents:
9507
diff
changeset
|
593 { |
|
cc1fd3084cb2
implement dim_vector::first_non_singleton
Jaroslav Hajek <highegg@gmail.com>
parents:
9507
diff
changeset
|
594 if (elem (i) != 1) |
|
cc1fd3084cb2
implement dim_vector::first_non_singleton
Jaroslav Hajek <highegg@gmail.com>
parents:
9507
diff
changeset
|
595 return i; |
|
cc1fd3084cb2
implement dim_vector::first_non_singleton
Jaroslav Hajek <highegg@gmail.com>
parents:
9507
diff
changeset
|
596 } |
|
cc1fd3084cb2
implement dim_vector::first_non_singleton
Jaroslav Hajek <highegg@gmail.com>
parents:
9507
diff
changeset
|
597 |
|
cc1fd3084cb2
implement dim_vector::first_non_singleton
Jaroslav Hajek <highegg@gmail.com>
parents:
9507
diff
changeset
|
598 return def; |
|
cc1fd3084cb2
implement dim_vector::first_non_singleton
Jaroslav Hajek <highegg@gmail.com>
parents:
9507
diff
changeset
|
599 } |
|
cc1fd3084cb2
implement dim_vector::first_non_singleton
Jaroslav Hajek <highegg@gmail.com>
parents:
9507
diff
changeset
|
600 |
| 10150 | 601 // Compute a linear index from an index tuple. |
| 602 | |
|
9739
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
603 octave_idx_type compute_index (const octave_idx_type *idx) |
|
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
604 { |
|
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
605 octave_idx_type k = 0; |
|
9743
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9739
diff
changeset
|
606 for (int i = length () - 1; i >= 0; i--) |
|
9739
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
607 k = k * rep[i] + idx[i]; |
|
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
608 |
|
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
609 return k; |
|
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
610 } |
|
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
611 |
| 10150 | 612 // Increment a multi-dimensional index tuple, optionally starting |
| 613 // from an offset position and return the index of the last index | |
|
9739
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
614 // position that was changed, or length () if just cycled over. |
| 10150 | 615 |
|
9739
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
616 int increment_index (octave_idx_type *idx, int start = 0) |
|
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
617 { |
|
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
618 int i; |
|
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
619 for (i = start; i < length (); i++) |
|
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
620 { |
|
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
621 if (++(*idx) == rep[i]) |
|
9743
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9739
diff
changeset
|
622 *idx++ = 0; |
|
9739
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
623 else |
|
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
624 break; |
|
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
625 } |
|
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
626 return i; |
|
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
627 } |
|
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
628 |
| 10150 | 629 // Return cumulative dimensions. |
| 630 | |
|
9739
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
631 dim_vector cumulative (void) const |
|
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
632 { |
|
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
633 int nd = length (); |
|
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
634 dim_vector retval = alloc (nd); |
|
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
635 |
|
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
636 octave_idx_type k = 1; |
|
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
637 for (int i = 0; i < nd; i++) |
|
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
638 retval.rep[i] = k *= rep[i]; |
|
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
639 |
|
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
640 return retval; |
|
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
641 } |
|
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
642 |
| 10150 | 643 // Compute a linear index from an index tuple. Dimensions are |
| 644 // required to be cumulative. | |
| 645 | |
|
9739
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
646 octave_idx_type cum_compute_index (const octave_idx_type *idx) |
|
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
647 { |
|
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
648 octave_idx_type k = idx[0]; |
|
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
649 |
|
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
650 for (int i = 1; i < length (); i++) |
|
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
651 k += rep[i-1] * idx[i]; |
|
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
652 |
|
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
653 return k; |
|
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
654 } |
|
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
655 |
|
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
656 |
|
9694
50db3c5175b5
allow unpacked form of LU
Jaroslav Hajek <highegg@gmail.com>
parents:
9666
diff
changeset
|
657 friend bool operator == (const dim_vector& a, const dim_vector& b); |
| 4513 | 658 }; |
| 659 | |
|
9694
50db3c5175b5
allow unpacked form of LU
Jaroslav Hajek <highegg@gmail.com>
parents:
9666
diff
changeset
|
660 inline bool |
| 4543 | 661 operator == (const dim_vector& a, const dim_vector& b) |
| 662 { | |
|
9694
50db3c5175b5
allow unpacked form of LU
Jaroslav Hajek <highegg@gmail.com>
parents:
9666
diff
changeset
|
663 // Fast case. |
|
50db3c5175b5
allow unpacked form of LU
Jaroslav Hajek <highegg@gmail.com>
parents:
9666
diff
changeset
|
664 if (a.rep == b.rep) |
|
50db3c5175b5
allow unpacked form of LU
Jaroslav Hajek <highegg@gmail.com>
parents:
9666
diff
changeset
|
665 return true; |
|
50db3c5175b5
allow unpacked form of LU
Jaroslav Hajek <highegg@gmail.com>
parents:
9666
diff
changeset
|
666 |
| 4543 | 667 bool retval = true; |
| 668 | |
| 669 int a_len = a.length (); | |
| 670 int b_len = b.length (); | |
| 671 | |
| 672 if (a_len != b_len) | |
| 673 retval = false; | |
| 674 else | |
| 675 { | |
| 676 for (int i = 0; i < a_len; i++) | |
| 10150 | 677 { |
| 678 if (a(i) != b(i)) | |
| 679 { | |
| 680 retval = false; | |
| 681 break; | |
| 682 } | |
| 683 } | |
| 4543 | 684 } |
| 685 | |
| 686 return retval; | |
| 687 } | |
| 688 | |
|
9694
50db3c5175b5
allow unpacked form of LU
Jaroslav Hajek <highegg@gmail.com>
parents:
9666
diff
changeset
|
689 inline bool |
| 4543 | 690 operator != (const dim_vector& a, const dim_vector& b) |
| 691 { | |
| 692 return ! operator == (a, b); | |
| 693 } | |
| 694 | |
| 4513 | 695 #endif |