Mercurial > hg > octave-nkf

comparison liboctave/CColVector.cc @ 1205:8302fab9fe24

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[project @ 1995-04-04 02:05:01 by jwe]
author jwe
date Tue, 04 Apr 1995 02:05:01 +0000
parents b6360f2d4fa6
children 0bf4d2b7def4
comparison
equal deleted inserted replaced
1204:68d147abe7ca 1205:8302fab9fe24
36 36
37 // Fortran functions we call. 37 // Fortran functions we call.
38 38
39 extern "C" 39 extern "C"
40 { 40 {
41 int F77_FCN (zgemm) (const char*, const char*, const int*, 41 int F77_FCN (zgemv) (const char*, const int*, const int*,
42 const int*, const int*, const Complex*, 42 const Complex*, const Complex*, const int*,
43 const Complex*, const int*, const Complex*, 43 const Complex*, const int*, const Complex*,
44 const int*, const Complex*, Complex*, const int*, 44 Complex*, const int*, long);
45 long, long);
46 } 45 }
47 46
48 /* 47 /*
49 * Complex Column Vector class 48 * Complex Column Vector class
50 */ 49 */
62 { 61 {
63 for (int i = 0; i < length (); i++) 62 for (int i = 0; i < length (); i++)
64 elem (i) = a.elem (i); 63 elem (i) = a.elem (i);
65 } 64 }
66 65
67 #if 0
68 ComplexColumnVector&
69 ComplexColumnVector::resize (int n)
70 {
71 if (n < 0)
72 {
73 (*current_liboctave_error_handler)
74 ("can't resize to negative dimension");
75 return *this;
76 }
77
78 Complex *new_data = 0;
79 if (n > 0)
80 {
81 new_data = new Complex [n];
82 int min_len = len < n ? len : n;
83
84 for (int i = 0; i < min_len; i++)
85 new_data[i] = data[i];
86 }
87
88 delete [] data;
89 len = n;
90 data = new_data;
91
92 return *this;
93 }
94
95 ComplexColumnVector&
96 ComplexColumnVector::resize (int n, double val)
97 {
98 int old_len = len;
99 resize (n);
100 for (int i = old_len; i < len; i++)
101 data[i] = val;
102
103 return *this;
104 }
105
106 ComplexColumnVector&
107 ComplexColumnVector::resize (int n, const Complex& val)
108 {
109 int old_len = len;
110 resize (n);
111 for (int i = old_len; i < len; i++)
112 data[i] = val;
113
114 return *this;
115 }
116 #endif
117
118 int 66 int
119 ComplexColumnVector::operator == (const ComplexColumnVector& a) const 67 ComplexColumnVector::operator == (const ComplexColumnVector& a) const
120 { 68 {
121 int len = length (); 69 int len = length ();
122 if (len != a.length ()) 70 if (len != a.length ())
254 { 202 {
255 int len = length (); 203 int len = length ();
256 return ComplexRowVector (dup (data (), len), len); 204 return ComplexRowVector (dup (data (), len), len);
257 } 205 }
258 206
259 ColumnVector
260 real (const ComplexColumnVector& a)
261 {
262 int a_len = a.length ();
263 ColumnVector retval;
264 if (a_len > 0)
265 retval = ColumnVector (real_dup (a.data (), a_len), a_len);
266 return retval;
267 }
268
269 ColumnVector
270 imag (const ComplexColumnVector& a)
271 {
272 int a_len = a.length ();
273 ColumnVector retval;
274 if (a_len > 0)
275 retval = ColumnVector (imag_dup (a.data (), a_len), a_len);
276 return retval;
277 }
278
279 ComplexColumnVector 207 ComplexColumnVector
280 conj (const ComplexColumnVector& a) 208 conj (const ComplexColumnVector& a)
281 { 209 {
282 int a_len = a.length (); 210 int a_len = a.length ();
283 ComplexColumnVector retval; 211 ComplexColumnVector retval;
414 { 342 {
415 int len = v.length (); 343 int len = v.length ();
416 return ComplexColumnVector (divide (v.data (), len, s), len); 344 return ComplexColumnVector (divide (v.data (), len, s), len);
417 } 345 }
418 346
347 ComplexColumnVector
348 operator + (const ColumnVector& a, const Complex& s)
349 {
350 int len = a.length ();
351 return ComplexColumnVector (add (a.data (), len, s), len);
352 }
353
354 ComplexColumnVector
355 operator - (const ColumnVector& a, const Complex& s)
356 {
357 int len = a.length ();
358 return ComplexColumnVector (subtract (a.data (), len, s), len);
359 }
360
361 ComplexColumnVector
362 operator * (const ColumnVector& a, const Complex& s)
363 {
364 int len = a.length ();
365 return ComplexColumnVector (multiply (a.data (), len, s), len);
366 }
367
368 ComplexColumnVector
369 operator / (const ColumnVector& a, const Complex& s)
370 {
371 int len = a.length ();
372 return ComplexColumnVector (divide (a.data (), len, s), len);
373 }
374
419 // scalar by column vector -> column vector operations 375 // scalar by column vector -> column vector operations
420 376
421 ComplexColumnVector 377 ComplexColumnVector
422 operator + (double s, const ComplexColumnVector& a) 378 operator + (double s, const ComplexColumnVector& a)
423 { 379 {
444 { 400 {
445 int a_len = a.length (); 401 int a_len = a.length ();
446 return ComplexColumnVector (divide (s, a.data (), a_len), a_len); 402 return ComplexColumnVector (divide (s, a.data (), a_len), a_len);
447 } 403 }
448 404
449 // column vector by row vector -> matrix operations 405 ComplexColumnVector
450 406 operator + (const Complex& s, const ColumnVector& a)
451 ComplexMatrix 407 {
452 operator * (const ComplexColumnVector& v, const ComplexRowVector& a) 408 int a_len = a.length ();
453 { 409 return ComplexColumnVector (add (a.data (), a_len, s), a_len);
454 int len = v.length (); 410 }
455 int a_len = a.length (); 411
456 if (len != a_len) 412 ComplexColumnVector
457 { 413 operator - (const Complex& s, const ColumnVector& a)
458 (*current_liboctave_error_handler) 414 {
459 ("nonconformant vector multiplication attempted"); 415 int a_len = a.length ();
460 return ComplexMatrix (); 416 return ComplexColumnVector (subtract (s, a.data (), a_len), a_len);
461 } 417 }
462 418
463 if (len == 0) 419 ComplexColumnVector
464 return ComplexMatrix (len, len, 0.0); 420 operator * (const Complex& s, const ColumnVector& a)
465 421 {
466 char transa = 'N'; 422 int a_len = a.length ();
467 char transb = 'N'; 423 return ComplexColumnVector (multiply (a.data (), a_len, s), a_len);
424 }
425
426 ComplexColumnVector
427 operator / (const Complex& s, const ColumnVector& a)
428 {
429 int a_len = a.length ();
430 return ComplexColumnVector (divide (s, a.data (), a_len), a_len);
431 }
432
433 // matrix by column vector -> column vector operations
434
435 ComplexColumnVector
436 operator * (const ComplexMatrix& m, const ColumnVector& a)
437 {
438 ComplexColumnVector tmp (a);
439 return m * tmp;
440 }
441
442 ComplexColumnVector
443 operator * (const ComplexMatrix& m, const ComplexColumnVector& a)
444 {
445 int nr = m.rows ();
446 int nc = m.cols ();
447 if (nc != a.length ())
448 {
449 (*current_liboctave_error_handler)
450 ("nonconformant matrix multiplication attempted");
451 return ComplexColumnVector ();
452 }
453
454 if (nc == 0 || nr == 0)
455 return ComplexColumnVector (0);
456
457 char trans = 'N';
458 int ld = nr;
468 Complex alpha (1.0); 459 Complex alpha (1.0);
469 Complex beta (0.0); 460 Complex beta (0.0);
470 int anr = 1; 461 int i_one = 1;
471 462
472 Complex *c = new Complex [len * a_len]; 463 Complex *y = new Complex [nr];
473 464
474 F77_FCN (zgemm) (&transa, &transb, &len, &a_len, &anr, &alpha, 465 F77_FCN (zgemv) (&trans, &nr, &nc, &alpha, m.data (), &ld, a.data (),
475 v.data (), &len, a.data (), &anr, &beta, c, &len, 466 &i_one, &beta, y, &i_one, 1L);
476 1L, 1L); 467
477 468 return ComplexColumnVector (y, nr);
478 return ComplexMatrix (c, len, a_len);
479 } 469 }
480 470
481 // column vector by column vector -> column vector operations 471 // column vector by column vector -> column vector operations
482 472
483 ComplexColumnVector 473 ComplexColumnVector
513 503
514 return ComplexColumnVector (subtract (v.data (), a.data (), len), len); 504 return ComplexColumnVector (subtract (v.data (), a.data (), len), len);
515 } 505 }
516 506
517 ComplexColumnVector 507 ComplexColumnVector
508 operator + (const ColumnVector& v, const ComplexColumnVector& a)
509 {
510 int len = v.length ();
511 if (len != a.length ())
512 {
513 (*current_liboctave_error_handler)
514 ("nonconformant vector subtraction attempted");
515 return ComplexColumnVector ();
516 }
517
518 if (len == 0)
519 return ComplexColumnVector (0);
520
521 return ComplexColumnVector (add (v.data (), a.data (), len), len);
522 }
523
524 ComplexColumnVector
525 operator - (const ColumnVector& v, const ComplexColumnVector& a)
526 {
527 int len = v.length ();
528 if (len != a.length ())
529 {
530 (*current_liboctave_error_handler)
531 ("nonconformant vector subtraction attempted");
532 return ComplexColumnVector ();
533 }
534
535 if (len == 0)
536 return ComplexColumnVector (0);
537
538 return ComplexColumnVector (subtract (v.data (), a.data (), len), len);
539 }
540
541 ComplexColumnVector
518 product (const ComplexColumnVector& v, const ColumnVector& a) 542 product (const ComplexColumnVector& v, const ColumnVector& a)
519 { 543 {
520 int len = v.length (); 544 int len = v.length ();
521 if (len != a.length ()) 545 if (len != a.length ())
522 { 546 {
544 568
545 if (len == 0) 569 if (len == 0)
546 return ComplexColumnVector (0); 570 return ComplexColumnVector (0);
547 571
548 return ComplexColumnVector (divide (v.data (), a.data (), len), len); 572 return ComplexColumnVector (divide (v.data (), a.data (), len), len);
573 }
574
575 ComplexColumnVector
576 product (const ColumnVector& v, const ComplexColumnVector& a)
577 {
578 int len = v.length ();
579 if (len != a.length ())
580 {
581 (*current_liboctave_error_handler)
582 ("nonconformant vector product attempted");
583 return ColumnVector ();
584 }
585
586 if (len == 0)
587 return ComplexColumnVector (0);
588
589 return ComplexColumnVector (multiply (v.data (), a.data (), len), len);
590 }
591
592 ComplexColumnVector
593 quotient (const ColumnVector& v, const ComplexColumnVector& a)
594 {
595 int len = v.length ();
596 if (len != a.length ())
597 {
598 (*current_liboctave_error_handler)
599 ("nonconformant vector quotient attempted");
600 return ColumnVector ();
601 }
602
603 if (len == 0)
604 return ComplexColumnVector (0);
605
606 return ComplexColumnVector (divide (v.data (), a.data (), len), len);
607 }
608
609 // matrix by column vector -> column vector operations
610
611 ComplexColumnVector
612 operator * (const Matrix& m, const ComplexColumnVector& a)
613 {
614 ComplexMatrix tmp (m);
615 return tmp * a;
616 }
617
618 // diagonal matrix by column vector -> column vector operations
619
620 ComplexColumnVector
621 operator * (const DiagMatrix& m, const ComplexColumnVector& a)
622 {
623 int nr = m.rows ();
624 int nc = m.cols ();
625 int a_len = a.length ();
626 if (nc != a_len)
627 {
628 (*current_liboctave_error_handler)
629 ("nonconformant matrix multiplication attempted");
630 return ColumnVector ();
631 }
632
633 if (nc == 0 || nr == 0)
634 return ComplexColumnVector (0);
635
636 ComplexColumnVector result (nr);
637
638 for (int i = 0; i < a_len; i++)
639 result.elem (i) = a.elem (i) * m.elem (i, i);
640
641 for (i = a_len; i < nr; i++)
642 result.elem (i) = 0.0;
643
644 return result;
645 }
646
647 ComplexColumnVector
648 operator * (const ComplexDiagMatrix& m, const ColumnVector& a)
649 {
650 int nr = m.rows ();
651 int nc = m.cols ();
652 int a_len = a.length ();
653 if (nc != a_len)
654 {
655 (*current_liboctave_error_handler)
656 ("nonconformant matrix muliplication attempted");
657 return ComplexColumnVector ();
658 }
659
660 if (nc == 0 || nr == 0)
661 return ComplexColumnVector (0);
662
663 ComplexColumnVector result (nr);
664
665 for (int i = 0; i < a_len; i++)
666 result.elem (i) = a.elem (i) * m.elem (i, i);
667
668 for (i = a_len; i < nr; i++)
669 result.elem (i) = 0.0;
670
671 return result;
672 }
673
674 ComplexColumnVector
675 operator * (const ComplexDiagMatrix& m, const ComplexColumnVector& a)
676 {
677 int nr = m.rows ();
678 int nc = m.cols ();
679 int a_len = a.length ();
680 if (nc != a_len)
681 {
682 (*current_liboctave_error_handler)
683 ("nonconformant matrix muliplication attempted");
684 return ComplexColumnVector ();
685 }
686
687 if (nc == 0 || nr == 0)
688 return ComplexColumnVector (0);
689
690 ComplexColumnVector result (nr);
691
692 for (int i = 0; i < a_len; i++)
693 result.elem (i) = a.elem (i) * m.elem (i, i);
694
695 for (i = a_len; i < nr; i++)
696 result.elem (i) = 0.0;
697
698 return result;
549 } 699 }
550 700
551 // other operations 701 // other operations
552 702
553 ComplexColumnVector 703 ComplexColumnVector
554 map (c_c_Mapper f, const ComplexColumnVector& a) 704 map (c_c_Mapper f, const ComplexColumnVector& a)
555 { 705 {
556 ComplexColumnVector b (a); 706 ComplexColumnVector b (a);
557 b.map (f); 707 b.map (f);
558 return b;
559 }
560
561 ColumnVector
562 map (d_c_Mapper f, const ComplexColumnVector& a)
563 {
564 int a_len = a.length ();
565 ColumnVector b (a_len);
566 for (int i = 0; i < a_len; i++)
567 b.elem (i) = f (a.elem (i));
568 return b; 708 return b;
569 } 709 }
570 710
571 void 711 void
572 ComplexColumnVector::map (c_c_Mapper f) 712 ComplexColumnVector::map (c_c_Mapper f)