Mercurial > hg > octave-lyh

comparison liboctave/Array.cc @ 254:c9894e8d5f04

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[project @ 1993-12-08 07:30:53 by jwe]
author jwe
date Wed, 08 Dec 1993 07:30:53 +0000
parents 5ba769d183b9
children 5638a94baa25
comparison
equal deleted inserted replaced
253:e208bd9ade36 254:c9894e8d5f04
190 Array<T>::checkelem (int n) 190 Array<T>::checkelem (int n)
191 { 191 {
192 if (n < 0 || n >= rep->length ()) 192 if (n < 0 || n >= rep->length ())
193 { 193 {
194 (*current_liboctave_error_handler) ("range error"); 194 (*current_liboctave_error_handler) ("range error");
195 static T foo (0); 195 static T foo;
196 return foo; 196 return foo;
197 } 197 }
198 return elem (n); 198 return elem (n);
199 } 199 }
200 200
224 Array<T>::checkelem (int n) const 224 Array<T>::checkelem (int n) const
225 { 225 {
226 if (n < 0 || n >= rep->length ()) 226 if (n < 0 || n >= rep->length ())
227 { 227 {
228 (*current_liboctave_error_handler) ("range error"); 228 (*current_liboctave_error_handler) ("range error");
229 return T (0); 229 T foo;
230 return foo;
230 } 231 }
231 return elem (n); 232 return elem (n);
232 } 233 }
233 234
234 template <class T> 235 template <class T>
428 429
429 template <class T> 430 template <class T>
430 T& 431 T&
431 Array2<T>::checkelem (int i, int j) 432 Array2<T>::checkelem (int i, int j)
432 { 433 {
433 return Array<T>::checkelem (d1*j+i); 434 if (i < 0 || j < 0 || i >= d1 || j >= d2)
435 {
436 (*current_liboctave_error_handler) ("range error");
437 static T foo;
438 return foo;
439 }
440 return Array<T>::elem (d1*j+i);
434 } 441 }
435 442
436 template <class T> 443 template <class T>
437 T& 444 T&
438 Array2<T>::operator () (int i, int j) 445 Array2<T>::operator () (int i, int j)
439 { 446 {
440 return Array<T>::checkelem (d1*j+i); 447 if (i < 0 || j < 0 || i >= d1 || j >= d2)
448 {
449 (*current_liboctave_error_handler) ("range error");
450 static T foo;
451 return foo;
452 }
453 return Array<T>::elem (d1*j+i);
441 } 454 }
442 455
443 template <class T> 456 template <class T>
444 T& 457 T&
445 Array2<T>::xelem (int i, int j) 458 Array2<T>::xelem (int i, int j)
456 469
457 template <class T> 470 template <class T>
458 T 471 T
459 Array2<T>::checkelem (int i, int j) const 472 Array2<T>::checkelem (int i, int j) const
460 { 473 {
461 return Array<T>::checkelem (d1*j+i); 474 if (i < 0 || j < 0 || i >= d1 || j >= d2)
475 {
476 (*current_liboctave_error_handler) ("range error");
477 T foo;
478 return foo;
479 }
480 return Array<T>::elem (d1*j+i);
462 } 481 }
463 482
464 template <class T> 483 template <class T>
465 T 484 T
466 Array2<T>::operator () (int i, int j) const 485 Array2<T>::operator () (int i, int j) const
467 { 486 {
468 return Array<T>::checkelem (d1*j+i); 487 if (i < 0 || j < 0 || i >= d1 || j >= d2)
488 {
489 (*current_liboctave_error_handler) ("range error");
490 T foo;
491 return foo;
492 }
493 return Array<T>::elem (d1*j+i);
469 } 494 }
470 495
471 template <class T> 496 template <class T>
472 void 497 void
473 Array2<T>::resize (int r, int c) 498 Array2<T>::resize (int r, int c)
624 649
625 template <class T> 650 template <class T>
626 T& 651 T&
627 Array3<T>::checkelem (int i, int j, int k) 652 Array3<T>::checkelem (int i, int j, int k)
628 { 653 {
629 return Array2<T>::checkelem (i, d1*k+j); 654 if (i < 0 || j < 0 || k < 0 || i >= d1 || j >= d2 || k >= d3)
655 {
656 (*current_liboctave_error_handler) ("range error");
657 static T foo;
658 return foo;
659 }
660 return Array2<T>::elem (i, d1*k+j);
630 } 661 }
631 662
632 template <class T> 663 template <class T>
633 T& 664 T&
634 Array3<T>::operator () (int i, int j, int k) 665 Array3<T>::operator () (int i, int j, int k)
635 { 666 {
636 return Array2<T>::checkelem (i, d2*k+j); 667 if (i < 0 || j < 0 || k < 0 || i >= d1 || j >= d2 || k >= d3)
668 {
669 (*current_liboctave_error_handler) ("range error");
670 static T foo;
671 return foo;
672 }
673 return Array2<T>::elem (i, d2*k+j);
637 } 674 }
638 675
639 template <class T> 676 template <class T>
640 T& 677 T&
641 Array3<T>::xelem (int i, int j, int k) 678 Array3<T>::xelem (int i, int j, int k)
652 689
653 template <class T> 690 template <class T>
654 T 691 T
655 Array3<T>::checkelem (int i, int j, int k) const 692 Array3<T>::checkelem (int i, int j, int k) const
656 { 693 {
657 return Array2<T>::checkelem (i, d1*k+j); 694 if (i < 0 || j < 0 || k < 0 || i >= d1 || j >= d2 || k >= d3)
695 {
696 (*current_liboctave_error_handler) ("range error");
697 T foo;
698 return foo;
699 }
700 return Array2<T>::elem (i, d1*k+j);
658 } 701 }
659 702
660 template <class T> 703 template <class T>
661 T 704 T
662 Array3<T>::operator () (int i, int j, int k) const 705 Array3<T>::operator () (int i, int j, int k) const
663 { 706 {
664 return Array2<T>::checkelem (i, d2*k+j); 707 if (i < 0 || j < 0 || k < 0 || i >= d1 || j >= d2 || k >= d3)
708 {
709 (*current_liboctave_error_handler) ("range error");
710 T foo;
711 return foo;
712 }
713 return Array2<T>::elem (i, d2*k+j);
665 } 714 }
666 715
667 template <class T> 716 template <class T>
668 void 717 void
669 Array3<T>::resize (int n, int m, int k) 718 Array3<T>::resize (int n, int m, int k)
793 template <class T> 842 template <class T>
794 T& 843 T&
795 DiagArray<T>::checkelem (int r, int c) 844 DiagArray<T>::checkelem (int r, int c)
796 { 845 {
797 static T foo (0); 846 static T foo (0);
798 return (r == c) ? Array<T>::checkelem (r) : foo; 847 if (r < 0 || c < 0 || r >= nr || c >= nc)
848 {
849 (*current_liboctave_error_handler) ("range error");
850 return foo;
851 }
852 return (r == c) ? Array<T>::elem (r) : foo;
799 } 853 }
800 854
801 template <class T> 855 template <class T>
802 T& 856 T&
803 DiagArray<T>::operator () (int r, int c) 857 DiagArray<T>::operator () (int r, int c)
804 { 858 {
805 static T foo (0); 859 static T foo (0);
806 return (r == c) ? Array<T>::operator () (r) : foo; 860 if (r < 0 || c < 0 || r >= nr || c >= nc)
861 {
862 (*current_liboctave_error_handler) ("range error");
863 return foo;
864 }
865 return (r == c) ? Array<T>::elem (r) : foo;
807 } 866 }
808 867
809 template <class T> 868 template <class T>
810 T& 869 T&
811 DiagArray<T>::xelem (int r, int c) 870 DiagArray<T>::xelem (int r, int c)
823 882
824 template <class T> 883 template <class T>
825 T 884 T
826 DiagArray<T>::checkelem (int r, int c) const 885 DiagArray<T>::checkelem (int r, int c) const
827 { 886 {
828 return (r == c) ? Array<T>::checkelem (r) : T (0); 887 if (r < 0 || c < 0 || r >= nr || c >= nc)
888 {
889 (*current_liboctave_error_handler) ("range error");
890 T foo;
891 return foo;
892 }
893 return (r == c) ? Array<T>::elem (r) : T (0);
829 } 894 }
830 895
831 template <class T> 896 template <class T>
832 T 897 T
833 DiagArray<T>::operator () (int r, int c) const 898 DiagArray<T>::operator () (int r, int c) const
834 { 899 {
835 return (r == c) ? Array<T>::operator () (r) : T (0); 900 if (r < 0 || c < 0 || r >= nr || c >= nc)
901 {
902 (*current_liboctave_error_handler) ("range error");
903 T foo;
904 return foo;
905 }
906 return (r == c) ? Array<T>::elem (r) : T (0);
836 } 907 }
837 908
838 template <class T> 909 template <class T>
839 void 910 void
840 DiagArray<T>::resize (int r, int c) 911 DiagArray<T>::resize (int r, int c)