|
3
|
1 // ColumnVector manipulations. -*- C++ -*- |
|
|
2 /* |
|
|
3 |
|
|
4 Copyright (C) 1992, 1993 John W. Eaton |
|
|
5 |
|
|
6 This file is part of Octave. |
|
|
7 |
|
|
8 Octave is free software; you can redistribute it and/or modify it |
|
|
9 under the terms of the GNU General Public License as published by the |
|
|
10 Free Software Foundation; either version 2, or (at your option) any |
|
|
11 later version. |
|
|
12 |
|
|
13 Octave is distributed in the hope that it will be useful, but WITHOUT |
|
|
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
|
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
|
16 for more details. |
|
|
17 |
|
|
18 You should have received a copy of the GNU General Public License |
|
|
19 along with Octave; see the file COPYING. If not, write to the Free |
|
|
20 Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. |
|
|
21 |
|
|
22 */ |
|
|
23 |
|
|
24 // I\'m not sure how this is supposed to work if the .h file declares |
|
|
25 // several classes, each of which is defined in a separate file... |
|
|
26 // |
|
|
27 // #ifdef __GNUG__ |
|
|
28 // #pragma implementation "Matrix.h" |
|
|
29 // #endif |
|
|
30 |
|
|
31 #include "Matrix.h" |
|
|
32 #include "mx-inlines.cc" |
|
227
|
33 #include "lo-error.h" |
|
230
|
34 #include "f77-uscore.h" |
|
|
35 |
|
|
36 // Fortran functions we call. |
|
|
37 |
|
|
38 extern "C" |
|
|
39 { |
|
|
40 int F77_FCN (dgemm) (const char*, const char*, const int*, |
|
|
41 const int*, const int*, const double*, |
|
|
42 const double*, const int*, const double*, |
|
|
43 const int*, const double*, double*, const int*, |
|
|
44 long, long); |
|
|
45 |
|
|
46 /* |
|
|
47 * f2c translates complex*16 as |
|
|
48 * |
|
|
49 * typedef struct { doublereal re, im; } doublecomplex; |
|
|
50 * |
|
|
51 * and Complex.h from libg++ uses |
|
|
52 * |
|
|
53 * protected: |
|
|
54 * double re; |
|
|
55 * double im; |
|
|
56 * |
|
|
57 * as the only data members, so this should work (fingers crossed that |
|
|
58 * things don't change). |
|
|
59 */ |
|
|
60 |
|
|
61 int F77_FCN (zgemm) (const char*, const char*, const int*, |
|
|
62 const int*, const int*, const Complex*, |
|
|
63 const Complex*, const int*, const Complex*, |
|
|
64 const int*, const Complex*, Complex*, const int*, |
|
|
65 long, long); |
|
|
66 } |
|
3
|
67 |
|
|
68 /* |
|
|
69 * Column Vector class. |
|
|
70 */ |
|
|
71 |
|
|
72 ColumnVector::ColumnVector (int n) |
|
|
73 { |
|
|
74 if (n < 0) |
|
227
|
75 { |
|
|
76 (*current_liboctave_error_handler) |
|
|
77 ("can't create column vector with negative dimension"); |
|
|
78 len = 0; |
|
|
79 data = (double *) NULL; |
|
|
80 return; |
|
|
81 } |
|
3
|
82 |
|
|
83 len = n; |
|
|
84 if (n > 0) |
|
|
85 data = new double [len]; |
|
|
86 else |
|
|
87 data = (double *) NULL; |
|
|
88 } |
|
|
89 |
|
|
90 ColumnVector::ColumnVector (int n, double val) |
|
|
91 { |
|
|
92 if (n < 0) |
|
227
|
93 { |
|
|
94 (*current_liboctave_error_handler) |
|
|
95 ("can't create column vector with negative dimension"); |
|
|
96 len = 0; |
|
|
97 data = (double *) NULL; |
|
|
98 return; |
|
|
99 } |
|
3
|
100 |
|
|
101 len = n; |
|
|
102 if (n > 0) |
|
|
103 { |
|
|
104 data = new double [len]; |
|
|
105 copy (data, len, val); |
|
|
106 } |
|
|
107 else |
|
|
108 data = (double *) NULL; |
|
|
109 } |
|
|
110 |
|
|
111 ColumnVector::ColumnVector (const ColumnVector& a) |
|
|
112 { |
|
|
113 len = a.len; |
|
|
114 if (len > 0) |
|
|
115 { |
|
|
116 data = new double [len]; |
|
|
117 copy (data, a.data, len); |
|
|
118 } |
|
|
119 else |
|
|
120 data = (double *) NULL; |
|
|
121 } |
|
|
122 |
|
|
123 ColumnVector::ColumnVector (double a) |
|
|
124 { |
|
|
125 len = 1; |
|
|
126 data = new double [1]; |
|
|
127 data[0] = a; |
|
|
128 } |
|
|
129 |
|
|
130 ColumnVector& |
|
|
131 ColumnVector::operator = (const ColumnVector& a) |
|
|
132 { |
|
|
133 if (this != &a) |
|
|
134 { |
|
|
135 delete [] data; |
|
|
136 len = a.len; |
|
|
137 if (len > 0) |
|
|
138 { |
|
|
139 data = new double [len]; |
|
|
140 copy (data, a.data, len); |
|
|
141 } |
|
|
142 else |
|
|
143 data = (double *) NULL; |
|
|
144 } |
|
|
145 return *this; |
|
|
146 } |
|
|
147 |
|
227
|
148 double& |
|
|
149 ColumnVector::checkelem (int n) |
|
|
150 { |
|
|
151 #ifndef NO_RANGE_CHECK |
|
|
152 if (n < 0 || n >= len) |
|
|
153 { |
|
|
154 (*current_liboctave_error_handler) ("range error"); |
|
|
155 static double foo = 0.0; |
|
|
156 return foo; |
|
|
157 } |
|
|
158 #endif |
|
|
159 |
|
|
160 return elem (n); |
|
|
161 } |
|
|
162 |
|
|
163 double |
|
|
164 ColumnVector::checkelem (int n) const |
|
|
165 { |
|
|
166 #ifndef NO_RANGE_CHECK |
|
|
167 if (n < 0 || n >= len) |
|
|
168 { |
|
|
169 (*current_liboctave_error_handler) ("range error"); |
|
|
170 return 0.0; |
|
|
171 } |
|
|
172 #endif |
|
|
173 |
|
|
174 return elem (n); |
|
|
175 } |
|
|
176 |
|
3
|
177 ColumnVector& |
|
|
178 ColumnVector::resize (int n) |
|
|
179 { |
|
|
180 if (n < 0) |
|
227
|
181 { |
|
|
182 (*current_liboctave_error_handler) |
|
|
183 ("can't resize to negative dimension"); |
|
|
184 return *this; |
|
|
185 } |
|
3
|
186 |
|
|
187 double *new_data = (double *) NULL; |
|
|
188 if (n > 0) |
|
|
189 { |
|
|
190 new_data = new double [n]; |
|
|
191 int min_len = len < n ? len : n; |
|
|
192 |
|
|
193 for (int i = 0; i < min_len; i++) |
|
|
194 new_data[i] = data[i]; |
|
|
195 } |
|
|
196 |
|
|
197 delete [] data; |
|
|
198 len = n; |
|
|
199 data = new_data; |
|
|
200 |
|
|
201 return *this; |
|
|
202 } |
|
|
203 |
|
|
204 ColumnVector& |
|
|
205 ColumnVector::resize (int n, double val) |
|
|
206 { |
|
|
207 int old_len = len; |
|
|
208 resize (n); |
|
|
209 for (int i = old_len; i < len; i++) |
|
|
210 data[i] = val; |
|
|
211 |
|
|
212 return *this; |
|
|
213 } |
|
|
214 |
|
|
215 int |
|
|
216 ColumnVector::operator == (const ColumnVector& a) const |
|
|
217 { |
|
|
218 if (len != a.len) |
|
|
219 return 0; |
|
|
220 return equal (data, a.data, len); |
|
|
221 } |
|
|
222 |
|
|
223 int |
|
|
224 ColumnVector::operator != (const ColumnVector& a) const |
|
|
225 { |
|
|
226 if (len != a.len) |
|
|
227 return 1; |
|
|
228 return !equal (data, a.data, len); |
|
|
229 } |
|
|
230 |
|
|
231 ColumnVector& |
|
|
232 ColumnVector::insert (const ColumnVector& a, int r) |
|
|
233 { |
|
|
234 if (r < 0 || r + a.len - 1 > len) |
|
227
|
235 { |
|
|
236 (*current_liboctave_error_handler) ("range error for insert"); |
|
|
237 return *this; |
|
|
238 } |
|
3
|
239 |
|
|
240 for (int i = 0; i < a.len; i++) |
|
|
241 data[r+i] = a.data[i]; |
|
|
242 |
|
|
243 return *this; |
|
|
244 } |
|
|
245 |
|
|
246 ColumnVector& |
|
|
247 ColumnVector::fill (double val) |
|
|
248 { |
|
|
249 if (len > 0) |
|
|
250 copy (data, len, val); |
|
|
251 return *this; |
|
|
252 } |
|
|
253 |
|
|
254 ColumnVector& |
|
|
255 ColumnVector::fill (double val, int r1, int r2) |
|
|
256 { |
|
|
257 if (r1 < 0 || r2 < 0 || r1 >= len || r2 >= len) |
|
227
|
258 { |
|
|
259 (*current_liboctave_error_handler) ("range error for fill"); |
|
|
260 return *this; |
|
|
261 } |
|
3
|
262 |
|
|
263 if (r1 > r2) { int tmp = r1; r1 = r2; r2 = tmp; } |
|
|
264 |
|
|
265 for (int i = r1; i <= r2; i++) |
|
|
266 data[i] = val; |
|
|
267 |
|
|
268 return *this; |
|
|
269 } |
|
|
270 |
|
|
271 ColumnVector |
|
|
272 ColumnVector::stack (const ColumnVector& a) const |
|
|
273 { |
|
|
274 int nr_insert = len; |
|
|
275 ColumnVector retval (len + a.len); |
|
|
276 retval.insert (*this, 0); |
|
|
277 retval.insert (a, nr_insert); |
|
|
278 return retval; |
|
|
279 } |
|
|
280 |
|
|
281 RowVector |
|
|
282 ColumnVector::transpose (void) const |
|
|
283 { |
|
|
284 return RowVector (dup (data, len), len); |
|
|
285 } |
|
|
286 |
|
|
287 // resize is the destructive equivalent for this one |
|
|
288 |
|
|
289 ColumnVector |
|
|
290 ColumnVector::extract (int r1, int r2) const |
|
|
291 { |
|
|
292 if (r1 > r2) { int tmp = r1; r1 = r2; r2 = tmp; } |
|
|
293 |
|
|
294 int new_r = r2 - r1 + 1; |
|
|
295 |
|
|
296 ColumnVector result (new_r); |
|
|
297 |
|
|
298 for (int i = 0; i < new_r; i++) |
|
|
299 result.data[i] = elem (r1+i); |
|
|
300 |
|
|
301 return result; |
|
|
302 } |
|
|
303 |
|
|
304 // column vector by scalar -> column vector operations |
|
|
305 |
|
|
306 ColumnVector |
|
|
307 ColumnVector::operator + (double s) const |
|
|
308 { |
|
|
309 return ColumnVector (add (data, len, s), len); |
|
|
310 } |
|
|
311 |
|
|
312 ColumnVector |
|
|
313 ColumnVector::operator - (double s) const |
|
|
314 { |
|
|
315 return ColumnVector (subtract (data, len, s), len); |
|
|
316 } |
|
|
317 |
|
|
318 ColumnVector |
|
|
319 ColumnVector::operator * (double s) const |
|
|
320 { |
|
|
321 return ColumnVector (multiply (data, len, s), len); |
|
|
322 } |
|
|
323 |
|
|
324 ColumnVector |
|
|
325 ColumnVector::operator / (double s) const |
|
|
326 { |
|
|
327 return ColumnVector (divide (data, len, s), len); |
|
|
328 } |
|
|
329 |
|
|
330 // scalar by column vector -> column vector operations |
|
|
331 |
|
|
332 ColumnVector |
|
|
333 operator + (double s, const ColumnVector& a) |
|
|
334 { |
|
|
335 return ColumnVector (add (a.data, a.len, s), a.len); |
|
|
336 } |
|
|
337 |
|
|
338 ColumnVector |
|
|
339 operator - (double s, const ColumnVector& a) |
|
|
340 { |
|
|
341 return ColumnVector (subtract (s, a.data, a.len), a.len); |
|
|
342 } |
|
|
343 |
|
|
344 ColumnVector |
|
|
345 operator * (double s, const ColumnVector& a) |
|
|
346 { |
|
|
347 return ColumnVector (multiply (a.data, a.len, s), a.len); |
|
|
348 } |
|
|
349 |
|
|
350 ColumnVector |
|
|
351 operator / (double s, const ColumnVector& a) |
|
|
352 { |
|
|
353 return ColumnVector (divide (s, a.data, a.len), a.len); |
|
|
354 } |
|
|
355 |
|
|
356 ComplexColumnVector |
|
161
|
357 ColumnVector::operator + (const Complex& s) const |
|
3
|
358 { |
|
|
359 return ComplexColumnVector (add (data, len, s), len); |
|
|
360 } |
|
|
361 |
|
|
362 ComplexColumnVector |
|
161
|
363 ColumnVector::operator - (const Complex& s) const |
|
3
|
364 { |
|
|
365 return ComplexColumnVector (subtract (data, len, s), len); |
|
|
366 } |
|
|
367 |
|
|
368 ComplexColumnVector |
|
161
|
369 ColumnVector::operator * (const Complex& s) const |
|
3
|
370 { |
|
|
371 return ComplexColumnVector (multiply (data, len, s), len); |
|
|
372 } |
|
|
373 |
|
|
374 ComplexColumnVector |
|
161
|
375 ColumnVector::operator / (const Complex& s) const |
|
3
|
376 { |
|
|
377 return ComplexColumnVector (divide (data, len, s), len); |
|
|
378 } |
|
|
379 |
|
|
380 // column vector by row vector -> matrix operations |
|
|
381 |
|
|
382 Matrix |
|
|
383 ColumnVector::operator * (const RowVector& a) const |
|
|
384 { |
|
|
385 if (len != a.len) |
|
227
|
386 { |
|
|
387 (*current_liboctave_error_handler) |
|
|
388 ("nonconformant vector multiplication attempted"); |
|
|
389 return Matrix (); |
|
|
390 } |
|
3
|
391 |
|
|
392 if (len == 0) |
|
|
393 return Matrix (len, len, 0.0); |
|
|
394 |
|
|
395 char transa = 'N'; |
|
|
396 char transb = 'N'; |
|
|
397 double alpha = 1.0; |
|
|
398 double beta = 0.0; |
|
|
399 int anr = 1; |
|
|
400 int anc = a.len; |
|
|
401 |
|
|
402 double *c = new double [len * a.len]; |
|
|
403 |
|
|
404 F77_FCN (dgemm) (&transa, &transb, &len, &anc, &anr, &alpha, data, |
|
|
405 &len, a.data, &anr, &beta, c, &len, 1L, 1L); |
|
|
406 |
|
|
407 return Matrix (c, len, a.len); |
|
|
408 } |
|
|
409 |
|
|
410 ComplexMatrix |
|
|
411 ColumnVector::operator * (const ComplexRowVector& a) const |
|
|
412 { |
|
|
413 ComplexColumnVector tmp (*this); |
|
|
414 return tmp * a; |
|
|
415 } |
|
|
416 |
|
|
417 // column vector by column vector -> column vector operations |
|
|
418 |
|
|
419 ColumnVector |
|
|
420 ColumnVector::operator + (const ColumnVector& a) const |
|
|
421 { |
|
|
422 if (len != a.len) |
|
227
|
423 { |
|
|
424 (*current_liboctave_error_handler) |
|
|
425 ("nonconformant vector addition attempted"); |
|
|
426 return ColumnVector (); |
|
|
427 } |
|
3
|
428 |
|
|
429 if (len == 0) |
|
|
430 return ColumnVector (0); |
|
|
431 |
|
|
432 return ColumnVector (add (data, a.data, len), len); |
|
|
433 } |
|
|
434 |
|
|
435 ColumnVector |
|
|
436 ColumnVector::operator - (const ColumnVector& a) const |
|
|
437 { |
|
|
438 if (len != a.len) |
|
227
|
439 { |
|
|
440 (*current_liboctave_error_handler) |
|
|
441 ("nonconformant vector subtraction attempted"); |
|
|
442 return ColumnVector (); |
|
|
443 } |
|
3
|
444 |
|
|
445 if (len == 0) |
|
|
446 return ColumnVector (0); |
|
|
447 |
|
|
448 return ColumnVector (subtract (data, a.data, len), len); |
|
|
449 } |
|
|
450 |
|
|
451 ComplexColumnVector |
|
|
452 ColumnVector::operator + (const ComplexColumnVector& a) const |
|
|
453 { |
|
|
454 if (len != a.len) |
|
227
|
455 { |
|
|
456 (*current_liboctave_error_handler) |
|
|
457 ("nonconformant vector addition attempted"); |
|
|
458 return ComplexColumnVector (); |
|
|
459 } |
|
3
|
460 |
|
|
461 if (len == 0) |
|
|
462 return ComplexColumnVector (0); |
|
|
463 |
|
|
464 return ComplexColumnVector (add (data, a.data, len), len); |
|
|
465 } |
|
|
466 |
|
|
467 ComplexColumnVector |
|
|
468 ColumnVector::operator - (const ComplexColumnVector& a) const |
|
|
469 { |
|
|
470 if (len != a.len) |
|
227
|
471 { |
|
|
472 (*current_liboctave_error_handler) |
|
|
473 ("nonconformant vector subtraction attempted"); |
|
|
474 return ComplexColumnVector (); |
|
|
475 } |
|
3
|
476 |
|
|
477 if (len == 0) |
|
|
478 return ComplexColumnVector (0); |
|
|
479 |
|
|
480 return ComplexColumnVector (subtract (data, a.data, len), len); |
|
|
481 } |
|
|
482 |
|
|
483 ColumnVector |
|
|
484 ColumnVector::product (const ColumnVector& a) const |
|
|
485 { |
|
|
486 if (len != a.len) |
|
227
|
487 { |
|
|
488 (*current_liboctave_error_handler) |
|
|
489 ("nonconformant vector product attempted"); |
|
|
490 return ColumnVector (); |
|
|
491 } |
|
3
|
492 |
|
|
493 if (len == 0) |
|
|
494 return ColumnVector (0); |
|
|
495 |
|
|
496 return ColumnVector (multiply (data, a.data, len), len); |
|
|
497 } |
|
|
498 |
|
|
499 ColumnVector |
|
|
500 ColumnVector::quotient (const ColumnVector& a) const |
|
|
501 { |
|
|
502 if (len != a.len) |
|
227
|
503 { |
|
|
504 (*current_liboctave_error_handler) |
|
|
505 ("nonconformant vector quotient attempted"); |
|
|
506 return ColumnVector (); |
|
|
507 } |
|
3
|
508 |
|
|
509 if (len == 0) |
|
|
510 return ColumnVector (0); |
|
|
511 |
|
|
512 return ColumnVector (divide (data, a.data, len), len); |
|
|
513 } |
|
|
514 |
|
|
515 ComplexColumnVector |
|
|
516 ColumnVector::product (const ComplexColumnVector& a) const |
|
|
517 { |
|
|
518 if (len != a.len) |
|
227
|
519 { |
|
|
520 (*current_liboctave_error_handler) |
|
|
521 ("nonconformant vector product attempted"); |
|
|
522 return ColumnVector (); |
|
|
523 } |
|
3
|
524 |
|
|
525 if (len == 0) |
|
|
526 return ComplexColumnVector (0); |
|
|
527 |
|
|
528 return ComplexColumnVector (multiply (data, a.data, len), len); |
|
|
529 } |
|
|
530 |
|
|
531 ComplexColumnVector |
|
|
532 ColumnVector::quotient (const ComplexColumnVector& a) const |
|
|
533 { |
|
|
534 if (len != a.len) |
|
227
|
535 { |
|
|
536 (*current_liboctave_error_handler) |
|
|
537 ("nonconformant vector quotient attempted"); |
|
|
538 return ColumnVector (); |
|
|
539 } |
|
3
|
540 |
|
|
541 if (len == 0) |
|
|
542 return ComplexColumnVector (0); |
|
|
543 |
|
|
544 return ComplexColumnVector (divide (data, a.data, len), len); |
|
|
545 } |
|
|
546 |
|
|
547 ColumnVector& |
|
|
548 ColumnVector::operator += (const ColumnVector& a) |
|
|
549 { |
|
|
550 if (len != a.len) |
|
227
|
551 { |
|
|
552 (*current_liboctave_error_handler) |
|
|
553 ("nonconformant vector += operation attempted"); |
|
|
554 return ColumnVector (); |
|
|
555 } |
|
3
|
556 |
|
|
557 if (len == 0) |
|
|
558 return *this; |
|
|
559 |
|
|
560 add2 (data, a.data, len); |
|
|
561 return *this; |
|
|
562 } |
|
|
563 |
|
|
564 ColumnVector& |
|
|
565 ColumnVector::operator -= (const ColumnVector& a) |
|
|
566 { |
|
|
567 if (len != a.len) |
|
227
|
568 { |
|
|
569 (*current_liboctave_error_handler) |
|
|
570 ("nonconformant vector -= operation attempted"); |
|
|
571 return ColumnVector (); |
|
|
572 } |
|
3
|
573 |
|
|
574 if (len == 0) |
|
|
575 return *this; |
|
|
576 |
|
|
577 subtract2 (data, a.data, len); |
|
|
578 return *this; |
|
|
579 } |
|
|
580 |
|
|
581 // unary operations |
|
|
582 |
|
|
583 ColumnVector |
|
|
584 ColumnVector::operator - (void) const |
|
|
585 { |
|
|
586 if (len == 0) |
|
|
587 return ColumnVector (0); |
|
|
588 |
|
|
589 return ColumnVector (negate (data, len), len); |
|
|
590 } |
|
|
591 |
|
|
592 ColumnVector |
|
|
593 map (d_d_Mapper f, const ColumnVector& a) |
|
|
594 { |
|
|
595 ColumnVector b (a); |
|
|
596 b.map (f); |
|
|
597 return b; |
|
|
598 } |
|
|
599 |
|
|
600 void |
|
|
601 ColumnVector::map (d_d_Mapper f) |
|
|
602 { |
|
|
603 for (int i = 0; i < len; i++) |
|
|
604 data[i] = f (data[i]); |
|
|
605 } |
|
|
606 |
|
|
607 double |
|
|
608 ColumnVector::min (void) const |
|
|
609 { |
|
|
610 if (len == 0) |
|
|
611 return 0.0; |
|
|
612 |
|
|
613 double res = data[0]; |
|
|
614 |
|
|
615 for (int i = 1; i < len; i++) |
|
|
616 if (data[i] < res) |
|
|
617 res = data[i]; |
|
|
618 |
|
|
619 return res; |
|
|
620 } |
|
|
621 |
|
|
622 double |
|
|
623 ColumnVector::max (void) const |
|
|
624 { |
|
|
625 if (len == 0) |
|
|
626 return 0.0; |
|
|
627 |
|
|
628 double res = data[0]; |
|
|
629 |
|
|
630 for (int i = 1; i < len; i++) |
|
|
631 if (data[i] > res) |
|
|
632 res = data[i]; |
|
|
633 |
|
|
634 return res; |
|
|
635 } |
|
|
636 |
|
|
637 ostream& |
|
|
638 operator << (ostream& os, const ColumnVector& a) |
|
|
639 { |
|
|
640 // int field_width = os.precision () + 7; |
|
|
641 for (int i = 0; i < a.len; i++) |
|
|
642 os << /* setw (field_width) << */ a.data[i] << "\n"; |
|
|
643 return os; |
|
|
644 } |
|
|
645 |
|
|
646 /* |
|
|
647 * Complex Column Vector class |
|
|
648 */ |
|
|
649 |
|
|
650 ComplexColumnVector::ComplexColumnVector (int n) |
|
|
651 { |
|
|
652 if (n < 0) |
|
227
|
653 { |
|
|
654 (*current_liboctave_error_handler) |
|
|
655 ("can't create column vector with negative dimension"); |
|
|
656 len = 0; |
|
|
657 data = (Complex *) NULL; |
|
|
658 return; |
|
|
659 } |
|
3
|
660 |
|
|
661 len = n; |
|
|
662 if (n > 0) |
|
|
663 data = new Complex [len]; |
|
|
664 else |
|
|
665 data = (Complex *) NULL; |
|
|
666 } |
|
|
667 |
|
|
668 ComplexColumnVector::ComplexColumnVector (int n, double val) |
|
|
669 { |
|
|
670 if (n < 0) |
|
227
|
671 { |
|
|
672 (*current_liboctave_error_handler) |
|
|
673 ("can't create column vector with negative dimension"); |
|
|
674 len = 0; |
|
|
675 data = (Complex *) NULL; |
|
|
676 return; |
|
|
677 } |
|
3
|
678 |
|
|
679 len = n; |
|
|
680 if (n > 0) |
|
|
681 { |
|
|
682 data = new Complex [len]; |
|
|
683 copy (data, len, val); |
|
|
684 } |
|
|
685 else |
|
|
686 data = (Complex *) NULL; |
|
|
687 } |
|
|
688 |
|
161
|
689 ComplexColumnVector::ComplexColumnVector (int n, const Complex& val) |
|
3
|
690 { |
|
|
691 if (n < 0) |
|
227
|
692 { |
|
|
693 (*current_liboctave_error_handler) |
|
|
694 ("can't create column vector with negative dimension"); |
|
|
695 len = 0; |
|
|
696 data = (Complex *) NULL; |
|
|
697 return; |
|
|
698 } |
|
3
|
699 |
|
|
700 len = n; |
|
|
701 if (n > 0) |
|
|
702 { |
|
|
703 data = new Complex [len]; |
|
|
704 copy (data, len, val); |
|
|
705 } |
|
|
706 else |
|
|
707 data = (Complex *) NULL; |
|
|
708 } |
|
|
709 |
|
|
710 ComplexColumnVector::ComplexColumnVector (const ColumnVector& a) |
|
|
711 { |
|
|
712 len = a.len; |
|
|
713 if (len > 0) |
|
|
714 { |
|
|
715 data = new Complex [len]; |
|
|
716 copy (data, a.data, len); |
|
|
717 } |
|
|
718 else |
|
|
719 data = (Complex *) NULL; |
|
|
720 } |
|
|
721 |
|
|
722 ComplexColumnVector::ComplexColumnVector (const ComplexColumnVector& a) |
|
|
723 { |
|
|
724 len = a.len; |
|
|
725 if (len > 0) |
|
|
726 { |
|
|
727 data = new Complex [len]; |
|
|
728 copy (data, a.data, len); |
|
|
729 } |
|
|
730 else |
|
|
731 data = (Complex *) NULL; |
|
|
732 } |
|
|
733 |
|
|
734 ComplexColumnVector::ComplexColumnVector (double a) |
|
|
735 { |
|
|
736 len = 1; |
|
|
737 data = new Complex [1]; |
|
|
738 data[0] = a; |
|
|
739 } |
|
|
740 |
|
161
|
741 ComplexColumnVector::ComplexColumnVector (const Complex& a) |
|
3
|
742 { |
|
|
743 len = 1; |
|
|
744 data = new Complex [1]; |
|
|
745 data[0] = Complex (a); |
|
|
746 } |
|
|
747 |
|
|
748 ComplexColumnVector& |
|
|
749 ComplexColumnVector::operator = (const ColumnVector& a) |
|
|
750 { |
|
|
751 delete [] data; |
|
|
752 len = a.len; |
|
|
753 if (len > 0) |
|
|
754 { |
|
|
755 data = new Complex [len]; |
|
|
756 copy (data, a.data, len); |
|
|
757 } |
|
|
758 else |
|
|
759 data = (Complex *) NULL; |
|
|
760 |
|
|
761 return *this; |
|
|
762 } |
|
|
763 |
|
|
764 ComplexColumnVector& |
|
|
765 ComplexColumnVector::operator = (const ComplexColumnVector& a) |
|
|
766 { |
|
|
767 if (this != &a) |
|
|
768 { |
|
|
769 delete [] data; |
|
|
770 len = a.len; |
|
|
771 if (len > 0) |
|
|
772 { |
|
|
773 data = new Complex [len]; |
|
|
774 copy (data, a.data, len); |
|
|
775 } |
|
|
776 else |
|
|
777 data = (Complex *) NULL; |
|
|
778 } |
|
|
779 return *this; |
|
|
780 } |
|
|
781 |
|
227
|
782 Complex& |
|
|
783 ComplexColumnVector::checkelem (int n) |
|
|
784 { |
|
|
785 #ifndef NO_RANGE_CHECK |
|
|
786 if (n < 0 || n >= len) |
|
|
787 { |
|
|
788 (*current_liboctave_error_handler) ("range error"); |
|
|
789 static Complex foo (0.0); |
|
|
790 return foo; |
|
|
791 } |
|
|
792 #endif |
|
|
793 |
|
|
794 return elem (n); |
|
|
795 } |
|
|
796 |
|
|
797 Complex |
|
|
798 ComplexColumnVector::checkelem (int n) const |
|
|
799 { |
|
|
800 #ifndef NO_RANGE_CHECK |
|
|
801 if (n < 0 || n >= len) |
|
|
802 { |
|
|
803 (*current_liboctave_error_handler) ("range error"); |
|
|
804 return Complex (0.0); |
|
|
805 } |
|
|
806 #endif |
|
|
807 |
|
|
808 return elem (n); |
|
|
809 } |
|
|
810 |
|
3
|
811 ComplexColumnVector& |
|
|
812 ComplexColumnVector::resize (int n) |
|
|
813 { |
|
|
814 if (n < 0) |
|
227
|
815 { |
|
|
816 (*current_liboctave_error_handler) |
|
|
817 ("can't resize to negative dimension"); |
|
|
818 return *this; |
|
|
819 } |
|
3
|
820 |
|
|
821 Complex *new_data = (Complex *) NULL; |
|
|
822 if (n > 0) |
|
|
823 { |
|
|
824 new_data = new Complex [n]; |
|
|
825 int min_len = len < n ? len : n; |
|
|
826 |
|
|
827 for (int i = 0; i < min_len; i++) |
|
|
828 new_data[i] = data[i]; |
|
|
829 } |
|
|
830 |
|
|
831 delete [] data; |
|
|
832 len = n; |
|
|
833 data = new_data; |
|
|
834 |
|
|
835 return *this; |
|
|
836 } |
|
|
837 |
|
|
838 ComplexColumnVector& |
|
|
839 ComplexColumnVector::resize (int n, double val) |
|
|
840 { |
|
|
841 int old_len = len; |
|
|
842 resize (n); |
|
|
843 for (int i = old_len; i < len; i++) |
|
|
844 data[i] = val; |
|
|
845 |
|
|
846 return *this; |
|
|
847 } |
|
|
848 |
|
|
849 ComplexColumnVector& |
|
161
|
850 ComplexColumnVector::resize (int n, const Complex& val) |
|
3
|
851 { |
|
|
852 int old_len = len; |
|
|
853 resize (n); |
|
|
854 for (int i = old_len; i < len; i++) |
|
|
855 data[i] = val; |
|
|
856 |
|
|
857 return *this; |
|
|
858 } |
|
|
859 |
|
|
860 int |
|
|
861 ComplexColumnVector::operator == (const ComplexColumnVector& a) const |
|
|
862 { |
|
|
863 if (len != a.len) |
|
|
864 return 0; |
|
|
865 return equal (data, a.data, len); |
|
|
866 } |
|
|
867 |
|
|
868 int |
|
|
869 ComplexColumnVector::operator != (const ComplexColumnVector& a) const |
|
|
870 { |
|
|
871 if (len != a.len) |
|
|
872 return 0; |
|
|
873 return !equal (data, a.data, len); |
|
|
874 } |
|
|
875 |
|
|
876 // destructive insert/delete/reorder operations |
|
|
877 |
|
|
878 ComplexColumnVector& |
|
|
879 ComplexColumnVector::insert (const ColumnVector& a, int r) |
|
|
880 { |
|
|
881 if (r < 0 || r + a.len - 1 > len) |
|
227
|
882 { |
|
|
883 (*current_liboctave_error_handler) ("range error for insert"); |
|
|
884 return *this; |
|
|
885 } |
|
3
|
886 |
|
|
887 for (int i = 0; i < a.len; i++) |
|
|
888 data[r+i] = a.data[i]; |
|
|
889 |
|
|
890 return *this; |
|
|
891 } |
|
|
892 |
|
|
893 ComplexColumnVector& |
|
|
894 ComplexColumnVector::insert (const ComplexColumnVector& a, int r) |
|
|
895 { |
|
|
896 if (r < 0 || r + a.len - 1 > len) |
|
227
|
897 { |
|
|
898 (*current_liboctave_error_handler) ("range error for insert"); |
|
|
899 return *this; |
|
|
900 } |
|
3
|
901 |
|
|
902 for (int i = 0; i < a.len; i++) |
|
|
903 data[r+i] = a.data[i]; |
|
|
904 |
|
|
905 return *this; |
|
|
906 } |
|
|
907 |
|
|
908 ComplexColumnVector& |
|
|
909 ComplexColumnVector::fill (double val) |
|
|
910 { |
|
|
911 if (len > 0) |
|
|
912 copy (data, len, val); |
|
|
913 return *this; |
|
|
914 } |
|
|
915 |
|
|
916 ComplexColumnVector& |
|
161
|
917 ComplexColumnVector::fill (const Complex& val) |
|
3
|
918 { |
|
|
919 if (len > 0) |
|
|
920 copy (data, len, val); |
|
|
921 return *this; |
|
|
922 } |
|
|
923 |
|
|
924 ComplexColumnVector& |
|
|
925 ComplexColumnVector::fill (double val, int r1, int r2) |
|
|
926 { |
|
|
927 if (r1 < 0 || r2 < 0 || r1 >= len || r2 >= len) |
|
227
|
928 { |
|
|
929 (*current_liboctave_error_handler) ("range error for fill"); |
|
|
930 return *this; |
|
|
931 } |
|
3
|
932 |
|
|
933 if (r1 > r2) { int tmp = r1; r1 = r2; r2 = tmp; } |
|
|
934 |
|
|
935 for (int i = r1; i <= r2; i++) |
|
|
936 data[i] = val; |
|
|
937 |
|
|
938 return *this; |
|
|
939 } |
|
|
940 |
|
|
941 ComplexColumnVector& |
|
161
|
942 ComplexColumnVector::fill (const Complex& val, int r1, int r2) |
|
3
|
943 { |
|
|
944 if (r1 < 0 || r2 < 0 || r1 >= len || r2 >= len) |
|
227
|
945 { |
|
|
946 (*current_liboctave_error_handler) ("range error for fill"); |
|
|
947 return *this; |
|
|
948 } |
|
3
|
949 |
|
|
950 if (r1 > r2) { int tmp = r1; r1 = r2; r2 = tmp; } |
|
|
951 |
|
|
952 for (int i = r1; i <= r2; i++) |
|
|
953 data[i] = val; |
|
|
954 |
|
|
955 return *this; |
|
|
956 } |
|
|
957 |
|
|
958 ComplexColumnVector |
|
|
959 ComplexColumnVector::stack (const ColumnVector& a) const |
|
|
960 { |
|
|
961 int nr_insert = len; |
|
|
962 ComplexColumnVector retval (len + a.len); |
|
|
963 retval.insert (*this, 0); |
|
|
964 retval.insert (a, nr_insert); |
|
|
965 return retval; |
|
|
966 } |
|
|
967 |
|
|
968 ComplexColumnVector |
|
|
969 ComplexColumnVector::stack (const ComplexColumnVector& a) const |
|
|
970 { |
|
|
971 int nr_insert = len; |
|
|
972 ComplexColumnVector retval (len + a.len); |
|
|
973 retval.insert (*this, 0); |
|
|
974 retval.insert (a, nr_insert); |
|
|
975 return retval; |
|
|
976 } |
|
|
977 |
|
|
978 ComplexRowVector |
|
|
979 ComplexColumnVector::hermitian (void) const |
|
|
980 { |
|
|
981 return ComplexRowVector (conj_dup (data, len), len); |
|
|
982 } |
|
|
983 |
|
|
984 ComplexRowVector |
|
|
985 ComplexColumnVector::transpose (void) const |
|
|
986 { |
|
|
987 return ComplexRowVector (dup (data, len), len); |
|
|
988 } |
|
|
989 |
|
|
990 ColumnVector |
|
|
991 real (const ComplexColumnVector& a) |
|
|
992 { |
|
|
993 ColumnVector retval; |
|
|
994 if (a.len > 0) |
|
|
995 retval = ColumnVector (real_dup (a.data, a.len), a.len); |
|
|
996 return retval; |
|
|
997 } |
|
|
998 |
|
|
999 ColumnVector |
|
|
1000 imag (const ComplexColumnVector& a) |
|
|
1001 { |
|
|
1002 ColumnVector retval; |
|
|
1003 if (a.len > 0) |
|
|
1004 retval = ColumnVector (imag_dup (a.data, a.len), a.len); |
|
|
1005 return retval; |
|
|
1006 } |
|
|
1007 |
|
|
1008 ComplexColumnVector |
|
|
1009 conj (const ComplexColumnVector& a) |
|
|
1010 { |
|
|
1011 ComplexColumnVector retval; |
|
|
1012 if (a.len > 0) |
|
|
1013 retval = ComplexColumnVector (conj_dup (a.data, a.len), a.len); |
|
|
1014 return retval; |
|
|
1015 } |
|
|
1016 |
|
|
1017 // resize is the destructive equivalent for this one |
|
|
1018 |
|
|
1019 ComplexColumnVector |
|
|
1020 ComplexColumnVector::extract (int r1, int r2) const |
|
|
1021 { |
|
|
1022 if (r1 > r2) { int tmp = r1; r1 = r2; r2 = tmp; } |
|
|
1023 |
|
|
1024 int new_r = r2 - r1 + 1; |
|
|
1025 |
|
|
1026 ComplexColumnVector result (new_r); |
|
|
1027 |
|
|
1028 for (int i = 0; i < new_r; i++) |
|
|
1029 result.data[i] = elem (r1+i); |
|
|
1030 |
|
|
1031 return result; |
|
|
1032 } |
|
|
1033 |
|
|
1034 // column vector by scalar -> column vector operations |
|
|
1035 |
|
|
1036 ComplexColumnVector |
|
|
1037 ComplexColumnVector::operator + (double s) const |
|
|
1038 { |
|
|
1039 return ComplexColumnVector (add (data, len, s), len); |
|
|
1040 } |
|
|
1041 |
|
|
1042 ComplexColumnVector |
|
|
1043 ComplexColumnVector::operator - (double s) const |
|
|
1044 { |
|
|
1045 return ComplexColumnVector (subtract (data, len, s), len); |
|
|
1046 } |
|
|
1047 |
|
|
1048 ComplexColumnVector |
|
|
1049 ComplexColumnVector::operator * (double s) const |
|
|
1050 { |
|
|
1051 return ComplexColumnVector (multiply (data, len, s), len); |
|
|
1052 } |
|
|
1053 |
|
|
1054 ComplexColumnVector |
|
|
1055 ComplexColumnVector::operator / (double s) const |
|
|
1056 { |
|
|
1057 return ComplexColumnVector (divide (data, len, s), len); |
|
|
1058 } |
|
|
1059 |
|
|
1060 ComplexColumnVector |
|
161
|
1061 ComplexColumnVector::operator + (const Complex& s) const |
|
3
|
1062 { |
|
|
1063 return ComplexColumnVector (add (data, len, s), len); |
|
|
1064 } |
|
|
1065 |
|
|
1066 ComplexColumnVector |
|
161
|
1067 ComplexColumnVector::operator - (const Complex& s) const |
|
3
|
1068 { |
|
|
1069 return ComplexColumnVector (subtract (data, len, s), len); |
|
|
1070 } |
|
|
1071 |
|
|
1072 ComplexColumnVector |
|
161
|
1073 ComplexColumnVector::operator * (const Complex& s) const |
|
3
|
1074 { |
|
|
1075 return ComplexColumnVector (multiply (data, len, s), len); |
|
|
1076 } |
|
|
1077 |
|
|
1078 ComplexColumnVector |
|
161
|
1079 ComplexColumnVector::operator / (const Complex& s) const |
|
3
|
1080 { |
|
|
1081 return ComplexColumnVector (divide (data, len, s), len); |
|
|
1082 } |
|
|
1083 |
|
|
1084 // scalar by column vector -> column vector operations |
|
|
1085 |
|
|
1086 ComplexColumnVector |
|
|
1087 operator + (double s, const ComplexColumnVector& a) |
|
|
1088 { |
|
|
1089 return ComplexColumnVector (add (a.data, a.len, s), a.len); |
|
|
1090 } |
|
|
1091 |
|
|
1092 ComplexColumnVector |
|
|
1093 operator - (double s, const ComplexColumnVector& a) |
|
|
1094 { |
|
|
1095 return ComplexColumnVector (subtract (s, a.data, a.len), a.len); |
|
|
1096 } |
|
|
1097 |
|
|
1098 ComplexColumnVector |
|
|
1099 operator * (double s, const ComplexColumnVector& a) |
|
|
1100 { |
|
|
1101 return ComplexColumnVector (multiply (a.data, a.len, s), a.len); |
|
|
1102 } |
|
|
1103 |
|
|
1104 ComplexColumnVector |
|
|
1105 operator / (double s, const ComplexColumnVector& a) |
|
|
1106 { |
|
|
1107 return ComplexColumnVector (divide (s, a.data, a.len), a.len); |
|
|
1108 } |
|
|
1109 |
|
|
1110 ComplexColumnVector |
|
161
|
1111 operator + (const Complex& s, const ComplexColumnVector& a) |
|
3
|
1112 { |
|
|
1113 return ComplexColumnVector (add (a.data, a.len, s), a.len); |
|
|
1114 } |
|
|
1115 |
|
|
1116 ComplexColumnVector |
|
161
|
1117 operator - (const Complex& s, const ComplexColumnVector& a) |
|
3
|
1118 { |
|
|
1119 return ComplexColumnVector (subtract (s, a.data, a.len), a.len); |
|
|
1120 } |
|
|
1121 |
|
|
1122 ComplexColumnVector |
|
161
|
1123 operator * (const Complex& s, const ComplexColumnVector& a) |
|
3
|
1124 { |
|
|
1125 return ComplexColumnVector (multiply (a.data, a.len, s), a.len); |
|
|
1126 } |
|
|
1127 |
|
|
1128 ComplexColumnVector |
|
161
|
1129 operator / (const Complex& s, const ComplexColumnVector& a) |
|
3
|
1130 { |
|
|
1131 return ComplexColumnVector (divide (s, a.data, a.len), a.len); |
|
|
1132 } |
|
|
1133 |
|
|
1134 // column vector by row vector -> matrix operations |
|
|
1135 |
|
|
1136 ComplexMatrix |
|
|
1137 ComplexColumnVector::operator * (const RowVector& a) const |
|
|
1138 { |
|
|
1139 ComplexRowVector tmp (a); |
|
|
1140 return *this * tmp; |
|
|
1141 } |
|
|
1142 |
|
|
1143 ComplexMatrix |
|
|
1144 ComplexColumnVector::operator * (const ComplexRowVector& a) const |
|
|
1145 { |
|
|
1146 if (len != a.len) |
|
227
|
1147 { |
|
|
1148 (*current_liboctave_error_handler) |
|
|
1149 ("nonconformant vector multiplication attempted"); |
|
|
1150 return ComplexMatrix (); |
|
|
1151 } |
|
3
|
1152 |
|
|
1153 if (len == 0) |
|
|
1154 return ComplexMatrix (len, len, 0.0); |
|
|
1155 |
|
|
1156 char transa = 'N'; |
|
|
1157 char transb = 'N'; |
|
|
1158 Complex alpha (1.0); |
|
|
1159 Complex beta (0.0); |
|
|
1160 int anr = 1; |
|
|
1161 int anc = a.len; |
|
|
1162 |
|
|
1163 Complex *c = new Complex [len * a.len]; |
|
|
1164 |
|
|
1165 F77_FCN (zgemm) (&transa, &transb, &len, &anc, &anr, &alpha, data, |
|
|
1166 &len, a.data, &anr, &beta, c, &len, 1L, 1L); |
|
|
1167 |
|
|
1168 return ComplexMatrix (c, len, a.len); |
|
|
1169 } |
|
|
1170 |
|
|
1171 // column vector by column vector -> column vector operations |
|
|
1172 |
|
|
1173 ComplexColumnVector |
|
|
1174 ComplexColumnVector::operator + (const ColumnVector& a) const |
|
|
1175 { |
|
|
1176 if (len != a.len) |
|
227
|
1177 { |
|
|
1178 (*current_liboctave_error_handler) |
|
|
1179 ("nonconformant vector addition attempted"); |
|
|
1180 return ComplexColumnVector (); |
|
|
1181 } |
|
3
|
1182 |
|
|
1183 if (len == 0) |
|
|
1184 return ComplexColumnVector (0); |
|
|
1185 |
|
|
1186 return ComplexColumnVector (add (data, a.data, len), len); |
|
|
1187 } |
|
|
1188 |
|
|
1189 ComplexColumnVector |
|
|
1190 ComplexColumnVector::operator - (const ColumnVector& a) const |
|
|
1191 { |
|
|
1192 if (len != a.len) |
|
227
|
1193 { |
|
|
1194 (*current_liboctave_error_handler) |
|
|
1195 ("nonconformant vector subtraction attempted"); |
|
|
1196 return ComplexColumnVector (); |
|
|
1197 } |
|
3
|
1198 |
|
|
1199 if (len == 0) |
|
|
1200 return ComplexColumnVector (0); |
|
|
1201 |
|
|
1202 return ComplexColumnVector (subtract (data, a.data, len), len); |
|
|
1203 } |
|
|
1204 |
|
|
1205 ComplexColumnVector |
|
|
1206 ComplexColumnVector::operator + (const ComplexColumnVector& a) const |
|
|
1207 { |
|
|
1208 if (len != a.len) |
|
227
|
1209 { |
|
|
1210 (*current_liboctave_error_handler) |
|
|
1211 ("nonconformant vector addition attempted"); |
|
|
1212 return ComplexColumnVector (); |
|
|
1213 } |
|
3
|
1214 |
|
|
1215 if (len == 0) |
|
|
1216 return ComplexColumnVector (0); |
|
|
1217 |
|
|
1218 return ComplexColumnVector (add (data, a.data, len), len); |
|
|
1219 } |
|
|
1220 |
|
|
1221 ComplexColumnVector |
|
|
1222 ComplexColumnVector::operator - (const ComplexColumnVector& a) const |
|
|
1223 { |
|
|
1224 if (len != a.len) |
|
227
|
1225 { |
|
|
1226 (*current_liboctave_error_handler) |
|
|
1227 ("nonconformant vector subtraction attempted"); |
|
|
1228 return ComplexColumnVector (); |
|
|
1229 } |
|
3
|
1230 |
|
|
1231 if (len == 0) |
|
|
1232 return ComplexColumnVector (0); |
|
|
1233 |
|
|
1234 return ComplexColumnVector (subtract (data, a.data, len), len); |
|
|
1235 } |
|
|
1236 |
|
|
1237 ComplexColumnVector |
|
|
1238 ComplexColumnVector::product (const ColumnVector& a) const |
|
|
1239 { |
|
|
1240 if (len != a.len) |
|
227
|
1241 { |
|
|
1242 (*current_liboctave_error_handler) |
|
|
1243 ("nonconformant vector product attempted"); |
|
|
1244 return ComplexColumnVector (); |
|
|
1245 } |
|
3
|
1246 |
|
|
1247 if (len == 0) |
|
|
1248 return ComplexColumnVector (0); |
|
|
1249 |
|
|
1250 return ComplexColumnVector (multiply (data, a.data, len), len); |
|
|
1251 } |
|
|
1252 |
|
|
1253 ComplexColumnVector |
|
|
1254 ComplexColumnVector::quotient (const ColumnVector& a) const |
|
|
1255 { |
|
|
1256 if (len != a.len) |
|
227
|
1257 { |
|
|
1258 (*current_liboctave_error_handler) |
|
|
1259 ("nonconformant vector quotient attempted"); |
|
|
1260 return ComplexColumnVector (); |
|
|
1261 } |
|
3
|
1262 |
|
|
1263 if (len == 0) |
|
|
1264 return ComplexColumnVector (0); |
|
|
1265 |
|
|
1266 return ComplexColumnVector (divide (data, a.data, len), len); |
|
|
1267 } |
|
|
1268 |
|
|
1269 ComplexColumnVector |
|
|
1270 ComplexColumnVector::product (const ComplexColumnVector& a) const |
|
|
1271 { |
|
|
1272 if (len != a.len) |
|
227
|
1273 { |
|
|
1274 (*current_liboctave_error_handler) |
|
|
1275 ("nonconformant vector product attempted"); |
|
|
1276 return ComplexColumnVector (); |
|
|
1277 } |
|
3
|
1278 |
|
|
1279 if (len == 0) |
|
|
1280 return ComplexColumnVector (0); |
|
|
1281 |
|
|
1282 return ComplexColumnVector (multiply (data, a.data, len), len); |
|
|
1283 } |
|
|
1284 |
|
|
1285 ComplexColumnVector |
|
|
1286 ComplexColumnVector::quotient (const ComplexColumnVector& a) const |
|
|
1287 { |
|
|
1288 if (len != a.len) |
|
227
|
1289 { |
|
|
1290 (*current_liboctave_error_handler) |
|
|
1291 ("nonconformant vector quotient attempted"); |
|
|
1292 return ComplexColumnVector (); |
|
|
1293 } |
|
3
|
1294 |
|
|
1295 if (len == 0) |
|
|
1296 return ComplexColumnVector (0); |
|
|
1297 |
|
|
1298 return ComplexColumnVector (divide (data, a.data, len), len); |
|
|
1299 } |
|
|
1300 |
|
|
1301 ComplexColumnVector& |
|
|
1302 ComplexColumnVector::operator += (const ColumnVector& a) |
|
|
1303 { |
|
|
1304 if (len != a.len) |
|
227
|
1305 { |
|
|
1306 (*current_liboctave_error_handler) |
|
|
1307 ("nonconformant vector += operation attempted"); |
|
|
1308 return *this; |
|
|
1309 } |
|
3
|
1310 |
|
|
1311 if (len == 0) |
|
|
1312 return *this; |
|
|
1313 |
|
|
1314 add2 (data, a.data, len); |
|
|
1315 return *this; |
|
|
1316 } |
|
|
1317 |
|
|
1318 ComplexColumnVector& |
|
|
1319 ComplexColumnVector::operator -= (const ColumnVector& a) |
|
|
1320 { |
|
|
1321 if (len != a.len) |
|
227
|
1322 { |
|
|
1323 (*current_liboctave_error_handler) |
|
|
1324 ("nonconformant vector -= operation attempted"); |
|
|
1325 return *this; |
|
|
1326 } |
|
3
|
1327 |
|
|
1328 if (len == 0) |
|
|
1329 return *this; |
|
|
1330 |
|
|
1331 subtract2 (data, a.data, len); |
|
|
1332 return *this; |
|
|
1333 } |
|
|
1334 |
|
|
1335 ComplexColumnVector& |
|
|
1336 ComplexColumnVector::operator += (const ComplexColumnVector& a) |
|
|
1337 { |
|
|
1338 if (len != a.len) |
|
227
|
1339 { |
|
|
1340 (*current_liboctave_error_handler) |
|
|
1341 ("nonconformant vector += operation attempted"); |
|
|
1342 return *this; |
|
|
1343 } |
|
3
|
1344 |
|
|
1345 if (len == 0) |
|
|
1346 return *this; |
|
|
1347 |
|
|
1348 add2 (data, a.data, len); |
|
|
1349 return *this; |
|
|
1350 } |
|
|
1351 |
|
|
1352 ComplexColumnVector& |
|
|
1353 ComplexColumnVector::operator -= (const ComplexColumnVector& a) |
|
|
1354 { |
|
|
1355 if (len != a.len) |
|
227
|
1356 { |
|
|
1357 (*current_liboctave_error_handler) |
|
|
1358 ("nonconformant vector -= operation attempted"); |
|
|
1359 return *this; |
|
|
1360 } |
|
3
|
1361 |
|
|
1362 if (len == 0) |
|
|
1363 return *this; |
|
|
1364 |
|
|
1365 subtract2 (data, a.data, len); |
|
|
1366 return *this; |
|
|
1367 } |
|
|
1368 |
|
|
1369 // unary operations |
|
|
1370 |
|
|
1371 ComplexColumnVector |
|
|
1372 ComplexColumnVector::operator - (void) const |
|
|
1373 { |
|
|
1374 if (len == 0) |
|
|
1375 return ComplexColumnVector (0); |
|
|
1376 |
|
|
1377 return ComplexColumnVector (negate (data, len), len); |
|
|
1378 } |
|
|
1379 |
|
|
1380 ComplexColumnVector |
|
|
1381 map (c_c_Mapper f, const ComplexColumnVector& a) |
|
|
1382 { |
|
|
1383 ComplexColumnVector b (a); |
|
|
1384 b.map (f); |
|
|
1385 return b; |
|
|
1386 } |
|
|
1387 |
|
|
1388 ColumnVector |
|
|
1389 map (d_c_Mapper f, const ComplexColumnVector& a) |
|
|
1390 { |
|
|
1391 ColumnVector b (a.len); |
|
|
1392 for (int i = 0; i < a.len; i++) |
|
|
1393 b.elem (i) = f (a.elem (i)); |
|
|
1394 return b; |
|
|
1395 } |
|
|
1396 |
|
|
1397 void |
|
|
1398 ComplexColumnVector::map (c_c_Mapper f) |
|
|
1399 { |
|
|
1400 for (int i = 0; i < len; i++) |
|
|
1401 data[i] = f (data[i]); |
|
|
1402 } |
|
|
1403 |
|
|
1404 Complex |
|
|
1405 ComplexColumnVector::min (void) const |
|
|
1406 { |
|
|
1407 if (len == 0) |
|
|
1408 return 0.0; |
|
|
1409 |
|
|
1410 Complex res = data[0]; |
|
|
1411 double absres = abs (res); |
|
|
1412 |
|
|
1413 for (int i = 1; i < len; i++) |
|
|
1414 if (abs (data[i]) < absres) |
|
|
1415 { |
|
|
1416 res = data[i]; |
|
|
1417 absres = abs (res); |
|
|
1418 } |
|
|
1419 |
|
|
1420 return res; |
|
|
1421 } |
|
|
1422 |
|
|
1423 Complex |
|
|
1424 ComplexColumnVector::max (void) const |
|
|
1425 { |
|
|
1426 if (len == 0) |
|
|
1427 return 0.0; |
|
|
1428 |
|
|
1429 Complex res = data[0]; |
|
|
1430 double absres = abs (res); |
|
|
1431 |
|
|
1432 for (int i = 1; i < len; i++) |
|
|
1433 if (abs (data[i]) > absres) |
|
|
1434 { |
|
|
1435 res = data[i]; |
|
|
1436 absres = abs (res); |
|
|
1437 } |
|
|
1438 |
|
|
1439 return res; |
|
|
1440 } |
|
|
1441 |
|
|
1442 // i/o |
|
|
1443 |
|
|
1444 ostream& |
|
|
1445 operator << (ostream& os, const ComplexColumnVector& a) |
|
|
1446 { |
|
|
1447 // int field_width = os.precision () + 7; |
|
|
1448 for (int i = 0; i < a.len; i++) |
|
|
1449 os << /* setw (field_width) << */ a.data[i] << "\n"; |
|
|
1450 return os; |
|
|
1451 } |
|
|
1452 |
|
|
1453 /* |
|
|
1454 ;;; Local Variables: *** |
|
|
1455 ;;; mode: C++ *** |
|
|
1456 ;;; page-delimiter: "^/\\*" *** |
|
|
1457 ;;; End: *** |
|
|
1458 */ |
