OPAL (Object Oriented Parallel Accelerator Library) 2022.1
OPAL
FMatrix.h
Go to the documentation of this file.
1#ifndef CLASSIC_FMatrix_HH
2#define CLASSIC_FMatrix_HH
3
4// ------------------------------------------------------------------------
5// $RCSfile: FMatrix.h,v $
6// ------------------------------------------------------------------------
7// $Revision: 1.2.2.2 $
8// ------------------------------------------------------------------------
9// Copyright: see Copyright.readme
10// ------------------------------------------------------------------------
11//
12// Template class: FMatrix<T,R,C>
13//
14// ------------------------------------------------------------------------
15// Class category: FixedAlgebra
16// ------------------------------------------------------------------------
17//
18// $Date: 2004/11/18 22:18:06 $
19// $Author: jsberg $
20//
21// ------------------------------------------------------------------------
22
23#include "FixedAlgebra/FArray2D.h"
24#include "FixedAlgebra/FVector.h"
25#include "Utilities/SizeError.h"
26#include <algorithm>
27#include <numeric>
28#include <functional>
29
30// Template class FMatrix<T,R,C>
31// ------------------------------------------------------------------------
33// This class implements the basic algebraic operations on general matrices,
34// which need not be square.
35// The destructor generated by the compiler does the correct thing,
36// and is not defined for speed.
37
38template<class T, int R, int C>
39class FMatrix: public FArray2D<T, R, C> {
40
41public:
42
44 // Construct zero matrix.
45 FMatrix();
46
48 FMatrix(const FMatrix &);
49
51 FMatrix(const FArray2D<T, R, C> &);
52
54 // Set all matrix elements to [b]t[/b].
55 explicit FMatrix(const T &t);
56
58 FMatrix &operator=(const FMatrix &);
59
61 // Fill all matrix elements from the C-array [b]t[/b].
62 explicit FMatrix(const T *t);
63
65 FMatrix &operator=(const FArray2D<T, R, C> &);
66
68 FMatrix &operator*=(const T &);
69
71 FMatrix &operator/=(const T &);
72
74 FMatrix &operator+=(const FMatrix &);
75
77 FMatrix &operator-=(const FMatrix &);
78
80 FMatrix<T, C, R> transpose() const;
81};
82
83
84// ------------------------------------------------------------------------
85
87template <class T, int R, int C>
88FMatrix<T, R, C> operator-(const FMatrix<T, R, C> &);
89
91template <class T, int R, int C>
92FMatrix<T, R, C> operator+(const FMatrix<T, R, C> &, const FMatrix<T, R, C> &);
93
95template <class T, int R, int C>
96FMatrix<T, R, C> operator-(const FMatrix<T, R, C> &, const FMatrix<T, R, C> &);
97
99template <class T, int R, int C>
100FVector<T, R> operator*(const FMatrix<T, R, C> &, const FVector<T, C> &);
101
103template <class T, int R, int C>
104FVector<T, C> operator*(const FVector<T, R> &, const FMatrix<T, R, C> &);
105
107template <class T, int R, int C>
108FMatrix<T, R, C> operator*(const FMatrix<T, R, C> &, const T &);
109
111template <class T, int R, int C>
112FMatrix<T, R, C> operator*(const T &, const FMatrix<T, R, C> &);
113
115template <class T, int R, int C>
116FMatrix<T, R, C> operator/(const FMatrix<T, R, C> &, const T &);
117
119template <class T, int C>
120FMatrix<T, C, C> operator+(const FMatrix<T, C, C> &, const T &t);
121
123template <class T, int C>
124FMatrix<T, C, C> operator-(const FMatrix<T, C, C> &, const T &t);
125
126
127// Public methods of FMatrix<T,R,C>.
128// ------------------------------------------------------------------------
129
130template<class T, int R, int C>
131FMatrix<T, R, C>::FMatrix():
132 FArray2D<T, R, C>()
133{}
134
135
136template<class T, int R, int C>
137FMatrix<T, R, C>::FMatrix(const FMatrix<T, R, C> &rhs):
138 FArray2D<T, R, C>(rhs)
139{}
140
141
142template<class T, int R, int C>
143FMatrix<T, R, C>::FMatrix(const FArray2D<T, R, C> &rhs):
144 FArray2D<T, R, C>(rhs)
145{}
146
147
148template<class T, int R, int C>
149FMatrix<T, R, C>::FMatrix(const T &rhs):
150 FArray2D<T, R, C>(rhs)
151{}
152
153
154template<class T, int R, int C>
155FMatrix<T, R, C>::FMatrix(const T *rhs):
156 FArray2D<T, R, C>(rhs)
157{}
158
159
160template<class T, int R, int C>
161FMatrix<T, R, C> &FMatrix<T, R, C>::operator=(const FMatrix<T, R, C> &rhs) {
162 FArray2D<T, R, C>::operator=(rhs);
163 return *this;
164}
165
166
167template<class T, int R, int C>
168FMatrix<T, R, C> &FMatrix<T, R, C>::operator=(const FArray2D<T, R, C> &rhs) {
169 FArray2D<T, R, C>::operator=(rhs);
170 return *this;
171}
172
173
174template<class T, int R, int C>
175FMatrix<T, R, C> &FMatrix<T, R, C>::operator*=(const T &rhs) {
176 std::transform(this->begin(), this->end(), this->begin(),
177 std::bind(std::multiplies<T>(), std::placeholders::_1, rhs));
178 return *this;
179}
180
181
182template<class T, int R, int C>
183FMatrix<T, R, C> &FMatrix<T, R, C>::operator/=(const T &rhs) {
184 std::transform(this->begin(), this->end(), this->begin(),
185 std::bind(std::divides<T>(), std::placeholders::_1, rhs));
186 return *this;
187}
188
189
190template<class T, int R, int C>
191FMatrix<T, R, C> &FMatrix<T, R, C>::operator+=(const FMatrix<T, R, C> &array) {
192 std::transform(this->begin(), this->end(), array.begin(), this->begin(),
193 std::plus<T>());
194 return *this;
195}
196
197
198template<class T, int R, int C>
199FMatrix<T, R, C> &FMatrix<T, R, C>::operator-=(const FMatrix<T, R, C> &array) {
200 std::transform(this->begin(), this->end(), array.begin(), this->begin(),
201 std::minus<T>());
202 return *this;
203}
204
205
206template <class T, int R, int C>
207FMatrix<T, C, R> FMatrix<T, R, C>::transpose() const {
208 FMatrix<T, C, R> result;
209
210 for(int i = 0; i < R; ++i) {
211 std::copy(this->row_begin(i), this->row_end(i), result.col_begin(i));
212 }
213
214 return result;
215}
216
217
218// Global functions acting on FMatrix<T,R,C>.
219// ------------------------------------------------------------------------
220
221template<class T, int R, int C>
222FMatrix<T, R, C> operator-(const FMatrix<T, R, C> &rhs) {
223 FMatrix<T, R, C> result;
224 std::transform(rhs.begin(), rhs.end(), result.begin(), std::negate<T>());
225 return result;
226}
227
228
229template<class T, int R, int C>
230FMatrix<T, R, C> operator+(const FMatrix<T, R, C> &lhs, const FMatrix<T, R, C> &rhs) {
231 FMatrix<T, R, C> result(lhs);
232 return result += rhs;
233}
234
235
236template<class T, int R, int C>
237FMatrix<T, R, C> operator-(const FMatrix<T, R, C> &lhs, const FMatrix<T, R, C> &rhs) {
238 FMatrix<T, R, C> result(lhs);
239 return result -= rhs;
240}
241
242
243template <class T, int R, int I, int C>
244FMatrix<T, R, C> operator*(const FMatrix<T, R, I> &lhs, const FMatrix<T, I, C> &rhs) {
245 FMatrix<T, R, C> result;
246
247 for(int i = 0; i < R; i++) {
248 typename FMatrix<T, R, I>::const_row_iterator i1 = lhs.row_begin(i);
249 typename FMatrix<T, R, I>::const_row_iterator i2 = lhs.row_end(i);
250
251 for(int j = 0; j < C; j++) {
252 result(i, j) = std::inner_product(i1, i2, rhs.col_begin(j), T(0));
253 }
254 }
255
256 return result;
257}
258
259
260template<class T, int R, int C>
261FVector<T, R> operator*(const FMatrix<T, R, C> &lhs, const FVector<T, C> &rhs) {
262 FVector<T, R> result;
263
264 for(int i = 0; i < R; ++i) {
265 result[i] = std::inner_product(lhs.row_begin(i), lhs.row_end(i),
266 rhs.begin(), T(0));
267 }
268
269 return result;
270}
271
272
273template<class T, int R, int C>
274FVector<T, C> operator*(const FVector<T, R> &lhs, const FMatrix<T, R, C> &rhs) {
275 FVector<T, C> result;
276
277 for(int j = 0; j < C; j++) {
278 result[j] = std::inner_product(lhs.begin(), lhs.end(),
279 rhs.col_begin(j), T(0));
280 }
281
282 return result;
283}
284
285
286template<class T, int R, int C>
287FMatrix<T, R, C> operator*(const FMatrix<T, R, C> &lhs, const T &rhs) {
288 FMatrix<T, R, C> result(lhs);
289 return result *= rhs;
290}
291
292
293template<class T, int R, int C>
294FMatrix<T, R, C> operator*(const T &lhs, const FMatrix<T, R, C> &rhs) {
295 FMatrix<T, R, C> result(rhs);
296 return result *= lhs;
297}
298
299
300template<class T, int R, int C>
301FMatrix<T, R, C> operator/(const FMatrix<T, R, C> &lhs, const T &rhs) {
302 FMatrix<T, R, C> result(lhs);
303 return result /= rhs;
304}
305
306
307// Special functions on square matrices.
308// ------------------------------------------------------------------------
309
310template<class T, int C>
311FMatrix<T, C, C> operator+(const FMatrix<T, C, C> &lhs, const T &rhs) {
312 FMatrix<T, C, C> result(lhs);
313 for(int i = 0; i < C; i++) result[i][i] += rhs;
314 return result;
315}
316
317
318template<class T, int C>
319FMatrix<T, C, C> operator-(const FMatrix<T, C, C> &lhs, const T &rhs) {
320 FMatrix<T, C, C> result(lhs);
321 for(int i = 0; i < C; i++) result[i][i] -= rhs;
322 return result;
323}
324
325#endif // CLASSIC_FMatrix_HH
operator+
FMatrix< T, R, C > operator+(const FMatrix< T, R, C > &, const FMatrix< T, R, C > &)
Add.
Definition: FMatrix.h:230
operator/
FMatrix< T, R, C > operator/(const FMatrix< T, R, C > &, const T &)
Matrix divided by scalar.
Definition: FMatrix.h:301
operator-
FMatrix< T, R, C > operator-(const FMatrix< T, R, C > &)
Unary minus.
Definition: FMatrix.h:222
operator*
FVector< T, R > operator*(const FMatrix< T, R, C > &, const FVector< T, C > &)
Multiply by column vector.
Definition: FMatrix.h:261
end
PartBunchBase< T, Dim >::ConstIterator end(PartBunchBase< T, Dim > const &bunch)
Definition: PartBunchBase.h:736
begin
PartBunchBase< T, Dim >::ConstIterator begin(PartBunchBase< T, Dim > const &bunch)
Definition: PartBunchBase.h:731
FArray1D::end
iterator end()
Get iterator pointing past end of array.
Definition: FArray1D.h:198
FArray1D::begin
iterator begin()
Get iterator pointing to beginning of array.
Definition: FArray1D.h:192
FArray2D
A templated representation for 2-dimensional arrays.
Definition: FArray2D.h:40
FArray2D::end
iterator end()
Get pointer past end of data.
Definition: FArray2D.h:277
FArray2D::row_end
row_iterator row_end(int r)
Get row iterator.
Definition: FArray2D.h:304
FArray2D::operator=
const FArray2D< T, M, N > & operator=(const FArray2D< T, M, N > &)
Assignment.
Definition: FArray2D.h:228
FArray2D::col_begin
col_iterator col_begin(int c)
Get column iterator.
Definition: FArray2D.h:343
FArray2D< T, R, C >::const_row_iterator
const T * const_row_iterator
Iterator for access by rows.
Definition: FArray2D.h:57
FArray2D::row_begin
row_iterator row_begin(int r)
Get row iterator.
Definition: FArray2D.h:295
FArray2D::begin
iterator begin()
Get beginning of data.
Definition: FArray2D.h:271
FMatrix
A templated representation for matrices.
Definition: FMatrix.h:39
FMatrix::operator+=
FMatrix & operator+=(const FMatrix &)
Add matrix and assign.
Definition: FMatrix.h:191
FMatrix::operator-=
FMatrix & operator-=(const FMatrix &)
Subtract ,atrix and assign.
Definition: FMatrix.h:199
FMatrix::operator/=
FMatrix & operator/=(const T &)
Divide by scalar and assign.
Definition: FMatrix.h:183
FMatrix::FMatrix
FMatrix(const FArray2D< T, R, C > &)
Conversion from two-dimensional array.
Definition: FMatrix.h:143
FMatrix::FMatrix
FMatrix(const T *t)
Constructor.
Definition: FMatrix.h:155
FMatrix::FMatrix
FMatrix(const T &t)
Constructor.
Definition: FMatrix.h:149
FMatrix::operator=
FMatrix & operator=(const FArray2D< T, R, C > &)
Convert and assign.
Definition: FMatrix.h:168
FMatrix::operator*=
FMatrix & operator*=(const T &)
Multiply by scalar and assign.
Definition: FMatrix.h:175
FMatrix::transpose
FMatrix< T, C, R > transpose() const
FMatrix transpose.
Definition: FMatrix.h:207
FMatrix::FMatrix
FMatrix(const FMatrix &)
Copy constructor.
Definition: FMatrix.h:137
FMatrix::operator=
FMatrix & operator=(const FMatrix &)
Assignment.
Definition: FMatrix.h:161
FMatrix::FMatrix
FMatrix()
Default constructor.
Definition: FMatrix.h:131
FVector
A templated representation for vectors.
Definition: FVector.h:38
Generated on Thu Oct 20 2022 17:40:10 for OPAL (Object Oriented Parallel Accelerator Library) by doxygen 1.9.3