Mercurial > hg > octave-nkf
annotate liboctave/dim-vector.h @ 10396:a0b51ac0f88a
optimize accumdim with summation
author | Jaroslav Hajek <highegg@gmail.com> |
---|---|
date | Fri, 05 Mar 2010 12:31:30 +0100 |
parents | e5ae13b8b2c2 |
children | 69ecfbffcf4f |
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 } | |
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
157 |
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
158 octave_idx_type& elem (int i) |
10150 | 159 { |
10366
e5ae13b8b2c2
improve Array indexing error messages
Jaroslav Hajek <highegg@gmail.com>
parents:
10350
diff
changeset
|
160 #ifdef BOUNDS_CHECKING |
10150 | 161 assert (i >= 0 && i < ndims ()); |
10366
e5ae13b8b2c2
improve Array indexing error messages
Jaroslav Hajek <highegg@gmail.com>
parents:
10350
diff
changeset
|
162 #endif |
10150 | 163 make_unique (); |
164 return rep[i]; | |
165 } | |
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
166 |
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
167 octave_idx_type elem (int i) const |
10150 | 168 { |
10366
e5ae13b8b2c2
improve Array indexing error messages
Jaroslav Hajek <highegg@gmail.com>
parents:
10350
diff
changeset
|
169 #ifdef BOUNDS_CHECKING |
10150 | 170 assert (i >= 0 && i < ndims ()); |
10366
e5ae13b8b2c2
improve Array indexing error messages
Jaroslav Hajek <highegg@gmail.com>
parents:
10350
diff
changeset
|
171 #endif |
10150 | 172 return rep[i]; |
173 } | |
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
174 |
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
175 void chop_trailing_singletons (void) |
10150 | 176 { |
177 int l = ndims (); | |
178 if (l > 2 && rep[l-1] == 1) | |
179 { | |
180 make_unique (); | |
181 do | |
182 l--; | |
183 while (l > 2 && rep[l-1] == 1); | |
184 ndims () = l; | |
185 } | |
186 } | |
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
187 |
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
188 void chop_all_singletons (void) |
10150 | 189 { |
190 make_unique (); | |
191 | |
192 int j = 0; | |
193 int l = ndims(); | |
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
194 |
10150 | 195 for (int i = 0; i < l; i++) |
196 { | |
197 if (rep[i] != 1) | |
198 rep[j++] = rep[i]; | |
199 } | |
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
200 |
10150 | 201 if (j == 1) |
202 rep[1] = 1; | |
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
203 |
10150 | 204 ndims () = j > 2 ? j : 2; |
205 } | |
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
206 |
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
207 private: |
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
208 |
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
209 static octave_idx_type *nil_rep (void) |
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
210 { |
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
211 static dim_vector zv (0, 0); |
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
212 return zv.rep; |
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 |
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
215 explicit dim_vector (octave_idx_type *r) |
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
216 : rep (r) { } |
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 public: |
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
219 |
10150 | 220 explicit dim_vector (void) : rep (nil_rep ()) { count()++; } |
4548 | 221 |
10150 | 222 dim_vector (const dim_vector& dv) : rep (dv.rep) { count()++; } |
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
223 |
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
224 static dim_vector alloc (int n) |
10150 | 225 { |
226 return dim_vector (newrep (n < 2 ? 2 : n)); | |
227 } | |
4548 | 228 |
229 dim_vector& operator = (const dim_vector& dv) | |
230 { | |
231 if (&dv != this) | |
232 { | |
10150 | 233 if (--count() <= 0) |
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
234 freerep (); |
4548 | 235 |
10150 | 236 rep = dv.rep; |
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
237 count()++; |
4548 | 238 } |
239 | |
240 return *this; | |
241 } | |
242 | |
243 ~dim_vector (void) | |
244 { | |
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
245 if (--count() <= 0) |
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
246 freerep (); |
4548 | 247 } |
248 | |
10150 | 249 int length (void) const { return ndims (); } |
4513 | 250 |
5275 | 251 octave_idx_type& operator () (int i) { return elem (i); } |
4513 | 252 |
5275 | 253 octave_idx_type operator () (int i) const { return elem (i); } |
4513 | 254 |
4887 | 255 void resize (int n, int fill_value = 0) |
4548 | 256 { |
257 int len = length (); | |
4513 | 258 |
4548 | 259 if (n != len) |
260 { | |
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
261 octave_idx_type *r = resizerep (n, fill_value); |
4513 | 262 |
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
263 if (--count() <= 0) |
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
264 freerep (); |
4513 | 265 |
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
266 rep = r; |
4548 | 267 } |
268 } | |
4513 | 269 |
4559 | 270 std::string str (char sep = 'x') const |
4548 | 271 { |
5765 | 272 std::ostringstream buf; |
4543 | 273 |
4548 | 274 for (int i = 0; i < length (); i++) |
275 { | |
10150 | 276 buf << elem (i); |
4543 | 277 |
10150 | 278 if (i < length () - 1) |
279 buf << sep; | |
4548 | 280 } |
4543 | 281 |
5765 | 282 std::string retval = buf.str (); |
4543 | 283 |
4548 | 284 return retval; |
285 } | |
4543 | 286 |
287 bool all_zero (void) const | |
4548 | 288 { |
289 bool retval = true; | |
4543 | 290 |
4548 | 291 for (int i = 0; i < length (); i++) |
292 { | |
10150 | 293 if (elem (i) != 0) |
294 { | |
295 retval = false; | |
296 break; | |
297 } | |
4548 | 298 } |
4543 | 299 |
4548 | 300 return retval; |
301 } | |
4559 | 302 |
9886
cddd5c3d5f04
fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
9840
diff
changeset
|
303 bool zero_by_zero (void) const |
cddd5c3d5f04
fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
9840
diff
changeset
|
304 { |
cddd5c3d5f04
fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
9840
diff
changeset
|
305 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
|
306 } |
cddd5c3d5f04
fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
9840
diff
changeset
|
307 |
4559 | 308 bool any_zero (void) const |
309 { | |
310 bool retval = false; | |
311 | |
312 for (int i = 0; i < length (); i++) | |
313 { | |
10150 | 314 if (elem (i) == 0) |
315 { | |
316 retval = true; | |
317 break; | |
318 } | |
4559 | 319 } |
320 | |
321 return retval; | |
322 } | |
4567 | 323 |
10150 | 324 int num_ones (void) const |
4635 | 325 { |
326 int retval = 0; | |
327 | |
328 for (int i = 0; i < length (); i++) | |
329 if (elem (i) == 1) | |
10150 | 330 retval++; |
4635 | 331 |
332 return retval; | |
333 } | |
334 | |
10150 | 335 bool all_ones (void) const |
4655 | 336 { |
337 return (num_ones () == length ()); | |
338 } | |
339 | |
10150 | 340 // Return the number of elements that a matrix with this dimension |
4567 | 341 // vector would have, NOT the number of dimensions (elements in the |
342 // dimension vector). | |
343 | |
9027
9a46ba093db4
generalize dim_vector::numel
Jaroslav Hajek <highegg@gmail.com>
parents:
8950
diff
changeset
|
344 octave_idx_type numel (int n = 0) const |
4567 | 345 { |
346 int n_dims = length (); | |
347 | |
9027
9a46ba093db4
generalize dim_vector::numel
Jaroslav Hajek <highegg@gmail.com>
parents:
8950
diff
changeset
|
348 octave_idx_type retval = 1; |
4567 | 349 |
9027
9a46ba093db4
generalize dim_vector::numel
Jaroslav Hajek <highegg@gmail.com>
parents:
8950
diff
changeset
|
350 for (int i = n; i < n_dims; i++) |
4567 | 351 retval *= elem (i); |
352 | |
353 return retval; | |
354 } | |
4673 | 355 |
9840
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
356 // 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
|
357 // 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
|
358 // 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
|
359 // 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
|
360 // 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
|
361 // 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
|
362 // indices. |
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
363 |
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
364 octave_idx_type safe_numel (void) const |
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
365 { |
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
366 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
|
367 octave_idx_type n = 1; |
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
368 int n_dims = length (); |
10150 | 369 |
9840
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
370 for (int i = 0; i < n_dims; i++) |
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
371 { |
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
372 n *= rep[i]; |
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
373 if (rep[i] != 0) |
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
374 idx_max /= rep[i]; |
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
375 if (idx_max <= 0) |
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
376 throw std::bad_alloc (); |
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
377 } |
10150 | 378 |
9840
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
379 return n; |
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
380 } |
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
381 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
382 bool any_neg (void) const |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
383 { |
10150 | 384 int n_dims = length (); |
385 int i; | |
386 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
387 for (i = 0; i < n_dims; i++) |
10150 | 388 if (elem (i) < 0) |
389 break; | |
390 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
391 return i < n_dims; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
392 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
393 |
4735 | 394 dim_vector squeeze (void) const |
395 { | |
396 dim_vector new_dims = *this; | |
397 | |
398 bool dims_changed = 1; | |
399 | |
400 int k = 0; | |
401 | |
402 for (int i = 0; i < length (); i++) | |
403 { | |
10150 | 404 if (elem (i) == 1) |
405 dims_changed = true; | |
406 else | |
407 new_dims(k++) = elem (i); | |
4735 | 408 } |
409 | |
410 if (dims_changed) | |
411 { | |
10150 | 412 if (k == 0) |
413 new_dims = dim_vector (1, 1); | |
414 else if (k == 1) | |
415 { | |
416 // There is one non-singleton dimension, so we need | |
417 // to decide the correct orientation. | |
4735 | 418 |
10150 | 419 if (elem (0) == 1) |
420 { | |
421 // The original dimension vector had a leading | |
422 // singleton dimension. | |
4735 | 423 |
10150 | 424 octave_idx_type tmp = new_dims(0); |
425 | |
426 new_dims.resize (2); | |
4735 | 427 |
10150 | 428 new_dims(0) = 1; |
429 new_dims(1) = tmp; | |
430 } | |
431 else | |
432 { | |
433 // The first element of the original dimension vector | |
434 // was not a singleton dimension. | |
4735 | 435 |
10150 | 436 new_dims.resize (2); |
4735 | 437 |
10150 | 438 new_dims(1) = 1; |
439 } | |
440 } | |
441 else | |
442 new_dims.resize(k); | |
4735 | 443 } |
444 | |
445 return new_dims; | |
446 } | |
4915 | 447 |
448 bool concat (const dim_vector& dvb, int dim = 0) | |
449 { | |
450 if (all_zero ()) | |
451 { | |
10150 | 452 *this = dvb; |
453 return true; | |
4915 | 454 } |
455 | |
456 if (dvb.all_zero ()) | |
457 return true; | |
458 | |
459 int na = length (); | |
460 int nb = dvb.length (); | |
461 | |
462 // Find the max and min value of na and nb | |
463 int n_max = na > nb ? na : nb; | |
464 int n_min = na < nb ? na : nb; | |
465 | |
466 // The elements of the dimension vectors can only differ | |
467 // if the dim variable differs from the actual dimension | |
468 // they differ. | |
469 | |
470 for (int i = 0; i < n_min; i++) | |
471 { | |
10150 | 472 if (elem(i) != dvb(i) && dim != i) |
473 return false; | |
4915 | 474 } |
475 | |
476 // Ditto. | |
477 for (int i = n_min; i < n_max; i++) | |
478 { | |
10150 | 479 if (na > n_min) |
480 { | |
481 if (elem(i) != 1 && dim != i) | |
482 return false; | |
483 } | |
484 else | |
485 { | |
486 if (dvb(i) != 1 && dim != i) | |
487 return false; | |
488 } | |
4915 | 489 } |
490 | |
491 // If we want to add the dimension vectors at a dimension | |
492 // larger than both, then we need to set n_max to this number | |
493 // so that we resize *this to the right dimension. | |
494 | |
495 n_max = n_max > (dim + 1) ? n_max : (dim + 1); | |
496 | |
497 // Resize *this to the appropriate dimensions. | |
498 | |
499 if (n_max > na) | |
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
500 resize (n_max, 1); |
4915 | 501 |
502 // Larger or equal since dim has been decremented by one. | |
503 | |
504 if (dim >= nb) | |
4940 | 505 elem (dim)++; |
4915 | 506 else |
507 elem (dim) += dvb(dim); | |
508 | |
509 return true; | |
510 } | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
511 |
10150 | 512 // Force certain dimensionality, preserving numel (). Missing |
513 // dimensions are set to 1, redundant are folded into the trailing | |
514 // one. If n = 1, the result is 2d and the second dim is 1 | |
515 // (dim_vectors are always at least 2D). If the original dimensions | |
516 // were all zero, the padding value is zero. | |
517 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
518 dim_vector redim (int n) const |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
519 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
520 int n_dims = length (); |
10150 | 521 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
522 if (n_dims == n) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
523 return *this; |
9666
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
524 else if (n_dims < n) |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
525 { |
9666
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
526 dim_vector retval = alloc (n); |
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
527 |
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
528 int pad = 0; |
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
529 for (int i = 0; i < n_dims; i++) |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
530 { |
9666
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
531 retval.rep[i] = rep[i]; |
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
532 if (rep[i] != 0) |
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
533 pad = 1; |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
534 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
535 |
9666
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
536 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
|
537 retval.rep[i] = pad; |
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
538 |
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
539 return retval; |
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
540 } |
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
541 else |
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
542 { |
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
543 if (n < 1) n = 1; |
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
544 |
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
545 dim_vector retval = alloc (n); |
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
546 |
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
547 retval.rep[1] = 1; |
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
548 |
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
549 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
|
550 retval.rep[i] = rep[i]; |
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 int k = rep[n-1]; |
a531dec450c4
allow 1D case for sub2ind and ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9648
diff
changeset
|
553 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
|
554 k *= rep[i]; |
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 retval.rep[n-1] = k; |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
557 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
558 return retval; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
559 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
560 } |
8721
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
561 |
10350
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10150
diff
changeset
|
562 dim_vector as_column (void) const |
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10150
diff
changeset
|
563 { |
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10150
diff
changeset
|
564 if (length () == 2 && elem (1) == 1) |
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10150
diff
changeset
|
565 return *this; |
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10150
diff
changeset
|
566 else |
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10150
diff
changeset
|
567 return dim_vector (numel (), 1); |
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10150
diff
changeset
|
568 } |
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10150
diff
changeset
|
569 |
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10150
diff
changeset
|
570 dim_vector as_row (void) const |
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10150
diff
changeset
|
571 { |
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10150
diff
changeset
|
572 if (length () == 2 && elem (0) == 1) |
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10150
diff
changeset
|
573 return *this; |
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10150
diff
changeset
|
574 else |
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10150
diff
changeset
|
575 return dim_vector (1, numel ()); |
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 |
8721
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
578 bool is_vector (void) const |
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
579 { |
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
580 return (length () == 2 && (elem (0) == 1 || elem (1) == 1)); |
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
581 } |
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
582 |
9511
cc1fd3084cb2
implement dim_vector::first_non_singleton
Jaroslav Hajek <highegg@gmail.com>
parents:
9507
diff
changeset
|
583 int first_non_singleton (int def = 0) const |
cc1fd3084cb2
implement dim_vector::first_non_singleton
Jaroslav Hajek <highegg@gmail.com>
parents:
9507
diff
changeset
|
584 { |
cc1fd3084cb2
implement dim_vector::first_non_singleton
Jaroslav Hajek <highegg@gmail.com>
parents:
9507
diff
changeset
|
585 for (int i = 0; i < length (); i++) |
cc1fd3084cb2
implement dim_vector::first_non_singleton
Jaroslav Hajek <highegg@gmail.com>
parents:
9507
diff
changeset
|
586 { |
cc1fd3084cb2
implement dim_vector::first_non_singleton
Jaroslav Hajek <highegg@gmail.com>
parents:
9507
diff
changeset
|
587 if (elem (i) != 1) |
cc1fd3084cb2
implement dim_vector::first_non_singleton
Jaroslav Hajek <highegg@gmail.com>
parents:
9507
diff
changeset
|
588 return i; |
cc1fd3084cb2
implement dim_vector::first_non_singleton
Jaroslav Hajek <highegg@gmail.com>
parents:
9507
diff
changeset
|
589 } |
cc1fd3084cb2
implement dim_vector::first_non_singleton
Jaroslav Hajek <highegg@gmail.com>
parents:
9507
diff
changeset
|
590 |
cc1fd3084cb2
implement dim_vector::first_non_singleton
Jaroslav Hajek <highegg@gmail.com>
parents:
9507
diff
changeset
|
591 return def; |
cc1fd3084cb2
implement dim_vector::first_non_singleton
Jaroslav Hajek <highegg@gmail.com>
parents:
9507
diff
changeset
|
592 } |
cc1fd3084cb2
implement dim_vector::first_non_singleton
Jaroslav Hajek <highegg@gmail.com>
parents:
9507
diff
changeset
|
593 |
10150 | 594 // Compute a linear index from an index tuple. |
595 | |
9739
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
596 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
|
597 { |
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
598 octave_idx_type k = 0; |
9743
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9739
diff
changeset
|
599 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
|
600 k = k * rep[i] + idx[i]; |
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
601 |
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
602 return k; |
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
603 } |
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
604 |
10150 | 605 // Increment a multi-dimensional index tuple, optionally starting |
606 // 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
|
607 // position that was changed, or length () if just cycled over. |
10150 | 608 |
9739
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
609 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
|
610 { |
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
611 int i; |
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
612 for (i = start; i < length (); i++) |
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
613 { |
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
614 if (++(*idx) == rep[i]) |
9743
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9739
diff
changeset
|
615 *idx++ = 0; |
9739
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
616 else |
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
617 break; |
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
618 } |
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
619 return 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 |
10150 | 622 // Return cumulative dimensions. |
623 | |
9739
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
624 dim_vector cumulative (void) const |
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 int nd = length (); |
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
627 dim_vector retval = alloc (nd); |
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
628 |
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
629 octave_idx_type k = 1; |
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
630 for (int i = 0; i < nd; i++) |
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
631 retval.rep[i] = k *= rep[i]; |
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 return retval; |
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
634 } |
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
635 |
10150 | 636 // Compute a linear index from an index tuple. Dimensions are |
637 // required to be cumulative. | |
638 | |
9739
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
639 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
|
640 { |
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
641 octave_idx_type k = idx[0]; |
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
642 |
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
643 for (int i = 1; i < length (); i++) |
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
644 k += rep[i-1] * idx[i]; |
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
645 |
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
646 return k; |
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 |
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
649 |
9694
50db3c5175b5
allow unpacked form of LU
Jaroslav Hajek <highegg@gmail.com>
parents:
9666
diff
changeset
|
650 friend bool operator == (const dim_vector& a, const dim_vector& b); |
4513 | 651 }; |
652 | |
9694
50db3c5175b5
allow unpacked form of LU
Jaroslav Hajek <highegg@gmail.com>
parents:
9666
diff
changeset
|
653 inline bool |
4543 | 654 operator == (const dim_vector& a, const dim_vector& b) |
655 { | |
9694
50db3c5175b5
allow unpacked form of LU
Jaroslav Hajek <highegg@gmail.com>
parents:
9666
diff
changeset
|
656 // Fast case. |
50db3c5175b5
allow unpacked form of LU
Jaroslav Hajek <highegg@gmail.com>
parents:
9666
diff
changeset
|
657 if (a.rep == b.rep) |
50db3c5175b5
allow unpacked form of LU
Jaroslav Hajek <highegg@gmail.com>
parents:
9666
diff
changeset
|
658 return true; |
50db3c5175b5
allow unpacked form of LU
Jaroslav Hajek <highegg@gmail.com>
parents:
9666
diff
changeset
|
659 |
4543 | 660 bool retval = true; |
661 | |
662 int a_len = a.length (); | |
663 int b_len = b.length (); | |
664 | |
665 if (a_len != b_len) | |
666 retval = false; | |
667 else | |
668 { | |
669 for (int i = 0; i < a_len; i++) | |
10150 | 670 { |
671 if (a(i) != b(i)) | |
672 { | |
673 retval = false; | |
674 break; | |
675 } | |
676 } | |
4543 | 677 } |
678 | |
679 return retval; | |
680 } | |
681 | |
9694
50db3c5175b5
allow unpacked form of LU
Jaroslav Hajek <highegg@gmail.com>
parents:
9666
diff
changeset
|
682 inline bool |
4543 | 683 operator != (const dim_vector& a, const dim_vector& b) |
684 { | |
685 return ! operator == (a, b); | |
686 } | |
687 | |
4513 | 688 #endif |