Mercurial > octave-nkf

comparison libinterp/parse-tree/pt-mat.cc @ 20590:1a0a433c8263

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
eliminate more simple uses of error_state * dirfns.cc, oct-map.cc, oct-stream.cc, regexp.cc, ov-base-mat.cc, ov-cell.cc, pt-idx.cc, pt-mat.cc: Eliminate simple uses of error_state.
author John W. Eaton <jwe@octave.org>
date Mon, 05 Oct 2015 21:13:12 -0400
parents 7ac907da9fba
children
comparison
equal deleted inserted replaced
20589:b10432a40432 20590:1a0a433c8263
358 358
359 tree_expression *elt = *p; 359 tree_expression *elt = *p;
360 360
361 octave_value tmp = elt->rvalue1 (); 361 octave_value tmp = elt->rvalue1 ();
362 362
363 if (error_state || tmp.is_undefined ()) 363 if (tmp.is_undefined ())
364 { 364 {
365 ok = ! error_state; 365 ok = true;
366 return; 366 return;
367 } 367 }
368 else 368 else
369 { 369 {
370 if (tmp.is_cs_list ()) 370 if (tmp.is_cs_list ())
386 if (any_cell && ! any_class && ! first_elem_is_struct) 386 if (any_cell && ! any_class && ! first_elem_is_struct)
387 cellify (); 387 cellify ();
388 388
389 first_elem = true; 389 first_elem = true;
390 390
391 if (! error_state) 391 for (iterator p = begin (); p != end (); p++)
392 { 392 {
393 for (iterator p = begin (); p != end (); p++) 393 octave_quit ();
394 { 394
395 octave_quit (); 395 octave_value val = *p;
396 396
397 octave_value val = *p; 397 dim_vector this_elt_dv = val.dims ();
398 398
399 dim_vector this_elt_dv = val.dims (); 399 if (! this_elt_dv.zero_by_zero ())
400 400 {
401 if (! this_elt_dv.zero_by_zero ()) 401 all_mt = false;
402
403 if (first_elem)
402 { 404 {
403 all_mt = false; 405 first_elem = false;
404 406 dv = this_elt_dv;
405 if (first_elem)
406 {
407 first_elem = false;
408 dv = this_elt_dv;
409 }
410 else if ((! any_class) && (! dv.hvcat (this_elt_dv, 1)))
411 {
412 eval_error ("horizontal dimensions mismatch", dv, this_elt_dv);
413 break;
414 }
415 } 407 }
416 } 408 else if ((! any_class) && (! dv.hvcat (this_elt_dv, 1)))
417 } 409 {
418 410 eval_error ("horizontal dimensions mismatch", dv, this_elt_dv);
419 ok = ! error_state; 411 break;
412 }
413 }
414 }
415
416 ok = true;
420 } 417 }
421 418
422 void 419 void
423 tm_row_const::tm_row_const_rep::cellify (void) 420 tm_row_const::tm_row_const_rep::cellify (void)
424 { 421 {
604 } 601 }
605 else 602 else
606 break; 603 break;
607 } 604 }
608 605
609 if (! error_state) 606 if (any_cell && ! any_class && ! first_elem_is_struct)
610 { 607 {
611 if (any_cell && ! any_class && ! first_elem_is_struct)
612 {
613 for (iterator q = begin (); q != end (); q++)
614 {
615 octave_quit ();
616
617 q->cellify ();
618 }
619 }
620
621 first_elem = true;
622
623 for (iterator q = begin (); q != end (); q++) 608 for (iterator q = begin (); q != end (); q++)
624 { 609 {
625 octave_quit (); 610 octave_quit ();
626 611
627 tm_row_const elt = *q; 612 q->cellify ();
628 613 }
629 octave_idx_type this_elt_nr = elt.rows (); 614 }
630 octave_idx_type this_elt_nc = elt.cols (); 615
631 616 first_elem = true;
632 std::string this_elt_class_nm = elt.class_name (); 617
633 class_nm = get_concat_class (class_nm, this_elt_class_nm); 618 for (iterator q = begin (); q != end (); q++)
634 619 {
635 dim_vector this_elt_dv = elt.dims (); 620 octave_quit ();
636 621
637 all_mt = false; 622 tm_row_const elt = *q;
638 623
639 if (first_elem) 624 octave_idx_type this_elt_nr = elt.rows ();
640 { 625 octave_idx_type this_elt_nc = elt.cols ();
641 first_elem = false; 626
642 627 std::string this_elt_class_nm = elt.class_name ();
643 dv = this_elt_dv; 628 class_nm = get_concat_class (class_nm, this_elt_class_nm);
644 } 629
645 else if (all_str && dv.length () == 2 630 dim_vector this_elt_dv = elt.dims ();
646 && this_elt_dv.length () == 2) 631
647 { 632 all_mt = false;
648 // FIXME: this is Octave's specialty. Character matrices allow 633
649 // rows of unequal length. 634 if (first_elem)
650 if (this_elt_nc > cols ()) 635 {
651 dv(1) = this_elt_nc; 636 first_elem = false;
652 dv(0) += this_elt_nr; 637
653 } 638 dv = this_elt_dv;
654 else if ((!any_class) && (!dv.hvcat (this_elt_dv, 0))) 639 }
655 { 640 else if (all_str && dv.length () == 2
656 eval_error ("vertical dimensions mismatch", dv, this_elt_dv); 641 && this_elt_dv.length () == 2)
657 return; 642 {
658 } 643 // FIXME: this is Octave's specialty. Character matrices allow
659 } 644 // rows of unequal length.
660 } 645 if (this_elt_nc > cols ())
661 646 dv(1) = this_elt_nc;
662 ok = ! error_state; 647 dv(0) += this_elt_nr;
648 }
649 else if ((!any_class) && (!dv.hvcat (this_elt_dv, 0)))
650 {
651 eval_error ("vertical dimensions mismatch", dv, this_elt_dv);
652 return;
653 }
654 }
655
656 ok = true;
663 } 657 }
664 658
665 octave_value_list 659 octave_value_list
666 tree_matrix::rvalue (int nargout) 660 tree_matrix::rvalue (int nargout)
667 { 661 {
705 octave_quit (); 699 octave_quit ();
706 700
707 TYPE ra = octave_value_extract<TYPE> (*q); 701 TYPE ra = octave_value_extract<TYPE> (*q);
708 702
709 // Skip empty arrays to allow looser rules. 703 // Skip empty arrays to allow looser rules.
710 if (! error_state) 704
705 if (! ra.is_empty ())
711 { 706 {
712 if (! ra.is_empty ()) 707 result.insert (ra, r, c);
713 { 708
714 result.insert (ra, r, c); 709 c += ra.columns ();
715
716 if (! error_state)
717 c += ra.columns ();
718 else
719 return;
720 }
721 } 710 }
722 else
723 return;
724 } 711 }
725 712
726 r += row.rows (); 713 r += row.rows ();
727 c = 0; 714 c = 0;
728 } 715 }
750 { 737 {
751 // Optimize all scalars case. 738 // Optimize all scalars case.
752 result.clear (dv); 739 result.clear (dv);
753 assert (static_cast<size_t> (result.numel ()) == row.length ()); 740 assert (static_cast<size_t> (result.numel ()) == row.length ());
754 octave_idx_type i = 0; 741 octave_idx_type i = 0;
755 for (tm_row_const::iterator q = row.begin (); 742 for (tm_row_const::iterator q = row.begin (); q != row.end (); q++)
756 q != row.end () && ! error_state; q++)
757 result(i++) = octave_value_extract<T> (*q); 743 result(i++) = octave_value_extract<T> (*q);
758 744
759 return; 745 return;
760 } 746 }
761 747
762 octave_idx_type ncols = row.length (); 748 octave_idx_type ncols = row.length ();
763 octave_idx_type i = 0; 749 octave_idx_type i = 0;
764 OCTAVE_LOCAL_BUFFER (Array<T>, array_list, ncols); 750 OCTAVE_LOCAL_BUFFER (Array<T>, array_list, ncols);
765 751
766 for (tm_row_const::iterator q = row.begin (); 752 for (tm_row_const::iterator q = row.begin (); q != row.end (); q++)
767 q != row.end () && ! error_state;
768 q++)
769 { 753 {
770 octave_quit (); 754 octave_quit ();
771 755
772 array_list[i] = octave_value_extract<TYPE> (*q); 756 array_list[i] = octave_value_extract<TYPE> (*q);
773 i++; 757 i++;
774 } 758 }
775 759
776 if (! error_state) 760 result = Array<T>::cat (-2, ncols, array_list);
777 result = Array<T>::cat (-2, ncols, array_list);
778 } 761 }
779 else 762 else
780 { 763 {
781 result = Array<T> (dv); 764 result = Array<T> (dv);
782 single_type_concat<TYPE> (result, tmp); 765 single_type_concat<TYPE> (result, tmp);
806 tm_row_const row = *p; 789 tm_row_const row = *p;
807 octave_idx_type ncols = row.length (); 790 octave_idx_type ncols = row.length ();
808 octave_idx_type i = 0; 791 octave_idx_type i = 0;
809 OCTAVE_LOCAL_BUFFER (Sparse<T>, sparse_list, ncols); 792 OCTAVE_LOCAL_BUFFER (Sparse<T>, sparse_list, ncols);
810 793
811 for (tm_row_const::iterator q = row.begin (); 794 for (tm_row_const::iterator q = row.begin (); q != row.end (); q++)
812 q != row.end () && ! error_state;
813 q++)
814 { 795 {
815 octave_quit (); 796 octave_quit ();
816 797
817 sparse_list[i] = octave_value_extract<TYPE> (*q); 798 sparse_list[i] = octave_value_extract<TYPE> (*q);
818 i++; 799 i++;
846 tm_row_const row = *p; 827 tm_row_const row = *p;
847 octave_idx_type ncols = row.length (); 828 octave_idx_type ncols = row.length ();
848 octave_idx_type i = 0; 829 octave_idx_type i = 0;
849 OCTAVE_LOCAL_BUFFER (MAP, map_list, ncols); 830 OCTAVE_LOCAL_BUFFER (MAP, map_list, ncols);
850 831
851 for (tm_row_const::iterator q = row.begin (); 832 for (tm_row_const::iterator q = row.begin (); q != row.end (); q++)
852 q != row.end () && ! error_state;
853 q++)
854 { 833 {
855 octave_quit (); 834 octave_quit ();
856 835
857 map_list[i] = octave_value_extract<MAP> (*q); 836 map_list[i] = octave_value_extract<MAP> (*q);
858 i++; 837 i++;
919 898
920 rows(j++) = do_class_concat (row, "horzcat", 1); 899 rows(j++) = do_class_concat (row, "horzcat", 1);
921 } 900 }
922 } 901 }
923 902
924 if (! error_state) 903 if (rows.length () == 1)
925 { 904 retval = rows(0);
926 if (rows.length () == 1) 905 else
927 retval = rows(0); 906 retval = do_class_concat (rows, "vertcat", 0);
928 else
929 retval = do_class_concat (rows, "vertcat", 0);
930 }
931 907
932 return retval; 908 return retval;
933 } 909 }
934 910
935 octave_value 911 octave_value
1093 1069
1094 if (! all_empty_p) 1070 if (! all_empty_p)
1095 ctmp = ctmp.resize (dim_vector (0,0)).resize (dv); 1071 ctmp = ctmp.resize (dim_vector (0,0)).resize (dv);
1096 } 1072 }
1097 1073
1098 if (! error_state) 1074 // Now, extract the values from the individual elements and
1075 // insert them in the result matrix.
1076
1077 int dv_len = dv.length ();
1078 octave_idx_type ntmp = dv_len > 1 ? dv_len : 2;
1079 Array<octave_idx_type> ra_idx (dim_vector (ntmp, 1), 0);
1080
1081 for (tm_const::iterator p = tmp.begin (); p != tmp.end (); p++)
1099 { 1082 {
1100 // Now, extract the values from the individual elements and 1083 octave_quit ();
1101 // insert them in the result matrix. 1084
1102 1085 tm_row_const row = *p;
1103 int dv_len = dv.length (); 1086
1104 octave_idx_type ntmp = dv_len > 1 ? dv_len : 2; 1087 for (tm_row_const::iterator q = row.begin ();
1105 Array<octave_idx_type> ra_idx (dim_vector (ntmp, 1), 0); 1088 q != row.end ();
1106 1089 q++)
1107 for (tm_const::iterator p = tmp.begin (); p != tmp.end (); p++)
1108 { 1090 {
1109 octave_quit (); 1091 octave_quit ();
1110 1092
1111 tm_row_const row = *p; 1093 octave_value elt = *q;
1112 1094
1113 for (tm_row_const::iterator q = row.begin (); 1095 if (elt.is_empty ())
1114 q != row.end (); 1096 continue;
1115 q++) 1097
1116 { 1098 ctmp = do_cat_op (ctmp, elt, ra_idx);
1117 octave_quit (); 1099
1118 1100 ra_idx (1) += elt.columns ();
1119 octave_value elt = *q;
1120
1121 if (elt.is_empty ())
1122 continue;
1123
1124 ctmp = do_cat_op (ctmp, elt, ra_idx);
1125
1126 if (error_state)
1127 goto done;
1128
1129 ra_idx (1) += elt.columns ();
1130 }
1131
1132 ra_idx (0) += row.rows ();
1133 ra_idx (1) = 0;
1134 } 1101 }
1135 1102
1136 retval = ctmp; 1103 ra_idx (0) += row.rows ();
1137 1104 ra_idx (1) = 0;
1138 if (frc_str_conv && ! retval.is_string ())
1139 retval = retval.convert_to_str ();
1140 } 1105 }
1141 } 1106
1142 } 1107 retval = ctmp;
1143 1108
1144 done: 1109 if (frc_str_conv && ! retval.is_string ())
1110 retval = retval.convert_to_str ();
1111 }
1112 }
1113
1145 return retval; 1114 return retval;
1146 } 1115 }
1147 1116
1148 tree_expression * 1117 tree_expression *
1149 tree_matrix::dup (symbol_table::scope_id scope, 1118 tree_matrix::dup (symbol_table::scope_id scope,