GNU Octave  9.1.0
A high-level interpreted language, primarily intended for numerical computations, mostly compatible with Matlab
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
fMatrix.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_fMatrix_h)
27 #define octave_fMatrix_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 "fNDArray.h"
36 #include "mx-defs.h"
37 #include "mx-op-decl.h"
38 
39 class
40 OCTAVE_API
41 FloatMatrix : public FloatNDArray
42 {
43 public:
44 
45  typedef FloatColumnVector column_vector_type;
46  typedef FloatRowVector row_vector_type;
47 
48  typedef FloatColumnVector real_column_vector_type;
49  typedef FloatRowVector real_row_vector_type;
50 
51  typedef FloatMatrix real_matrix_type;
52  typedef FloatComplexMatrix complex_matrix_type;
53 
54  typedef FloatDiagMatrix real_diag_matrix_type;
55  typedef FloatComplexDiagMatrix complex_diag_matrix_type;
56 
57  typedef float real_elt_type;
58  typedef FloatComplex complex_elt_type;
59 
60  typedef void (*solve_singularity_handler) (float rcon);
61 
62  FloatMatrix () = default;
63 
64  FloatMatrix (const FloatMatrix& a) = default;
65 
66  FloatMatrix& operator = (const FloatMatrix& a) = default;
67 
68  ~FloatMatrix () = default;
69 
70  FloatMatrix (octave_idx_type r, octave_idx_type c)
71  : FloatNDArray (dim_vector (r, c)) { }
72 
73  FloatMatrix (octave_idx_type r, octave_idx_type c, float val)
74  : FloatNDArray (dim_vector (r, c), val) { }
75 
76  FloatMatrix (const dim_vector& dv) : FloatNDArray (dv.redim (2)) { }
77 
78  FloatMatrix (const dim_vector& dv, float val)
79  : FloatNDArray (dv.redim (2), val) { }
80 
81  template <typename U>
82  FloatMatrix (const MArray<U>& a) : FloatNDArray (a.as_matrix ()) { }
83 
84  template <typename U>
85  FloatMatrix (const Array<U>& a) : FloatNDArray (a.as_matrix ()) { }
86 
87  explicit OCTAVE_API FloatMatrix (const FloatRowVector& rv);
88 
89  explicit OCTAVE_API FloatMatrix (const FloatColumnVector& cv);
90 
91  explicit OCTAVE_API FloatMatrix (const FloatDiagMatrix& a);
92 
93  explicit OCTAVE_API FloatMatrix (const MDiagArray2<float>& a);
94 
95  explicit OCTAVE_API FloatMatrix (const DiagArray2<float>& a);
96 
97  explicit OCTAVE_API FloatMatrix (const PermMatrix& a);
98 
99  explicit OCTAVE_API FloatMatrix (const boolMatrix& a);
100 
101  explicit OCTAVE_API FloatMatrix (const charMatrix& a);
102 
103  OCTAVE_API bool operator == (const FloatMatrix& a) const;
104  OCTAVE_API bool operator != (const FloatMatrix& a) const;
105 
106  OCTAVE_API bool issymmetric () const;
107 
108  // destructive insert/delete/reorder operations
109 
110  OCTAVE_API FloatMatrix&
111  insert (const FloatMatrix& a, octave_idx_type r, octave_idx_type c);
112  OCTAVE_API FloatMatrix&
113  insert (const FloatRowVector& a, octave_idx_type r, octave_idx_type c);
114  OCTAVE_API FloatMatrix&
115  insert (const FloatColumnVector& a, octave_idx_type r, octave_idx_type c);
116  OCTAVE_API FloatMatrix&
117  insert (const FloatDiagMatrix& a, octave_idx_type r, octave_idx_type c);
118 
119  OCTAVE_API FloatMatrix& fill (float val);
120  OCTAVE_API FloatMatrix&
121  fill (float val, octave_idx_type r1, octave_idx_type c1,
122  octave_idx_type r2, octave_idx_type c2);
123 
124  OCTAVE_API FloatMatrix append (const FloatMatrix& a) const;
125  OCTAVE_API FloatMatrix append (const FloatRowVector& a) const;
126  OCTAVE_API FloatMatrix append (const FloatColumnVector& a) const;
127  OCTAVE_API FloatMatrix append (const FloatDiagMatrix& a) const;
128 
129  OCTAVE_API FloatMatrix stack (const FloatMatrix& a) const;
130  OCTAVE_API FloatMatrix stack (const FloatRowVector& a) const;
131  OCTAVE_API FloatMatrix stack (const FloatColumnVector& a) const;
132  OCTAVE_API FloatMatrix stack (const FloatDiagMatrix& a) const;
133 
134  friend OCTAVE_API FloatMatrix real (const FloatComplexMatrix& a);
135  friend OCTAVE_API FloatMatrix imag (const FloatComplexMatrix& a);
136 
137  friend class FloatComplexMatrix;
138 
139  FloatMatrix hermitian () const { return MArray<float>::transpose (); }
140  FloatMatrix transpose () const { return MArray<float>::transpose (); }
141 
142  // resize is the destructive equivalent for this one
143 
144  OCTAVE_API FloatMatrix
145  extract (octave_idx_type r1, octave_idx_type c1,
146  octave_idx_type r2, octave_idx_type c2) const;
147 
148  OCTAVE_API FloatMatrix
149  extract_n (octave_idx_type r1, octave_idx_type c1,
150  octave_idx_type nr, octave_idx_type nc) const;
151 
152  // extract row or column i.
153 
154  OCTAVE_API FloatRowVector row (octave_idx_type i) const;
155 
156  OCTAVE_API FloatColumnVector column (octave_idx_type i) const;
157 
158  void resize (octave_idx_type nr, octave_idx_type nc, float rfv = 0)
159  {
160  MArray<float>::resize (dim_vector (nr, nc), rfv);
161  }
162 
163 private:
164  FloatMatrix tinverse (MatrixType& mattype, octave_idx_type& info,
165  float& rcon, bool force, bool calc_cond) const;
166 
167  FloatMatrix finverse (MatrixType& mattype, octave_idx_type& info,
168  float& rcon, bool force, bool calc_cond) const;
169 
170 public:
171  OCTAVE_API FloatMatrix inverse () const;
172  OCTAVE_API FloatMatrix inverse (octave_idx_type& info) const;
173  OCTAVE_API FloatMatrix
174  inverse (octave_idx_type& info, float& rcon, bool force = false,
175  bool calc_cond = true) const;
176 
177  OCTAVE_API FloatMatrix inverse (MatrixType& mattype) const;
178  OCTAVE_API FloatMatrix
179  inverse (MatrixType& mattype, octave_idx_type& info) const;
180  OCTAVE_API FloatMatrix
181  inverse (MatrixType& mattype, octave_idx_type& info, float& rcon,
182  bool force = false, bool calc_cond = true) const;
183 
184  OCTAVE_API FloatMatrix pseudo_inverse (float tol = 0.0) const;
185 
186  OCTAVE_API FloatComplexMatrix fourier () const;
187  OCTAVE_API FloatComplexMatrix ifourier () const;
188 
189  OCTAVE_API FloatComplexMatrix fourier2d () const;
190  OCTAVE_API FloatComplexMatrix ifourier2d () const;
191 
192  OCTAVE_API FloatDET determinant () const;
193  OCTAVE_API FloatDET determinant (octave_idx_type& info) const;
194  OCTAVE_API FloatDET
195  determinant (octave_idx_type& info, float& rcon,
196  bool calc_cond = true) const;
197  OCTAVE_API FloatDET
198  determinant (MatrixType& mattype, octave_idx_type& info, float& rcon,
199  bool calc_cond = true) const;
200 
201  OCTAVE_API float rcond () const;
202  OCTAVE_API float rcond (MatrixType& mattype) const;
203 
204 private:
205  // Upper triangular matrix solvers
206  FloatMatrix utsolve (MatrixType& mattype, const FloatMatrix& b,
207  octave_idx_type& info,
208  float& rcon, solve_singularity_handler sing_handler,
209  bool calc_cond = false,
210  blas_trans_type transt = blas_no_trans) const;
211 
212  // Lower triangular matrix solvers
213  FloatMatrix ltsolve (MatrixType& mattype, const FloatMatrix& b,
214  octave_idx_type& info,
215  float& rcon, solve_singularity_handler sing_handler,
216  bool calc_cond = false,
217  blas_trans_type transt = blas_no_trans) const;
218 
219  // Full matrix solvers (lu/cholesky)
220  FloatMatrix fsolve (MatrixType& mattype, const FloatMatrix& b,
221  octave_idx_type& info,
222  float& rcon, solve_singularity_handler sing_handler,
223  bool calc_cond = false) const;
224 
225 public:
226  // Generic interface to solver with no probing of type
227  OCTAVE_API FloatMatrix
228  solve (MatrixType& mattype, const FloatMatrix& b) const;
229  OCTAVE_API FloatMatrix
230  solve (MatrixType& mattype, const FloatMatrix& b,
231  octave_idx_type& info) const;
232  OCTAVE_API FloatMatrix
233  solve (MatrixType& mattype, const FloatMatrix& b, octave_idx_type& info,
234  float& rcon) const;
235  OCTAVE_API FloatMatrix
236  solve (MatrixType& mattype, const FloatMatrix& b, octave_idx_type& info,
237  float& rcon, solve_singularity_handler sing_handler,
238  bool singular_fallback = true,
239  blas_trans_type transt = blas_no_trans) const;
240 
241  OCTAVE_API FloatComplexMatrix
242  solve (MatrixType& mattype, const FloatComplexMatrix& b) const;
243  OCTAVE_API FloatComplexMatrix
244  solve (MatrixType& mattype, const FloatComplexMatrix& b,
245  octave_idx_type& info) const;
246  OCTAVE_API FloatComplexMatrix
247  solve (MatrixType& mattype, const FloatComplexMatrix& b,
248  octave_idx_type& info, float& rcon) const;
249  OCTAVE_API FloatComplexMatrix
250  solve (MatrixType& mattype, const FloatComplexMatrix& b,
251  octave_idx_type& info, float& rcon,
252  solve_singularity_handler sing_handler, bool singular_fallback = true,
253  blas_trans_type transt = blas_no_trans) const;
254 
255  OCTAVE_API FloatColumnVector
256  solve (MatrixType& mattype, const FloatColumnVector& b) const;
257  OCTAVE_API FloatColumnVector
258  solve (MatrixType& mattype, const FloatColumnVector& b,
259  octave_idx_type& info) const;
260  OCTAVE_API FloatColumnVector
261  solve (MatrixType& mattype, const FloatColumnVector& b,
262  octave_idx_type& info, float& rcon) const;
263  OCTAVE_API FloatColumnVector
264  solve (MatrixType& mattype, const FloatColumnVector& b,
265  octave_idx_type& info, float& rcon,
266  solve_singularity_handler sing_handler,
267  blas_trans_type transt = blas_no_trans) const;
268 
269  OCTAVE_API FloatComplexColumnVector
270  solve (MatrixType& mattype, const FloatComplexColumnVector& b) const;
271  OCTAVE_API FloatComplexColumnVector
272  solve (MatrixType& mattype, const FloatComplexColumnVector& b,
273  octave_idx_type& info) const;
274  OCTAVE_API FloatComplexColumnVector
275  solve (MatrixType& mattype, const FloatComplexColumnVector& b,
276  octave_idx_type& info, float& rcon) const;
277  OCTAVE_API FloatComplexColumnVector
278  solve (MatrixType& mattype, const FloatComplexColumnVector& b,
279  octave_idx_type& info, float& rcon,
280  solve_singularity_handler sing_handler,
281  blas_trans_type transt = blas_no_trans) const;
282 
283  // Generic interface to solver with probing of type
284  OCTAVE_API FloatMatrix solve (const FloatMatrix& b) const;
285  OCTAVE_API FloatMatrix
286  solve (const FloatMatrix& b, octave_idx_type& info) const;
287  OCTAVE_API FloatMatrix
288  solve (const FloatMatrix& b, octave_idx_type& info, float& rcon) const;
289  OCTAVE_API FloatMatrix
290  solve (const FloatMatrix& b, octave_idx_type& info, float& rcon,
291  solve_singularity_handler sing_handler,
292  blas_trans_type transt = blas_no_trans) const;
293 
294  OCTAVE_API FloatComplexMatrix solve (const FloatComplexMatrix& b) const;
295  OCTAVE_API FloatComplexMatrix
296  solve (const FloatComplexMatrix& b, octave_idx_type& info) const;
297  OCTAVE_API FloatComplexMatrix
298  solve (const FloatComplexMatrix& b, octave_idx_type& info,
299  float& rcon) const;
300  OCTAVE_API FloatComplexMatrix
301  solve (const FloatComplexMatrix& b, octave_idx_type& info,
302  float& rcon, solve_singularity_handler sing_handler,
303  blas_trans_type transt = blas_no_trans) const;
304 
305  OCTAVE_API FloatColumnVector solve (const FloatColumnVector& b) const;
306  OCTAVE_API FloatColumnVector
307  solve (const FloatColumnVector& b, octave_idx_type& info) const;
308  OCTAVE_API FloatColumnVector
309  solve (const FloatColumnVector& b, octave_idx_type& info, float& rcon) const;
310  OCTAVE_API FloatColumnVector
311  solve (const FloatColumnVector& b, octave_idx_type& info, float& rcon,
312  solve_singularity_handler sing_handler,
313  blas_trans_type transt = blas_no_trans) const;
314 
315  OCTAVE_API FloatComplexColumnVector
316  solve (const FloatComplexColumnVector& b) const;
317  OCTAVE_API FloatComplexColumnVector
318  solve (const FloatComplexColumnVector& b, octave_idx_type& info) const;
319  OCTAVE_API FloatComplexColumnVector
320  solve (const FloatComplexColumnVector& b, octave_idx_type& info,
321  float& rcon) const;
322  OCTAVE_API FloatComplexColumnVector
323  solve (const FloatComplexColumnVector& b, octave_idx_type& info, float& rcon,
324  solve_singularity_handler sing_handler,
325  blas_trans_type transt = blas_no_trans) const;
326 
327  // Singular solvers
328  OCTAVE_API FloatMatrix lssolve (const FloatMatrix& b) const;
329  OCTAVE_API FloatMatrix
330  lssolve (const FloatMatrix& b, octave_idx_type& info) const;
331  OCTAVE_API FloatMatrix
332  lssolve (const FloatMatrix& b, octave_idx_type& info,
333  octave_idx_type& rank) const;
334  OCTAVE_API FloatMatrix
335  lssolve (const FloatMatrix& b, octave_idx_type& info,
336  octave_idx_type& rank, float& rcon) const;
337 
338  OCTAVE_API FloatComplexMatrix lssolve (const FloatComplexMatrix& b) const;
339  OCTAVE_API FloatComplexMatrix
340  lssolve (const FloatComplexMatrix& b, octave_idx_type& info) const;
341  OCTAVE_API FloatComplexMatrix
342  lssolve (const FloatComplexMatrix& b, octave_idx_type& info,
343  octave_idx_type& rank) const;
344  OCTAVE_API FloatComplexMatrix
345  lssolve (const FloatComplexMatrix& b, octave_idx_type& info,
346  octave_idx_type& rank, float& rcon) const;
347 
348  OCTAVE_API FloatColumnVector lssolve (const FloatColumnVector& b) const;
349  OCTAVE_API FloatColumnVector
350  lssolve (const FloatColumnVector& b, octave_idx_type& info) const;
351  OCTAVE_API FloatColumnVector
352  lssolve (const FloatColumnVector& b, octave_idx_type& info,
353  octave_idx_type& rank) const;
354  OCTAVE_API FloatColumnVector
355  lssolve (const FloatColumnVector& b, octave_idx_type& info,
356  octave_idx_type& rank, float& rcon) const;
357 
358  OCTAVE_API FloatComplexColumnVector
359  lssolve (const FloatComplexColumnVector& b) const;
360  OCTAVE_API FloatComplexColumnVector
361  lssolve (const FloatComplexColumnVector& b, octave_idx_type& info) const;
362  OCTAVE_API FloatComplexColumnVector
363  lssolve (const FloatComplexColumnVector& b, octave_idx_type& info,
364  octave_idx_type& rank) const;
365  OCTAVE_API FloatComplexColumnVector
366  lssolve (const FloatComplexColumnVector& b, octave_idx_type& info,
367  octave_idx_type& rank, float& rcon) const;
368 
369  OCTAVE_API FloatMatrix& operator += (const FloatDiagMatrix& a);
370  OCTAVE_API FloatMatrix& operator -= (const FloatDiagMatrix& a);
371 
372  OCTAVE_API FloatMatrix cumprod (int dim = -1) const;
373  OCTAVE_API FloatMatrix cumsum (int dim = -1) const;
374  OCTAVE_API FloatMatrix prod (int dim = -1) const;
375  OCTAVE_API FloatMatrix sum (int dim = -1) const;
376  OCTAVE_API FloatMatrix sumsq (int dim = -1) const;
377  OCTAVE_API FloatMatrix abs () const;
378 
379  OCTAVE_API FloatMatrix diag (octave_idx_type k = 0) const;
380 
381  OCTAVE_API FloatDiagMatrix diag (octave_idx_type m, octave_idx_type n) const;
382 
383  OCTAVE_API FloatColumnVector row_min () const;
384  OCTAVE_API FloatColumnVector row_max () const;
385 
386  OCTAVE_API FloatColumnVector row_min (Array<octave_idx_type>& index) const;
387  OCTAVE_API FloatColumnVector row_max (Array<octave_idx_type>& index) const;
388 
389  OCTAVE_API FloatRowVector column_min () const;
390  OCTAVE_API FloatRowVector column_max () const;
391 
392  OCTAVE_API FloatRowVector column_min (Array<octave_idx_type>& index) const;
393  OCTAVE_API FloatRowVector column_max (Array<octave_idx_type>& index) const;
394 
395  // i/o
396 
397  friend OCTAVE_API std::ostream&
398  operator << (std::ostream& os, const FloatMatrix& a);
399  friend OCTAVE_API std::istream&
400  operator >> (std::istream& is, FloatMatrix& a);
401 };
402 
403 // Publish externally used friend functions.
404 
405 extern OCTAVE_API FloatMatrix real (const FloatComplexMatrix& a);
406 extern OCTAVE_API FloatMatrix imag (const FloatComplexMatrix& a);
407 
408 // column vector by row vector -> matrix operations
409 
410 extern OCTAVE_API FloatMatrix operator * (const FloatColumnVector& a,
411  const FloatRowVector& b);
412 
413 // Other functions.
414 
415 extern OCTAVE_API FloatMatrix Givens (float, float);
416 
417 extern OCTAVE_API FloatMatrix Sylvester (const FloatMatrix&, const FloatMatrix&,
418  const FloatMatrix&);
419 
420 extern OCTAVE_API FloatMatrix xgemm (const FloatMatrix& a, const FloatMatrix& b,
421  blas_trans_type transa = blas_no_trans,
422  blas_trans_type transb = blas_no_trans);
423 
424 extern OCTAVE_API FloatMatrix operator * (const FloatMatrix& a,
425  const FloatMatrix& b);
426 
427 extern OCTAVE_API FloatMatrix min (float d, const FloatMatrix& m);
428 extern OCTAVE_API FloatMatrix min (const FloatMatrix& m, float d);
429 extern OCTAVE_API FloatMatrix min (const FloatMatrix& a, const FloatMatrix& b);
430 
431 extern OCTAVE_API FloatMatrix max (float d, const FloatMatrix& m);
432 extern OCTAVE_API FloatMatrix max (const FloatMatrix& m, float d);
433 extern OCTAVE_API FloatMatrix max (const FloatMatrix& a, const FloatMatrix& b);
434 
435 extern OCTAVE_API FloatMatrix linspace (const FloatColumnVector& x1,
436  const FloatColumnVector& x2,
437  octave_idx_type n);
438 
439 MS_CMP_OP_DECLS (FloatMatrix, float, OCTAVE_API)
440 MS_BOOL_OP_DECLS (FloatMatrix, float, OCTAVE_API)
441 
442 SM_CMP_OP_DECLS (float, FloatMatrix, OCTAVE_API)
443 SM_BOOL_OP_DECLS (float, FloatMatrix, OCTAVE_API)
444 
445 MM_CMP_OP_DECLS (FloatMatrix, FloatMatrix, OCTAVE_API)
446 MM_BOOL_OP_DECLS (FloatMatrix, FloatMatrix, OCTAVE_API)
447 
448 MARRAY_FORWARD_DEFS (MArray, FloatMatrix, float)
449 
450 template <typename T>
451 void read_int (std::istream& is, bool swap_bytes, T& val);
452 
453 #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::index
Array< T, Alloc > index(const octave::idx_vector &i) const
Indexing without resizing.
Definition: Array-base.cc:710
Array< T >::resize
void resize(const dim_vector &dv, const T &rfv)
Definition: Array-base.cc:1023
FloatComplexMatrix::row_min
FloatComplexColumnVector row_min() const
Definition: fCMatrix.cc:2919
FloatComplexMatrix::ifourier
FloatComplexMatrix ifourier() const
Definition: fCMatrix.cc:1077
FloatComplexMatrix::sumsq
FloatComplexMatrix sumsq(int dim=-1) const
Definition: fCMatrix.cc:2847
FloatComplexMatrix::pseudo_inverse
FloatComplexMatrix pseudo_inverse(float tol=0.0) const
Definition: fCMatrix.cc:1003
FloatComplexMatrix::extract
FloatComplexMatrix extract(octave_idx_type r1, octave_idx_type c1, octave_idx_type r2, octave_idx_type c2) const
Definition: fCMatrix.cc:686
FloatComplexMatrix::lssolve
FloatComplexMatrix lssolve(const FloatMatrix &b) const
Definition: fCMatrix.cc:2245
FloatComplexMatrix::row
FloatComplexRowVector row(octave_idx_type i) const
Definition: fCMatrix.cc:705
FloatComplexMatrix::rcond
float rcond() const
Definition: fCMatrix.cc:1353
FloatComplexMatrix::column
FloatComplexColumnVector column(octave_idx_type i) const
Definition: fCMatrix.cc:711
FloatComplexMatrix::fourier2d
FloatComplexMatrix fourier2d() const
Definition: fCMatrix.cc:1106
FloatComplexMatrix::abs
FloatMatrix abs() const
Definition: fCMatrix.cc:2853
FloatComplexMatrix::cumsum
FloatComplexMatrix cumsum(int dim=-1) const
Definition: fCMatrix.cc:2829
FloatComplexMatrix::diag
FloatComplexMatrix diag(octave_idx_type k=0) const
Definition: fCMatrix.cc:2859
FloatComplexMatrix::ifourier2d
FloatComplexMatrix ifourier2d() const
Definition: fCMatrix.cc:1120
FloatComplexMatrix::fourier
FloatComplexMatrix fourier() const
Definition: fCMatrix.cc:1048
FloatComplexMatrix::sum
FloatComplexMatrix sum(int dim=-1) const
Definition: fCMatrix.cc:2841
FloatComplexMatrix::solve_singularity_handler
void(* solve_singularity_handler)(float rcon)
Definition: fCMatrix.h:61
FloatComplexMatrix::column_max
FloatComplexRowVector column_max() const
Definition: fCMatrix.cc:3144
FloatComplexMatrix::solve
FloatComplexMatrix solve(MatrixType &mattype, const FloatMatrix &b) const
Definition: fCMatrix.cc:1942
FloatComplexMatrix::column_min
FloatComplexRowVector column_min() const
Definition: fCMatrix.cc:3069
FloatComplexMatrix::determinant
FloatComplexDET determinant() const
Definition: fCMatrix.cc:1174
FloatComplexMatrix::inverse
FloatComplexMatrix inverse() const
Definition: fCMatrix.cc:740
FloatComplexMatrix::cumprod
FloatComplexMatrix cumprod(int dim=-1) const
Definition: fCMatrix.cc:2823
FloatComplexMatrix::row_max
FloatComplexColumnVector row_max() const
Definition: fCMatrix.cc:2994
FloatComplexMatrix::prod
FloatComplexMatrix prod(int dim=-1) const
Definition: fCMatrix.cc:2835
FloatComplexMatrix::extract_n
FloatComplexMatrix extract_n(octave_idx_type r1, octave_idx_type c1, octave_idx_type nr, octave_idx_type nc) const
Definition: fCMatrix.cc:696
FloatMatrix::FloatMatrix
FloatMatrix(octave_idx_type r, octave_idx_type c, float val)
Definition: fMatrix.h:73
FloatMatrix::real_matrix_type
FloatMatrix real_matrix_type
Definition: fMatrix.h:51
FloatMatrix::complex_elt_type
FloatComplex complex_elt_type
Definition: fMatrix.h:58
FloatMatrix::~FloatMatrix
~FloatMatrix()=default
FloatMatrix::resize
void resize(octave_idx_type nr, octave_idx_type nc, float rfv=0)
Definition: fMatrix.h:158
FloatMatrix::FloatMatrix
FloatMatrix(const Array< U > &a)
Definition: fMatrix.h:85
FloatMatrix::real_diag_matrix_type
FloatDiagMatrix real_diag_matrix_type
Definition: fMatrix.h:54
FloatMatrix::complex_diag_matrix_type
FloatComplexDiagMatrix complex_diag_matrix_type
Definition: fMatrix.h:55
FloatMatrix::hermitian
FloatMatrix hermitian() const
Definition: fMatrix.h:139
FloatMatrix::FloatMatrix
FloatMatrix(const dim_vector &dv)
Definition: fMatrix.h:76
FloatMatrix::FloatMatrix
FloatMatrix(octave_idx_type r, octave_idx_type c)
Definition: fMatrix.h:70
FloatMatrix::column_vector_type
FloatColumnVector column_vector_type
Definition: fMatrix.h:45
FloatMatrix::FloatMatrix
FloatMatrix(const dim_vector &dv, float val)
Definition: fMatrix.h:78
FloatMatrix::FloatMatrix
FloatMatrix(const MArray< U > &a)
Definition: fMatrix.h:82
FloatMatrix::FloatMatrix
FloatMatrix(const FloatMatrix &a)=default
FloatMatrix::real_elt_type
float real_elt_type
Definition: fMatrix.h:57
FloatMatrix::row_vector_type
FloatRowVector row_vector_type
Definition: fMatrix.h:46
FloatMatrix::FloatMatrix
FloatMatrix()=default
FloatMatrix::real_row_vector_type
FloatRowVector real_row_vector_type
Definition: fMatrix.h:49
FloatMatrix::complex_matrix_type
FloatComplexMatrix complex_matrix_type
Definition: fMatrix.h:52
FloatMatrix::real_column_vector_type
FloatColumnVector real_column_vector_type
Definition: fMatrix.h:48
FloatMatrix::transpose
FloatMatrix transpose() const
Definition: fMatrix.h:140
MArray
Template for N-dimensional array classes with like-type math operators.
Definition: MArray.h:63
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
read_int
void read_int(std::istream &is, bool swap_bytes, T &val)
Givens
FloatMatrix Givens(float, float)
Definition: fMatrix.cc:2697
operator-=
FloatMatrix operator-=(FloatMatrix &x, const float &y)
Definition: fMatrix.h:448
linspace
FloatMatrix linspace(const FloatColumnVector &x1, const FloatColumnVector &x2, octave_idx_type n)
Definition: fMatrix.cc:3018
operator+=
FloatMatrix operator+=(FloatMatrix &x, const float &y)
Definition: fMatrix.h:448
min
FloatMatrix min(float d, const FloatMatrix &m)
Definition: fMatrix.cc:2890
operator*
FloatMatrix operator*(const FloatColumnVector &a, const FloatRowVector &b)
Definition: fMatrix.cc:2354
real
FloatMatrix real(const FloatComplexMatrix &a)
Definition: fMatrix.cc:391
imag
FloatMatrix imag(const FloatComplexMatrix &a)
Definition: fMatrix.cc:397
max
FloatMatrix max(float d, const FloatMatrix &m)
Definition: fMatrix.cc:2954
Sylvester
FloatMatrix Sylvester(const FloatMatrix &, const FloatMatrix &, const FloatMatrix &)
Definition: fMatrix.cc:2714
xgemm
FloatMatrix xgemm(const FloatMatrix &a, const FloatMatrix &b, blas_trans_type transa=blas_no_trans, blas_trans_type transb=blas_no_trans)
Definition: fMatrix.cc:2792
d
F77_RET_T const F77_DBLE const F77_DBLE F77_DBLE * d
Definition: lo-slatec-proto.h:39
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