GNU Octave 7.1.0
A high-level interpreted language, primarily intended for numerical computations, mostly compatible with Matlab
fCMatrix.h
Go to the documentation of this file.
1////////////////////////////////////////////////////////////////////////
2//
3// Copyright (C) 1994-2022 The Octave Project Developers
4//
5// See the file COPYRIGHT.md in the top-level directory of this
6// distribution or <https://octave.org/copyright/>.
7//
8// This file is part of Octave.
9//
10// Octave is free software: you can redistribute it and/or modify it
11// under the terms of the GNU General Public License as published by
12// the Free Software Foundation, either version 3 of the License, or
13// (at your option) any later version.
14//
15// Octave is distributed in the hope that it will be useful, but
16// WITHOUT ANY WARRANTY; without even the implied warranty of
17// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18// GNU General Public License for more details.
19//
20// You should have received a copy of the GNU General Public License
21// along with Octave; see the file COPYING. If not, see
22// <https://www.gnu.org/licenses/>.
23//
24////////////////////////////////////////////////////////////////////////
25
26#if ! defined (octave_fCMatrix_h)
27#define octave_fCMatrix_h 1
28
29#include "octave-config.h"
30
31#include "DET.h"
32#include "MArray.h"
33#include "MDiagArray2.h"
34#include "MatrixType.h"
35#include "fCNDArray.h"
36#include "mx-defs.h"
37#include "mx-op-decl.h"
38#include "oct-cmplx.h"
39
40class
41OCTAVE_API
42FloatComplexMatrix : public FloatComplexNDArray
43{
44public:
45
46 typedef FloatComplexColumnVector column_vector_type;
47 typedef FloatComplexRowVector row_vector_type;
48
49 typedef FloatColumnVector real_column_vector_type;
50 typedef FloatRowVector real_row_vector_type;
51
52 typedef FloatMatrix real_matrix_type;
53 typedef FloatComplexMatrix complex_matrix_type;
54
55 typedef FloatDiagMatrix real_diag_matrix_type;
56 typedef FloatComplexDiagMatrix complex_diag_matrix_type;
57
58 typedef float real_elt_type;
59 typedef FloatComplex complex_elt_type;
60
61 typedef void (*solve_singularity_handler) (float rcon);
62
63 FloatComplexMatrix (void) = default;
64
65 FloatComplexMatrix (const FloatComplexMatrix& a) = default;
66
67 FloatComplexMatrix& operator = (const FloatComplexMatrix& a) = default;
68
69 ~FloatComplexMatrix (void) = default;
70
71 FloatComplexMatrix (octave_idx_type r, octave_idx_type c)
72 : FloatComplexNDArray (dim_vector (r, c)) { }
73
74 FloatComplexMatrix (octave_idx_type r, octave_idx_type c,
75 const FloatComplex& val)
76 : FloatComplexNDArray (dim_vector (r, c), val) { }
77
78 FloatComplexMatrix (const dim_vector& dv)
79 : FloatComplexNDArray (dv.redim (2)) { }
80
81 FloatComplexMatrix (const dim_vector& dv, const FloatComplex& val)
82 : FloatComplexNDArray (dv.redim (2), val) { }
83
84 template <typename U>
85 FloatComplexMatrix (const MArray<U>& a)
86 : FloatComplexNDArray (a.as_matrix ()) { }
87
88 template <typename U>
89 FloatComplexMatrix (const Array<U>& a)
90 : FloatComplexNDArray (a.as_matrix ()) { }
91
92 explicit OCTAVE_API FloatComplexMatrix (const FloatMatrix& a);
93
94 explicit OCTAVE_API FloatComplexMatrix (const FloatRowVector& rv);
95
96 explicit OCTAVE_API FloatComplexMatrix (const FloatColumnVector& cv);
97
98 explicit OCTAVE_API FloatComplexMatrix (const FloatDiagMatrix& a);
99
100 explicit OCTAVE_API FloatComplexMatrix (const MDiagArray2<float>& a);
101
102 explicit OCTAVE_API FloatComplexMatrix (const DiagArray2<float>& a);
103
104 explicit OCTAVE_API FloatComplexMatrix (const FloatComplexRowVector& rv);
105
106 explicit OCTAVE_API FloatComplexMatrix (const FloatComplexColumnVector& cv);
107
108 explicit OCTAVE_API FloatComplexMatrix (const FloatComplexDiagMatrix& a);
109
110 explicit OCTAVE_API FloatComplexMatrix (const MDiagArray2<FloatComplex>& a);
111
112 explicit OCTAVE_API FloatComplexMatrix (const DiagArray2<FloatComplex>& a);
113
114 explicit OCTAVE_API FloatComplexMatrix (const boolMatrix& a);
115
116 explicit OCTAVE_API FloatComplexMatrix (const charMatrix& a);
117
118 OCTAVE_API FloatComplexMatrix (const FloatMatrix& re, const FloatMatrix& im);
119
120 OCTAVE_API bool operator == (const FloatComplexMatrix& a) const;
121 OCTAVE_API bool operator != (const FloatComplexMatrix& a) const;
122
123 OCTAVE_API bool ishermitian (void) const;
124
125 // destructive insert/delete/reorder operations
126
127 OCTAVE_API FloatComplexMatrix&
128 insert (const FloatMatrix& a, octave_idx_type r, octave_idx_type c);
129 OCTAVE_API FloatComplexMatrix&
130 insert (const FloatRowVector& a, octave_idx_type r, octave_idx_type c);
131 OCTAVE_API FloatComplexMatrix&
132 insert (const FloatColumnVector& a, octave_idx_type r, octave_idx_type c);
133 OCTAVE_API FloatComplexMatrix&
134 insert (const FloatDiagMatrix& a, octave_idx_type r, octave_idx_type c);
135
136 OCTAVE_API FloatComplexMatrix&
137 insert (const FloatComplexMatrix& a, octave_idx_type r, octave_idx_type c);
138 OCTAVE_API FloatComplexMatrix&
139 insert (const FloatComplexRowVector& a, octave_idx_type r,
140 octave_idx_type c);
141 OCTAVE_API FloatComplexMatrix&
142 insert (const FloatComplexColumnVector& a, octave_idx_type r,
143 octave_idx_type c);
144 OCTAVE_API FloatComplexMatrix&
145 insert (const FloatComplexDiagMatrix& a, octave_idx_type r,
146 octave_idx_type c);
147
148 OCTAVE_API FloatComplexMatrix& fill (float val);
149 OCTAVE_API FloatComplexMatrix& fill (const FloatComplex& val);
150 OCTAVE_API FloatComplexMatrix&
151 fill (float val, octave_idx_type r1, octave_idx_type c1,
152 octave_idx_type r2, octave_idx_type c2);
153 OCTAVE_API FloatComplexMatrix&
154 fill (const FloatComplex& val, octave_idx_type r1, octave_idx_type c1,
155 octave_idx_type r2, octave_idx_type c2);
156
157 OCTAVE_API FloatComplexMatrix append (const FloatMatrix& a) const;
158 OCTAVE_API FloatComplexMatrix append (const FloatRowVector& a) const;
159 OCTAVE_API FloatComplexMatrix append (const FloatColumnVector& a) const;
160 OCTAVE_API FloatComplexMatrix append (const FloatDiagMatrix& a) const;
161
162 OCTAVE_API FloatComplexMatrix append (const FloatComplexMatrix& a) const;
163 OCTAVE_API FloatComplexMatrix append (const FloatComplexRowVector& a) const;
164 OCTAVE_API FloatComplexMatrix
165 append (const FloatComplexColumnVector& a) const;
166 OCTAVE_API FloatComplexMatrix append (const FloatComplexDiagMatrix& a) const;
167
168 OCTAVE_API FloatComplexMatrix stack (const FloatMatrix& a) const;
169 OCTAVE_API FloatComplexMatrix stack (const FloatRowVector& a) const;
170 OCTAVE_API FloatComplexMatrix stack (const FloatColumnVector& a) const;
171 OCTAVE_API FloatComplexMatrix stack (const FloatDiagMatrix& a) const;
172
173 OCTAVE_API FloatComplexMatrix stack (const FloatComplexMatrix& a) const;
174 OCTAVE_API FloatComplexMatrix stack (const FloatComplexRowVector& a) const;
175 OCTAVE_API FloatComplexMatrix stack (const FloatComplexColumnVector& a) const;
176 OCTAVE_API FloatComplexMatrix stack (const FloatComplexDiagMatrix& a) const;
177
178 FloatComplexMatrix hermitian (void) const
179 { return MArray<FloatComplex>::hermitian (std::conj); }
180 FloatComplexMatrix transpose (void) const
181 { return MArray<FloatComplex>::transpose (); }
182
183 friend OCTAVE_API FloatComplexMatrix conj (const FloatComplexMatrix& a);
184
185 // resize is the destructive equivalent for this one
186
187 OCTAVE_API FloatComplexMatrix
188 extract (octave_idx_type r1, octave_idx_type c1,
189 octave_idx_type r2, octave_idx_type c2) const;
190
191 OCTAVE_API FloatComplexMatrix
192 extract_n (octave_idx_type r1, octave_idx_type c1,
193 octave_idx_type nr, octave_idx_type nc) const;
194
195 // extract row or column i.
196
197 OCTAVE_API FloatComplexRowVector row (octave_idx_type i) const;
198
199 OCTAVE_API FloatComplexColumnVector column (octave_idx_type i) const;
200
201 void resize (octave_idx_type nr, octave_idx_type nc,
202 const FloatComplex& rfv = FloatComplex (0))
203 {
204 MArray<FloatComplex>::resize (dim_vector (nr, nc), rfv);
205 }
206
207private:
208 FloatComplexMatrix tinverse (MatrixType& mattype, octave_idx_type& info,
209 float& rcon, bool force, bool calc_cond) const;
210
211 FloatComplexMatrix finverse (MatrixType& mattype, octave_idx_type& info,
212 float& rcon, bool force, bool calc_cond) const;
213
214public:
215 OCTAVE_API FloatComplexMatrix inverse (void) const;
216 OCTAVE_API FloatComplexMatrix inverse (octave_idx_type& info) const;
217 OCTAVE_API FloatComplexMatrix
218 inverse (octave_idx_type& info, float& rcon, bool force = false,
219 bool calc_cond = true) const;
220
221 OCTAVE_API FloatComplexMatrix inverse (MatrixType& mattype) const;
222 OCTAVE_API FloatComplexMatrix
223 inverse (MatrixType& mattype, octave_idx_type& info) const;
224 OCTAVE_API FloatComplexMatrix
225 inverse (MatrixType& mattype, octave_idx_type& info, float& rcon,
226 bool force = false, bool calc_cond = true) const;
227
228 OCTAVE_API FloatComplexMatrix pseudo_inverse (float tol = 0.0) const;
229
230 OCTAVE_API FloatComplexMatrix fourier (void) const;
231 OCTAVE_API FloatComplexMatrix ifourier (void) const;
232
233 OCTAVE_API FloatComplexMatrix fourier2d (void) const;
234 OCTAVE_API FloatComplexMatrix ifourier2d (void) const;
235
236 OCTAVE_API FloatComplexDET determinant (void) const;
237 OCTAVE_API FloatComplexDET determinant (octave_idx_type& info) const;
238 OCTAVE_API FloatComplexDET
239 determinant (octave_idx_type& info, float& rcon,
240 bool calc_cond = true) const;
241 OCTAVE_API FloatComplexDET
242 determinant (MatrixType& mattype, octave_idx_type& info,
243 float& rcon, bool calc_cond = true) const;
244
245 OCTAVE_API float rcond (void) const;
246 OCTAVE_API float rcond (MatrixType& mattype) const;
247
248private:
249 // Upper triangular matrix solvers
250 FloatComplexMatrix utsolve (MatrixType& mattype, const FloatComplexMatrix& b,
251 octave_idx_type& info, float& rcon,
252 solve_singularity_handler sing_handler,
253 bool calc_cond = false,
254 blas_trans_type transt = blas_no_trans) const;
255
256 // Lower triangular matrix solvers
257 FloatComplexMatrix ltsolve (MatrixType& mattype, const FloatComplexMatrix& b,
258 octave_idx_type& info, float& rcon,
259 solve_singularity_handler sing_handler,
260 bool calc_cond = false,
261 blas_trans_type transt = blas_no_trans) const;
262
263 // Full matrix solvers (umfpack/cholesky)
264 FloatComplexMatrix fsolve (MatrixType& mattype, const FloatComplexMatrix& b,
265 octave_idx_type& info, float& rcon,
266 solve_singularity_handler sing_handler,
267 bool calc_cond = false) const;
268
269public:
270 // Generic interface to solver with no probing of type
271 OCTAVE_API FloatComplexMatrix
272 solve (MatrixType& mattype, const FloatMatrix& b) const;
273 OCTAVE_API FloatComplexMatrix
274 solve (MatrixType& mattype, const FloatMatrix& b,
275 octave_idx_type& info) const;
276 OCTAVE_API FloatComplexMatrix
277 solve (MatrixType& mattype, const FloatMatrix& b, octave_idx_type& info,
278 float& rcon) const;
279 OCTAVE_API FloatComplexMatrix
280 solve (MatrixType& mattype, const FloatMatrix& b, octave_idx_type& info,
281 float& rcon, solve_singularity_handler sing_handler,
282 bool singular_fallback = true,
283 blas_trans_type transt = blas_no_trans) const;
284
285 OCTAVE_API FloatComplexMatrix
286 solve (MatrixType& mattype, const FloatComplexMatrix& b) const;
287 OCTAVE_API FloatComplexMatrix
288 solve (MatrixType& mattype, const FloatComplexMatrix& b,
289 octave_idx_type& info) const;
290 OCTAVE_API FloatComplexMatrix
291 solve (MatrixType& mattype, const FloatComplexMatrix& b,
292 octave_idx_type& info, float& rcon) const;
293 OCTAVE_API FloatComplexMatrix
294 solve (MatrixType& mattype, const FloatComplexMatrix& b,
295 octave_idx_type& info, float& rcon,
296 solve_singularity_handler sing_handler,
297 bool singular_fallback = true,
298 blas_trans_type transt = blas_no_trans) const;
299
300 OCTAVE_API FloatComplexColumnVector
301 solve (MatrixType& mattype, const FloatColumnVector& b) const;
302 OCTAVE_API FloatComplexColumnVector
303 solve (MatrixType& mattype, const FloatColumnVector& b,
304 octave_idx_type& info) const;
305 OCTAVE_API FloatComplexColumnVector
306 solve (MatrixType& mattype, const FloatColumnVector& b,
307 octave_idx_type& info, float& rcon) const;
308 OCTAVE_API FloatComplexColumnVector
309 solve (MatrixType& mattype, const FloatColumnVector& b,
310 octave_idx_type& info, float& rcon,
311 solve_singularity_handler sing_handler,
312 blas_trans_type transt = blas_no_trans) const;
313
314 OCTAVE_API FloatComplexColumnVector
315 solve (MatrixType& mattype, const FloatComplexColumnVector& b) const;
316 OCTAVE_API FloatComplexColumnVector
317 solve (MatrixType& mattype, const FloatComplexColumnVector& b,
318 octave_idx_type& info) const;
319 OCTAVE_API FloatComplexColumnVector
320 solve (MatrixType& mattype, const FloatComplexColumnVector& b,
321 octave_idx_type& info, float& rcon) const;
322 OCTAVE_API FloatComplexColumnVector
323 solve (MatrixType& mattype, const FloatComplexColumnVector& b,
324 octave_idx_type& info, float& rcon,
325 solve_singularity_handler sing_handler,
326 blas_trans_type transt = blas_no_trans) const;
327
328 // Generic interface to solver with probing of type
329 OCTAVE_API FloatComplexMatrix solve (const FloatMatrix& b) const;
330 OCTAVE_API FloatComplexMatrix
331 solve (const FloatMatrix& b, octave_idx_type& info) const;
332 OCTAVE_API FloatComplexMatrix
333 solve (const FloatMatrix& b, octave_idx_type& info, float& rcon) const;
334 OCTAVE_API FloatComplexMatrix
335 solve (const FloatMatrix& b, octave_idx_type& info, float& rcon,
336 solve_singularity_handler sing_handler,
337 blas_trans_type transt = blas_no_trans) const;
338
339 OCTAVE_API FloatComplexMatrix solve (const FloatComplexMatrix& b) const;
340 OCTAVE_API FloatComplexMatrix
341 solve (const FloatComplexMatrix& b, octave_idx_type& info) const;
342 OCTAVE_API FloatComplexMatrix
343 solve (const FloatComplexMatrix& b, octave_idx_type& info,
344 float& rcon) const;
345 OCTAVE_API FloatComplexMatrix
346 solve (const FloatComplexMatrix& b, octave_idx_type& info, float& rcon,
347 solve_singularity_handler sing_handler,
348 blas_trans_type transt = blas_no_trans) const;
349
350 OCTAVE_API FloatComplexColumnVector solve (const FloatColumnVector& b) const;
351 OCTAVE_API FloatComplexColumnVector
352 solve (const FloatColumnVector& b, octave_idx_type& info) const;
353 OCTAVE_API FloatComplexColumnVector
354 solve (const FloatColumnVector& b, octave_idx_type& info,
355 float& rcon) const;
356 OCTAVE_API FloatComplexColumnVector
357 solve (const FloatColumnVector& b, octave_idx_type& info, float& rcon,
358 solve_singularity_handler sing_handler,
359 blas_trans_type transt = blas_no_trans) const;
360
361 OCTAVE_API FloatComplexColumnVector
362 solve (const FloatComplexColumnVector& b) const;
363 OCTAVE_API FloatComplexColumnVector
364 solve (const FloatComplexColumnVector& b, octave_idx_type& info) const;
365 OCTAVE_API FloatComplexColumnVector
366 solve (const FloatComplexColumnVector& b, octave_idx_type& info,
367 float& rcon) const;
368 OCTAVE_API FloatComplexColumnVector
369 solve (const FloatComplexColumnVector& b, octave_idx_type& info, float& rcon,
370 solve_singularity_handler sing_handler,
371 blas_trans_type transt = blas_no_trans) const;
372
373 OCTAVE_API FloatComplexMatrix lssolve (const FloatMatrix& b) const;
374 OCTAVE_API FloatComplexMatrix
375 lssolve (const FloatMatrix& b, octave_idx_type& info) const;
376 OCTAVE_API FloatComplexMatrix
377 lssolve (const FloatMatrix& b, octave_idx_type& info, octave_idx_type& rank) const;
378 OCTAVE_API FloatComplexMatrix
379 lssolve (const FloatMatrix& b, octave_idx_type& info, octave_idx_type& rank,
380 float& rcon) const;
381
382 OCTAVE_API FloatComplexMatrix lssolve (const FloatComplexMatrix& b) const;
383 OCTAVE_API FloatComplexMatrix
384 lssolve (const FloatComplexMatrix& b, octave_idx_type& info) const;
385 OCTAVE_API FloatComplexMatrix
386 lssolve (const FloatComplexMatrix& b, octave_idx_type& info,
387 octave_idx_type& rank) const;
388 OCTAVE_API FloatComplexMatrix
389 lssolve (const FloatComplexMatrix& b, octave_idx_type& info,
390 octave_idx_type& rank, float& rcon) const;
391
392 OCTAVE_API FloatComplexColumnVector
393 lssolve (const FloatColumnVector& b) const;
394 OCTAVE_API FloatComplexColumnVector
395 lssolve (const FloatColumnVector& b, octave_idx_type& info) const;
396 OCTAVE_API FloatComplexColumnVector
397 lssolve (const FloatColumnVector& b, octave_idx_type& info,
398 octave_idx_type& rank) const;
399 OCTAVE_API FloatComplexColumnVector
400 lssolve (const FloatColumnVector& b, octave_idx_type& info,
401 octave_idx_type& rank, float& rcon) const;
402
403 OCTAVE_API FloatComplexColumnVector
404 lssolve (const FloatComplexColumnVector& b) const;
405 OCTAVE_API FloatComplexColumnVector
406 lssolve (const FloatComplexColumnVector& b, octave_idx_type& info) const;
407 OCTAVE_API FloatComplexColumnVector
408 lssolve (const FloatComplexColumnVector& b, octave_idx_type& info,
409 octave_idx_type& rank) const;
410 OCTAVE_API FloatComplexColumnVector
411 lssolve (const FloatComplexColumnVector& b, octave_idx_type& info,
412 octave_idx_type& rank, float& rcon) const;
413
414 // matrix by diagonal matrix -> matrix operations
415
416 OCTAVE_API FloatComplexMatrix& operator += (const FloatDiagMatrix& a);
417 OCTAVE_API FloatComplexMatrix& operator -= (const FloatDiagMatrix& a);
418
419 OCTAVE_API FloatComplexMatrix& operator += (const FloatComplexDiagMatrix& a);
420 OCTAVE_API FloatComplexMatrix& operator -= (const FloatComplexDiagMatrix& a);
421
422 // matrix by matrix -> matrix operations
423
424 OCTAVE_API FloatComplexMatrix& operator += (const FloatMatrix& a);
425 OCTAVE_API FloatComplexMatrix& operator -= (const FloatMatrix& a);
426
427 // unary operations
428
429 OCTAVE_API boolMatrix operator ! (void) const;
430
431 // other operations
432
433 OCTAVE_API boolMatrix all (int dim = -1) const;
434 OCTAVE_API boolMatrix any (int dim = -1) const;
435
436 OCTAVE_API FloatComplexMatrix cumprod (int dim = -1) const;
437 OCTAVE_API FloatComplexMatrix cumsum (int dim = -1) const;
438 OCTAVE_API FloatComplexMatrix prod (int dim = -1) const;
439 OCTAVE_API FloatComplexMatrix sum (int dim = -1) const;
440 OCTAVE_API FloatComplexMatrix sumsq (int dim = -1) const;
441 OCTAVE_API FloatMatrix abs (void) const;
442
443 OCTAVE_API FloatComplexMatrix diag (octave_idx_type k = 0) const;
444
445 OCTAVE_API FloatComplexDiagMatrix
446 diag (octave_idx_type m, octave_idx_type n) const;
447
448 OCTAVE_API bool row_is_real_only (octave_idx_type) const;
449 OCTAVE_API bool column_is_real_only (octave_idx_type) const;
450
451 OCTAVE_API FloatComplexColumnVector row_min (void) const;
452 OCTAVE_API FloatComplexColumnVector row_max (void) const;
453
454 OCTAVE_API FloatComplexColumnVector
455 row_min (Array<octave_idx_type>& index) const;
456 OCTAVE_API FloatComplexColumnVector
457 row_max (Array<octave_idx_type>& index) const;
458
459 OCTAVE_API FloatComplexRowVector column_min (void) const;
460 OCTAVE_API FloatComplexRowVector column_max (void) const;
461
462 OCTAVE_API FloatComplexRowVector
463 column_min (Array<octave_idx_type>& index) const;
464 OCTAVE_API FloatComplexRowVector
465 column_max (Array<octave_idx_type>& index) const;
466
467 // i/o
468
469 friend OCTAVE_API std::ostream&
470 operator << (std::ostream& os, const FloatComplexMatrix& a);
471 friend OCTAVE_API std::istream&
472 operator >> (std::istream& is, FloatComplexMatrix& a);
473};
474
475extern OCTAVE_API FloatComplexMatrix conj (const FloatComplexMatrix& a);
476
477// column vector by row vector -> matrix operations
478
479extern OCTAVE_API FloatComplexMatrix
480operator * (const FloatColumnVector& a, const FloatComplexRowVector& b);
481
482extern OCTAVE_API FloatComplexMatrix
483operator * (const FloatComplexColumnVector& a, const FloatRowVector& b);
484
485extern OCTAVE_API FloatComplexMatrix
486operator * (const FloatComplexColumnVector& a, const FloatComplexRowVector& b);
487
488extern OCTAVE_API FloatComplexMatrix
489Givens (const FloatComplex&, const FloatComplex&);
490
491extern OCTAVE_API FloatComplexMatrix
492Sylvester (const FloatComplexMatrix&, const FloatComplexMatrix&,
493 const FloatComplexMatrix&);
494
495extern OCTAVE_API FloatComplexMatrix
496xgemm (const FloatComplexMatrix& a, const FloatComplexMatrix& b,
497 blas_trans_type transa = blas_no_trans,
498 blas_trans_type transb = blas_no_trans);
499
500extern OCTAVE_API FloatComplexMatrix operator * (const FloatMatrix&,
501 const FloatComplexMatrix&);
502extern OCTAVE_API FloatComplexMatrix operator * (const FloatComplexMatrix&,
503 const FloatMatrix&);
504extern OCTAVE_API FloatComplexMatrix operator * (const FloatComplexMatrix&,
505 const FloatComplexMatrix&);
506
507extern OCTAVE_API FloatComplexMatrix min (const FloatComplex& c,
508 const FloatComplexMatrix& m);
509extern OCTAVE_API FloatComplexMatrix min (const FloatComplexMatrix& m,
510 const FloatComplex& c);
511extern OCTAVE_API FloatComplexMatrix min (const FloatComplexMatrix& a,
512 const FloatComplexMatrix& b);
513
514extern OCTAVE_API FloatComplexMatrix max (const FloatComplex& c,
515 const FloatComplexMatrix& m);
516extern OCTAVE_API FloatComplexMatrix max (const FloatComplexMatrix& m,
517 const FloatComplex& c);
518extern OCTAVE_API FloatComplexMatrix max (const FloatComplexMatrix& a,
519 const FloatComplexMatrix& b);
520
521extern OCTAVE_API FloatComplexMatrix
522linspace (const FloatComplexColumnVector& x1,
523 const FloatComplexColumnVector& x2,
524 octave_idx_type n);
525
526MS_CMP_OP_DECLS (FloatComplexMatrix, FloatComplex, OCTAVE_API)
527MS_BOOL_OP_DECLS (FloatComplexMatrix, FloatComplex, OCTAVE_API)
528
529SM_CMP_OP_DECLS (FloatComplex, FloatComplexMatrix, OCTAVE_API)
530SM_BOOL_OP_DECLS (FloatComplex, FloatComplexMatrix, OCTAVE_API)
531
532MM_CMP_OP_DECLS (FloatComplexMatrix, FloatComplexMatrix, OCTAVE_API)
533MM_BOOL_OP_DECLS (FloatComplexMatrix, FloatComplexMatrix, OCTAVE_API)
534
535MARRAY_FORWARD_DEFS (MArray, FloatComplexMatrix, FloatComplex)
536
537#endif
operator<<
template OCTAVE_API std::ostream & operator<<(std::ostream &, const Array< bool > &)
MARRAY_FORWARD_DEFS
#define MARRAY_FORWARD_DEFS(B, R, T)
Definition: MArray.h:130
operator>>
std::istream & operator>>(std::istream &is, SparseBoolMatrix &a)
Definition: boolSparse.cc:279
Array
N Dimensional Array with copy-on-write semantics.
Definition: Array.h:129
Array< T >::resize
OCTARRAY_API void resize(const dim_vector &dv, const T &rfv)
Definition: Array.cc:1010
FloatComplexMatrix::FloatComplexMatrix
FloatComplexMatrix(const dim_vector &dv, const FloatComplex &val)
Definition: fCMatrix.h:81
FloatComplexMatrix::FloatComplexMatrix
FloatComplexMatrix(const FloatComplexMatrix &a)=default
FloatComplexMatrix::FloatComplexMatrix
FloatComplexMatrix(const dim_vector &dv)
Definition: fCMatrix.h:78
FloatComplexMatrix::FloatComplexMatrix
FloatComplexMatrix(void)=default
FloatComplexMatrix::complex_diag_matrix_type
FloatComplexDiagMatrix complex_diag_matrix_type
Definition: fCMatrix.h:56
FloatComplexMatrix::real_column_vector_type
FloatColumnVector real_column_vector_type
Definition: fCMatrix.h:49
FloatComplexMatrix::hermitian
FloatComplexMatrix hermitian(void) const
Definition: fCMatrix.h:178
FloatComplexMatrix::real_row_vector_type
FloatRowVector real_row_vector_type
Definition: fCMatrix.h:50
FloatComplexMatrix::complex_matrix_type
FloatComplexMatrix complex_matrix_type
Definition: fCMatrix.h:53
FloatComplexMatrix::FloatComplexMatrix
FloatComplexMatrix(const Array< U > &a)
Definition: fCMatrix.h:89
FloatComplexMatrix::real_matrix_type
FloatMatrix real_matrix_type
Definition: fCMatrix.h:52
FloatComplexMatrix::transpose
FloatComplexMatrix transpose(void) const
Definition: fCMatrix.h:180
FloatComplexMatrix::~FloatComplexMatrix
~FloatComplexMatrix(void)=default
FloatComplexMatrix::resize
void resize(octave_idx_type nr, octave_idx_type nc, const FloatComplex &rfv=FloatComplex(0))
Definition: fCMatrix.h:201
FloatComplexMatrix::complex_elt_type
FloatComplex complex_elt_type
Definition: fCMatrix.h:59
FloatComplexMatrix::FloatComplexMatrix
FloatComplexMatrix(octave_idx_type r, octave_idx_type c, const FloatComplex &val)
Definition: fCMatrix.h:74
FloatComplexMatrix::row_vector_type
FloatComplexRowVector row_vector_type
Definition: fCMatrix.h:47
FloatComplexMatrix::real_elt_type
float real_elt_type
Definition: fCMatrix.h:58
FloatComplexMatrix::FloatComplexMatrix
FloatComplexMatrix(octave_idx_type r, octave_idx_type c)
Definition: fCMatrix.h:71
FloatComplexMatrix::real_diag_matrix_type
FloatDiagMatrix real_diag_matrix_type
Definition: fCMatrix.h:55
FloatComplexMatrix::column_vector_type
FloatComplexColumnVector column_vector_type
Definition: fCMatrix.h:46
FloatComplexMatrix::FloatComplexMatrix
FloatComplexMatrix(const MArray< U > &a)
Definition: fCMatrix.h:85
MArray
Template for N-dimensional array classes with like-type math operators.
Definition: MArray.h:63
MArray::hermitian
MArray< T > hermitian(T(*fcn)(const T &)=nullptr) const
Definition: MArray.h:102
MArray::transpose
MArray< T > transpose(void) const
Definition: MArray.h:99
base_det
Definition: DET.h:39
dim_vector
Vector representing the dimensions (size) of an Array.
Definition: dim-vector.h:94
octave_idx_type
operator!=
bool operator!=(const dim_vector &a, const dim_vector &b)
Definition: dim-vector.h:536
operator==
bool operator==(const dim_vector &a, const dim_vector &b)
Definition: dim-vector.h:520
utsolve
static M utsolve(const SM &U, const ColumnVector &Q, const M &m)
Definition: eigs-base.cc:259
ltsolve
static M ltsolve(const SM &L, const ColumnVector &Q, const M &m)
Definition: eigs-base.cc:239
linspace
OCTAVE_API FloatComplexMatrix linspace(const FloatComplexColumnVector &x1, const FloatComplexColumnVector &x2, octave_idx_type n)
Definition: fCMatrix.cc:3653
max
OCTAVE_API FloatComplexMatrix max(const FloatComplex &c, const FloatComplexMatrix &m)
Definition: fCMatrix.cc:3579
Sylvester
OCTAVE_API FloatComplexMatrix Sylvester(const FloatComplexMatrix &, const FloatComplexMatrix &, const FloatComplexMatrix &)
Definition: fCMatrix.cc:3272
min
OCTAVE_API FloatComplexMatrix min(const FloatComplex &c, const FloatComplexMatrix &m)
Definition: fCMatrix.cc:3507
operator+=
FloatComplexMatrix operator+=(FloatComplexMatrix &x, const FloatComplex &y)
Definition: fCMatrix.h:535
operator-=
FloatComplexMatrix operator-=(FloatComplexMatrix &x, const FloatComplex &y)
Definition: fCMatrix.h:535
xgemm
OCTAVE_API FloatComplexMatrix xgemm(const FloatComplexMatrix &a, const FloatComplexMatrix &b, blas_trans_type transa=blas_no_trans, blas_trans_type transb=blas_no_trans)
Definition: fCMatrix.cc:3372
Givens
OCTAVE_API FloatComplexMatrix Givens(const FloatComplex &, const FloatComplex &)
Definition: fCMatrix.cc:3253
conj
OCTAVE_API FloatComplexMatrix conj(const FloatComplexMatrix &a)
Definition: fCMatrix.cc:678
operator*
OCTAVE_API FloatComplexMatrix operator*(const FloatColumnVector &a, const FloatComplexRowVector &b)
Definition: fCMatrix.cc:2647
OCTAVE_API
#define OCTAVE_API
Definition: main.in.cc:55
blas_trans_type
blas_trans_type
Definition: mx-defs.h:80
blas_no_trans
@ blas_no_trans
Definition: mx-defs.h:81
FloatComplexMatrix
class OCTAVE_API FloatComplexMatrix
Definition: mx-fwd.h:34
SM_BOOL_OP_DECLS
#define SM_BOOL_OP_DECLS(S, M, API)
Definition: mx-op-decl.h:122
MS_CMP_OP_DECLS
#define MS_CMP_OP_DECLS(M, S, API)
Definition: mx-op-decl.h:89
SM_CMP_OP_DECLS
#define SM_CMP_OP_DECLS(S, M, API)
Definition: mx-op-decl.h:114
MS_BOOL_OP_DECLS
#define MS_BOOL_OP_DECLS(M, S, API)
Definition: mx-op-decl.h:97
MM_CMP_OP_DECLS
#define MM_CMP_OP_DECLS(M1, M2, API)
Definition: mx-op-decl.h:139
MM_BOOL_OP_DECLS
#define MM_BOOL_OP_DECLS(M1, M2, API)
Definition: mx-op-decl.h:147
FloatComplex
std::complex< float > FloatComplex
Definition: oct-cmplx.h:34
operator!
octave_value operator!(const octave_value &a)
Definition: ov.h:1835
abs
static T abs(T x)
Definition: pr-output.cc:1678