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

Comparing trunk/OOPSE-2.0/src/math/RectMatrix.hpp (file contents):
Revision 1586 by tim, Sun Oct 17 01:19:11 2004 UTC vs.
Revision 2204 by gezelter, Fri Apr 15 22:04:00 2005 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 < Row; i++)
155 >        v[i] = this->data_[row][i];
156  
157 <            for (unsigned int j = 0; j < Col; j++)
158 <                v[j] = data_[j][col];
140 <
141 <            return v;
142 <        }
157 >      return v;
158 >    }
159  
160 <        /**
161 <         * Sets a column of  this matrix
162 <         * @param col the column index
163 <         * @param v the vector to be set
164 <         */                
165 <         void setColum(unsigned int col, const Vector<Real, Col>& v){
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 j = 0; j < Col; j++)
168 <                data_[j][col] = v[j];
169 <         }        
167 >      for (unsigned int i = 0; i < Row; i++)
168 >        this->data_[row][i] = v[i];
169 >    }
170  
171 <        /**
172 <         * Tests if this matrix is identical to matrix m
173 <         * @return true if this matrix is equal to the matrix m, return false otherwise
174 <         * @m matrix to be compared
175 <         *
176 <         * @todo replace operator == by template function equal
177 <         */
162 <        bool operator ==(const RectMatrix<Real, Row, Col>& m) {
163 <            for (unsigned int i = 0; i < Row; i++)
164 <                for (unsigned int j = 0; j < Col; j++)
165 <                    if (!equal(data_[i][j], m.data_[i][j]))
166 <                        return false;
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 <            return true;
180 <        }
179 >      for (unsigned int j = 0; j < Col; j++)
180 >        v[j] = this->data_[j][col];
181  
182 <        /**
183 <         * Tests if this matrix is not equal to matrix m
173 <         * @return true if this matrix is not equal to the matrix m, return false otherwise
174 <         * @m matrix to be compared
175 <         */
176 <        bool operator !=(const RectMatrix<Real, Row, Col>& m) {
177 <            return !(*this == m);
178 <        }
182 >      return v;
183 >    }
184  
185 <        /** Negates the value of this matrix in place. */          
186 <        inline void negate() {
187 <            for (unsigned int i = 0; i < Row; i++)
188 <                for (unsigned int j = 0; j < Col; j++)
189 <                    data_[i][j] = -data_[i][j];
190 <        }
186 <        
187 <        /**
188 <        * Sets the value of this matrix to the negation of matrix m.
189 <        * @param m the source matrix
190 <        */
191 <        inline void negate(const RectMatrix<Real, Row, Col>& m) {
192 <            for (unsigned int i = 0; i < Row; i++)
193 <                for (unsigned int j = 0; j < Col; j++)
194 <                    data_[i][j] = -m.data_[i][j];        
195 <        }
196 <        
197 <        /**
198 <        * Sets the value of this matrix to the sum of itself and m (*this += m).
199 <        * @param m the other matrix
200 <        */
201 <        inline void add( const RectMatrix<Real, Row, Col>& m ) {
202 <            for (unsigned int i = 0; i < Row; i++)
203 <                for (unsigned int j = 0; j < Col; j++)        
204 <                data_[i][j] += m.data_[i][j];
205 <        }
206 <        
207 <        /**
208 <        * Sets the value of this matrix to the sum of m1 and m2 (*this = m1 + m2).
209 <        * @param m1 the first matrix
210 <        * @param m2 the second matrix
211 <        */
212 <        inline void add( const RectMatrix<Real, Row, Col>& m1, const RectMatrix<Real, Row, Col>& m2 ) {
213 <            for (unsigned int i = 0; i < Row; i++)
214 <                for (unsigned int j = 0; j < Col; j++)        
215 <                data_[i][j] = m1.data_[i][j] + m2.data_[i][j];
216 <        }
217 <        
218 <        /**
219 <        * Sets the value of this matrix to the difference  of itself and m (*this -= m).
220 <        * @param m the other matrix
221 <        */
222 <        inline void sub( const RectMatrix<Real, Row, Col>& m ) {
223 <            for (unsigned int i = 0; i < Row; i++)
224 <                for (unsigned int j = 0; j < Col; j++)        
225 <                    data_[i][j] -= m.data_[i][j];
226 <        }
227 <        
228 <        /**
229 <        * Sets the value of this matrix to the difference of matrix m1 and m2 (*this = m1 - m2).
230 <        * @param m1 the first matrix
231 <        * @param m2 the second matrix
232 <        */
233 <        inline void sub( const RectMatrix<Real, Row, Col>& m1, const RectMatrix<Real, Row, Col>& m2){
234 <            for (unsigned int i = 0; i < Row; i++)
235 <                for (unsigned int j = 0; j < Col; j++)        
236 <                    data_[i][j] = m1.data_[i][j] - m2.data_[i][j];
237 <        }
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 <        * Sets the value of this matrix to the scalar multiplication of itself (*this *= s).
194 <        * @param s the scalar value
242 <        */
243 <        inline void mul( double s ) {
244 <            for (unsigned int i = 0; i < Row; i++)
245 <                for (unsigned int j = 0; j < Col; j++)  
246 <                    data_[i][j] *= s;
247 <        }
192 >      for (unsigned int j = 0; j < Col; j++)
193 >        this->data_[j][col] = v[j];
194 >    }        
195  
196 <        /**
197 <        * Sets the value of this matrix to the scalar multiplication of matrix m  (*this = s * m).
198 <        * @param s the scalar value
199 <        * @param m the matrix
200 <        */
201 <        inline void mul( double s, const RectMatrix<Real, Row, Col>& m ) {
202 <            for (unsigned int i = 0; i < Row; i++)
256 <                for (unsigned int j = 0; j < Col; j++)  
257 <                    data_[i][j] = s * m.data_[i][j];
258 <        }
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 division of itself  (*this /= s ).
206 <        * @param s the scalar value
263 <        */            
264 <        inline void div( double s) {
265 <            for (unsigned int i = 0; i < Row; i++)
266 <                for (unsigned int j = 0; j < Col; j++)  
267 <                    data_[i][j] /= s;
268 <        }
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 division of matrix m  (*this = m /s).
210 <        * @param s the scalar value
211 <        * @param m the matrix
212 <        */
213 <        inline void div( 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] = m.data_[i][j] / s;
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 <         *  Multiples a scalar into every element of this matrix.
222 <         * @param s the scalar value
223 <         */
224 <        RectMatrix<Real, Row, Col>& operator *=(const double s) {
225 <            this->mul(s);
226 <            return *this;
227 <        }
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 <         *  Divides every element of this matrix by a scalar.
292 <         * @param s the scalar value
293 <         */
294 <        RectMatrix<Real, Row, Col>& operator /=(const double s) {
295 <            this->div(s);
296 <            return *this;
297 <        }
233 >      return true;
234 >    }
235  
236 <        /**
237 <         * Sets the value of this matrix to the sum of the other matrix and itself (*this += m).
238 <         * @param m the other matrix
239 <         */
240 <        RectMatrix<Real, Row, Col>& operator += (const RectMatrix<Real, Row, Col>& m) {
241 <            add(m);
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 <         * Sets the value of this matrix to the differerence of itself and the other matrix (*this -= m)
247 <         * @param m the other matrix
248 <         */
249 <        RectMatrix<Real, Row, Col>& operator -= (const RectMatrix<Real, Row, Col>& m){
250 <            sub(m);
314 <            return *this;
315 <        }
316 <
317 <        /** Return the transpose of this matrix */
318 <        RectMatrix<Real,  Col, Row> transpose(){
319 <            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) {
350 <        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) {
365 <        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 +  protected:
394 +    Real data_[Row][Col];
395 +  };
396  
397 <    /**
398 <    * Return the multiplication of scalra and  matrix  (m * s).
399 <    * @return the multiplication of a scalra and  a matrix
400 <    * @param m the matrix
376 <    * @param s the scalar
377 <    */
378 <    template<typename Real, unsigned int Row, unsigned int Col>
379 <    inline RectMatrix<Real, Row, Col> operator *(const RectMatrix<Real, Row, Col>& m, Real s) {
380 <        RectMatrix<Real, Row, Col> result;
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.mul(s, m);
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;
416  
417 <    /**
388 <    * Return the multiplication of a scalra and  a matrix  (s * m).
389 <    * @return the multiplication of a scalra and  a matrix
390 <    * @param s the scalar
391 <    * @param m the matrix
392 <    */
393 <    template<typename Real, unsigned int Row, unsigned int Col>
394 <    inline RectMatrix<Real, Row, Col> operator *(Real s, const RectMatrix<Real, Row, Col>& m) {
395 <        RectMatrix<Real, Row, Col> result;
417 >    result.add(m1, m2);
418  
419 <        result.mul(s, m);
419 >    return result;
420 >  }
421 >    
422 >  /**
423 >   * Return the difference of two matrixes  (m1 - m2).
424 >   * @return the sum of two matrixes
425 >   * @param m1 the first matrix
426 >   * @param m2 the second matrix
427 >   */
428 >  template<typename Real, unsigned int Row, unsigned int Col>
429 >  inline RectMatrix<Real, Row, Col> operator - (const RectMatrix<Real, Row, Col>& m1, const RectMatrix<Real, Row, Col>& m2) {
430 >    RectMatrix<Real, Row, Col> result;
431  
432 <        return result;
433 <    }
432 >    result.sub(m1, m2);
433 >
434 >    return result;
435 >  }
436 >
437 >  /**
438 >   * Return the multiplication of scalra and  matrix  (m * s).
439 >   * @return the multiplication of a scalra and  a matrix
440 >   * @param m the matrix
441 >   * @param s the scalar
442 >   */
443 >  template<typename Real, unsigned int Row, unsigned int Col>
444 >  inline RectMatrix<Real, Row, Col> operator *(const RectMatrix<Real, Row, Col>& m, Real s) {
445 >    RectMatrix<Real, Row, Col> result;
446 >
447 >    result.mul(s, m);
448 >
449 >    return result;
450 >  }
451 >
452 >  /**
453 >   * Return the multiplication of a scalra and  a matrix  (s * m).
454 >   * @return the multiplication of a scalra and  a matrix
455 >   * @param s the scalar
456 >   * @param m the matrix
457 >   */
458 >  template<typename Real, unsigned int Row, unsigned int Col>
459 >  inline RectMatrix<Real, Row, Col> operator *(Real s, const RectMatrix<Real, Row, Col>& m) {
460 >    RectMatrix<Real, Row, Col> result;
461 >
462 >    result.mul(s, m);
463 >
464 >    return result;
465 >  }
466      
467 <    /**
468 <    * Return the multiplication of two matrixes  (m1 * m2).
469 <    * @return the multiplication of two matrixes
470 <    * @param m1 the first matrix
471 <    * @param m2 the second matrix
472 <    */
473 <    template<typename Real, unsigned int Row, unsigned int Col, unsigned int SameDim>
474 <    inline RectMatrix<Real, Row, Col> operator *(const RectMatrix<Real, Row, SameDim>& m1, const RectMatrix<Real, SameDim, Col>& m2) {
475 <        RectMatrix<Real, Row, Col> result;
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) << "\t"
526 <            }
527 <            o << ")" << std::endl;
528 <        }
529 <        return o;        
530 <    }    
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