ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/src/math/RectMatrix.hpp
Revision: 253
Committed: Thu Jan 13 19:40:37 2005 UTC (20 years, 9 months ago) by tim
File size: 19452 byte(s)
Log Message: 
port to SGI platform

File Contents

# User Rev Content
1 gezelter 246 /*
2     * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3 tim 71 *
4 gezelter 246 * The University of Notre Dame grants you ("Licensee") a
5     * non-exclusive, royalty free, license to use, modify and
6     * redistribute this software in source and binary code form, provided
7     * that the following conditions are met:
8     *
9     * 1. Acknowledgement of the program authors must be made in any
10     * publication of scientific results based in part on use of the
11     * program. An acceptable form of acknowledgement is citation of
12     * the article in which the program was described (Matthew
13     * A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher
14     * J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented
15     * Parallel Simulation Engine for Molecular Dynamics,"
16     * J. Comput. Chem. 26, pp. 252-271 (2005))
17     *
18     * 2. Redistributions of source code must retain the above copyright
19     * notice, this list of conditions and the following disclaimer.
20     *
21     * 3. Redistributions in binary form must reproduce the above copyright
22     * notice, this list of conditions and the following disclaimer in the
23     * documentation and/or other materials provided with the
24     * distribution.
25     *
26     * This software is provided "AS IS," without a warranty of any
27     * kind. All express or implied conditions, representations and
28     * warranties, including any implied warranty of merchantability,
29     * fitness for a particular purpose or non-infringement, are hereby
30     * excluded. The University of Notre Dame and its licensors shall not
31     * be liable for any damages suffered by licensee as a result of
32     * using, modifying or distributing the software or its
33     * derivatives. In no event will the University of Notre Dame or its
34     * licensors be liable for any lost revenue, profit or data, or for
35     * direct, indirect, special, consequential, incidental or punitive
36     * damages, however caused and regardless of the theory of liability,
37     * arising out of the use of or inability to use software, even if the
38     * University of Notre Dame has been advised of the possibility of
39     * such damages.
40 tim 71 */
41 gezelter 246
42 tim 71 /**
43     * @file RectMatrix.hpp
44     * @author Teng Lin
45     * @date 10/11/2004
46     * @version 1.0
47     */
48    
49     #ifndef MATH_RECTMATRIX_HPP
50     #define MATH_RECTMATRIX_HPP
51 tim 253 #include <math.h>
52 tim 74 #include <cmath>
53 tim 71 #include "Vector.hpp"
54    
55     namespace oopse {
56    
57     /**
58     * @class RectMatrix RectMatrix.hpp "math/RectMatrix.hpp"
59     * @brief rectangular matrix class
60     */
61     template<typename Real, unsigned int Row, unsigned int Col>
62     class RectMatrix {
63     public:
64 tim 137 typedef Real ElemType;
65     typedef Real* ElemPoinerType;
66    
67     /** default constructor */
68     RectMatrix() {
69     for (unsigned int i = 0; i < Row; i++)
70     for (unsigned int j = 0; j < Col; j++)
71     data_[i][j] = 0.0;
72     }
73 tim 71
74 tim 137 /** Constructs and initializes every element of this matrix to a scalar */
75     RectMatrix(Real s) {
76     for (unsigned int i = 0; i < Row; i++)
77     for (unsigned int j = 0; j < Col; j++)
78     data_[i][j] = s;
79     }
80 tim 71
81 tim 151 RectMatrix(Real* array) {
82     for (unsigned int i = 0; i < Row; i++)
83     for (unsigned int j = 0; j < Col; j++)
84     data_[i][j] = array[i * Row + j];
85     }
86    
87 tim 137 /** copy constructor */
88     RectMatrix(const RectMatrix<Real, Row, Col>& m) {
89     *this = m;
90     }
91    
92     /** destructor*/
93     ~RectMatrix() {}
94 tim 71
95 tim 137 /** copy assignment operator */
96     RectMatrix<Real, Row, Col>& operator =(const RectMatrix<Real, Row, Col>& m) {
97     if (this == &m)
98     return *this;
99    
100     for (unsigned int i = 0; i < Row; i++)
101     for (unsigned int j = 0; j < Col; j++)
102     data_[i][j] = m.data_[i][j];
103 tim 71 return *this;
104 tim 137 }
105 tim 71
106 tim 137 /**
107     * Return the reference of a single element of this matrix.
108     * @return the reference of a single element of this matrix
109     * @param i row index
110 gezelter 246 * @param j Column index
111 tim 137 */
112     Real& operator()(unsigned int i, unsigned int j) {
113     //assert( i < Row && j < Col);
114     return data_[i][j];
115     }
116 tim 71
117 tim 137 /**
118     * Return the value of a single element of this matrix.
119     * @return the value of a single element of this matrix
120     * @param i row index
121 gezelter 246 * @param j Column index
122 tim 137 */
123     Real operator()(unsigned int i, unsigned int j) const {
124    
125     return data_[i][j];
126     }
127 tim 71
128 tim 151 /**
129     * Copy the internal data to an array
130     * @param array the pointer of destination array
131     */
132     void getArray(Real* array) {
133     for (unsigned int i = 0; i < Row; i++) {
134     for (unsigned int j = 0; j < Col; j++) {
135     array[i * Row + j] = data_[i][j];
136     }
137     }
138     }
139    
140    
141 tim 137 /** Returns the pointer of internal array */
142     Real* getArrayPointer() {
143     return &data_[0][0];
144     }
145 tim 71
146 tim 137 /**
147     * Returns a row of this matrix as a vector.
148     * @return a row of this matrix as a vector
149     * @param row the row index
150     */
151     Vector<Real, Row> getRow(unsigned int row) {
152     Vector<Real, Row> v;
153 tim 71
154 tim 137 for (unsigned int i = 0; i < Row; i++)
155     v[i] = data_[row][i];
156 tim 71
157 tim 137 return v;
158     }
159 tim 71
160 tim 137 /**
161     * Sets a row of this matrix
162     * @param row the row index
163     * @param v the vector to be set
164     */
165     void setRow(unsigned int row, const Vector<Real, Row>& v) {
166 tim 71
167 tim 137 for (unsigned int i = 0; i < Row; i++)
168     data_[row][i] = v[i];
169     }
170 tim 71
171 tim 137 /**
172     * Returns a column of this matrix as a vector.
173     * @return a column of this matrix as a vector
174     * @param col the column index
175     */
176 gezelter 246 Vector<Real, Col> getColumn(unsigned int col) {
177 tim 137 Vector<Real, Col> v;
178 tim 71
179 tim 137 for (unsigned int j = 0; j < Col; j++)
180     v[j] = data_[j][col];
181 tim 71
182 tim 137 return v;
183     }
184 tim 71
185 tim 137 /**
186     * Sets a column of this matrix
187     * @param col the column index
188     * @param v the vector to be set
189     */
190 gezelter 246 void setColumn(unsigned int col, const Vector<Real, Col>& v){
191 tim 71
192 tim 137 for (unsigned int j = 0; j < Col; j++)
193     data_[j][col] = v[j];
194     }
195 tim 101
196 tim 137 /**
197     * swap two rows of this matrix
198     * @param i the first row
199     * @param j the second row
200     */
201     void swapRow(unsigned int i, unsigned int j){
202     assert(i < Row && j < Row);
203 tim 101
204 tim 137 for (unsigned int k = 0; k < Col; k++)
205     std::swap(data_[i][k], data_[j][k]);
206     }
207 tim 101
208 tim 137 /**
209 gezelter 246 * swap two Columns of this matrix
210     * @param i the first Column
211     * @param j the second Column
212 tim 137 */
213 gezelter 246 void swapColumn(unsigned int i, unsigned int j){
214 tim 137 assert(i < Col && j < Col);
215    
216     for (unsigned int k = 0; k < Row; k++)
217     std::swap(data_[k][i], data_[k][j]);
218     }
219 tim 71
220 tim 137 /**
221     * Tests if this matrix is identical to matrix m
222     * @return true if this matrix is equal to the matrix m, return false otherwise
223     * @m matrix to be compared
224     *
225     * @todo replace operator == by template function equal
226     */
227     bool operator ==(const RectMatrix<Real, Row, Col>& m) {
228     for (unsigned int i = 0; i < Row; i++)
229     for (unsigned int j = 0; j < Col; j++)
230     if (!equal(data_[i][j], m.data_[i][j]))
231     return false;
232 tim 71
233 tim 137 return true;
234     }
235 tim 71
236 tim 137 /**
237     * Tests if this matrix is not equal to matrix m
238     * @return true if this matrix is not equal to the matrix m, return false otherwise
239     * @m matrix to be compared
240     */
241     bool operator !=(const RectMatrix<Real, Row, Col>& m) {
242     return !(*this == m);
243     }
244 tim 71
245 tim 137 /** Negates the value of this matrix in place. */
246     inline void negate() {
247     for (unsigned int i = 0; i < Row; i++)
248     for (unsigned int j = 0; j < Col; j++)
249     data_[i][j] = -data_[i][j];
250     }
251    
252     /**
253     * Sets the value of this matrix to the negation of matrix m.
254     * @param m the source matrix
255     */
256     inline void negate(const RectMatrix<Real, Row, Col>& m) {
257     for (unsigned int i = 0; i < Row; i++)
258     for (unsigned int j = 0; j < Col; j++)
259     data_[i][j] = -m.data_[i][j];
260     }
261    
262     /**
263     * Sets the value of this matrix to the sum of itself and m (*this += m).
264     * @param m the other matrix
265     */
266     inline void add( const RectMatrix<Real, Row, Col>& m ) {
267     for (unsigned int i = 0; i < Row; i++)
268     for (unsigned int j = 0; j < Col; j++)
269     data_[i][j] += m.data_[i][j];
270     }
271    
272     /**
273     * Sets the value of this matrix to the sum of m1 and m2 (*this = m1 + m2).
274     * @param m1 the first matrix
275     * @param m2 the second matrix
276     */
277     inline void add( const RectMatrix<Real, Row, Col>& m1, const RectMatrix<Real, Row, Col>& m2 ) {
278     for (unsigned int i = 0; i < Row; i++)
279     for (unsigned int j = 0; j < Col; j++)
280     data_[i][j] = m1.data_[i][j] + m2.data_[i][j];
281     }
282    
283     /**
284     * Sets the value of this matrix to the difference of itself and m (*this -= m).
285     * @param m the other matrix
286     */
287     inline void sub( const RectMatrix<Real, Row, Col>& m ) {
288     for (unsigned int i = 0; i < Row; i++)
289     for (unsigned int j = 0; j < Col; j++)
290     data_[i][j] -= m.data_[i][j];
291     }
292    
293     /**
294     * Sets the value of this matrix to the difference of matrix m1 and m2 (*this = m1 - m2).
295     * @param m1 the first matrix
296     * @param m2 the second matrix
297     */
298     inline void sub( const RectMatrix<Real, Row, Col>& m1, const RectMatrix<Real, Row, Col>& m2){
299     for (unsigned int i = 0; i < Row; i++)
300     for (unsigned int j = 0; j < Col; j++)
301     data_[i][j] = m1.data_[i][j] - m2.data_[i][j];
302     }
303 tim 71
304 tim 137 /**
305     * Sets the value of this matrix to the scalar multiplication of itself (*this *= s).
306     * @param s the scalar value
307     */
308     inline void mul( Real s ) {
309     for (unsigned int i = 0; i < Row; i++)
310     for (unsigned int j = 0; j < Col; j++)
311     data_[i][j] *= s;
312     }
313 tim 71
314 tim 137 /**
315     * Sets the value of this matrix to the scalar multiplication of matrix m (*this = s * m).
316     * @param s the scalar value
317     * @param m the matrix
318     */
319     inline void mul( Real s, const RectMatrix<Real, Row, Col>& m ) {
320     for (unsigned int i = 0; i < Row; i++)
321     for (unsigned int j = 0; j < Col; j++)
322     data_[i][j] = s * m.data_[i][j];
323     }
324 tim 71
325 tim 137 /**
326     * Sets the value of this matrix to the scalar division of itself (*this /= s ).
327     * @param s the scalar value
328     */
329     inline void div( Real s) {
330     for (unsigned int i = 0; i < Row; i++)
331     for (unsigned int j = 0; j < Col; j++)
332     data_[i][j] /= s;
333     }
334 tim 71
335 tim 137 /**
336     * Sets the value of this matrix to the scalar division of matrix m (*this = m /s).
337     * @param s the scalar value
338     * @param m the matrix
339     */
340     inline void div( Real s, const RectMatrix<Real, Row, Col>& m ) {
341     for (unsigned int i = 0; i < Row; i++)
342     for (unsigned int j = 0; j < Col; j++)
343     data_[i][j] = m.data_[i][j] / s;
344     }
345 tim 71
346 tim 137 /**
347     * Multiples a scalar into every element of this matrix.
348     * @param s the scalar value
349     */
350     RectMatrix<Real, Row, Col>& operator *=(const Real s) {
351     this->mul(s);
352     return *this;
353     }
354 tim 71
355 tim 137 /**
356     * Divides every element of this matrix by a scalar.
357     * @param s the scalar value
358     */
359     RectMatrix<Real, Row, Col>& operator /=(const Real s) {
360     this->div(s);
361     return *this;
362     }
363 tim 71
364 tim 137 /**
365     * Sets the value of this matrix to the sum of the other matrix and itself (*this += m).
366     * @param m the other matrix
367     */
368     RectMatrix<Real, Row, Col>& operator += (const RectMatrix<Real, Row, Col>& m) {
369     add(m);
370     return *this;
371     }
372 tim 71
373 tim 137 /**
374     * Sets the value of this matrix to the differerence of itself and the other matrix (*this -= m)
375     * @param m the other matrix
376     */
377     RectMatrix<Real, Row, Col>& operator -= (const RectMatrix<Real, Row, Col>& m){
378     sub(m);
379     return *this;
380     }
381 tim 71
382 tim 137 /** Return the transpose of this matrix */
383 gezelter 246 RectMatrix<Real, Col, Row> transpose() const{
384 tim 137 RectMatrix<Real, Col, Row> result;
385    
386     for (unsigned int i = 0; i < Row; i++)
387     for (unsigned int j = 0; j < Col; j++)
388     result(j, i) = data_[i][j];
389    
390     return result;
391     }
392 tim 71
393     protected:
394     Real data_[Row][Col];
395     };
396    
397     /** Negate the value of every element of this matrix. */
398     template<typename Real, unsigned int Row, unsigned int Col>
399     inline RectMatrix<Real, Row, Col> operator -(const RectMatrix<Real, Row, Col>& m) {
400     RectMatrix<Real, Row, Col> result(m);
401    
402     result.negate();
403    
404     return result;
405     }
406    
407     /**
408     * Return the sum of two matrixes (m1 + m2).
409     * @return the sum of two matrixes
410     * @param m1 the first matrix
411     * @param m2 the second matrix
412     */
413     template<typename Real, unsigned int Row, unsigned int Col>
414     inline RectMatrix<Real, Row, Col> operator + (const RectMatrix<Real, Row, Col>& m1,const RectMatrix<Real, Row, Col>& m2) {
415     RectMatrix<Real, Row, Col> result;
416    
417     result.add(m1, m2);
418    
419     return result;
420     }
421    
422     /**
423     * Return the difference of two matrixes (m1 - m2).
424     * @return the sum of two matrixes
425     * @param m1 the first matrix
426     * @param m2 the second matrix
427     */
428     template<typename Real, unsigned int Row, unsigned int Col>
429     inline RectMatrix<Real, Row, Col> operator - (const RectMatrix<Real, Row, Col>& m1, const RectMatrix<Real, Row, Col>& m2) {
430     RectMatrix<Real, Row, Col> result;
431    
432     result.sub(m1, m2);
433    
434     return result;
435     }
436    
437     /**
438     * Return the multiplication of scalra and matrix (m * s).
439     * @return the multiplication of a scalra and a matrix
440     * @param m the matrix
441     * @param s the scalar
442     */
443     template<typename Real, unsigned int Row, unsigned int Col>
444     inline RectMatrix<Real, Row, Col> operator *(const RectMatrix<Real, Row, Col>& m, Real s) {
445     RectMatrix<Real, Row, Col> result;
446    
447     result.mul(s, m);
448    
449     return result;
450     }
451    
452     /**
453     * Return the multiplication of a scalra and a matrix (s * m).
454     * @return the multiplication of a scalra and a matrix
455     * @param s the scalar
456     * @param m the matrix
457     */
458     template<typename Real, unsigned int Row, unsigned int Col>
459     inline RectMatrix<Real, Row, Col> operator *(Real s, const RectMatrix<Real, Row, Col>& m) {
460     RectMatrix<Real, Row, Col> result;
461    
462     result.mul(s, m);
463    
464     return result;
465     }
466    
467     /**
468     * Return the multiplication of two matrixes (m1 * m2).
469     * @return the multiplication of two matrixes
470     * @param m1 the first matrix
471     * @param m2 the second matrix
472     */
473     template<typename Real, unsigned int Row, unsigned int Col, unsigned int SameDim>
474     inline RectMatrix<Real, Row, Col> operator *(const RectMatrix<Real, Row, SameDim>& m1, const RectMatrix<Real, SameDim, Col>& m2) {
475     RectMatrix<Real, Row, Col> result;
476    
477     for (unsigned int i = 0; i < Row; i++)
478     for (unsigned int j = 0; j < Col; j++)
479     for (unsigned int k = 0; k < SameDim; k++)
480 tim 76 result(i, j) += m1(i, k) * m2(k, j);
481 tim 71
482     return result;
483     }
484    
485     /**
486     * Return the multiplication of a matrix and a vector (m * v).
487     * @return the multiplication of a matrix and a vector
488     * @param m the matrix
489     * @param v the vector
490     */
491     template<typename Real, unsigned int Row, unsigned int Col>
492     inline Vector<Real, Row> operator *(const RectMatrix<Real, Row, Col>& m, const Vector<Real, Col>& v) {
493     Vector<Real, Row> result;
494    
495     for (unsigned int i = 0; i < Row ; i++)
496     for (unsigned int j = 0; j < Col ; j++)
497     result[i] += m(i, j) * v[j];
498    
499     return result;
500     }
501    
502     /**
503     * Return the scalar division of matrix (m / s).
504     * @return the scalar division of matrix
505     * @param m the matrix
506     * @param s the scalar
507     */
508     template<typename Real, unsigned int Row, unsigned int Col>
509     inline RectMatrix<Real, Row, Col> operator /(const RectMatrix<Real, Row, Col>& m, Real s) {
510     RectMatrix<Real, Row, Col> result;
511    
512     result.div(s, m);
513    
514     return result;
515     }
516 tim 93
517     /**
518     * Write to an output stream
519     */
520     template<typename Real, unsigned int Row, unsigned int Col>
521     std::ostream &operator<< ( std::ostream& o, const RectMatrix<Real, Row, Col>& m) {
522     for (unsigned int i = 0; i < Row ; i++) {
523 tim 110 o << "(";
524 tim 93 for (unsigned int j = 0; j < Col ; j++) {
525 tim 113 o << m(i, j);
526     if (j != Col -1)
527     o << "\t";
528 tim 93 }
529     o << ")" << std::endl;
530     }
531     return o;
532     }
533 tim 71 }
534     #endif //MATH_RECTMATRIX_HPP

Properties

Name Value
svn:executable *