Mercurial > hg > octave-nkf
annotate liboctave/Array-util.cc @ 9507:b096d11237be
dim_vector improvements
| author | Jaroslav Hajek <highegg@gmail.com> |
|---|---|
| date | Fri, 07 Aug 2009 08:21:39 +0200 |
| parents | d9716e3ee0dd |
| children | ed34b1da0e26 |
| rev | line source |
|---|---|
| 4588 | 1 /* |
| 2 | |
| 8920 | 3 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 John W. Eaton |
| 4588 | 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. | |
| 4588 | 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/>. | |
| 4588 | 20 |
| 21 */ | |
| 22 | |
| 23 #ifdef HAVE_CONFIG_H | |
| 24 #include <config.h> | |
| 25 #endif | |
| 26 | |
| 27 #include "Array-util.h" | |
| 4669 | 28 #include "dim-vector.h" |
| 29 #include "lo-error.h" | |
|
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
30 #include "oct-locbuf.h" |
| 4588 | 31 |
| 32 bool | |
| 8333 | 33 index_in_bounds (const Array<octave_idx_type>& ra_idx, |
| 34 const dim_vector& dimensions) | |
| 4588 | 35 { |
| 36 bool retval = true; | |
| 37 | |
| 38 int n = ra_idx.length (); | |
| 39 | |
| 40 if (n == dimensions.length ()) | |
| 41 { | |
| 42 for (int i = 0; i < n; i++) | |
| 43 { | |
| 4747 | 44 if (ra_idx(i) < 0 || ra_idx(i) >= dimensions(i)) |
| 4588 | 45 { |
| 46 retval = false; | |
| 47 break; | |
| 48 } | |
| 49 } | |
| 50 } | |
| 51 else | |
| 52 retval = false; | |
| 53 | |
| 54 return retval; | |
| 55 } | |
| 56 | |
| 57 void | |
| 5275 | 58 increment_index (Array<octave_idx_type>& ra_idx, const dim_vector& dimensions, |
| 4588 | 59 int start_dimension) |
| 60 { | |
| 61 ra_idx(start_dimension)++; | |
| 62 | |
| 63 int n = ra_idx.length () - 1; | |
| 6868 | 64 int nda = dimensions.length (); |
| 4588 | 65 |
| 66 for (int i = start_dimension; i < n; i++) | |
| 67 { | |
| 6868 | 68 if (ra_idx(i) < (i < nda ? dimensions(i) : 1)) |
| 4588 | 69 break; |
| 70 else | |
| 71 { | |
| 72 ra_idx(i) = 0; | |
| 73 ra_idx(i+1)++; | |
| 74 } | |
| 75 } | |
| 76 } | |
| 77 | |
| 5275 | 78 octave_idx_type |
| 79 get_scalar_idx (Array<octave_idx_type>& idx, dim_vector& dims) | |
| 4588 | 80 { |
| 5275 | 81 octave_idx_type retval (-1); |
| 4588 | 82 |
| 83 int n = idx.length (); | |
| 84 | |
| 85 if (n > 0) | |
| 86 { | |
| 87 retval = idx(--n); | |
| 88 | |
| 89 while (--n >= 0) | |
| 90 { | |
| 91 retval *= dims (n); | |
| 92 | |
| 93 retval += idx(n); | |
| 94 } | |
| 95 } | |
| 96 return retval; | |
| 97 } | |
| 98 | |
| 5275 | 99 octave_idx_type |
| 100 num_ones (const Array<octave_idx_type>& ra_idx) | |
| 4588 | 101 { |
| 5275 | 102 octave_idx_type retval = 0; |
| 4635 | 103 |
| 5275 | 104 for (octave_idx_type i = 0; i < ra_idx.length (); i++) |
| 4588 | 105 { |
| 106 if (ra_idx (i) == 1) | |
| 107 retval++; | |
| 108 } | |
| 4635 | 109 |
| 4588 | 110 return retval; |
| 111 } | |
| 112 | |
| 113 bool | |
| 114 is_scalar (const dim_vector& dim) | |
| 115 { | |
| 116 bool retval = true; | |
| 117 | |
| 118 int n = dim.length (); | |
| 119 | |
| 120 if (n == 0) | |
| 121 { | |
| 122 retval = false; | |
| 123 } | |
| 124 else | |
| 125 { | |
| 126 for (int i = 0; i < n; i ++) | |
| 127 { | |
| 128 if (dim (i) != 1) | |
| 129 { | |
| 130 retval = false; | |
| 131 | |
| 132 break; | |
| 133 } | |
| 134 } | |
| 135 } | |
| 136 return retval; | |
| 137 } | |
| 138 | |
| 139 bool | |
|
7642
9a4541c622b5
refactor Array::assignN dimensioning code for empty initial matrices
David Bateman <dbateman@free.fr>
parents:
7241
diff
changeset
|
140 is_vector (const dim_vector& dim) |
|
9a4541c622b5
refactor Array::assignN dimensioning code for empty initial matrices
David Bateman <dbateman@free.fr>
parents:
7241
diff
changeset
|
141 { |
|
9a4541c622b5
refactor Array::assignN dimensioning code for empty initial matrices
David Bateman <dbateman@free.fr>
parents:
7241
diff
changeset
|
142 int m = 0; |
|
9a4541c622b5
refactor Array::assignN dimensioning code for empty initial matrices
David Bateman <dbateman@free.fr>
parents:
7241
diff
changeset
|
143 int n = dim.length (); |
|
9a4541c622b5
refactor Array::assignN dimensioning code for empty initial matrices
David Bateman <dbateman@free.fr>
parents:
7241
diff
changeset
|
144 |
|
9a4541c622b5
refactor Array::assignN dimensioning code for empty initial matrices
David Bateman <dbateman@free.fr>
parents:
7241
diff
changeset
|
145 if (n == 0) |
|
9a4541c622b5
refactor Array::assignN dimensioning code for empty initial matrices
David Bateman <dbateman@free.fr>
parents:
7241
diff
changeset
|
146 m = 2; |
|
9a4541c622b5
refactor Array::assignN dimensioning code for empty initial matrices
David Bateman <dbateman@free.fr>
parents:
7241
diff
changeset
|
147 else |
|
9a4541c622b5
refactor Array::assignN dimensioning code for empty initial matrices
David Bateman <dbateman@free.fr>
parents:
7241
diff
changeset
|
148 { |
|
9a4541c622b5
refactor Array::assignN dimensioning code for empty initial matrices
David Bateman <dbateman@free.fr>
parents:
7241
diff
changeset
|
149 for (int i = 0; i < n; i ++) |
|
9a4541c622b5
refactor Array::assignN dimensioning code for empty initial matrices
David Bateman <dbateman@free.fr>
parents:
7241
diff
changeset
|
150 if (dim (i) > 1) |
|
9a4541c622b5
refactor Array::assignN dimensioning code for empty initial matrices
David Bateman <dbateman@free.fr>
parents:
7241
diff
changeset
|
151 m++; |
|
9a4541c622b5
refactor Array::assignN dimensioning code for empty initial matrices
David Bateman <dbateman@free.fr>
parents:
7241
diff
changeset
|
152 else if (dim(i) < 1) |
|
9a4541c622b5
refactor Array::assignN dimensioning code for empty initial matrices
David Bateman <dbateman@free.fr>
parents:
7241
diff
changeset
|
153 m += 2; |
|
9a4541c622b5
refactor Array::assignN dimensioning code for empty initial matrices
David Bateman <dbateman@free.fr>
parents:
7241
diff
changeset
|
154 } |
| 7924 | 155 |
|
7642
9a4541c622b5
refactor Array::assignN dimensioning code for empty initial matrices
David Bateman <dbateman@free.fr>
parents:
7241
diff
changeset
|
156 return (m < 2); |
|
9a4541c622b5
refactor Array::assignN dimensioning code for empty initial matrices
David Bateman <dbateman@free.fr>
parents:
7241
diff
changeset
|
157 } |
|
9a4541c622b5
refactor Array::assignN dimensioning code for empty initial matrices
David Bateman <dbateman@free.fr>
parents:
7241
diff
changeset
|
158 |
|
9a4541c622b5
refactor Array::assignN dimensioning code for empty initial matrices
David Bateman <dbateman@free.fr>
parents:
7241
diff
changeset
|
159 bool |
| 5275 | 160 any_ones (const Array<octave_idx_type>& arr) |
| 4588 | 161 { |
| 162 bool retval = false; | |
| 163 | |
| 5275 | 164 for (octave_idx_type i = 0; i < arr.length (); i++) |
| 4588 | 165 { |
| 166 if (arr (i) == 1) | |
| 167 { | |
| 168 retval = true; | |
| 169 | |
| 170 break; | |
| 171 } | |
| 172 } | |
| 173 return retval; | |
| 174 } | |
| 175 | |
| 5275 | 176 octave_idx_type |
| 177 compute_index (const Array<octave_idx_type>& ra_idx, const dim_vector& dims) | |
| 4588 | 178 { |
| 5275 | 179 octave_idx_type retval = -1; |
| 4588 | 180 |
| 181 int n = dims.length (); | |
| 182 | |
| 183 if (n > 0 && n == ra_idx.length ()) | |
| 184 { | |
| 185 retval = ra_idx(--n); | |
| 186 | |
| 187 while (--n >= 0) | |
| 188 { | |
| 189 retval *= dims(n); | |
| 190 | |
| 191 retval += ra_idx(n); | |
| 192 } | |
| 193 } | |
| 194 else | |
| 195 (*current_liboctave_error_handler) | |
| 196 ("ArrayN<T>::compute_index: invalid ra_idxing operation"); | |
| 197 | |
| 198 return retval; | |
| 199 } | |
| 200 | |
| 5275 | 201 Array<octave_idx_type> |
| 4588 | 202 conv_to_int_array (const Array<idx_vector>& a) |
| 203 { | |
| 5275 | 204 Array<octave_idx_type> retval (a.length ()); |
| 4588 | 205 |
| 5275 | 206 for (octave_idx_type i = 0; i < a.length (); i++) |
| 4588 | 207 retval (i) = a(i).elem (0); |
| 208 | |
| 209 return retval; | |
| 210 } | |
| 211 | |
| 212 Array<idx_vector> | |
| 5275 | 213 conv_to_array (const idx_vector *tmp, const octave_idx_type len) |
| 4588 | 214 { |
| 215 Array<idx_vector> retval (len); | |
| 216 | |
| 5275 | 217 for (octave_idx_type i = 0; i < len; i++) |
| 4588 | 218 retval (i) = tmp[i]; |
| 219 | |
| 220 return retval; | |
| 221 } | |
| 222 | |
| 223 dim_vector | |
| 224 freeze (Array<idx_vector>& ra_idx, const dim_vector& dimensions, int resize_ok) | |
| 225 { | |
| 226 dim_vector retval; | |
| 227 | |
| 228 int n = ra_idx.length (); | |
| 229 | |
| 230 assert (n == dimensions.length ()); | |
| 231 | |
| 232 retval.resize (n); | |
| 233 | |
| 5136 | 234 static const char *tag[3] = { "row", "column", 0 }; |
| 235 | |
| 4588 | 236 for (int i = 0; i < n; i++) |
| 5136 | 237 retval(i) = ra_idx(i).freeze (dimensions(i), tag[i < 2 ? i : 3], |
| 238 resize_ok); | |
| 4588 | 239 |
| 240 return retval; | |
| 241 } | |
| 242 | |
| 243 bool | |
| 5519 | 244 vector_equivalent (const dim_vector& dv) |
| 4588 | 245 { |
| 5519 | 246 int n = dv.length (); |
| 4588 | 247 |
| 248 bool found_first = false; | |
| 249 | |
| 5519 | 250 for (int i = 0; i < n; i++) |
| 4588 | 251 { |
| 5519 | 252 if (dv(i) != 1) |
| 4588 | 253 { |
| 254 if (! found_first) | |
| 255 found_first = true; | |
| 256 else | |
| 257 return false; | |
| 258 } | |
| 259 } | |
| 260 | |
| 261 return true; | |
| 262 } | |
| 263 | |
| 264 bool | |
| 265 all_ok (const Array<idx_vector>& ra_idx) | |
| 266 { | |
| 267 bool retval = true; | |
| 268 | |
| 5275 | 269 octave_idx_type n = ra_idx.length (); |
| 4588 | 270 |
| 5275 | 271 for (octave_idx_type i = 0; i < n; i++) |
| 4588 | 272 { |
| 273 if (! ra_idx(i)) | |
| 274 { | |
| 275 retval = false; | |
| 276 break; | |
| 277 } | |
| 278 } | |
| 279 | |
| 280 return retval; | |
| 281 } | |
| 282 | |
| 283 bool | |
| 284 any_orig_empty (const Array<idx_vector>& ra_idx) | |
| 285 { | |
| 286 bool retval = false; | |
| 287 | |
| 5275 | 288 octave_idx_type n = ra_idx.length (); |
| 4588 | 289 |
| 5275 | 290 for (octave_idx_type i = 0; i < n; i++) |
| 4588 | 291 { |
| 292 if (ra_idx(i).orig_empty ()) | |
| 293 { | |
| 294 retval = true; | |
| 295 break; | |
| 296 } | |
| 297 } | |
| 298 | |
| 299 return retval; | |
| 300 } | |
| 301 | |
| 302 bool | |
| 303 all_colon_equiv (const Array<idx_vector>& ra_idx, | |
| 304 const dim_vector& frozen_lengths) | |
| 305 { | |
| 306 bool retval = true; | |
| 307 | |
| 5275 | 308 octave_idx_type idx_n = ra_idx.length (); |
| 4588 | 309 |
| 310 int n = frozen_lengths.length (); | |
| 311 | |
| 312 assert (idx_n == n); | |
| 313 | |
| 5275 | 314 for (octave_idx_type i = 0; i < n; i++) |
| 4588 | 315 { |
| 316 if (! ra_idx(i).is_colon_equiv (frozen_lengths(i))) | |
| 317 { | |
| 318 retval = false; | |
| 319 break; | |
| 320 } | |
| 321 } | |
| 322 | |
| 323 return retval; | |
| 324 } | |
| 325 | |
| 326 bool | |
| 5275 | 327 all_ones (const Array<octave_idx_type>& arr) |
| 4588 | 328 { |
| 329 bool retval = true; | |
| 330 | |
| 5275 | 331 for (octave_idx_type i = 0; i < arr.length (); i++) |
| 4588 | 332 { |
| 333 if (arr(i) != 1) | |
| 334 { | |
| 335 retval = false; | |
| 336 break; | |
| 337 } | |
| 338 } | |
| 339 | |
| 340 return retval; | |
| 341 } | |
| 342 | |
| 5275 | 343 Array<octave_idx_type> |
| 8333 | 344 get_elt_idx (const Array<idx_vector>& ra_idx, |
| 345 const Array<octave_idx_type>& result_idx) | |
| 4588 | 346 { |
| 5275 | 347 octave_idx_type n = ra_idx.length (); |
| 4588 | 348 |
| 5275 | 349 Array<octave_idx_type> retval (n); |
| 4588 | 350 |
| 5275 | 351 for (octave_idx_type i = 0; i < n; i++) |
| 4588 | 352 retval(i) = ra_idx(i).elem (result_idx(i)); |
| 353 | |
| 354 return retval; | |
| 355 } | |
| 356 | |
| 5275 | 357 Array<octave_idx_type> |
| 358 get_ra_idx (octave_idx_type idx, const dim_vector& dims) | |
| 4588 | 359 { |
| 5275 | 360 Array<octave_idx_type> retval; |
| 4588 | 361 |
| 362 int n_dims = dims.length (); | |
| 363 | |
| 364 retval.resize (n_dims); | |
| 365 | |
| 366 for (int i = 0; i < n_dims; i++) | |
| 367 retval(i) = 0; | |
| 368 | |
| 4747 | 369 assert (idx > 0 || idx < dims.numel ()); |
| 4588 | 370 |
| 5275 | 371 for (octave_idx_type i = 0; i < idx; i++) |
| 4588 | 372 increment_index (retval, dims); |
| 373 | |
| 5775 | 374 // FIXME -- the solution using increment_index is not |
| 4588 | 375 // efficient. |
| 376 | |
| 377 #if 0 | |
| 5275 | 378 octave_idx_type var = 1; |
| 4588 | 379 for (int i = 0; i < n_dims; i++) |
| 380 { | |
| 8333 | 381 std::cout << "idx: " << idx << ", var: " << var |
| 382 << ", dims(" << i << "): " << dims(i) <<"\n"; | |
| 4588 | 383 retval(i) = ((int)floor(((idx) / (double)var))) % dims(i); |
| 384 idx -= var * retval(i); | |
| 385 var = dims(i); | |
| 386 } | |
| 387 #endif | |
| 388 | |
| 389 return retval; | |
| 390 } | |
| 391 | |
|
8677
095ae5e0a831
eliminte some compiler warnings
John W. Eaton <jwe@octave.org>
parents:
8333
diff
changeset
|
392 dim_vector |
|
095ae5e0a831
eliminte some compiler warnings
John W. Eaton <jwe@octave.org>
parents:
8333
diff
changeset
|
393 zero_dims_inquire (const Array<idx_vector>& ia, const dim_vector& rhdv) |
| 4588 | 394 { |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
395 int ial = ia.length (), rhdvl = rhdv.length (); |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9479
diff
changeset
|
396 dim_vector rdv = dim_vector::alloc (ial); |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
397 bool *scalar = new bool[ial], *colon = new bool[ial]; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
398 // Mark scalars and colons, count non-scalar indices. |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
399 int nonsc = 0; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
400 bool all_colons = true; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
401 for (int i = 0; i < ial; i++) |
| 4588 | 402 { |
| 8333 | 403 // FIXME -- should we check for length() instead? |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
404 scalar[i] = ia(i).is_scalar (); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
405 colon[i] = ia(i).is_colon (); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
406 if (! scalar[i]) nonsc++; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
407 if (! colon[i]) rdv(i) = ia(i).extent (0); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
408 all_colons = all_colons && colon[i]; |
| 4588 | 409 } |
| 410 | |
| 8333 | 411 // If the number of nonscalar indices matches the dimensionality of |
| 412 // RHS, we try an exact match, inquiring even singleton dimensions. | |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
413 if (all_colons) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
414 { |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
415 rdv = rhdv; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
416 rdv.resize(ial, 1); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
417 } |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
418 else if (nonsc == rhdvl) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
419 { |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
420 for (int i = 0, j = 0; i < ial; i++) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
421 { |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
422 if (scalar[i]) continue; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
423 if (colon[i]) |
|
9192
864805896876
fix zero-dims assignment bug
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
424 rdv(i) = rhdv(j); |
|
864805896876
fix zero-dims assignment bug
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
425 j++; |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
426 } |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
427 } |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
428 else |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
429 { |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
430 dim_vector rhdv0 = rhdv; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
431 rhdv0.chop_all_singletons (); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
432 int rhdv0l = rhdv0.length (); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
433 for (int i = 0, j = 0; i < ial; i++) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
434 { |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
435 if (scalar[i]) continue; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
436 if (colon[i]) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
437 rdv(i) = (j < rhdv0l) ? rhdv0(j++) : 1; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
438 } |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
439 } |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
440 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
441 delete [] scalar; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
442 delete [] colon; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
443 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
444 return rdv; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
445 } |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
446 |
|
8677
095ae5e0a831
eliminte some compiler warnings
John W. Eaton <jwe@octave.org>
parents:
8333
diff
changeset
|
447 dim_vector |
|
095ae5e0a831
eliminte some compiler warnings
John W. Eaton <jwe@octave.org>
parents:
8333
diff
changeset
|
448 zero_dims_inquire (const idx_vector& i, const idx_vector& j, |
|
095ae5e0a831
eliminte some compiler warnings
John W. Eaton <jwe@octave.org>
parents:
8333
diff
changeset
|
449 const dim_vector& rhdv) |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
450 { |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
451 bool icol = i.is_colon (), jcol = j.is_colon (); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
452 dim_vector rdv; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
453 if (icol && jcol && rhdv.length () == 2) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
454 { |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
455 rdv(0) = rhdv(0); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
456 rdv(1) = rhdv(1); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
457 } |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
458 else |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
459 { |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
460 dim_vector rhdv0 = rhdv; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
461 rhdv0.chop_all_singletons (); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
462 int k = 0; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
463 rdv(0) = i.extent (0); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
464 if (icol) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
465 rdv(0) = rhdv0(k++); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
466 else if (! i.is_scalar ()) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
467 k++; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
468 rdv(1) = j.extent (0); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
469 if (jcol) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
470 rdv(1) = rhdv0(k++); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
471 else if (! j.is_scalar ()) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
472 k++; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
473 } |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
474 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
475 return rdv; |
| 4588 | 476 } |
| 477 | |
|
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
478 // A helper class. |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
479 struct sub2ind_helper |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
480 { |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
481 octave_idx_type *ind, n; |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
482 sub2ind_helper (octave_idx_type *_ind, octave_idx_type _n) |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
483 : ind(_ind), n(_n) { } |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
484 void operator ()(octave_idx_type k) { (*ind++ *= n) += k; } |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
485 }; |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
486 |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
487 idx_vector sub2ind (const dim_vector& dv, const Array<idx_vector>& idxa) |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
488 { |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
489 idx_vector retval; |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
490 octave_idx_type len = idxa.length (); |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
491 |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
492 if (len >= 2) |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
493 { |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
494 const dim_vector dvx = dv.redim (len); |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
495 bool all_ranges = true; |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
496 octave_idx_type clen = -1; |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
497 |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
498 for (octave_idx_type i = 0; i < len; i++) |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
499 { |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
500 idx_vector idx = idxa(i); |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
501 octave_idx_type n = dvx(i); |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
502 |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
503 all_ranges = all_ranges && idx.is_range (); |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
504 if (clen < 0) |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
505 clen = idx.length (n); |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
506 else if (clen != idx.length (n)) |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
507 current_liboctave_error_handler ("sub2ind: lengths of indices must match"); |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
508 |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
509 if (idx.extent (n) > n) |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
510 current_liboctave_error_handler ("sub2ind: index out of range"); |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
511 } |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
512 |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
513 if (clen == 1) |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
514 { |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
515 // All scalars case - the result is a scalar. |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
516 octave_idx_type idx = idxa(len-1)(0); |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
517 for (octave_idx_type i = len - 2; i >= 0; i--) |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
518 idx = idx * dvx(i) + idxa(i)(0); |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
519 retval = idx_vector (idx); |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
520 } |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
521 else if (all_ranges && clen != 0) |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
522 { |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
523 // All ranges case - the result is a range. |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
524 octave_idx_type start = 0, step = 0; |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
525 for (octave_idx_type i = len - 1; i >= 0; i--) |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
526 { |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
527 octave_idx_type xstart = idxa(i)(0), xstep = idxa(i)(1) - xstart; |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
528 start = start * dvx(i) + xstart; |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
529 step = step * dvx(i) + xstep; |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
530 } |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
531 retval = idx_vector::make_range (start, step, clen); |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
532 } |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
533 else |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
534 { |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
535 Array<octave_idx_type> idx (idxa(0).orig_dimensions ()); |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
536 octave_idx_type *idx_vec = idx.fortran_vec (); |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
537 |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
538 for (octave_idx_type i = len - 1; i >= 0; i--) |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
539 { |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
540 if (i < len - 1) |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
541 idxa(i).loop (clen, sub2ind_helper (idx_vec, dvx(i))); |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
542 else |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
543 idxa(i).copy_data (idx_vec); |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
544 } |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
545 |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
546 retval = idx_vector (idx); |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
547 } |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
548 } |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
549 else |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
550 current_liboctave_error_handler ("sub2ind: needs at least 2 indices"); |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
551 |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
552 return retval; |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
553 } |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
554 |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
555 Array<idx_vector> ind2sub (const dim_vector& dv, const idx_vector& idx) |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
556 { |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
557 octave_idx_type len = idx.length (0), n = dv.length (); |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
558 Array<idx_vector> retval(n); |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
559 octave_idx_type numel = dv.numel (); |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
560 |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
561 if (idx.extent (numel) > numel) |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
562 current_liboctave_error_handler ("ind2sub: index out of range"); |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
563 else |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
564 { |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
565 if (idx.is_scalar ()) |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
566 { |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
567 octave_idx_type k = idx(0); |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
568 for (octave_idx_type j = 0; j < n; j++) |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
569 { |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
570 retval(j) = k % dv(j); |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
571 k /= dv(j); |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
572 } |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
573 } |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
574 else |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
575 { |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
576 OCTAVE_LOCAL_BUFFER (Array<octave_idx_type>, rdata, n); |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
577 |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
578 dim_vector odv = idx.orig_dimensions (); |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
579 for (octave_idx_type j = 0; j < n; j++) |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
580 rdata[j] = Array<octave_idx_type> (odv); |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
581 |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
582 for (octave_idx_type i = 0; i < len; i++) |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
583 { |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
584 octave_idx_type k = idx(i); |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
585 for (octave_idx_type j = 0; j < n; j++) |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
586 { |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
587 rdata[j](i) = k % dv(j); |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
588 k /= dv(j); |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
589 } |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
590 } |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
591 |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
592 for (octave_idx_type j = 0; j < n; j++) |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
593 retval(j) = rdata[j]; |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
594 } |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
595 |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
596 |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
597 } |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
598 |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
599 return retval; |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
600 } |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9192
diff
changeset
|
601 |
| 7241 | 602 int |
| 603 permute_vector_compare (const void *a, const void *b) | |
| 604 { | |
| 605 const permute_vector *pva = static_cast<const permute_vector *> (a); | |
| 606 const permute_vector *pvb = static_cast<const permute_vector *> (b); | |
| 607 | |
| 608 return pva->pidx > pvb->pidx; | |
| 609 } | |
| 610 | |
|
7922
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7642
diff
changeset
|
611 void |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7642
diff
changeset
|
612 gripe_nan_to_logical_conversion (void) |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7642
diff
changeset
|
613 { |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7642
diff
changeset
|
614 (*current_liboctave_error_handler) ("invalid conversion of NaN to logical"); |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7642
diff
changeset
|
615 } |
| 7241 | 616 |
| 4669 | 617 void |
| 618 gripe_nonconformant (const char *op, int op1_len, int op2_len) | |
| 619 { | |
| 620 (*current_liboctave_error_handler) | |
| 621 ("%s: nonconformant arguments (op1 len: %d, op2 len: %d)", | |
| 622 op, op1_len, op2_len); | |
| 623 } | |
| 624 | |
| 625 void | |
| 626 gripe_nonconformant (const char *op, int op1_nr, int op1_nc, | |
| 627 int op2_nr, int op2_nc) | |
| 628 { | |
| 629 (*current_liboctave_error_handler) | |
| 630 ("%s: nonconformant arguments (op1 is %dx%d, op2 is %dx%d)", | |
| 631 op, op1_nr, op1_nc, op2_nr, op2_nc); | |
| 632 } | |
| 633 | |
| 634 void | |
| 635 gripe_nonconformant (const char *op, dim_vector& op1_dims, | |
| 636 dim_vector& op2_dims) | |
| 637 { | |
| 638 std::string op1_dims_str = op1_dims.str (); | |
| 639 std::string op2_dims_str = op2_dims.str (); | |
| 640 | |
| 641 (*current_liboctave_error_handler) | |
| 642 ("%s: nonconformant arguments (op1 is %s, op2 is %s)", | |
| 643 op, op1_dims_str.c_str (), op2_dims_str.c_str ()); | |
| 644 } | |
| 645 | |
| 4588 | 646 /* |
| 647 ;;; Local Variables: *** | |
| 648 ;;; mode: C++ *** | |
| 649 ;;; End: *** | |
| 650 */ |