ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/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 507 by gezelter, Fri Apr 15 22:04:00 2005 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 54 | Line 54 | namespace oopse {
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 <            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 < Row; 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 < Row; 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 < Col; 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 < Col; 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 <            }
390 >      return result;
391 >    }
392          
393 <        protected:
394 <            Real data_[Row][Col];
395 <    };
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);
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();
402 >    result.negate();
403  
404 <        return result;
405 <    }
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;
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);
417 >    result.add(m1, m2);
418  
419 <        return result;
420 <    }
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;
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);
432 >    result.sub(m1, m2);
433  
434 <        return result;
435 <    }
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;
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);
447 >    result.mul(s, m);
448  
449 <        return result;
450 <    }
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;
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);
462 >    result.mul(s, m);
463  
464 <        return result;
465 <    }
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;
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 <                        result(i, j)  += m1(i, k) * m2(k, j);                
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 >          result(i, j)  += m1(i, k) * m2(k, j);                
481  
482 <        return result;
483 <    }
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;
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];
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 <    }
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;
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);
512 >    result.div(s, m);
513  
514 <        return result;
515 <    }    
514 >    return result;
515 >  }    
516  
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 <            o << "(";
524 <            for (unsigned int j = 0; j < Col ; j++) {
525 <                o << m(i, j);
526 <                if (j != Col -1)
527 <                    o << "\t";
528 <            }
529 <            o << ")" << std::endl;
530 <        }
531 <        return o;        
532 <    }    
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 >      o << "(";
524 >      for (unsigned int j = 0; j < Col ; j++) {
525 >        o << m(i, j);
526 >        if (j != Col -1)
527 >          o << "\t";
528 >      }
529 >      o << ")" << std::endl;
530 >    }
531 >    return o;        
532 >  }    
533   }
534   #endif //MATH_RECTMATRIX_HPP

Diff Legend

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