Mercurial > hg > octave-avbm

comparison src/data.cc @ 6979:2883ea1c5c18

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[project @ 2007-10-08 20:23:48 by dbateman]
author dbateman
date Mon, 08 Oct 2007 20:26:01 +0000
parents 47f4f4e88166
children 9325d3f604a3
comparison
equal deleted inserted replaced
6978:b75630794a11 6979:2883ea1c5c18
431 @end deftypefn") 431 @end deftypefn")
432 { 432 {
433 DATA_REDUCTION (cumsum); 433 DATA_REDUCTION (cumsum);
434 } 434 }
435 435
436 // FIXME -- we could eliminate some duplicate code here with 436 template <class T>
437 // some template functions or macros.
438
439 static octave_value 437 static octave_value
440 make_diag (const Matrix& v, octave_idx_type k) 438 make_diag (const T& v, octave_idx_type k)
441 { 439 {
442 octave_idx_type nr = v.rows (); 440 octave_value retval;
443 octave_idx_type nc = v.columns (); 441 dim_vector dv = v.dims ();
444 assert (nc == 1 || nr == 1); 442 octave_idx_type nd = dv.length ();
445 443
446 octave_value retval; 444 if (nd > 2)
447 445 error ("diag: expecting 2-dimensional matrix");
448 octave_idx_type roff = 0; 446 else
449 octave_idx_type coff = 0; 447 {
450 if (k > 0) 448 octave_idx_type nr = dv (0);
451 { 449 octave_idx_type nc = dv (1);
452 roff = 0; 450
453 coff = k; 451 if (nr == 0 || nc == 0)
454 } 452 retval = T ();
455 else if (k < 0) 453 else if (nr != 1 && nc != 1)
456 { 454 retval = v.diag (k);
457 roff = -k; 455 else
458 coff = 0; 456 {
459 } 457 octave_idx_type roff = 0;
460 458 octave_idx_type coff = 0;
461 if (nr == 1) 459 if (k > 0)
462 { 460 {
463 octave_idx_type n = nc + std::abs (k); 461 roff = 0;
464 Matrix m (n, n, 0.0); 462 coff = k;
465 for (octave_idx_type i = 0; i < nc; i++) 463 }
466 m (i+roff, i+coff) = v (0, i); 464 else if (k < 0)
467 retval = m; 465 {
468 } 466 roff = -k;
469 else 467 coff = 0;
470 { 468 }
471 octave_idx_type n = nr + std::abs (k); 469
472 Matrix m (n, n, 0.0); 470 if (nr == 1)
473 for (octave_idx_type i = 0; i < nr; i++) 471 {
474 m (i+roff, i+coff) = v (i, 0); 472 octave_idx_type n = nc + std::abs (k);
475 retval = m; 473 T m (dim_vector (n, n), T::resize_fill_value ());
476 } 474
477 475 for (octave_idx_type i = 0; i < nc; i++)
478 return retval; 476 m (i+roff, i+coff) = v (0, i);
479 } 477 retval = m;
480 478 }
479 else
480 {
481 octave_idx_type n = nr + std::abs (k);
482 T m (dim_vector (n, n), T::resize_fill_value ());
483 for (octave_idx_type i = 0; i < nr; i++)
484 m (i+roff, i+coff) = v (i, 0);
485 retval = m;
486 }
487 }
488 }
489
490 return retval;
491 }
492
493 #if !defined (CXX_NEW_FRIEND_TEMPLATE_DECL)
481 static octave_value 494 static octave_value
482 make_diag (const ComplexMatrix& v, octave_idx_type k) 495 make_diag (const Matrix& v, octave_idx_type k);
483 { 496
484 octave_idx_type nr = v.rows (); 497 static octave_value
485 octave_idx_type nc = v.columns (); 498 make_diag (const ComplexMatrix& v, octave_idx_type k);
486 assert (nc == 1 || nr == 1); 499
487 500 static octave_value
488 octave_value retval; 501 make_diag (const charMatrix& v, octave_idx_type k);
489 502
490 octave_idx_type roff = 0; 503 static octave_value
491 octave_idx_type coff = 0; 504 make_diag (const boolMatrix& v, octave_idx_type k);
492 if (k > 0) 505
493 { 506 static octave_value
494 roff = 0; 507 make_diag (const int8NDArray& v, octave_idx_type k);
495 coff = k; 508
496 } 509 static octave_value
497 else if (k < 0) 510 make_diag (const int16NDArray& v, octave_idx_type k);
498 { 511
499 roff = -k; 512 static octave_value
500 coff = 0; 513 make_diag (const int32NDArray& v, octave_idx_type k);
501 } 514
502 515 static octave_value
503 if (nr == 1) 516 make_diag (const int64NDArray& v, octave_idx_type k);
504 { 517
505 octave_idx_type n = nc + std::abs (k); 518 static octave_value
506 ComplexMatrix m (n, n, 0.0); 519 make_diag (const uint8NDArray& v, octave_idx_type k);
507 for (octave_idx_type i = 0; i < nc; i++) 520
508 m (i+roff, i+coff) = v (0, i); 521 static octave_value
509 retval = m; 522 make_diag (const uint16NDArray& v, octave_idx_type k);
510 } 523
511 else 524 static octave_value
512 { 525 make_diag (const uint32NDArray& v, octave_idx_type k);
513 octave_idx_type n = nr + std::abs (k); 526
514 ComplexMatrix m (n, n, 0.0); 527 static octave_value
515 for (octave_idx_type i = 0; i < nr; i++) 528 make_diag (const uint64NDArray& v, octave_idx_type k);
516 m (i+roff, i+coff) = v (i, 0); 529 #endif
517 retval = m; 530
518 } 531 static octave_value
532 make_diag (const octave_value& a, octave_idx_type k)
533 {
534 octave_value retval;
535 std::string result_type = a.class_name ();
536
537 if (result_type == "double")
538 {
539 if (a.is_real_type ())
540 {
541 Matrix m = a.matrix_value ();
542 if (!error_state)
543 retval = make_diag (m, k);
544 }
545 else
546 {
547 ComplexMatrix m = a.complex_matrix_value ();
548 if (!error_state)
549 retval = make_diag (m, k);
550 }
551 }
552 #if 0
553 else if (result_type == "single")
554 retval = make_diag (a.single_array_value (), k);
555 #endif
556 else if (result_type == "char")
557 {
558 charMatrix m = a.char_matrix_value ();
559 if (!error_state)
560 {
561 retval = make_diag (m, k);
562 if (a.is_sq_string ())
563 retval = octave_value (retval.char_array_value (), true, '\'');
564 }
565 }
566 else if (result_type == "logical")
567 {
568 boolMatrix m = a.bool_matrix_value ();
569 if (!error_state)
570 retval = make_diag (m, k);
571 }
572 else if (result_type == "int8")
573 retval = make_diag (a.int8_array_value (), k);
574 else if (result_type == "int16")
575 retval = make_diag (a.int16_array_value (), k);
576 else if (result_type == "int32")
577 retval = make_diag (a.int32_array_value (), k);
578 else if (result_type == "int64")
579 retval = make_diag (a.int64_array_value (), k);
580 else if (result_type == "uint8")
581 retval = make_diag (a.uint8_array_value (), k);
582 else if (result_type == "uint16")
583 retval = make_diag (a.uint16_array_value (), k);
584 else if (result_type == "uint32")
585 retval = make_diag (a.uint32_array_value (), k);
586 else if (result_type == "uint64")
587 retval = make_diag (a.uint64_array_value (), k);
588 else
589 gripe_wrong_type_arg ("diag", a);
519 590
520 return retval; 591 return retval;
521 } 592 }
522 593
523 static octave_value 594 static octave_value
524 make_diag (const octave_value& arg) 595 make_diag (const octave_value& arg)
525 { 596 {
526 octave_value retval; 597 return make_diag (arg, 0);
527
528 if (arg.is_real_type ())
529 {
530 Matrix m = arg.matrix_value ();
531
532 if (! error_state)
533 {
534 octave_idx_type nr = m.rows ();
535 octave_idx_type nc = m.columns ();
536
537 if (nr == 0 || nc == 0)
538 retval = Matrix ();
539 else if (nr == 1 || nc == 1)
540 retval = make_diag (m, 0);
541 else
542 {
543 ColumnVector v = m.diag ();
544 if (v.numel () > 0)
545 retval = v;
546 }
547 }
548 else
549 gripe_wrong_type_arg ("diag", arg);
550 }
551 else if (arg.is_complex_type ())
552 {
553 ComplexMatrix cm = arg.complex_matrix_value ();
554
555 if (! error_state)
556 {
557 octave_idx_type nr = cm.rows ();
558 octave_idx_type nc = cm.columns ();
559
560 if (nr == 0 || nc == 0)
561 retval = Matrix ();
562 else if (nr == 1 || nc == 1)
563 retval = make_diag (cm, 0);
564 else
565 {
566 ComplexColumnVector v = cm.diag ();
567 if (v.numel () > 0)
568 retval = v;
569 }
570 }
571 else
572 gripe_wrong_type_arg ("diag", arg);
573 }
574 else
575 gripe_wrong_type_arg ("diag", arg);
576
577 return retval;
578 } 598 }
579 599
580 static octave_value 600 static octave_value
581 make_diag (const octave_value& a, const octave_value& b) 601 make_diag (const octave_value& a, const octave_value& b)
582 { 602 {
583 octave_value retval; 603 octave_value retval;
584 604
585 octave_idx_type k = b.int_value (); 605 octave_idx_type k = b.int_value ();
586 606
587 if (error_state) 607 if (error_state)
588 { 608 error ("diag: invalid second argument");
589 error ("diag: invalid second argument"); 609 else
590 return retval; 610 retval = make_diag (a, k);
591 }
592
593 if (a.is_real_type ())
594 {
595 Matrix m = a.matrix_value ();
596
597 if (! error_state)
598 {
599 octave_idx_type nr = m.rows ();
600 octave_idx_type nc = m.columns ();
601
602 if (nr == 1 || nc == 1)
603 retval = make_diag (m, k);
604 else if (nr == 0 || nc == 0)
605 retval = Matrix ();
606 else
607 {
608 ColumnVector d = m.diag (k);
609 retval = d;
610 }
611 }
612 }
613 else if (a.is_complex_type ())
614 {
615 ComplexMatrix cm = a.complex_matrix_value ();
616
617 if (! error_state)
618 {
619 octave_idx_type nr = cm.rows ();
620 octave_idx_type nc = cm.columns ();
621
622 if (nr == 1 || nc == 1)
623 retval = make_diag (cm, k);
624 else if (nr == 0 || nc == 0)
625 retval = Matrix ();
626 else
627 {
628 ComplexColumnVector d = cm.diag (k);
629 retval = d;
630 }
631 }
632 }
633 else
634 gripe_wrong_type_arg ("diag", a);
635 611
636 return retval; 612 return retval;
637 } 613 }
638 614
639 DEFUN (diag, args, , 615 DEFUN (diag, args, ,