Mercurial > hg > octave-jordi

comparison src/pt-const.cc @ 2305:5a3f1d00a474

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[project @ 1996-07-09 16:20:40 by jwe]
author jwe
date Tue, 09 Jul 1996 16:20:40 +0000
parents 38fea6d34daf
children 18953de8c308
comparison
equal deleted inserted replaced
2304:532542bd9493 2305:5a3f1d00a474
160 int nr = a.rows (); 160 int nr = a.rows ();
161 int nc = a.columns (); 161 int nc = a.columns ();
162 162
163 for (int j = 0; j < nc; j++) 163 for (int j = 0; j < nc; j++)
164 for (int i = 0; i < nr; i++) 164 for (int i = 0; i < nr; i++)
165 if (imag (a.elem (i, j)) != 0.0) 165 if (imag (a (i, j)) != 0.0)
166 return true; 166 return true;
167 167
168 return false; 168 return false;
169 } 169 }
170 170
483 483
484 OCT_VAL_REP::octave_value_rep (const Matrix& m) 484 OCT_VAL_REP::octave_value_rep (const Matrix& m)
485 { 485 {
486 if (m.rows () == 1 && m.columns () == 1) 486 if (m.rows () == 1 && m.columns () == 1)
487 { 487 {
488 scalar = m.elem (0, 0); 488 scalar = m (0, 0);
489 type_tag = scalar_constant; 489 type_tag = scalar_constant;
490 } 490 }
491 else 491 else
492 { 492 {
493 matrix = new Matrix (m); 493 matrix = new Matrix (m);
497 497
498 OCT_VAL_REP::octave_value_rep (const DiagMatrix& d) 498 OCT_VAL_REP::octave_value_rep (const DiagMatrix& d)
499 { 499 {
500 if (d.rows () == 1 && d.columns () == 1) 500 if (d.rows () == 1 && d.columns () == 1)
501 { 501 {
502 scalar = d.elem (0, 0); 502 scalar = d (0, 0);
503 type_tag = scalar_constant; 503 type_tag = scalar_constant;
504 } 504 }
505 else 505 else
506 { 506 {
507 matrix = new Matrix (d); 507 matrix = new Matrix (d);
512 OCT_VAL_REP::octave_value_rep (const RowVector& v, int prefer_column_vector) 512 OCT_VAL_REP::octave_value_rep (const RowVector& v, int prefer_column_vector)
513 { 513 {
514 int len = v.capacity (); 514 int len = v.capacity ();
515 if (len == 1) 515 if (len == 1)
516 { 516 {
517 scalar = v.elem (0); 517 scalar = v (0);
518 type_tag = scalar_constant; 518 type_tag = scalar_constant;
519 } 519 }
520 else 520 else
521 { 521 {
522 int pcv = (prefer_column_vector < 0) 522 int pcv = (prefer_column_vector < 0)
525 525
526 if (pcv) 526 if (pcv)
527 { 527 {
528 Matrix m (len, 1); 528 Matrix m (len, 1);
529 for (int i = 0; i < len; i++) 529 for (int i = 0; i < len; i++)
530 m.elem (i, 0) = v.elem (i); 530 m (i, 0) = v (i);
531 matrix = new Matrix (m); 531 matrix = new Matrix (m);
532 type_tag = matrix_constant; 532 type_tag = matrix_constant;
533 } 533 }
534 else 534 else
535 { 535 {
536 Matrix m (1, len); 536 Matrix m (1, len);
537 for (int i = 0; i < len; i++) 537 for (int i = 0; i < len; i++)
538 m.elem (0, i) = v.elem (i); 538 m (0, i) = v (i);
539 matrix = new Matrix (m); 539 matrix = new Matrix (m);
540 type_tag = matrix_constant; 540 type_tag = matrix_constant;
541 } 541 }
542 } 542 }
543 } 543 }
545 OCT_VAL_REP::octave_value_rep (const ColumnVector& v, int prefer_column_vector) 545 OCT_VAL_REP::octave_value_rep (const ColumnVector& v, int prefer_column_vector)
546 { 546 {
547 int len = v.capacity (); 547 int len = v.capacity ();
548 if (len == 1) 548 if (len == 1)
549 { 549 {
550 scalar = v.elem (0); 550 scalar = v (0);
551 type_tag = scalar_constant; 551 type_tag = scalar_constant;
552 } 552 }
553 else 553 else
554 { 554 {
555 int pcv = (prefer_column_vector < 0) 555 int pcv = (prefer_column_vector < 0)
558 558
559 if (pcv) 559 if (pcv)
560 { 560 {
561 Matrix m (len, 1); 561 Matrix m (len, 1);
562 for (int i = 0; i < len; i++) 562 for (int i = 0; i < len; i++)
563 m.elem (i, 0) = v.elem (i); 563 m (i, 0) = v (i);
564 matrix = new Matrix (m); 564 matrix = new Matrix (m);
565 type_tag = matrix_constant; 565 type_tag = matrix_constant;
566 } 566 }
567 else 567 else
568 { 568 {
569 Matrix m (1, len); 569 Matrix m (1, len);
570 for (int i = 0; i < len; i++) 570 for (int i = 0; i < len; i++)
571 m.elem (0, i) = v.elem (i); 571 m (0, i) = v (i);
572 matrix = new Matrix (m); 572 matrix = new Matrix (m);
573 type_tag = matrix_constant; 573 type_tag = matrix_constant;
574 } 574 }
575 } 575 }
576 } 576 }
591 591
592 OCT_VAL_REP::octave_value_rep (const ComplexMatrix& m) 592 OCT_VAL_REP::octave_value_rep (const ComplexMatrix& m)
593 { 593 {
594 if (m.rows () == 1 && m.columns () == 1) 594 if (m.rows () == 1 && m.columns () == 1)
595 { 595 {
596 Complex c = m.elem (0, 0); 596 Complex c = m (0, 0);
597 597
598 if (::imag (c) == 0.0) 598 if (::imag (c) == 0.0)
599 { 599 {
600 scalar = ::real (c); 600 scalar = ::real (c);
601 type_tag = scalar_constant; 601 type_tag = scalar_constant;
615 615
616 OCT_VAL_REP::octave_value_rep (const ComplexDiagMatrix& d) 616 OCT_VAL_REP::octave_value_rep (const ComplexDiagMatrix& d)
617 { 617 {
618 if (d.rows () == 1 && d.columns () == 1) 618 if (d.rows () == 1 && d.columns () == 1)
619 { 619 {
620 Complex c = d.elem (0, 0); 620 Complex c = d (0, 0);
621 621
622 if (::imag (c) == 0.0) 622 if (::imag (c) == 0.0)
623 { 623 {
624 scalar = ::real (c); 624 scalar = ::real (c);
625 type_tag = scalar_constant; 625 type_tag = scalar_constant;
641 int prefer_column_vector) 641 int prefer_column_vector)
642 { 642 {
643 int len = v.capacity (); 643 int len = v.capacity ();
644 if (len == 1) 644 if (len == 1)
645 { 645 {
646 Complex c = v.elem (0); 646 Complex c = v (0);
647 647
648 if (::imag (c) == 0.0) 648 if (::imag (c) == 0.0)
649 { 649 {
650 scalar = ::real (c); 650 scalar = ::real (c);
651 type_tag = scalar_constant; 651 type_tag = scalar_constant;
664 664
665 if (pcv) 665 if (pcv)
666 { 666 {
667 ComplexMatrix m (len, 1); 667 ComplexMatrix m (len, 1);
668 for (int i = 0; i < len; i++) 668 for (int i = 0; i < len; i++)
669 m.elem (i, 0) = v.elem (i); 669 m (i, 0) = v (i);
670 complex_matrix = new ComplexMatrix (m); 670 complex_matrix = new ComplexMatrix (m);
671 type_tag = complex_matrix_constant; 671 type_tag = complex_matrix_constant;
672 } 672 }
673 else 673 else
674 { 674 {
675 ComplexMatrix m (1, len); 675 ComplexMatrix m (1, len);
676 for (int i = 0; i < len; i++) 676 for (int i = 0; i < len; i++)
677 m.elem (0, i) = v.elem (i); 677 m (0, i) = v (i);
678 complex_matrix = new ComplexMatrix (m); 678 complex_matrix = new ComplexMatrix (m);
679 type_tag = complex_matrix_constant; 679 type_tag = complex_matrix_constant;
680 } 680 }
681 } 681 }
682 } 682 }
685 prefer_column_vector) 685 prefer_column_vector)
686 { 686 {
687 int len = v.capacity (); 687 int len = v.capacity ();
688 if (len == 1) 688 if (len == 1)
689 { 689 {
690 Complex c = v.elem (0); 690 Complex c = v (0);
691 691
692 if (::imag (c) == 0.0) 692 if (::imag (c) == 0.0)
693 { 693 {
694 scalar = ::real (c); 694 scalar = ::real (c);
695 type_tag = scalar_constant; 695 type_tag = scalar_constant;
708 708
709 if (pcv) 709 if (pcv)
710 { 710 {
711 ComplexMatrix m (len, 1); 711 ComplexMatrix m (len, 1);
712 for (int i = 0; i < len; i++) 712 for (int i = 0; i < len; i++)
713 m.elem (i, 0) = v.elem (i); 713 m (i, 0) = v (i);
714 complex_matrix = new ComplexMatrix (m); 714 complex_matrix = new ComplexMatrix (m);
715 type_tag = complex_matrix_constant; 715 type_tag = complex_matrix_constant;
716 } 716 }
717 else 717 else
718 { 718 {
719 ComplexMatrix m (1, len); 719 ComplexMatrix m (1, len);
720 for (int i = 0; i < len; i++) 720 for (int i = 0; i < len; i++)
721 m.elem (0, i) = v.elem (i); 721 m (0, i) = v (i);
722 complex_matrix = new ComplexMatrix (m); 722 complex_matrix = new ComplexMatrix (m);
723 type_tag = complex_matrix_constant; 723 type_tag = complex_matrix_constant;
724 } 724 }
725 } 725 }
726 } 726 }
744 char_matrix = new charMatrix (nr, nc, 0); 744 char_matrix = new charMatrix (nr, nc, 0);
745 for (int i = 0; i < nr; i++) 745 for (int i = 0; i < nr; i++)
746 { 746 {
747 nc = s[i].length (); 747 nc = s[i].length ();
748 for (int j = 0; j < nc; j++) 748 for (int j = 0; j < nc; j++)
749 char_matrix->elem (i, j) = s[i][j]; 749 (*char_matrix) (i, j) = s[i][j];
750 } 750 }
751 type_tag = char_matrix_constant_str; 751 type_tag = char_matrix_constant_str;
752 } 752 }
753 753
754 OCT_VAL_REP::octave_value_rep (const charMatrix& chm, bool is_str) 754 OCT_VAL_REP::octave_value_rep (const charMatrix& chm, bool is_str)
1159 case matrix_constant: 1159 case matrix_constant:
1160 { 1160 {
1161 Matrix m = (matrix->all ()) . all (); 1161 Matrix m = (matrix->all ()) . all ();
1162 retval = (m.rows () == 1 1162 retval = (m.rows () == 1
1163 && m.columns () == 1 1163 && m.columns () == 1
1164 && m.elem (0, 0) != 0.0); 1164 && m (0, 0) != 0.0);
1165 } 1165 }
1166 break; 1166 break;
1167 1167
1168 case complex_scalar_constant: 1168 case complex_scalar_constant:
1169 retval = (*complex_scalar != 0.0); 1169 retval = (*complex_scalar != 0.0);
1172 case complex_matrix_constant: 1172 case complex_matrix_constant:
1173 { 1173 {
1174 Matrix m = (complex_matrix->all ()) . all (); 1174 Matrix m = (complex_matrix->all ()) . all ();
1175 retval = (m.rows () == 1 1175 retval = (m.rows () == 1
1176 && m.columns () == 1 1176 && m.columns () == 1
1177 && m.elem (0, 0) != 0.0); 1177 && m (0, 0) != 0.0);
1178 } 1178 }
1179 break; 1179 break;
1180 1180
1181 default: 1181 default:
1182 gripe_wrong_type_arg (0, *this); 1182 gripe_wrong_type_arg (0, *this);
1206 break; 1206 break;
1207 1207
1208 case matrix_constant: 1208 case matrix_constant:
1209 { 1209 {
1210 if (Vdo_fortran_indexing && rows () > 0 && columns () > 0) 1210 if (Vdo_fortran_indexing && rows () > 0 && columns () > 0)
1211 retval = matrix->elem (0, 0); 1211 retval = (*matrix) (0, 0);
1212 else 1212 else
1213 gripe_invalid_conversion ("real matrix", "real scalar"); 1213 gripe_invalid_conversion ("real matrix", "real scalar");
1214 } 1214 }
1215 break; 1215 break;
1216 1216
1228 retval = ::real (*complex_scalar); 1228 retval = ::real (*complex_scalar);
1229 else if (type_tag == complex_matrix_constant) 1229 else if (type_tag == complex_matrix_constant)
1230 { 1230 {
1231 if (Vdo_fortran_indexing 1231 if (Vdo_fortran_indexing
1232 && rows () > 0 && columns () > 0) 1232 && rows () > 0 && columns () > 0)
1233 retval = ::real (complex_matrix->elem (0, 0)); 1233 retval = ::real ((*complex_matrix) (0, 0));
1234 else 1234 else
1235 gripe_invalid_conversion ("complex matrix", "real scalar"); 1235 gripe_invalid_conversion ("complex matrix", "real scalar");
1236 } 1236 }
1237 else 1237 else
1238 panic_impossible (); 1238 panic_impossible ();
1245 case char_matrix_constant: 1245 case char_matrix_constant:
1246 { 1246 {
1247 int len = char_matrix->rows (); 1247 int len = char_matrix->rows ();
1248 if ((char_matrix->rows () == 1 && len == 1) 1248 if ((char_matrix->rows () == 1 && len == 1)
1249 || (len > 1 && Vdo_fortran_indexing)) 1249 || (len > 1 && Vdo_fortran_indexing))
1250 retval = toascii ((int) char_matrix->elem (0, 0)); 1250 retval = toascii ((int) (*char_matrix) (0, 0));
1251 else 1251 else
1252 gripe_invalid_conversion ("char matrix", "real scalar"); 1252 gripe_invalid_conversion ("char matrix", "real scalar");
1253 } 1253 }
1254 break; 1254 break;
1255 1255
1264 1264
1265 int len = char_matrix->rows (); 1265 int len = char_matrix->rows ();
1266 if (flag 1266 if (flag
1267 && ((char_matrix->rows () == 1 && len == 1) 1267 && ((char_matrix->rows () == 1 && len == 1)
1268 || (len > 1 && Vdo_fortran_indexing))) 1268 || (len > 1 && Vdo_fortran_indexing)))
1269 retval = toascii ((int) char_matrix->elem (0, 0)); 1269 retval = toascii ((int) (*char_matrix) (0, 0));
1270 else 1270 else
1271 gripe_invalid_conversion ("string", "real scalar"); 1271 gripe_invalid_conversion ("string", "real scalar");
1272 } 1272 }
1273 break; 1273 break;
1274 1274
1377 case matrix_constant: 1377 case matrix_constant:
1378 { 1378 {
1379 if (Vdo_fortran_indexing && rows () > 0 && columns () > 0) 1379 if (Vdo_fortran_indexing && rows () > 0 && columns () > 0)
1380 { 1380 {
1381 if (type_tag == complex_matrix_constant) 1381 if (type_tag == complex_matrix_constant)
1382 retval = complex_matrix->elem (0, 0); 1382 retval = (*complex_matrix) (0, 0);
1383 else 1383 else
1384 retval = matrix->elem (0, 0); 1384 retval = (*matrix) (0, 0);
1385 } 1385 }
1386 else 1386 else
1387 gripe_invalid_conversion ("real matrix", "real scalar"); 1387 gripe_invalid_conversion ("real matrix", "real scalar");
1388 } 1388 }
1389 break; 1389 break;
1391 case char_matrix_constant: 1391 case char_matrix_constant:
1392 { 1392 {
1393 int len = char_matrix->cols (); 1393 int len = char_matrix->cols ();
1394 if ((char_matrix->rows () == 1 && len == 1) 1394 if ((char_matrix->rows () == 1 && len == 1)
1395 || (len > 1 && Vdo_fortran_indexing)) 1395 || (len > 1 && Vdo_fortran_indexing))
1396 retval = toascii ((int) char_matrix->elem (0, 0)); 1396 retval = toascii ((int) (*char_matrix) (0, 0));
1397 else 1397 else
1398 gripe_invalid_conversion ("char matrix", "complex scalar"); 1398 gripe_invalid_conversion ("char matrix", "complex scalar");
1399 } 1399 }
1400 break; 1400 break;
1401 1401
1410 1410
1411 int len = char_matrix->cols (); 1411 int len = char_matrix->cols ();
1412 if (flag 1412 if (flag
1413 && ((char_matrix->rows () == 1 && len == 1) 1413 && ((char_matrix->rows () == 1 && len == 1)
1414 || (len > 1 && Vdo_fortran_indexing))) 1414 || (len > 1 && Vdo_fortran_indexing)))
1415 retval = toascii ((int) char_matrix->elem (0, 0)); 1415 retval = toascii ((int) (*char_matrix) (0, 0));
1416 else 1416 else
1417 gripe_invalid_conversion ("string", "complex scalar"); 1417 gripe_invalid_conversion ("string", "complex scalar");
1418 } 1418 }
1419 break; 1419 break;
1420 1420
1597 int nc = m.columns (); 1597 int nc = m.columns ();
1598 if (nr == 1) 1598 if (nr == 1)
1599 { 1599 {
1600 retval.resize (nc); 1600 retval.resize (nc);
1601 for (int i = 0; i < nc; i++) 1601 for (int i = 0; i < nc; i++)
1602 retval.elem (i) = m (0, i); 1602 retval (i) = m (0, i);
1603 } 1603 }
1604 else if (nc == 1) 1604 else if (nc == 1)
1605 { 1605 {
1606 retval.resize (nr); 1606 retval.resize (nr);
1607 for (int i = 0; i < nr; i++) 1607 for (int i = 0; i < nr; i++)
1608 retval.elem (i) = m.elem (i, 0); 1608 retval (i) = m (i, 0);
1609 } 1609 }
1610 else if (nr > 0 && nc > 0 1610 else if (nr > 0 && nc > 0
1611 && (Vdo_fortran_indexing || force_vector_conversion)) 1611 && (Vdo_fortran_indexing || force_vector_conversion))
1612 { 1612 {
1613 retval.resize (nr * nc); 1613 retval.resize (nr * nc);
1614 int k = 0; 1614 int k = 0;
1615 for (int j = 0; j < nc; j++) 1615 for (int j = 0; j < nc; j++)
1616 for (int i = 0; i < nr; i++) 1616 for (int i = 0; i < nr; i++)
1617 retval.elem (k++) = m.elem (i, j); 1617 retval (k++) = m (i, j);
1618 } 1618 }
1619 else 1619 else
1620 gripe_invalid_conversion ("real matrix", "real vector"); 1620 gripe_invalid_conversion ("real matrix", "real vector");
1621 1621
1622 return retval; 1622 return retval;
1641 int nc = m.columns (); 1641 int nc = m.columns ();
1642 if (nr == 1) 1642 if (nr == 1)
1643 { 1643 {
1644 retval.resize (nc); 1644 retval.resize (nc);
1645 for (int i = 0; i < nc; i++) 1645 for (int i = 0; i < nc; i++)
1646 retval.elem (i) = m (0, i); 1646 retval (i) = m (0, i);
1647 } 1647 }
1648 else if (nc == 1) 1648 else if (nc == 1)
1649 { 1649 {
1650 retval.resize (nr); 1650 retval.resize (nr);
1651 for (int i = 0; i < nr; i++) 1651 for (int i = 0; i < nr; i++)
1652 retval.elem (i) = m.elem (i, 0); 1652 retval (i) = m (i, 0);
1653 } 1653 }
1654 else if (nr > 0 && nc > 0 1654 else if (nr > 0 && nc > 0
1655 && (Vdo_fortran_indexing || force_vector_conversion)) 1655 && (Vdo_fortran_indexing || force_vector_conversion))
1656 { 1656 {
1657 retval.resize (nr * nc); 1657 retval.resize (nr * nc);
1658 int k = 0; 1658 int k = 0;
1659 for (int j = 0; j < nc; j++) 1659 for (int j = 0; j < nc; j++)
1660 for (int i = 0; i < nr; i++) 1660 for (int i = 0; i < nr; i++)
1661 retval.elem (k++) = m.elem (i, j); 1661 retval (k++) = m (i, j);
1662 } 1662 }
1663 else 1663 else
1664 gripe_invalid_conversion ("complex matrix", "complex vector"); 1664 gripe_invalid_conversion ("complex matrix", "complex vector");
1665 1665
1666 return retval; 1666 return retval;
1722 1722
1723 for (int j = 0; j < nc; j++) 1723 for (int j = 0; j < nc; j++)
1724 { 1724 {
1725 for (int i = 0; i < nr; i++) 1725 for (int i = 0; i < nr; i++)
1726 { 1726 {
1727 double d = m.elem (i, j); 1727 double d = m (i, j);
1728 1728
1729 if (xisnan (d)) 1729 if (xisnan (d))
1730 { 1730 {
1731 ::error ("invalid conversion from NaN to character"); 1731 ::error ("invalid conversion from NaN to character");
1732 return retval; 1732 return retval;
1735 { 1735 {
1736 // XXX FIXME XXX -- warn about out of 1736 // XXX FIXME XXX -- warn about out of
1737 // range conversions? 1737 // range conversions?
1738 1738
1739 int ival = NINT (d); 1739 int ival = NINT (d);
1740 chm.elem (i, j) = (char) ival; 1740 chm (i, j) = (char) ival;
1741 } 1741 }
1742 } 1742 }
1743 } 1743 }
1744 1744
1745 retval = octave_value (chm, 1); 1745 retval = octave_value (chm, 1);
1826 double *cop_out = matrix->fortran_vec (); 1826 double *cop_out = matrix->fortran_vec ();
1827 1827
1828 for (int i = 0; i < len; i++) 1828 for (int i = 0; i < len; i++)
1829 { 1829 {
1830 if (new_nr == 1) 1830 if (new_nr == 1)
1831 m->elem (0, i) = *cop_out++; 1831 (*m) (0, i) = *cop_out++;
1832 else 1832 else
1833 m->elem (i, 0) = *cop_out++; 1833 (*m) (i, 0) = *cop_out++;
1834 } 1834 }
1835 1835
1836 delete matrix; 1836 delete matrix;
1837 matrix = m; 1837 matrix = m;
1838 } 1838 }
1843 Complex *cop_out = complex_matrix->fortran_vec (); 1843 Complex *cop_out = complex_matrix->fortran_vec ();
1844 1844
1845 for (int i = 0; i < len; i++) 1845 for (int i = 0; i < len; i++)
1846 { 1846 {
1847 if (new_nr == 1) 1847 if (new_nr == 1)
1848 cm->elem (0, i) = *cop_out++; 1848 (*cm) (0, i) = *cop_out++;
1849 else 1849 else
1850 cm->elem (i, 0) = *cop_out++; 1850 (*cm) (i, 0) = *cop_out++;
1851 } 1851 }
1852 1852
1853 delete complex_matrix; 1853 delete complex_matrix;
1854 complex_matrix = cm; 1854 complex_matrix = cm;
1855 } 1855 }
1949 int nc = char_matrix->cols (); 1949 int nc = char_matrix->cols ();
1950 1950
1951 if (nr == 1 && nc == 1) 1951 if (nr == 1 && nc == 1)
1952 { 1952 {
1953 type_tag = scalar_constant; 1953 type_tag = scalar_constant;
1954 double tmp = toascii ((int) char_matrix->elem (0, 0)); 1954 double tmp = toascii ((int) (*char_matrix) (0, 0));
1955 delete char_matrix; 1955 delete char_matrix;
1956 scalar = tmp; 1956 scalar = tmp;
1957 } 1957 }
1958 else if (nr == 0 || nc == 0) 1958 else if (nr == 0 || nc == 0)
1959 { 1959 {
1969 1969
1970 for (int i = 0; i < nr; i++) 1970 for (int i = 0; i < nr; i++)
1971 { 1971 {
1972 for (int j = 0; j < nc; j++) 1972 for (int j = 0; j < nc; j++)
1973 { 1973 {
1974 int c = (int) char_matrix->elem (i, j); 1974 int c = (int) (*char_matrix) (i, j);
1975 tm->elem (i, j) = toascii (c); 1975 (*tm) (i, j) = toascii (c);
1976 } 1976 }
1977 } 1977 }
1978 delete char_matrix; 1978 delete char_matrix;
1979 matrix = tm; 1979 matrix = tm;
1980 } 1980 }
1991 type_tag = matrix_constant; 1991 type_tag = matrix_constant;
1992 Matrix *tm = new Matrix (1, len); 1992 Matrix *tm = new Matrix (1, len);
1993 double b = range->base (); 1993 double b = range->base ();
1994 double increment = range->inc (); 1994 double increment = range->inc ();
1995 for (int i = 0; i < len; i++) 1995 for (int i = 0; i < len; i++)
1996 tm->elem (0, i) = b + i * increment; 1996 (*tm) (0, i) = b + i * increment;
1997 delete range; 1997 delete range;
1998 matrix = tm; 1998 matrix = tm;
1999 } 1999 }
2000 else if (len == 1) 2000 else if (len == 1)
2001 { 2001 {
2221 switch (type_tag) 2221 switch (type_tag)
2222 { 2222 {
2223 case matrix_constant: 2223 case matrix_constant:
2224 if (nr == 1 && nc == 1) 2224 if (nr == 1 && nc == 1)
2225 { 2225 {
2226 double d = matrix->elem (0, 0); 2226 double d = (*matrix) (0, 0);
2227 delete matrix; 2227 delete matrix;
2228 scalar = d; 2228 scalar = d;
2229 type_tag = scalar_constant; 2229 type_tag = scalar_constant;
2230 } 2230 }
2231 break; 2231 break;
2232 2232
2233 case complex_matrix_constant: 2233 case complex_matrix_constant:
2234 if (nr == 1 && nc == 1) 2234 if (nr == 1 && nc == 1)
2235 { 2235 {
2236 Complex c = complex_matrix->elem (0, 0); 2236 Complex c = (*complex_matrix) (0, 0);
2237 delete complex_matrix; 2237 delete complex_matrix;
2238 complex_scalar = new Complex (c); 2238 complex_scalar = new Complex (c);
2239 type_tag = complex_scalar_constant; 2239 type_tag = complex_scalar_constant;
2240 } 2240 }
2241 break; 2241 break;