Mercurial > hg > octave-lyh

comparison src/ov-re-mat.cc @ 10315:57a59eae83cc

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
untabify src C++ source files
author John W. Eaton <jwe@octave.org>
date Thu, 11 Feb 2010 12:41:46 -0500
parents 3a8c13b71612
children de2d43bcb083
comparison
equal deleted inserted replaced
10314:07ebe522dac2 10315:57a59eae83cc
109 double retval = lo_ieee_nan_value (); 109 double retval = lo_ieee_nan_value ();
110 110
111 if (numel () > 0) 111 if (numel () > 0)
112 { 112 {
113 gripe_implicit_conversion ("Octave:array-as-scalar", 113 gripe_implicit_conversion ("Octave:array-as-scalar",
114 "real matrix", "real scalar"); 114 "real matrix", "real scalar");
115 115
116 retval = matrix (0, 0); 116 retval = matrix (0, 0);
117 } 117 }
118 else 118 else
119 gripe_invalid_conversion ("real matrix", "real scalar"); 119 gripe_invalid_conversion ("real matrix", "real scalar");
127 float retval = lo_ieee_float_nan_value (); 127 float retval = lo_ieee_float_nan_value ();
128 128
129 if (numel () > 0) 129 if (numel () > 0)
130 { 130 {
131 gripe_implicit_conversion ("Octave:array-as-scalar", 131 gripe_implicit_conversion ("Octave:array-as-scalar",
132 "real matrix", "real scalar"); 132 "real matrix", "real scalar");
133 133
134 retval = matrix (0, 0); 134 retval = matrix (0, 0);
135 } 135 }
136 else 136 else
137 gripe_invalid_conversion ("real matrix", "real scalar"); 137 gripe_invalid_conversion ("real matrix", "real scalar");
161 Complex retval (tmp, tmp); 161 Complex retval (tmp, tmp);
162 162
163 if (rows () > 0 && columns () > 0) 163 if (rows () > 0 && columns () > 0)
164 { 164 {
165 gripe_implicit_conversion ("Octave:array-as-scalar", 165 gripe_implicit_conversion ("Octave:array-as-scalar",
166 "real matrix", "complex scalar"); 166 "real matrix", "complex scalar");
167 167
168 retval = matrix (0, 0); 168 retval = matrix (0, 0);
169 } 169 }
170 else 170 else
171 gripe_invalid_conversion ("real matrix", "complex scalar"); 171 gripe_invalid_conversion ("real matrix", "complex scalar");
181 FloatComplex retval (tmp, tmp); 181 FloatComplex retval (tmp, tmp);
182 182
183 if (rows () > 0 && columns () > 0) 183 if (rows () > 0 && columns () > 0)
184 { 184 {
185 gripe_implicit_conversion ("Octave:array-as-scalar", 185 gripe_implicit_conversion ("Octave:array-as-scalar",
186 "real matrix", "complex scalar"); 186 "real matrix", "complex scalar");
187 187
188 retval = matrix (0, 0); 188 retval = matrix (0, 0);
189 } 189 }
190 else 190 else
191 gripe_invalid_conversion ("real matrix", "complex scalar"); 191 gripe_invalid_conversion ("real matrix", "complex scalar");
315 octave_quit (); 315 octave_quit ();
316 316
317 double d = matrix (i); 317 double d = matrix (i);
318 318
319 if (xisnan (d)) 319 if (xisnan (d))
320 { 320 {
321 ::error ("invalid conversion from NaN to character"); 321 ::error ("invalid conversion from NaN to character");
322 return retval; 322 return retval;
323 } 323 }
324 else 324 else
325 { 325 {
326 int ival = NINT (d); 326 int ival = NINT (d);
327 327
328 if (ival < 0 || ival > UCHAR_MAX) 328 if (ival < 0 || ival > UCHAR_MAX)
329 { 329 {
330 // FIXME -- is there something 330 // FIXME -- is there something
331 // better we could do? 331 // better we could do?
332 332
333 ival = 0; 333 ival = 0;
334 334
335 if (! warned) 335 if (! warned)
336 { 336 {
337 ::warning ("range error for conversion to character value"); 337 ::warning ("range error for conversion to character value");
338 warned = true; 338 warned = true;
339 } 339 }
340 } 340 }
341 341
342 chm (i) = static_cast<char> (ival); 342 chm (i) = static_cast<char> (ival);
343 } 343 }
344 } 344 }
345 345
346 retval = octave_value (chm, type); 346 retval = octave_value (chm, type);
347 347
348 return retval; 348 return retval;
358 NDArray tmp = array_value (); 358 NDArray tmp = array_value ();
359 359
360 os << "# ndims: " << d.length () << "\n"; 360 os << "# ndims: " << d.length () << "\n";
361 361
362 for (int i=0; i < d.length (); i++) 362 for (int i=0; i < d.length (); i++)
363 os << " " << d (i); 363 os << " " << d (i);
364 364
365 os << "\n" << tmp; 365 os << "\n" << tmp;
366 } 366 }
367 else 367 else
368 { 368 {
369 // Keep this case, rather than use generic code above for backward 369 // Keep this case, rather than use generic code above for backward
370 // compatiability. Makes load_ascii much more complex!! 370 // compatiability. Makes load_ascii much more complex!!
371 os << "# rows: " << rows () << "\n" 371 os << "# rows: " << rows () << "\n"
372 << "# columns: " << columns () << "\n"; 372 << "# columns: " << columns () << "\n";
373 373
374 os << matrix_value (); 374 os << matrix_value ();
375 } 375 }
376 376
377 return true; 377 return true;
391 octave_idx_type val = 0; 391 octave_idx_type val = 0;
392 392
393 if (extract_keyword (is, keywords, kw, val, true)) 393 if (extract_keyword (is, keywords, kw, val, true))
394 { 394 {
395 if (kw == "ndims") 395 if (kw == "ndims")
396 { 396 {
397 int mdims = static_cast<int> (val); 397 int mdims = static_cast<int> (val);
398 398
399 if (mdims >= 0) 399 if (mdims >= 0)
400 { 400 {
401 dim_vector dv; 401 dim_vector dv;
402 dv.resize (mdims); 402 dv.resize (mdims);
403 403
404 for (int i = 0; i < mdims; i++) 404 for (int i = 0; i < mdims; i++)
405 is >> dv(i); 405 is >> dv(i);
406 406
407 if (is) 407 if (is)
408 { 408 {
409 NDArray tmp(dv); 409 NDArray tmp(dv);
410 410
411 is >> tmp; 411 is >> tmp;
412 412
413 if (is) 413 if (is)
414 matrix = tmp; 414 matrix = tmp;
415 else 415 else
416 { 416 {
417 error ("load: failed to load matrix constant"); 417 error ("load: failed to load matrix constant");
418 success = false; 418 success = false;
419 } 419 }
420 } 420 }
421 else 421 else
422 { 422 {
423 error ("load: failed to read dimensions"); 423 error ("load: failed to read dimensions");
424 success = false; 424 success = false;
425 } 425 }
426 } 426 }
427 else 427 else
428 { 428 {
429 error ("load: failed to extract number of dimensions"); 429 error ("load: failed to extract number of dimensions");
430 success = false; 430 success = false;
431 } 431 }
432 } 432 }
433 else if (kw == "rows") 433 else if (kw == "rows")
434 { 434 {
435 octave_idx_type nr = val; 435 octave_idx_type nr = val;
436 octave_idx_type nc = 0; 436 octave_idx_type nc = 0;
437 437
438 if (nr >= 0 && extract_keyword (is, "columns", nc) && nc >= 0) 438 if (nr >= 0 && extract_keyword (is, "columns", nc) && nc >= 0)
439 { 439 {
440 if (nr > 0 && nc > 0) 440 if (nr > 0 && nc > 0)
441 { 441 {
442 Matrix tmp (nr, nc); 442 Matrix tmp (nr, nc);
443 is >> tmp; 443 is >> tmp;
444 if (is) 444 if (is)
445 matrix = tmp; 445 matrix = tmp;
446 else 446 else
447 { 447 {
448 error ("load: failed to load matrix constant"); 448 error ("load: failed to load matrix constant");
449 success = false; 449 success = false;
450 } 450 }
451 } 451 }
452 else if (nr == 0 || nc == 0) 452 else if (nr == 0 || nc == 0)
453 matrix = Matrix (nr, nc); 453 matrix = Matrix (nr, nc);
454 else 454 else
455 panic_impossible (); 455 panic_impossible ();
456 } 456 }
457 else 457 else
458 { 458 {
459 error ("load: failed to extract number of rows and columns"); 459 error ("load: failed to extract number of rows and columns");
460 success = false; 460 success = false;
461 } 461 }
462 } 462 }
463 else 463 else
464 panic_impossible (); 464 panic_impossible ();
465 } 465 }
466 else 466 else
467 { 467 {
468 error ("load: failed to extract number of rows and columns"); 468 error ("load: failed to extract number of rows and columns");
469 success = false; 469 success = false;
492 NDArray m = array_value (); 492 NDArray m = array_value ();
493 save_type st = LS_DOUBLE; 493 save_type st = LS_DOUBLE;
494 if (save_as_floats) 494 if (save_as_floats)
495 { 495 {
496 if (m.too_large_for_float ()) 496 if (m.too_large_for_float ())
497 { 497 {
498 warning ("save: some values too large to save as floats --"); 498 warning ("save: some values too large to save as floats --");
499 warning ("save: saving as doubles instead"); 499 warning ("save: saving as doubles instead");
500 } 500 }
501 else 501 else
502 st = LS_FLOAT; 502 st = LS_FLOAT;
503 } 503 }
504 else if (d.numel () > 8192) // FIXME -- make this configurable. 504 else if (d.numel () > 8192) // FIXME -- make this configurable.
505 { 505 {
506 double max_val, min_val; 506 double max_val, min_val;
507 if (m.all_integers (max_val, min_val)) 507 if (m.all_integers (max_val, min_val))
508 st = get_save_type (max_val, min_val); 508 st = get_save_type (max_val, min_val);
509 } 509 }
510 510
511 const double *mtmp = m.data (); 511 const double *mtmp = m.data ();
512 write_doubles (os, mtmp, st, d.numel ()); 512 write_doubles (os, mtmp, st, d.numel ());
513 513
514 return true; 514 return true;
515 } 515 }
516 516
517 bool 517 bool
518 octave_matrix::load_binary (std::istream& is, bool swap, 518 octave_matrix::load_binary (std::istream& is, bool swap,
519 oct_mach_info::float_format fmt) 519 oct_mach_info::float_format fmt)
520 { 520 {
521 char tmp; 521 char tmp;
522 int32_t mdims; 522 int32_t mdims;
523 if (! is.read (reinterpret_cast<char *> (&mdims), 4)) 523 if (! is.read (reinterpret_cast<char *> (&mdims), 4))
524 return false; 524 return false;
530 int32_t di; 530 int32_t di;
531 dim_vector dv; 531 dim_vector dv;
532 dv.resize (mdims); 532 dv.resize (mdims);
533 533
534 for (int i = 0; i < mdims; i++) 534 for (int i = 0; i < mdims; i++)
535 { 535 {
536 if (! is.read (reinterpret_cast<char *> (&di), 4)) 536 if (! is.read (reinterpret_cast<char *> (&di), 4))
537 return false; 537 return false;
538 if (swap) 538 if (swap)
539 swap_bytes<4> (&di); 539 swap_bytes<4> (&di);
540 dv(i) = di; 540 dv(i) = di;
541 } 541 }
542 542
543 // Convert an array with a single dimension to be a row vector. 543 // Convert an array with a single dimension to be a row vector.
544 // Octave should never write files like this, other software 544 // Octave should never write files like this, other software
545 // might. 545 // might.
546 546
547 if (mdims == 1) 547 if (mdims == 1)
548 { 548 {
549 mdims = 2; 549 mdims = 2;
550 dv.resize (mdims); 550 dv.resize (mdims);
551 dv(1) = dv(0); 551 dv(1) = dv(0);
552 dv(0) = 1; 552 dv(0) = 1;
553 } 553 }
554 554
555 if (! is.read (reinterpret_cast<char *> (&tmp), 1)) 555 if (! is.read (reinterpret_cast<char *> (&tmp), 1))
556 return false; 556 return false;
557 557
558 NDArray m(dv); 558 NDArray m(dv);
559 double *re = m.fortran_vec (); 559 double *re = m.fortran_vec ();
560 read_doubles (is, re, static_cast<save_type> (tmp), dv.numel (), swap, fmt); 560 read_doubles (is, re, static_cast<save_type> (tmp), dv.numel (), swap, fmt);
561 if (error_state || ! is) 561 if (error_state || ! is)
562 return false; 562 return false;
563 matrix = m; 563 matrix = m;
564 } 564 }
565 else 565 else
566 { 566 {
567 int32_t nr, nc; 567 int32_t nr, nc;
568 nr = mdims; 568 nr = mdims;
569 if (! is.read (reinterpret_cast<char *> (&nc), 4)) 569 if (! is.read (reinterpret_cast<char *> (&nc), 4))
570 return false; 570 return false;
571 if (swap) 571 if (swap)
572 swap_bytes<4> (&nc); 572 swap_bytes<4> (&nc);
573 if (! is.read (reinterpret_cast<char *> (&tmp), 1)) 573 if (! is.read (reinterpret_cast<char *> (&tmp), 1))
574 return false; 574 return false;
575 Matrix m (nr, nc); 575 Matrix m (nr, nc);
576 double *re = m.fortran_vec (); 576 double *re = m.fortran_vec ();
577 octave_idx_type len = nr * nc; 577 octave_idx_type len = nr * nc;
578 read_doubles (is, re, static_cast<save_type> (tmp), len, swap, fmt); 578 read_doubles (is, re, static_cast<save_type> (tmp), len, swap, fmt);
579 if (error_state || ! is) 579 if (error_state || ! is)
580 return false; 580 return false;
581 matrix = m; 581 matrix = m;
582 } 582 }
583 return true; 583 return true;
584 } 584 }
585 585
611 hid_t save_type_hid = H5T_NATIVE_DOUBLE; 611 hid_t save_type_hid = H5T_NATIVE_DOUBLE;
612 612
613 if (save_as_floats) 613 if (save_as_floats)
614 { 614 {
615 if (m.too_large_for_float ()) 615 if (m.too_large_for_float ())
616 { 616 {
617 warning ("save: some values too large to save as floats --"); 617 warning ("save: some values too large to save as floats --");
618 warning ("save: saving as doubles instead"); 618 warning ("save: saving as doubles instead");
619 } 619 }
620 else 620 else
621 save_type_hid = H5T_NATIVE_FLOAT; 621 save_type_hid = H5T_NATIVE_FLOAT;
622 } 622 }
623 #if HAVE_HDF5_INT2FLOAT_CONVERSIONS 623 #if HAVE_HDF5_INT2FLOAT_CONVERSIONS
624 // hdf5 currently doesn't support float/integer conversions 624 // hdf5 currently doesn't support float/integer conversions
625 else 625 else
626 { 626 {
627 double max_val, min_val; 627 double max_val, min_val;
628 628
629 if (m.all_integers (max_val, min_val)) 629 if (m.all_integers (max_val, min_val))
630 save_type_hid 630 save_type_hid
631 = save_type_to_hdf5 (get_save_type (max_val, min_val)); 631 = save_type_to_hdf5 (get_save_type (max_val, min_val));
632 } 632 }
633 #endif /* HAVE_HDF5_INT2FLOAT_CONVERSIONS */ 633 #endif /* HAVE_HDF5_INT2FLOAT_CONVERSIONS */
634 634
635 #if HAVE_HDF5_18 635 #if HAVE_HDF5_18
636 data_hid = H5Dcreate (loc_id, name, save_type_hid, space_hid, 636 data_hid = H5Dcreate (loc_id, name, save_type_hid, space_hid,
637 H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); 637 H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
638 #else 638 #else
639 data_hid = H5Dcreate (loc_id, name, save_type_hid, space_hid, 639 data_hid = H5Dcreate (loc_id, name, save_type_hid, space_hid,
640 H5P_DEFAULT); 640 H5P_DEFAULT);
641 #endif 641 #endif
642 if (data_hid < 0) 642 if (data_hid < 0)
643 { 643 {
644 H5Sclose (space_hid); 644 H5Sclose (space_hid);
645 return false; 645 return false;
646 } 646 }
647 647
648 double *mtmp = m.fortran_vec (); 648 double *mtmp = m.fortran_vec ();
649 retval = H5Dwrite (data_hid, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, 649 retval = H5Dwrite (data_hid, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL,
650 H5P_DEFAULT, mtmp) >= 0; 650 H5P_DEFAULT, mtmp) >= 0;
651 651
652 H5Dclose (data_hid); 652 H5Dclose (data_hid);
653 H5Sclose (space_hid); 653 H5Sclose (space_hid);
654 654
655 return retval; 655 return retval;
697 } 697 }
698 else 698 else
699 { 699 {
700 dv.resize (rank); 700 dv.resize (rank);
701 for (hsize_t i = 0, j = rank - 1; i < rank; i++, j--) 701 for (hsize_t i = 0, j = rank - 1; i < rank; i++, j--)
702 dv(j) = hdims[i]; 702 dv(j) = hdims[i];
703 } 703 }
704 704
705 NDArray m (dv); 705 NDArray m (dv);
706 double *re = m.fortran_vec (); 706 double *re = m.fortran_vec ();
707 if (H5Dread (data_hid, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, 707 if (H5Dread (data_hid, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL,
708 H5P_DEFAULT, re) >= 0) 708 H5P_DEFAULT, re) >= 0)
709 { 709 {
710 retval = true; 710 retval = true;
711 matrix = m; 711 matrix = m;
712 } 712 }
713 713
719 719
720 #endif 720 #endif
721 721
722 void 722 void
723 octave_matrix::print_raw (std::ostream& os, 723 octave_matrix::print_raw (std::ostream& os,
724 bool pr_as_read_syntax) const 724 bool pr_as_read_syntax) const
725 { 725 {
726 octave_print_internal (os, matrix, pr_as_read_syntax, 726 octave_print_internal (os, matrix, pr_as_read_syntax,
727 current_print_indent_level ()); 727 current_print_indent_level ());
728 } 728 }
729 729
730 mxArray * 730 mxArray *
731 octave_matrix::as_mxArray (void) const 731 octave_matrix::as_mxArray (void) const
732 { 732 {
875 { 875 {
876 OCTAVE_TYPE_CONV_BODY3 (double, octave_perm_matrix, octave_scalar); 876 OCTAVE_TYPE_CONV_BODY3 (double, octave_perm_matrix, octave_scalar);
877 } 877 }
878 else if (args(0).is_diag_matrix ()) 878 else if (args(0).is_diag_matrix ())
879 { 879 {
880 if (args(0).is_complex_type ()) 880 if (args(0).is_complex_type ())
881 { 881 {
882 OCTAVE_TYPE_CONV_BODY3 (double, octave_complex_diag_matrix, octave_complex); 882 OCTAVE_TYPE_CONV_BODY3 (double, octave_complex_diag_matrix, octave_complex);
883 } 883 }
884 else 884 else
885 { 885 {
886 OCTAVE_TYPE_CONV_BODY3 (double, octave_diag_matrix, octave_scalar); 886 OCTAVE_TYPE_CONV_BODY3 (double, octave_diag_matrix, octave_scalar);
887 } 887 }
888 } 888 }
889 else if (args(0).is_sparse_type ()) 889 else if (args(0).is_sparse_type ())
890 { 890 {
891 if (args(0).is_complex_type ()) 891 if (args(0).is_complex_type ())
892 { 892 {
893 OCTAVE_TYPE_CONV_BODY3 (double, octave_sparse_complex_matrix, octave_complex); 893 OCTAVE_TYPE_CONV_BODY3 (double, octave_sparse_complex_matrix, octave_complex);
894 } 894 }
895 else 895 else
896 { 896 {
897 OCTAVE_TYPE_CONV_BODY3 (double, octave_sparse_matrix, octave_scalar); 897 OCTAVE_TYPE_CONV_BODY3 (double, octave_sparse_matrix, octave_scalar);
898 } 898 }
899 } 899 }
900 else if (args(0).is_complex_type ()) 900 else if (args(0).is_complex_type ())
901 { 901 {
902 OCTAVE_TYPE_CONV_BODY3 (double, octave_complex_matrix, octave_complex); 902 OCTAVE_TYPE_CONV_BODY3 (double, octave_complex_matrix, octave_complex);
903 } 903 }
904 else 904 else
905 { 905 {
906 OCTAVE_TYPE_CONV_BODY3 (double, octave_matrix, octave_scalar); 906 OCTAVE_TYPE_CONV_BODY3 (double, octave_matrix, octave_scalar);
907 } 907 }
908 } 908 }
909 else 909 else
910 print_usage (); 910 print_usage ();
911 911
912 return octave_value (); 912 return octave_value ();