OPAL (Object Oriented Parallel Accelerator Library)  2024.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 
38 template<class T, int R, int C>
39 class FMatrix: public FArray2D<T, R, C> {
40 
41 public:
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 
87 template <class T, int R, int C>
88 FMatrix<T, R, C> operator-(const FMatrix<T, R, C> &);
89 
91 template <class T, int R, int C>
92 FMatrix<T, R, C> operator+(const FMatrix<T, R, C> &, const FMatrix<T, R, C> &);
93 
95 template <class T, int R, int C>
96 FMatrix<T, R, C> operator-(const FMatrix<T, R, C> &, const FMatrix<T, R, C> &);
97 
99 template <class T, int R, int C>
100 FVector<T, R> operator*(const FMatrix<T, R, C> &, const FVector<T, C> &);
101 
103 template <class T, int R, int C>
104 FVector<T, C> operator*(const FVector<T, R> &, const FMatrix<T, R, C> &);
105 
107 template <class T, int R, int C>
108 FMatrix<T, R, C> operator*(const FMatrix<T, R, C> &, const T &);
109 
111 template <class T, int R, int C>
112 FMatrix<T, R, C> operator*(const T &, const FMatrix<T, R, C> &);
113 
115 template <class T, int R, int C>
116 FMatrix<T, R, C> operator/(const FMatrix<T, R, C> &, const T &);
117 
119 template <class T, int C>
120 FMatrix<T, C, C> operator+(const FMatrix<T, C, C> &, const T &t);
121 
123 template <class T, int C>
124 FMatrix<T, C, C> operator-(const FMatrix<T, C, C> &, const T &t);
125 
126 
127 // Public methods of FMatrix<T,R,C>.
128 // ------------------------------------------------------------------------
129 
130 template<class T, int R, int C>
131 FMatrix<T, R, C>::FMatrix():
132  FArray2D<T, R, C>()
133 {}
134 
135 
136 template<class T, int R, int C>
137 FMatrix<T, R, C>::FMatrix(const FMatrix<T, R, C> &rhs):
138  FArray2D<T, R, C>(rhs)
139 {}
140 
141 
142 template<class T, int R, int C>
143 FMatrix<T, R, C>::FMatrix(const FArray2D<T, R, C> &rhs):
144  FArray2D<T, R, C>(rhs)
145 {}
146 
147 
148 template<class T, int R, int C>
149 FMatrix<T, R, C>::FMatrix(const T &rhs):
150  FArray2D<T, R, C>(rhs)
151 {}
152 
153 
154 template<class T, int R, int C>
155 FMatrix<T, R, C>::FMatrix(const T *rhs):
156  FArray2D<T, R, C>(rhs)
157 {}
158 
159 
160 template<class T, int R, int C>
161 FMatrix<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 
167 template<class T, int R, int C>
168 FMatrix<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 
174 template<class T, int R, int C>
175 FMatrix<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 
182 template<class T, int R, int C>
183 FMatrix<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 
190 template<class T, int R, int C>
191 FMatrix<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 
198 template<class T, int R, int C>
199 FMatrix<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 
206 template <class T, int R, int C>
207 FMatrix<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 
221 template<class T, int R, int C>
222 FMatrix<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 
229 template<class T, int R, int C>
230 FMatrix<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 
236 template<class T, int R, int C>
237 FMatrix<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 
243 template <class T, int R, int I, int C>
244 FMatrix<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 
260 template<class T, int R, int C>
261 FVector<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 
273 template<class T, int R, int C>
274 FVector<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 
286 template<class T, int R, int C>
287 FMatrix<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 
293 template<class T, int R, int C>
294 FMatrix<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 
300 template<class T, int R, int C>
301 FMatrix<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 
310 template<class T, int C>
311 FMatrix<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 
318 template<class T, int C>
319 FMatrix<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
FVector
A templated representation for vectors.
Definition: FTps.h:34
copy
and give any other recipients of the Program a copy of this License along with the Program You may charge a fee for the physical act of transferring a copy
Definition: LICENSE:87
operator-
Matrix< T > operator-(const Matrix< T > &, const Matrix< T > &)
Matrix subtraction.
Definition: Matrix.h:283
FMatrix::operator/=
FMatrix & operator/=(const T &)
Divide by scalar and assign.
Definition: FMatrix.h:183
FArray2D::operator=
const FArray2D< T, M, N > & operator=(const FArray2D< T, M, N > &)
Assignment.
Definition: FArray2D.h:228
FArray2D< T, R, C >::const_row_iterator
const T * const_row_iterator
Iterator for access by rows.
Definition: FArray2D.h:57
FArray2D< T, R, C >::col_begin
col_iterator col_begin(int c)
Get column iterator.
FMatrix::transpose
FMatrix< T, C, R > transpose() const
FMatrix transpose.
Definition: FMatrix.h:207
FMatrix::operator*=
FMatrix & operator*=(const T &)
Multiply by scalar and assign.
Definition: FMatrix.h:175
operator*
Matrix< T > operator*(const Matrix< T > &, const Matrix< T > &)
Matrix multiply.
Definition: Matrix.h:298
begin
clearpage the user may choose between constant or variable radius This model includes fringe fields begin
Definition: multipole_t.tex:6
FMatrix::operator+=
FMatrix & operator+=(const FMatrix &)
Add matrix and assign.
Definition: FMatrix.h:191
FArray2D< T, R, C >::row_end
row_iterator row_end(int r)
Get row iterator.
FMatrix::FMatrix
FMatrix()
Default constructor.
Definition: FMatrix.h:131
FMatrix
A templated representation for matrices.
Definition: FLieGenerator.h:28
FArray1D::end
iterator end()
Get iterator pointing past end of array.
Definition: FArray1D.h:198
FArray2D
A templated representation for 2-dimensional arrays.
Definition: FArray2D.h:40
operator+
Matrix< T > operator+(const Matrix< T > &, const Matrix< T > &)
Matrix addition.
Definition: Matrix.h:276
FArray2D< T, R, C >::begin
iterator begin()
Get beginning of data.
test.result
float result
Definition: test.py:2
FArray2D< T, R, C >::row_begin
row_iterator row_begin(int r)
Get row iterator.
FMatrix::operator=
FMatrix & operator=(const FMatrix &)
Assignment.
FMatrix::operator-=
FMatrix & operator-=(const FMatrix &)
Subtract ,atrix and assign.
Definition: FMatrix.h:199
FArray2D< T, R, C >::end
iterator end()
Get pointer past end of data.
operator/
Matrix< T > operator/(const Matrix< T > &, const T &)
Matrix divided by scalar.
Definition: Matrix.h:330
end
end
Definition: multipole_t.tex:9
FArray1D::begin
iterator begin()
Get iterator pointing to beginning of array.
Definition: FArray1D.h:192
Generated on Tue Jul 2 2024 15:05:21 for OPAL (Object Oriented Parallel Accelerator Library) by   doxygen 1.8.5