fmatvec  0.0.0
Fast Matrix/Vector Library
linear_algebra.h
1 /* Copyright (C) 2003-2005 Martin Förg, Rober Huber
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 linear_algebra_h
23 #define linear_algebra_h
24 
25 #include "square_matrix.h"
26 #include "vector.h"
27 #include "row_vector.h"
28 #include "fixed_square_matrix.h"
29 #include "fixed_vector.h"
30 #include "fixed_row_vector.h"
31 #include "fixed_symmetric_matrix.h"
32 #include "var_square_matrix.h"
33 #include "var_symmetric_matrix.h"
34 #include "var_vector.h"
35 #include "var_row_vector.h"
36 #include "var_fixed_general_matrix.h"
37 #include "fixed_var_general_matrix.h"
38 #include "diagonal_matrix.h"
39 #include <cmath>
40 
41 namespace fmatvec {
42 
43  // template declaration for complex type defined in linear_algebra_complex.h
44  template<class T> std::complex<T> operator+(const std::complex<T> &x, int y);
45  template<class T> std::complex<T> operator-(const std::complex<T> &x, int y);
46  template<class T> std::complex<T> operator*(const std::complex<T> &x, int y);
47  template<class T> std::complex<T> operator/(const std::complex<T> &x, int y);
48  template<class T> std::complex<T> operator+(int x, const std::complex<T> &y);
49  template<class T> std::complex<T> operator-(int x, const std::complex<T> &y);
50  template<class T> std::complex<T> operator*(int x, const std::complex<T> &y);
51  template<class T> std::complex<T> operator/(int x, const std::complex<T> &y);
52 
54 
55  // Vector-Vector
56  template <class Row1, class Row2, class Row3, class AT1, class AT2, class AT3>
57  inline void add(const Vector<Row1, AT1> &a1, const Vector<Row2, AT2> &a2, Vector<Row3, AT3> &a3) {
58  FMATVEC_ASSERT(a1.size() == a2.size(), AT3);
59  for (int i = 0; i < a1.size(); i++)
60  a3.e(i) = a1.e(i) + a2.e(i);
61  }
62 
63  template <class Row1, class Row2, class AT>
64  inline void add(Vector<Row1, AT> &a1, const Vector<Row2, AT> &a2) {
65  FMATVEC_ASSERT(a1.size() == a2.size(), AT);
66  for (int i = 0; i < a1.size(); i++)
67  a1.e(i) += a2.e(i);
68  }
69 
70  template <class Row1, class Row2, class Row3, class AT1, class AT2>
71  inline void sub(const Vector<Row1, AT1> &a1, const Vector<Row2, AT2> &a2, Vector<Row3, typename fmatvec::OperatorResult<AT1, AT2>::Type> &a3) {
72  FMATVEC_ASSERT(a1.size() == a2.size(), AT2);
73  for (int i = 0; i < a1.size(); i++)
74  a3.e(i) = a1.e(i) - a2.e(i);
75  }
76 
77  template <class Row1, class Row2, class AT1, class AT2>
78  inline void sub(Vector<Row1, AT1> &a1, const Vector<Row2, AT2> &a2) {
79  FMATVEC_ASSERT(a1.size() == a2.size(), AT2);
80  for (int i = 0; i < a1.size(); i++)
81  a1.e(i) -= a2.e(i);
82  }
83 
84  // Addition
85  template <class AT1, class AT2, class Row1, class Row2>
86  inline Vector<Var, typename OperatorResult<AT1, AT2>::Type> operator+(const Vector<Row1, AT1> &a, const Vector<Row2, AT2> &b) {
87  Vector<Var, typename OperatorResult<AT1, AT2>::Type> c(a.size(), NONINIT);
88  add(a, b, c);
89  return c;
90  }
91  template <class AT1, class AT2, class Row>
92  inline Vector<Row, typename OperatorResult<AT1, AT2>::Type> operator+(const Vector<Row, AT1> &a, const Vector<Row, AT2> &b) {
93  Vector<Row, typename OperatorResult<AT1, AT2>::Type> c(a.size(), NONINIT);
94  add(a, b, c);
95  return c;
96  }
97  template <class AT1, class AT2, int M, class Row>
98  inline Vector<Fixed<M>, typename OperatorResult<AT1, AT2>::Type> operator+(const Vector<Fixed<M>, AT1> &a, const Vector<Row, AT2> &b) {
99  Vector<Fixed<M>, typename OperatorResult<AT1, AT2>::Type> c(a.size(), NONINIT);
100  add(a, b, c);
101  return c;
102  }
103  template <class AT1, class AT2, int M>
104  inline Vector<Fixed<M>, typename OperatorResult<AT1, AT2>::Type> operator+(const Vector<Fixed<M>, AT1> &a, const Vector<Fixed<M>, AT2> &b) {
105  Vector<Fixed<M>, typename OperatorResult<AT1, AT2>::Type> c(a.size(), NONINIT);
106  add(a, b, c);
107  return c;
108  }
109  // move
110  template <class Row1, class Row2>
111  inline Vector<Row2, double> operator+(Vector<Row1, double> &&a, Vector<Row2, double> &&b) {
112  add(a, b);
113  return std::move(a);
114  }
115  template <class Row1, class Row2>
116  inline Vector<Row1, double> operator+(Vector<Row1, double> &&a, const Vector<Row2, double> &b) {
117  add(a, b);
118  return std::move(a);
119  }
120  template <class Row1, class Row2>
121  inline Vector<Row2, double> operator+(const Vector<Row1, double> &a, Vector<Row2, double> &&b) {
122  add(b, a);
123  return std::move(b);
124  }
125  template <class AT, class Row1, class Row2>
126  inline Vector<Row1, AT> operator+=(Vector<Row1, AT> &a, const Vector<Row2, AT> &b) {
127  add(a, b);
128  return a;
129  }
130 
131  // Subtraction
132  template <class AT1, class AT2, class Row1, class Row2>
133  inline Vector<Var, typename fmatvec::OperatorResult<AT1, AT2>::Type> operator-(const Vector<Row1, AT1> &a, const Vector<Row2, AT2> &b) {
134  Vector<Var, typename fmatvec::OperatorResult<AT1, AT2>::Type> c(a.size(), NONINIT);
135  sub(a, b, c);
136  return c;
137  }
138  template <class AT1, class AT2, class Row>
139  inline Vector<Row, typename fmatvec::OperatorResult<AT1, AT2>::Type> operator-(const Vector<Row, AT1> &a, const Vector<Row, AT2> &b) {
140  Vector<Row, typename fmatvec::OperatorResult<AT1, AT2>::Type> c(a.size(), NONINIT);
141  sub(a, b, c);
142  return c;
143  }
144  template <class AT1, class AT2, int M, class Row2>
145  inline Vector<Fixed<M>, typename fmatvec::OperatorResult<AT1, AT2>::Type> operator-(const Vector<Fixed<M>, AT1> &a, const Vector<Row2, AT2> &b) {
146  Vector<Fixed<M>, typename fmatvec::OperatorResult<AT1, AT2>::Type> c(a.size(), NONINIT);
147  sub(a, b, c);
148  return c;
149  }
150  template <class AT1, class AT2, int M>
151  inline Vector<Fixed<M>, typename fmatvec::OperatorResult<AT1, AT2>::Type> operator-(const Vector<Fixed<M>, AT1> &a, const Vector<Fixed<M>, AT2> &b) {
152  Vector<Fixed<M>, typename fmatvec::OperatorResult<AT1, AT2>::Type> c(a.size(), NONINIT);
153  sub(a, b, c);
154  return c;
155  }
156  // move
157  template <class Row1, class Row2>
158  inline Vector<Row2, double> operator-(Vector<Row1, double> &&a, Vector<Row2, double> &&b) {
159  sub(a, b);
160  return std::move(a);
161  }
162  template <class Row1, class Row2>
163  inline Vector<Row1, double> operator-(Vector<Row1, double> &&a, const Vector<Row2, double> &b) {
164  sub(a, b);
165  return std::move(a);
166  }
167  template <class Row1, class Row2>
168  inline Vector<Row2, double> operator-(const Vector<Row1, double> &a, Vector<Row2, double> &&b) {
169  FMATVEC_ASSERT(a.size() == b.size(), double);
170  for (int i = 0; i < a.size(); i++)
171  b.e(i) = a.e(i) - b.e(i);
172  return std::move(b);
173  }
174  template <class AT, class Row1, class Row2>
175  inline Vector<Row1, AT> operator-=(Vector<Row1, AT> &a, const Vector<Row2, AT> &b) {
176  sub(a, b);
177  return a;
178  }
179 
180  // RowVector-Vector
181  template <class Col1, class Col2, class Col3, class AT>
182  inline void add(const RowVector<Col1, AT> &a1, const RowVector<Col2, AT> &a2, RowVector<Col3, AT> &a3) {
183  FMATVEC_ASSERT(a1.size() == a2.size(), AT);
184  for (int i = 0; i < a1.size(); i++)
185  a3.e(i) = a1.e(i) + a2.e(i);
186  }
187 
188  template <class Col1, class Col2, class AT>
189  inline void add(RowVector<Col1, AT> &a1, const RowVector<Col2, AT> &a2) {
190  FMATVEC_ASSERT(a1.size() == a2.size(), AT);
191  for (int i = 0; i < a1.size(); i++)
192  a1.e(i) += a2.e(i);
193  }
194 
195  template <class Col1, class Col2, class Col3, class AT1, class AT2>
196  inline void sub(const RowVector<Col1, AT1> &a1, const RowVector<Col2, AT2> &a2, RowVector<Col3, typename fmatvec::OperatorResult<AT1, AT2>::Type> &a3) {
197  FMATVEC_ASSERT(a1.size() == a2.size(), AT2);
198  for (int i = 0; i < a1.size(); i++)
199  a3.e(i) = a1.e(i) - a2.e(i);
200  }
201 
202  template <class Col1, class Col2, class AT1, class AT2>
203  inline void sub(RowVector<Col1, AT1> &a1, const RowVector<Col2, AT2> &a2) {
204  FMATVEC_ASSERT(a1.size() == a2.size(), AT2);
205  for (int i = 0; i < a1.size(); i++)
206  a1.e(i) -= a2.e(i);
207  }
208 
209  // Addition
210  template <class AT1, class AT2, class Col1, class Col2>
211  inline RowVector<Var, typename OperatorResult<AT1, AT2>::Type> operator+(const RowVector<Col1, AT1> &a, const RowVector<Col2, AT2> &b) {
212  RowVector<Var, typename OperatorResult<AT1, AT2>::Type> c(a.size(), NONINIT);
213  add(a, b, c);
214  return c;
215  }
216  template <class AT1, class AT2, class Col>
217  inline RowVector<Col, typename OperatorResult<AT1, AT2>::Type> operator+(const RowVector<Col, AT1> &a, const RowVector<Col, AT2> &b) {
218  RowVector<Col, typename OperatorResult<AT1, AT2>::Type> c(a.size(), NONINIT);
219  add(a, b, c);
220  return c;
221  }
222  template <class AT1, class AT2, int N, class Col2>
223  inline RowVector<Fixed<N>, typename OperatorResult<AT1, AT2>::Type> operator+(const RowVector<Fixed<N>, AT1> &a, const RowVector<Col2, AT2> &b) {
224  RowVector<Fixed<N>, typename OperatorResult<AT1, AT2>::Type> c(a.size(), NONINIT);
225  add(a, b, c);
226  return c;
227  }
228  template <class AT1, class AT2, int N>
229  inline RowVector<Fixed<N>, typename OperatorResult<AT1, AT2>::Type> operator+(const RowVector<Fixed<N>, AT1> &a, const RowVector<Fixed<N>, AT2> &b) {
230  RowVector<Fixed<N>, typename OperatorResult<AT1, AT2>::Type> c(a.size(), NONINIT);
231  add(a, b, c);
232  return c;
233  }
234  // move
235  template <class Row1, class Row2>
236  inline RowVector<Row2, double> operator+(RowVector<Row1, double> &&a, RowVector<Row2, double> &&b) {
237  add(a, b);
238  return std::move(a);
239  }
240  template <class Row1, class Row2>
241  inline RowVector<Row1, double> operator+(RowVector<Row1, double> &&a, const RowVector<Row2, double> &b) {
242  add(a, b);
243  return std::move(a);
244  }
245  template <class Row1, class Row2>
246  inline RowVector<Row2, double> operator+(const RowVector<Row1, double> &a, RowVector<Row2, double> &&b) {
247  add(b, a);
248  return std::move(b);
249  }
250  template <class AT, class Col1, class Col2>
251  inline RowVector<Col1, AT> operator+=(RowVector<Col1, AT> &a, const RowVector<Col2, AT> &b) {
252  add(a, b);
253  return a;
254  }
255 
256  // Subtraction
257  template <class AT1, class AT2, class Col1, class Col2>
258  inline RowVector<Var, typename fmatvec::OperatorResult<AT1, AT2>::Type> operator-(const RowVector<Col1, AT1> &a, const RowVector<Col2, AT2> &b) {
259  RowVector<Var, typename fmatvec::OperatorResult<AT1, AT2>::Type> c(a.size(), NONINIT);
260  sub(a, b, c);
261  return c;
262  }
263  template <class AT1, class AT2, class Col>
264  inline RowVector<Col, typename fmatvec::OperatorResult<AT1, AT2>::Type> operator-(const RowVector<Col, AT1> &a, const RowVector<Col, AT2> &b) {
265  RowVector<Col, typename fmatvec::OperatorResult<AT1, AT2>::Type> c(a.size(), NONINIT);
266  sub(a, b, c);
267  return c;
268  }
269  template <class AT1, class AT2, int N, class Col2>
270  inline RowVector<Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> operator-(const RowVector<Fixed<N>, AT1> &a, const RowVector<Col2, AT2> &b) {
271  RowVector<Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> c(a.size(), NONINIT);
272  sub(a, b, c);
273  return c;
274  }
275  template <class AT1, class AT2, int N>
276  inline RowVector<Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> operator-(const RowVector<Fixed<N>, AT1> &a, const RowVector<Fixed<N>, AT2> &b) {
277  RowVector<Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> c(a.size(), NONINIT);
278  sub(a, b, c);
279  return c;
280  }
281  // move
282  template <class Row1, class Row2>
283  inline RowVector<Row2, double> operator-(RowVector<Row1, double> &&a, RowVector<Row2, double> &&b) {
284  sub(a, b);
285  return std::move(a);
286  }
287  template <class Row1, class Row2>
288  inline RowVector<Row1, double> operator-(RowVector<Row1, double> &&a, const RowVector<Row2, double> &b) {
289  sub(a, b);
290  return std::move(a);
291  }
292  template <class Row1, class Row2>
293  inline RowVector<Row2, double> operator-(const RowVector<Row1, double> &a, RowVector<Row2, double> &&b) {
294  FMATVEC_ASSERT(a.size() == b.size(), double);
295  for (int i = 0; i < a.size(); i++)
296  b.e(i) = a.e(i) - b.e(i);
297  return std::move(b);
298  }
299  template <class AT, class Col1, class Col2>
300  inline RowVector<Col1, AT> operator-=(RowVector<Col1, AT> &a, const RowVector<Col2, AT> &b) {
301  sub(a, b);
302  return a;
303  }
304 
305  // Matrix-Matrix
306  template <class Type1, class Row1, class Col1, class Type2, class Row2, class Col2, class Type3, class Row3, class Col3, class AT1, class AT2, class AT3>
307  inline void add(const Matrix<Type1, Row1, Col1, AT1> &A1, const Matrix<Type2, Row2, Col2, AT2> &A2, Matrix<Type3, Row3, Col3, AT3> &A3) {
308  FMATVEC_ASSERT(A1.rows() == A2.rows(), AT3);
309  FMATVEC_ASSERT(A1.cols() == A2.cols(), AT3);
310  for (int i = 0; i < A1.rows(); i++)
311  for (int j = 0; j < A2.cols(); j++)
312  A3.e(i, j) = A1.e(i, j) + A2.e(i, j);
313  }
314 
315  template <class Row1, class Row2, class Row3, class AT>
316  inline void add(const Matrix<Symmetric, Row1, Row1, AT> &A1, const Matrix<Symmetric, Row2, Row2, AT> &A2, Matrix<Symmetric, Row3, Row3, AT> &A3) {
317  FMATVEC_ASSERT(A1.size() == A2.size(), AT);
318  for (int i = 0; i < A1.size(); i++)
319  for (int j = i; j < A2.size(); j++)
320  A3.ej(i, j) = A1.ej(i, j) + A2.ej(i, j);
321  }
322 
323  template <class Row1, class Row2, class Row3, class AT>
324  inline void add(const Matrix<Diagonal, Row1, Row1, AT> &A1, const Matrix<Diagonal, Row2, Row2, AT> &A2, Matrix<Diagonal, Row3, Row3, AT> &A3) {
325  FMATVEC_ASSERT(A1.size() == A2.size(), AT);
326  for (int i = 0; i < A3.size(); i++)
327  A3.e(i) = A1.e(i) + A2.e(i);
328  }
329 
330  template <class Type1, class Row1, class Col1, class Type2, class Row2, class Col2, class AT>
331  inline void add(Matrix<Type1, Row1, Col1, AT> &A1, const Matrix<Type2, Row2, Col2, AT> &A2) {
332  FMATVEC_ASSERT(A1.rows() == A2.rows(), AT);
333  FMATVEC_ASSERT(A1.cols() == A2.cols(), AT);
334  for (int i = 0; i < A1.rows(); i++)
335  for (int j = 0; j < A2.cols(); j++)
336  A1.e(i, j) += A2.e(i, j);
337  }
338 
339  template <class Row1, class Row2, class AT>
340  inline void add(Matrix<Symmetric, Row1, Row1, AT> &A1, const Matrix<Symmetric, Row2, Row2, AT> &A2) {
341  FMATVEC_ASSERT(A1.size() == A2.size(), AT);
342  for (int i = 0; i < A1.size(); i++)
343  for (int j = i; j < A2.size(); j++)
344  A1.ej(i, j) += A2.ej(i, j);
345  }
346 
347  template <class Type1, class Row1, class Col1, class Type2, class Row2, class Col2, class Type3, class Row3, class Col3, class AT1, class AT2>
348  inline void sub(const Matrix<Type1, Row1, Col1, AT1> &A1, const Matrix<Type2, Row2, Col2, AT2> &A2, Matrix<Type3, Row3, Col3, typename fmatvec::OperatorResult<AT1, AT2>::Type> &A3) {
349  FMATVEC_ASSERT(A1.rows() == A2.rows(), AT2);
350  FMATVEC_ASSERT(A1.cols() == A2.cols(), AT2);
351  for (int i = 0; i < A1.rows(); i++)
352  for (int j = 0; j < A2.cols(); j++)
353  A3.e(i, j) = A1.e(i, j) - A2.e(i, j);
354  }
355 
356  template <class Row1, class Row2, class Row3, class AT1, class AT2>
357  inline void sub(const Matrix<Symmetric, Row1, Row1, AT1> &A1, const Matrix<Symmetric, Row2, Row2, AT2> &A2, Matrix<Symmetric, Row3, Row3, typename fmatvec::OperatorResult<AT1, AT2>::Type> &A3) {
358  FMATVEC_ASSERT(A1.size() == A2.size(), AT2);
359  for (int i = 0; i < A1.size(); i++)
360  for (int j = i; j < A2.size(); j++)
361  A3.ej(i, j) = A1.ej(i, j) - A2.ej(i, j);
362  }
363 
364  template <class Row1, class Row2, class Row3, class AT1, class AT2>
365  inline void sub(const Matrix<Diagonal, Row1, Row1, AT1> &A1, const Matrix<Diagonal, Row2, Row2, AT2> &A2, Matrix<Diagonal, Row3, Row3, typename fmatvec::OperatorResult<AT1, AT2>::Type> &A3) {
366  FMATVEC_ASSERT(A1.size() == A2.size(), AT2);
367  for (int i = 0; i < A3.size(); i++)
368  A3.e(i) = A1.e(i) - A2.e(i);
369  }
370 
371  template <class Type1, class Row1, class Col1, class Type2, class Row2, class Col2, class AT1, class AT2>
372  inline void sub(Matrix<Type1, Row1, Col1, AT1> &A1, const Matrix<Type2, Row2, Col2, AT2> &A2) {
373  FMATVEC_ASSERT(A1.rows() == A2.rows(), AT2);
374  FMATVEC_ASSERT(A1.cols() == A2.cols(), AT2);
375  for (int i = 0; i < A1.rows(); i++)
376  for (int j = 0; j < A2.cols(); j++)
377  A1.e(i, j) -= A2.e(i, j);
378  }
379 
380  template <class Row1, class Row2, class AT1, class AT2>
381  inline void sub(Matrix<Symmetric, Row1, Row1, AT1> &A1, const Matrix<Symmetric, Row2, Row2, AT2> &A2) {
382  FMATVEC_ASSERT(A1.size() == A2.size(), AT2);
383  for (int i = 0; i < A1.size(); i++)
384  for (int j = i; j < A2.size(); j++)
385  A1.ej(i, j) -= A2.ej(i, j);
386  }
387 
388  // Addition
389  // Type1 Type2
390  template <class AT1, class AT2, class Type1, class Type2, class Row1, class Col1, class Row2, class Col2>
391  inline Matrix<General, Var, Var, typename OperatorResult<AT1, AT2>::Type> operator+(const Matrix<Type1, Row1, Col1, AT1> &A, const Matrix<Type2, Row2, Col2, AT2> &B) {
392  Matrix<General, Var, Var, typename OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
393  add(A, B, C);
394  return C;
395  }
396  template <class AT1, class AT2, class Type1, class Type2, class Row, class Col>
397  inline Matrix<General, Row, Col, typename OperatorResult<AT1, AT2>::Type> operator+(const Matrix<Type1, Row, Col, AT1> &A, const Matrix<Type2, Row, Col, AT2> &B) {
398  Matrix<General, Row, Col, typename OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
399  add(A, B, C);
400  return C;
401  }
402  template <class AT1, class AT2, int M, class Type1, class Type2, class Row, class Col>
403  inline Matrix<General, Fixed<M>, Var, typename OperatorResult<AT1, AT2>::Type> operator+(const Matrix<Type1, Fixed<M>, Var, AT1> &A, const Matrix<Type2, Row, Col, AT2> &B) {
404  Matrix<General, Fixed<M>, Var, typename OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
405  add(A, B, C);
406  return C;
407  }
408  template <class AT1, class AT2, int M, class Type1, class Type2>
409  inline Matrix<General, Fixed<M>, Var, typename OperatorResult<AT1, AT2>::Type> operator+(const Matrix<Type1, Fixed<M>, Var, AT1> &A, const Matrix<Type2, Fixed<M>, Var, AT2> &B) {
410  Matrix<General, Fixed<M>, Var, typename OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
411  add(A, B, C);
412  return C;
413  }
414  template <class AT1, class AT2, int N, class Type1, class Type2, class Row, class Col>
415  inline Matrix<General, Var, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> operator+(const Matrix<Type1, Var, Fixed<N>, AT1> &A, const Matrix<Type2, Row, Col, AT2> &B) {
416  Matrix<General, Var, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
417  add(A, B, C);
418  return C;
419  }
420  template <class AT1, class AT2, int N, class Type1, class Type2>
421  inline Matrix<General, Var, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> operator+(const Matrix<Type1, Var, Fixed<N>, AT1> &A, const Matrix<Type2, Var, Fixed<N>, AT2> &B) {
422  Matrix<General, Var, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
423  add(A, B, C);
424  return C;
425  }
426  template <class AT1, class AT2, int M, int N, class Type1, class Type2, class Row, class Col>
427  inline Matrix<General, Fixed<M>, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> operator+(const Matrix<Type1, Fixed<M>, Fixed<N>, AT1> &A, const Matrix<Type2, Row, Col, AT2> &B) {
428  Matrix<General, Fixed<M>, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
429  add(A, B, C);
430  return C;
431  }
432  template <class AT1, class AT2, int M, int N, class Type1, class Type2>
433  inline Matrix<General, Fixed<M>, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> operator+(const Matrix<Type1, Fixed<M>, Fixed<N>, AT1> &A, const Matrix<Type2, Fixed<M>, Var, AT2> &B) {
434  Matrix<General, Fixed<M>, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
435  add(A, B, C);
436  return C;
437  }
438  template <class AT1, class AT2, int M, int N, class Type1, class Type2>
439  inline Matrix<General, Fixed<M>, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> operator+(const Matrix<Type1, Fixed<M>, Fixed<N>, AT1> &A, const Matrix<Type2, Var, Fixed<N>, AT2> &B) {
440  Matrix<General, Fixed<M>, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
441  add(A, B, C);
442  return C;
443  }
444  template <class AT1, class AT2, int M, int N, class Type1, class Type2>
445  inline Matrix<General, Fixed<M>, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> operator+(const Matrix<Type1, Fixed<M>, Fixed<N>, AT1> &A, const Matrix<Type2, Fixed<M>, Fixed<N>, AT2> &B) {
446  Matrix<General, Fixed<M>, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
447  add(A, B, C);
448  return C;
449  }
450  template <class AT1, class AT2, int M, int N, class Type1, class Type2, class Row, class Col>
451  inline Matrix<General, Fixed<M>, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> operator+(const Matrix<Type2, Row, Col, AT1> &A, const Matrix<Type1, Fixed<M>, Fixed<N>, AT2> &B) {
452  Matrix<General, Fixed<M>, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
453  add(A, B, C);
454  return C;
455  }
456  template <class AT1, class AT2, int M, int N, class Type1, class Type2>
457  inline Matrix<General, Fixed<M>, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> operator+(const Matrix<Type2, Fixed<M>, Var, AT1> &A, const Matrix<Type1, Fixed<M>, Fixed<N>, AT2> &B) {
458  Matrix<General, Fixed<M>, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
459  add(A, B, C);
460  return C;
461  }
462  template <class AT1, class AT2, int M, int N, class Type1, class Type2>
463  inline Matrix<General, Fixed<M>, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> operator+(const Matrix<Type2, Var, Fixed<N>, AT1> &A, const Matrix<Type1, Fixed<M>, Fixed<N>, AT2> &B) {
464  Matrix<General, Fixed<M>, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
465  add(A, B, C);
466  return C;
467  }
468  // Type
469  template <class AT1, class AT2, class Type, class Row1, class Col1, class Row2, class Col2>
470  inline Matrix<Type, Var, Var, typename OperatorResult<AT1, AT2>::Type> operator+(const Matrix<Type, Row1, Col1, AT1> &A, const Matrix<Type, Row2, Col2, AT2> &B) {
471  Matrix<Type, Var, Var, typename OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
472  add(A, B, C);
473  return C;
474  }
475  template <class AT1, class AT2, class Type, class Row, class Col>
476  inline Matrix<Type, Row, Col, typename OperatorResult<AT1, AT2>::Type> operator+(const Matrix<Type, Row, Col, AT1> &A, const Matrix<Type, Row, Col, AT2> &B) {
477  Matrix<Type, Row, Col, typename OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
478  add(A, B, C);
479  return C;
480  }
481  template <class AT1, class AT2, int M, class Type, class Row, class Col>
482  inline Matrix<Type, Fixed<M>, Var, typename OperatorResult<AT1, AT2>::Type> operator+(const Matrix<Type, Fixed<M>, Var, AT1> &A, const Matrix<Type, Row, Col, AT2> &B) {
483  Matrix<Type, Fixed<M>, Var, typename OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
484  add(A, B, C);
485  return C;
486  }
487  template <class AT1, class AT2, int M, class Type>
488  inline Matrix<Type, Fixed<M>, Var, typename OperatorResult<AT1, AT2>::Type> operator+(const Matrix<Type, Fixed<M>, Var, AT1> &A, const Matrix<Type, Fixed<M>, Var, AT2> &B) {
489  Matrix<Type, Fixed<M>, Var, typename OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
490  add(A, B, C);
491  return C;
492  }
493  template <class AT1, class AT2, int N, class Type, class Row, class Col>
494  inline Matrix<Type, Var, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> operator+(const Matrix<Type, Var, Fixed<N>, AT1> &A, const Matrix<Type, Row, Col, AT2> &B) {
495  Matrix<Type, Var, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
496  add(A, B, C);
497  return C;
498  }
499  template <class AT1, class AT2, int N, class Type>
500  inline Matrix<Type, Var, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> operator+(const Matrix<Type, Var, Fixed<N>, AT1> &A, const Matrix<Type, Var, Fixed<N>, AT2> &B) {
501  Matrix<Type, Var, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
502  add(A, B, C);
503  return C;
504  }
505  template <class AT1, class AT2, int M, int N, class Type, class Row, class Col>
506  inline Matrix<Type, Fixed<M>, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> operator+(const Matrix<Type, Fixed<M>, Fixed<N>, AT1> &A, const Matrix<Type, Row, Col, AT2> &B) {
507  Matrix<Type, Fixed<M>, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
508  add(A, B, C);
509  return C;
510  }
511  template <class AT1, class AT2, int M, int N, class Type>
512  inline Matrix<Type, Fixed<M>, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> operator+(const Matrix<Type, Fixed<M>, Fixed<N>, AT1> &A, const Matrix<Type, Fixed<M>, Var, AT2> &B) {
513  Matrix<Type, Fixed<M>, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
514  add(A, B, C);
515  return C;
516  }
517  template <class AT1, class AT2, int M, int N, class Type>
518  inline Matrix<Type, Fixed<M>, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> operator+(const Matrix<Type, Fixed<M>, Fixed<N>, AT1> &A, const Matrix<Type, Var, Fixed<N>, AT2> &B) {
519  Matrix<Type, Fixed<M>, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
520  add(A, B, C);
521  return C;
522  }
523  template <class AT1, class AT2, int M, int N, class Type>
524  inline Matrix<Type, Fixed<M>, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> operator+(const Matrix<Type, Fixed<M>, Fixed<N>, AT1> &A, const Matrix<Type, Fixed<M>, Fixed<N>, AT2> &B) {
525  Matrix<Type, Fixed<M>, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
526  add(A, B, C);
527  return C;
528  }
529  template <class AT1, class AT2, int M, int N, class Type, class Row, class Col>
530  inline Matrix<Type, Fixed<M>, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> operator+(const Matrix<Type, Row, Col, AT1> &A, const Matrix<Type, Fixed<M>, Fixed<N>, AT2> &B) {
531  Matrix<Type, Fixed<M>, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
532  add(A, B, C);
533  return C;
534  }
535  template <class AT1, class AT2, int M, int N, class Type>
536  inline Matrix<Type, Fixed<M>, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> operator+(const Matrix<Type, Fixed<M>, Var, AT1> &A, const Matrix<Type, Fixed<M>, Fixed<N>, AT2> &B) {
537  Matrix<Type, Fixed<M>, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
538  add(A, B, C);
539  return C;
540  }
541  template <class AT1, class AT2, int M, int N, class Type>
542  inline Matrix<Type, Fixed<M>, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> operator+(const Matrix<Type, Var, Fixed<N>, AT1> &A, const Matrix<Type, Fixed<M>, Fixed<N>, AT2> &B) {
543  Matrix<Type, Fixed<M>, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
544  add(A, B, C);
545  return C;
546  }
547  // move
548  template <class Type1, class Type2, class Row1, class Row2, class Col1, class Col2>
549  inline Matrix<Type2, Row2, Col2, double> operator+(Matrix<Type1, Row1, Col1, double> &&a, Matrix<Type2, Row2, Col2, double> &&b) {
550  add(a, b);
551  return std::move(a);
552  }
553  template <class Type1, class Type2, class Row1, class Row2, class Col1, class Col2>
554  inline Matrix<Type1, Row1, Col1, double> operator+(Matrix<Type1, Row1, Col1, double> &&a, const Matrix<Type2, Row2, Col2, double> &b) {
555  add(a, b);
556  return std::move(a);
557  }
558  template <class Type1, class Type2, class Row1, class Row2, class Col1, class Col2>
559  inline Matrix<Type2, Row2, Col2, double> operator+(const Matrix<Type1, Row1, Col1, double> &a, Matrix<Type2, Row2, Col2, double> &&b) {
560  add(b, a);
561  return std::move(b);
562  }
563  template <class AT, class Type1, class Row1, class Col1, class Type2, class Row2, class Col2>
564  inline Matrix<Type1, Row1, Col1, AT>& operator+=(Matrix<Type1, Row1, Col1, AT> &A, const Matrix<Type2, Row2, Col2, AT> &B) {
565  add(A, B);
566  return A;
567  }
568 
569  // Subtraction
570  // Type1 Type2
571  template <class AT1, class AT2, class Type1, class Type2, class Row1, class Col1, class Row2, class Col2>
572  inline Matrix<General, Var, Var, typename fmatvec::OperatorResult<AT1, AT2>::Type> operator-(const Matrix<Type1, Row1, Col1, AT1> &A, const Matrix<Type2, Row2, Col2, AT2> &B) {
573  Matrix<General, Var, Var, typename fmatvec::OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
574  sub(A, B, C);
575  return C;
576  }
577  template <class AT1, class AT2, class Type1, class Type2, class Row, class Col>
578  inline Matrix<General, Row, Col, typename fmatvec::OperatorResult<AT1, AT2>::Type> operator-(const Matrix<Type1, Row, Col, AT1> &A, const Matrix<Type2, Row, Col, AT2> &B) {
579  Matrix<General, Row, Col, typename fmatvec::OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
580  sub(A, B, C);
581  return C;
582  }
583  template <class AT1, class AT2, int M, class Type1, class Type2, class Row, class Col>
584  inline Matrix<General, Fixed<M>, Var, typename fmatvec::OperatorResult<AT1, AT2>::Type> operator-(const Matrix<Type1, Fixed<M>, Var, AT1> &A, const Matrix<Type2, Row, Col, AT2> &B) {
585  Matrix<General, Fixed<M>, Var, typename fmatvec::OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
586  sub(A, B, C);
587  return C;
588  }
589  template <class AT1, class AT2, int M, class Type1, class Type2>
590  inline Matrix<General, Fixed<M>, Var, typename fmatvec::OperatorResult<AT1, AT2>::Type> operator-(const Matrix<Type1, Fixed<M>, Var, AT1> &A, const Matrix<Type2, Fixed<M>, Var, AT2> &B) {
591  Matrix<General, Fixed<M>, Var, typename fmatvec::OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
592  sub(A, B, C);
593  return C;
594  }
595  template <class AT1, class AT2, int N, class Type1, class Type2, class Row, class Col>
596  inline Matrix<General, Var, Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> operator-(const Matrix<Type1, Var, Fixed<N>, AT1> &A, const Matrix<Type2, Row, Col, AT2> &B) {
597  Matrix<General, Var, Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
598  sub(A, B, C);
599  return C;
600  }
601  template <class AT1, class AT2, int N, class Type1, class Type2>
602  inline Matrix<General, Var, Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> operator-(const Matrix<Type1, Var, Fixed<N>, AT1> &A, const Matrix<Type2, Var, Fixed<N>, AT2> &B) {
603  Matrix<General, Var, Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
604  sub(A, B, C);
605  return C;
606  }
607  template <class AT1, class AT2, int M, int N, class Type1, class Type2, class Row, class Col>
608  inline Matrix<General, Fixed<M>, Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> operator-(const Matrix<Type1, Fixed<M>, Fixed<N>, AT1> &A, const Matrix<Type2, Row, Col, AT2> &B) {
609  Matrix<General, Fixed<M>, Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
610  sub(A, B, C);
611  return C;
612  }
613  template <class AT1, class AT2, int M, int N, class Type1, class Type2>
614  inline Matrix<General, Fixed<M>, Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> operator-(const Matrix<Type1, Fixed<M>, Fixed<N>, AT1> &A, const Matrix<Type2, Fixed<M>, Var, AT2> &B) {
615  Matrix<General, Fixed<M>, Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
616  sub(A, B, C);
617  return C;
618  }
619  template <class AT1, class AT2, int M, int N, class Type1, class Type2>
620  inline Matrix<General, Fixed<M>, Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> operator-(const Matrix<Type1, Fixed<M>, Fixed<N>, AT1> &A, const Matrix<Type2, Var, Fixed<N>, AT2> &B) {
621  Matrix<General, Fixed<M>, Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
622  sub(A, B, C);
623  return C;
624  }
625  template <class AT1, class AT2, int M, int N, class Type1, class Type2>
626  inline Matrix<General, Fixed<M>, Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> operator-(const Matrix<Type1, Fixed<M>, Fixed<N>, AT1> &A, const Matrix<Type2, Fixed<M>, Fixed<N>, AT2> &B) {
627  Matrix<General, Fixed<M>, Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
628  sub(A, B, C);
629  return C;
630  }
631  template <class AT1, class AT2, int M, int N, class Type1, class Type2, class Row, class Col>
632  inline Matrix<General, Fixed<M>, Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> operator-(const Matrix<Type2, Row, Col, AT1> &A, const Matrix<Type1, Fixed<M>, Fixed<N>, AT2> &B) {
633  Matrix<General, Fixed<M>, Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
634  sub(A, B, C);
635  return C;
636  }
637  template <class AT1, class AT2, int M, int N, class Type1, class Type2>
638  inline Matrix<General, Fixed<M>, Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> operator-(const Matrix<Type2, Fixed<M>, Var, AT1> &A, const Matrix<Type1, Fixed<M>, Fixed<N>, AT2> &B) {
639  Matrix<General, Fixed<M>, Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
640  sub(A, B, C);
641  return C;
642  }
643  template <class AT1, class AT2, int M, int N, class Type1, class Type2>
644  inline Matrix<General, Fixed<M>, Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> operator-(const Matrix<Type2, Var, Fixed<N>, AT1> &A, const Matrix<Type1, Fixed<M>, Fixed<N>, AT2> &B) {
645  Matrix<General, Fixed<M>, Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
646  sub(A, B, C);
647  return C;
648  }
649  // Type
650  template <class AT1, class AT2, class Type, class Row1, class Col1, class Row2, class Col2>
651  inline Matrix<Type, Var, Var, typename fmatvec::OperatorResult<AT1, AT2>::Type> operator-(const Matrix<Type, Row1, Col1, AT1> &A, const Matrix<Type, Row2, Col2, AT2> &B) {
652  Matrix<Type, Var, Var, typename fmatvec::OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
653  sub(A, B, C);
654  return C;
655  }
656  template <class AT1, class AT2, class Type, class Row, class Col>
657  inline Matrix<Type, Row, Col, typename fmatvec::OperatorResult<AT1, AT2>::Type> operator-(const Matrix<Type, Row, Col, AT1> &A, const Matrix<Type, Row, Col, AT2> &B) {
658  Matrix<Type, Row, Col, typename fmatvec::OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
659  sub(A, B, C);
660  return C;
661  }
662  template <class AT1, class AT2, int M, class Type, class Row, class Col>
663  inline Matrix<Type, Fixed<M>, Var, typename fmatvec::OperatorResult<AT1, AT2>::Type> operator-(const Matrix<Type, Fixed<M>, Var, AT1> &A, const Matrix<Type, Row, Col, AT2> &B) {
664  Matrix<Type, Fixed<M>, Var, typename fmatvec::OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
665  sub(A, B, C);
666  return C;
667  }
668  template <class AT1, class AT2, int M, class Type>
669  inline Matrix<Type, Fixed<M>, Var, typename fmatvec::OperatorResult<AT1, AT2>::Type> operator-(const Matrix<Type, Fixed<M>, Var, AT1> &A, const Matrix<Type, Fixed<M>, Var, AT2> &B) {
670  Matrix<Type, Fixed<M>, Var, typename fmatvec::OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
671  sub(A, B, C);
672  return C;
673  }
674  template <class AT1, class AT2, int N, class Type, class Row, class Col>
675  inline Matrix<Type, Var, Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> operator-(const Matrix<Type, Var, Fixed<N>, AT1> &A, const Matrix<Type, Row, Col, AT2> &B) {
676  Matrix<Type, Var, Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
677  sub(A, B, C);
678  return C;
679  }
680  template <class AT1, class AT2, int N, class Type>
681  inline Matrix<Type, Var, Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> operator-(const Matrix<Type, Var, Fixed<N>, AT1> &A, const Matrix<Type, Var, Fixed<N>, AT2> &B) {
682  Matrix<Type, Var, Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
683  sub(A, B, C);
684  return C;
685  }
686  template <class AT1, class AT2, int M, int N, class Type, class Row, class Col>
687  inline Matrix<Type, Fixed<M>, Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> operator-(const Matrix<Type, Fixed<M>, Fixed<N>, AT1> &A, const Matrix<Type, Row, Col, AT2> &B) {
688  Matrix<Type, Fixed<M>, Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
689  sub(A, B, C);
690  return C;
691  }
692  template <class AT1, class AT2, int M, int N, class Type>
693  inline Matrix<Type, Fixed<M>, Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> operator-(const Matrix<Type, Fixed<M>, Fixed<N>, AT1> &A, const Matrix<Type, Fixed<M>, Var, AT2> &B) {
694  Matrix<Type, Fixed<M>, Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
695  sub(A, B, C);
696  return C;
697  }
698  template <class AT1, class AT2, int M, int N, class Type>
699  inline Matrix<Type, Fixed<M>, Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> operator-(const Matrix<Type, Fixed<M>, Fixed<N>, AT1> &A, const Matrix<Type, Var, Fixed<N>, AT2> &B) {
700  Matrix<Type, Fixed<M>, Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
701  sub(A, B, C);
702  return C;
703  }
704  template <class AT1, class AT2, int M, int N, class Type>
705  inline Matrix<Type, Fixed<M>, Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> operator-(const Matrix<Type, Fixed<M>, Fixed<N>, AT1> &A, const Matrix<Type, Fixed<M>, Fixed<N>, AT2> &B) {
706  Matrix<Type, Fixed<M>, Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
707  sub(A, B, C);
708  return C;
709  }
710  template <class AT1, class AT2, int M, int N, class Type, class Row, class Col>
711  inline Matrix<Type, Fixed<M>, Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> operator-(const Matrix<Type, Row, Col, AT1> &A, const Matrix<Type, Fixed<M>, Fixed<N>, AT2> &B) {
712  Matrix<Type, Fixed<M>, Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
713  sub(A, B, C);
714  return C;
715  }
716  template <class AT1, class AT2, int M, int N, class Type>
717  inline Matrix<Type, Fixed<M>, Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> operator-(const Matrix<Type, Fixed<M>, Var, AT1> &A, const Matrix<Type, Fixed<M>, Fixed<N>, AT2> &B) {
718  Matrix<Type, Fixed<M>, Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
719  sub(A, B, C);
720  return C;
721  }
722  template <class AT1, class AT2, int M, int N, class Type>
723  inline Matrix<Type, Fixed<M>, Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> operator-(const Matrix<Type, Var, Fixed<N>, AT1> &A, const Matrix<Type, Fixed<M>, Fixed<N>, AT2> &B) {
724  Matrix<Type, Fixed<M>, Fixed<N>, typename fmatvec::OperatorResult<AT1, AT2>::Type> C(A.rows(), A.cols(), NONINIT);
725  sub(A, B, C);
726  return C;
727  }
728  // move
729  template <class Type1, class Type2, class Row1, class Row2, class Col1, class Col2>
730  inline Matrix<Type2, Row2, Col2, double> operator-(Matrix<Type1, Row1, Col1, double> &&a, Matrix<Type2, Row2, Col2, double> &&b) {
731  sub(a, b);
732  return std::move(a);
733  }
734  template <class Type1, class Type2, class Row1, class Row2, class Col1, class Col2>
735  inline Matrix<Type1, Row1, Col1, double> operator-(Matrix<Type1, Row1, Col1, double> &&a, const Matrix<Type2, Row2, Col2, double> &b) {
736  sub(a, b);
737  return std::move(a);
738  }
739  template <class Type1, class Type2, class Row1, class Row2, class Col1, class Col2>
740  inline Matrix<Type2, Row2, Col2, double> operator-(const Matrix<Type1, Row1, Col1, double> &a, Matrix<Type2, Row2, Col2, double> &&b) {
741  FMATVEC_ASSERT(a.rows() == b.rows(), double);
742  FMATVEC_ASSERT(a.cols() == b.cols(), double);
743  for (int i = 0; i < a.rows(); i++)
744  for (int j = 0; j < a.cols(); j++)
745  b.e(i, j) = a.e(i, j) - b.e(i, j);
746  return std::move(b);
747  }
748  template <class AT, class Type1, class Row1, class Col1, class Type2, class Row2, class Col2>
749  inline Matrix<Type1, Row1, Col1, AT>& operator-=(Matrix<Type1, Row1, Col1, AT> &A, const Matrix<Type2, Row2, Col2, AT> &B) {
750  sub(A, B);
751  return A;
752  }
753 
754 // SquareMatrix-SquareMatrix
755  template <class AT1, class AT2, class Row1, class Row2>
756  inline SquareMatrix<Var, typename OperatorResult<AT1, AT2>::Type> operator+(const SquareMatrix<Row1, AT1> &A1, const SquareMatrix<Row2, AT2> &A2) {
757  SquareMatrix<Var, typename OperatorResult<AT1, AT2>::Type> A3(A1.size(), NONINIT);
758  add(A1, A2, A3);
759  return A3;
760  }
761  template <class AT1, class AT2, class Row>
762  inline SquareMatrix<Row, typename OperatorResult<AT1, AT2>::Type> operator+(const SquareMatrix<Row, AT1> &A1, const SquareMatrix<Row, AT2> &A2) {
763  SquareMatrix<Row, typename OperatorResult<AT1, AT2>::Type> A3(A1.size(), NONINIT);
764  add(A1, A2, A3);
765  return A3;
766  }
767  // move
768  template <class Row1, class Row2>
769  inline SquareMatrix<Row1, double> operator+(SquareMatrix<Row1, double> &&A1, SquareMatrix<Row2, double> &&A2) {
770  add(A1, A2);
771  return std::move(A1);;
772  }
773  template <class Row1, class Row2>
774  inline SquareMatrix<Row1, double> operator+(SquareMatrix<Row1, double> &&A1, const SquareMatrix<Row2, double> &A2) {
775  add(A1, A2);
776  return std::move(A1);;
777  }
778  template <class Row1, class Row2>
779  inline SquareMatrix<Row2, double> operator+(const SquareMatrix<Row1, double> &A1, SquareMatrix<Row2, double> &&A2) {
780  add(A2, A1);
781  return std::move(A2);
782  }
783 
784 // SquareMatrix-SquareMatrix
785  template <class AT1, class AT2, class Row1, class Row2>
786  inline SquareMatrix<Var, typename fmatvec::OperatorResult<AT1, AT2>::Type> operator-(const SquareMatrix<Row1, AT1> &A1, const SquareMatrix<Row2, AT2> &A2) {
787  SquareMatrix<Var, typename fmatvec::OperatorResult<AT1, AT2>::Type> A3(A1.size(), NONINIT);
788  sub(A1, A2, A3);
789  return A3;
790  }
791  template <class AT1, class AT2, class Row>
792  inline SquareMatrix<Row, typename fmatvec::OperatorResult<AT1, AT2>::Type> operator-(const SquareMatrix<Row, AT1> &A1, const SquareMatrix<Row, AT2> &A2) {
793  SquareMatrix<Row, typename fmatvec::OperatorResult<AT1, AT2>::Type> A3(A1.size(), NONINIT);
794  sub(A1, A2, A3);
795  return A3;
796  }
797  // move
798  template <class Row1, class Row2>
799  inline SquareMatrix<Row1, double> operator-(SquareMatrix<Row1, double> &&A1, SquareMatrix<Row2, double> &&A2) {
800  sub(A1, A2);
801  return std::move(A1);;
802  }
803  template <class Row1, class Row2>
804  inline SquareMatrix<Row1, double> operator-(SquareMatrix<Row1, double> &&A1, const SquareMatrix<Row2, double> &A2) {
805  sub(A1, A2);
806  return std::move(A1);;
807  }
808  template <class Row1, class Row2>
809  inline SquareMatrix<Row2, double> operator-(const SquareMatrix<Row1, double> &A1, SquareMatrix<Row2, double> &&A2) {
810  FMATVEC_ASSERT(A1.size() == A2.size(), double);
811  for (int i = 0; i < A1.size(); i++)
812  for (int j = 0; j < A1.size(); j++)
813  A2.e(i, j) = A1.e(i, j) - A2.e(i, j);
814  return std::move(A2);
815  }
816 
822  template <class Type1, class Row1, class Col1, class Row2, class Row3, class AT1, class AT2>
823  inline void mult(const Matrix<Type1, Row1, Col1, AT1> &A, const Vector<Row2, AT2> &x, Vector<Row3, typename fmatvec::OperatorResult<AT1, AT2>::Type> &y) {
824  FMATVEC_ASSERT(A.cols() == x.size(), AT2);
825  for (int i = 0; i < y.size(); i++) {
826  y.e(i) = 0;
827  for (int j = 0; j < x.size(); j++)
828  y.e(i) += A.e(i, j) * x.e(j);
829  }
830  }
831 
832  template <class Row1, class Row2, class Row3, class AT1, class AT2>
833  inline void mult(const Matrix<Symmetric, Row1, Row1, AT1> &A, const Vector<Row2, AT2> &x, Vector<Row3, typename fmatvec::OperatorResult<AT1, AT2>::Type> &y) {
834  FMATVEC_ASSERT(A.cols() == x.size(), AT2);
835  for (int i = 0; i < y.size(); i++) {
836  y.e(i) = 0;
837  for (int j = 0; j < i; j++)
838  y.e(i) += A.ei(i, j) * x.e(j);
839  for (int j = i; j < x.size(); j++)
840  y.e(i) += A.ej(i, j) * x.e(j);
841  }
842  }
843 
844  // Matrix-Vector
845  template <class AT1, class AT2, class Type1, class Row1, class Col1, class Row2>
846  inline Vector<Var, typename OperatorResult<AT1, AT2>::Type> operator*(const Matrix<Type1, Row1, Col1, AT1> &A, const Vector<Row2, AT2> &x) {
847  Vector<Var, typename OperatorResult<AT1, AT2>::Type> y(A.rows(), NONINIT);
848  mult(A, x, y);
849  return y;
850  }
851  template <class AT1, class AT2, class Type1, class Row, class Col>
852  inline Vector<Row, typename OperatorResult<AT1, AT2>::Type> operator*(const Matrix<Type1, Row, Col, AT1> &A, const Vector<Row, AT2> &x) {
853  Vector<Row, typename OperatorResult<AT1, AT2>::Type> y(A.rows(), NONINIT);
854  mult(A, x, y);
855  return y;
856  }
857  template <class AT1, class AT2, int M, class Type1, class Col1, class Row2>
858  inline Vector<Fixed<M>, typename OperatorResult<AT1, AT2>::Type> operator*(const Matrix<Type1, Fixed<M>, Col1, AT1> &A, const Vector<Row2, AT2> &x) {
859  Vector<Fixed<M>, typename OperatorResult<AT1, AT2>::Type> y(A.rows(), NONINIT);
860  mult(A, x, y);
861  return y;
862  }
863  template <class AT1, class AT2, int M, class Type1>
864  inline Vector<Fixed<M>, typename OperatorResult<AT1, AT2>::Type> operator*(const Matrix<Type1, Fixed<M>, Fixed<M>, AT1> &A, const Vector<Fixed<M>, AT2> &x) {
865  Vector<Fixed<M>, typename OperatorResult<AT1, AT2>::Type> y(A.rows(), NONINIT);
866  mult(A, x, y);
867  return y;
868  }
869  template <class AT1, class AT2, int M, int N, class Type, class Row2>
870  inline Vector<Fixed<M>, typename OperatorResult<AT1, AT2>::Type> operator*(const Matrix<Type, Fixed<M>, Fixed<N>, AT1> &A, const Vector<Row2, AT2> &x) {
871  Vector<Fixed<M>, typename OperatorResult<AT1, AT2>::Type> y(A.rows(), NONINIT);
872  mult(A, x, y);
873  return y;
874  }
875  template <class AT1, class AT2, int M, int N, class Type>
876  inline Vector<Fixed<M>, typename OperatorResult<AT1, AT2>::Type> operator*(const Matrix<Type, Fixed<M>, Fixed<N>, AT1> &A, const Vector<Fixed<N>, AT2> &x) {
877  Vector<Fixed<M>, typename OperatorResult<AT1, AT2>::Type> y(A.rows(), NONINIT);
878  mult(A, x, y);
879  return y;
880  }
881 
882  // RowVector-Matrix
883  template <class Col1, class Type2, class Row2, class Col2, class Type3, class Col3, class AT1, class AT2>
884  inline void mult(const RowVector<Col1, AT1> &x, const Matrix<Type2, Row2, Col2, AT2> &A, RowVector<Col3, typename fmatvec::OperatorResult<AT1, AT2>::Type> &y) {
885  FMATVEC_ASSERT(x.size() == A.rows(), AT2);
886  for (int i = 0; i < y.size(); i++) {
887  y.e(i) = 0;
888  for (int j = 0; j < x.size(); j++)
889  y.e(i) += x.e(j) * A.e(j, i);
890  }
891  }
892 
893  template <class Col1, class Row2, class Col3, class AT1, class AT2>
894  inline void mult(const RowVector<Col1, AT1> &x, const Matrix<Symmetric, Row2, Row2, AT2> &A, RowVector<Col3, typename fmatvec::OperatorResult<AT1, AT2>::Type> &y) {
895  FMATVEC_ASSERT(x.size() == A.rows(), AT2);
896  for (int i = 0; i < y.size(); i++) {
897  y.e(i) = 0;
898  for (int j = 0; j < i; j++)
899  y.e(i) += x.e(j) * A.ej(j, i);
900  for (int j = i; j < x.size(); j++)
901  y.e(i) += x.e(j) * A.ei(j, i);
902  }
903  }
904 
905  template <class AT1, class AT2, class Type2, class Col2, class Row1, class Col1>
906  inline RowVector<Var, typename OperatorResult<AT1, AT2>::Type> operator*(const RowVector<Col2, AT1> &x, const Matrix<Type2, Row1, Col1, AT2> &A) {
907  RowVector<Var, typename OperatorResult<AT1, AT2>::Type> y(A.cols(), NONINIT);
908  mult(x, A, y);
909  return y;
910  }
911  template <class AT1, class AT2, class Type2, class Row, class Col>
912  inline RowVector<Col, typename OperatorResult<AT1, AT2>::Type> operator*(const RowVector<Col, AT1> &x, const Matrix<Type2, Row, Col, AT2> &A) {
913  RowVector<Col, typename OperatorResult<AT1, AT2>::Type> y(A.cols(), NONINIT);
914  mult(x, A, y);
915  return y;
916  }
917  template <class AT1, class AT2, int N, class Type2, class Col1, class Row2>
918  inline RowVector<Fixed<N>, typename OperatorResult<AT1, AT2>::Type> operator*(const RowVector<Col1, AT1> &x, const Matrix<Type2, Row2, Fixed<N>, AT2> &A) {
919  RowVector<Fixed<N>, typename OperatorResult<AT1, AT2>::Type> y(A.cols(), NONINIT);
920  mult(x, A, y);
921  return y;
922  }
923  template <class AT1, class AT2, int N, class Type2>
924  inline RowVector<Fixed<N>, typename OperatorResult<AT1, AT2>::Type> operator*(const RowVector<Fixed<N>, AT1> &x, const Matrix<Type2, Fixed<N>, Fixed<N>, AT2> &A) {
925  RowVector<Fixed<N>, typename OperatorResult<AT1, AT2>::Type> y(A.cols(), NONINIT);
926  mult(x, A, y);
927  return y;
928  }
929 
930  // Matrix-Matrix
931  template <class Type1, class Row1, class Col1, class Type2, class Row2, class Col2, class Type3, class Row3, class Col3, class AT1, class AT2>
932  inline void mult(const Matrix<Type1, Row1, Col1, AT1> &A1, const Matrix<Type2, Row2, Col2, AT2> &A2, Matrix<Type3, Row3, Col3, typename fmatvec::OperatorResult<AT1, AT2>::Type> &A3) {
933  FMATVEC_ASSERT(A1.cols() == A2.rows(), AT2);
934  for (int i = 0; i < A3.rows(); i++) {
935  for (int k = 0; k < A3.cols(); k++) {
936  A3.e(i, k) = 0;
937  for (int j = 0; j < A1.cols(); j++)
938  A3.e(i, k) += A1.e(i, j) * A2.e(j, k);
939  }
940  }
941  }
942  template <class Row1, class Type2, class Row2, class Col2, class Type3, class Row3, class Col3, class AT1, class AT2>
943  inline void mult(const Matrix<Symmetric, Row1, Row1, AT1> &A1, const Matrix<Type2, Row2, Col2, AT2> &A2, Matrix<Type3, Row3, Col3, typename fmatvec::OperatorResult<AT1, AT2>::Type> &A3) {
944  FMATVEC_ASSERT(A1.size() == A2.rows(), AT2);
945  for (int i = 0; i < A3.rows(); i++) {
946  for (int k = 0; k < A3.cols(); k++) {
947  A3.e(i, k) = 0;
948  for (int j = 0; j < i; j++)
949  A3.e(i, k) += A1.ei(i, j) * A2.e(j, k);
950  for (int j = i; j < A1.cols(); j++)
951  A3.e(i, k) += A1.ej(i, j) * A2.e(j, k);
952  }
953  }
954  }
955  template <class Row1, class Row2, class Row3, class AT1, class AT2>
956  inline void mult(const Matrix<Diagonal, Row1, Row1, AT1> &A1, const Matrix<Diagonal, Row2, Row2, AT2> &A2, Matrix<Diagonal, Row3, Row3, typename fmatvec::OperatorResult<AT1, AT2>::Type> &A3) {
957  FMATVEC_ASSERT(A1.size() == A2.size(), AT2);
958  for (int i = 0; i < A3.size(); i++)
959  A3.e(i) = A1.e(i) * A2.e(i);
960  }
961 
962  template <class AT1, class AT2, class Type1, class Type2, class Row1, class Col1, class Row2, class Col2>
963  inline Matrix<General, Var, Var, typename OperatorResult<AT1, AT2>::Type> operator*(const Matrix<Type1, Row1, Col1, AT1> &A1, const Matrix<Type2, Row2, Col2, AT2> &A2) {
964  Matrix<General, Var, Var, typename OperatorResult<AT1, AT2>::Type> A3(A1.rows(), A2.cols(), NONINIT);
965  mult(A1, A2, A3);
966  return A3;
967  }
968  template <class AT1, class AT2, class Type1, class Type2, class Row, class Col>
969  inline Matrix<General, Row, Col, typename OperatorResult<AT1, AT2>::Type> operator*(const Matrix<Type1, Row, Col, AT1> &A1, const Matrix<Type2, Row, Col, AT2> &A2) {
970  Matrix<General, Row, Col, typename OperatorResult<AT1, AT2>::Type> A3(A1.rows(), A2.cols(), NONINIT);
971  mult(A1, A2, A3);
972  return A3;
973  }
974  template <class AT1, class AT2, int M, class Type1, class Type2, class Col1, class Row2, class Col2>
975  inline Matrix<General, Fixed<M>, Var, typename OperatorResult<AT1, AT2>::Type> operator*(const Matrix<Type1, Fixed<M>, Col1, AT1> &A1, const Matrix<Type2, Row2, Col2, AT2> &A2) {
976  Matrix<General, Fixed<M>, Var, typename OperatorResult<AT1, AT2>::Type> A3(A1.rows(), A2.cols(), NONINIT);
977  mult(A1, A2, A3);
978  return A3;
979  }
980  template <class AT1, class AT2, int N, class Type1, class Row1, class Col1, class Type2, class Row2>
981  inline Matrix<General, Var, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> operator*(const Matrix<Type1, Row1, Col1, AT1> &A1, const Matrix<Type2, Row2, Fixed<N>, AT2> &A2) {
982  Matrix<General, Var, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> A3(A1.rows(), A2.cols(), NONINIT);
983  mult(A1, A2, A3);
984  return A3;
985  }
986  template <class AT1, class AT2, int M, int N, class Type1, class Type2, class Col1, class Row2>
987  inline Matrix<General, Fixed<M>, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> operator*(const Matrix<Type1, Fixed<M>, Col1, AT1> &A1, const Matrix<Type2, Row2, Fixed<N>, AT2> &A2) {
988  Matrix<General, Fixed<M>, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> A3(A1.rows(), A2.cols(), NONINIT);
989  mult(A1, A2, A3);
990  return A3;
991  }
992  template <class AT1, class AT2, int M, class Type1, class Type2>
993  inline Matrix<General, Fixed<M>, Fixed<M>, typename OperatorResult<AT1, AT2>::Type> operator*(const Matrix<Type1, Fixed<M>, Fixed<M>, AT1> &A1, const Matrix<Type2, Fixed<M>, Fixed<M>, AT2> &A2) {
994  Matrix<General, Fixed<M>, Fixed<M>, typename OperatorResult<AT1, AT2>::Type> A3(A1.rows(), A2.cols(), NONINIT);
995  mult(A1, A2, A3);
996  return A3;
997  }
998  template <class AT1, class AT2, class Type, class Row1, class Col1, class Row2, class Col2>
999  inline Matrix<Type, Var, Var, typename OperatorResult<AT1, AT2>::Type> operator*(const Matrix<Type, Row1, Col1, AT1> &A1, const Matrix<Type, Row2, Col2, AT2> &A2) {
1000  Matrix<Type, Var, Var, typename OperatorResult<AT1, AT2>::Type> A3(A1.rows(), A2.cols(), NONINIT);
1001  mult(A1, A2, A3);
1002  return A3;
1003  }
1004  template <class AT1, class AT2, class Type, class Row, class Col>
1005  inline Matrix<Type, Row, Col, typename OperatorResult<AT1, AT2>::Type> operator*(const Matrix<Type, Row, Col, AT1> &A1, const Matrix<Type, Row, Col, AT2> &A2) {
1006  Matrix<Type, Row, Col, typename OperatorResult<AT1, AT2>::Type> A3(A1.rows(), A2.cols(), NONINIT);
1007  mult(A1, A2, A3);
1008  return A3;
1009  }
1010  template <class AT1, class AT2, int M, class Type, class Col1, class Row2, class Col2>
1011  inline Matrix<Type, Fixed<M>, Var, typename OperatorResult<AT1, AT2>::Type> operator*(const Matrix<Type, Fixed<M>, Col1, AT1> &A1, const Matrix<Type, Row2, Col2, AT2> &A2) {
1012  Matrix<Type, Fixed<M>, Var, typename OperatorResult<AT1, AT2>::Type> A3(A1.rows(), A2.cols(), NONINIT);
1013  mult(A1, A2, A3);
1014  return A3;
1015  }
1016  template <class AT1, class AT2, int N, class Type, class Row1, class Col1, class Row2>
1017  inline Matrix<Type, Var, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> operator*(const Matrix<Type, Row1, Col1, AT1> &A1, const Matrix<Type, Row2, Fixed<N>, AT2> &A2) {
1018  Matrix<Type, Var, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> A3(A1.rows(), A2.cols(), NONINIT);
1019  mult(A1, A2, A3);
1020  return A3;
1021  }
1022  template <class AT1, class AT2, int M, int N, class Type, class Col1, class Row2>
1023  inline Matrix<Type, Fixed<M>, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> operator*(const Matrix<Type, Fixed<M>, Col1, AT1> &A1, const Matrix<Type, Row2, Fixed<N>, AT2> &A2) {
1024  Matrix<Type, Fixed<M>, Fixed<N>, typename OperatorResult<AT1, AT2>::Type> A3(A1.rows(), A2.cols(), NONINIT);
1025  mult(A1, A2, A3);
1026  return A3;
1027  }
1028  template <class AT1, class AT2, int M, class Type>
1029  inline Matrix<Type, Fixed<M>, Fixed<M>, typename OperatorResult<AT1, AT2>::Type> operator*(const Matrix<Type, Fixed<M>, Fixed<M>, AT1> &A1, const Matrix<Type, Fixed<M>, Fixed<M>, AT2> &A2) {
1030  Matrix<Type, Fixed<M>, Fixed<M>, typename OperatorResult<AT1, AT2>::Type> A3(A1.rows(), A2.cols(), NONINIT);
1031  mult(A1, A2, A3);
1032  return A3;
1033  }
1034 
1035 // SquareMatrix-SquareMatrix
1036  template <class AT1, class AT2, class Row1, class Row2>
1037  inline SquareMatrix<Var, typename OperatorResult<AT1, AT2>::Type> operator*(const SquareMatrix<Row1, AT1> &A1, const SquareMatrix<Row2, AT2> &A2) {
1038  SquareMatrix<Var, typename OperatorResult<AT1, AT2>::Type> A3(A1.size(), NONINIT);
1039  mult(A1, A2, A3);
1040  return A3;
1041  }
1042  template <class AT1, class AT2, class Row>
1043  inline SquareMatrix<Row, typename OperatorResult<AT1, AT2>::Type> operator*(const SquareMatrix<Row, AT1> &A1, const SquareMatrix<Row, AT2> &A2) {
1044  SquareMatrix<Row, typename OperatorResult<AT1, AT2>::Type> A3(A1.size(), NONINIT);
1045  mult(A1, A2, A3);
1046  return A3;
1047  }
1048 
1049  // SymmetricMatrix-SymmetricMatrix
1050  template <class AT1, class AT2, class Row1, class Row2>
1051  inline Matrix<General, Var, Var, typename OperatorResult<AT1, AT2>::Type> operator*(const Matrix<Symmetric, Row1, Row1, AT1> &A1, const Matrix<Symmetric, Row2, Row2, AT2> &A2) {
1052  Matrix<General, Var, Var, typename OperatorResult<AT1, AT2>::Type> A3(A1.rows(), A2.cols(), NONINIT);
1053  mult(A1, A2, A3);
1054  return A3;
1055  }
1056  template <class AT1, class AT2, class Row>
1057  inline Matrix<General, Row, Row, typename OperatorResult<AT1, AT2>::Type> operator*(const Matrix<Symmetric, Row, Row, AT1> &A1, const Matrix<Symmetric, Row, Row, AT2> &A2) {
1058  Matrix<General, Row, Row, typename OperatorResult<AT1, AT2>::Type> A3(A1.rows(), A2.cols(), NONINIT);
1059  mult(A1, A2, A3);
1060  return A3;
1061  }
1062 
1064 
1071  template <class Row, class AT1, class AT2>
1073 
1075 
1076  for (int i = 0; i < x.size(); i++)
1077  y.e(i) = x.e(i) * alpha;
1078 
1079  return y;
1080  }
1081  // move
1082  template <class Row>
1083  Vector<Row, double> operator*(Vector<Row, double> &&x, const double& alpha) {
1084  for (int i = 0; i < x.size(); i++)
1085  x.e(i) *= alpha;
1086  return std::move(x);
1087  }
1088 
1093  template <class Row, class AT1, class AT2>
1095 
1097 
1098  for (int i = 0; i < x.size(); i++)
1099  y.e(i) = x.e(i) * alpha;
1100 
1101  return y;
1102  }
1103  // move
1104  template <class Row>
1105  Vector<Row, double> operator*(const double& alpha, Vector<Row, double> &&x) {
1106  for (int i = 0; i < x.size(); i++)
1107  x.e(i) *= alpha;
1108  return std::move(x);
1109  }
1110 
1111  template <class Row, class AT1, class AT2>
1112  inline Vector<Row, AT1> operator*=(Vector<Row, AT1> &x, const AT2 &alpha) {
1113  for (int i = 0; i < x.size(); i++)
1114  x.e(i) *= alpha;
1115  return x;
1116  }
1117 
1118  template <class Row, class AT1, class AT2>
1119  inline Vector<Row, typename OperatorResult<AT1, AT2>::Type> operator/(const Vector<Row, AT1> &x, const AT2 &alpha) {
1120  Vector<Row, typename OperatorResult<AT1, AT2>::Type> y(x.size(), NONINIT);
1121  for (int i = 0; i < x.size(); i++)
1122  y.e(i) = x.e(i) / alpha;
1123  return y;
1124  }
1125  // move
1126  template <class Row>
1127  inline Vector<Row, double> operator/(Vector<Row, double> &&x, const double &alpha) {
1128  for (int i = 0; i < x.size(); i++)
1129  x.e(i) /= alpha;
1130  return std::move(x);
1131  }
1132 
1133  template <class Row, class AT1, class AT2>
1134  inline Vector<Row, AT1> operator/=(Vector<Row, AT1> &x, const AT2 &alpha) {
1135  for (int i = 0; i < x.size(); i++)
1136  x.e(i) /= alpha;
1137  return x;
1138  }
1145  template <class Col, class AT1, class AT2>
1147 
1149 
1150  for (int i = 0; i < x.size(); i++)
1151  y.e(i) = x.e(i) * alpha;
1152 
1153  return y;
1154  }
1155  // move
1156  template <class Col>
1157  RowVector<Col, double> operator*(RowVector<Col, double> &&x, const double& alpha) {
1158  for (int i = 0; i < x.size(); i++)
1159  x.e(i) *= alpha;
1160  return std::move(x);
1161  }
1162 
1167  template <class Col, class AT1, class AT2>
1169 
1171 
1172  for (int i = 0; i < x.size(); i++)
1173  y.e(i) = x.e(i) * alpha;
1174 
1175  return y;
1176  }
1177  // move
1178  template <class Col>
1179  RowVector<Col, double> operator*(const double &alpha, RowVector<Col, double> &&x) {
1180  for (int i = 0; i < x.size(); i++)
1181  x.e(i) *= alpha;
1182  return std::move(x);
1183  }
1184 
1185  template <class Col, class AT1, class AT2>
1186  inline RowVector<Col, AT1> operator*=(RowVector<Col, AT1> &x, const AT2 &alpha) {
1187  for (int i = 0; i < x.size(); i++)
1188  x.e(i) *= alpha;
1189  return x;
1190  }
1191 
1192  template <class Col, class AT1, class AT2>
1193  inline RowVector<Col, typename OperatorResult<AT1, AT2>::Type> operator/(const RowVector<Col, AT1> &x, const AT2 &a) {
1194  RowVector<Col, typename OperatorResult<AT1, AT2>::Type> y(x.size(), NONINIT);
1195  for (int i = 0; i < x.size(); i++)
1196  y.e(i) = x.e(i) / a;
1197  return y;
1198  }
1199  // move
1200  template <class Col>
1201  inline RowVector<Col, double> operator/(RowVector<Col, double> &&x, const double &a) {
1202  for (int i = 0; i < x.size(); i++)
1203  x.e(i) /= a;
1204  return std::move(x);
1205  }
1206 
1207  template <class Col, class AT1, class AT2>
1208  inline RowVector<Col, AT1> operator/=(RowVector<Col, AT1> &x, const AT2 &a) {
1209  for (int i = 0; i < x.size(); i++)
1210  x.e(i) /= a;
1211  return x;
1212  }
1213 
1215 
1217 
1224  template <class Col, class Row, class AT1, class AT2>
1226 
1227  FMATVEC_ASSERT(x.size() == y.size(), AT2);
1228 
1229  typename OperatorResult<AT1, AT2>::Type res = 0;
1230 
1231  for (int i = 0; i < x.size(); i++)
1232  res += x.e(i) * y.e(i);
1233 
1234  return res;
1235  }
1236 
1242  template <class Row, class AT>
1244 
1245  FMATVEC_ASSERT(x.size() == y.size(), AT);
1246 
1247  AT res = 0;
1248 
1249  for (int i = 0; i < x.size(); i++)
1250  res += x.e(i) * y.e(i);
1251 
1252  return res;
1253  }
1254 
1260  template <class Row1, class Row2, class AT1, class AT2>
1262 
1263  FMATVEC_ASSERT(x.size() == 3, AT2);
1264  FMATVEC_ASSERT(y.size() == 3, AT2);
1265 
1266  Vector<Fixed<3>, typename OperatorResult<AT1, AT2>::Type> z(3, NONINIT);
1267 
1268  z.e(0) = x.e(1) * y.e(2) - x.e(2) * y.e(1);
1269  z.e(1) = x.e(2) * y.e(0) - x.e(0) * y.e(2);
1270  z.e(2) = x.e(0) * y.e(1) - x.e(1) * y.e(0);
1271 
1272  return z;
1273  }
1274 
1280  template <class Row, class AT>
1281  double tripleProduct(const Vector<Row, AT> &a, const Vector<Row, AT> &x, const Vector<Row, AT> &y) {
1282 
1283  FMATVEC_ASSERT(a.size() == 3, AT);
1284  FMATVEC_ASSERT(x.size() == 3, AT);
1285  FMATVEC_ASSERT(y.size() == 3, AT);
1286 
1287  return a.e(0) * (x.e(1) * y.e(2) - x.e(2) * y.e(1)) + a.e(1) * (x.e(2) * y.e(0) - x.e(0) * y.e(2)) + a.e(2) * (x.e(0) * y.e(1) - x.e(1) * y.e(0));
1288  }
1289 
1291  //
1293 
1302  template <class Type, class Row, class Col, class AT1, class AT2>
1304 
1306 
1307  for (int i = 0; i < A.rows(); i++)
1308  for (int j = 0; j < A.cols(); j++)
1309  B.e(i, j) = A.e(i, j) * alpha;
1310 
1311  return B;
1312  }
1313  // move
1314  template <class Type, class Row, class Col>
1315  Matrix<Type, Row, Col, double> operator*(Matrix<Type, Row, Col, double> &&A, const double &alpha) {
1316  for (int i = 0; i < A.rows(); i++)
1317  for (int j = 0; j < A.cols(); j++)
1318  A.e(i, j) *= alpha;
1319  return std::move(A);
1320  }
1321 
1322  template <class Type, class Row, class Col, class AT1, class AT2>
1323  Matrix<Type, Row, Col, typename OperatorResult<AT1, AT2>::Type> operator*(const AT1 &alpha, const Matrix<Type, Row, Col, AT2> &A) {
1324 
1325  Matrix<Type, Row, Col, typename OperatorResult<AT1, AT2>::Type> B(A.rows(), A.cols(), NONINIT);
1326 
1327  for (int i = 0; i < A.rows(); i++)
1328  for (int j = 0; j < A.cols(); j++)
1329  B.e(i, j) = A.e(i, j) * alpha;
1330 
1331  return B;
1332  }
1333  // move
1334  template <class Type, class Row, class Col>
1335  Matrix<Type, Row, Col, double> operator*(const double &alpha, Matrix<Type, Row, Col, double> &&A) {
1336  for (int i = 0; i < A.rows(); i++)
1337  for (int j = 0; j < A.cols(); j++)
1338  A.e(i, j) *= alpha;
1339  return std::move(A);
1340  }
1341 
1342  template <class Row, class AT1, class AT2>
1343  inline Matrix<Symmetric, Row, Row, typename OperatorResult<AT1, AT2>::Type> operator*(const AT1 &alpha, const Matrix<Symmetric, Row, Row, AT2> &A) {
1344  Matrix<Symmetric, Row, Row, typename OperatorResult<AT1, AT2>::Type> B(A.size(), A.size(), NONINIT);
1345  for (int i = 0; i < A.size(); i++)
1346  for (int j = i; j < A.size(); j++)
1347  B.ej(i, j) = A.ej(i, j) * alpha;
1348  return B;
1349  }
1350  // move
1351  template <class Row>
1352  inline Matrix<Symmetric, Row, Row, double> operator*(const double &alpha, Matrix<Symmetric, Row, Row, double> &&A) {
1353  for (int i = 0; i < A.size(); i++)
1354  for (int j = i; j < A.size(); j++)
1355  A.ej(i, j) *= alpha;
1356  return std::move(A);
1357  }
1358 
1359  template <class Row, class AT1, class AT2>
1360  inline Matrix<Symmetric, Row, Row, typename OperatorResult<AT1, AT2>::Type> operator*(const Matrix<Symmetric, Row, Row, AT1> &A, const AT2 &alpha) {
1361  Matrix<Symmetric, Row, Row, typename OperatorResult<AT1, AT2>::Type> B(A.size(), A.size(), NONINIT);
1362  for (int i = 0; i < A.size(); i++)
1363  for (int j = i; j < A.size(); j++)
1364  B.ej(i, j) = A.ej(i, j) * alpha;
1365  return B;
1366  }
1367  // move
1368  template <class Row>
1369  inline Matrix<Symmetric, Row, Row, double> operator*(Matrix<Symmetric, Row, Row, double> &&A, const double &alpha) {
1370  for (int i = 0; i < A.size(); i++)
1371  for (int j = i; j < A.size(); j++)
1372  A.ej(i, j) *= alpha;
1373  return std::move(A);
1374  }
1375 
1376  template <class AT1, class AT2>
1377  inline Matrix<Diagonal, Ref, Ref, typename OperatorResult<AT1, AT2>::Type> operator*(const AT1 &alpha, const Matrix<Diagonal, Ref, Ref, AT2> &A) {
1378  Matrix<Diagonal, Ref, Ref, typename OperatorResult<AT1, AT2>::Type> B(A.rows(), A.cols(), NONINIT);
1379  for (int i = 0; i < A.rows(); i++)
1380  B.e(i) = A.e(i) * alpha;
1381  return B;
1382  }
1383  // move
1384  inline Matrix<Diagonal, Ref, Ref, double> operator*(const double &alpha, Matrix<Diagonal, Ref, Ref, double> &&A) {
1385  for (int i = 0; i < A.rows(); i++)
1386  A.e(i) *= alpha;
1387  return std::move(A);
1388  }
1389 
1390  template <class AT1, class AT2>
1391  inline Matrix<Diagonal, Ref, Ref, typename OperatorResult<AT1, AT2>::Type> operator*(const Matrix<Diagonal, Ref, Ref, AT1> &A, const AT2 &alpha) {
1392  Matrix<Diagonal, Ref, Ref, typename OperatorResult<AT1, AT2>::Type> B(A.rows(), A.cols(), NONINIT);
1393  for (int i = 0; i < A.size(); i++)
1394  B.e(i) = A.e(i) * alpha;
1395  return B;
1396  }
1397  // move
1398  inline Matrix<Diagonal, Ref, Ref, double> operator*(Matrix<Diagonal, Ref, Ref, double> &&A, const double &alpha) {
1399  for (int i = 0; i < A.size(); i++)
1400  A.e(i) *= alpha;
1401  return std::move(A);
1402  }
1403 
1404  template <class Type, class Row, class Col, class AT1, class AT2>
1405  Matrix<Type, Row, Col, typename OperatorResult<AT1, AT2>::Type> operator/(const Matrix<Type, Row, Col, AT1> &A, const AT2 &alpha) {
1406 
1407  Matrix<Type, Row, Col, typename OperatorResult<AT1, AT2>::Type> B(A.rows(), A.cols(), NONINIT);
1408 
1409  for (int i = 0; i < A.rows(); i++)
1410  for (int j = 0; j < A.cols(); j++)
1411  B.e(i, j) = A.e(i, j) / alpha;
1412 
1413  return B;
1414  }
1415  // move
1416  template <class Type, class Row, class Col>
1417  Matrix<Type, Row, Col, double> operator/(Matrix<Type, Row, Col, double> &&A, const double &alpha) {
1418  for (int i = 0; i < A.rows(); i++)
1419  for (int j = 0; j < A.cols(); j++)
1420  A.e(i, j) /= alpha;
1421  return std::move(A);
1422  }
1423 
1424  template <class Row, class AT1, class AT2>
1425  inline Matrix<Symmetric, Row, Row, typename OperatorResult<AT1, AT2>::Type> operator/(const Matrix<Symmetric, Row, Row, AT1> &A, const AT2 &alpha) {
1426  Matrix<Symmetric, Row, Row, typename OperatorResult<AT1, AT2>::Type> B(A.size(), A.size(), NONINIT);
1427  for (int i = 0; i < A.size(); i++)
1428  for (int j = i; j < A.size(); j++)
1429  B.ej(i, j) = A.ej(i, j) / alpha;
1430  return B;
1431  }
1432  // move
1433  template <class Row>
1434  inline Matrix<Symmetric, Row, Row, double> operator/(Matrix<Symmetric, Row, Row, double> &&A, const double &alpha) {
1435  for (int i = 0; i < A.size(); i++)
1436  for (int j = i; j < A.size(); j++)
1437  A.ej(i, j) /= alpha;
1438  return std::move(A);
1439  }
1440 
1441  template <class Row, class AT1, class AT2>
1442  inline Matrix<Diagonal, Row, Row, typename OperatorResult<AT1, AT2>::Type> operator/(const Matrix<Diagonal, Row, Row, AT1> &A, const AT2 &alpha) {
1443  Matrix<Diagonal, Row, Row, typename OperatorResult<AT1, AT2>::Type> B(A.size(), A.size(), NONINIT);
1444  for (int i = 0; i < A.size(); i++)
1445  B.e(i) = A.e(i) / alpha;
1446  return B;
1447  }
1448  // move
1449  template <class Row>
1450  inline Matrix<Diagonal, Row, Row, double> operator/(Matrix<Diagonal, Row, Row, double> &&A, const double &alpha) {
1451  for (int i = 0; i < A.size(); i++)
1452  A.e(i) /= alpha;
1453  return std::move(A);
1454  }
1455 
1456  template <class Row, class AT1, class AT2>
1457  SquareMatrix<Row, typename OperatorResult<AT1, AT2>::Type> operator*(const SquareMatrix<Row, AT1> &A, const AT2 &alpha) {
1458 
1459  SquareMatrix<Row, typename OperatorResult<AT1, AT2>::Type> B(A.size(), NONINIT);
1460 
1461  for (int i = 0; i < A.size(); i++)
1462  for (int j = 0; j < A.size(); j++)
1463  B.e(i, j) = A.e(i, j) * alpha;
1464 
1465  return B;
1466  }
1467  // move
1468  template <class Row>
1469  SquareMatrix<Row, double> operator*(SquareMatrix<Row, double> &&A, const double &alpha) {
1470  for (int i = 0; i < A.size(); i++)
1471  for (int j = 0; j < A.size(); j++)
1472  A.e(i, j) *= alpha;
1473  return std::move(A);
1474  }
1475 
1476  template <class Row, class AT1, class AT2>
1477  SquareMatrix<Row, typename OperatorResult<AT1, AT2>::Type> operator*(const AT1 &alpha, const SquareMatrix<Row, AT2> &A) {
1478 
1479  SquareMatrix<Row, typename OperatorResult<AT1, AT2>::Type> B(A.size(), NONINIT);
1480 
1481  for (int i = 0; i < A.size(); i++)
1482  for (int j = 0; j < A.size(); j++)
1483  B.e(i, j) = A.e(i, j) * alpha;
1484 
1485  return B;
1486  }
1487  // move
1488  template <class Row>
1489  SquareMatrix<Row, double> operator*(const double &alpha, SquareMatrix<Row, double> &&A) {
1490  for (int i = 0; i < A.size(); i++)
1491  for (int j = 0; j < A.size(); j++)
1492  A.e(i, j) *= alpha;
1493  return std::move(A);
1494  }
1495 
1496  template <class Row, class AT1, class AT2>
1497  SquareMatrix<Row, typename OperatorResult<AT1, AT2>::Type> operator/(const SquareMatrix<Row, AT1> &A, const AT2 &alpha) {
1498 
1499  SquareMatrix<Row, typename OperatorResult<AT1, AT2>::Type> B(A.size(), NONINIT);
1500 
1501  for (int i = 0; i < A.size(); i++)
1502  for (int j = 0; j < A.size(); j++)
1503  B.e(i, j) = A.e(i, j) / alpha;
1504 
1505  return B;
1506  }
1507  // move
1508  template <class Row>
1509  SquareMatrix<Row, double> operator/(SquareMatrix<Row, double> &&A, const double &alpha) {
1510  for (int i = 0; i < A.size(); i++)
1511  for (int j = 0; j < A.size(); j++)
1512  A.e(i, j) /= alpha;
1513  return std::move(A);
1514  }
1515 
1516  template <class Type, class Row, class Col, class AT1, class AT2>
1517  Matrix<Type, Row, Col, typename OperatorResult<AT1, AT2>::Type> operator*=(Matrix<Type, Row, Col, AT1> &A, const AT2 &alpha) {
1518  for (int i = 0; i < A.rows(); i++)
1519  for (int j = 0; j < A.cols(); j++)
1520  A.e(i, j) *= alpha;
1521 
1522  return A;
1523  }
1524 
1525  template <class Row, class AT1, class AT2>
1526  inline Matrix<Symmetric, Row, Row, AT1> operator*=(Matrix<Symmetric, Row, Row, AT1> &A, const AT2 &alpha) {
1527  for (int i = 0; i < A.size(); i++)
1528  for (int j = i; j < A.size(); j++)
1529  A.ej(i, j) *= alpha;
1530  return A;
1531  }
1532 
1533  template <class Row, class AT1, class AT2>
1534  inline Matrix<Diagonal, Row, Row, AT1> operator*=(Matrix<Diagonal, Row, Row, AT1> &A, const AT2 &alpha) {
1535  for (int i = 0; i < A.size(); i++)
1536  A.e(i) *= alpha;
1537  return A;
1538  }
1539 
1540  template <class Type, class Row, class Col, class AT1, class AT2>
1541  Matrix<Type, Row, Col, AT1> operator/=(Matrix<Type, Row, Col, AT1> &A, const AT2 &alpha) {
1542  for (int i = 0; i < A.rows(); i++)
1543  for (int j = 0; j < A.cols(); j++)
1544  A.e(i, j) /= alpha;
1545 
1546  return A;
1547  }
1548 
1549  template <class Row, class AT1, class AT2>
1550  inline Matrix<Symmetric, Row, Row, AT1> operator/=(Matrix<Symmetric, Row, Row, AT1> &A, const AT2 &alpha) {
1551  for (int i = 0; i < A.size(); i++)
1552  for (int j = i; j < A.size(); j++)
1553  A.ej(i, j) /= alpha;
1554  return A;
1555  }
1556 
1557  template <class Row, class AT1, class AT2>
1558  inline Matrix<Diagonal, Row, Row, AT1> operator/=(Matrix<Diagonal, Row, Row, AT1> &A, const AT2 &alpha) {
1559  for (int i = 0; i < A.size(); i++)
1560  A.e(i) /= alpha;
1561  return A;
1562  }
1563 
1565 
1567 
1573  template <class Row, class AT>
1575 
1577 
1578  for (int i = 0; i < x.size(); i++)
1579  y.e(i) = -x.e(i);
1580 
1581  return y;
1582  }
1583  // move
1584  template <class Row>
1585  Vector<Row, double> operator-(Vector<Row, double> &&x) {
1586  for (int i = 0; i < x.size(); i++)
1587  x.e(i) = -x.e(i);
1588  return std::move(x);
1589  }
1590 
1596  template <class Col, class AT>
1598 
1600 
1601  for (int i = 0; i < a.size(); i++)
1602  c.e(i) = -a.e(i);
1603 
1604  return c;
1605  }
1606  // move
1607  template <class Col>
1608  RowVector<Col, double> operator-(RowVector<Col, double> &&a) {
1609  for (int i = 0; i < a.size(); i++)
1610  a.e(i) = -a.e(i);
1611  return std::move(a);
1612  }
1613 
1619  template <class Row, class AT>
1621 
1623 
1624  for (int i = 0; i < A.size(); i++)
1625  for (int j = 0; j < A.size(); j++)
1626  B.e(i, j) = -A.e(i, j);
1627 
1628  return B;
1629  }
1630  // move
1631  template <class Row>
1632  SquareMatrix<Row, double> operator-(SquareMatrix<Row, double> &&A) {
1633  for (int i = 0; i < A.size(); i++)
1634  for (int j = 0; j < A.size(); j++)
1635  A.e(i, j) = -A.e(i, j);
1636  return std::move(A);
1637  }
1638 
1644  template <class Type, class Row, class Col, class AT>
1646 
1648 
1649  for (int i = 0; i < A.rows(); i++)
1650  for (int j = 0; j < A.cols(); j++)
1651  B.e(i, j) = -A.e(i, j);
1652 
1653  return B;
1654  }
1655  // move
1656  template <class Type, class Row, class Col>
1657  Matrix<Type, Row, Col, double> operator-(Matrix<Type, Row, Col, double> &&A) {
1658  for (int i = 0; i < A.rows(); i++)
1659  for (int j = 0; j < A.cols(); j++)
1660  A.e(i, j) = -A.e(i, j);
1661  return std::move(A);
1662  }
1663 
1666 
1672  template <class Row, class AT>
1673  RowVector<Row,AT> trans(const Vector<Row,AT> &x) { return x.T(); }
1674  // move
1675  inline RowVector<Var,double> trans(Vector<Var,double> &&x) { return std::move(x).T(); }
1676 
1684  template <class Col, class AT>
1685  Vector<Col,AT> trans(const RowVector<Col,AT> &x) { return x.T(); }
1686  // move
1687  inline Vector<Var,double> trans(RowVector<Var,double> &&x) { return std::move(x).T(); }
1688 
1697  template <class Type, class Row, class Col, class AT>
1699 
1708  template <class Row, class AT>
1710 
1711 // template <class Type, class Row, class Col, class AT>
1712 // inline Matrix<Type, Col, Row, AT> trans(const Matrix<Type, Row, Col, AT> &A) {
1713 // Matrix<Type, Col, Row, AT> B(A.cols(), A.rows(), NONINIT);
1714 // for (int i = 0; i < B.rows(); i++)
1715 // for (int j = 0; j < B.cols(); j++)
1716 // B.e(i, j) = A.e(j, i);
1717 // return B;
1718 // }
1719 //
1720 // template <class Row, class AT>
1721 // inline SquareMatrix<Row, AT> trans(const SquareMatrix<Row, AT> &A) {
1722 // SquareMatrix<Row, AT> B(A.size(), NONINIT);
1723 // for (int i = 0; i < B.size(); i++)
1724 // for (int j = 0; j < B.size(); j++)
1725 // B.e(i, j) = A.e(j, i);
1726 // return B;
1727 // }
1728 //
1729 // template <class Row, class AT>
1730 // inline RowVector<Row, AT> trans(const Vector<Row, AT> &x) {
1731 // RowVector<Row, AT> y(x.size(), NONINIT);
1732 // for (int i = 0; i < y.size(); i++)
1733 // y.e(i) = x.e(i);
1734 // return y;
1735 // }
1736 //
1737 // template <class Row, class AT>
1738 // inline Vector<Row, AT> trans(const RowVector<Row, AT> &x) {
1739 // Vector<Row, AT> y(x.size(), NONINIT);
1740 // for (int i = 0; i < y.size(); i++)
1741 // y.e(i) = x.e(i);
1742 // return y;
1743 // }
1744 
1746 
1748  template <class Row, class AT>
1749  inline AT nrmInf(const Vector<Row, AT> &x) {
1750  AT c = 0;
1751  for (int i = 0; i < x.size(); i++)
1752  if (c < fabs(x.e(i)))
1753  c = fabs(x.e(i));
1754  return c;
1755  }
1756 
1757  template <class Row, class AT>
1758  inline AT nrmInf(const RowVector<Row, AT> &x) {
1759  AT c = 0;
1760  for (int i = 0; i < x.size(); i++)
1761  if (c < fabs(x.e(i)))
1762  c = fabs(x.e(i));
1763  return c;
1764  }
1765 
1766  template <class Row, class AT>
1767  inline typename OperatorResult<AT, AT>::Type nrm2(const Vector<Row, AT> &x) {
1768  typename OperatorResult<AT, AT>::Type c=typename OperatorResult<AT, AT>::Type();
1769  for (int i = 0; i < x.size(); i++)
1770  c += pow(x.e(i), 2);
1771  return sqrt(c);
1772  }
1773 
1774  template <class Col, class AT>
1775  inline typename OperatorResult<AT, AT>::Type nrm2(const RowVector<Col, AT> &x) {
1776  typename OperatorResult<AT, AT>::Type c=typename OperatorResult<AT, AT>::Type();
1777  for (int i = 0; i < x.size(); i++)
1778  c += pow(x.e(i), 2);
1779  return sqrt(c);
1780  }
1781 
1783 
1795  template <class Row, class AT>
1797 
1798  SquareMatrix<Row, AT> B(x.size(), NONINIT);
1799 
1800  B.e(0, 0) = 0.0;
1801  B.e(1, 1) = 0.0;
1802  B.e(2, 2) = 0.0;
1803  B.e(0, 1) = -x.e(2);
1804  B.e(0, 2) = x.e(1);
1805  B.e(1, 0) = x.e(2);
1806  B.e(1, 2) = -x.e(0);
1807  B.e(2, 0) = -x.e(1);
1808  B.e(2, 1) = x.e(0);
1809 
1810  return B;
1811  }
1812 
1818  template <class AT, class Type1, class Row1, class Col1, class Type2, class Row2, class Col2>
1820 
1821  if (&A == &B)
1822  return true;
1823 
1824  if (A.rows() != B.rows() || A.cols() != B.cols())
1825  return false;
1826 
1827  for (int i = 0; i < A.rows(); i++)
1828  for (int j = 0; j < A.cols(); j++)
1829  if (A(i, j) != B(i, j))
1830  return false;
1831 
1832  return true;
1833  }
1834 
1840  template <class AT, class Type1, class Row1, class Col1, class Type2, class Row2, class Col2>
1842 
1843  if (A.rows() != B.rows() || A.cols() != B.cols())
1844  return true;
1845 
1846  for (int i = 0; i < A.rows(); i++)
1847  for (int j = 0; j < A.cols(); j++)
1848  if (A(i, j) != B(i, j))
1849  return true;
1850 
1851  return false;
1852  }
1853 
1859  template <class Row, class AT>
1860  AT max(const Vector<Row, AT> &x) {
1861 
1862  FMATVEC_ASSERT(x.size() > 0, AT);
1863  AT maximum = x.e(0);
1864  for (int i = 1; i < x.size(); i++) {
1865  if (x.e(i) > maximum)
1866  maximum = x.e(i);
1867  }
1868  return maximum;
1869  }
1870 
1876  template <class Row, class AT>
1877  int maxIndex(const Vector<Row, AT> &x) {
1878 
1879  FMATVEC_ASSERT(x.size() > 0, AT);
1880  AT maximum = x.e(0);
1881  int index = 0;
1882  for (int i = 1; i < x.size(); i++) {
1883  if (x.e(i) > maximum) {
1884  maximum = x.e(i);
1885  index = i;
1886  }
1887  }
1888  return index;
1889  }
1890 
1896  template <class Row, class AT>
1897  AT min(const Vector<Row, AT> &x) {
1898 
1899  FMATVEC_ASSERT(x.size() > 0, AT);
1900  AT minimum = x.e(0);
1901  for (int i = 1; i < x.size(); i++) {
1902  if (x.e(i) < minimum)
1903  minimum = x.e(i);
1904  }
1905  return minimum;
1906  }
1907 
1913  template <class Row, class AT>
1914  int minIndex(const Vector<Row, AT> &x) {
1915 
1916  FMATVEC_ASSERT(x.size() > 0, AT);
1917  AT minimum = x.e(0);
1918  int index = 0;
1919  for (int i = 1; i < x.size(); i++) {
1920  if (x.e(i) < minimum) {
1921  minimum = x.e(i);
1922  index = i;
1923  }
1924  }
1925  return index;
1926  }
1927 
1928  // HR 28.09.2006
1935  template <class AT>
1937 
1938  FMATVEC_ASSERT(A_.rows() > 0, AT);
1939  FMATVEC_ASSERT(A_.cols() > 0, AT);
1940  FMATVEC_ASSERT(A_.cols() > PivotCol, AT);
1942  int i, j, N;
1943  RowVector<Ref, AT> tmp(A.cols(), NONINIT);
1944  N = A.rows();
1945  for (i = 1; i <= N - 1; i++) {
1946  for (j = 0; j < N - 1; j++) {
1947  if (A(j, PivotCol) > A(j + 1, PivotCol)) {
1948  tmp = A.row(j);
1949  A.set(j, A.row(j + 1));
1950  A.set(j + 1, tmp);
1951  }
1952  }
1953  }
1954  return A;
1955  }
1956 
1957  // HR 28.09.2006
1959  template <class AT>
1960  void quicksortmedian_intern(Matrix<General, Ref, Ref, AT> &A, int PivotCol, RowVector<Ref, AT> &tmp, int l, int r) {
1961 
1962  if (r > l) {
1963  int i = l - 1, j = r;
1964  //RowVec tmp;
1965  if (r - l > 3) { //Median of three
1966  int m = l + (r - l) / 2;
1967  if (A(l, PivotCol) > A(m, PivotCol)) {
1968  tmp = A.row(l);
1969  A.set(l, A.row(m));
1970  A.set(m, tmp);
1971  }
1972  if (A(l, PivotCol) > A(r, PivotCol)) {
1973  tmp = A.row(l);
1974  A.set(l, A.row(r));
1975  A.set(r, tmp);
1976  }
1977  else if (A(r, PivotCol) > A(m, PivotCol)) {
1978  tmp = A.row(r);
1979  A.set(r, A.row(m));
1980  A.set(m, tmp);
1981  }
1982  }
1983 
1984  for (;;) {
1985  while(A(++i,PivotCol) < A(r,PivotCol));
1986  while(A(--j,PivotCol) > A(r,PivotCol) && j>i);
1987  if(i>=j) break;
1988  tmp = A.row(i);
1989  A.set(i, A.row(j));
1990  A.set(j, tmp);
1991  }
1992  tmp = A.row(i);
1993  A.set(i, A.row(r));
1994  A.set(r, tmp);
1995  quicksortmedian_intern(A, PivotCol, tmp, l, i - 1);
1996  quicksortmedian_intern(A, PivotCol, tmp, i + 1, r);
1997  }
1998  }
1999 
2000  // HR 28.09.2006
2009  template <class AT>
2012  int N = A.rows();
2013  RowVector<Ref, AT> tmp(A.cols(), NONINIT);
2014  quicksortmedian_intern(A, PivotCol, tmp, 0, N - 1);
2015  return A;
2016  }
2017 
2018  template <class Row, class Col, class AT>
2019  inline Matrix<Symmetric, Col, Col, AT> JTJ(const Matrix<General, Row, Col, AT> &A) {
2020  Matrix<Symmetric, Col, Col, AT> S(A.cols(), A.cols(), NONINIT);
2021  for (int i = 0; i < A.cols(); i++) {
2022  for (int k = i; k < A.cols(); k++) {
2023  S.ej(i, k) = 0;
2024  for (int j = 0; j < A.rows(); j++)
2025  S.ej(i, k) += A.e(j, i) * A.e(j, k);
2026  }
2027  }
2028  return S;
2029  }
2030 
2031  template <class Row, class Col, class AT>
2032  inline Matrix<Symmetric, Col, Col, AT> JTMJ(const Matrix<Symmetric, Row, Row, AT> &B, const Matrix<General, Row, Col, AT> &A) {
2033 
2034  Matrix<Symmetric, Col, Col, AT> S(A.cols(), A.cols(), NONINIT);
2035  Matrix<General, Row, Col, AT> C = B * A;
2036 
2037  for (int i = 0; i < A.cols(); i++) {
2038  for (int k = i; k < A.cols(); k++) {
2039  S.ej(i, k) = 0;
2040  for (int j = 0; j < A.rows(); j++)
2041  S.ej(i, k) += A.e(j, i) * C.e(j, k);
2042  }
2043  }
2044  return S;
2045  }
2046 
2047  template <class Row, class Col, class AT>
2048  inline Matrix<Symmetric, Row, Row, AT> JMJT(const Matrix<General, Row, Col, AT> &A, const Matrix<Symmetric, Col, Col, AT> &B) {
2049 
2050  Matrix<Symmetric, Row, Row, AT> S(A.rows(), A.rows(), NONINIT);
2051  Matrix<General, Row, Col, AT> C = A * B;
2052 
2053  for (int i = 0; i < S.size(); i++) {
2054  for (int k = i; k < S.size(); k++) {
2055  S.ej(i, k) = 0;
2056  for (int j = 0; j < A.cols(); j++)
2057  S.ej(i, k) += C.e(k, j) * A.e(i, j);
2058  }
2059  }
2060  return S;
2061  }
2062 
2063 }
2064 
2065 #endif
RowVector< Row, AT > trans(const Vector< Row, AT > &x)
Transpose of a vector.
Definition: linear_algebra.h:1673
Matrix< General, Ref, Ref, AT > quickSortMedian(const Matrix< General, Ref, Ref, AT > &A_, int PivotCol)
Modified QuickSort Algorithm (unstable sorting Algorithm )
Definition: linear_algebra.h:2010
This is the basic matrix class for arbitrary matrices.
Definition: fmatvec.h:41
int rows() const
Number of rows.
Definition: general_matrix.h:304
void quicksortmedian_intern(Matrix< General, Ref, Ref, AT > &A, int PivotCol, RowVector< Ref, AT > &tmp, int l, int r)
Definition: linear_algebra.h:1960
int minIndex(const Vector< Row, AT > &x)
Index of minimum value.
Definition: linear_algebra.h:1914
Definition: fmatvec.h:50
Vector< Fixed< 3 >, typename OperatorResult< AT1, AT2 >::Type > crossProduct(const Vector< Row1, AT1 > &x, const Vector< Row2, AT2 > &y)
Cross product.
Definition: linear_algebra.h:1261
This is a rowvector class of general shape in dense storage format.
Definition: row_vector.h:36
Definition: fmatvec.h:44
AT min(const Vector< Row, AT > &x)
Minimum value.
Definition: linear_algebra.h:1897
Definition: fmatvec.h:47
Matrix< General, Ref, Ref, AT > bubbleSort(const Matrix< General, Ref, Ref, AT > &A_, int PivotCol)
Bubble Sort Algorithm (stable sorting Algorithm )
Definition: linear_algebra.h:1936
int maxIndex(const Vector< Row, AT > &x)
Index of maximum value.
Definition: linear_algebra.h:1877
int cols() const
Number of columns.
This is a matrix class for general matrices.
Definition: general_matrix.h:41
Namespace fmatvec.
Definition: _memory.cc:28
bool operator==(const Matrix< Type1, Row1, Col1, AT > &A, const Matrix< Type2, Row2, Col2, AT > &B)
Matrix-matrix comparison.
Definition: linear_algebra.h:1819
int cols() const
Number of columns.
Definition: general_matrix.h:310
const RowVector< Ref, AT > row(int i) const
Row operator.
Definition: general_matrix.h:516
bool operator!=(const Matrix< Type1, Row1, Col1, AT > &A, const Matrix< Type2, Row2, Col2, AT > &B)
Matrix-matrix comparison.
Definition: linear_algebra.h:1841
Definition: types.h:210
AT max(const Vector< Row, AT > &x)
Maximum value.
Definition: linear_algebra.h:1860
double tripleProduct(const Vector< Row, AT > &a, const Vector< Row, AT > &x, const Vector< Row, AT > &y)
Triple product.
Definition: linear_algebra.h:1281
SquareMatrix< Row, AT > tilde(const Vector< Row, AT > &x)
Tilde operator.
Definition: linear_algebra.h:1796
int rows() const
Number of rows.
AT scalarProduct(const Vector< Row, AT > &x, const Vector< Row, AT > &y)
Scalar product.
Definition: linear_algebra.h:1243