fmatvec 0.0.0

fixed_general_matrix.h
1 /* Copyright (C) 2003-2005 Martin Förg
2
3 * This library is free software; you can redistribute it and/or
4 * modify it under the terms of the GNU Lesser General Public
5 * License as published by the Free Software Foundation; either
6 * version 2.1 of the License, or (at your option) any later version.
7 *
8 * This library is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * Lesser General Public License for more details.
12 *
13 * You should have received a copy of the GNU Lesser General Public
14 * License along with this library; if not, write to the Free Software
15 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16 *
17 * Contact:
18 * martin.o.foerg@googlemail.com
19 *
20 */
21
22 #ifndef fixed_general_matrix_h
23 #define fixed_general_matrix_h
24
25 #include "types.h"
26 #include "range.h"
27 #include <vector>
28 #include <cstdlib>
29 #include <stdexcept>
30
31 namespace fmatvec {
32
41 template <int M, int N, class AT> class Matrix<General,Fixed<M>,Fixed<N>,AT> {
42
43 public:
44 static constexpr bool isVector {false};
45
46 using iterator = AT *;
47 using const_iterator = const AT *;
48 using value_type = AT;
49 using shape_type = General;
50
52
53 protected:
54
55 AT ele[M][N];
56
57 template <class Type, class Row, class Col> inline Matrix<General,Fixed<M>,Fixed<N>,AT>& copy(const Matrix<Type,Row,Col,AT> &A);
58 template<class Row> inline Matrix<General,Fixed<M>,Fixed<N>,AT>& copy(const Matrix<Symmetric,Row,Row,AT> &A);
59
61
62 public:
63
64 // Works with -std=gnu++0x only
65 // template<class Ini=All<AT>>
66 // Matrix(Ini ini=All<AT>()) {
67 // init(ini);
68 // }
69 // template<class Ini=All<AT>>
70 // Matrix(int m_, int n_, Ini ini=All<AT>()) {
71 // init(ini);
72 // }
73
74 explicit Matrix(Noinit) { }
75 explicit Matrix(Init ini=INIT, const AT &a=AT()) { init(a); }
76 explicit Matrix(Eye ini, const AT &a=1) { init(ini,a); }
77 explicit Matrix(int m, int n, Noinit) { FMATVEC_ASSERT(m==M && n==N, AT); }
78 explicit Matrix(int m, int n, Init ini=INIT, const AT &a=AT()) { FMATVEC_ASSERT(m==M && n==N, AT); init(a); }
79 explicit Matrix(int m, int n, Eye ini, const AT &a=1) { FMATVEC_ASSERT(m==M && n==N, AT); init(ini,a); }
80
86 Matrix(const Matrix<General,Fixed<M>,Fixed<N>,AT> &A) = default;
87
93 template<class Row, class Col>
94 Matrix(const Matrix<General,Row,Col,AT> &A) {
95 FMATVEC_ASSERT(A.rows() == M, AT);
96 FMATVEC_ASSERT(A.cols() == N, AT);
97 copy(A);
98 }
99
105 template<class Type, class Row, class Col>
106 explicit Matrix(const Matrix<Type,Row,Col,AT> &A) {
107 FMATVEC_ASSERT(A.rows() == M, AT);
108 FMATVEC_ASSERT(A.cols() == N, AT);
109 copy(A);
110 }
111
124 Matrix(const std::string &strs);
125 Matrix(const char *strs);
126
133 inline Matrix<General,Fixed<M>,Fixed<N>,AT>& operator=(const Matrix<General,Fixed<M>,Fixed<N>,AT> &A) = default;
134
141 template <class Type, class Row, class Col>
142 inline Matrix<General,Fixed<M>,Fixed<N>,AT>& operator=(const Matrix<Type,Row,Col,AT> &A) {
143 FMATVEC_ASSERT(A.rows() == M, AT);
144 FMATVEC_ASSERT(A.cols() == N, AT);
145 return copy(A);
146 }
147
154 template<class Type, class Row, class Col>
155 inline Matrix<General,Fixed<M>,Fixed<N>,AT>& operator<<=(const Matrix<Type,Row,Col,AT> &A) { return operator=(A); }
156
157 template <class AT2>
158 operator Matrix<General,Fixed<M>,Fixed<N>,AT2>() const {
159 Matrix<General,Fixed<M>,Fixed<N>,AT2> ret;
160 for(size_t r=0; r<M; ++r)
161 for(size_t c=0; c<N; ++c)
162 ret(r,c) = (*this)(r,c);
163 return ret;
164 }
165
166 iterator begin() { return &ele[0][0]; }
167 iterator end() { return &ele[M-1][N]; }
168 const_iterator begin() const { return &ele[0][0]; }
169 const_iterator end() const { return &ele[M-1][N]; }
170
180 AT& operator()(int i, int j) {
181 FMATVEC_ASSERT(i>=0, AT);
182 FMATVEC_ASSERT(j>=0, AT);
183 FMATVEC_ASSERT(i<M, AT);
184 FMATVEC_ASSERT(j<N, AT);
185
186 return e(i,j);
187 }
188
193 const AT& operator()(int i, int j) const {
194 FMATVEC_ASSERT(i>=0, AT);
195 FMATVEC_ASSERT(j>=0, AT);
196 FMATVEC_ASSERT(i<M, AT);
197 FMATVEC_ASSERT(j<N, AT);
198
199 return e(i,j);
200 }
201
202 AT& e(int i, int j) {
203 return ele[i][j];
204 }
205
210 const AT& e(int i, int j) const {
211 return ele[i][j];
212 }
213
219 AT* operator()() {return &(ele[0][0]);}
220
225 const AT* operator()() const {return &(ele[0][0]);}
226
231 constexpr int rows() const {return M;}
232
237 constexpr int cols() const {return N;}
238
243 int ldim() const {return N;}
244
247 void resize(int m, int n) {
248 if(m!=M || n!=N)
249 throw std::runtime_error("A fixed matrix cannot be resized.");
250 }
251
258 const CBLAS_TRANSPOSE blasTrans() const {
259 return CblasNoTrans;
260 }
261
269 const CBLAS_ORDER blasOrder() const {
270 return CblasRowMajor;
271 }
272
277 inline const Matrix<General,Var,Var,AT> operator()(const Range<Var,Var> &I, const Range<Var,Var> &J) const;
278
279 template <int M1, int M2, int N1, int N2>
280 inline const Matrix<General,Fixed<M2-M1+1>,Fixed<N2-N1+1>,AT> operator()(const Range<Fixed<M1>,Fixed<M2>> &I, const Range<Fixed<N1>,Fixed<N2>> &J) const;
281 template <int M1, int M2>
282 inline const Matrix<General,Fixed<M2-M1+1>,Var,AT> operator()(const Range<Fixed<M1>,Fixed<M2>> &I, const Range<Var,Var > &J) const;
283
284 template <int N1, int N2>
285 inline const Matrix<General,Var,Fixed<N2-N1+1>,AT> operator()(const Range<Var,Var> &I, const Range<Fixed<N1>,Fixed<N2>> &J) const;
286
287 inline const RowVector<Fixed<N>,AT> row(int i) const;
288 inline const Vector<Fixed<M>,AT> col(int j) const;
289
297 inline Matrix<General,Fixed<M>,Fixed<N>,AT>& init(const AT &val=AT());
298 inline Matrix<General,Fixed<M>,Fixed<N>,AT>& init(Init, const AT &a=AT()) { return init(a); }
299 inline Matrix<General,Fixed<M>,Fixed<N>,AT>& init(Eye, const AT &val=1);
300 inline Matrix<General,Fixed<M>,Fixed<N>,AT>& init(Noinit, const AT &a=AT()) { return *this; }
301
306 explicit inline operator std::vector<std::vector<AT>>() const;
307
313 explicit Matrix(const std::vector<std::vector<AT>> &m);
314
315 // /*! \brief Cast to AT.
316 // *
317 // * \return The AT representation of the matrix
318 // * */
319 // explicit operator AT() const {
320 // FMATVEC_ASSERT(M==1, AT);
321 // FMATVEC_ASSERT(N==1, AT);
322 // return ele[0][0];
323 // }
324 //
325 // /*! \brief AT Constructor.
326 // * Constructs and initializes a matrix with a AT object.
327 // * \param v The AT the matrix will be initialized with.
328 // * */
329 // explicit Matrix(const AT &x) {
330 // FMATVEC_ASSERT(M==1, AT);
331 // FMATVEC_ASSERT(N==1, AT);
332 // ele[0][0] = x;
333 // }
334
335 inline const Matrix<General,Fixed<N>,Fixed<M>,AT> T() const;
336
340 template<class Row> inline void set(int j, const Vector<Row,AT> &x);
341
345 template<class Col> inline void set(int i, const RowVector<Col,AT> &x);
346
353 template<class Type, class Row, class Col> inline void set(const Range<Var,Var> &I, const Range<Var,Var> &J, const Matrix<Type,Row,Col,AT> &A);
354
358 template<class Row> inline void add(int j, const Vector<Row,AT> &x);
359
363 template<class Col> inline void add(int i, const RowVector<Col,AT> &x);
364
365 template<class Type, class Row, class Col> inline void add(const Range<Var,Var> &I, const Range<Var,Var> &J, const Matrix<Type,Row,Col,AT> &A);
366 };
367
368 template <int M, int N, class AT>
369 Matrix<General,Fixed<M>,Fixed<N>,AT>::Matrix(const std::string &strs) {
370 std::istringstream iss(strs);
371 iss>>*this;
372
373 // check end of stream
374 iss>>std::ws;
375 if(!iss.eof())
376 throw std::runtime_error("Input not fully read.");
377 }
378 template <int M, int N, class AT> Matrix<General,Fixed<M>,Fixed<N>,AT>::Matrix(const char *strs) :
379 Matrix<General,Fixed<M>,Fixed<N>,AT>::Matrix(std::string(strs)) {}
380
381 template <int M, int N, class AT>
382 inline Matrix<General,Fixed<M>,Fixed<N>,AT>& Matrix<General,Fixed<M>,Fixed<N>,AT>::init(const AT &val) {
383 for(int i=0; i<M; i++)
384 for(int j=0; j<N; j++)
385 e(i,j) = val;
386 return *this;
387 }
388
389 template <int M, int N, class AT>
390 inline Matrix<General,Fixed<M>,Fixed<N>,AT>& Matrix<General,Fixed<M>,Fixed<N>,AT>::init(Eye, const AT &val) {
391 for(int i=0; i<M; i++)
392 for(int j=0; j<N; j++)
393 e(i,j) = (i==j) ? val : 0;
394 return *this;
395 }
396
397 template <int M, int N, class AT>
398 inline const Matrix<General,Var,Var,AT> Matrix<General,Fixed<M>,Fixed<N>,AT>::operator()(const Range<Var,Var> &I, const Range<Var,Var> &J) const {
399 FMATVEC_ASSERT(I.end()<M, AT);
400 FMATVEC_ASSERT(J.end()<N, AT);
401 Matrix<General,Var,Var,AT> A(I.size(),J.size(),NONINIT);
402
403 for(int i=0; i<A.rows(); i++)
404 for(int j=0; j<A.cols(); j++)
405 A.e(i,j) = e(I.start()+i,J.start()+j);
406
407 return A;
408 }
409
410 template <int M, int N, class AT> template <int M1, int M2, int N1, int N2>
411 inline const Matrix<General,Fixed<M2-M1+1>,Fixed<N2-N1+1>,AT> Matrix<General,Fixed<M>,Fixed<N>,AT>::operator()(const Range<Fixed<M1>,Fixed<M2>> &I, const Range<Fixed<N1>,Fixed<N2>> &J) const {
412 FMATVEC_ASSERT(M2<M, AT);
413 FMATVEC_ASSERT(N2<N, AT);
414 Matrix<General,Fixed<M2-M1+1>,Fixed<N2-N1+1>,AT> A(NONINIT);
415
416 for(int i=0; i<A.rows(); i++)
417 for(int j=0; j<A.cols(); j++)
418 A.e(i,j) = e(M1+i,J.start()+j);
419
420 return A;
421 }
422
423 template <int M, int N, class AT> template <int M1, int M2>
424 inline const Matrix<General,Fixed<M2-M1+1>,Var,AT> Matrix<General,Fixed<M>,Fixed<N>,AT>::operator()(const Range<Fixed<M1>,Fixed<M2>> &I, const Range<Var,Var> &J) const {
425 FMATVEC_ASSERT(M2<M, AT);
426 FMATVEC_ASSERT(J.end()<N, AT);
427 Matrix<General,Fixed<M2-M1+1>,Var,AT> A(J.size(),NONINIT);
428
429 for(int i=0; i<A.rows(); i++)
430 for(int j=0; j<A.cols(); j++)
431 A.e(i,j) = e(I.start()+i,J.start()+j);
432
433 return A;
434 }
435
436 template <int M, int N, class AT> template <int N1, int N2>
437 inline const Matrix<General,Var,Fixed<N2-N1+1>,AT> Matrix<General,Fixed<M>,Fixed<N>,AT>::operator()(const Range<Var,Var> &I, const Range<Fixed<N1>,Fixed<N2>> &J) const {
438 FMATVEC_ASSERT(I.end()<M, AT);
439 FMATVEC_ASSERT(N2<N, AT);
440 Matrix<General,Var,Fixed<N2-N1+1>,AT> A(I.size(),NONINIT);
441
442 for(int i=0; i<A.rows(); i++)
443 for(int j=0; j<A.cols(); j++)
444 A.e(i,j) = e(I.start()+i,J.start()+j);
445
446 return A;
447 }
448
449 template <int M, int N, class AT>
450 inline const RowVector<Fixed<N>,AT> Matrix<General,Fixed<M>,Fixed<N>,AT>::row(int i) const {
451
452 FMATVEC_ASSERT(i>=0, AT);
453 FMATVEC_ASSERT(i<M, AT);
454
455 RowVector<Fixed<N>,AT> x(NONINIT);
456
457 for(int j=0; j<N; j++)
458 x.e(j) = e(i,j);
459
460 return x;
461 }
462
463 template <int M, int N, class AT>
464 inline const Vector<Fixed<M>,AT> Matrix<General,Fixed<M>,Fixed<N>,AT>::col(int j) const {
465
466 FMATVEC_ASSERT(j>=0, AT);
467 FMATVEC_ASSERT(j<N, AT);
468
469 Vector<Fixed<M>,AT> x(NONINIT);
470
471 for(int i=0; i<M; i++)
472 x.e(i) = e(i,j);
473
474 return x;
475 }
476
477 template <int M, int N, class AT>
478 inline const Matrix<General,Fixed<N>,Fixed<M>,AT> Matrix<General,Fixed<M>,Fixed<N>,AT>::T() const {
479 Matrix<General,Fixed<N>,Fixed<M>,AT> A(NONINIT);
480 for(int i=0; i<N; i++)
481 for(int j=0; j<M; j++)
482 A.e(i,j) = e(j,i);
483 return A;
484 }
485
486 template <int M, int N, class AT> template <class Row>
487 inline void Matrix<General,Fixed<M>,Fixed<N>,AT>::set(int j, const Vector<Row,AT> &x) {
488 FMATVEC_ASSERT(j<cols(), AT);
489 FMATVEC_ASSERT(rows()==x.size(), AT);
490 for(int i=0; i<rows(); i++)
491 e(i,j) = x.e(i);
492 }
493
494 template <int M, int N, class AT> template <class Col>
495 inline void Matrix<General,Fixed<M>,Fixed<N>,AT>::set(int i, const RowVector<Col,AT> &x) {
496 FMATVEC_ASSERT(i<rows(), AT);
497 FMATVEC_ASSERT(cols()==x.size(), AT);
498 for(int j=0; j<cols(); j++)
499 e(i,j) = x.e(j);
500 }
501
502 template <int M, int N, class AT> template<class Type, class Row, class Col>
503 inline void Matrix<General,Fixed<M>,Fixed<N>,AT>::set(const Range<Var,Var> &I, const Range<Var,Var> &J, const Matrix<Type,Row,Col,AT> &A) {
504
505 FMATVEC_ASSERT(I.end()<rows(), AT);
506 FMATVEC_ASSERT(J.end()<cols(), AT);
507 FMATVEC_ASSERT(I.size()==A.rows(), AT);
508 FMATVEC_ASSERT(J.size()==A.cols(), AT);
509
510 for(int i=I.start(), ii=0; i<=I.end(); i++, ii++)
511 for(int j=J.start(), jj=0; j<=J.end(); j++, jj++)
512 e(i,j) = A.e(ii,jj);
513 }
514
515 template <int M, int N, class AT> template <class Row>
516 inline void Matrix<General,Fixed<M>,Fixed<N>,AT>::add(int j, const Vector<Row,AT> &x) {
517 FMATVEC_ASSERT(j<cols(), AT);
518 FMATVEC_ASSERT(rows()==x.size(), AT);
519 for(int i=0; i<rows(); i++)
520 e(i,j) += x.e(i);
521 }
522
523 template <int M, int N, class AT> template <class Col>
524 inline void Matrix<General,Fixed<M>,Fixed<N>,AT>::add(int i, const RowVector<Col,AT> &x) {
525 FMATVEC_ASSERT(i<rows(), AT);
526 FMATVEC_ASSERT(cols()==x.size(), AT);
527 for(int j=0; j<cols(); j++)
528 e(i,j) += x.e(j);
529 }
530
531 template <int M, int N, class AT> template<class Type, class Row, class Col>
532 inline void Matrix<General,Fixed<M>,Fixed<N>,AT>::add(const Range<Var,Var> &I, const Range<Var,Var> &J, const Matrix<Type,Row,Col,AT> &A) {
533
534 FMATVEC_ASSERT(I.end()<rows(), AT);
535 FMATVEC_ASSERT(J.end()<cols(), AT);
536 FMATVEC_ASSERT(I.size()==A.rows(), AT);
537 FMATVEC_ASSERT(J.size()==A.cols(), AT);
538
539 for(int i=I.start(), ii=0; i<=I.end(); i++, ii++)
540 for(int j=J.start(), jj=0; j<=J.end(); j++, jj++)
541 e(i,j) += A.e(ii,jj);
542 }
543
544 template <int M, int N, class AT>
545 inline Matrix<General,Fixed<M>,Fixed<N>,AT>::operator std::vector<std::vector<AT>>() const {
546 std::vector<std::vector<AT>> ret(rows(),std::vector<AT>(cols()));
547 for(int r=0; r<rows(); r++) {
548 for(int c=0; c<cols(); c++)
549 ret[r][c]=e(r,c);
550 }
551 return ret;
552 }
553
554 template <int M, int N, class AT>
555 inline Matrix<General,Fixed<M>,Fixed<N>,AT>::Matrix(const std::vector<std::vector<AT>> &m) {
556 if(m.size() != M)
557 throw std::runtime_error("The input has "+std::to_string(m.size())+" rows but "+std::to_string(M)+" rows are required.");
558 if(m[0].size() != N)
559 throw std::runtime_error("The input has "+std::to_string(m[0].size())+" columne but "+std::to_string(N)+" columns are required.");
560 for(int r=0; r<rows(); r++) {
561 if(static_cast<int>(m[r].size())!=cols())
562 throw std::runtime_error("The rows of the input have different length.");
563 for(int c=0; c<cols(); c++)
564 e(r,c)=m[r][c];
565 }
566 }
567
569
570 template <int M, int N, class AT> template <class Type, class Row, class Col>
571 inline Matrix<General,Fixed<M>,Fixed<N>,AT>& Matrix<General,Fixed<M>,Fixed<N>,AT>::copy(const Matrix<Type,Row,Col,AT> &A) {
572 for(int i=0; i<M; i++)
573 for(int j=0; j<N; j++)
574 e(i,j) = A.e(i,j);
575 return *this;
576 }
577
578 template<int M, int N, class AT> template<class Row>
579 inline Matrix<General,Fixed<M>,Fixed<N>,AT>& Matrix<General,Fixed<M>,Fixed<N>,AT>::copy(const Matrix<Symmetric,Row,Row,AT> &A) {
580 for(int i=0; i<A.size(); i++) {
581 e(i,i) = A.ej(i,i);
582 for(int j=i+1; j<A.size(); j++)
583 e(i,j) = e(j,i) = A.ej(i,j);
584 }
585 return *this;
586 }
587
589
597 template<int M, class AT>
598 class Matrix<Rotation,Fixed<M>,Fixed<M>,AT> : public Matrix<General,Fixed<M>,Fixed<M>,AT> {
599 public:
600 using value_type = AT;
601 using shape_type = Rotation;
602 // Constructors are not inherited. Hence we must redefine all ctors here.
603
604 Matrix(Noinit ini) { }
605 Matrix(Init ini=INIT, const AT &a=0) { this->init(a); }
606 Matrix(Eye ini, const AT &a=1) { this->init(ini,a); }
607
608 Matrix(int m, int n) { }
609 Matrix(int m, int n, Noinit ini) { }
610 Matrix(int m, int n, Init ini, const AT &a=0) { this->init(a); }
611 Matrix(int m, int n, Eye ini, const AT &a=1) { this->init(ini,a); }
612
613 Matrix(const Matrix<Rotation,Fixed<M>,Fixed<M>,AT> &A) = default;
614
615 explicit Matrix(const Matrix<General,Fixed<M>,Fixed<M>,AT> &A) : Matrix<General,Fixed<M>,Fixed<M>,AT>(A) { }
616
617 template<class Row>
618 explicit Matrix(const Matrix<Symmetric,Row,Row,AT> &A) : Matrix<General,Fixed<M>,Fixed<M>,AT>(A) { }
619
620 template<class Type, class Row, class Col>
621 explicit Matrix(const Matrix<Type,Row,Col,AT> &A) : Matrix<General,Fixed<M>,Fixed<M>,AT>(A) { }
622
623 explicit Matrix(const std::vector<std::vector<AT>> &m) : Matrix<General,Fixed<M>,Fixed<M>,AT>(m) { }
624
625 inline const Matrix<Rotation,Fixed<M>,Fixed<M>,AT> T() const;
626
627 using Matrix<General,Fixed<M>,Fixed<M>,AT>::e;
628
629 // TODO: we should add some overloaded member functions here which capitalize the special
630 // properties of rotation matrices, link "RotMat inv() { return trans(*this); }"
631 };
632
633 template <int M, class AT>
634 inline const Matrix<Rotation,Fixed<M>,Fixed<M>,AT> Matrix<Rotation,Fixed<M>,Fixed<M>,AT>::T() const {
635 Matrix<Rotation,Fixed<M>,Fixed<M>,AT> A(NONINIT);
636 for(int i=0; i<M; i++)
637 for(int j=0; j<M; j++)
638 A.e(i,j) = e(j,i);
639 return A;
640 }
641
642 }
643
644 #endif
fmatvec::Range< Var, Var >::end
int end() const
Last element.
Definition: range.h:91
fmatvec::Matrix< General, Fixed< M >, Fixed< N >, AT >::operator=
Matrix< General, Fixed< M >, Fixed< N >, AT > & operator=(const Matrix< Type, Row, Col, AT > &A)
Assignment operator.
Definition: fixed_general_matrix.h:142
fmatvec::Matrix< General, Fixed< M >, Fixed< N >, AT >::rows
constexpr int rows() const
Number of rows.
Definition: fixed_general_matrix.h:231
fmatvec::Fixed
Definition: fmatvec.h:39
fmatvec::Matrix
This is the basic matrix class for arbitrary matrices.
Definition: fmatvec.h:42
fmatvec::Matrix< General, Fixed< M >, Fixed< N >, AT >::operator()
const AT & operator()(int i, int j) const
Element operator.
Definition: fixed_general_matrix.h:193
fmatvec::Matrix< General, Fixed< M >, Fixed< N >, AT >::operator()
AT * operator()()
Pointer operator.
Definition: fixed_general_matrix.h:219
fmatvec::Matrix< General, Var, Var, AT >
This is a matrix class for general matrices.
Definition: var_general_matrix.h:41
fmatvec::Matrix< General, Fixed< M >, Fixed< N >, AT >::ldim
int ldim() const
Leading dimension.
Definition: fixed_general_matrix.h:243
fmatvec::Matrix::operator()
AT & operator()(int i, int j)
Standard constructor.
Definition: matrix.h:84
fmatvec::Init
Definition: types.h:89
fmatvec::Var
Definition: types.h:101
fmatvec::RowVector
Definition: fmatvec.h:51
fmatvec::Rotation
Shape class for rotation matrices.
Definition: types.h:136
fmatvec::Range< Var, Var >::start
int start() const
First element.
Definition: range.h:85
fmatvec::Vector
Definition: fmatvec.h:48
fmatvec::Matrix< General, Fixed< M >, Fixed< N >, AT >::Matrix
Matrix(const Matrix< Type, Row, Col, AT > &A)
Copy Constructor.
Definition: fixed_general_matrix.h:106
fmatvec::Matrix::cols
int cols() const
Number of columns.
fmatvec::Matrix< General, Fixed< M >, Fixed< N >, AT >::e
const AT & e(int i, int j) const
Element operator.
Definition: fixed_general_matrix.h:210
fmatvec::Matrix< General, Fixed< M >, Fixed< N >, AT >::blasTrans
const CBLAS_TRANSPOSE blasTrans() const
Transposed status.
Definition: fixed_general_matrix.h:258
fmatvec::Matrix< General, Fixed< M >, Fixed< N >, AT >::blasOrder
const CBLAS_ORDER blasOrder() const
Storage convention.
Definition: fixed_general_matrix.h:269
fmatvec::Range
This is an index class for creating submatrices.
Definition: range.h:35
fmatvec
Namespace fmatvec.
Definition: _memory.cc:28
fmatvec::Range< Var, Var >::size
int size() const
Size.
Definition: range.h:97
fmatvec::Matrix< General, Fixed< M >, Fixed< N >, AT >::operator()
const AT * operator()() const
Pointer operator.
Definition: fixed_general_matrix.h:225
fmatvec::Noinit
Definition: types.h:88
fmatvec::Matrix< General, Fixed< M >, Fixed< N >, AT >::operator()
AT & operator()(int i, int j)
Element operator.
Definition: fixed_general_matrix.h:180
fmatvec::General
Shape class for general matrices.
Definition: types.h:112
fmatvec::Matrix< General, Fixed< M >, Fixed< N >, AT >::resize
void resize(int m, int n)
Definition: fixed_general_matrix.h:247
fmatvec::Matrix< General, Fixed< M >, Fixed< N >, AT >::Matrix
Matrix(const Matrix< General, Row, Col, AT > &A)
Copy Constructor.
Definition: fixed_general_matrix.h:94
fmatvec::Matrix< General, Fixed< M >, Fixed< N >, AT >::cols
constexpr int cols() const
Number of columns.
Definition: fixed_general_matrix.h:237
fmatvec::Matrix::rows
int rows() const
Number of rows.
fmatvec::Range< Var, Var >
This is an index class for creating submatrices.
Definition: range.h:44
fmatvec::Eye
Definition: types.h:90