ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE-4/src/math/RectMatrix.hpp
(Generate patch)

Comparing trunk/OOPSE-4/src/math/RectMatrix.hpp (file contents):
Revision 1606 by tim, Tue Oct 19 23:01:03 2004 UTC vs.
Revision 2596 by tim, Wed Feb 22 20:35:16 2006 UTC

# Line 1 | Line 1
1   /*
2 < * Copyright (C) 2000-2004  Object Oriented Parallel Simulation Engine (OOPSE) project
3 < *
4 < * Contact: oopse@oopse.org
5 < *
6 < * This program is free software; you can redistribute it and/or
7 < * modify it under the terms of the GNU Lesser General Public License
8 < * as published by the Free Software Foundation; either version 2.1
9 < * of the License, or (at your option) any later version.
10 < * All we ask is that proper credit is given for our work, which includes
11 < * - but is not limited to - adding the above copyright notice to the beginning
12 < * of your source code files, and to any copyright notice that you may distribute
13 < * with programs based on this work.
14 < *
15 < * This program is distributed in the hope that it will be useful,
16 < * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 < * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18 < * GNU Lesser General Public License for more details.
19 < *
20 < * You should have received a copy of the GNU Lesser General Public License
21 < * along with this program; if not, write to the Free Software
22 < * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
2 > * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3   *
4 + * 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   */
41 <
26 <
41 >
42   /**
43   * @file RectMatrix.hpp
44   * @author Teng Lin
# Line 33 | Line 48
48  
49   #ifndef MATH_RECTMATRIX_HPP
50   #define MATH_RECTMATRIX_HPP
51 <
51 > #include <math.h>
52   #include <cmath>
53   #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:
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 >    }
73  
74 <        /** default constructor */
75 <        RectMatrix() {
76 <            for (unsigned int i = 0; i < Row; i++)
77 <                for (unsigned int j = 0; j < Col; j++)
78 <                    data_[i][j] = 0.0;
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 <        /** Constructs and initializes every element of this matrix to a scalar */
82 <        RectMatrix(Real s) {
83 <            for (unsigned int i = 0; i < Row; i++)
84 <                for (unsigned int j = 0; j < Col; j++)
85 <                    data_[i][j] = s;
62 <        }
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 <        }
68 <        
69 <        /** destructor*/
70 <        ~RectMatrix() {}
71 <
72 <        /** copy assignment operator */
73 <        RectMatrix<Real, Row, Col>& operator =(const RectMatrix<Real, Row, Col>& m) {
74 <            if (this == &m)
75 <                return *this;
87 >    /** copy constructor */
88 >    RectMatrix(const RectMatrix<Real, Row, Col>& m) {
89 >      *this = m;
90 >    }
91              
92 <            for (unsigned int i = 0; i < Row; i++)
93 <                for (unsigned int j = 0; j < Col; j++)
79 <                    data_[i][j] = m.data_[i][j];
80 <            return *this;
81 <        }
82 <        
83 <        /**
84 <         * Return the reference of a single element of this matrix.
85 <         * @return the reference of a single element of this matrix
86 <         * @param i row index
87 <         * @param j colum index
88 <         */
89 <        double& operator()(unsigned int i, unsigned int j) {
90 <            //assert( i < Row && j < Col);
91 <            return data_[i][j];
92 <        }
92 >    /** destructor*/
93 >    ~RectMatrix() {}
94  
95 <        /**
96 <         * Return the value of a single element of this matrix.
97 <         * @return the value of a single element of this matrix
98 <         * @param i row index
99 <         * @param j colum index
100 <         */        
101 <        double operator()(unsigned int i, unsigned int j) const  {
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 >    }
105              
106 <            return data_[i][j];  
107 <        }
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 <         * Returns a row of  this matrix as a vector.
119 <         * @return a row of  this matrix as a vector
120 <         * @param row the row index
121 <         */                
122 <        Vector<Real, Row> getRow(unsigned int row) {
123 <            Vector<Real, Row> v;
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 >    }
127  
128 <            for (unsigned int i = 0; i < Row; i++)
129 <                v[i] = data_[row][i];
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  
116            return v;
117        }
140  
141 <        /**
142 <         * Sets a row of  this matrix
143 <         * @param row the row index
144 <         * @param v the vector to be set
123 <         */                
124 <         void setRow(unsigned int row, const Vector<Real, Row>& v) {
141 >    /** Returns the pointer of internal array */
142 >    Real* getArrayPointer() {
143 >      return &this->data_[0][0];
144 >    }
145  
146 <            for (unsigned int i = 0; i < Row; i++)
147 <                data_[row][i] = v[i];
148 <         }
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 <        /**
155 <         * Returns a column of  this matrix as a vector.
132 <         * @return a column of  this matrix as a vector
133 <         * @param col the column index
134 <         */                
135 <        Vector<Real, Col> getColum(unsigned int col) {
136 <            Vector<Real, Col> v;
154 >      for (unsigned int i = 0; i < Col; i++)
155 >        v[i] = this->data_[row][i];
156  
157 <            for (unsigned int j = 0; j < Col; j++)
158 <                v[j] = data_[j][col];
157 >      return v;
158 >    }
159  
160 <            return v;
161 <        }
162 <
163 <        /**
164 <         * Sets a column of  this matrix
165 <         * @param col the column index
147 <         * @param v the vector to be set
148 <         */                
149 <         void setColum(unsigned int col, const Vector<Real, Col>& v){
150 <
151 <            for (unsigned int j = 0; j < Col; j++)
152 <                data_[j][col] = v[j];
153 <         }        
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 <        /**
168 <         * swap two rows of this matrix
169 <         * @param i the first row
158 <         * @param j the second row
159 <         */
160 <        void swapRow(unsigned int i, unsigned int j){
161 <                assert(i < Row && j < Row);
167 >      for (unsigned int i = 0; i < Col; i++)
168 >        this->data_[row][i] = v[i];
169 >    }
170  
171 <                for (unsigned int k = 0; k < Col; k++)
172 <                    std::swap(data_[i][k], data_[j][k]);
173 <        }
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 <       /**
180 <         * swap two colums of this matrix
169 <         * @param i the first colum
170 <         * @param j the second colum
171 <         */
172 <        void swapColum(unsigned int i, unsigned int j){
173 <                assert(i < Col && j < Col);
174 <                
175 <                for (unsigned int k = 0; k < Row; k++)
176 <                    std::swap(data_[k][i], data_[k][j]);
177 <        }
179 >      for (unsigned int j = 0; j < Row; j++)
180 >        v[j] = this->data_[j][col];
181  
182 <        /**
183 <         * Tests if this matrix is identical to matrix m
181 <         * @return true if this matrix is equal to the matrix m, return false otherwise
182 <         * @m matrix to be compared
183 <         *
184 <         * @todo replace operator == by template function equal
185 <         */
186 <        bool operator ==(const RectMatrix<Real, Row, Col>& m) {
187 <            for (unsigned int i = 0; i < Row; i++)
188 <                for (unsigned int j = 0; j < Col; j++)
189 <                    if (!equal(data_[i][j], m.data_[i][j]))
190 <                        return false;
182 >      return v;
183 >    }
184  
185 <            return true;
186 <        }
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 <        /**
193 <         * Tests if this matrix is not equal to matrix m
194 <         * @return true if this matrix is not equal to the matrix m, return false otherwise
198 <         * @m matrix to be compared
199 <         */
200 <        bool operator !=(const RectMatrix<Real, Row, Col>& m) {
201 <            return !(*this == m);
202 <        }
192 >      for (unsigned int j = 0; j < Row; j++)
193 >        this->data_[j][col] = v[j];
194 >    }        
195  
196 <        /** Negates the value of this matrix in place. */          
197 <        inline void negate() {
198 <            for (unsigned int i = 0; i < Row; i++)
199 <                for (unsigned int j = 0; j < Col; j++)
200 <                    data_[i][j] = -data_[i][j];
201 <        }
202 <        
211 <        /**
212 <        * Sets the value of this matrix to the negation of matrix m.
213 <        * @param m the source matrix
214 <        */
215 <        inline void negate(const RectMatrix<Real, Row, Col>& m) {
216 <            for (unsigned int i = 0; i < Row; i++)
217 <                for (unsigned int j = 0; j < Col; j++)
218 <                    data_[i][j] = -m.data_[i][j];        
219 <        }
220 <        
221 <        /**
222 <        * Sets the value of this matrix to the sum of itself and m (*this += m).
223 <        * @param m the other matrix
224 <        */
225 <        inline void add( const RectMatrix<Real, Row, Col>& m ) {
226 <            for (unsigned int i = 0; i < Row; i++)
227 <                for (unsigned int j = 0; j < Col; j++)        
228 <                data_[i][j] += m.data_[i][j];
229 <        }
230 <        
231 <        /**
232 <        * Sets the value of this matrix to the sum of m1 and m2 (*this = m1 + m2).
233 <        * @param m1 the first matrix
234 <        * @param m2 the second matrix
235 <        */
236 <        inline void add( const RectMatrix<Real, Row, Col>& m1, const RectMatrix<Real, Row, Col>& m2 ) {
237 <            for (unsigned int i = 0; i < Row; i++)
238 <                for (unsigned int j = 0; j < Col; j++)        
239 <                data_[i][j] = m1.data_[i][j] + m2.data_[i][j];
240 <        }
241 <        
242 <        /**
243 <        * Sets the value of this matrix to the difference  of itself and m (*this -= m).
244 <        * @param m the other matrix
245 <        */
246 <        inline void sub( const RectMatrix<Real, Row, Col>& m ) {
247 <            for (unsigned int i = 0; i < Row; i++)
248 <                for (unsigned int j = 0; j < Col; j++)        
249 <                    data_[i][j] -= m.data_[i][j];
250 <        }
251 <        
252 <        /**
253 <        * Sets the value of this matrix to the difference of matrix m1 and m2 (*this = m1 - m2).
254 <        * @param m1 the first matrix
255 <        * @param m2 the second matrix
256 <        */
257 <        inline void sub( const RectMatrix<Real, Row, Col>& m1, const RectMatrix<Real, Row, Col>& m2){
258 <            for (unsigned int i = 0; i < Row; i++)
259 <                for (unsigned int j = 0; j < Col; j++)        
260 <                    data_[i][j] = m1.data_[i][j] - m2.data_[i][j];
261 <        }
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 <        /**
205 <        * Sets the value of this matrix to the scalar multiplication of itself (*this *= s).
206 <        * @param s the scalar value
266 <        */
267 <        inline void mul( double s ) {
268 <            for (unsigned int i = 0; i < Row; i++)
269 <                for (unsigned int j = 0; j < Col; j++)  
270 <                    data_[i][j] *= s;
271 <        }
204 >      for (unsigned int k = 0; k < Col; k++)
205 >        std::swap(this->data_[i][k], this->data_[j][k]);
206 >    }
207  
208 <        /**
209 <        * Sets the value of this matrix to the scalar multiplication of matrix m  (*this = s * m).
210 <        * @param s the scalar value
211 <        * @param m the matrix
212 <        */
213 <        inline void mul( double s, const RectMatrix<Real, Row, Col>& m ) {
214 <            for (unsigned int i = 0; i < Row; i++)
215 <                for (unsigned int j = 0; j < Col; j++)  
216 <                    data_[i][j] = s * m.data_[i][j];
217 <        }
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 >    }
219  
220 <        /**
221 <        * Sets the value of this matrix to the scalar division of itself  (*this /= s ).
222 <        * @param s the scalar value
223 <        */            
224 <        inline void div( double s) {
225 <            for (unsigned int i = 0; i < Row; i++)
226 <                for (unsigned int j = 0; j < Col; j++)  
227 <                    data_[i][j] /= s;
228 <        }
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 <        /**
234 <        * Sets the value of this matrix to the scalar division of matrix m  (*this = m /s).
296 <        * @param s the scalar value
297 <        * @param m the matrix
298 <        */
299 <        inline void div( double s, const RectMatrix<Real, Row, Col>& m ) {
300 <            for (unsigned int i = 0; i < Row; i++)
301 <                for (unsigned int j = 0; j < Col; j++)  
302 <                    data_[i][j] = m.data_[i][j] / s;
303 <        }
233 >      return true;
234 >    }
235  
236 <        /**
237 <         *  Multiples a scalar into every element of this matrix.
238 <         * @param s the scalar value
239 <         */
240 <        RectMatrix<Real, Row, Col>& operator *=(const double s) {
241 <            this->mul(s);
242 <            return *this;
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 <        /**
246 <         *  Divides every element of this matrix by a scalar.
247 <         * @param s the scalar value
248 <         */
249 <        RectMatrix<Real, Row, Col>& operator /=(const double s) {
250 <            this->div(s);
320 <            return *this;
321 <        }
322 <
323 <        /**
324 <         * Sets the value of this matrix to the sum of the other matrix and itself (*this += m).
325 <         * @param m the other matrix
326 <         */
327 <        RectMatrix<Real, Row, Col>& operator += (const RectMatrix<Real, Row, Col>& m) {
328 <            add(m);
329 <            return *this;
330 <         }
331 <
332 <        /**
333 <         * Sets the value of this matrix to the differerence of itself and the other matrix (*this -= m)
334 <         * @param m the other matrix
335 <         */
336 <        RectMatrix<Real, Row, Col>& operator -= (const RectMatrix<Real, Row, Col>& m){
337 <            sub(m);
338 <            return *this;
339 <        }
340 <
341 <        /** Return the transpose of this matrix */
342 <        RectMatrix<Real,  Col, Row> transpose(){
343 <            RectMatrix<Real,  Col, Row> result;
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 <            for (unsigned int i = 0; i < Row; i++)
253 <                for (unsigned int j = 0; j < Col; j++)              
254 <                    result(j, i) = data_[i][j];
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 >    }
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 >    }
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 >    }
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 >    }
303  
304 <            return result;
305 <        }
306 <        
307 <        protected:
308 <            Real data_[Row][Col];
309 <    };
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 <    /** Negate the value of every element of this matrix. */
315 <    template<typename Real, unsigned int Row, unsigned int Col>
316 <    inline RectMatrix<Real, Row, Col> operator -(const RectMatrix<Real, Row, Col>& m) {
317 <        RectMatrix<Real, Row, Col> result(m);
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 <        result.negate();
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 <        return result;
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 <    
345 >
346      /**
347 <    * Return the sum of two matrixes  (m1 + m2).
348 <    * @return the sum of two matrixes
349 <    * @param m1 the first matrix
350 <    * @param m2 the second matrix
351 <    */
352 <    template<typename Real, unsigned int Row, unsigned int Col>
353 <    inline RectMatrix<Real, Row, Col> operator + (const RectMatrix<Real, Row, Col>& m1,const RectMatrix<Real, Row, Col>& m2) {
374 <        RectMatrix<Real, Row, Col> result;
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 <        result.add(m1, m2);
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 <        return result;
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 <    
372 >
373      /**
374 <    * Return the difference of two matrixes  (m1 - m2).
375 <    * @return the sum of two matrixes
376 <    * @param m1 the first matrix
377 <    * @param m2 the second matrix
378 <    */
379 <    template<typename Real, unsigned int Row, unsigned int Col>
380 <    inline RectMatrix<Real, Row, Col> operator - (const RectMatrix<Real, Row, Col>& m1, const RectMatrix<Real, Row, Col>& m2) {
389 <        RectMatrix<Real, Row, Col> result;
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 <        result.sub(m1, m2);
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];
389  
390 <        return result;
390 >      return result;
391      }
392  
393 <    /**
394 <    * Return the multiplication of scalra and  matrix  (m * s).
395 <    * @return the multiplication of a scalra and  a matrix
396 <    * @param m the matrix
400 <    * @param s the scalar
401 <    */
402 <    template<typename Real, unsigned int Row, unsigned int Col>
403 <    inline RectMatrix<Real, Row, Col> operator *(const RectMatrix<Real, Row, Col>& m, Real s) {
404 <        RectMatrix<Real, Row, Col> result;
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.mul(s, m);
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 +    unsigned int getNRow() const {return Row;}
414 +    unsigned int getNCol() const {return Col;}        
415  
416 <    /**
417 <    * Return the multiplication of a scalra and  a matrix  (s * m).
418 <    * @return the multiplication of a scalra and  a matrix
414 <    * @param s the scalar
415 <    * @param m the matrix
416 <    */
417 <    template<typename Real, unsigned int Row, unsigned int Col>
418 <    inline RectMatrix<Real, Row, Col> operator *(Real s, const RectMatrix<Real, Row, Col>& m) {
419 <        RectMatrix<Real, Row, Col> result;
416 >  protected:
417 >    Real data_[Row][Col];
418 >  };
419  
420 <        result.mul(s, m);
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 <        return result;
426 <    }
425 >    result.negate();
426 >
427 >    return result;
428 >  }
429      
430 <    /**
431 <    * Return the multiplication of two matrixes  (m1 * m2).
432 <    * @return the multiplication 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, unsigned int SameDim>
437 <    inline RectMatrix<Real, Row, Col> operator *(const RectMatrix<Real, Row, SameDim>& m1, const RectMatrix<Real, SameDim, 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 <            for (unsigned int i = 0; i < Row; i++)
437 <                for (unsigned int j = 0; j < Col; j++)
438 <                    for (unsigned int k = 0; k < SameDim; k++)
439 <                        result(i, j)  += m1(i, k) * m2(k, j);                
440 >    result.add(m1, m2);
441  
442 <        return result;
443 <    }
442 >    return result;
443 >  }
444      
445 <    /**
446 <    * Return the multiplication of  a matrix and a vector  (m * v).
447 <    * @return the multiplication of a matrix and a vector
448 <    * @param m the matrix
449 <    * @param v the vector
450 <    */
451 <    template<typename Real, unsigned int Row, unsigned int Col>
452 <    inline Vector<Real, Row> operator *(const RectMatrix<Real, Row, Col>& m, const Vector<Real, Col>& v) {
453 <        Vector<Real, Row> result;
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 <        for (unsigned int i = 0; i < Row ; i++)
456 <            for (unsigned int j = 0; j < Col ; j++)            
457 <                result[i] += m(i, j) * v[j];
455 >    result.sub(m1, m2);
456 >
457 >    return result;
458 >  }
459 >
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 >    result.mul(s, m);
471 >
472 >    return result;
473 >  }
474 >
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;
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);                
504 >
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;
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];
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