Mercurial > octave-nkf
annotate liboctave/Array-util.cc @ 8290:7cbe01c21986
improve dense array indexing
| author | Jaroslav Hajek <highegg@gmail.com> |
|---|---|
| date | Mon, 20 Oct 2008 16:54:28 +0200 |
| parents | 4976f66d469b |
| children | 9238637cb81c |
| rev | line source |
|---|---|
| 4588 | 1 /* |
| 2 | |
| 7017 | 3 Copyright (C) 2003, 2004, 2005, 2006, 2007 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" | |
| 4588 | 30 |
| 31 bool | |
| 5275 | 32 index_in_bounds (const Array<octave_idx_type>& ra_idx, const dim_vector& dimensions) |
| 4588 | 33 { |
| 34 bool retval = true; | |
| 35 | |
| 36 int n = ra_idx.length (); | |
| 37 | |
| 38 if (n == dimensions.length ()) | |
| 39 { | |
| 40 for (int i = 0; i < n; i++) | |
| 41 { | |
| 4747 | 42 if (ra_idx(i) < 0 || ra_idx(i) >= dimensions(i)) |
| 4588 | 43 { |
| 44 retval = false; | |
| 45 break; | |
| 46 } | |
| 47 } | |
| 48 } | |
| 49 else | |
| 50 retval = false; | |
| 51 | |
| 52 return retval; | |
| 53 } | |
| 54 | |
| 55 void | |
| 5275 | 56 increment_index (Array<octave_idx_type>& ra_idx, const dim_vector& dimensions, |
| 4588 | 57 int start_dimension) |
| 58 { | |
| 59 ra_idx(start_dimension)++; | |
| 60 | |
| 61 int n = ra_idx.length () - 1; | |
| 6868 | 62 int nda = dimensions.length (); |
| 4588 | 63 |
| 64 for (int i = start_dimension; i < n; i++) | |
| 65 { | |
| 6868 | 66 if (ra_idx(i) < (i < nda ? dimensions(i) : 1)) |
| 4588 | 67 break; |
| 68 else | |
| 69 { | |
| 70 ra_idx(i) = 0; | |
| 71 ra_idx(i+1)++; | |
| 72 } | |
| 73 } | |
| 74 } | |
| 75 | |
| 5275 | 76 octave_idx_type |
| 77 get_scalar_idx (Array<octave_idx_type>& idx, dim_vector& dims) | |
| 4588 | 78 { |
| 5275 | 79 octave_idx_type retval (-1); |
| 4588 | 80 |
| 81 int n = idx.length (); | |
| 82 | |
| 83 if (n > 0) | |
| 84 { | |
| 85 retval = idx(--n); | |
| 86 | |
| 87 while (--n >= 0) | |
| 88 { | |
| 89 retval *= dims (n); | |
| 90 | |
| 91 retval += idx(n); | |
| 92 } | |
| 93 } | |
| 94 return retval; | |
| 95 } | |
| 96 | |
| 5275 | 97 octave_idx_type |
| 98 num_ones (const Array<octave_idx_type>& ra_idx) | |
| 4588 | 99 { |
| 5275 | 100 octave_idx_type retval = 0; |
| 4635 | 101 |
| 5275 | 102 for (octave_idx_type i = 0; i < ra_idx.length (); i++) |
| 4588 | 103 { |
| 104 if (ra_idx (i) == 1) | |
| 105 retval++; | |
| 106 } | |
| 4635 | 107 |
| 4588 | 108 return retval; |
| 109 } | |
| 110 | |
| 111 bool | |
| 112 is_scalar (const dim_vector& dim) | |
| 113 { | |
| 114 bool retval = true; | |
| 115 | |
| 116 int n = dim.length (); | |
| 117 | |
| 118 if (n == 0) | |
| 119 { | |
| 120 retval = false; | |
| 121 } | |
| 122 else | |
| 123 { | |
| 124 for (int i = 0; i < n; i ++) | |
| 125 { | |
| 126 if (dim (i) != 1) | |
| 127 { | |
| 128 retval = false; | |
| 129 | |
| 130 break; | |
| 131 } | |
| 132 } | |
| 133 } | |
| 134 return retval; | |
| 135 } | |
| 136 | |
| 137 bool | |
|
7642
9a4541c622b5
refactor Array::assignN dimensioning code for empty initial matrices
David Bateman <dbateman@free.fr>
parents:
7241
diff
changeset
|
138 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
|
139 { |
|
9a4541c622b5
refactor Array::assignN dimensioning code for empty initial matrices
David Bateman <dbateman@free.fr>
parents:
7241
diff
changeset
|
140 int m = 0; |
|
9a4541c622b5
refactor Array::assignN dimensioning code for empty initial matrices
David Bateman <dbateman@free.fr>
parents:
7241
diff
changeset
|
141 int n = dim.length (); |
|
9a4541c622b5
refactor Array::assignN dimensioning code for empty initial matrices
David Bateman <dbateman@free.fr>
parents:
7241
diff
changeset
|
142 |
|
9a4541c622b5
refactor Array::assignN dimensioning code for empty initial matrices
David Bateman <dbateman@free.fr>
parents:
7241
diff
changeset
|
143 if (n == 0) |
|
9a4541c622b5
refactor Array::assignN dimensioning code for empty initial matrices
David Bateman <dbateman@free.fr>
parents:
7241
diff
changeset
|
144 m = 2; |
|
9a4541c622b5
refactor Array::assignN dimensioning code for empty initial matrices
David Bateman <dbateman@free.fr>
parents:
7241
diff
changeset
|
145 else |
|
9a4541c622b5
refactor Array::assignN dimensioning code for empty initial matrices
David Bateman <dbateman@free.fr>
parents:
7241
diff
changeset
|
146 { |
|
9a4541c622b5
refactor Array::assignN dimensioning code for empty initial matrices
David Bateman <dbateman@free.fr>
parents:
7241
diff
changeset
|
147 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
|
148 if (dim (i) > 1) |
|
9a4541c622b5
refactor Array::assignN dimensioning code for empty initial matrices
David Bateman <dbateman@free.fr>
parents:
7241
diff
changeset
|
149 m++; |
|
9a4541c622b5
refactor Array::assignN dimensioning code for empty initial matrices
David Bateman <dbateman@free.fr>
parents:
7241
diff
changeset
|
150 else 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 += 2; |
|
9a4541c622b5
refactor Array::assignN dimensioning code for empty initial matrices
David Bateman <dbateman@free.fr>
parents:
7241
diff
changeset
|
152 } |
| 7924 | 153 |
|
7642
9a4541c622b5
refactor Array::assignN dimensioning code for empty initial matrices
David Bateman <dbateman@free.fr>
parents:
7241
diff
changeset
|
154 return (m < 2); |
|
9a4541c622b5
refactor Array::assignN dimensioning code for empty initial matrices
David Bateman <dbateman@free.fr>
parents:
7241
diff
changeset
|
155 } |
|
9a4541c622b5
refactor Array::assignN dimensioning code for empty initial matrices
David Bateman <dbateman@free.fr>
parents:
7241
diff
changeset
|
156 |
|
9a4541c622b5
refactor Array::assignN dimensioning code for empty initial matrices
David Bateman <dbateman@free.fr>
parents:
7241
diff
changeset
|
157 bool |
| 5275 | 158 any_ones (const Array<octave_idx_type>& arr) |
| 4588 | 159 { |
| 160 bool retval = false; | |
| 161 | |
| 5275 | 162 for (octave_idx_type i = 0; i < arr.length (); i++) |
| 4588 | 163 { |
| 164 if (arr (i) == 1) | |
| 165 { | |
| 166 retval = true; | |
| 167 | |
| 168 break; | |
| 169 } | |
| 170 } | |
| 171 return retval; | |
| 172 } | |
| 173 | |
| 5275 | 174 octave_idx_type |
| 175 compute_index (const Array<octave_idx_type>& ra_idx, const dim_vector& dims) | |
| 4588 | 176 { |
| 5275 | 177 octave_idx_type retval = -1; |
| 4588 | 178 |
| 179 int n = dims.length (); | |
| 180 | |
| 181 if (n > 0 && n == ra_idx.length ()) | |
| 182 { | |
| 183 retval = ra_idx(--n); | |
| 184 | |
| 185 while (--n >= 0) | |
| 186 { | |
| 187 retval *= dims(n); | |
| 188 | |
| 189 retval += ra_idx(n); | |
| 190 } | |
| 191 } | |
| 192 else | |
| 193 (*current_liboctave_error_handler) | |
| 194 ("ArrayN<T>::compute_index: invalid ra_idxing operation"); | |
| 195 | |
| 196 return retval; | |
| 197 } | |
| 198 | |
| 5275 | 199 Array<octave_idx_type> |
| 4588 | 200 conv_to_int_array (const Array<idx_vector>& a) |
| 201 { | |
| 5275 | 202 Array<octave_idx_type> retval (a.length ()); |
| 4588 | 203 |
| 5275 | 204 for (octave_idx_type i = 0; i < a.length (); i++) |
| 4588 | 205 retval (i) = a(i).elem (0); |
| 206 | |
| 207 return retval; | |
| 208 } | |
| 209 | |
| 210 Array<idx_vector> | |
| 5275 | 211 conv_to_array (const idx_vector *tmp, const octave_idx_type len) |
| 4588 | 212 { |
| 213 Array<idx_vector> retval (len); | |
| 214 | |
| 5275 | 215 for (octave_idx_type i = 0; i < len; i++) |
| 4588 | 216 retval (i) = tmp[i]; |
| 217 | |
| 218 return retval; | |
| 219 } | |
| 220 | |
| 221 dim_vector | |
| 222 freeze (Array<idx_vector>& ra_idx, const dim_vector& dimensions, int resize_ok) | |
| 223 { | |
| 224 dim_vector retval; | |
| 225 | |
| 226 int n = ra_idx.length (); | |
| 227 | |
| 228 assert (n == dimensions.length ()); | |
| 229 | |
| 230 retval.resize (n); | |
| 231 | |
| 5136 | 232 static const char *tag[3] = { "row", "column", 0 }; |
| 233 | |
| 4588 | 234 for (int i = 0; i < n; i++) |
| 5136 | 235 retval(i) = ra_idx(i).freeze (dimensions(i), tag[i < 2 ? i : 3], |
| 236 resize_ok); | |
| 4588 | 237 |
| 238 return retval; | |
| 239 } | |
| 240 | |
| 241 bool | |
| 5519 | 242 vector_equivalent (const dim_vector& dv) |
| 4588 | 243 { |
| 5519 | 244 int n = dv.length (); |
| 4588 | 245 |
| 246 bool found_first = false; | |
| 247 | |
| 5519 | 248 for (int i = 0; i < n; i++) |
| 4588 | 249 { |
| 5519 | 250 if (dv(i) != 1) |
| 4588 | 251 { |
| 252 if (! found_first) | |
| 253 found_first = true; | |
| 254 else | |
| 255 return false; | |
| 256 } | |
| 257 } | |
| 258 | |
| 259 return true; | |
| 260 } | |
| 261 | |
| 262 bool | |
| 263 all_ok (const Array<idx_vector>& ra_idx) | |
| 264 { | |
| 265 bool retval = true; | |
| 266 | |
| 5275 | 267 octave_idx_type n = ra_idx.length (); |
| 4588 | 268 |
| 5275 | 269 for (octave_idx_type i = 0; i < n; i++) |
| 4588 | 270 { |
| 271 if (! ra_idx(i)) | |
| 272 { | |
| 273 retval = false; | |
| 274 break; | |
| 275 } | |
| 276 } | |
| 277 | |
| 278 return retval; | |
| 279 } | |
| 280 | |
| 281 bool | |
| 282 any_orig_empty (const Array<idx_vector>& ra_idx) | |
| 283 { | |
| 284 bool retval = false; | |
| 285 | |
| 5275 | 286 octave_idx_type n = ra_idx.length (); |
| 4588 | 287 |
| 5275 | 288 for (octave_idx_type i = 0; i < n; i++) |
| 4588 | 289 { |
| 290 if (ra_idx(i).orig_empty ()) | |
| 291 { | |
| 292 retval = true; | |
| 293 break; | |
| 294 } | |
| 295 } | |
| 296 | |
| 297 return retval; | |
| 298 } | |
| 299 | |
| 300 bool | |
| 301 all_colon_equiv (const Array<idx_vector>& ra_idx, | |
| 302 const dim_vector& frozen_lengths) | |
| 303 { | |
| 304 bool retval = true; | |
| 305 | |
| 5275 | 306 octave_idx_type idx_n = ra_idx.length (); |
| 4588 | 307 |
| 308 int n = frozen_lengths.length (); | |
| 309 | |
| 310 assert (idx_n == n); | |
| 311 | |
| 5275 | 312 for (octave_idx_type i = 0; i < n; i++) |
| 4588 | 313 { |
| 314 if (! ra_idx(i).is_colon_equiv (frozen_lengths(i))) | |
| 315 { | |
| 316 retval = false; | |
| 317 break; | |
| 318 } | |
| 319 } | |
| 320 | |
| 321 return retval; | |
| 322 } | |
| 323 | |
| 324 bool | |
| 5275 | 325 all_ones (const Array<octave_idx_type>& arr) |
| 4588 | 326 { |
| 327 bool retval = true; | |
| 328 | |
| 5275 | 329 for (octave_idx_type i = 0; i < arr.length (); i++) |
| 4588 | 330 { |
| 331 if (arr(i) != 1) | |
| 332 { | |
| 333 retval = false; | |
| 334 break; | |
| 335 } | |
| 336 } | |
| 337 | |
| 338 return retval; | |
| 339 } | |
| 340 | |
| 5275 | 341 Array<octave_idx_type> |
| 342 get_elt_idx (const Array<idx_vector>& ra_idx, const Array<octave_idx_type>& result_idx) | |
| 4588 | 343 { |
| 5275 | 344 octave_idx_type n = ra_idx.length (); |
| 4588 | 345 |
| 5275 | 346 Array<octave_idx_type> retval (n); |
| 4588 | 347 |
| 5275 | 348 for (octave_idx_type i = 0; i < n; i++) |
| 4588 | 349 retval(i) = ra_idx(i).elem (result_idx(i)); |
| 350 | |
| 351 return retval; | |
| 352 } | |
| 353 | |
| 5275 | 354 Array<octave_idx_type> |
| 355 get_ra_idx (octave_idx_type idx, const dim_vector& dims) | |
| 4588 | 356 { |
| 5275 | 357 Array<octave_idx_type> retval; |
| 4588 | 358 |
| 359 int n_dims = dims.length (); | |
| 360 | |
| 361 retval.resize (n_dims); | |
| 362 | |
| 363 for (int i = 0; i < n_dims; i++) | |
| 364 retval(i) = 0; | |
| 365 | |
| 4747 | 366 assert (idx > 0 || idx < dims.numel ()); |
| 4588 | 367 |
| 5275 | 368 for (octave_idx_type i = 0; i < idx; i++) |
| 4588 | 369 increment_index (retval, dims); |
| 370 | |
| 5775 | 371 // FIXME -- the solution using increment_index is not |
| 4588 | 372 // efficient. |
| 373 | |
| 374 #if 0 | |
| 5275 | 375 octave_idx_type var = 1; |
| 4588 | 376 for (int i = 0; i < n_dims; i++) |
| 377 { | |
| 378 std::cout << "idx: " << idx << ", var: " << var << ", dims(" << i << "): " << dims(i) <<"\n"; | |
| 379 retval(i) = ((int)floor(((idx) / (double)var))) % dims(i); | |
| 380 idx -= var * retval(i); | |
| 381 var = dims(i); | |
| 382 } | |
| 383 #endif | |
| 384 | |
| 385 return retval; | |
| 386 } | |
| 387 | |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
388 dim_vector zero_dims_inquire (const Array<idx_vector>& ia, |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
389 const dim_vector& rhdv) |
| 4588 | 390 { |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
391 int ial = ia.length (), rhdvl = rhdv.length (); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
392 dim_vector rdv; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
393 rdv.resize (ial); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
394 bool *scalar = new bool[ial], *colon = new bool[ial]; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
395 // Mark scalars and colons, count non-scalar indices. |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
396 int nonsc = 0; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
397 bool all_colons = true; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
398 for (int i = 0; i < ial; i++) |
| 4588 | 399 { |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
400 // FIXME: should we check for length() instead? |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
401 scalar[i] = ia(i).is_scalar (); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
402 colon[i] = ia(i).is_colon (); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
403 if (! scalar[i]) nonsc++; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
404 if (! colon[i]) rdv(i) = ia(i).extent (0); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
405 all_colons = all_colons && colon[i]; |
| 4588 | 406 } |
| 407 | |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
408 bool match = false; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
409 // If the number of nonscalar indices matches the dimensionality of RHS, |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
410 // we try an exact match, inquiring even singleton dimensions. |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
411 if (all_colons) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
412 { |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
413 rdv = rhdv; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
414 rdv.resize(ial, 1); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
415 } |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
416 else if (nonsc == rhdvl) |
|
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 for (int i = 0, j = 0; i < ial; i++) |
|
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 if (scalar[i]) continue; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
421 if (colon[i]) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
422 rdv(i) = rhdv(j++); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
423 } |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
424 } |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
425 else |
|
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 dim_vector rhdv0 = rhdv; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
428 rhdv0.chop_all_singletons (); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
429 int rhdv0l = rhdv0.length (); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
430 for (int i = 0, j = 0; i < ial; i++) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
431 { |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
432 if (scalar[i]) continue; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
433 if (colon[i]) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
434 rdv(i) = (j < rhdv0l) ? rhdv0(j++) : 1; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
435 } |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
436 } |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
437 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
438 delete [] scalar; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
439 delete [] colon; |
|
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 return rdv; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
442 } |
|
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 dim_vector zero_dims_inquire (const idx_vector& i, const idx_vector& j, |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
445 const dim_vector& rhdv) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
446 { |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
447 bool icol = i.is_colon (), jcol = j.is_colon (); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
448 dim_vector rdv; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
449 if (icol && jcol && rhdv.length () == 2) |
|
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 rdv(0) = rhdv(0); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
452 rdv(1) = rhdv(1); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
453 } |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
454 else |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
455 { |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
456 dim_vector rhdv0 = rhdv; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
457 rhdv0.chop_all_singletons (); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
458 int k = 0; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
459 rdv(0) = i.extent (0); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
460 if (icol) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
461 rdv(0) = rhdv0(k++); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
462 else if (! i.is_scalar ()) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
463 k++; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
464 rdv(1) = j.extent (0); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
465 if (jcol) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
466 rdv(1) = rhdv0(k++); |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
467 else if (! j.is_scalar ()) |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
468 k++; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
469 } |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
470 |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
471 return rdv; |
| 4588 | 472 } |
| 473 | |
| 7241 | 474 int |
| 475 permute_vector_compare (const void *a, const void *b) | |
| 476 { | |
| 477 const permute_vector *pva = static_cast<const permute_vector *> (a); | |
| 478 const permute_vector *pvb = static_cast<const permute_vector *> (b); | |
| 479 | |
| 480 return pva->pidx > pvb->pidx; | |
| 481 } | |
| 482 | |
|
7922
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7642
diff
changeset
|
483 void |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7642
diff
changeset
|
484 gripe_nan_to_logical_conversion (void) |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7642
diff
changeset
|
485 { |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7642
diff
changeset
|
486 (*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
|
487 } |
| 7241 | 488 |
| 4669 | 489 void |
| 490 gripe_nonconformant (const char *op, int op1_len, int op2_len) | |
| 491 { | |
| 492 (*current_liboctave_error_handler) | |
| 493 ("%s: nonconformant arguments (op1 len: %d, op2 len: %d)", | |
| 494 op, op1_len, op2_len); | |
| 495 } | |
| 496 | |
| 497 void | |
| 498 gripe_nonconformant (const char *op, int op1_nr, int op1_nc, | |
| 499 int op2_nr, int op2_nc) | |
| 500 { | |
| 501 (*current_liboctave_error_handler) | |
| 502 ("%s: nonconformant arguments (op1 is %dx%d, op2 is %dx%d)", | |
| 503 op, op1_nr, op1_nc, op2_nr, op2_nc); | |
| 504 } | |
| 505 | |
| 506 void | |
| 507 gripe_nonconformant (const char *op, dim_vector& op1_dims, | |
| 508 dim_vector& op2_dims) | |
| 509 { | |
| 510 std::string op1_dims_str = op1_dims.str (); | |
| 511 std::string op2_dims_str = op2_dims.str (); | |
| 512 | |
| 513 (*current_liboctave_error_handler) | |
| 514 ("%s: nonconformant arguments (op1 is %s, op2 is %s)", | |
| 515 op, op1_dims_str.c_str (), op2_dims_str.c_str ()); | |
| 516 } | |
| 517 | |
| 4588 | 518 /* |
| 519 ;;; Local Variables: *** | |
| 520 ;;; mode: C++ *** | |
| 521 ;;; End: *** | |
| 522 */ |