ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/branches/development/src/math/RectMatrix.hpp
Revision: 74
Committed: Wed Oct 13 23:53:40 2004 UTC (20 years, 6 months ago) by tim
Original Path: trunk/src/math/RectMatrix.hpp
File size: 15643 byte(s)
Log Message: 
Matrix in progress, test in isOrthogonal of SquareMatrix is failed by some reasons

File Contents

# User Rev Content
1 tim 71 /*
2     * Copyright (C) 2000-2004 Object Oriented Parallel Simulation Engine (OOPSE) project
3     *
4     * Contact: oopse@oopse.org
5     *
6     * This program is free software; you can redistribute it and/or
7     * modify it under the terms of the GNU Lesser General Public License
8     * as published by the Free Software Foundation; either version 2.1
9     * of the License, or (at your option) any later version.
10     * All we ask is that proper credit is given for our work, which includes
11     * - but is not limited to - adding the above copyright notice to the beginning
12     * of your source code files, and to any copyright notice that you may distribute
13     * with programs based on this work.
14     *
15     * This program is distributed in the hope that it will be useful,
16     * but WITHOUT ANY WARRANTY; without even the implied warranty of
17     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18     * GNU Lesser General Public License for more details.
19     *
20     * You should have received a copy of the GNU Lesser General Public License
21     * along with this program; if not, write to the Free Software
22     * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
23     *
24     */
25    
26    
27     /**
28     * @file RectMatrix.hpp
29     * @author Teng Lin
30     * @date 10/11/2004
31     * @version 1.0
32     */
33    
34     #ifndef MATH_RECTMATRIX_HPP
35     #define MATH_RECTMATRIX_HPP
36    
37 tim 74 #include <cmath>
38 tim 71 #include "Vector.hpp"
39    
40     namespace oopse {
41 tim 74 const double epsilon = 0.000001;
42 tim 71
43     template<typename T>
44     inline bool equal(T e1, T e2) {
45     return e1 == e2;
46     }
47    
48     template<>
49     inline bool equal(float e1, float e2) {
50 tim 74 return fabs(e1 - e2) < epsilon;
51 tim 71 }
52    
53     template<>
54     inline bool equal(double e1, double e2) {
55 tim 74 return fabs(e1 - e2) < epsilon;
56 tim 71 }
57    
58     /**
59     * @class RectMatrix RectMatrix.hpp "math/RectMatrix.hpp"
60     * @brief rectangular matrix class
61     */
62     template<typename Real, unsigned int Row, unsigned int Col>
63     class RectMatrix {
64     public:
65    
66     /** default constructor */
67     RectMatrix() {
68     for (unsigned int i = 0; i < Row; i++)
69     for (unsigned int j = 0; j < Col; j++)
70     data_[i][j] = 0.0;
71     }
72    
73     /** Constructs and initializes every element of this matrix to a scalar */
74     RectMatrix(Real s) {
75     for (unsigned int i = 0; i < Row; i++)
76     for (unsigned int j = 0; j < Col; j++)
77     data_[i][j] = s;
78     }
79    
80     /** copy constructor */
81     RectMatrix(const RectMatrix<Real, Row, Col>& m) {
82     *this = m;
83     }
84    
85     /** destructor*/
86     ~RectMatrix() {}
87    
88     /** copy assignment operator */
89     RectMatrix<Real, Row, Col>& operator =(const RectMatrix<Real, Row, Col>& m) {
90     if (this == &m)
91     return *this;
92    
93     for (unsigned int i = 0; i < Row; i++)
94     for (unsigned int j = 0; j < Col; j++)
95     data_[i][j] = m.data_[i][j];
96     return *this;
97     }
98    
99     /**
100     * Return the reference of a single element of this matrix.
101     * @return the reference of a single element of this matrix
102     * @param i row index
103     * @param j colum index
104     */
105     double& operator()(unsigned int i, unsigned int j) {
106     //assert( i < Row && j < Col);
107     return data_[i][j];
108     }
109    
110     /**
111     * Return the value of a single element of this matrix.
112     * @return the value of a single element of this matrix
113     * @param i row index
114     * @param j colum index
115     */
116     double operator()(unsigned int i, unsigned int j) const {
117    
118     return data_[i][j];
119     }
120    
121     /**
122     * Returns a row of this matrix as a vector.
123     * @return a row of this matrix as a vector
124     * @param row the row index
125     */
126     Vector<Real, Row> getRow(unsigned int row) {
127     Vector<Real, Row> v;
128    
129     for (unsigned int i = 0; i < Row; i++)
130     v[i] = data_[row][i];
131    
132     return v;
133     }
134    
135     /**
136     * Sets a row of this matrix
137     * @param row the row index
138     * @param v the vector to be set
139     */
140     void setRow(unsigned int row, const Vector<Real, Row>& v) {
141    
142     for (unsigned int i = 0; i < Row; i++)
143     data_[row][i] = v[i];
144     }
145    
146     /**
147     * Returns a column of this matrix as a vector.
148     * @return a column of this matrix as a vector
149     * @param col the column index
150     */
151     Vector<Real, Col> getColum(unsigned int col) {
152     Vector<Real, Col> v;
153    
154     for (unsigned int j = 0; j < Col; j++)
155     v[j] = data_[j][col];
156    
157     return v;
158     }
159    
160     /**
161     * Sets a column of this matrix
162     * @param col the column index
163     * @param v the vector to be set
164     */
165     void setColum(unsigned int col, const Vector<Real, Col>& v){
166    
167     for (unsigned int j = 0; j < Col; j++)
168     data_[j][col] = v[j];
169     }
170    
171     /**
172     * Tests if this matrix is identical to matrix m
173     * @return true if this matrix is equal to the matrix m, return false otherwise
174     * @m matrix to be compared
175     *
176     * @todo replace operator == by template function equal
177     */
178     bool operator ==(const RectMatrix<Real, Row, Col>& m) {
179     for (unsigned int i = 0; i < Row; i++)
180     for (unsigned int j = 0; j < Col; j++)
181     if (!equal(data_[i][j], m.data_[i][j]))
182     return false;
183    
184     return true;
185     }
186    
187     /**
188     * Tests if this matrix is not equal to matrix m
189     * @return true if this matrix is not equal to the matrix m, return false otherwise
190     * @m matrix to be compared
191     */
192     bool operator !=(const RectMatrix<Real, Row, Col>& m) {
193     return !(*this == m);
194     }
195    
196     /** Negates the value of this matrix in place. */
197     inline void negate() {
198     for (unsigned int i = 0; i < Row; i++)
199     for (unsigned int j = 0; j < Col; j++)
200     data_[i][j] = -data_[i][j];
201     }
202    
203     /**
204     * Sets the value of this matrix to the negation of matrix m.
205     * @param m the source matrix
206     */
207     inline void negate(const RectMatrix<Real, Row, Col>& m) {
208     for (unsigned int i = 0; i < Row; i++)
209     for (unsigned int j = 0; j < Col; j++)
210     data_[i][j] = -m.data_[i][j];
211     }
212    
213     /**
214     * Sets the value of this matrix to the sum of itself and m (*this += m).
215     * @param m the other matrix
216     */
217     inline void add( const RectMatrix<Real, Row, Col>& m ) {
218     for (unsigned int i = 0; i < Row; i++)
219     for (unsigned int j = 0; j < Col; j++)
220     data_[i][j] += m.data_[i][j];
221     }
222    
223     /**
224     * Sets the value of this matrix to the sum of m1 and m2 (*this = m1 + m2).
225     * @param m1 the first matrix
226     * @param m2 the second matrix
227     */
228     inline void add( const RectMatrix<Real, Row, Col>& m1, const RectMatrix<Real, Row, Col>& m2 ) {
229     for (unsigned int i = 0; i < Row; i++)
230     for (unsigned int j = 0; j < Col; j++)
231     data_[i][j] = m1.data_[i][j] + m2.data_[i][j];
232     }
233    
234     /**
235     * Sets the value of this matrix to the difference of itself and m (*this -= m).
236     * @param m the other matrix
237     */
238     inline void sub( const RectMatrix<Real, Row, Col>& m ) {
239     for (unsigned int i = 0; i < Row; i++)
240     for (unsigned int j = 0; j < Col; j++)
241     data_[i][j] -= m.data_[i][j];
242     }
243    
244     /**
245     * Sets the value of this matrix to the difference of matrix m1 and m2 (*this = m1 - m2).
246     * @param m1 the first matrix
247     * @param m2 the second matrix
248     */
249     inline void sub( const RectMatrix<Real, Row, Col>& m1, const RectMatrix<Real, Row, Col>& m2){
250     for (unsigned int i = 0; i < Row; i++)
251     for (unsigned int j = 0; j < Col; j++)
252     data_[i][j] = m1.data_[i][j] - m2.data_[i][j];
253     }
254    
255     /**
256     * Sets the value of this matrix to the scalar multiplication of itself (*this *= s).
257     * @param s the scalar value
258     */
259     inline void mul( double s ) {
260     for (unsigned int i = 0; i < Row; i++)
261     for (unsigned int j = 0; j < Col; j++)
262     data_[i][j] *= s;
263     }
264    
265     /**
266     * Sets the value of this matrix to the scalar multiplication of matrix m (*this = s * m).
267     * @param s the scalar value
268     * @param m the matrix
269     */
270     inline void mul( double s, const RectMatrix<Real, Row, Col>& m ) {
271     for (unsigned int i = 0; i < Row; i++)
272     for (unsigned int j = 0; j < Col; j++)
273     data_[i][j] = s * m.data_[i][j];
274     }
275    
276     /**
277     * Sets the value of this matrix to the scalar division of itself (*this /= s ).
278     * @param s the scalar value
279     */
280     inline void div( double s) {
281     for (unsigned int i = 0; i < Row; i++)
282     for (unsigned int j = 0; j < Col; j++)
283     data_[i][j] /= s;
284     }
285    
286     /**
287     * Sets the value of this matrix to the scalar division of matrix m (*this = m /s).
288     * @param s the scalar value
289     * @param m the matrix
290     */
291     inline void div( double s, const RectMatrix<Real, Row, Col>& m ) {
292     for (unsigned int i = 0; i < Row; i++)
293     for (unsigned int j = 0; j < Col; j++)
294     data_[i][j] = m.data_[i][j] / s;
295     }
296    
297     /**
298     * Multiples a scalar into every element of this matrix.
299     * @param s the scalar value
300     */
301     RectMatrix<Real, Row, Col>& operator *=(const double s) {
302     this->mul(s);
303     return *this;
304     }
305    
306     /**
307     * Divides every element of this matrix by a scalar.
308     * @param s the scalar value
309     */
310     RectMatrix<Real, Row, Col>& operator /=(const double s) {
311     this->div(s);
312     return *this;
313     }
314    
315     /**
316     * Sets the value of this matrix to the sum of the other matrix and itself (*this += m).
317     * @param m the other matrix
318     */
319     RectMatrix<Real, Row, Col>& operator += (const RectMatrix<Real, Row, Col>& m) {
320     add(m);
321     return *this;
322     }
323    
324     /**
325     * Sets the value of this matrix to the differerence of itself and the other matrix (*this -= m)
326     * @param m the other matrix
327     */
328     RectMatrix<Real, Row, Col>& operator -= (const RectMatrix<Real, Row, Col>& m){
329     sub(m);
330     return *this;
331     }
332    
333     /** Return the transpose of this matrix */
334     RectMatrix<Real, Col, Row> transpose(){
335     RectMatrix<Real, Col, Row> result;
336    
337     for (unsigned int i = 0; i < Row; i++)
338     for (unsigned int j = 0; j < Col; j++)
339     result(j, i) = data_[i][j];
340    
341     return result;
342     }
343    
344     protected:
345     Real data_[Row][Col];
346     };
347    
348     /** Negate the value of every element of this matrix. */
349     template<typename Real, unsigned int Row, unsigned int Col>
350     inline RectMatrix<Real, Row, Col> operator -(const RectMatrix<Real, Row, Col>& m) {
351     RectMatrix<Real, Row, Col> result(m);
352    
353     result.negate();
354    
355     return result;
356     }
357    
358     /**
359     * Return the sum of two matrixes (m1 + m2).
360     * @return the sum of two matrixes
361     * @param m1 the first matrix
362     * @param m2 the second matrix
363     */
364     template<typename Real, unsigned int Row, unsigned int Col>
365     inline RectMatrix<Real, Row, Col> operator + (const RectMatrix<Real, Row, Col>& m1,const RectMatrix<Real, Row, Col>& m2) {
366     RectMatrix<Real, Row, Col> result;
367    
368     result.add(m1, m2);
369    
370     return result;
371     }
372    
373     /**
374     * Return the difference of two matrixes (m1 - m2).
375     * @return the sum of two matrixes
376     * @param m1 the first matrix
377     * @param m2 the second matrix
378     */
379     template<typename Real, unsigned int Row, unsigned int Col>
380     inline RectMatrix<Real, Row, Col> operator - (const RectMatrix<Real, Row, Col>& m1, const RectMatrix<Real, Row, Col>& m2) {
381     RectMatrix<Real, Row, Col> result;
382    
383     result.sub(m1, m2);
384    
385     return result;
386     }
387    
388     /**
389     * Return the multiplication of scalra and matrix (m * s).
390     * @return the multiplication of a scalra and a matrix
391     * @param m the matrix
392     * @param s the scalar
393     */
394     template<typename Real, unsigned int Row, unsigned int Col>
395     inline RectMatrix<Real, Row, Col> operator *(const RectMatrix<Real, Row, Col>& m, Real s) {
396     RectMatrix<Real, Row, Col> result;
397    
398     result.mul(s, m);
399    
400     return result;
401     }
402    
403     /**
404     * Return the multiplication of a scalra and a matrix (s * m).
405     * @return the multiplication of a scalra and a matrix
406     * @param s the scalar
407     * @param m the matrix
408     */
409     template<typename Real, unsigned int Row, unsigned int Col>
410     inline RectMatrix<Real, Row, Col> operator *(Real s, const RectMatrix<Real, Row, Col>& m) {
411     RectMatrix<Real, Row, Col> result;
412    
413     result.mul(s, m);
414    
415     return result;
416     }
417    
418     /**
419     * Return the multiplication of two matrixes (m1 * m2).
420     * @return the multiplication of two matrixes
421     * @param m1 the first matrix
422     * @param m2 the second matrix
423     */
424     template<typename Real, unsigned int Row, unsigned int Col, unsigned int SameDim>
425     inline RectMatrix<Real, Row, Col> operator *(const RectMatrix<Real, Row, SameDim>& m1, const RectMatrix<Real, SameDim, Col>& m2) {
426     RectMatrix<Real, Row, Col> result;
427    
428     for (unsigned int i = 0; i < Row; i++)
429     for (unsigned int j = 0; j < Col; j++)
430     for (unsigned int k = 0; k < SameDim; k++)
431     result(i, j) = m1(i, k) * m2(k, j);
432    
433     return result;
434     }
435    
436     /**
437     * Return the multiplication of a matrix and a vector (m * v).
438     * @return the multiplication of a matrix and a vector
439     * @param m the matrix
440     * @param v the vector
441     */
442     template<typename Real, unsigned int Row, unsigned int Col>
443     inline Vector<Real, Row> operator *(const RectMatrix<Real, Row, Col>& m, const Vector<Real, Col>& v) {
444     Vector<Real, Row> result;
445    
446     for (unsigned int i = 0; i < Row ; i++)
447     for (unsigned int j = 0; j < Col ; j++)
448     result[i] += m(i, j) * v[j];
449    
450     return result;
451     }
452    
453     /**
454     * Return the scalar division of matrix (m / s).
455     * @return the scalar division of matrix
456     * @param m the matrix
457     * @param s the scalar
458     */
459     template<typename Real, unsigned int Row, unsigned int Col>
460     inline RectMatrix<Real, Row, Col> operator /(const RectMatrix<Real, Row, Col>& m, Real s) {
461     RectMatrix<Real, Row, Col> result;
462    
463     result.div(s, m);
464    
465     return result;
466     }
467     }
468     #endif //MATH_RECTMATRIX_HPP

Properties

Name Value
svn:executable *