Mercurial > hg > octave-nkf

comparison liboctave/Array.cc @ 5275:23b37da9fd5b

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[project @ 2005-04-08 16:07:35 by jwe]
author jwe
date Fri, 08 Apr 2005 16:07:37 +0000
parents 86185152b7a4
children fe5ee25a5e6c
comparison
equal deleted inserted replaced
5274:eae7b40388e9 5275:23b37da9fd5b
91 new_dimensions = dim_vector (1, 1); 91 new_dimensions = dim_vector (1, 1);
92 break; 92 break;
93 93
94 case 1: 94 case 1:
95 { 95 {
96 int tmp = new_dimensions(0); 96 octave_idx_type tmp = new_dimensions(0);
97 97
98 new_dimensions.resize (2); 98 new_dimensions.resize (2);
99 99
100 new_dimensions(0) = tmp; 100 new_dimensions(0) = tmp;
101 new_dimensions(1) = 1; 101 new_dimensions(1) = 1;
122 122
123 // A guess (should be quite conservative). 123 // A guess (should be quite conservative).
124 #define MALLOC_OVERHEAD 1024 124 #define MALLOC_OVERHEAD 1024
125 125
126 template <class T> 126 template <class T>
127 int 127 octave_idx_type
128 Array<T>::get_size (int r, int c) 128 Array<T>::get_size (octave_idx_type r, octave_idx_type c)
129 { 129 {
130 // XXX KLUGE XXX 130 // XXX KLUGE XXX
131 131
132 // If an allocation of an array with r * c elements of type T 132 // If an allocation of an array with r * c elements of type T
133 // would cause an overflow in the allocator when computing the 133 // would cause an overflow in the allocator when computing the
136 // most current hardware, but not so large to cause the 136 // most current hardware, but not so large to cause the
137 // allocator to barf on computing retval * sizeof (T). 137 // allocator to barf on computing retval * sizeof (T).
138 138
139 static int nl; 139 static int nl;
140 static double dl 140 static double dl
141 = frexp (static_cast<double> 141 = frexp (static_cast<double>
142 (INT_MAX - MALLOC_OVERHEAD) / sizeof (T), &nl); 142 (std::numeric_limits<octave_idx_type>::max() - MALLOC_OVERHEAD) / sizeof (T), &nl);
143 143
144 // This value should be an integer. If we return this value and 144 // This value should be an integer. If we return this value and
145 // things work the way we expect, we should be paying a visit to 145 // things work the way we expect, we should be paying a visit to
146 // new_handler in no time flat. 146 // new_handler in no time flat.
147 static int max_items = static_cast<int> (ldexp (dl, nl)); 147 static octave_idx_type max_items = static_cast<octave_idx_type> (ldexp (dl, nl)); // = dl.2^nl
148 148
149 int nr, nc; 149 int nr, nc;
150 double dr = frexp (static_cast<double> (r), &nr); 150 double dr = frexp (static_cast<double> (r), &nr); // r = dr * 2^nr
151 double dc = frexp (static_cast<double> (c), &nc); 151 double dc = frexp (static_cast<double> (c), &nc); // c = dc * 2^nc
152 152
153 int nt = nr + nc; 153 int nt = nr + nc;
154 double dt = dr * dc; 154 double dt = dr * dc;
155 155
156 if (dt < 0.5) 156 if (dt < 0.5)
157 { 157 {
158 nt--; 158 nt--;
159 dt *= 2; 159 dt *= 2;
160 } 160 }
161 161
162 // if (r*c) below limit, then return r*c, otherwise return TOO BIG num!
162 return (nt < nl || (nt == nl && dt < dl)) ? r * c : max_items; 163 return (nt < nl || (nt == nl && dt < dl)) ? r * c : max_items;
163 } 164 }
164 165
165 template <class T> 166 template <class T>
166 int 167 octave_idx_type
167 Array<T>::get_size (int r, int c, int p) 168 Array<T>::get_size (octave_idx_type r, octave_idx_type c, octave_idx_type p)
168 { 169 {
169 // XXX KLUGE XXX 170 // XXX KLUGE XXX
170 171
171 // If an allocation of an array with r * c * p elements of type T 172 // If an allocation of an array with r * c * p elements of type T
172 // would cause an overflow in the allocator when computing the 173 // would cause an overflow in the allocator when computing the
176 // allocator to barf on computing retval * sizeof (T). 177 // allocator to barf on computing retval * sizeof (T).
177 178
178 static int nl; 179 static int nl;
179 static double dl 180 static double dl
180 = frexp (static_cast<double> 181 = frexp (static_cast<double>
181 (INT_MAX - MALLOC_OVERHEAD) / sizeof (T), &nl); 182 (std::numeric_limits<octave_idx_type>::max() - MALLOC_OVERHEAD) / sizeof (T), &nl);
182 183
183 // This value should be an integer. If we return this value and 184 // This value should be an integer. If we return this value and
184 // things work the way we expect, we should be paying a visit to 185 // things work the way we expect, we should be paying a visit to
185 // new_handler in no time flat. 186 // new_handler in no time flat.
186 static int max_items = static_cast<int> (ldexp (dl, nl)); 187 static octave_idx_type max_items = static_cast<octave_idx_type> (ldexp (dl, nl));
187 188
188 int nr, nc, np; 189 int nr, nc, np;
189 double dr = frexp (static_cast<double> (r), &nr); 190 double dr = frexp (static_cast<double> (r), &nr);
190 double dc = frexp (static_cast<double> (c), &nc); 191 double dc = frexp (static_cast<double> (c), &nc);
191 double dp = frexp (static_cast<double> (p), &np); 192 double dp = frexp (static_cast<double> (p), &np);
207 208
208 return (nt < nl || (nt == nl && dt < dl)) ? r * c * p : max_items; 209 return (nt < nl || (nt == nl && dt < dl)) ? r * c * p : max_items;
209 } 210 }
210 211
211 template <class T> 212 template <class T>
212 int 213 octave_idx_type
213 Array<T>::get_size (const dim_vector& ra_idx) 214 Array<T>::get_size (const dim_vector& ra_idx)
214 { 215 {
215 // XXX KLUGE XXX 216 // XXX KLUGE XXX
216 217
217 // If an allocation of an array with r * c elements of type T 218 // If an allocation of an array with r * c elements of type T
222 // allocator to barf on computing retval * sizeof (T). 223 // allocator to barf on computing retval * sizeof (T).
223 224
224 static int nl; 225 static int nl;
225 static double dl 226 static double dl
226 = frexp (static_cast<double> 227 = frexp (static_cast<double>
227 (INT_MAX - MALLOC_OVERHEAD) / sizeof (T), &nl); 228 (std::numeric_limits<octave_idx_type>::max() - MALLOC_OVERHEAD) / sizeof (T), &nl);
228 229
229 // This value should be an integer. If we return this value and 230 // This value should be an integer. If we return this value and
230 // things work the way we expect, we should be paying a visit to 231 // things work the way we expect, we should be paying a visit to
231 // new_handler in no time flat. 232 // new_handler in no time flat.
232 233
233 static int max_items = static_cast<int> (ldexp (dl, nl)); 234 static octave_idx_type max_items = static_cast<octave_idx_type> (ldexp (dl, nl));
234 235
235 int retval = max_items; 236 octave_idx_type retval = max_items;
236 237
237 int n = ra_idx.length (); 238 int n = ra_idx.length ();
238 239
239 int nt = 0; 240 int nt = 0;
240 double dt = 1; 241 double dt = 1;
266 } 267 }
267 268
268 #undef MALLOC_OVERHEAD 269 #undef MALLOC_OVERHEAD
269 270
270 template <class T> 271 template <class T>
271 int 272 octave_idx_type
272 Array<T>::compute_index (const Array<int>& ra_idx) const 273 Array<T>::compute_index (const Array<octave_idx_type>& ra_idx) const
273 { 274 {
274 int retval = -1; 275 octave_idx_type retval = -1;
275 276
276 int n = dimensions.length (); 277 int n = dimensions.length ();
277 278
278 if (n > 0 && n == ra_idx.length ()) 279 if (n > 0 && n == ra_idx.length ())
279 { 280 {
292 return retval; 293 return retval;
293 } 294 }
294 295
295 template <class T> 296 template <class T>
296 T 297 T
297 Array<T>::range_error (const char *fcn, int n) const 298 Array<T>::range_error (const char *fcn, octave_idx_type n) const
298 { 299 {
299 (*current_liboctave_error_handler) ("%s (%d): range error", fcn, n); 300 (*current_liboctave_error_handler) ("%s (%d): range error", fcn, n);
300 return T (); 301 return T ();
301 } 302 }
302 303
303 template <class T> 304 template <class T>
304 T& 305 T&
305 Array<T>::range_error (const char *fcn, int n) 306 Array<T>::range_error (const char *fcn, octave_idx_type n)
306 { 307 {
307 (*current_liboctave_error_handler) ("%s (%d): range error", fcn, n); 308 (*current_liboctave_error_handler) ("%s (%d): range error", fcn, n);
308 static T foo; 309 static T foo;
309 return foo; 310 return foo;
310 } 311 }
311 312
312 template <class T> 313 template <class T>
313 T 314 T
314 Array<T>::range_error (const char *fcn, int i, int j) const 315 Array<T>::range_error (const char *fcn, octave_idx_type i, octave_idx_type j) const
315 { 316 {
316 (*current_liboctave_error_handler) 317 (*current_liboctave_error_handler)
317 ("%s (%d, %d): range error", fcn, i, j); 318 ("%s (%d, %d): range error", fcn, i, j);
318 return T (); 319 return T ();
319 } 320 }
320 321
321 template <class T> 322 template <class T>
322 T& 323 T&
323 Array<T>::range_error (const char *fcn, int i, int j) 324 Array<T>::range_error (const char *fcn, octave_idx_type i, octave_idx_type j)
324 { 325 {
325 (*current_liboctave_error_handler) 326 (*current_liboctave_error_handler)
326 ("%s (%d, %d): range error", fcn, i, j); 327 ("%s (%d, %d): range error", fcn, i, j);
327 static T foo; 328 static T foo;
328 return foo; 329 return foo;
329 } 330 }
330 331
331 template <class T> 332 template <class T>
332 T 333 T
333 Array<T>::range_error (const char *fcn, int i, int j, int k) const 334 Array<T>::range_error (const char *fcn, octave_idx_type i, octave_idx_type j, octave_idx_type k) const
334 { 335 {
335 (*current_liboctave_error_handler) 336 (*current_liboctave_error_handler)
336 ("%s (%d, %d, %d): range error", fcn, i, j, k); 337 ("%s (%d, %d, %d): range error", fcn, i, j, k);
337 return T (); 338 return T ();
338 } 339 }
339 340
340 template <class T> 341 template <class T>
341 T& 342 T&
342 Array<T>::range_error (const char *fcn, int i, int j, int k) 343 Array<T>::range_error (const char *fcn, octave_idx_type i, octave_idx_type j, octave_idx_type k)
343 { 344 {
344 (*current_liboctave_error_handler) 345 (*current_liboctave_error_handler)
345 ("%s (%d, %d, %d): range error", fcn, i, j, k); 346 ("%s (%d, %d, %d): range error", fcn, i, j, k);
346 static T foo; 347 static T foo;
347 return foo; 348 return foo;
353 { 354 {
354 OSSTREAM buf; 355 OSSTREAM buf;
355 356
356 buf << fcn << " ("; 357 buf << fcn << " (";
357 358
358 int n = ra_idx.length (); 359 octave_idx_type n = ra_idx.length ();
359 360
360 if (n > 0) 361 if (n > 0)
361 buf << ra_idx(0); 362 buf << ra_idx(0);
362 363
363 for (int i = 1; i < n; i++) 364 for (octave_idx_type i = 1; i < n; i++)
364 buf << ", " << ra_idx(i); 365 buf << ", " << ra_idx(i);
365 366
366 buf << "): range error"; 367 buf << "): range error";
367 368
368 buf << OSSTREAM_ENDS; 369 buf << OSSTREAM_ENDS;
380 { 381 {
381 OSSTREAM buf; 382 OSSTREAM buf;
382 383
383 buf << fcn << " ("; 384 buf << fcn << " (";
384 385
385 int n = ra_idx.length (); 386 octave_idx_type n = ra_idx.length ();
386 387
387 if (n > 0) 388 if (n > 0)
388 buf << ra_idx(0); 389 buf << ra_idx(0);
389 390
390 for (int i = 1; i < n; i++) 391 for (octave_idx_type i = 1; i < n; i++)
391 buf << ", " << ra_idx(i); 392 buf << ", " << ra_idx(i);
392 393
393 buf << "): range error"; 394 buf << "): range error";
394 395
395 buf << OSSTREAM_ENDS; 396 buf << OSSTREAM_ENDS;
421 return retval; 422 return retval;
422 } 423 }
423 424
424 template <class T> 425 template <class T>
425 Array<T> 426 Array<T>
426 Array<T>::permute (const Array<int>& perm_vec, bool inv) const 427 Array<T>::permute (const Array<octave_idx_type>& perm_vec, bool inv) const
427 { 428 {
428 Array<T> retval; 429 Array<T> retval;
429 430
430 dim_vector dv = dims (); 431 dim_vector dv = dims ();
431 dim_vector dv_new; 432 dim_vector dv_new;
447 Array<bool> checked (perm_vec_len, false); 448 Array<bool> checked (perm_vec_len, false);
448 449
449 // Find dimension vector of permuted array. 450 // Find dimension vector of permuted array.
450 for (int i = 0; i < perm_vec_len; i++) 451 for (int i = 0; i < perm_vec_len; i++)
451 { 452 {
452 int perm_elt = perm_vec.elem (i); 453 octave_idx_type perm_elt = perm_vec.elem (i);
453 454
454 if (perm_elt >= perm_vec_len || perm_elt < 0) 455 if (perm_elt >= perm_vec_len || perm_elt < 0)
455 { 456 {
456 (*current_liboctave_error_handler) 457 (*current_liboctave_error_handler)
457 ("%s: permutation vector contains an invalid element", 458 ("%s: permutation vector contains an invalid element",
475 } 476 }
476 477
477 retval.resize (dv_new); 478 retval.resize (dv_new);
478 479
479 // Index array to the original array. 480 // Index array to the original array.
480 Array<int> old_idx (perm_vec_len, 0); 481 Array<octave_idx_type> old_idx (perm_vec_len, 0);
481 482
482 // Number of elements in Array (should be the same for 483 // Number of elements in Array (should be the same for
483 // both the permuted array and original array). 484 // both the permuted array and original array).
484 int n = retval.length (); 485 octave_idx_type n = retval.length ();
485 486
486 // Permute array. 487 // Permute array.
487 for (int i = 0; i < n; i++) 488 for (octave_idx_type i = 0; i < n; i++)
488 { 489 {
489 // Get the idx of permuted array. 490 // Get the idx of permuted array.
490 Array<int> new_idx = calc_permutated_idx (old_idx, perm_vec, inv); 491 Array<octave_idx_type> new_idx = calc_permutated_idx (old_idx, perm_vec, inv);
491 492
492 retval.elem (new_idx) = tmp.elem (old_idx); 493 retval.elem (new_idx) = tmp.elem (old_idx);
493 494
494 increment_index (old_idx, dv); 495 increment_index (old_idx, dv);
495 } 496 }
497 return retval; 498 return retval;
498 } 499 }
499 500
500 template <class T> 501 template <class T>
501 void 502 void
502 Array<T>::resize_no_fill (int n) 503 Array<T>::resize_no_fill (octave_idx_type n)
503 { 504 {
504 if (n < 0) 505 if (n < 0)
505 { 506 {
506 (*current_liboctave_error_handler) 507 (*current_liboctave_error_handler)
507 ("can't resize to negative dimension"); 508 ("can't resize to negative dimension");
511 if (n == length ()) 512 if (n == length ())
512 return; 513 return;
513 514
514 typename Array<T>::ArrayRep *old_rep = rep; 515 typename Array<T>::ArrayRep *old_rep = rep;
515 const T *old_data = data (); 516 const T *old_data = data ();
516 int old_len = length (); 517 octave_idx_type old_len = length ();
517 518
518 rep = new typename Array<T>::ArrayRep (n); 519 rep = new typename Array<T>::ArrayRep (n);
519 520
520 dimensions = dim_vector (n); 521 dimensions = dim_vector (n);
521 522
522 if (n > 0 && old_data && old_len > 0) 523 if (n > 0 && old_data && old_len > 0)
523 { 524 {
524 int min_len = old_len < n ? old_len : n; 525 octave_idx_type min_len = old_len < n ? old_len : n;
525 526
526 for (int i = 0; i < min_len; i++) 527 for (octave_idx_type i = 0; i < min_len; i++)
527 xelem (i) = old_data[i]; 528 xelem (i) = old_data[i];
528 } 529 }
529 530
530 if (--old_rep->count <= 0) 531 if (--old_rep->count <= 0)
531 delete old_rep; 532 delete old_rep;
533 534
534 template <class T> 535 template <class T>
535 void 536 void
536 Array<T>::resize_no_fill (const dim_vector& dv) 537 Array<T>::resize_no_fill (const dim_vector& dv)
537 { 538 {
538 int n = dv.length (); 539 octave_idx_type n = dv.length ();
539 540
540 for (int i = 0; i < n; i++) 541 for (octave_idx_type i = 0; i < n; i++)
541 { 542 {
542 if (dv(i) < 0) 543 if (dv(i) < 0)
543 { 544 {
544 (*current_liboctave_error_handler) 545 (*current_liboctave_error_handler)
545 ("can't resize to negative dimension"); 546 ("can't resize to negative dimension");
553 { 554 {
554 same_size = false; 555 same_size = false;
555 } 556 }
556 else 557 else
557 { 558 {
558 for (int i = 0; i < n; i++) 559 for (octave_idx_type i = 0; i < n; i++)
559 { 560 {
560 if (dv(i) != dimensions(i)) 561 if (dv(i) != dimensions(i))
561 { 562 {
562 same_size = false; 563 same_size = false;
563 break; 564 break;
569 return; 570 return;
570 571
571 typename Array<T>::ArrayRep *old_rep = rep; 572 typename Array<T>::ArrayRep *old_rep = rep;
572 const T *old_data = data (); 573 const T *old_data = data ();
573 574
574 int ts = get_size (dv); 575 octave_idx_type ts = get_size (dv);
575 576
576 rep = new typename Array<T>::ArrayRep (ts); 577 rep = new typename Array<T>::ArrayRep (ts);
577 578
578 dim_vector dv_old = dimensions; 579 dim_vector dv_old = dimensions;
579 int dv_old_orig_len = dv_old.length (); 580 octave_idx_type dv_old_orig_len = dv_old.length ();
580 dimensions = dv; 581 dimensions = dv;
581 int ts_old = get_size (dv_old); 582 octave_idx_type ts_old = get_size (dv_old);
582 583
583 if (ts > 0 && ts_old > 0 && dv_old_orig_len > 0) 584 if (ts > 0 && ts_old > 0 && dv_old_orig_len > 0)
584 { 585 {
585 Array<int> ra_idx (dimensions.length (), 0); 586 Array<octave_idx_type> ra_idx (dimensions.length (), 0);
586 587
587 if (n > dv_old_orig_len) 588 if (n > dv_old_orig_len)
588 { 589 {
589 dv_old.resize (n); 590 dv_old.resize (n);
590 591
591 for (int i = dv_old_orig_len; i < n; i++) 592 for (octave_idx_type i = dv_old_orig_len; i < n; i++)
592 dv_old.elem (i) = 1; 593 dv_old.elem (i) = 1;
593 } 594 }
594 595
595 for (int i = 0; i < ts; i++) 596 for (octave_idx_type i = 0; i < ts; i++)
596 { 597 {
597 if (index_in_bounds (ra_idx, dv_old)) 598 if (index_in_bounds (ra_idx, dv_old))
598 rep->elem (i) = old_data[get_scalar_idx (ra_idx, dv_old)]; 599 rep->elem (i) = old_data[get_scalar_idx (ra_idx, dv_old)];
599 600
600 increment_index (ra_idx, dimensions); 601 increment_index (ra_idx, dimensions);
605 delete old_rep; 606 delete old_rep;
606 } 607 }
607 608
608 template <class T> 609 template <class T>
609 void 610 void
610 Array<T>::resize_no_fill (int r, int c) 611 Array<T>::resize_no_fill (octave_idx_type r, octave_idx_type c)
611 { 612 {
612 if (r < 0 || c < 0) 613 if (r < 0 || c < 0)
613 { 614 {
614 (*current_liboctave_error_handler) 615 (*current_liboctave_error_handler)
615 ("can't resize to negative dimension"); 616 ("can't resize to negative dimension");
627 return; 628 return;
628 629
629 typename Array<T>::ArrayRep *old_rep = Array<T>::rep; 630 typename Array<T>::ArrayRep *old_rep = Array<T>::rep;
630 const T *old_data = data (); 631 const T *old_data = data ();
631 632
632 int old_d1 = dim1 (); 633 octave_idx_type old_d1 = dim1 ();
633 int old_d2 = dim2 (); 634 octave_idx_type old_d2 = dim2 ();
634 int old_len = length (); 635 octave_idx_type old_len = length ();
635 636
636 int ts = get_size (r, c); 637 octave_idx_type ts = get_size (r, c);
637 638
638 rep = new typename Array<T>::ArrayRep (ts); 639 rep = new typename Array<T>::ArrayRep (ts);
639 640
640 dimensions = dim_vector (r, c); 641 dimensions = dim_vector (r, c);
641 642
642 if (ts > 0 && old_data && old_len > 0) 643 if (ts > 0 && old_data && old_len > 0)
643 { 644 {
644 int min_r = old_d1 < r ? old_d1 : r; 645 octave_idx_type min_r = old_d1 < r ? old_d1 : r;
645 int min_c = old_d2 < c ? old_d2 : c; 646 octave_idx_type min_c = old_d2 < c ? old_d2 : c;
646 647
647 for (int j = 0; j < min_c; j++) 648 for (octave_idx_type j = 0; j < min_c; j++)
648 for (int i = 0; i < min_r; i++) 649 for (octave_idx_type i = 0; i < min_r; i++)
649 xelem (i, j) = old_data[old_d1*j+i]; 650 xelem (i, j) = old_data[old_d1*j+i];
650 } 651 }
651 652
652 if (--old_rep->count <= 0) 653 if (--old_rep->count <= 0)
653 delete old_rep; 654 delete old_rep;
654 } 655 }
655 656
656 template <class T> 657 template <class T>
657 void 658 void
658 Array<T>::resize_no_fill (int r, int c, int p) 659 Array<T>::resize_no_fill (octave_idx_type r, octave_idx_type c, octave_idx_type p)
659 { 660 {
660 if (r < 0 || c < 0 || p < 0) 661 if (r < 0 || c < 0 || p < 0)
661 { 662 {
662 (*current_liboctave_error_handler) 663 (*current_liboctave_error_handler)
663 ("can't resize to negative dimension"); 664 ("can't resize to negative dimension");
675 return; 676 return;
676 677
677 typename Array<T>::ArrayRep *old_rep = rep; 678 typename Array<T>::ArrayRep *old_rep = rep;
678 const T *old_data = data (); 679 const T *old_data = data ();
679 680
680 int old_d1 = dim1 (); 681 octave_idx_type old_d1 = dim1 ();
681 int old_d2 = dim2 (); 682 octave_idx_type old_d2 = dim2 ();
682 int old_d3 = dim3 (); 683 octave_idx_type old_d3 = dim3 ();
683 int old_len = length (); 684 octave_idx_type old_len = length ();
684 685
685 int ts = get_size (get_size (r, c), p); 686 octave_idx_type ts = get_size (get_size (r, c), p);
686 687
687 rep = new typename Array<T>::ArrayRep (ts); 688 rep = new typename Array<T>::ArrayRep (ts);
688 689
689 dimensions = dim_vector (r, c, p); 690 dimensions = dim_vector (r, c, p);
690 691
691 if (ts > 0 && old_data && old_len > 0) 692 if (ts > 0 && old_data && old_len > 0)
692 { 693 {
693 int min_r = old_d1 < r ? old_d1 : r; 694 octave_idx_type min_r = old_d1 < r ? old_d1 : r;
694 int min_c = old_d2 < c ? old_d2 : c; 695 octave_idx_type min_c = old_d2 < c ? old_d2 : c;
695 int min_p = old_d3 < p ? old_d3 : p; 696 octave_idx_type min_p = old_d3 < p ? old_d3 : p;
696 697
697 for (int k = 0; k < min_p; k++) 698 for (octave_idx_type k = 0; k < min_p; k++)
698 for (int j = 0; j < min_c; j++) 699 for (octave_idx_type j = 0; j < min_c; j++)
699 for (int i = 0; i < min_r; i++) 700 for (octave_idx_type i = 0; i < min_r; i++)
700 xelem (i, j, k) = old_data[old_d1*(old_d2*k+j)+i]; 701 xelem (i, j, k) = old_data[old_d1*(old_d2*k+j)+i];
701 } 702 }
702 703
703 if (--old_rep->count <= 0) 704 if (--old_rep->count <= 0)
704 delete old_rep; 705 delete old_rep;
705 } 706 }
706 707
707 template <class T> 708 template <class T>
708 void 709 void
709 Array<T>::resize_and_fill (int n, const T& val) 710 Array<T>::resize_and_fill (octave_idx_type n, const T& val)
710 { 711 {
711 if (n < 0) 712 if (n < 0)
712 { 713 {
713 (*current_liboctave_error_handler) 714 (*current_liboctave_error_handler)
714 ("can't resize to negative dimension"); 715 ("can't resize to negative dimension");
718 if (n == length ()) 719 if (n == length ())
719 return; 720 return;
720 721
721 typename Array<T>::ArrayRep *old_rep = rep; 722 typename Array<T>::ArrayRep *old_rep = rep;
722 const T *old_data = data (); 723 const T *old_data = data ();
723 int old_len = length (); 724 octave_idx_type old_len = length ();
724 725
725 rep = new typename Array<T>::ArrayRep (n); 726 rep = new typename Array<T>::ArrayRep (n);
726 727
727 dimensions = dim_vector (n); 728 dimensions = dim_vector (n);
728 729
729 if (n > 0) 730 if (n > 0)
730 { 731 {
731 int min_len = old_len < n ? old_len : n; 732 octave_idx_type min_len = old_len < n ? old_len : n;
732 733
733 if (old_data && old_len > 0) 734 if (old_data && old_len > 0)
734 { 735 {
735 for (int i = 0; i < min_len; i++) 736 for (octave_idx_type i = 0; i < min_len; i++)
736 xelem (i) = old_data[i]; 737 xelem (i) = old_data[i];
737 } 738 }
738 739
739 for (int i = old_len; i < n; i++) 740 for (octave_idx_type i = old_len; i < n; i++)
740 xelem (i) = val; 741 xelem (i) = val;
741 } 742 }
742 743
743 if (--old_rep->count <= 0) 744 if (--old_rep->count <= 0)
744 delete old_rep; 745 delete old_rep;
745 } 746 }
746 747
747 template <class T> 748 template <class T>
748 void 749 void
749 Array<T>::resize_and_fill (int r, int c, const T& val) 750 Array<T>::resize_and_fill (octave_idx_type r, octave_idx_type c, const T& val)
750 { 751 {
751 if (r < 0 || c < 0) 752 if (r < 0 || c < 0)
752 { 753 {
753 (*current_liboctave_error_handler) 754 (*current_liboctave_error_handler)
754 ("can't resize to negative dimension"); 755 ("can't resize to negative dimension");
764 return; 765 return;
765 766
766 typename Array<T>::ArrayRep *old_rep = Array<T>::rep; 767 typename Array<T>::ArrayRep *old_rep = Array<T>::rep;
767 const T *old_data = data (); 768 const T *old_data = data ();
768 769
769 int old_d1 = dim1 (); 770 octave_idx_type old_d1 = dim1 ();
770 int old_d2 = dim2 (); 771 octave_idx_type old_d2 = dim2 ();
771 int old_len = length (); 772 octave_idx_type old_len = length ();
772 773
773 int ts = get_size (r, c); 774 octave_idx_type ts = get_size (r, c);
774 775
775 rep = new typename Array<T>::ArrayRep (ts); 776 rep = new typename Array<T>::ArrayRep (ts);
776 777
777 dimensions = dim_vector (r, c); 778 dimensions = dim_vector (r, c);
778 779
779 if (ts > 0) 780 if (ts > 0)
780 { 781 {
781 int min_r = old_d1 < r ? old_d1 : r; 782 octave_idx_type min_r = old_d1 < r ? old_d1 : r;
782 int min_c = old_d2 < c ? old_d2 : c; 783 octave_idx_type min_c = old_d2 < c ? old_d2 : c;
783 784
784 if (old_data && old_len > 0) 785 if (old_data && old_len > 0)
785 { 786 {
786 for (int j = 0; j < min_c; j++) 787 for (octave_idx_type j = 0; j < min_c; j++)
787 for (int i = 0; i < min_r; i++) 788 for (octave_idx_type i = 0; i < min_r; i++)
788 xelem (i, j) = old_data[old_d1*j+i]; 789 xelem (i, j) = old_data[old_d1*j+i];
789 } 790 }
790 791
791 for (int j = 0; j < min_c; j++) 792 for (octave_idx_type j = 0; j < min_c; j++)
792 for (int i = min_r; i < r; i++) 793 for (octave_idx_type i = min_r; i < r; i++)
793 xelem (i, j) = val; 794 xelem (i, j) = val;
794 795
795 for (int j = min_c; j < c; j++) 796 for (octave_idx_type j = min_c; j < c; j++)
796 for (int i = 0; i < r; i++) 797 for (octave_idx_type i = 0; i < r; i++)
797 xelem (i, j) = val; 798 xelem (i, j) = val;
798 } 799 }
799 800
800 if (--old_rep->count <= 0) 801 if (--old_rep->count <= 0)
801 delete old_rep; 802 delete old_rep;
802 } 803 }
803 804
804 template <class T> 805 template <class T>
805 void 806 void
806 Array<T>::resize_and_fill (int r, int c, int p, const T& val) 807 Array<T>::resize_and_fill (octave_idx_type r, octave_idx_type c, octave_idx_type p, const T& val)
807 { 808 {
808 if (r < 0 || c < 0 || p < 0) 809 if (r < 0 || c < 0 || p < 0)
809 { 810 {
810 (*current_liboctave_error_handler) 811 (*current_liboctave_error_handler)
811 ("can't resize to negative dimension"); 812 ("can't resize to negative dimension");
821 return; 822 return;
822 823
823 typename Array<T>::ArrayRep *old_rep = rep; 824 typename Array<T>::ArrayRep *old_rep = rep;
824 const T *old_data = data (); 825 const T *old_data = data ();
825 826
826 int old_d1 = dim1 (); 827 octave_idx_type old_d1 = dim1 ();
827 int old_d2 = dim2 (); 828 octave_idx_type old_d2 = dim2 ();
828 int old_d3 = dim3 (); 829 octave_idx_type old_d3 = dim3 ();
829 830
830 int old_len = length (); 831 octave_idx_type old_len = length ();
831 832
832 int ts = get_size (get_size (r, c), p); 833 octave_idx_type ts = get_size (get_size (r, c), p);
833 834
834 rep = new typename Array<T>::ArrayRep (ts); 835 rep = new typename Array<T>::ArrayRep (ts);
835 836
836 dimensions = dim_vector (r, c, p); 837 dimensions = dim_vector (r, c, p);
837 838
838 if (ts > 0) 839 if (ts > 0)
839 { 840 {
840 int min_r = old_d1 < r ? old_d1 : r; 841 octave_idx_type min_r = old_d1 < r ? old_d1 : r;
841 int min_c = old_d2 < c ? old_d2 : c; 842 octave_idx_type min_c = old_d2 < c ? old_d2 : c;
842 int min_p = old_d3 < p ? old_d3 : p; 843 octave_idx_type min_p = old_d3 < p ? old_d3 : p;
843 844
844 if (old_data && old_len > 0) 845 if (old_data && old_len > 0)
845 for (int k = 0; k < min_p; k++) 846 for (octave_idx_type k = 0; k < min_p; k++)
846 for (int j = 0; j < min_c; j++) 847 for (octave_idx_type j = 0; j < min_c; j++)
847 for (int i = 0; i < min_r; i++) 848 for (octave_idx_type i = 0; i < min_r; i++)
848 xelem (i, j, k) = old_data[old_d1*(old_d2*k+j)+i]; 849 xelem (i, j, k) = old_data[old_d1*(old_d2*k+j)+i];
849 850
850 // XXX FIXME XXX -- if the copy constructor is expensive, this 851 // XXX FIXME XXX -- if the copy constructor is expensive, this
851 // may win. Otherwise, it may make more sense to just copy the 852 // may win. Otherwise, it may make more sense to just copy the
852 // value everywhere when making the new ArrayRep. 853 // value everywhere when making the new ArrayRep.
853 854
854 for (int k = 0; k < min_p; k++) 855 for (octave_idx_type k = 0; k < min_p; k++)
855 for (int j = min_c; j < c; j++) 856 for (octave_idx_type j = min_c; j < c; j++)
856 for (int i = 0; i < min_r; i++) 857 for (octave_idx_type i = 0; i < min_r; i++)
857 xelem (i, j, k) = val; 858 xelem (i, j, k) = val;
858 859
859 for (int k = 0; k < min_p; k++) 860 for (octave_idx_type k = 0; k < min_p; k++)
860 for (int j = 0; j < c; j++) 861 for (octave_idx_type j = 0; j < c; j++)
861 for (int i = min_r; i < r; i++) 862 for (octave_idx_type i = min_r; i < r; i++)
862 xelem (i, j, k) = val; 863 xelem (i, j, k) = val;
863 864
864 for (int k = min_p; k < p; k++) 865 for (octave_idx_type k = min_p; k < p; k++)
865 for (int j = 0; j < c; j++) 866 for (octave_idx_type j = 0; j < c; j++)
866 for (int i = 0; i < r; i++) 867 for (octave_idx_type i = 0; i < r; i++)
867 xelem (i, j, k) = val; 868 xelem (i, j, k) = val;
868 } 869 }
869 870
870 if (--old_rep->count <= 0) 871 if (--old_rep->count <= 0)
871 delete old_rep; 872 delete old_rep;
873 874
874 template <class T> 875 template <class T>
875 void 876 void
876 Array<T>::resize_and_fill (const dim_vector& dv, const T& val) 877 Array<T>::resize_and_fill (const dim_vector& dv, const T& val)
877 { 878 {
878 int n = dv.length (); 879 octave_idx_type n = dv.length ();
879 880
880 for (int i = 0; i < n; i++) 881 for (octave_idx_type i = 0; i < n; i++)
881 { 882 {
882 if (dv(i) < 0) 883 if (dv(i) < 0)
883 { 884 {
884 (*current_liboctave_error_handler) 885 (*current_liboctave_error_handler)
885 ("can't resize to negative dimension"); 886 ("can't resize to negative dimension");
893 { 894 {
894 same_size = false; 895 same_size = false;
895 } 896 }
896 else 897 else
897 { 898 {
898 for (int i = 0; i < n; i++) 899 for (octave_idx_type i = 0; i < n; i++)
899 { 900 {
900 if (dv(i) != dimensions(i)) 901 if (dv(i) != dimensions(i))
901 { 902 {
902 same_size = false; 903 same_size = false;
903 break; 904 break;
909 return; 910 return;
910 911
911 typename Array<T>::ArrayRep *old_rep = rep; 912 typename Array<T>::ArrayRep *old_rep = rep;
912 const T *old_data = data (); 913 const T *old_data = data ();
913 914
914 int len = get_size (dv); 915 octave_idx_type len = get_size (dv);
915 916
916 rep = new typename Array<T>::ArrayRep (len); 917 rep = new typename Array<T>::ArrayRep (len);
917 918
918 dim_vector dv_old = dimensions; 919 dim_vector dv_old = dimensions;
919 int dv_old_orig_len = dv_old.length (); 920 octave_idx_type dv_old_orig_len = dv_old.length ();
920 dimensions = dv; 921 dimensions = dv;
921 922
922 if (len > 0 && dv_old_orig_len > 0) 923 if (len > 0 && dv_old_orig_len > 0)
923 { 924 {
924 Array<int> ra_idx (dimensions.length (), 0); 925 Array<octave_idx_type> ra_idx (dimensions.length (), 0);
925 926
926 if (n > dv_old_orig_len) 927 if (n > dv_old_orig_len)
927 { 928 {
928 dv_old.resize (n); 929 dv_old.resize (n);
929 930
930 for (int i = dv_old_orig_len; i < n; i++) 931 for (octave_idx_type i = dv_old_orig_len; i < n; i++)
931 dv_old.elem (i) = 1; 932 dv_old.elem (i) = 1;
932 } 933 }
933 934
934 for (int i = 0; i < len; i++) 935 for (octave_idx_type i = 0; i < len; i++)
935 { 936 {
936 if (index_in_bounds (ra_idx, dv_old)) 937 if (index_in_bounds (ra_idx, dv_old))
937 rep->elem (i) = old_data[get_scalar_idx (ra_idx, dv_old)]; 938 rep->elem (i) = old_data[get_scalar_idx (ra_idx, dv_old)];
938 else 939 else
939 rep->elem (i) = val; 940 rep->elem (i) = val;
940 941
941 increment_index (ra_idx, dimensions); 942 increment_index (ra_idx, dimensions);
942 } 943 }
943 } 944 }
944 else 945 else
945 for (int i = 0; i < len; i++) 946 for (octave_idx_type i = 0; i < len; i++)
946 rep->elem (i) = val; 947 rep->elem (i) = val;
947 948
948 if (--old_rep->count <= 0) 949 if (--old_rep->count <= 0)
949 delete old_rep; 950 delete old_rep;
950 } 951 }
951 952
952 template <class T> 953 template <class T>
953 Array<T>& 954 Array<T>&
954 Array<T>::insert (const Array<T>& a, int r, int c) 955 Array<T>::insert (const Array<T>& a, octave_idx_type r, octave_idx_type c)
955 { 956 {
956 if (ndims () == 2 && a.ndims () == 2) 957 if (ndims () == 2 && a.ndims () == 2)
957 insert2 (a, r, c); 958 insert2 (a, r, c);
958 else 959 else
959 insertN (a, r, c); 960 insertN (a, r, c);
962 } 963 }
963 964
964 965
965 template <class T> 966 template <class T>
966 Array<T>& 967 Array<T>&
967 Array<T>::insert2 (const Array<T>& a, int r, int c) 968 Array<T>::insert2 (const Array<T>& a, octave_idx_type r, octave_idx_type c)
968 { 969 {
969 int a_rows = a.rows (); 970 octave_idx_type a_rows = a.rows ();
970 int a_cols = a.cols (); 971 octave_idx_type a_cols = a.cols ();
971 972
972 if (r < 0 || r + a_rows > rows () || c < 0 || c + a_cols > cols ()) 973 if (r < 0 || r + a_rows > rows () || c < 0 || c + a_cols > cols ())
973 { 974 {
974 (*current_liboctave_error_handler) ("range error for insert"); 975 (*current_liboctave_error_handler) ("range error for insert");
975 return *this; 976 return *this;
976 } 977 }
977 978
978 for (int j = 0; j < a_cols; j++) 979 for (octave_idx_type j = 0; j < a_cols; j++)
979 for (int i = 0; i < a_rows; i++) 980 for (octave_idx_type i = 0; i < a_rows; i++)
980 elem (r+i, c+j) = a.elem (i, j); 981 elem (r+i, c+j) = a.elem (i, j);
981 982
982 return *this; 983 return *this;
983 } 984 }
984 985
985 template <class T> 986 template <class T>
986 Array<T>& 987 Array<T>&
987 Array<T>::insertN (const Array<T>& a, int r, int c) 988 Array<T>::insertN (const Array<T>& a, octave_idx_type r, octave_idx_type c)
988 { 989 {
989 dim_vector dv = dims (); 990 dim_vector dv = dims ();
990 991
991 dim_vector a_dv = a.dims (); 992 dim_vector a_dv = a.dims ();
992 993
993 int n = a_dv.length (); 994 int n = a_dv.length ();
994 995
995 if (n == dimensions.length ()) 996 if (n == dimensions.length ())
996 { 997 {
997 Array<int> a_ra_idx (a_dv.length (), 0); 998 Array<octave_idx_type> a_ra_idx (a_dv.length (), 0);
998 999
999 a_ra_idx.elem (0) = r; 1000 a_ra_idx.elem (0) = r;
1000 a_ra_idx.elem (1) = c; 1001 a_ra_idx.elem (1) = c;
1001 1002
1002 for (int i = 0; i < n; i++) 1003 for (int i = 0; i < n; i++)
1007 ("Array<T>::insert: range error for insert"); 1008 ("Array<T>::insert: range error for insert");
1008 return *this; 1009 return *this;
1009 } 1010 }
1010 } 1011 }
1011 1012
1012 int n_elt = a.numel (); 1013 octave_idx_type n_elt = a.numel ();
1013 1014
1014 const T *a_data = a.data (); 1015 const T *a_data = a.data ();
1015 1016
1016 int iidx = 0; 1017 octave_idx_type iidx = 0;
1017 1018
1018 int a_rows = a_dv(0); 1019 octave_idx_type a_rows = a_dv(0);
1019 1020
1020 int this_rows = dv(0); 1021 octave_idx_type this_rows = dv(0);
1021 1022
1022 int numel_page = a_dv(0) * a_dv(1); 1023 octave_idx_type numel_page = a_dv(0) * a_dv(1);
1023 1024
1024 int count_pages = 0; 1025 octave_idx_type count_pages = 0;
1025 1026
1026 for (int i = 0; i < n_elt; i++) 1027 for (octave_idx_type i = 0; i < n_elt; i++)
1027 { 1028 {
1028 if (i != 0 && i % a_rows == 0) 1029 if (i != 0 && i % a_rows == 0)
1029 iidx += (this_rows - a_rows); 1030 iidx += (this_rows - a_rows);
1030 1031
1031 if (i % numel_page == 0) 1032 if (i % numel_page == 0)
1041 return *this; 1042 return *this;
1042 } 1043 }
1043 1044
1044 template <class T> 1045 template <class T>
1045 Array<T>& 1046 Array<T>&
1046 Array<T>::insert (const Array<T>& a, const Array<int>& ra_idx) 1047 Array<T>::insert (const Array<T>& a, const Array<octave_idx_type>& ra_idx)
1047 { 1048 {
1048 int n = ra_idx.length (); 1049 octave_idx_type n = ra_idx.length ();
1049 1050
1050 if (n == dimensions.length ()) 1051 if (n == dimensions.length ())
1051 { 1052 {
1052 dim_vector dva = a.dims (); 1053 dim_vector dva = a.dims ();
1053 dim_vector dv = dims (); 1054 dim_vector dv = dims ();
1054 int len_a = dva.length (); 1055 int len_a = dva.length ();
1055 int non_full_dim = 0; 1056 int non_full_dim = 0;
1056 1057
1057 for (int i = 0; i < n; i++) 1058 for (octave_idx_type i = 0; i < n; i++)
1058 { 1059 {
1059 if (ra_idx(i) < 0 || (ra_idx(i) + 1060 if (ra_idx(i) < 0 || (ra_idx(i) +
1060 (i < len_a ? dva(i) : 1)) > dimensions(i)) 1061 (i < len_a ? dva(i) : 1)) > dimensions(i))
1061 { 1062 {
1062 (*current_liboctave_error_handler) 1063 (*current_liboctave_error_handler)
1072 { 1073 {
1073 if (non_full_dim < 2) 1074 if (non_full_dim < 2)
1074 { 1075 {
1075 // Special case for fast concatenation 1076 // Special case for fast concatenation
1076 const T *a_data = a.data (); 1077 const T *a_data = a.data ();
1077 int numel_to_move = 1; 1078 octave_idx_type numel_to_move = 1;
1078 int skip = 0; 1079 octave_idx_type skip = 0;
1079 for (int i = 0; i < len_a; i++) 1080 for (int i = 0; i < len_a; i++)
1080 if (ra_idx(i) == 0 && dva(i) == dv(i)) 1081 if (ra_idx(i) == 0 && dva(i) == dv(i))
1081 numel_to_move *= dva(i); 1082 numel_to_move *= dva(i);
1082 else 1083 else
1083 { 1084 {
1084 skip = numel_to_move * (dv(i) - dva(i)); 1085 skip = numel_to_move * (dv(i) - dva(i));
1085 numel_to_move *= dva(i); 1086 numel_to_move *= dva(i);
1086 break; 1087 break;
1087 } 1088 }
1088 1089
1089 int jidx = ra_idx(n-1); 1090 octave_idx_type jidx = ra_idx(n-1);
1090 for (int i = n-2; i >= 0; i--) 1091 for (int i = n-2; i >= 0; i--)
1091 { 1092 {
1092 jidx *= dv(i); 1093 jidx *= dv(i);
1093 jidx += ra_idx(i); 1094 jidx += ra_idx(i);
1094 } 1095 }
1095 1096
1096 int iidx = 0; 1097 octave_idx_type iidx = 0;
1097 int moves = dva.numel () / numel_to_move; 1098 octave_idx_type moves = dva.numel () / numel_to_move;
1098 for (int i = 0; i < moves; i++) 1099 for (octave_idx_type i = 0; i < moves; i++)
1099 { 1100 {
1100 for (int j = 0; j < numel_to_move; j++) 1101 for (octave_idx_type j = 0; j < numel_to_move; j++)
1101 elem (jidx++) = a_data[iidx++]; 1102 elem (jidx++) = a_data[iidx++];
1102 jidx += skip; 1103 jidx += skip;
1103 } 1104 }
1104 } 1105 }
1105 else 1106 else
1106 { 1107 {
1107 // Generic code 1108 // Generic code
1108 const T *a_data = a.data (); 1109 const T *a_data = a.data ();
1109 int nel = a.numel (); 1110 int nel = a.numel ();
1110 Array<int> a_idx (n, 0); 1111 Array<octave_idx_type> a_idx (n, 0);
1111 1112
1112 for (int i = 0; i < nel; i++) 1113 for (int i = 0; i < nel; i++)
1113 { 1114 {
1114 int iidx = a_idx(n-1) + ra_idx(n-1); 1115 int iidx = a_idx(n-1) + ra_idx(n-1);
1115 for (int j = n-2; j >= 0; j--) 1116 for (int j = n-2; j >= 0; j--)
1136 Array<T> 1137 Array<T>
1137 Array<T>::transpose (void) const 1138 Array<T>::transpose (void) const
1138 { 1139 {
1139 assert (ndims () == 2); 1140 assert (ndims () == 2);
1140 1141
1141 int nr = dim1 (); 1142 octave_idx_type nr = dim1 ();
1142 int nc = dim2 (); 1143 octave_idx_type nc = dim2 ();
1143 1144
1144 if (nr > 1 && nc > 1) 1145 if (nr > 1 && nc > 1)
1145 { 1146 {
1146 Array<T> result (dim_vector (nc, nr)); 1147 Array<T> result (dim_vector (nc, nr));
1147 1148
1148 for (int j = 0; j < nc; j++) 1149 for (octave_idx_type j = 0; j < nc; j++)
1149 for (int i = 0; i < nr; i++) 1150 for (octave_idx_type i = 0; i < nr; i++)
1150 result.xelem (j, i) = xelem (i, j); 1151 result.xelem (j, i) = xelem (i, j);
1151 1152
1152 return result; 1153 return result;
1153 } 1154 }
1154 else 1155 else
1259 1260
1260 template <class T> 1261 template <class T>
1261 void 1262 void
1262 Array<T>::maybe_delete_elements_1 (idx_vector& idx_arg) 1263 Array<T>::maybe_delete_elements_1 (idx_vector& idx_arg)
1263 { 1264 {
1264 int len = length (); 1265 octave_idx_type len = length ();
1265 1266
1266 if (len == 0) 1267 if (len == 0)
1267 return; 1268 return;
1268 1269
1269 if (idx_arg.is_colon_equiv (len, 1)) 1270 if (idx_arg.is_colon_equiv (len, 1))
1272 { 1273 {
1273 int num_to_delete = idx_arg.length (len); 1274 int num_to_delete = idx_arg.length (len);
1274 1275
1275 if (num_to_delete != 0) 1276 if (num_to_delete != 0)
1276 { 1277 {
1277 int new_len = len; 1278 octave_idx_type new_len = len;
1278 1279
1279 int iidx = 0; 1280 octave_idx_type iidx = 0;
1280 1281
1281 for (int i = 0; i < len; i++) 1282 for (octave_idx_type i = 0; i < len; i++)
1282 if (i == idx_arg.elem (iidx)) 1283 if (i == idx_arg.elem (iidx))
1283 { 1284 {
1284 iidx++; 1285 iidx++;
1285 new_len--; 1286 new_len--;
1286 1287
1290 1291
1291 if (new_len > 0) 1292 if (new_len > 0)
1292 { 1293 {
1293 T *new_data = new T [new_len]; 1294 T *new_data = new T [new_len];
1294 1295
1295 int ii = 0; 1296 octave_idx_type ii = 0;
1296 iidx = 0; 1297 iidx = 0;
1297 for (int i = 0; i < len; i++) 1298 for (octave_idx_type i = 0; i < len; i++)
1298 { 1299 {
1299 if (iidx < num_to_delete && i == idx_arg.elem (iidx)) 1300 if (iidx < num_to_delete && i == idx_arg.elem (iidx))
1300 iidx++; 1301 iidx++;
1301 else 1302 else
1302 { 1303 {
1324 void 1325 void
1325 Array<T>::maybe_delete_elements_2 (idx_vector& idx_arg) 1326 Array<T>::maybe_delete_elements_2 (idx_vector& idx_arg)
1326 { 1327 {
1327 assert (ndims () == 2); 1328 assert (ndims () == 2);
1328 1329
1329 int nr = dim1 (); 1330 octave_idx_type nr = dim1 ();
1330 int nc = dim2 (); 1331 octave_idx_type nc = dim2 ();
1331 1332
1332 if (nr == 0 && nc == 0) 1333 if (nr == 0 && nc == 0)
1333 return; 1334 return;
1334 1335
1335 int n; 1336 octave_idx_type n;
1336 if (nr == 1) 1337 if (nr == 1)
1337 n = nc; 1338 n = nc;
1338 else if (nc == 1) 1339 else if (nc == 1)
1339 n = nr; 1340 n = nr;
1340 else 1341 else
1357 return; 1358 return;
1358 } 1359 }
1359 1360
1360 idx_arg.sort (true); 1361 idx_arg.sort (true);
1361 1362
1362 int num_to_delete = idx_arg.length (n); 1363 octave_idx_type num_to_delete = idx_arg.length (n);
1363 1364
1364 if (num_to_delete != 0) 1365 if (num_to_delete != 0)
1365 { 1366 {
1366 int new_n = n; 1367 octave_idx_type new_n = n;
1367 1368
1368 int iidx = 0; 1369 octave_idx_type iidx = 0;
1369 1370
1370 for (int i = 0; i < n; i++) 1371 for (octave_idx_type i = 0; i < n; i++)
1371 if (i == idx_arg.elem (iidx)) 1372 if (i == idx_arg.elem (iidx))
1372 { 1373 {
1373 iidx++; 1374 iidx++;
1374 new_n--; 1375 new_n--;
1375 1376
1379 1380
1380 if (new_n > 0) 1381 if (new_n > 0)
1381 { 1382 {
1382 T *new_data = new T [new_n]; 1383 T *new_data = new T [new_n];
1383 1384
1384 int ii = 0; 1385 octave_idx_type ii = 0;
1385 iidx = 0; 1386 iidx = 0;
1386 for (int i = 0; i < n; i++) 1387 for (octave_idx_type i = 0; i < n; i++)
1387 { 1388 {
1388 if (iidx < num_to_delete && i == idx_arg.elem (iidx)) 1389 if (iidx < num_to_delete && i == idx_arg.elem (iidx))
1389 iidx++; 1390 iidx++;
1390 else 1391 else
1391 { 1392 {
1423 void 1424 void
1424 Array<T>::maybe_delete_elements (idx_vector& idx_i, idx_vector& idx_j) 1425 Array<T>::maybe_delete_elements (idx_vector& idx_i, idx_vector& idx_j)
1425 { 1426 {
1426 assert (ndims () == 2); 1427 assert (ndims () == 2);
1427 1428
1428 int nr = dim1 (); 1429 octave_idx_type nr = dim1 ();
1429 int nc = dim2 (); 1430 octave_idx_type nc = dim2 ();
1430 1431
1431 if (nr == 0 && nc == 0) 1432 if (nr == 0 && nc == 0)
1432 return; 1433 return;
1433 1434
1434 if (idx_i.is_colon ()) 1435 if (idx_i.is_colon ())
1469 resize_no_fill (0, 0); 1470 resize_no_fill (0, 0);
1470 else 1471 else
1471 { 1472 {
1472 idx_j.sort (true); 1473 idx_j.sort (true);
1473 1474
1474 int num_to_delete = idx_j.length (nc); 1475 octave_idx_type num_to_delete = idx_j.length (nc);
1475 1476
1476 if (num_to_delete != 0) 1477 if (num_to_delete != 0)
1477 { 1478 {
1478 if (nr == 1 && num_to_delete == nc) 1479 if (nr == 1 && num_to_delete == nc)
1479 resize_no_fill (0, 0); 1480 resize_no_fill (0, 0);
1480 else 1481 else
1481 { 1482 {
1482 int new_nc = nc; 1483 octave_idx_type new_nc = nc;
1483 1484
1484 int iidx = 0; 1485 octave_idx_type iidx = 0;
1485 1486
1486 for (int j = 0; j < nc; j++) 1487 for (octave_idx_type j = 0; j < nc; j++)
1487 if (j == idx_j.elem (iidx)) 1488 if (j == idx_j.elem (iidx))
1488 { 1489 {
1489 iidx++; 1490 iidx++;
1490 new_nc--; 1491 new_nc--;
1491 1492
1495 1496
1496 if (new_nc > 0) 1497 if (new_nc > 0)
1497 { 1498 {
1498 T *new_data = new T [nr * new_nc]; 1499 T *new_data = new T [nr * new_nc];
1499 1500
1500 int jj = 0; 1501 octave_idx_type jj = 0;
1501 iidx = 0; 1502 iidx = 0;
1502 for (int j = 0; j < nc; j++) 1503 for (octave_idx_type j = 0; j < nc; j++)
1503 { 1504 {
1504 if (iidx < num_to_delete && j == idx_j.elem (iidx)) 1505 if (iidx < num_to_delete && j == idx_j.elem (iidx))
1505 iidx++; 1506 iidx++;
1506 else 1507 else
1507 { 1508 {
1508 for (int i = 0; i < nr; i++) 1509 for (octave_idx_type i = 0; i < nr; i++)
1509 new_data[nr*jj+i] = elem (i, j); 1510 new_data[nr*jj+i] = elem (i, j);
1510 jj++; 1511 jj++;
1511 } 1512 }
1512 } 1513 }
1513 1514
1532 resize_no_fill (0, 0); 1533 resize_no_fill (0, 0);
1533 else 1534 else
1534 { 1535 {
1535 idx_i.sort (true); 1536 idx_i.sort (true);
1536 1537
1537 int num_to_delete = idx_i.length (nr); 1538 octave_idx_type num_to_delete = idx_i.length (nr);
1538 1539
1539 if (num_to_delete != 0) 1540 if (num_to_delete != 0)
1540 { 1541 {
1541 if (nc == 1 && num_to_delete == nr) 1542 if (nc == 1 && num_to_delete == nr)
1542 resize_no_fill (0, 0); 1543 resize_no_fill (0, 0);
1543 else 1544 else
1544 { 1545 {
1545 int new_nr = nr; 1546 octave_idx_type new_nr = nr;
1546 1547
1547 int iidx = 0; 1548 octave_idx_type iidx = 0;
1548 1549
1549 for (int i = 0; i < nr; i++) 1550 for (octave_idx_type i = 0; i < nr; i++)
1550 if (i == idx_i.elem (iidx)) 1551 if (i == idx_i.elem (iidx))
1551 { 1552 {
1552 iidx++; 1553 iidx++;
1553 new_nr--; 1554 new_nr--;
1554 1555
1558 1559
1559 if (new_nr > 0) 1560 if (new_nr > 0)
1560 { 1561 {
1561 T *new_data = new T [new_nr * nc]; 1562 T *new_data = new T [new_nr * nc];
1562 1563
1563 int ii = 0; 1564 octave_idx_type ii = 0;
1564 iidx = 0; 1565 iidx = 0;
1565 for (int i = 0; i < nr; i++) 1566 for (octave_idx_type i = 0; i < nr; i++)
1566 { 1567 {
1567 if (iidx < num_to_delete && i == idx_i.elem (iidx)) 1568 if (iidx < num_to_delete && i == idx_i.elem (iidx))
1568 iidx++; 1569 iidx++;
1569 else 1570 else
1570 { 1571 {
1571 for (int j = 0; j < nc; j++) 1572 for (octave_idx_type j = 0; j < nc; j++)
1572 new_data[new_nr*j+ii] = elem (i, j); 1573 new_data[new_nr*j+ii] = elem (i, j);
1573 ii++; 1574 ii++;
1574 } 1575 }
1575 } 1576 }
1576 1577
1600 1601
1601 template <class T> 1602 template <class T>
1602 void 1603 void
1603 Array<T>::maybe_delete_elements (Array<idx_vector>& ra_idx, const T& rfv) 1604 Array<T>::maybe_delete_elements (Array<idx_vector>& ra_idx, const T& rfv)
1604 { 1605 {
1605 int n_idx = ra_idx.length (); 1606 octave_idx_type n_idx = ra_idx.length ();
1606 1607
1607 dim_vector lhs_dims = dims (); 1608 dim_vector lhs_dims = dims ();
1608 1609
1609 if (lhs_dims.all_zero ()) 1610 if (lhs_dims.all_zero ())
1610 return; 1611 return;
1615 1616
1616 Array<int> idx_is_colon_equiv (n_idx, 0); 1617 Array<int> idx_is_colon_equiv (n_idx, 0);
1617 1618
1618 // Initialization of colon arrays. 1619 // Initialization of colon arrays.
1619 1620
1620 for (int i = 0; i < n_idx; i++) 1621 for (octave_idx_type i = 0; i < n_idx; i++)
1621 { 1622 {
1622 idx_is_colon_equiv(i) = ra_idx(i).is_colon_equiv (lhs_dims(i), 1); 1623 idx_is_colon_equiv(i) = ra_idx(i).is_colon_equiv (lhs_dims(i), 1);
1623 1624
1624 idx_is_colon(i) = ra_idx(i).is_colon (); 1625 idx_is_colon(i) = ra_idx(i).is_colon ();
1625 } 1626 }
1626 1627
1627 bool idx_ok = true; 1628 bool idx_ok = true;
1628 1629
1629 // Check for index out of bounds. 1630 // Check for index out of bounds.
1630 1631
1631 for (int i = 0 ; i < n_idx - 1; i++) 1632 for (octave_idx_type i = 0 ; i < n_idx - 1; i++)
1632 { 1633 {
1633 if (! (idx_is_colon(i) || idx_is_colon_equiv(i))) 1634 if (! (idx_is_colon(i) || idx_is_colon_equiv(i)))
1634 { 1635 {
1635 ra_idx(i).sort (true); 1636 ra_idx(i).sort (true);
1636 1637
1653 } 1654 }
1654 } 1655 }
1655 1656
1656 if (n_idx <= n_lhs_dims) 1657 if (n_idx <= n_lhs_dims)
1657 { 1658 {
1658 int last_idx = ra_idx(n_idx-1).max (); 1659 octave_idx_type last_idx = ra_idx(n_idx-1).max ();
1659 1660
1660 int sum_el = lhs_dims(n_idx-1); 1661 octave_idx_type sum_el = lhs_dims(n_idx-1);
1661 1662
1662 for (int i = n_idx; i < n_lhs_dims; i++) 1663 for (octave_idx_type i = n_idx; i < n_lhs_dims; i++)
1663 sum_el *= lhs_dims(i); 1664 sum_el *= lhs_dims(i);
1664 1665
1665 if (last_idx > sum_el - 1) 1666 if (last_idx > sum_el - 1)
1666 { 1667 {
1667 (*current_liboctave_error_handler) 1668 (*current_liboctave_error_handler)
1700 // in the other dimensions that we started with. 1701 // in the other dimensions that we started with.
1701 1702
1702 dim_vector temp_dims; 1703 dim_vector temp_dims;
1703 temp_dims.resize (n_idx); 1704 temp_dims.resize (n_idx);
1704 1705
1705 for (int i = 0; i < n_idx; i++) 1706 for (octave_idx_type i = 0; i < n_idx; i++)
1706 { 1707 {
1707 if (idx_is_colon (i)) 1708 if (idx_is_colon (i))
1708 temp_dims(i) = lhs_dims(i); 1709 temp_dims(i) = lhs_dims(i);
1709 else 1710 else
1710 temp_dims(i) = 0; 1711 temp_dims(i) = 0;
1723 1724
1724 if (liboctave_wfi_flag && ! (ra_idx(n_idx-1).is_colon ())) 1725 if (liboctave_wfi_flag && ! (ra_idx(n_idx-1).is_colon ()))
1725 (*current_liboctave_warning_handler) 1726 (*current_liboctave_warning_handler)
1726 ("fewer indices than dimensions for N-d array"); 1727 ("fewer indices than dimensions for N-d array");
1727 1728
1728 for (int i = n_idx; i < n_lhs_dims; i++) 1729 for (octave_idx_type i = n_idx; i < n_lhs_dims; i++)
1729 lhs_dims(n_idx-1) *= lhs_dims(i); 1730 lhs_dims(n_idx-1) *= lhs_dims(i);
1730 1731
1731 lhs_dims.resize (n_idx); 1732 lhs_dims.resize (n_idx);
1732 1733
1733 // Reshape *this. 1734 // Reshape *this.
1736 1737
1737 int non_col = 0; 1738 int non_col = 0;
1738 1739
1739 // Find the non-colon column. 1740 // Find the non-colon column.
1740 1741
1741 for (int i = 0; i < n_idx; i++) 1742 for (octave_idx_type i = 0; i < n_idx; i++)
1742 { 1743 {
1743 if (! idx_is_colon(i)) 1744 if (! idx_is_colon(i))
1744 non_col = i; 1745 non_col = i;
1745 } 1746 }
1746 1747
1747 // The length of the non-colon dimension. 1748 // The length of the non-colon dimension.
1748 1749
1749 int non_col_dim = lhs_dims (non_col); 1750 octave_idx_type non_col_dim = lhs_dims (non_col);
1750 1751
1751 int num_to_delete = ra_idx(non_col).length (lhs_dims (non_col)); 1752 octave_idx_type num_to_delete = ra_idx(non_col).length (lhs_dims (non_col));
1752 1753
1753 if (num_to_delete > 0) 1754 if (num_to_delete > 0)
1754 { 1755 {
1755 int temp = lhs_dims.num_ones (); 1756 int temp = lhs_dims.num_ones ();
1756 1757
1769 else 1770 else
1770 { 1771 {
1771 // New length of non-colon dimension 1772 // New length of non-colon dimension
1772 // (calculated in the next for loop) 1773 // (calculated in the next for loop)
1773 1774
1774 int new_dim = non_col_dim; 1775 octave_idx_type new_dim = non_col_dim;
1775 1776
1776 int iidx = 0; 1777 octave_idx_type iidx = 0;
1777 1778
1778 for (int j = 0; j < non_col_dim; j++) 1779 for (octave_idx_type j = 0; j < non_col_dim; j++)
1779 if (j == ra_idx(non_col).elem (iidx)) 1780 if (j == ra_idx(non_col).elem (iidx))
1780 { 1781 {
1781 iidx++; 1782 iidx++;
1782 1783
1783 new_dim--; 1784 new_dim--;
1790 1791
1791 if (new_dim > 0) 1792 if (new_dim > 0)
1792 { 1793 {
1793 // Calculate number of elements in new array. 1794 // Calculate number of elements in new array.
1794 1795
1795 int num_new_elem=1; 1796 octave_idx_type num_new_elem=1;
1796 1797
1797 for (int i = 0; i < n_idx; i++) 1798 for (int i = 0; i < n_idx; i++)
1798 { 1799 {
1799 if (i == non_col) 1800 if (i == non_col)
1800 num_new_elem *= new_dim; 1801 num_new_elem *= new_dim;
1803 num_new_elem *= lhs_dims(i); 1804 num_new_elem *= lhs_dims(i);
1804 } 1805 }
1805 1806
1806 T *new_data = new T [num_new_elem]; 1807 T *new_data = new T [num_new_elem];
1807 1808
1808 Array<int> result_idx (n_lhs_dims, 0); 1809 Array<octave_idx_type> result_idx (n_lhs_dims, 0);
1809 1810
1810 dim_vector new_lhs_dim = lhs_dims; 1811 dim_vector new_lhs_dim = lhs_dims;
1811 1812
1812 new_lhs_dim(non_col) = new_dim; 1813 new_lhs_dim(non_col) = new_dim;
1813 1814
1814 int num_elem = 1; 1815 octave_idx_type num_elem = 1;
1815 1816
1816 int numidx = 0; 1817 octave_idx_type numidx = 0;
1817 1818
1818 int n = length (); 1819 octave_idx_type n = length ();
1819 1820
1820 for (int i = 0; i < n_lhs_dims; i++) 1821 for (int i = 0; i < n_lhs_dims; i++)
1821 if (i != non_col) 1822 if (i != non_col)
1822 num_elem *= lhs_dims(i); 1823 num_elem *= lhs_dims(i);
1823 1824
1824 num_elem *= ra_idx(non_col).capacity (); 1825 num_elem *= ra_idx(non_col).capacity ();
1825 1826
1826 for (int i = 0; i < n; i++) 1827 for (octave_idx_type i = 0; i < n; i++)
1827 { 1828 {
1828 if (numidx < num_elem 1829 if (numidx < num_elem
1829 && is_in (result_idx(non_col), ra_idx(non_col))) 1830 && is_in (result_idx(non_col), ra_idx(non_col)))
1830 numidx++; 1831 numidx++;
1831 1832
1832 else 1833 else
1833 { 1834 {
1834 Array<int> temp_result_idx = result_idx; 1835 Array<octave_idx_type> temp_result_idx = result_idx;
1835 1836
1836 int num_lgt = how_many_lgt (result_idx(non_col), 1837 octave_idx_type num_lgt = how_many_lgt (result_idx(non_col),
1837 ra_idx(non_col)); 1838 ra_idx(non_col));
1838 1839
1839 temp_result_idx(non_col) -= num_lgt; 1840 temp_result_idx(non_col) -= num_lgt;
1840 1841
1841 int kidx 1842 octave_idx_type kidx
1842 = ::compute_index (temp_result_idx, new_lhs_dim); 1843 = ::compute_index (temp_result_idx, new_lhs_dim);
1843 1844
1844 new_data[kidx] = elem (result_idx); 1845 new_data[kidx] = elem (result_idx);
1845 } 1846 }
1846 1847
1868 // column by column. 1869 // column by column.
1869 // 1870 //
1870 // A(3,3,3)=2; 1871 // A(3,3,3)=2;
1871 // A(3:5) = []; A(6)=[] 1872 // A(3:5) = []; A(6)=[]
1872 1873
1873 int lhs_numel = numel (); 1874 octave_idx_type lhs_numel = numel ();
1874 1875
1875 idx_vector idx_vec = ra_idx(0); 1876 idx_vector idx_vec = ra_idx(0);
1876 1877
1877 idx_vec.freeze (lhs_numel, 0, true, liboctave_wrore_flag); 1878 idx_vec.freeze (lhs_numel, 0, true, liboctave_wrore_flag);
1878 1879
1879 idx_vec.sort (true); 1880 idx_vec.sort (true);
1880 1881
1881 int num_to_delete = idx_vec.length (lhs_numel); 1882 octave_idx_type num_to_delete = idx_vec.length (lhs_numel);
1882 1883
1883 if (num_to_delete > 0) 1884 if (num_to_delete > 0)
1884 { 1885 {
1885 int new_numel = lhs_numel - num_to_delete; 1886 octave_idx_type new_numel = lhs_numel - num_to_delete;
1886 1887
1887 T *new_data = new T[new_numel]; 1888 T *new_data = new T[new_numel];
1888 1889
1889 Array<int> lhs_ra_idx (ndims (), 0); 1890 Array<octave_idx_type> lhs_ra_idx (ndims (), 0);
1890 1891
1891 int ii = 0; 1892 octave_idx_type ii = 0;
1892 int iidx = 0; 1893 octave_idx_type iidx = 0;
1893 1894
1894 for (int i = 0; i < lhs_numel; i++) 1895 for (octave_idx_type i = 0; i < lhs_numel; i++)
1895 { 1896 {
1896 if (iidx < num_to_delete && i == idx_vec.elem (iidx)) 1897 if (iidx < num_to_delete && i == idx_vec.elem (iidx))
1897 { 1898 {
1898 iidx++; 1899 iidx++;
1899 } 1900 }
1998 Array<T> 1999 Array<T>
1999 Array<T>::index1 (idx_vector& idx_arg, int resize_ok, const T& rfv) const 2000 Array<T>::index1 (idx_vector& idx_arg, int resize_ok, const T& rfv) const
2000 { 2001 {
2001 Array<T> retval; 2002 Array<T> retval;
2002 2003
2003 int len = length (); 2004 octave_idx_type len = length ();
2004 2005
2005 int n = idx_arg.freeze (len, "vector", resize_ok); 2006 octave_idx_type n = idx_arg.freeze (len, "vector", resize_ok);
2006 2007
2007 if (idx_arg) 2008 if (idx_arg)
2008 { 2009 {
2009 if (idx_arg.is_colon_equiv (len)) 2010 if (idx_arg.is_colon_equiv (len))
2010 { 2011 {
2022 } 2023 }
2023 else 2024 else
2024 { 2025 {
2025 retval.resize_no_fill (n); 2026 retval.resize_no_fill (n);
2026 2027
2027 for (int i = 0; i < n; i++) 2028 for (octave_idx_type i = 0; i < n; i++)
2028 { 2029 {
2029 int ii = idx_arg.elem (i); 2030 octave_idx_type ii = idx_arg.elem (i);
2030 if (ii >= len) 2031 if (ii >= len)
2031 retval.elem (i) = rfv; 2032 retval.elem (i) = rfv;
2032 else 2033 else
2033 retval.elem (i) = elem (ii); 2034 retval.elem (i) = elem (ii);
2034 } 2035 }
2046 { 2047 {
2047 Array<T> retval; 2048 Array<T> retval;
2048 2049
2049 assert (ndims () == 2); 2050 assert (ndims () == 2);
2050 2051
2051 int nr = dim1 (); 2052 octave_idx_type nr = dim1 ();
2052 int nc = dim2 (); 2053 octave_idx_type nc = dim2 ();
2053 2054
2054 int orig_len = nr * nc; 2055 octave_idx_type orig_len = nr * nc;
2055 2056
2056 dim_vector idx_orig_dims = idx_arg.orig_dimensions (); 2057 dim_vector idx_orig_dims = idx_arg.orig_dimensions ();
2057 2058
2058 int idx_orig_rows = idx_arg.orig_rows (); 2059 octave_idx_type idx_orig_rows = idx_arg.orig_rows ();
2059 int idx_orig_columns = idx_arg.orig_columns (); 2060 octave_idx_type idx_orig_columns = idx_arg.orig_columns ();
2060 2061
2061 if (idx_arg.is_colon ()) 2062 if (idx_arg.is_colon ())
2062 { 2063 {
2063 // Fast magic colon processing. 2064 // Fast magic colon processing.
2064 2065
2065 int result_nr = nr * nc; 2066 octave_idx_type result_nr = nr * nc;
2066 int result_nc = 1; 2067 octave_idx_type result_nc = 1;
2067 2068
2068 retval = Array<T> (*this, dim_vector (result_nr, result_nc)); 2069 retval = Array<T> (*this, dim_vector (result_nr, result_nc));
2069 } 2070 }
2070 else if (nr == 1 && nc == 1) 2071 else if (nr == 1 && nc == 1)
2071 { 2072 {
2072 Array<T> tmp = Array<T>::index1 (idx_arg, resize_ok); 2073 Array<T> tmp = Array<T>::index1 (idx_arg, resize_ok);
2073 2074
2074 int len = tmp.length (); 2075 octave_idx_type len = tmp.length ();
2075 2076
2076 if (len == 0 && idx_arg.one_zero_only ()) 2077 if (len == 0 && idx_arg.one_zero_only ())
2077 retval = Array<T> (tmp, dim_vector (0, 0)); 2078 retval = Array<T> (tmp, dim_vector (0, 0));
2078 else if (len >= idx_orig_dims.numel ()) 2079 else if (len >= idx_orig_dims.numel ())
2079 retval = Array<T> (tmp, idx_orig_dims); 2080 retval = Array<T> (tmp, idx_orig_dims);
2084 // shape as the index. Otherwise, it has same orientation as 2085 // shape as the index. Otherwise, it has same orientation as
2085 // indexed object. 2086 // indexed object.
2086 2087
2087 Array<T> tmp = Array<T>::index1 (idx_arg, resize_ok); 2088 Array<T> tmp = Array<T>::index1 (idx_arg, resize_ok);
2088 2089
2089 int len = tmp.length (); 2090 octave_idx_type len = tmp.length ();
2090 2091
2091 if ((len != 0 && idx_arg.one_zero_only ()) 2092 if ((len != 0 && idx_arg.one_zero_only ())
2092 || idx_orig_rows == 1 || idx_orig_columns == 1) 2093 || idx_orig_rows == 1 || idx_orig_columns == 1)
2093 { 2094 {
2094 if (nr == 1) 2095 if (nr == 1)
2112 2113
2113 idx_arg.freeze (nr * nc, "matrix", resize_ok); 2114 idx_arg.freeze (nr * nc, "matrix", resize_ok);
2114 2115
2115 if (idx_arg) 2116 if (idx_arg)
2116 { 2117 {
2117 int result_nr = idx_orig_rows; 2118 octave_idx_type result_nr = idx_orig_rows;
2118 int result_nc = idx_orig_columns; 2119 octave_idx_type result_nc = idx_orig_columns;
2119 2120
2120 if (idx_arg.one_zero_only ()) 2121 if (idx_arg.one_zero_only ())
2121 { 2122 {
2122 result_nr = idx_arg.ones_count (); 2123 result_nr = idx_arg.ones_count ();
2123 result_nc = (result_nr > 0 ? 1 : 0); 2124 result_nc = (result_nr > 0 ? 1 : 0);
2124 } 2125 }
2125 2126
2126 retval.resize_no_fill (result_nr, result_nc); 2127 retval.resize_no_fill (result_nr, result_nc);
2127 2128
2128 int k = 0; 2129 octave_idx_type k = 0;
2129 for (int j = 0; j < result_nc; j++) 2130 for (octave_idx_type j = 0; j < result_nc; j++)
2130 { 2131 {
2131 for (int i = 0; i < result_nr; i++) 2132 for (octave_idx_type i = 0; i < result_nr; i++)
2132 { 2133 {
2133 int ii = idx_arg.elem (k++); 2134 octave_idx_type ii = idx_arg.elem (k++);
2134 if (ii >= orig_len) 2135 if (ii >= orig_len)
2135 retval.elem (i, j) = rfv; 2136 retval.elem (i, j) = rfv;
2136 else 2137 else
2137 { 2138 {
2138 int fr = ii % nr; 2139 octave_idx_type fr = ii % nr;
2139 int fc = (ii - fr) / nr; 2140 octave_idx_type fc = (ii - fr) / nr;
2140 retval.elem (i, j) = elem (fr, fc); 2141 retval.elem (i, j) = elem (fr, fc);
2141 } 2142 }
2142 } 2143 }
2143 } 2144 }
2144 } 2145 }
2154 { 2155 {
2155 Array<T> retval; 2156 Array<T> retval;
2156 2157
2157 int n_dims = dims().length (); 2158 int n_dims = dims().length ();
2158 2159
2159 int orig_len = dims().numel (); 2160 octave_idx_type orig_len = dims().numel ();
2160 2161
2161 dim_vector idx_orig_dims = ra_idx.orig_dimensions (); 2162 dim_vector idx_orig_dims = ra_idx.orig_dimensions ();
2162 2163
2163 if (ra_idx.is_colon ()) 2164 if (ra_idx.is_colon ())
2164 { 2165 {
2170 { 2171 {
2171 // Only one element in array. 2172 // Only one element in array.
2172 2173
2173 Array<T> tmp = Array<T>::index (ra_idx, resize_ok); 2174 Array<T> tmp = Array<T>::index (ra_idx, resize_ok);
2174 2175
2175 int len = tmp.length (); 2176 octave_idx_type len = tmp.length ();
2176 2177
2177 if (len != 0) 2178 if (len != 0)
2178 { 2179 {
2179 if (len >= idx_orig_dims.numel ()) 2180 if (len >= idx_orig_dims.numel ())
2180 retval = Array<T> (tmp, idx_orig_dims); 2181 retval = Array<T> (tmp, idx_orig_dims);
2186 { 2187 {
2187 // We're getting elements from a vector equivalent i.e. (1x4x1). 2188 // We're getting elements from a vector equivalent i.e. (1x4x1).
2188 2189
2189 Array<T> tmp = Array<T>::index (ra_idx, resize_ok); 2190 Array<T> tmp = Array<T>::index (ra_idx, resize_ok);
2190 2191
2191 int len = tmp.length (); 2192 octave_idx_type len = tmp.length ();
2192 2193
2193 if (len == 0) 2194 if (len == 0)
2194 { 2195 {
2195 if (idx_orig_dims.any_zero ()) 2196 if (idx_orig_dims.any_zero ())
2196 retval = Array<T> (idx_orig_dims); 2197 retval = Array<T> (idx_orig_dims);
2252 dim_vector result_dims (idx_orig_dims); 2253 dim_vector result_dims (idx_orig_dims);
2253 2254
2254 if (ra_idx.one_zero_only ()) 2255 if (ra_idx.one_zero_only ())
2255 { 2256 {
2256 result_dims.resize (2); 2257 result_dims.resize (2);
2257 int ntot = ra_idx.ones_count (); 2258 octave_idx_type ntot = ra_idx.ones_count ();
2258 result_dims(0) = ntot; 2259 result_dims(0) = ntot;
2259 result_dims(1) = (ntot > 0 ? 1 : 0); 2260 result_dims(1) = (ntot > 0 ? 1 : 0);
2260 } 2261 }
2261 2262
2262 result_dims.chop_trailing_singletons (); 2263 result_dims.chop_trailing_singletons ();
2263 2264
2264 retval.resize (result_dims); 2265 retval.resize (result_dims);
2265 2266
2266 int n = result_dims.numel (); 2267 octave_idx_type n = result_dims.numel ();
2267 2268
2268 int r_dims = result_dims.length (); 2269 int r_dims = result_dims.length ();
2269 2270
2270 Array<int> iidx (r_dims, 0); 2271 Array<octave_idx_type> iidx (r_dims, 0);
2271 2272
2272 int k = 0; 2273 octave_idx_type k = 0;
2273 2274
2274 for (int i = 0; i < n; i++) 2275 for (octave_idx_type i = 0; i < n; i++)
2275 { 2276 {
2276 int ii = ra_idx.elem (k++); 2277 octave_idx_type ii = ra_idx.elem (k++);
2277 2278
2278 if (ii >= orig_len) 2279 if (ii >= orig_len)
2279 retval.elem (iidx) = rfv; 2280 retval.elem (iidx) = rfv;
2280 else 2281 else
2281 { 2282 {
2299 { 2300 {
2300 Array<T> retval; 2301 Array<T> retval;
2301 2302
2302 assert (ndims () == 2); 2303 assert (ndims () == 2);
2303 2304
2304 int nr = dim1 (); 2305 octave_idx_type nr = dim1 ();
2305 int nc = dim2 (); 2306 octave_idx_type nc = dim2 ();
2306 2307
2307 int n = idx_i.freeze (nr, "row", resize_ok); 2308 octave_idx_type n = idx_i.freeze (nr, "row", resize_ok);
2308 int m = idx_j.freeze (nc, "column", resize_ok); 2309 octave_idx_type m = idx_j.freeze (nc, "column", resize_ok);
2309 2310
2310 if (idx_i && idx_j) 2311 if (idx_i && idx_j)
2311 { 2312 {
2312 if (idx_i.orig_empty () || idx_j.orig_empty () || n == 0 || m == 0) 2313 if (idx_i.orig_empty () || idx_j.orig_empty () || n == 0 || m == 0)
2313 { 2314 {
2319 } 2320 }
2320 else 2321 else
2321 { 2322 {
2322 retval.resize_no_fill (n, m); 2323 retval.resize_no_fill (n, m);
2323 2324
2324 for (int j = 0; j < m; j++) 2325 for (octave_idx_type j = 0; j < m; j++)
2325 { 2326 {
2326 int jj = idx_j.elem (j); 2327 octave_idx_type jj = idx_j.elem (j);
2327 for (int i = 0; i < n; i++) 2328 for (octave_idx_type i = 0; i < n; i++)
2328 { 2329 {
2329 int ii = idx_i.elem (i); 2330 octave_idx_type ii = idx_i.elem (i);
2330 if (ii >= nr || jj >= nc) 2331 if (ii >= nr || jj >= nc)
2331 retval.elem (i, j) = rfv; 2332 retval.elem (i, j) = rfv;
2332 else 2333 else
2333 retval.elem (i, j) = elem (ii, jj); 2334 retval.elem (i, j) = elem (ii, jj);
2334 } 2335 }
2353 int n_dims = dimensions.length (); 2354 int n_dims = dimensions.length ();
2354 2355
2355 // Remove trailing singletons in ra_idx, but leave at least ndims 2356 // Remove trailing singletons in ra_idx, but leave at least ndims
2356 // elements. 2357 // elements.
2357 2358
2358 int ra_idx_len = ra_idx.length (); 2359 octave_idx_type ra_idx_len = ra_idx.length ();
2359 2360
2360 bool trim_trailing_singletons = true; 2361 bool trim_trailing_singletons = true;
2361 for (int j = ra_idx_len; j > n_dims; j--) 2362 for (octave_idx_type j = ra_idx_len; j > n_dims; j--)
2362 { 2363 {
2363 idx_vector iidx = ra_idx (ra_idx_len-1); 2364 idx_vector iidx = ra_idx (ra_idx_len-1);
2364 if (iidx.capacity () == 1 && trim_trailing_singletons) 2365 if (iidx.capacity () == 1 && trim_trailing_singletons)
2365 ra_idx_len--; 2366 ra_idx_len--;
2366 else 2367 else
2367 trim_trailing_singletons = false; 2368 trim_trailing_singletons = false;
2368 2369
2369 for (int i = 0; i < iidx.capacity (); i++) 2370 for (octave_idx_type i = 0; i < iidx.capacity (); i++)
2370 if (iidx (i) != 0) 2371 if (iidx (i) != 0)
2371 { 2372 {
2372 (*current_liboctave_error_handler) 2373 (*current_liboctave_error_handler)
2373 ("index exceeds N-d array dimensions"); 2374 ("index exceeds N-d array dimensions");
2374 2375
2408 2409
2409 frozen_lengths_for_resize.chop_trailing_singletons (); 2410 frozen_lengths_for_resize.chop_trailing_singletons ();
2410 2411
2411 retval.resize (frozen_lengths_for_resize); 2412 retval.resize (frozen_lengths_for_resize);
2412 2413
2413 int n = retval.length (); 2414 octave_idx_type n = retval.length ();
2414 2415
2415 Array<int> result_idx (ra_idx.length (), 0); 2416 Array<octave_idx_type> result_idx (ra_idx.length (), 0);
2416 2417
2417 Array<int> elt_idx; 2418 Array<octave_idx_type> elt_idx;
2418 2419
2419 for (int i = 0; i < n; i++) 2420 for (octave_idx_type i = 0; i < n; i++)
2420 { 2421 {
2421 elt_idx = get_elt_idx (ra_idx, result_idx); 2422 elt_idx = get_elt_idx (ra_idx, result_idx);
2422 2423
2423 int numelem_elt = get_scalar_idx (elt_idx, new_dims); 2424 octave_idx_type numelem_elt = get_scalar_idx (elt_idx, new_dims);
2424 2425
2425 if (numelem_elt > length () || numelem_elt < 0) 2426 if (numelem_elt > length () || numelem_elt < 0)
2426 (*current_liboctave_error_handler) 2427 (*current_liboctave_error_handler)
2427 ("invalid N-d array index"); 2428 ("invalid N-d array index");
2428 else 2429 else
2494 2495
2495 idx_vector *tmp = lhs.get_idx (); 2496 idx_vector *tmp = lhs.get_idx ();
2496 2497
2497 idx_vector lhs_idx = tmp[0]; 2498 idx_vector lhs_idx = tmp[0];
2498 2499
2499 int lhs_len = lhs.length (); 2500 octave_idx_type lhs_len = lhs.length ();
2500 int rhs_len = rhs.length (); 2501 octave_idx_type rhs_len = rhs.length ();
2501 2502
2502 int n = lhs_idx.freeze (lhs_len, "vector", true, liboctave_wrore_flag); 2503 octave_idx_type n = lhs_idx.freeze (lhs_len, "vector", true, liboctave_wrore_flag);
2503 2504
2504 if (n != 0) 2505 if (n != 0)
2505 { 2506 {
2506 if (rhs_len == n || rhs_len == 1) 2507 if (rhs_len == n || rhs_len == 1)
2507 { 2508 {
2508 int max_idx = lhs_idx.max () + 1; 2509 octave_idx_type max_idx = lhs_idx.max () + 1;
2509 if (max_idx > lhs_len) 2510 if (max_idx > lhs_len)
2510 lhs.resize_and_fill (max_idx, rfv); 2511 lhs.resize_and_fill (max_idx, rfv);
2511 } 2512 }
2512 2513
2513 if (rhs_len == n) 2514 if (rhs_len == n)
2514 { 2515 {
2515 for (int i = 0; i < n; i++) 2516 for (octave_idx_type i = 0; i < n; i++)
2516 { 2517 {
2517 int ii = lhs_idx.elem (i); 2518 octave_idx_type ii = lhs_idx.elem (i);
2518 lhs.elem (ii) = rhs.elem (i); 2519 lhs.elem (ii) = rhs.elem (i);
2519 } 2520 }
2520 } 2521 }
2521 else if (rhs_len == 1) 2522 else if (rhs_len == 1)
2522 { 2523 {
2523 RT scalar = rhs.elem (0); 2524 RT scalar = rhs.elem (0);
2524 2525
2525 for (int i = 0; i < n; i++) 2526 for (octave_idx_type i = 0; i < n; i++)
2526 { 2527 {
2527 int ii = lhs_idx.elem (i); 2528 octave_idx_type ii = lhs_idx.elem (i);
2528 lhs.elem (ii) = scalar; 2529 lhs.elem (ii) = scalar;
2529 } 2530 }
2530 } 2531 }
2531 else 2532 else
2532 { 2533 {
2540 { 2541 {
2541 if (lhs_len == 0) 2542 if (lhs_len == 0)
2542 { 2543 {
2543 lhs.resize_no_fill (rhs_len); 2544 lhs.resize_no_fill (rhs_len);
2544 2545
2545 for (int i = 0; i < rhs_len; i++) 2546 for (octave_idx_type i = 0; i < rhs_len; i++)
2546 lhs.elem (i) = rhs.elem (i); 2547 lhs.elem (i) = rhs.elem (i);
2547 } 2548 }
2548 else 2549 else
2549 (*current_liboctave_error_handler) 2550 (*current_liboctave_error_handler)
2550 ("A(:) = X: A must be the same size as X"); 2551 ("A(:) = X: A must be the same size as X");
2563 } 2564 }
2564 2565
2565 #define MAYBE_RESIZE_LHS \ 2566 #define MAYBE_RESIZE_LHS \
2566 do \ 2567 do \
2567 { \ 2568 { \
2568 int max_row_idx = idx_i_is_colon ? rhs_nr : idx_i.max () + 1; \ 2569 octave_idx_type max_row_idx = idx_i_is_colon ? rhs_nr : idx_i.max () + 1; \
2569 int max_col_idx = idx_j_is_colon ? rhs_nc : idx_j.max () + 1; \ 2570 octave_idx_type max_col_idx = idx_j_is_colon ? rhs_nc : idx_j.max () + 1; \
2570 \ 2571 \
2571 int new_nr = max_row_idx > lhs_nr ? max_row_idx : lhs_nr; \ 2572 octave_idx_type new_nr = max_row_idx > lhs_nr ? max_row_idx : lhs_nr; \
2572 int new_nc = max_col_idx > lhs_nc ? max_col_idx : lhs_nc; \ 2573 octave_idx_type new_nc = max_col_idx > lhs_nc ? max_col_idx : lhs_nc; \
2573 \ 2574 \
2574 lhs.resize_and_fill (new_nr, new_nc, rfv); \ 2575 lhs.resize_and_fill (new_nr, new_nc, rfv); \
2575 } \ 2576 } \
2576 while (0) 2577 while (0)
2577 2578
2581 { 2582 {
2582 int retval = 1; 2583 int retval = 1;
2583 2584
2584 int n_idx = lhs.index_count (); 2585 int n_idx = lhs.index_count ();
2585 2586
2586 int lhs_nr = lhs.rows (); 2587 octave_idx_type lhs_nr = lhs.rows ();
2587 int lhs_nc = lhs.cols (); 2588 octave_idx_type lhs_nc = lhs.cols ();
2588 2589
2589 Array<RT> xrhs = rhs; 2590 Array<RT> xrhs = rhs;
2590 2591
2591 int rhs_nr = xrhs.rows (); 2592 octave_idx_type rhs_nr = xrhs.rows ();
2592 int rhs_nc = xrhs.cols (); 2593 octave_idx_type rhs_nc = xrhs.cols ();
2593 2594
2594 if (xrhs.ndims () > 2) 2595 if (xrhs.ndims () > 2)
2595 { 2596 {
2596 xrhs = xrhs.squeeze (); 2597 xrhs = xrhs.squeeze ();
2597 2598
2629 if (n_idx > 0) 2630 if (n_idx > 0)
2630 idx_i = tmp[0]; 2631 idx_i = tmp[0];
2631 2632
2632 if (n_idx == 2) 2633 if (n_idx == 2)
2633 { 2634 {
2634 int n = idx_i.freeze (lhs_nr, "row", true, liboctave_wrore_flag); 2635 octave_idx_type n = idx_i.freeze (lhs_nr, "row", true, liboctave_wrore_flag);
2635 2636
2636 int m = idx_j.freeze (lhs_nc, "column", true, liboctave_wrore_flag); 2637 octave_idx_type m = idx_j.freeze (lhs_nc, "column", true, liboctave_wrore_flag);
2637 2638
2638 int idx_i_is_colon = idx_i.is_colon (); 2639 int idx_i_is_colon = idx_i.is_colon ();
2639 int idx_j_is_colon = idx_j.is_colon (); 2640 int idx_j_is_colon = idx_j.is_colon ();
2640 2641
2641 if (idx_i_is_colon) 2642 if (idx_i_is_colon)
2661 { 2662 {
2662 MAYBE_RESIZE_LHS; 2663 MAYBE_RESIZE_LHS;
2663 2664
2664 RT scalar = xrhs.elem (0, 0); 2665 RT scalar = xrhs.elem (0, 0);
2665 2666
2666 for (int j = 0; j < m; j++) 2667 for (octave_idx_type j = 0; j < m; j++)
2667 { 2668 {
2668 int jj = idx_j.elem (j); 2669 octave_idx_type jj = idx_j.elem (j);
2669 for (int i = 0; i < n; i++) 2670 for (octave_idx_type i = 0; i < n; i++)
2670 { 2671 {
2671 int ii = idx_i.elem (i); 2672 octave_idx_type ii = idx_i.elem (i);
2672 lhs.elem (ii, jj) = scalar; 2673 lhs.elem (ii, jj) = scalar;
2673 } 2674 }
2674 } 2675 }
2675 } 2676 }
2676 } 2677 }
2678 { 2679 {
2679 if (n > 0 && m > 0) 2680 if (n > 0 && m > 0)
2680 { 2681 {
2681 MAYBE_RESIZE_LHS; 2682 MAYBE_RESIZE_LHS;
2682 2683
2683 for (int j = 0; j < m; j++) 2684 for (octave_idx_type j = 0; j < m; j++)
2684 { 2685 {
2685 int jj = idx_j.elem (j); 2686 octave_idx_type jj = idx_j.elem (j);
2686 for (int i = 0; i < n; i++) 2687 for (octave_idx_type i = 0; i < n; i++)
2687 { 2688 {
2688 int ii = idx_i.elem (i); 2689 octave_idx_type ii = idx_i.elem (i);
2689 lhs.elem (ii, jj) = xrhs.elem (i, j); 2690 lhs.elem (ii, jj) = xrhs.elem (i, j);
2690 } 2691 }
2691 } 2692 }
2692 } 2693 }
2693 } 2694 }
2721 { 2722 {
2722 int lhs_is_empty = lhs_nr == 0 || lhs_nc == 0; 2723 int lhs_is_empty = lhs_nr == 0 || lhs_nc == 0;
2723 2724
2724 if (lhs_is_empty || (lhs_nr == 1 && lhs_nc == 1)) 2725 if (lhs_is_empty || (lhs_nr == 1 && lhs_nc == 1))
2725 { 2726 {
2726 int lhs_len = lhs.length (); 2727 octave_idx_type lhs_len = lhs.length ();
2727 2728
2728 int n = idx_i.freeze (lhs_len, 0, true, liboctave_wrore_flag); 2729 octave_idx_type n = idx_i.freeze (lhs_len, 0, true, liboctave_wrore_flag);
2729 2730
2730 if (idx_i) 2731 if (idx_i)
2731 { 2732 {
2732 if (rhs_nr == 0 && rhs_nc == 0) 2733 if (rhs_nr == 0 && rhs_nc == 0)
2733 { 2734 {
2745 (*current_liboctave_warning_handler) 2746 (*current_liboctave_warning_handler)
2746 ("A(:) = X: X is not a vector or scalar"); 2747 ("A(:) = X: X is not a vector or scalar");
2747 } 2748 }
2748 else 2749 else
2749 { 2750 {
2750 int idx_nr = idx_i.orig_rows (); 2751 octave_idx_type idx_nr = idx_i.orig_rows ();
2751 int idx_nc = idx_i.orig_columns (); 2752 octave_idx_type idx_nc = idx_i.orig_columns ();
2752 2753
2753 if (! (rhs_nr == idx_nr && rhs_nc == idx_nc)) 2754 if (! (rhs_nr == idx_nr && rhs_nc == idx_nc))
2754 (*current_liboctave_warning_handler) 2755 (*current_liboctave_warning_handler)
2755 ("A(I) = X: X does not have same shape as I"); 2756 ("A(I) = X: X does not have same shape as I");
2756 } 2757 }
2757 } 2758 }
2758 2759
2759 if (assign1 (lhs, xrhs, rfv)) 2760 if (assign1 (lhs, xrhs, rfv))
2760 { 2761 {
2761 int len = lhs.length (); 2762 octave_idx_type len = lhs.length ();
2762 2763
2763 if (len > 0) 2764 if (len > 0)
2764 { 2765 {
2765 // The following behavior is much simplified 2766 // The following behavior is much simplified
2766 // over previous versions of Octave. It 2767 // over previous versions of Octave. It
2821 && idx_i.orig_rows () == lhs_nr 2822 && idx_i.orig_rows () == lhs_nr
2822 && idx_i.orig_columns () == lhs_nc))) 2823 && idx_i.orig_columns () == lhs_nc)))
2823 (*current_liboctave_warning_handler) 2824 (*current_liboctave_warning_handler)
2824 ("single index used for matrix"); 2825 ("single index used for matrix");
2825 2826
2826 int len = idx_i.freeze (lhs_nr * lhs_nc, "matrix"); 2827 octave_idx_type len = idx_i.freeze (lhs_nr * lhs_nc, "matrix");
2827 2828
2828 if (idx_i) 2829 if (idx_i)
2829 { 2830 {
2830 if (rhs_nr == 0 && rhs_nc == 0) 2831 if (rhs_nr == 0 && rhs_nc == 0)
2831 lhs.maybe_delete_elements (idx_i); 2832 lhs.maybe_delete_elements (idx_i);
2836 (*current_liboctave_error_handler) 2837 (*current_liboctave_error_handler)
2837 ("A([]) = X: X must be an empty matrix or scalar"); 2838 ("A([]) = X: X must be an empty matrix or scalar");
2838 } 2839 }
2839 else if (len == rhs_nr * rhs_nc) 2840 else if (len == rhs_nr * rhs_nc)
2840 { 2841 {
2841 int k = 0; 2842 octave_idx_type k = 0;
2842 for (int j = 0; j < rhs_nc; j++) 2843 for (octave_idx_type j = 0; j < rhs_nc; j++)
2843 { 2844 {
2844 for (int i = 0; i < rhs_nr; i++) 2845 for (octave_idx_type i = 0; i < rhs_nr; i++)
2845 { 2846 {
2846 int ii = idx_i.elem (k++); 2847 octave_idx_type ii = idx_i.elem (k++);
2847 int fr = ii % lhs_nr; 2848 octave_idx_type fr = ii % lhs_nr;
2848 int fc = (ii - fr) / lhs_nr; 2849 octave_idx_type fc = (ii - fr) / lhs_nr;
2849 lhs.elem (fr, fc) = xrhs.elem (i, j); 2850 lhs.elem (fr, fc) = xrhs.elem (i, j);
2850 } 2851 }
2851 } 2852 }
2852 } 2853 }
2853 else if (rhs_nr == 1 && rhs_nc == 1) 2854 else if (rhs_nr == 1 && rhs_nc == 1)
2854 { 2855 {
2855 RT scalar = rhs.elem (0, 0); 2856 RT scalar = rhs.elem (0, 0);
2856 2857
2857 for (int i = 0; i < len; i++) 2858 for (octave_idx_type i = 0; i < len; i++)
2858 { 2859 {
2859 int ii = idx_i.elem (i); 2860 octave_idx_type ii = idx_i.elem (i);
2860 lhs.elem (ii) = scalar; 2861 lhs.elem (ii) = scalar;
2861 } 2862 }
2862 } 2863 }
2863 else 2864 else
2864 { 2865 {
2890 { 2891 {
2891 int retval = 1; 2892 int retval = 1;
2892 2893
2893 dim_vector rhs_dims = rhs.dims (); 2894 dim_vector rhs_dims = rhs.dims ();
2894 2895
2895 int rhs_dims_len = rhs_dims.length (); 2896 octave_idx_type rhs_dims_len = rhs_dims.length ();
2896 2897
2897 bool rhs_is_scalar = is_scalar (rhs_dims); 2898 bool rhs_is_scalar = is_scalar (rhs_dims);
2898 2899
2899 int n_idx = lhs.index_count (); 2900 int n_idx = lhs.index_count ();
2900 2901
2915 || (iidx.one_zero_only () 2916 || (iidx.one_zero_only ()
2916 && iidx.orig_dimensions () == lhs.dims ()))) 2917 && iidx.orig_dimensions () == lhs.dims ())))
2917 (*current_liboctave_warning_handler) 2918 (*current_liboctave_warning_handler)
2918 ("single index used for N-d array"); 2919 ("single index used for N-d array");
2919 2920
2920 int lhs_len = lhs.length (); 2921 octave_idx_type lhs_len = lhs.length ();
2921 2922
2922 int len = iidx.freeze (lhs_len, "N-d arrray"); 2923 octave_idx_type len = iidx.freeze (lhs_len, "N-d arrray");
2923 2924
2924 if (iidx) 2925 if (iidx)
2925 { 2926 {
2926 if (len == 0) 2927 if (len == 0)
2927 { 2928 {
2933 retval = 0; 2934 retval = 0;
2934 } 2935 }
2935 } 2936 }
2936 else if (len == rhs.length ()) 2937 else if (len == rhs.length ())
2937 { 2938 {
2938 for (int i = 0; i < len; i++) 2939 for (octave_idx_type i = 0; i < len; i++)
2939 { 2940 {
2940 int ii = iidx.elem (i); 2941 octave_idx_type ii = iidx.elem (i);
2941 2942
2942 lhs.elem (ii) = rhs.elem (i); 2943 lhs.elem (ii) = rhs.elem (i);
2943 } 2944 }
2944 } 2945 }
2945 else if (rhs_is_scalar) 2946 else if (rhs_is_scalar)
2946 { 2947 {
2947 RT scalar = rhs.elem (0); 2948 RT scalar = rhs.elem (0);
2948 2949
2949 for (int i = 0; i < len; i++) 2950 for (octave_idx_type i = 0; i < len; i++)
2950 { 2951 {
2951 int ii = iidx.elem (i); 2952 octave_idx_type ii = iidx.elem (i);
2952 2953
2953 lhs.elem (ii) = scalar; 2954 lhs.elem (ii) = scalar;
2954 } 2955 }
2955 } 2956 }
2956 else 2957 else
2968 { 2969 {
2969 // Maybe expand to more dimensions. 2970 // Maybe expand to more dimensions.
2970 2971
2971 dim_vector lhs_dims = lhs.dims (); 2972 dim_vector lhs_dims = lhs.dims ();
2972 2973
2973 int lhs_dims_len = lhs_dims.length (); 2974 octave_idx_type lhs_dims_len = lhs_dims.length ();
2974 2975
2975 dim_vector final_lhs_dims = lhs_dims; 2976 dim_vector final_lhs_dims = lhs_dims;
2976 2977
2977 dim_vector frozen_len; 2978 dim_vector frozen_len;
2978 2979
2979 int orig_lhs_dims_len = lhs_dims_len; 2980 octave_idx_type orig_lhs_dims_len = lhs_dims_len;
2980 2981
2981 bool orig_empty = lhs_dims.all_zero (); 2982 bool orig_empty = lhs_dims.all_zero ();
2982 2983
2983 if (n_idx < lhs_dims_len) 2984 if (n_idx < lhs_dims_len)
2984 { 2985 {
3087 { 3088 {
3088 lhs.resize_and_fill (new_dims, rfv); 3089 lhs.resize_and_fill (new_dims, rfv);
3089 3090
3090 if (! final_lhs_dims.any_zero ()) 3091 if (! final_lhs_dims.any_zero ())
3091 { 3092 {
3092 int n = Array<LT>::get_size (frozen_len); 3093 octave_idx_type n = Array<LT>::get_size (frozen_len);
3093 3094
3094 Array<int> result_idx (lhs_dims_len, 0); 3095 Array<octave_idx_type> result_idx (lhs_dims_len, 0);
3095 3096
3096 RT scalar = rhs.elem (0); 3097 RT scalar = rhs.elem (0);
3097 3098
3098 for (int i = 0; i < n; i++) 3099 for (octave_idx_type i = 0; i < n; i++)
3099 { 3100 {
3100 Array<int> elt_idx = get_elt_idx (idx, result_idx); 3101 Array<octave_idx_type> elt_idx = get_elt_idx (idx, result_idx);
3101 3102
3102 lhs.elem (elt_idx) = scalar; 3103 lhs.elem (elt_idx) = scalar;
3103 3104
3104 increment_index (result_idx, frozen_len); 3105 increment_index (result_idx, frozen_len);
3105 } 3106 }
3107 } 3108 }
3108 else 3109 else
3109 { 3110 {
3110 // RHS is matrix or higher dimension. 3111 // RHS is matrix or higher dimension.
3111 3112
3112 int n = Array<LT>::get_size (frozen_len); 3113 octave_idx_type n = Array<LT>::get_size (frozen_len);
3113 3114
3114 if (n != rhs.numel ()) 3115 if (n != rhs.numel ())
3115 { 3116 {
3116 (*current_liboctave_error_handler) 3117 (*current_liboctave_error_handler)
3117 ("A(IDX-LIST) = X: X must be a scalar or size of X must equal number of elements indexed by IDX-LIST"); 3118 ("A(IDX-LIST) = X: X must be a scalar or size of X must equal number of elements indexed by IDX-LIST");
3124 3125
3125 if (! final_lhs_dims.any_zero ()) 3126 if (! final_lhs_dims.any_zero ())
3126 { 3127 {
3127 n = Array<LT>::get_size (frozen_len); 3128 n = Array<LT>::get_size (frozen_len);
3128 3129
3129 Array<int> result_idx (lhs_dims_len, 0); 3130 Array<octave_idx_type> result_idx (lhs_dims_len, 0);
3130 3131
3131 for (int i = 0; i < n; i++) 3132 for (octave_idx_type i = 0; i < n; i++)
3132 { 3133 {
3133 Array<int> elt_idx = get_elt_idx (idx, result_idx); 3134 Array<octave_idx_type> elt_idx = get_elt_idx (idx, result_idx);
3134 3135
3135 lhs.elem (elt_idx) = rhs.elem (i); 3136 lhs.elem (elt_idx) = rhs.elem (i);
3136 3137
3137 increment_index (result_idx, frozen_len); 3138 increment_index (result_idx, frozen_len);
3138 } 3139 }