Mercurial > octave-nkf
annotate liboctave/dim-vector.h @ 9420:434ae96dc10f
dim-vector.h: dim vectors always have two dimensions
| author | John W. Eaton <jwe@octave.org> |
|---|---|
| date | Wed, 08 Jul 2009 13:49:21 -0400 |
| parents | 9a46ba093db4 |
| children | b096d11237be |
| 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) | |
|
9420
434ae96dc10f
dim-vector.h: dim vectors always have two dimensions
John W. Eaton <jwe@octave.org>
parents:
9027
diff
changeset
|
78 : dims (new octave_idx_type [dv.ndims]), |
|
434ae96dc10f
dim-vector.h: dim vectors always have two dimensions
John W. Eaton <jwe@octave.org>
parents:
9027
diff
changeset
|
79 ndims (dv.ndims), count (1) |
| 4548 | 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) | |
|
9420
434ae96dc10f
dim-vector.h: dim vectors always have two dimensions
John W. Eaton <jwe@octave.org>
parents:
9027
diff
changeset
|
90 : dims (new octave_idx_type [n < 2 ? 2 : n]), |
|
434ae96dc10f
dim-vector.h: dim vectors always have two dimensions
John W. Eaton <jwe@octave.org>
parents:
9027
diff
changeset
|
91 ndims (n < 2 ? 2 : n), count (1) |
| 4513 | 92 { |
|
9420
434ae96dc10f
dim-vector.h: dim vectors always have two dimensions
John W. Eaton <jwe@octave.org>
parents:
9027
diff
changeset
|
93 if (n == 0) |
|
434ae96dc10f
dim-vector.h: dim vectors always have two dimensions
John W. Eaton <jwe@octave.org>
parents:
9027
diff
changeset
|
94 { |
|
434ae96dc10f
dim-vector.h: dim vectors always have two dimensions
John W. Eaton <jwe@octave.org>
parents:
9027
diff
changeset
|
95 // Result is 0x0. |
|
434ae96dc10f
dim-vector.h: dim vectors always have two dimensions
John W. Eaton <jwe@octave.org>
parents:
9027
diff
changeset
|
96 dims[0] = 0; |
|
434ae96dc10f
dim-vector.h: dim vectors always have two dimensions
John W. Eaton <jwe@octave.org>
parents:
9027
diff
changeset
|
97 dims[1] = 0; |
|
434ae96dc10f
dim-vector.h: dim vectors always have two dimensions
John W. Eaton <jwe@octave.org>
parents:
9027
diff
changeset
|
98 } |
|
434ae96dc10f
dim-vector.h: dim vectors always have two dimensions
John W. Eaton <jwe@octave.org>
parents:
9027
diff
changeset
|
99 else if (n == 1) |
|
434ae96dc10f
dim-vector.h: dim vectors always have two dimensions
John W. Eaton <jwe@octave.org>
parents:
9027
diff
changeset
|
100 { |
|
434ae96dc10f
dim-vector.h: dim vectors always have two dimensions
John W. Eaton <jwe@octave.org>
parents:
9027
diff
changeset
|
101 // Result is a column vector. |
|
434ae96dc10f
dim-vector.h: dim vectors always have two dimensions
John W. Eaton <jwe@octave.org>
parents:
9027
diff
changeset
|
102 dims[0] = dv->dims[0]; |
|
434ae96dc10f
dim-vector.h: dim vectors always have two dimensions
John W. Eaton <jwe@octave.org>
parents:
9027
diff
changeset
|
103 dims[1] = 1; |
|
434ae96dc10f
dim-vector.h: dim vectors always have two dimensions
John W. Eaton <jwe@octave.org>
parents:
9027
diff
changeset
|
104 } |
|
434ae96dc10f
dim-vector.h: dim vectors always have two dimensions
John W. Eaton <jwe@octave.org>
parents:
9027
diff
changeset
|
105 else |
| 4513 | 106 { |
| 4548 | 107 int dv_ndims = dv ? dv->ndims : 0; |
| 4513 | 108 |
| 4565 | 109 int min_len = n < dv_ndims ? n : dv_ndims; |
| 110 | |
| 111 for (int i = 0; i < min_len; i++) | |
| 4548 | 112 dims[i] = dv->dims[i]; |
| 4513 | 113 |
| 4548 | 114 for (int i = dv_ndims; i < n; i++) |
| 4887 | 115 dims[i] = fill_value; |
| 4513 | 116 } |
| 117 } | |
| 118 | |
| 4548 | 119 ~dim_vector_rep (void) { delete [] dims; } |
| 4513 | 120 |
| 4548 | 121 int length (void) const { return ndims; } |
| 4513 | 122 |
| 5275 | 123 octave_idx_type& elem (int i) |
| 4513 | 124 { |
| 4548 | 125 assert (i >= 0 && i < ndims); |
| 126 return dims[i]; | |
| 127 } | |
| 4513 | 128 |
| 5275 | 129 octave_idx_type elem (int i) const |
| 4548 | 130 { |
| 131 assert (i >= 0 && i < ndims); | |
| 4513 | 132 return dims[i]; |
| 133 } | |
| 134 | |
| 4673 | 135 void chop_trailing_singletons (void) |
| 136 { | |
| 137 for (int i = ndims - 1; i > 1; i--) | |
| 138 { | |
| 139 if (dims[i] == 1) | |
| 140 ndims--; | |
| 141 else | |
| 142 break; | |
| 143 } | |
| 144 } | |
| 145 | |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
146 void chop_all_singletons (void) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
147 { |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
148 int j = 0; |
|
9420
434ae96dc10f
dim-vector.h: dim vectors always have two dimensions
John W. Eaton <jwe@octave.org>
parents:
9027
diff
changeset
|
149 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
150 for (int i = 0; i < ndims; i++) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
151 { |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
152 if (dims[i] != 1) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
153 dims[j++] = dims[i]; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
154 } |
|
9420
434ae96dc10f
dim-vector.h: dim vectors always have two dimensions
John W. Eaton <jwe@octave.org>
parents:
9027
diff
changeset
|
155 |
|
434ae96dc10f
dim-vector.h: dim vectors always have two dimensions
John W. Eaton <jwe@octave.org>
parents:
9027
diff
changeset
|
156 if (j == 1) |
|
434ae96dc10f
dim-vector.h: dim vectors always have two dimensions
John W. Eaton <jwe@octave.org>
parents:
9027
diff
changeset
|
157 dims[1] = 1; |
|
434ae96dc10f
dim-vector.h: dim vectors always have two dimensions
John W. Eaton <jwe@octave.org>
parents:
9027
diff
changeset
|
158 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
159 ndims = j > 2 ? j : 2; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
160 } |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
161 |
| 4548 | 162 private: |
| 163 | |
| 164 // No assignment! | |
| 165 | |
| 166 dim_vector_rep& operator = (const dim_vector_rep& dv); | |
| 167 }; | |
| 168 | |
| 169 dim_vector_rep *rep; | |
| 170 | |
| 171 void make_unique (void) | |
| 172 { | |
| 173 if (rep->count > 1) | |
| 174 { | |
| 175 --rep->count; | |
| 176 rep = new dim_vector_rep (*rep); | |
| 177 } | |
| 178 } | |
| 179 | |
| 180 private: | |
| 181 | |
| 182 dim_vector_rep *nil_rep (void) const | |
| 183 { | |
| 184 static dim_vector_rep *nr = new dim_vector_rep (); | |
| 185 | |
| 186 return nr; | |
| 187 } | |
| 188 | |
| 189 public: | |
| 190 | |
| 191 explicit dim_vector (void) | |
| 192 : rep (nil_rep ()) { rep->count++; } | |
| 193 | |
| 5275 | 194 explicit dim_vector (octave_idx_type n) |
| 4548 | 195 : rep (new dim_vector_rep (n)) { } |
| 196 | |
| 5275 | 197 explicit dim_vector (octave_idx_type r, octave_idx_type c) |
| 4548 | 198 : rep (new dim_vector_rep (r, c)) { } |
| 199 | |
| 5275 | 200 explicit dim_vector (octave_idx_type r, octave_idx_type c, octave_idx_type p) |
| 4548 | 201 : rep (new dim_vector_rep (r, c, p)) { } |
| 202 | |
| 203 dim_vector (const dim_vector& dv) | |
| 204 : rep (dv.rep) { rep->count++; } | |
| 205 | |
| 206 dim_vector& operator = (const dim_vector& dv) | |
| 207 { | |
| 208 if (&dv != this) | |
| 209 { | |
| 210 if (--rep->count <= 0) | |
| 211 delete rep; | |
| 212 | |
| 213 rep = dv.rep; | |
| 214 rep->count++; | |
| 215 } | |
| 216 | |
| 217 return *this; | |
| 218 } | |
| 219 | |
| 220 ~dim_vector (void) | |
| 221 { | |
| 222 if (--rep->count <= 0) | |
| 223 delete rep; | |
| 224 } | |
| 225 | |
| 226 int length (void) const { return rep->length (); } | |
| 227 | |
| 5275 | 228 octave_idx_type& elem (int i) { make_unique (); return rep->elem (i); } |
| 4548 | 229 |
| 5275 | 230 octave_idx_type elem (int i) const { return rep->elem (i); } |
| 4513 | 231 |
| 5275 | 232 octave_idx_type& operator () (int i) { return elem (i); } |
| 4513 | 233 |
| 5275 | 234 octave_idx_type operator () (int i) const { return elem (i); } |
| 4513 | 235 |
| 4887 | 236 void resize (int n, int fill_value = 0) |
| 4548 | 237 { |
| 238 int len = length (); | |
| 4513 | 239 |
| 4548 | 240 if (n != len) |
| 241 { | |
| 242 dim_vector_rep *old_rep = rep; | |
| 4513 | 243 |
| 4887 | 244 rep = new dim_vector_rep (n, old_rep, fill_value); |
| 4513 | 245 |
| 4548 | 246 if (--old_rep->count <= 0) |
| 247 delete old_rep; | |
| 248 } | |
| 249 } | |
| 4513 | 250 |
| 4559 | 251 std::string str (char sep = 'x') const |
| 4548 | 252 { |
| 5765 | 253 std::ostringstream buf; |
| 4543 | 254 |
| 4548 | 255 for (int i = 0; i < length (); i++) |
| 256 { | |
| 257 buf << elem (i); | |
| 4543 | 258 |
| 4548 | 259 if (i < length () - 1) |
| 4559 | 260 buf << sep; |
| 4548 | 261 } |
| 4543 | 262 |
| 5765 | 263 std::string retval = buf.str (); |
| 4543 | 264 |
| 4548 | 265 return retval; |
| 266 } | |
| 4543 | 267 |
| 268 bool all_zero (void) const | |
| 4548 | 269 { |
| 270 bool retval = true; | |
| 4543 | 271 |
| 4548 | 272 for (int i = 0; i < length (); i++) |
| 273 { | |
| 274 if (elem (i) != 0) | |
| 275 { | |
| 276 retval = false; | |
| 277 break; | |
| 278 } | |
| 279 } | |
| 4543 | 280 |
| 4548 | 281 return retval; |
| 282 } | |
| 4559 | 283 |
| 284 bool any_zero (void) const | |
| 285 { | |
| 286 bool retval = false; | |
| 287 | |
| 288 for (int i = 0; i < length (); i++) | |
| 289 { | |
| 290 if (elem (i) == 0) | |
| 291 { | |
| 292 retval = true; | |
| 293 break; | |
| 294 } | |
| 295 } | |
| 296 | |
| 297 return retval; | |
| 298 } | |
| 4567 | 299 |
| 4635 | 300 int |
| 301 num_ones (void) const | |
| 302 { | |
| 303 int retval = 0; | |
| 304 | |
| 305 for (int i = 0; i < length (); i++) | |
| 306 if (elem (i) == 1) | |
| 307 retval++; | |
| 308 | |
| 309 return retval; | |
| 310 } | |
| 311 | |
| 4655 | 312 bool |
| 313 all_ones (void) const | |
| 314 { | |
| 315 return (num_ones () == length ()); | |
| 316 } | |
| 317 | |
| 4567 | 318 // This is the number of elements that a matrix with this dimension |
| 319 // vector would have, NOT the number of dimensions (elements in the | |
| 320 // dimension vector). | |
| 321 | |
|
9027
9a46ba093db4
generalize dim_vector::numel
Jaroslav Hajek <highegg@gmail.com>
parents:
8950
diff
changeset
|
322 octave_idx_type numel (int n = 0) const |
| 4567 | 323 { |
| 324 int n_dims = length (); | |
| 325 | |
|
9027
9a46ba093db4
generalize dim_vector::numel
Jaroslav Hajek <highegg@gmail.com>
parents:
8950
diff
changeset
|
326 octave_idx_type retval = 1; |
| 4567 | 327 |
|
9027
9a46ba093db4
generalize dim_vector::numel
Jaroslav Hajek <highegg@gmail.com>
parents:
8950
diff
changeset
|
328 for (int i = n; i < n_dims; i++) |
| 4567 | 329 retval *= elem (i); |
| 330 | |
| 331 return retval; | |
| 332 } | |
| 4673 | 333 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
334 bool any_neg (void) const |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
335 { |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
336 int n_dims = length (), i; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
337 for (i = 0; i < n_dims; i++) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
338 if (elem (i) < 0) break; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
339 return i < n_dims; |
|
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 |
| 4673 | 342 void chop_trailing_singletons (void) |
| 343 { | |
| 344 make_unique (); | |
| 345 rep->chop_trailing_singletons (); | |
| 346 } | |
| 4735 | 347 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
348 void chop_all_singletons (void) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
349 { |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
350 make_unique (); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
351 rep->chop_all_singletons (); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
352 } |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
353 |
| 4735 | 354 dim_vector squeeze (void) const |
| 355 { | |
| 356 dim_vector new_dims = *this; | |
| 357 | |
| 358 bool dims_changed = 1; | |
| 359 | |
| 360 int k = 0; | |
| 361 | |
| 362 for (int i = 0; i < length (); i++) | |
| 363 { | |
| 364 if (elem (i) == 1) | |
| 365 dims_changed = true; | |
| 366 else | |
| 367 new_dims(k++) = elem (i); | |
| 368 } | |
| 369 | |
| 370 if (dims_changed) | |
| 371 { | |
| 372 if (k == 0) | |
| 373 new_dims = dim_vector (1, 1); | |
| 374 else if (k == 1) | |
| 375 { | |
| 376 // There is one non-singleton dimension, so we need | |
| 377 // to decide the correct orientation. | |
| 378 | |
| 379 if (elem (0) == 1) | |
| 380 { | |
| 381 // The original dimension vector had a leading | |
| 382 // singleton dimension. | |
| 383 | |
| 5275 | 384 octave_idx_type tmp = new_dims(0); |
| 4735 | 385 |
| 386 new_dims.resize (2); | |
| 387 | |
| 388 new_dims(0) = 1; | |
| 389 new_dims(1) = tmp; | |
| 390 } | |
| 391 else | |
| 392 { | |
| 393 // The first element of the original dimension vector | |
| 394 // was not a singleton dimension. | |
| 395 | |
| 396 new_dims.resize (2); | |
| 397 | |
| 398 new_dims(1) = 1; | |
| 399 } | |
| 400 } | |
| 401 else | |
| 402 new_dims.resize(k); | |
| 403 } | |
| 404 | |
| 405 return new_dims; | |
| 406 } | |
| 4915 | 407 |
| 408 bool concat (const dim_vector& dvb, int dim = 0) | |
| 409 { | |
| 410 if (all_zero ()) | |
| 411 { | |
| 412 *this = dvb; | |
| 413 return true; | |
| 414 } | |
| 415 | |
| 416 if (dvb.all_zero ()) | |
| 417 return true; | |
| 418 | |
| 419 int na = length (); | |
| 420 int nb = dvb.length (); | |
| 421 | |
| 422 // Find the max and min value of na and nb | |
| 423 int n_max = na > nb ? na : nb; | |
| 424 int n_min = na < nb ? na : nb; | |
| 425 | |
| 426 // The elements of the dimension vectors can only differ | |
| 427 // if the dim variable differs from the actual dimension | |
| 428 // they differ. | |
| 429 | |
| 430 for (int i = 0; i < n_min; i++) | |
| 431 { | |
| 432 if (elem(i) != dvb(i) && dim != i) | |
| 433 return false; | |
| 434 } | |
| 435 | |
| 436 // Ditto. | |
| 437 for (int i = n_min; i < n_max; i++) | |
| 438 { | |
| 439 if (na > n_min) | |
| 440 { | |
| 441 if (elem(i) != 1 && dim != i) | |
| 442 return false; | |
| 443 } | |
| 444 else | |
| 445 { | |
| 446 if (dvb(i) != 1 && dim != i) | |
| 447 return false; | |
| 448 } | |
| 449 } | |
| 450 | |
| 451 // If we want to add the dimension vectors at a dimension | |
| 452 // larger than both, then we need to set n_max to this number | |
| 453 // so that we resize *this to the right dimension. | |
| 454 | |
| 455 n_max = n_max > (dim + 1) ? n_max : (dim + 1); | |
| 456 | |
| 457 // Resize *this to the appropriate dimensions. | |
| 458 | |
| 459 if (n_max > na) | |
| 460 { | |
| 461 dim_vector_rep *old_rep = rep; | |
| 462 | |
| 463 rep = new dim_vector_rep (n_max, old_rep, 1); | |
| 464 | |
| 465 if (--old_rep->count <= 0) | |
| 466 delete old_rep; | |
| 467 } | |
| 468 | |
| 469 // Larger or equal since dim has been decremented by one. | |
| 470 | |
| 471 if (dim >= nb) | |
| 4940 | 472 elem (dim)++; |
| 4915 | 473 else |
| 474 elem (dim) += dvb(dim); | |
| 475 | |
| 476 return true; | |
| 477 } | |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
478 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
479 // Forces certain dimensionality, preserving numel (). Missing dimensions are |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
480 // 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
|
481 // 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
|
482 // 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
|
483 dim_vector redim (int n) const |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
484 { |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
485 int n_dims = length (); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
486 if (n_dims == n) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
487 return *this; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
488 else |
|
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 dim_vector retval; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
491 retval.resize (n == 1 ? 2 : n, 1); |
|
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 bool zeros = true; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
494 for (int i = 0; i < n && i < n_dims; i++) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
495 { |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
496 retval(i) = elem (i); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
497 zeros = zeros && elem (i) == 0; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
498 } |
|
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 if (n < n_dims) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
501 { |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
502 octave_idx_type k = 1; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
503 for (int i = n; i < n_dims; i++) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
504 k *= elem (i); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
505 retval(n - 1) *= k; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
506 } |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
507 else if (zeros) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
508 { |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
509 for (int i = n_dims; i < n; i++) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
510 retval.elem (i) = 0; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
511 } |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
512 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
513 return retval; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
514 } |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
515 } |
|
8721
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
516 |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
517 bool is_vector (void) const |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
518 { |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
519 return (length () == 2 && (elem (0) == 1 || elem (1) == 1)); |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
520 } |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
521 |
| 4513 | 522 }; |
| 523 | |
| 4543 | 524 static inline bool |
| 525 operator == (const dim_vector& a, const dim_vector& b) | |
| 526 { | |
| 527 bool retval = true; | |
| 528 | |
| 529 int a_len = a.length (); | |
| 530 int b_len = b.length (); | |
| 531 | |
| 532 if (a_len != b_len) | |
| 533 retval = false; | |
| 534 else | |
| 535 { | |
| 536 for (int i = 0; i < a_len; i++) | |
| 537 { | |
| 538 if (a(i) != b(i)) | |
| 539 { | |
| 540 retval = false; | |
| 541 break; | |
| 542 } | |
| 543 } | |
| 544 } | |
| 545 | |
| 546 return retval; | |
| 547 } | |
| 548 | |
| 549 static inline bool | |
| 550 operator != (const dim_vector& a, const dim_vector& b) | |
| 551 { | |
| 552 return ! operator == (a, b); | |
| 553 } | |
| 554 | |
| 4513 | 555 #endif |
| 556 | |
| 557 /* | |
| 558 ;;; Local Variables: *** | |
| 559 ;;; mode: C++ *** | |
| 560 ;;; End: *** | |
| 561 */ |