GNU Octave  9.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-2024 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 
40 class
41 OCTAVE_API
42 FloatComplexMatrix : public FloatComplexNDArray
43 {
44 public:
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 () = default;
64 
65  FloatComplexMatrix (const FloatComplexMatrix& a) = default;
66 
67  FloatComplexMatrix& operator = (const FloatComplexMatrix& a) = default;
68 
69  ~FloatComplexMatrix () = 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 () 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 () const
179  { return MArray<FloatComplex>::hermitian (std::conj); }
180  FloatComplexMatrix transpose () 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 
207 private:
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 
214 public:
215  OCTAVE_API FloatComplexMatrix inverse () 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 () const;
231  OCTAVE_API FloatComplexMatrix ifourier () const;
232 
233  OCTAVE_API FloatComplexMatrix fourier2d () const;
234  OCTAVE_API FloatComplexMatrix ifourier2d () const;
235 
236  OCTAVE_API FloatComplexDET determinant () 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 () const;
246  OCTAVE_API float rcond (MatrixType& mattype) const;
247 
248 private:
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 
269 public:
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 ! () 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 () 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 () const;
452  OCTAVE_API FloatComplexColumnVector row_max () 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 () const;
460  OCTAVE_API FloatComplexRowVector column_max () 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 
475 extern OCTAVE_API FloatComplexMatrix conj (const FloatComplexMatrix& a);
476 
477 // column vector by row vector -> matrix operations
478 
479 extern OCTAVE_API FloatComplexMatrix
480 operator * (const FloatColumnVector& a, const FloatComplexRowVector& b);
481 
482 extern OCTAVE_API FloatComplexMatrix
483 operator * (const FloatComplexColumnVector& a, const FloatRowVector& b);
484 
485 extern OCTAVE_API FloatComplexMatrix
486 operator * (const FloatComplexColumnVector& a, const FloatComplexRowVector& b);
487 
488 extern OCTAVE_API FloatComplexMatrix
489 Givens (const FloatComplex&, const FloatComplex&);
490 
491 extern OCTAVE_API FloatComplexMatrix
492 Sylvester (const FloatComplexMatrix&, const FloatComplexMatrix&,
493  const FloatComplexMatrix&);
494 
495 extern OCTAVE_API FloatComplexMatrix
496 xgemm (const FloatComplexMatrix& a, const FloatComplexMatrix& b,
497  blas_trans_type transa = blas_no_trans,
498  blas_trans_type transb = blas_no_trans);
499 
500 extern OCTAVE_API FloatComplexMatrix operator * (const FloatMatrix&,
501  const FloatComplexMatrix&);
502 extern OCTAVE_API FloatComplexMatrix operator * (const FloatComplexMatrix&,
503  const FloatMatrix&);
504 extern OCTAVE_API FloatComplexMatrix operator * (const FloatComplexMatrix&,
505  const FloatComplexMatrix&);
506 
507 extern OCTAVE_API FloatComplexMatrix min (const FloatComplex& c,
508  const FloatComplexMatrix& m);
509 extern OCTAVE_API FloatComplexMatrix min (const FloatComplexMatrix& m,
510  const FloatComplex& c);
511 extern OCTAVE_API FloatComplexMatrix min (const FloatComplexMatrix& a,
512  const FloatComplexMatrix& b);
513 
514 extern OCTAVE_API FloatComplexMatrix max (const FloatComplex& c,
515  const FloatComplexMatrix& m);
516 extern OCTAVE_API FloatComplexMatrix max (const FloatComplexMatrix& m,
517  const FloatComplex& c);
518 extern OCTAVE_API FloatComplexMatrix max (const FloatComplexMatrix& a,
519  const FloatComplexMatrix& b);
520 
521 extern OCTAVE_API FloatComplexMatrix
522 linspace (const FloatComplexColumnVector& x1,
523  const FloatComplexColumnVector& x2,
524  octave_idx_type n);
525 
526 MS_CMP_OP_DECLS (FloatComplexMatrix, FloatComplex, OCTAVE_API)
527 MS_BOOL_OP_DECLS (FloatComplexMatrix, FloatComplex, OCTAVE_API)
528 
529 SM_CMP_OP_DECLS (FloatComplex, FloatComplexMatrix, OCTAVE_API)
530 SM_BOOL_OP_DECLS (FloatComplex, FloatComplexMatrix, OCTAVE_API)
531 
532 MM_CMP_OP_DECLS (FloatComplexMatrix, FloatComplexMatrix, OCTAVE_API)
533 MM_BOOL_OP_DECLS (FloatComplexMatrix, FloatComplexMatrix, OCTAVE_API)
534 
535 MARRAY_FORWARD_DEFS (MArray, FloatComplexMatrix, FloatComplex)
536 
537 #endif
operator<<
template 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:130
Array< T >::resize
void resize(const dim_vector &dv, const T &rfv)
Definition: Array-base.cc:1023
FloatComplexMatrix::hermitian
FloatComplexMatrix hermitian() const
Definition: fCMatrix.h:178
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::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::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::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::transpose
FloatComplexMatrix transpose() const
Definition: fCMatrix.h:180
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()=default
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
FloatComplexMatrix::~FloatComplexMatrix
~FloatComplexMatrix()=default
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() 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
xgemm
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:3378
max
FloatComplexMatrix max(const FloatComplex &c, const FloatComplexMatrix &m)
Definition: fCMatrix.cc:3585
linspace
FloatComplexMatrix linspace(const FloatComplexColumnVector &x1, const FloatComplexColumnVector &x2, octave_idx_type n)
Definition: fCMatrix.cc:3660
Sylvester
FloatComplexMatrix Sylvester(const FloatComplexMatrix &, const FloatComplexMatrix &, const FloatComplexMatrix &)
Definition: fCMatrix.cc:3278
operator+=
FloatComplexMatrix operator+=(FloatComplexMatrix &x, const FloatComplex &y)
Definition: fCMatrix.h:535
operator-=
FloatComplexMatrix operator-=(FloatComplexMatrix &x, const FloatComplex &y)
Definition: fCMatrix.h:535
min
FloatComplexMatrix min(const FloatComplex &c, const FloatComplexMatrix &m)
Definition: fCMatrix.cc:3513
conj
FloatComplexMatrix conj(const FloatComplexMatrix &a)
Definition: fCMatrix.cc:678
operator*
FloatComplexMatrix operator*(const FloatColumnVector &a, const FloatComplexRowVector &b)
Definition: fCMatrix.cc:2652
Givens
FloatComplexMatrix Givens(const FloatComplex &, const FloatComplex &)
Definition: fCMatrix.cc:3259
OCTAVE_API
#define OCTAVE_API
Definition: main.cc:55
blas_trans_type
blas_trans_type
Definition: mx-defs.h:80
blas_no_trans
@ blas_no_trans
Definition: mx-defs.h:81
m
T octave_idx_type m
Definition: mx-inlines.cc:781
n
octave_idx_type n
Definition: mx-inlines.cc:761
r
T * r
Definition: mx-inlines.cc:781
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:1633
abs
template int8_t abs(int8_t)