Mercurial > octave
annotate liboctave/CColVector.cc @ 7503:8c32f95c2639
convert mapper functions to new format
author | David Bateman <dbateman@free.fr> |
---|---|
date | Wed, 20 Feb 2008 04:22:50 -0500 |
parents | 29980c6b8604 |
children | 82be108cc558 |
rev | line source |
---|---|
1993 | 1 // ColumnVector manipulations. |
458 | 2 /* |
3 | |
7017 | 4 Copyright (C) 1994, 1995, 1996, 1997, 2000, 2001, 2002, 2003, 2004, |
5 2005, 2007 John W. Eaton | |
458 | 6 |
7 This file is part of Octave. | |
8 | |
9 Octave is free software; you can redistribute it and/or modify it | |
10 under the terms of the GNU General Public License as published by the | |
7016 | 11 Free Software Foundation; either version 3 of the License, or (at your |
12 option) any later version. | |
458 | 13 |
14 Octave is distributed in the hope that it will be useful, but WITHOUT | |
15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
17 for more details. | |
18 | |
19 You should have received a copy of the GNU General Public License | |
7016 | 20 along with Octave; see the file COPYING. If not, see |
21 <http://www.gnu.org/licenses/>. | |
458 | 22 |
23 */ | |
24 | |
25 #ifdef HAVE_CONFIG_H | |
1192 | 26 #include <config.h> |
458 | 27 #endif |
28 | |
3503 | 29 #include <iostream> |
458 | 30 |
4669 | 31 #include "Array-util.h" |
1847 | 32 #include "f77-fcn.h" |
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7482
diff
changeset
|
33 #include "functor.h" |
1368 | 34 #include "lo-error.h" |
458 | 35 #include "mx-base.h" |
36 #include "mx-inlines.cc" | |
1650 | 37 #include "oct-cmplx.h" |
458 | 38 |
39 // Fortran functions we call. | |
40 | |
41 extern "C" | |
42 { | |
4552 | 43 F77_RET_T |
44 F77_FUNC (zgemv, ZGEMV) (F77_CONST_CHAR_ARG_DECL, | |
5275 | 45 const octave_idx_type&, const octave_idx_type&, const Complex&, |
46 const Complex*, const octave_idx_type&, const Complex*, | |
47 const octave_idx_type&, const Complex&, Complex*, const octave_idx_type& | |
4552 | 48 F77_CHAR_ARG_LEN_DECL); |
458 | 49 } |
50 | |
1360 | 51 // Complex Column Vector class |
458 | 52 |
53 ComplexColumnVector::ComplexColumnVector (const ColumnVector& a) | |
1214 | 54 : MArray<Complex> (a.length ()) |
458 | 55 { |
5275 | 56 for (octave_idx_type i = 0; i < length (); i++) |
458 | 57 elem (i) = a.elem (i); |
58 } | |
59 | |
2386 | 60 bool |
458 | 61 ComplexColumnVector::operator == (const ComplexColumnVector& a) const |
62 { | |
5275 | 63 octave_idx_type len = length (); |
458 | 64 if (len != a.length ()) |
65 return 0; | |
3769 | 66 return mx_inline_equal (data (), a.data (), len); |
458 | 67 } |
68 | |
2386 | 69 bool |
458 | 70 ComplexColumnVector::operator != (const ComplexColumnVector& a) const |
71 { | |
72 return !(*this == a); | |
73 } | |
74 | |
75 // destructive insert/delete/reorder operations | |
76 | |
77 ComplexColumnVector& | |
5275 | 78 ComplexColumnVector::insert (const ColumnVector& a, octave_idx_type r) |
458 | 79 { |
5275 | 80 octave_idx_type a_len = a.length (); |
4316 | 81 |
1699 | 82 if (r < 0 || r + a_len > length ()) |
458 | 83 { |
84 (*current_liboctave_error_handler) ("range error for insert"); | |
85 return *this; | |
86 } | |
87 | |
4316 | 88 if (a_len > 0) |
89 { | |
90 make_unique (); | |
91 | |
5275 | 92 for (octave_idx_type i = 0; i < a_len; i++) |
4316 | 93 xelem (r+i) = a.elem (i); |
94 } | |
458 | 95 |
96 return *this; | |
97 } | |
98 | |
99 ComplexColumnVector& | |
5275 | 100 ComplexColumnVector::insert (const ComplexColumnVector& a, octave_idx_type r) |
458 | 101 { |
5275 | 102 octave_idx_type a_len = a.length (); |
4316 | 103 |
1699 | 104 if (r < 0 || r + a_len > length ()) |
458 | 105 { |
106 (*current_liboctave_error_handler) ("range error for insert"); | |
107 return *this; | |
108 } | |
109 | |
4316 | 110 if (a_len > 0) |
111 { | |
112 make_unique (); | |
113 | |
5275 | 114 for (octave_idx_type i = 0; i < a_len; i++) |
4316 | 115 xelem (r+i) = a.elem (i); |
116 } | |
458 | 117 |
118 return *this; | |
119 } | |
120 | |
121 ComplexColumnVector& | |
122 ComplexColumnVector::fill (double val) | |
123 { | |
5275 | 124 octave_idx_type len = length (); |
4316 | 125 |
458 | 126 if (len > 0) |
4316 | 127 { |
128 make_unique (); | |
129 | |
5275 | 130 for (octave_idx_type i = 0; i < len; i++) |
4316 | 131 xelem (i) = val; |
132 } | |
133 | |
458 | 134 return *this; |
135 } | |
136 | |
137 ComplexColumnVector& | |
138 ComplexColumnVector::fill (const Complex& val) | |
139 { | |
5275 | 140 octave_idx_type len = length (); |
4316 | 141 |
458 | 142 if (len > 0) |
4316 | 143 { |
144 make_unique (); | |
145 | |
5275 | 146 for (octave_idx_type i = 0; i < len; i++) |
4316 | 147 xelem (i) = val; |
148 } | |
149 | |
150 | |
458 | 151 return *this; |
152 } | |
153 | |
154 ComplexColumnVector& | |
5275 | 155 ComplexColumnVector::fill (double val, octave_idx_type r1, octave_idx_type r2) |
458 | 156 { |
5275 | 157 octave_idx_type len = length (); |
4316 | 158 |
458 | 159 if (r1 < 0 || r2 < 0 || r1 >= len || r2 >= len) |
160 { | |
161 (*current_liboctave_error_handler) ("range error for fill"); | |
162 return *this; | |
163 } | |
164 | |
5275 | 165 if (r1 > r2) { octave_idx_type tmp = r1; r1 = r2; r2 = tmp; } |
458 | 166 |
4316 | 167 if (r2 >= r1) |
168 { | |
169 make_unique (); | |
170 | |
5275 | 171 for (octave_idx_type i = r1; i <= r2; i++) |
4316 | 172 xelem (i) = val; |
173 } | |
458 | 174 |
175 return *this; | |
176 } | |
177 | |
178 ComplexColumnVector& | |
5275 | 179 ComplexColumnVector::fill (const Complex& val, octave_idx_type r1, octave_idx_type r2) |
458 | 180 { |
5275 | 181 octave_idx_type len = length (); |
4316 | 182 |
458 | 183 if (r1 < 0 || r2 < 0 || r1 >= len || r2 >= len) |
184 { | |
185 (*current_liboctave_error_handler) ("range error for fill"); | |
186 return *this; | |
187 } | |
188 | |
5275 | 189 if (r1 > r2) { octave_idx_type tmp = r1; r1 = r2; r2 = tmp; } |
458 | 190 |
4316 | 191 if (r2 >= r1) |
192 { | |
193 make_unique (); | |
194 | |
5275 | 195 for (octave_idx_type i = r1; i <= r2; i++) |
4316 | 196 xelem (i) = val; |
197 } | |
458 | 198 |
199 return *this; | |
200 } | |
201 | |
202 ComplexColumnVector | |
203 ComplexColumnVector::stack (const ColumnVector& a) const | |
204 { | |
5275 | 205 octave_idx_type len = length (); |
206 octave_idx_type nr_insert = len; | |
458 | 207 ComplexColumnVector retval (len + a.length ()); |
208 retval.insert (*this, 0); | |
209 retval.insert (a, nr_insert); | |
210 return retval; | |
211 } | |
212 | |
213 ComplexColumnVector | |
214 ComplexColumnVector::stack (const ComplexColumnVector& a) const | |
215 { | |
5275 | 216 octave_idx_type len = length (); |
217 octave_idx_type nr_insert = len; | |
458 | 218 ComplexColumnVector retval (len + a.length ()); |
219 retval.insert (*this, 0); | |
220 retval.insert (a, nr_insert); | |
221 return retval; | |
222 } | |
223 | |
224 ComplexRowVector | |
225 ComplexColumnVector::hermitian (void) const | |
226 { | |
5275 | 227 octave_idx_type len = length (); |
3769 | 228 return ComplexRowVector (mx_inline_conj_dup (data (), len), len); |
458 | 229 } |
230 | |
231 ComplexRowVector | |
232 ComplexColumnVector::transpose (void) const | |
233 { | |
1858 | 234 return ComplexRowVector (*this); |
458 | 235 } |
236 | |
237 ComplexColumnVector | |
238 conj (const ComplexColumnVector& a) | |
239 { | |
5275 | 240 octave_idx_type a_len = a.length (); |
458 | 241 ComplexColumnVector retval; |
242 if (a_len > 0) | |
3769 | 243 retval = ComplexColumnVector (mx_inline_conj_dup (a.data (), a_len), a_len); |
458 | 244 return retval; |
245 } | |
246 | |
247 // resize is the destructive equivalent for this one | |
248 | |
249 ComplexColumnVector | |
5275 | 250 ComplexColumnVector::extract (octave_idx_type r1, octave_idx_type r2) const |
458 | 251 { |
5275 | 252 if (r1 > r2) { octave_idx_type tmp = r1; r1 = r2; r2 = tmp; } |
458 | 253 |
5275 | 254 octave_idx_type new_r = r2 - r1 + 1; |
458 | 255 |
256 ComplexColumnVector result (new_r); | |
257 | |
5275 | 258 for (octave_idx_type i = 0; i < new_r; i++) |
458 | 259 result.elem (i) = elem (r1+i); |
260 | |
261 return result; | |
262 } | |
263 | |
4316 | 264 ComplexColumnVector |
5275 | 265 ComplexColumnVector::extract_n (octave_idx_type r1, octave_idx_type n) const |
4316 | 266 { |
267 ComplexColumnVector result (n); | |
268 | |
5275 | 269 for (octave_idx_type i = 0; i < n; i++) |
4316 | 270 result.elem (i) = elem (r1+i); |
271 | |
272 return result; | |
273 } | |
274 | |
458 | 275 // column vector by column vector -> column vector operations |
276 | |
277 ComplexColumnVector& | |
278 ComplexColumnVector::operator += (const ColumnVector& a) | |
279 { | |
5275 | 280 octave_idx_type len = length (); |
2386 | 281 |
5275 | 282 octave_idx_type a_len = a.length (); |
2386 | 283 |
284 if (len != a_len) | |
458 | 285 { |
2386 | 286 gripe_nonconformant ("operator +=", len, a_len); |
458 | 287 return *this; |
288 } | |
289 | |
290 if (len == 0) | |
291 return *this; | |
292 | |
293 Complex *d = fortran_vec (); // Ensures only one reference to my privates! | |
294 | |
3769 | 295 mx_inline_add2 (d, a.data (), len); |
458 | 296 return *this; |
297 } | |
298 | |
299 ComplexColumnVector& | |
300 ComplexColumnVector::operator -= (const ColumnVector& a) | |
301 { | |
5275 | 302 octave_idx_type len = length (); |
2386 | 303 |
5275 | 304 octave_idx_type a_len = a.length (); |
2386 | 305 |
306 if (len != a_len) | |
458 | 307 { |
2386 | 308 gripe_nonconformant ("operator -=", len, a_len); |
458 | 309 return *this; |
310 } | |
311 | |
312 if (len == 0) | |
313 return *this; | |
314 | |
315 Complex *d = fortran_vec (); // Ensures only one reference to my privates! | |
316 | |
3769 | 317 mx_inline_subtract2 (d, a.data (), len); |
458 | 318 return *this; |
319 } | |
320 | |
1205 | 321 // matrix by column vector -> column vector operations |
322 | |
323 ComplexColumnVector | |
324 operator * (const ComplexMatrix& m, const ColumnVector& a) | |
325 { | |
326 ComplexColumnVector tmp (a); | |
327 return m * tmp; | |
328 } | |
329 | |
330 ComplexColumnVector | |
331 operator * (const ComplexMatrix& m, const ComplexColumnVector& a) | |
332 { | |
1947 | 333 ComplexColumnVector retval; |
334 | |
5275 | 335 octave_idx_type nr = m.rows (); |
336 octave_idx_type nc = m.cols (); | |
1947 | 337 |
5275 | 338 octave_idx_type a_len = a.length (); |
2386 | 339 |
340 if (nc != a_len) | |
341 gripe_nonconformant ("operator *", nr, nc, a_len, 1); | |
1947 | 342 else |
458 | 343 { |
1947 | 344 if (nc == 0 || nr == 0) |
345 retval.resize (nr, 0.0); | |
346 else | |
347 { | |
5275 | 348 octave_idx_type ld = nr; |
1947 | 349 |
350 retval.resize (nr); | |
351 Complex *y = retval.fortran_vec (); | |
352 | |
4552 | 353 F77_XFCN (zgemv, ZGEMV, (F77_CONST_CHAR_ARG2 ("N", 1), |
354 nr, nc, 1.0, m.data (), ld, | |
355 a.data (), 1, 0.0, y, 1 | |
356 F77_CHAR_ARG_LEN (1))); | |
1947 | 357 } |
458 | 358 } |
359 | |
1947 | 360 return retval; |
458 | 361 } |
362 | |
1205 | 363 // matrix by column vector -> column vector operations |
364 | |
365 ComplexColumnVector | |
366 operator * (const Matrix& m, const ComplexColumnVector& a) | |
367 { | |
368 ComplexMatrix tmp (m); | |
369 return tmp * a; | |
370 } | |
371 | |
372 // diagonal matrix by column vector -> column vector operations | |
373 | |
374 ComplexColumnVector | |
375 operator * (const DiagMatrix& m, const ComplexColumnVector& a) | |
376 { | |
5275 | 377 octave_idx_type nr = m.rows (); |
378 octave_idx_type nc = m.cols (); | |
2386 | 379 |
5275 | 380 octave_idx_type a_len = a.length (); |
2386 | 381 |
1205 | 382 if (nc != a_len) |
383 { | |
2386 | 384 gripe_nonconformant ("operator *", nr, nc, a_len, 1); |
3585 | 385 return ComplexColumnVector (); |
1205 | 386 } |
387 | |
388 if (nc == 0 || nr == 0) | |
389 return ComplexColumnVector (0); | |
390 | |
391 ComplexColumnVector result (nr); | |
392 | |
5275 | 393 for (octave_idx_type i = 0; i < a_len; i++) |
1205 | 394 result.elem (i) = a.elem (i) * m.elem (i, i); |
395 | |
5275 | 396 for (octave_idx_type i = a_len; i < nr; i++) |
1205 | 397 result.elem (i) = 0.0; |
398 | |
399 return result; | |
400 } | |
401 | |
402 ComplexColumnVector | |
403 operator * (const ComplexDiagMatrix& m, const ColumnVector& a) | |
404 { | |
5275 | 405 octave_idx_type nr = m.rows (); |
406 octave_idx_type nc = m.cols (); | |
2386 | 407 |
5275 | 408 octave_idx_type a_len = a.length (); |
2386 | 409 |
1205 | 410 if (nc != a_len) |
411 { | |
2386 | 412 gripe_nonconformant ("operator *", nr, nc, a_len, 1); |
1205 | 413 return ComplexColumnVector (); |
414 } | |
415 | |
416 if (nc == 0 || nr == 0) | |
417 return ComplexColumnVector (0); | |
418 | |
419 ComplexColumnVector result (nr); | |
420 | |
5275 | 421 for (octave_idx_type i = 0; i < a_len; i++) |
1205 | 422 result.elem (i) = a.elem (i) * m.elem (i, i); |
423 | |
5275 | 424 for (octave_idx_type i = a_len; i < nr; i++) |
1205 | 425 result.elem (i) = 0.0; |
426 | |
427 return result; | |
428 } | |
429 | |
430 ComplexColumnVector | |
431 operator * (const ComplexDiagMatrix& m, const ComplexColumnVector& a) | |
432 { | |
5275 | 433 octave_idx_type nr = m.rows (); |
434 octave_idx_type nc = m.cols (); | |
2386 | 435 |
5275 | 436 octave_idx_type a_len = a.length (); |
2386 | 437 |
1205 | 438 if (nc != a_len) |
439 { | |
2386 | 440 gripe_nonconformant ("operator *", nr, nc, a_len, 1); |
1205 | 441 return ComplexColumnVector (); |
442 } | |
443 | |
444 if (nc == 0 || nr == 0) | |
445 return ComplexColumnVector (0); | |
446 | |
447 ComplexColumnVector result (nr); | |
448 | |
5275 | 449 for (octave_idx_type i = 0; i < a_len; i++) |
1205 | 450 result.elem (i) = a.elem (i) * m.elem (i, i); |
451 | |
5275 | 452 for (octave_idx_type i = a_len; i < nr; i++) |
1205 | 453 result.elem (i) = 0.0; |
454 | |
455 return result; | |
456 } | |
457 | |
458 | 458 // other operations |
459 | |
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7482
diff
changeset
|
460 ColumnVector |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7482
diff
changeset
|
461 ComplexColumnVector::map (dmapper fcn) const |
458 | 462 { |
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7482
diff
changeset
|
463 return MArray<Complex>::map<double> (func_ptr (fcn)); |
458 | 464 } |
465 | |
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7482
diff
changeset
|
466 ComplexColumnVector |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7482
diff
changeset
|
467 ComplexColumnVector::map (cmapper fcn) const |
458 | 468 { |
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7482
diff
changeset
|
469 return MArray<Complex>::map<Complex> (func_ptr (fcn)); |
458 | 470 } |
471 | |
472 Complex | |
473 ComplexColumnVector::min (void) const | |
474 { | |
5275 | 475 octave_idx_type len = length (); |
458 | 476 if (len == 0) |
477 return 0.0; | |
478 | |
479 Complex res = elem (0); | |
5260 | 480 double absres = std::abs (res); |
458 | 481 |
5275 | 482 for (octave_idx_type i = 1; i < len; i++) |
5260 | 483 if (std::abs (elem (i)) < absres) |
458 | 484 { |
485 res = elem (i); | |
5260 | 486 absres = std::abs (res); |
458 | 487 } |
488 | |
489 return res; | |
490 } | |
491 | |
492 Complex | |
493 ComplexColumnVector::max (void) const | |
494 { | |
5275 | 495 octave_idx_type len = length (); |
458 | 496 if (len == 0) |
497 return 0.0; | |
498 | |
499 Complex res = elem (0); | |
5260 | 500 double absres = std::abs (res); |
458 | 501 |
5275 | 502 for (octave_idx_type i = 1; i < len; i++) |
5260 | 503 if (std::abs (elem (i)) > absres) |
458 | 504 { |
505 res = elem (i); | |
5260 | 506 absres = std::abs (res); |
458 | 507 } |
508 | |
509 return res; | |
510 } | |
511 | |
512 // i/o | |
513 | |
3504 | 514 std::ostream& |
515 operator << (std::ostream& os, const ComplexColumnVector& a) | |
458 | 516 { |
517 // int field_width = os.precision () + 7; | |
5275 | 518 for (octave_idx_type i = 0; i < a.length (); i++) |
458 | 519 os << /* setw (field_width) << */ a.elem (i) << "\n"; |
520 return os; | |
521 } | |
522 | |
3504 | 523 std::istream& |
524 operator >> (std::istream& is, ComplexColumnVector& a) | |
458 | 525 { |
5275 | 526 octave_idx_type len = a.length(); |
458 | 527 |
528 if (len < 1) | |
3504 | 529 is.clear (std::ios::badbit); |
458 | 530 else |
531 { | |
532 double tmp; | |
5275 | 533 for (octave_idx_type i = 0; i < len; i++) |
458 | 534 { |
535 is >> tmp; | |
536 if (is) | |
537 a.elem (i) = tmp; | |
538 else | |
539 break; | |
540 } | |
541 } | |
532 | 542 return is; |
458 | 543 } |
544 | |
545 /* | |
546 ;;; Local Variables: *** | |
547 ;;; mode: C++ *** | |
548 ;;; End: *** | |
549 */ |