ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/branches/development/src/math/RectMatrix.hpp
(Generate patch)

Comparing trunk/src/math/RectMatrix.hpp (file contents):
Revision 385 by tim, Tue Mar 1 20:10:14 2005 UTC vs.
Revision 1390 by gezelter, Wed Nov 25 20:02:06 2009 UTC

# Line 1 | Line 1
1 < /*
1 > /*
2   * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3   *
4   * The University of Notre Dame grants you ("Licensee") a
# Line 6 | Line 6
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
9 > * 1. Redistributions of source code must retain the above copyright
10   *    notice, this list of conditions and the following disclaimer.
11   *
12 < * 3. Redistributions in binary form must reproduce the above copyright
12 > * 2. Redistributions in binary form must reproduce the above copyright
13   *    notice, this list of conditions and the following disclaimer in the
14   *    documentation and/or other materials provided with the
15   *    distribution.
# Line 37 | Line 28
28   * arising out of the use of or inability to use software, even if the
29   * University of Notre Dame has been advised of the possibility of
30   * such damages.
31 + *
32 + * SUPPORT OPEN SCIENCE!  If you use OpenMD or its source code in your
33 + * research, please cite the appropriate papers when you publish your
34 + * work.  Good starting points are:
35 + *                                                                      
36 + * [1]  Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).            
37 + * [2]  Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).          
38 + * [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 24107 (2008).          
39 + * [4]  Vardeman & Gezelter, in progress (2009).                        
40   */
41  
42   /**
# Line 52 | Line 52
52   #include <cmath>
53   #include "Vector.hpp"
54  
55 < namespace oopse {
55 > namespace OpenMD {
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 <            typedef Real ElemType;
65 <            typedef Real* ElemPoinerType;
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 >    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 <                        this->data_[i][j] = 0.0;
72 <             }
67 >    /** default constructor */
68 >    RectMatrix() {
69 >      for (unsigned int i = 0; i < Row; i++)
70 >        for (unsigned int j = 0; j < Col; j++)
71 >          this->data_[i][j] = 0.0;
72 >    }
73  
74 <            /** 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 <                        this->data_[i][j] = s;
79 <            }
74 >    /** 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 >          this->data_[i][j] = s;
79 >    }
80  
81 <            RectMatrix(Real* array) {
82 <                for (unsigned int i = 0; i < Row; i++)
83 <                    for (unsigned int j = 0; j < Col; j++)
84 <                        this->data_[i][j] = array[i * Row + j];
85 <            }
81 >    RectMatrix(Real* array) {
82 >      for (unsigned int i = 0; i < Row; i++)
83 >        for (unsigned int j = 0; j < Col; j++)
84 >          this->data_[i][j] = array[i * Row + j];
85 >    }
86  
87 <            /** copy constructor */
88 <            RectMatrix(const RectMatrix<Real, Row, Col>& m) {
89 <                *this = m;
90 <            }
87 >    /** copy constructor */
88 >    RectMatrix(const RectMatrix<Real, Row, Col>& m) {
89 >      *this = m;
90 >    }
91              
92 <            /** destructor*/
93 <            ~RectMatrix() {}
92 >    /** destructor*/
93 >    ~RectMatrix() {}
94  
95 <            /** copy assignment operator */
96 <            RectMatrix<Real, Row, Col>& operator =(const RectMatrix<Real, Row, Col>& m) {
97 <                if (this == &m)
98 <                    return *this;
95 >    /** 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 <                        this->data_[i][j] = m.data_[i][j];
103 <                return *this;
104 <            }
100 >      for (unsigned int i = 0; i < Row; i++)
101 >        for (unsigned int j = 0; j < Col; j++)
102 >          this->data_[i][j] = m.data_[i][j];
103 >      return *this;
104 >    }
105              
106 <            /**
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 <             * @param j Column index
111 <             */
112 <            Real& operator()(unsigned int i, unsigned int j) {
113 <                //assert( i < Row && j < Col);
114 <                return this->data_[i][j];
115 <            }
106 >    /**
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 >     * @param j Column index
111 >     */
112 >    Real& operator()(unsigned int i, unsigned int j) {
113 >      //assert( i < Row && j < Col);
114 >      return this->data_[i][j];
115 >    }
116  
117 <            /**
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 <             * @param j Column index
122 <             */        
123 <            Real operator()(unsigned int i, unsigned int j) const  {
117 >    /**
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 >     * @param j Column index
122 >     */        
123 >    Real operator()(unsigned int i, unsigned int j) const  {
124                  
125 <                return this->data_[i][j];  
126 <            }
125 >      return this->data_[i][j];  
126 >    }
127  
128 <            /**
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] = this->data_[i][j];
136 <                    }
137 <                }
138 <            }
128 >    /**
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] = this->data_[i][j];
136 >        }
137 >      }
138 >    }
139  
140  
141 <            /** Returns the pointer of internal array */
142 <            Real* getArrayPointer() {
143 <                return &this->data_[0][0];
144 <            }
141 >    /** Returns the pointer of internal array */
142 >    Real* getArrayPointer() {
143 >      return &this->data_[0][0];
144 >    }
145  
146 <            /**
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;
146 >    /**
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  
154 <                for (unsigned int i = 0; i < Row; i++)
155 <                    v[i] = this->data_[row][i];
154 >      for (unsigned int i = 0; i < Col; i++)
155 >        v[i] = this->data_[row][i];
156  
157 <                return v;
158 <            }
157 >      return v;
158 >    }
159  
160 <            /**
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) {
160 >    /**
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  
167 <                for (unsigned int i = 0; i < Row; i++)
168 <                    this->data_[row][i] = v[i];
169 <             }
167 >      for (unsigned int i = 0; i < Col; i++)
168 >        this->data_[row][i] = v[i];
169 >    }
170  
171 <            /**
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 <            Vector<Real, Col> getColumn(unsigned int col) {
177 <                Vector<Real, Col> v;
171 >    /**
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 >    Vector<Real, Col> getColumn(unsigned int col) {
177 >      Vector<Real, Col> v;
178  
179 <                for (unsigned int j = 0; j < Col; j++)
180 <                    v[j] = this->data_[j][col];
179 >      for (unsigned int j = 0; j < Row; j++)
180 >        v[j] = this->data_[j][col];
181  
182 <                return v;
183 <            }
182 >      return v;
183 >    }
184  
185 <            /**
186 <             * Sets a column of  this matrix
187 <             * @param col the column index
188 <             * @param v the vector to be set
189 <             */                
190 <             void setColumn(unsigned int col, const Vector<Real, Col>& v){
185 >    /**
186 >     * Sets a column of  this matrix
187 >     * @param col the column index
188 >     * @param v the vector to be set
189 >     */                
190 >    void setColumn(unsigned int col, const Vector<Real, Col>& v){
191  
192 <                for (unsigned int j = 0; j < Col; j++)
193 <                    this->data_[j][col] = v[j];
194 <             }        
192 >      for (unsigned int j = 0; j < Row; j++)
193 >        this->data_[j][col] = v[j];
194 >    }        
195  
196 <            /**
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);
196 >    /**
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  
204 <                    for (unsigned int k = 0; k < Col; k++)
205 <                        std::swap(this->data_[i][k], this->data_[j][k]);
206 <            }
204 >      for (unsigned int k = 0; k < Col; k++)
205 >        std::swap(this->data_[i][k], this->data_[j][k]);
206 >    }
207  
208 <           /**
209 <             * swap two Columns of this matrix
210 <             * @param i the first Column
211 <             * @param j the second Column
212 <             */
213 <            void swapColumn(unsigned int i, unsigned int j){
214 <                    assert(i < Col && j < Col);
208 >    /**
209 >     * swap two Columns of this matrix
210 >     * @param i the first Column
211 >     * @param j the second Column
212 >     */
213 >    void swapColumn(unsigned int i, unsigned int j){
214 >      assert(i < Col && j < Col);
215                      
216 <                    for (unsigned int k = 0; k < Row; k++)
217 <                        std::swap(this->data_[k][i], this->data_[k][j]);
218 <            }
216 >      for (unsigned int k = 0; k < Row; k++)
217 >        std::swap(this->data_[k][i], this->data_[k][j]);
218 >    }
219  
220 <            /**
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(this->data_[i][j], m.data_[i][j]))
231 <                            return false;
220 >    /**
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(this->data_[i][j], m.data_[i][j]))
231 >            return false;
232  
233 <                return true;
234 <            }
233 >      return true;
234 >    }
235  
236 <            /**
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 <            }
236 >    /**
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  
245 <            /** 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 <                        this->data_[i][j] = -this->data_[i][j];
250 <            }
245 >    /** 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 >          this->data_[i][j] = -this->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 <                        this->data_[i][j] = -m.data_[i][j];        
260 <            }
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 >          this->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 <                    this->data_[i][j] += m.data_[i][j];
270 <            }
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 >          this->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 <                    this->data_[i][j] = m1.data_[i][j] + m2.data_[i][j];
281 <            }
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 >          this->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 <                        this->data_[i][j] -= m.data_[i][j];
291 <            }
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 >          this->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 <                        this->data_[i][j] = m1.data_[i][j] - m2.data_[i][j];
302 <            }
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 >          this->data_[i][j] = m1.data_[i][j] - m2.data_[i][j];
302 >    }
303  
304 <            /**
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 <                        this->data_[i][j] *= s;
312 <            }
304 >    /**
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 >          this->data_[i][j] *= s;
312 >    }
313  
314 <            /**
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 <                        this->data_[i][j] = s * m.data_[i][j];
323 <            }
314 >    /**
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 >          this->data_[i][j] = s * m.data_[i][j];
323 >    }
324  
325 <            /**
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 <                        this->data_[i][j] /= s;
333 <            }
325 >    /**
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 >          this->data_[i][j] /= s;
333 >    }
334  
335 <            /**
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 <                        this->data_[i][j] = m.data_[i][j] / s;
344 <            }
335 >    /**
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 >          this->data_[i][j] = m.data_[i][j] / s;
344 >    }
345  
346 <            /**
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 <            }
346 >    /**
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  
355 <            /**
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 <            }
355 >    /**
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  
364 <            /**
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 <             }
364 >    /**
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  
373 <            /**
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 <            }
373 >    /**
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  
382 <            /** Return the transpose of this matrix */
383 <            RectMatrix<Real,  Col, Row> transpose() const{
384 <                RectMatrix<Real,  Col, Row> result;
382 >    /** Return the transpose of this matrix */
383 >    RectMatrix<Real,  Col, Row> transpose() const{
384 >      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) = this->data_[i][j];
386 >      for (unsigned int i = 0; i < Row; i++)
387 >        for (unsigned int j = 0; j < Col; j++)              
388 >          result(j, i) = this->data_[i][j];
389  
390 <                return result;
391 <            }
392 <        
393 <        protected:
394 <            Real data_[Row][Col];
395 <    };
390 >      return result;
391 >    }
392  
393 <    /** Negate the value of every element of this matrix. */
394 <    template<typename Real, unsigned int Row, unsigned int Col>
395 <    inline RectMatrix<Real, Row, Col> operator -(const RectMatrix<Real, Row, Col>& m) {
396 <        RectMatrix<Real, Row, Col> result(m);
393 >    template<class MatrixType>
394 >    void setSubMatrix(unsigned int beginRow, unsigned int beginCol, const MatrixType& m) {
395 >        assert(beginRow + m.getNRow() -1 <= getNRow());
396 >        assert(beginCol + m.getNCol() -1 <= getNCol());
397  
398 <        result.negate();
398 >        for (unsigned int i = 0; i < m.getNRow(); ++i)
399 >            for (unsigned int j = 0; j < m.getNCol(); ++j)
400 >                this->data_[beginRow+i][beginCol+j] = m(i, j);
401 >    }
402  
403 <        return result;
403 >    template<class MatrixType>
404 >    void getSubMatrix(unsigned int beginRow, unsigned int beginCol, MatrixType& m) {
405 >        assert(beginRow + m.getNRow() -1 <= getNRow());
406 >        assert(beginCol + m.getNCol() - 1 <= getNCol());
407 >
408 >        for (unsigned int i = 0; i < m.getNRow(); ++i)
409 >            for (unsigned int j = 0; j < m.getNCol(); ++j)
410 >                m(i, j) = this->data_[beginRow+i][beginCol+j];
411      }
412      
413 <    /**
414 <    * 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;
413 >    unsigned int getNRow() const {return Row;}
414 >    unsigned int getNCol() const {return Col;}        
415  
416 <        result.add(m1, m2);
416 >  protected:
417 >    Real data_[Row][Col];
418 >  };
419  
420 <        return result;
421 <    }
420 >  /** Negate the value of every element of this matrix. */
421 >  template<typename Real, unsigned int Row, unsigned int Col>
422 >  inline RectMatrix<Real, Row, Col> operator -(const RectMatrix<Real, Row, Col>& m) {
423 >    RectMatrix<Real, Row, Col> result(m);
424 >
425 >    result.negate();
426 >
427 >    return result;
428 >  }
429      
430 <    /**
431 <    * Return the difference of two matrixes  (m1 - m2).
432 <    * @return the sum of two matrixes
433 <    * @param m1 the first matrix
434 <    * @param m2 the second matrix
435 <    */
436 <    template<typename Real, unsigned int Row, unsigned int Col>
437 <    inline RectMatrix<Real, Row, Col> operator - (const RectMatrix<Real, Row, Col>& m1, const RectMatrix<Real, Row, Col>& m2) {
438 <        RectMatrix<Real, Row, Col> result;
430 >  /**
431 >   * Return the sum of two matrixes  (m1 + m2).
432 >   * @return the sum of two matrixes
433 >   * @param m1 the first matrix
434 >   * @param m2 the second matrix
435 >   */
436 >  template<typename Real, unsigned int Row, unsigned int Col>
437 >  inline RectMatrix<Real, Row, Col> operator + (const RectMatrix<Real, Row, Col>& m1,const RectMatrix<Real, Row, Col>& m2) {
438 >    RectMatrix<Real, Row, Col> result;
439  
440 <        result.sub(m1, m2);
440 >    result.add(m1, m2);
441  
442 <        return result;
443 <    }
442 >    return result;
443 >  }
444 >    
445 >  /**
446 >   * Return the difference of two matrixes  (m1 - m2).
447 >   * @return the sum of two matrixes
448 >   * @param m1 the first matrix
449 >   * @param m2 the second matrix
450 >   */
451 >  template<typename Real, unsigned int Row, unsigned int Col>
452 >  inline RectMatrix<Real, Row, Col> operator - (const RectMatrix<Real, Row, Col>& m1, const RectMatrix<Real, Row, Col>& m2) {
453 >    RectMatrix<Real, Row, Col> result;
454  
455 <    /**
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;
455 >    result.sub(m1, m2);
456  
457 <        result.mul(s, m);
457 >    return result;
458 >  }
459  
460 <        return result;
461 <    }
460 >  /**
461 >   * Return the multiplication of scalra and  matrix  (m * s).
462 >   * @return the multiplication of a scalra and  a matrix
463 >   * @param m the matrix
464 >   * @param s the scalar
465 >   */
466 >  template<typename Real, unsigned int Row, unsigned int Col>
467 >  inline RectMatrix<Real, Row, Col> operator *(const RectMatrix<Real, Row, Col>& m, Real s) {
468 >    RectMatrix<Real, Row, Col> result;
469  
470 <    /**
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;
470 >    result.mul(s, m);
471  
472 <        result.mul(s, m);
472 >    return result;
473 >  }
474  
475 <        return result;
476 <    }
475 >  /**
476 >   * Return the multiplication of a scalra and  a matrix  (s * m).
477 >   * @return the multiplication of a scalra and  a matrix
478 >   * @param s the scalar
479 >   * @param m the matrix
480 >   */
481 >  template<typename Real, unsigned int Row, unsigned int Col>
482 >  inline RectMatrix<Real, Row, Col> operator *(Real s, const RectMatrix<Real, Row, Col>& m) {
483 >    RectMatrix<Real, Row, Col> result;
484 >
485 >    result.mul(s, m);
486 >
487 >    return result;
488 >  }
489      
490 <    /**
491 <    * Return the multiplication of two matrixes  (m1 * m2).
492 <    * @return the multiplication of two matrixes
493 <    * @param m1 the first matrix
494 <    * @param m2 the second matrix
495 <    */
496 <    template<typename Real, unsigned int Row, unsigned int Col, unsigned int SameDim>
497 <    inline RectMatrix<Real, Row, Col> operator *(const RectMatrix<Real, Row, SameDim>& m1, const RectMatrix<Real, SameDim, Col>& m2) {
498 <        RectMatrix<Real, Row, Col> result;
490 >  /**
491 >   * Return the multiplication of two matrixes  (m1 * m2).
492 >   * @return the multiplication of two matrixes
493 >   * @param m1 the first matrix
494 >   * @param m2 the second matrix
495 >   */
496 >  template<typename Real, unsigned int Row, unsigned int Col, unsigned int SameDim>
497 >  inline RectMatrix<Real, Row, Col> operator *(const RectMatrix<Real, Row, SameDim>& m1, const RectMatrix<Real, SameDim, Col>& m2) {
498 >    RectMatrix<Real, Row, Col> result;
499  
500 <            for (unsigned int i = 0; i < Row; i++)
501 <                for (unsigned int j = 0; j < Col; j++)
502 <                    for (unsigned int k = 0; k < SameDim; k++)
503 <                        result(i, j)  += m1(i, k) * m2(k, j);                
500 >    for (unsigned int i = 0; i < Row; i++)
501 >      for (unsigned int j = 0; j < Col; j++)
502 >        for (unsigned int k = 0; k < SameDim; k++)
503 >          result(i, j)  += m1(i, k) * m2(k, j);                
504  
505 <        return result;
506 <    }
505 >    return result;
506 >  }
507      
508 <    /**
509 <    * Return the multiplication of  a matrix and a vector  (m * v).
510 <    * @return the multiplication of a matrix and a vector
511 <    * @param m the matrix
512 <    * @param v the vector
513 <    */
514 <    template<typename Real, unsigned int Row, unsigned int Col>
515 <    inline Vector<Real, Row> operator *(const RectMatrix<Real, Row, Col>& m, const Vector<Real, Col>& v) {
516 <        Vector<Real, Row> result;
508 >  /**
509 >   * Return the multiplication of  a matrix and a vector  (m * v).
510 >   * @return the multiplication of a matrix and a vector
511 >   * @param m the matrix
512 >   * @param v the vector
513 >   */
514 >  template<typename Real, unsigned int Row, unsigned int Col>
515 >  inline Vector<Real, Row> operator *(const RectMatrix<Real, Row, Col>& m, const Vector<Real, Col>& v) {
516 >    Vector<Real, Row> result;
517  
518 <        for (unsigned int i = 0; i < Row ; i++)
519 <            for (unsigned int j = 0; j < Col ; j++)            
520 <                result[i] += m(i, j) * v[j];
518 >    for (unsigned int i = 0; i < Row ; i++)
519 >      for (unsigned int j = 0; j < Col ; j++)            
520 >        result[i] += m(i, j) * v[j];
521              
522 <        return result;                                                                
523 <    }
522 >    return result;                                                                
523 >  }
524  
525 <    /**
526 <    * Return the scalar division of matrix   (m / s).
527 <    * @return the scalar division of matrix  
528 <    * @param m the matrix
529 <    * @param s the scalar
530 <    */
531 <    template<typename Real, unsigned int Row, unsigned int Col>
532 <    inline RectMatrix<Real, Row, Col> operator /(const RectMatrix<Real, Row, Col>& m, Real s) {
533 <        RectMatrix<Real, Row, Col> result;
525 >  /**
526 >   * Return the scalar division of matrix   (m / s).
527 >   * @return the scalar division of matrix  
528 >   * @param m the matrix
529 >   * @param s the scalar
530 >   */
531 >  template<typename Real, unsigned int Row, unsigned int Col>
532 >  inline RectMatrix<Real, Row, Col> operator /(const RectMatrix<Real, Row, Col>& m, Real s) {
533 >    RectMatrix<Real, Row, Col> result;
534  
535 <        result.div(s, m);
535 >    result.div(s, m);
536  
537 <        return result;
538 <    }    
537 >    return result;
538 >  }    
539  
540 <    /**
541 <     * Write to an output stream
542 <     */
543 <    template<typename Real,  unsigned int Row, unsigned int Col>
544 <    std::ostream &operator<< ( std::ostream& o, const RectMatrix<Real, Row, Col>& m) {
545 <        for (unsigned int i = 0; i < Row ; i++) {
546 <            o << "(";
547 <            for (unsigned int j = 0; j < Col ; j++) {
548 <                o << m(i, j);
549 <                if (j != Col -1)
550 <                    o << "\t";
551 <            }
552 <            o << ")" << std::endl;
553 <        }
554 <        return o;        
555 <    }    
540 >  /**
541 >   * Write to an output stream
542 >   */
543 >  template<typename Real,  unsigned int Row, unsigned int Col>
544 >  std::ostream &operator<< ( std::ostream& o, const RectMatrix<Real, Row, Col>& m) {
545 >    for (unsigned int i = 0; i < Row ; i++) {
546 >      o << "(";
547 >      for (unsigned int j = 0; j < Col ; j++) {
548 >        o << m(i, j);
549 >        if (j != Col -1)
550 >          o << "\t";
551 >      }
552 >      o << ")" << std::endl;
553 >    }
554 >    return o;        
555 >  }    
556   }
557   #endif //MATH_RECTMATRIX_HPP

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines