Mercurial > hg > octave-lyh
annotate liboctave/dim-vector.h @ 8950:d865363208d6
include <iosfwd> instead of <iostream> in header files
| author | John W. Eaton <jwe@octave.org> |
|---|---|
| date | Tue, 10 Mar 2009 13:55:52 -0400 |
| parents | eb63fbe60fab |
| children | 9a46ba093db4 |
| rev | line source |
|---|---|
| 4513 | 1 /* |
| 2 | |
| 8920 | 3 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 John W. Eaton |
| 4513 | 4 |
| 5 This file is part of Octave. | |
| 6 | |
| 7 Octave is free software; you can redistribute it and/or modify it | |
| 8 under the terms of the GNU General Public License as published by the | |
| 7016 | 9 Free Software Foundation; either version 3 of the License, or (at your |
| 10 option) any later version. | |
| 4513 | 11 |
| 12 Octave is distributed in the hope that it will be useful, but WITHOUT | |
| 13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 15 for more details. | |
| 16 | |
| 17 You should have received a copy of the GNU General Public License | |
| 7016 | 18 along with Octave; see the file COPYING. If not, see |
| 19 <http://www.gnu.org/licenses/>. | |
| 4513 | 20 |
| 21 */ | |
| 22 | |
| 23 #if !defined (octave_dim_vector_h) | |
| 24 #define octave_dim_vector_h 1 | |
| 25 | |
| 26 #include <cassert> | |
|
8950
d865363208d6
include <iosfwd> instead of <iostream> in header files
John W. Eaton <jwe@octave.org>
parents:
8920
diff
changeset
|
27 |
| 5765 | 28 #include <sstream> |
| 4543 | 29 #include <string> |
| 30 | |
| 6216 | 31 #include "lo-error.h" |
| 5275 | 32 #include "oct-types.h" |
| 4513 | 33 |
| 34 class | |
| 35 dim_vector | |
| 36 { | |
| 4548 | 37 protected: |
| 4513 | 38 |
| 4548 | 39 class dim_vector_rep |
| 40 { | |
| 41 public: | |
| 4513 | 42 |
| 5275 | 43 octave_idx_type *dims; |
| 4548 | 44 int ndims; |
| 45 int count; | |
| 4513 | 46 |
| 6216 | 47 dim_vector_rep (void) |
| 48 : dims (new octave_idx_type [2]), ndims (2), count (1) | |
| 49 { | |
| 50 dims[0] = 0; | |
| 51 dims[1] = 0; | |
| 52 } | |
| 4548 | 53 |
| 6216 | 54 |
| 55 dim_vector_rep (octave_idx_type n) | |
| 56 : dims (new octave_idx_type [2]), ndims (2), count (1) | |
| 4548 | 57 { |
| 58 dims[0] = n; | |
| 6216 | 59 dims[1] = 1; |
| 4548 | 60 } |
| 4513 | 61 |
| 6216 | 62 dim_vector_rep (octave_idx_type r, octave_idx_type c) |
| 63 : dims (new octave_idx_type [2]), ndims (2), count (1) | |
| 4548 | 64 { |
| 65 dims[0] = r; | |
| 66 dims[1] = c; | |
| 67 } | |
| 4513 | 68 |
| 5275 | 69 dim_vector_rep (octave_idx_type r, octave_idx_type c, octave_idx_type p) |
| 70 : dims (new octave_idx_type [3]), ndims (3), count (1) | |
| 4513 | 71 { |
| 4548 | 72 dims[0] = r; |
| 73 dims[1] = c; | |
| 74 dims[2] = p; | |
| 75 } | |
| 76 | |
| 77 dim_vector_rep (const dim_vector_rep& dv) | |
| 5275 | 78 : dims (dv.ndims > 0 ? new octave_idx_type [dv.ndims] : 0), |
| 4548 | 79 ndims (dv.ndims > 0 ? dv.ndims : 0), count (1) |
| 80 { | |
| 81 if (dims) | |
| 4513 | 82 { |
| 83 for (int i = 0; i < ndims; i++) | |
| 84 dims[i] = dv.dims[i]; | |
| 85 } | |
| 86 } | |
| 87 | |
| 6216 | 88 dim_vector_rep (octave_idx_type n, const dim_vector_rep *dv, |
| 89 int fill_value = 0) | |
| 5275 | 90 : dims ((dv && n > 0) ? new octave_idx_type [n] : 0), |
| 4548 | 91 ndims (n > 0 ? n : 0), count (1) |
| 4513 | 92 { |
| 4548 | 93 if (dims) |
| 4513 | 94 { |
| 4548 | 95 int dv_ndims = dv ? dv->ndims : 0; |
| 4513 | 96 |
| 4565 | 97 int min_len = n < dv_ndims ? n : dv_ndims; |
| 98 | |
| 99 for (int i = 0; i < min_len; i++) | |
| 4548 | 100 dims[i] = dv->dims[i]; |
| 4513 | 101 |
| 4548 | 102 for (int i = dv_ndims; i < n; i++) |
| 4887 | 103 dims[i] = fill_value; |
| 4513 | 104 } |
| 105 } | |
| 106 | |
| 4548 | 107 ~dim_vector_rep (void) { delete [] dims; } |
| 4513 | 108 |
| 4548 | 109 int length (void) const { return ndims; } |
| 4513 | 110 |
| 5275 | 111 octave_idx_type& elem (int i) |
| 4513 | 112 { |
| 4548 | 113 assert (i >= 0 && i < ndims); |
| 114 return dims[i]; | |
| 115 } | |
| 4513 | 116 |
| 5275 | 117 octave_idx_type elem (int i) const |
| 4548 | 118 { |
| 119 assert (i >= 0 && i < ndims); | |
| 4513 | 120 return dims[i]; |
| 121 } | |
| 122 | |
| 4673 | 123 void chop_trailing_singletons (void) |
| 124 { | |
| 125 for (int i = ndims - 1; i > 1; i--) | |
| 126 { | |
| 127 if (dims[i] == 1) | |
| 128 ndims--; | |
| 129 else | |
| 130 break; | |
| 131 } | |
| 132 } | |
| 133 | |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
134 void chop_all_singletons (void) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
135 { |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
136 int j = 0; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
137 for (int i = 0; i < ndims; i++) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
138 { |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
139 if (dims[i] != 1) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
140 dims[j++] = dims[i]; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
141 } |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
142 if (j == 1) dims[1] = 1; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
143 ndims = j > 2 ? j : 2; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
144 } |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
145 |
| 4548 | 146 private: |
| 147 | |
| 148 // No assignment! | |
| 149 | |
| 150 dim_vector_rep& operator = (const dim_vector_rep& dv); | |
| 151 }; | |
| 152 | |
| 153 dim_vector_rep *rep; | |
| 154 | |
| 155 void make_unique (void) | |
| 156 { | |
| 157 if (rep->count > 1) | |
| 158 { | |
| 159 --rep->count; | |
| 160 rep = new dim_vector_rep (*rep); | |
| 161 } | |
| 162 } | |
| 163 | |
| 164 private: | |
| 165 | |
| 166 dim_vector_rep *nil_rep (void) const | |
| 167 { | |
| 168 static dim_vector_rep *nr = new dim_vector_rep (); | |
| 169 | |
| 170 return nr; | |
| 171 } | |
| 172 | |
| 173 public: | |
| 174 | |
| 175 explicit dim_vector (void) | |
| 176 : rep (nil_rep ()) { rep->count++; } | |
| 177 | |
| 5275 | 178 explicit dim_vector (octave_idx_type n) |
| 4548 | 179 : rep (new dim_vector_rep (n)) { } |
| 180 | |
| 5275 | 181 explicit dim_vector (octave_idx_type r, octave_idx_type c) |
| 4548 | 182 : rep (new dim_vector_rep (r, c)) { } |
| 183 | |
| 5275 | 184 explicit dim_vector (octave_idx_type r, octave_idx_type c, octave_idx_type p) |
| 4548 | 185 : rep (new dim_vector_rep (r, c, p)) { } |
| 186 | |
| 187 dim_vector (const dim_vector& dv) | |
| 188 : rep (dv.rep) { rep->count++; } | |
| 189 | |
| 190 dim_vector& operator = (const dim_vector& dv) | |
| 191 { | |
| 192 if (&dv != this) | |
| 193 { | |
| 194 if (--rep->count <= 0) | |
| 195 delete rep; | |
| 196 | |
| 197 rep = dv.rep; | |
| 198 rep->count++; | |
| 199 } | |
| 200 | |
| 201 return *this; | |
| 202 } | |
| 203 | |
| 204 ~dim_vector (void) | |
| 205 { | |
| 206 if (--rep->count <= 0) | |
| 207 delete rep; | |
| 208 } | |
| 209 | |
| 210 int length (void) const { return rep->length (); } | |
| 211 | |
| 5275 | 212 octave_idx_type& elem (int i) { make_unique (); return rep->elem (i); } |
| 4548 | 213 |
| 5275 | 214 octave_idx_type elem (int i) const { return rep->elem (i); } |
| 4513 | 215 |
| 5275 | 216 octave_idx_type& operator () (int i) { return elem (i); } |
| 4513 | 217 |
| 5275 | 218 octave_idx_type operator () (int i) const { return elem (i); } |
| 4513 | 219 |
| 4887 | 220 void resize (int n, int fill_value = 0) |
| 4548 | 221 { |
| 222 int len = length (); | |
| 4513 | 223 |
| 4548 | 224 if (n != len) |
| 225 { | |
| 6216 | 226 if (n < 2) |
| 227 { | |
| 228 (*current_liboctave_error_handler) | |
| 229 ("unable to resize object to fewer than 2 dimensions"); | |
| 230 return; | |
| 231 } | |
| 232 | |
| 4548 | 233 dim_vector_rep *old_rep = rep; |
| 4513 | 234 |
| 4887 | 235 rep = new dim_vector_rep (n, old_rep, fill_value); |
| 4513 | 236 |
| 4548 | 237 if (--old_rep->count <= 0) |
| 238 delete old_rep; | |
| 239 } | |
| 240 } | |
| 4513 | 241 |
| 4559 | 242 std::string str (char sep = 'x') const |
| 4548 | 243 { |
| 5765 | 244 std::ostringstream buf; |
| 4543 | 245 |
| 4548 | 246 for (int i = 0; i < length (); i++) |
| 247 { | |
| 248 buf << elem (i); | |
| 4543 | 249 |
| 4548 | 250 if (i < length () - 1) |
| 4559 | 251 buf << sep; |
| 4548 | 252 } |
| 4543 | 253 |
| 5765 | 254 std::string retval = buf.str (); |
| 4543 | 255 |
| 4548 | 256 return retval; |
| 257 } | |
| 4543 | 258 |
| 259 bool all_zero (void) const | |
| 4548 | 260 { |
| 261 bool retval = true; | |
| 4543 | 262 |
| 4548 | 263 for (int i = 0; i < length (); i++) |
| 264 { | |
| 265 if (elem (i) != 0) | |
| 266 { | |
| 267 retval = false; | |
| 268 break; | |
| 269 } | |
| 270 } | |
| 4543 | 271 |
| 4548 | 272 return retval; |
| 273 } | |
| 4559 | 274 |
| 275 bool any_zero (void) const | |
| 276 { | |
| 277 bool retval = false; | |
| 278 | |
| 279 for (int i = 0; i < length (); i++) | |
| 280 { | |
| 281 if (elem (i) == 0) | |
| 282 { | |
| 283 retval = true; | |
| 284 break; | |
| 285 } | |
| 286 } | |
| 287 | |
| 288 return retval; | |
| 289 } | |
| 4567 | 290 |
| 4635 | 291 int |
| 292 num_ones (void) const | |
| 293 { | |
| 294 int retval = 0; | |
| 295 | |
| 296 for (int i = 0; i < length (); i++) | |
| 297 if (elem (i) == 1) | |
| 298 retval++; | |
| 299 | |
| 300 return retval; | |
| 301 } | |
| 302 | |
| 4655 | 303 bool |
| 304 all_ones (void) const | |
| 305 { | |
| 306 return (num_ones () == length ()); | |
| 307 } | |
| 308 | |
| 4567 | 309 // This is the number of elements that a matrix with this dimension |
| 310 // vector would have, NOT the number of dimensions (elements in the | |
| 311 // dimension vector). | |
| 312 | |
| 5275 | 313 octave_idx_type numel (void) const |
| 4567 | 314 { |
| 315 int n_dims = length (); | |
| 316 | |
| 5275 | 317 octave_idx_type retval = n_dims > 0 ? elem (0) : 0; |
| 4567 | 318 |
| 319 for (int i = 1; i < n_dims; i++) | |
| 320 retval *= elem (i); | |
| 321 | |
| 322 return retval; | |
| 323 } | |
| 4673 | 324 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
325 bool any_neg (void) const |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
326 { |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
327 int n_dims = length (), i; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
328 for (i = 0; i < n_dims; i++) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
329 if (elem (i) < 0) break; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
330 return i < n_dims; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
331 } |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
332 |
| 4673 | 333 void chop_trailing_singletons (void) |
| 334 { | |
| 335 make_unique (); | |
| 336 rep->chop_trailing_singletons (); | |
| 337 } | |
| 4735 | 338 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
339 void chop_all_singletons (void) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
340 { |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
341 make_unique (); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
342 rep->chop_all_singletons (); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
343 } |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
344 |
| 4735 | 345 dim_vector squeeze (void) const |
| 346 { | |
| 347 dim_vector new_dims = *this; | |
| 348 | |
| 349 bool dims_changed = 1; | |
| 350 | |
| 351 int k = 0; | |
| 352 | |
| 353 for (int i = 0; i < length (); i++) | |
| 354 { | |
| 355 if (elem (i) == 1) | |
| 356 dims_changed = true; | |
| 357 else | |
| 358 new_dims(k++) = elem (i); | |
| 359 } | |
| 360 | |
| 361 if (dims_changed) | |
| 362 { | |
| 363 if (k == 0) | |
| 364 new_dims = dim_vector (1, 1); | |
| 365 else if (k == 1) | |
| 366 { | |
| 367 // There is one non-singleton dimension, so we need | |
| 368 // to decide the correct orientation. | |
| 369 | |
| 370 if (elem (0) == 1) | |
| 371 { | |
| 372 // The original dimension vector had a leading | |
| 373 // singleton dimension. | |
| 374 | |
| 5275 | 375 octave_idx_type tmp = new_dims(0); |
| 4735 | 376 |
| 377 new_dims.resize (2); | |
| 378 | |
| 379 new_dims(0) = 1; | |
| 380 new_dims(1) = tmp; | |
| 381 } | |
| 382 else | |
| 383 { | |
| 384 // The first element of the original dimension vector | |
| 385 // was not a singleton dimension. | |
| 386 | |
| 387 new_dims.resize (2); | |
| 388 | |
| 389 new_dims(1) = 1; | |
| 390 } | |
| 391 } | |
| 392 else | |
| 393 new_dims.resize(k); | |
| 394 } | |
| 395 | |
| 396 return new_dims; | |
| 397 } | |
| 4915 | 398 |
| 399 bool concat (const dim_vector& dvb, int dim = 0) | |
| 400 { | |
| 401 if (all_zero ()) | |
| 402 { | |
| 403 *this = dvb; | |
| 404 return true; | |
| 405 } | |
| 406 | |
| 407 if (dvb.all_zero ()) | |
| 408 return true; | |
| 409 | |
| 410 int na = length (); | |
| 411 int nb = dvb.length (); | |
| 412 | |
| 413 // Find the max and min value of na and nb | |
| 414 int n_max = na > nb ? na : nb; | |
| 415 int n_min = na < nb ? na : nb; | |
| 416 | |
| 417 // The elements of the dimension vectors can only differ | |
| 418 // if the dim variable differs from the actual dimension | |
| 419 // they differ. | |
| 420 | |
| 421 for (int i = 0; i < n_min; i++) | |
| 422 { | |
| 423 if (elem(i) != dvb(i) && dim != i) | |
| 424 return false; | |
| 425 } | |
| 426 | |
| 427 // Ditto. | |
| 428 for (int i = n_min; i < n_max; i++) | |
| 429 { | |
| 430 if (na > n_min) | |
| 431 { | |
| 432 if (elem(i) != 1 && dim != i) | |
| 433 return false; | |
| 434 } | |
| 435 else | |
| 436 { | |
| 437 if (dvb(i) != 1 && dim != i) | |
| 438 return false; | |
| 439 } | |
| 440 } | |
| 441 | |
| 442 // If we want to add the dimension vectors at a dimension | |
| 443 // larger than both, then we need to set n_max to this number | |
| 444 // so that we resize *this to the right dimension. | |
| 445 | |
| 446 n_max = n_max > (dim + 1) ? n_max : (dim + 1); | |
| 447 | |
| 448 // Resize *this to the appropriate dimensions. | |
| 449 | |
| 450 if (n_max > na) | |
| 451 { | |
| 452 dim_vector_rep *old_rep = rep; | |
| 453 | |
| 454 rep = new dim_vector_rep (n_max, old_rep, 1); | |
| 455 | |
| 456 if (--old_rep->count <= 0) | |
| 457 delete old_rep; | |
| 458 } | |
| 459 | |
| 460 // Larger or equal since dim has been decremented by one. | |
| 461 | |
| 462 if (dim >= nb) | |
| 4940 | 463 elem (dim)++; |
| 4915 | 464 else |
| 465 elem (dim) += dvb(dim); | |
| 466 | |
| 467 return true; | |
| 468 } | |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
469 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
470 // Forces certain dimensionality, preserving numel (). Missing dimensions are |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
471 // set to 1, redundant are folded into the trailing one. If n = 1, the result |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
472 // is 2d and the second dim is 1 (dim_vectors are always at least 2D). |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
473 // If the original dimensions were all zero, the padding value is zero. |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
474 dim_vector redim (int n) const |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
475 { |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
476 int n_dims = length (); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
477 if (n_dims == n) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
478 return *this; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
479 else |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
480 { |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
481 dim_vector retval; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
482 retval.resize (n == 1 ? 2 : n, 1); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
483 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
484 bool zeros = true; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
485 for (int i = 0; i < n && i < n_dims; i++) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
486 { |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
487 retval(i) = elem (i); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
488 zeros = zeros && elem (i) == 0; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
489 } |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
490 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
491 if (n < n_dims) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
492 { |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
493 octave_idx_type k = 1; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
494 for (int i = n; i < n_dims; i++) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
495 k *= elem (i); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
496 retval(n - 1) *= k; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
497 } |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
498 else if (zeros) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
499 { |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
500 for (int i = n_dims; i < n; i++) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
501 retval.elem (i) = 0; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
502 } |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
503 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
504 return retval; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
505 } |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
506 } |
|
8721
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
507 |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
508 bool is_vector (void) const |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
509 { |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
510 return (length () == 2 && (elem (0) == 1 || elem (1) == 1)); |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
511 } |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
512 |
| 4513 | 513 }; |
| 514 | |
| 4543 | 515 static inline bool |
| 516 operator == (const dim_vector& a, const dim_vector& b) | |
| 517 { | |
| 518 bool retval = true; | |
| 519 | |
| 520 int a_len = a.length (); | |
| 521 int b_len = b.length (); | |
| 522 | |
| 523 if (a_len != b_len) | |
| 524 retval = false; | |
| 525 else | |
| 526 { | |
| 527 for (int i = 0; i < a_len; i++) | |
| 528 { | |
| 529 if (a(i) != b(i)) | |
| 530 { | |
| 531 retval = false; | |
| 532 break; | |
| 533 } | |
| 534 } | |
| 535 } | |
| 536 | |
| 537 return retval; | |
| 538 } | |
| 539 | |
| 540 static inline bool | |
| 541 operator != (const dim_vector& a, const dim_vector& b) | |
| 542 { | |
| 543 return ! operator == (a, b); | |
| 544 } | |
| 545 | |
| 4513 | 546 #endif |
| 547 | |
| 548 /* | |
| 549 ;;; Local Variables: *** | |
| 550 ;;; mode: C++ *** | |
| 551 ;;; End: *** | |
| 552 */ |