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