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

Comparing trunk/src/math/RectMatrix.hpp (file contents):
Revision 113 by tim, Tue Oct 19 23:01:03 2004 UTC vs.
Revision 385 by tim, Tue Mar 1 20:10:14 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.
1 > /*
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  
# Line 46 | Line 61 | namespace oopse {
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 <        }
91 <        
92 <        /** destructor*/
93 <        ~RectMatrix() {}
87 >            /** copy constructor */
88 >            RectMatrix(const RectMatrix<Real, Row, Col>& m) {
89 >                *this = m;
90 >            }
91 >            
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)
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 <            for (unsigned int i = 0; i < Row; i++)
107 <                for (unsigned int j = 0; j < Col; j++)
108 <                    data_[i][j] = m.data_[i][j];
109 <            return *this;
110 <        }
111 <        
112 <        /**
113 <         * Return the reference of a single element of this matrix.
114 <         * @return the reference of a single element of this matrix
115 <         * @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 <        }
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 colum index
122 <         */        
123 <        double operator()(unsigned int i, unsigned int j) const  {
124 <            
125 <            return data_[i][j];  
126 <        }
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 <        /**
129 <         * Returns a row of  this matrix as a vector.
130 <         * @return a row of  this matrix as a vector
131 <         * @param row the row index
132 <         */                
133 <        Vector<Real, Row> getRow(unsigned int row) {
134 <            Vector<Real, Row> v;
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  
113 –            for (unsigned int i = 0; i < Row; i++)
114 –                v[i] = data_[row][i];
140  
141 <            return v;
142 <        }
141 >            /** Returns the pointer of internal array */
142 >            Real* getArrayPointer() {
143 >                return &this->data_[0][0];
144 >            }
145  
146 <        /**
147 <         * Sets a row of  this matrix
148 <         * @param row the row index
149 <         * @param v the vector to be set
150 <         */                
151 <         void setRow(unsigned int row, const 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 <                data_[row][i] = v[i];
128 <         }
154 >                for (unsigned int i = 0; i < Row; i++)
155 >                    v[i] = this->data_[row][i];
156  
157 <        /**
158 <         * 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;
157 >                return v;
158 >            }
159  
160 <            for (unsigned int j = 0; j < Col; j++)
161 <                v[j] = data_[j][col];
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 <            return v;
168 <        }
167 >                for (unsigned int i = 0; i < Row; i++)
168 >                    this->data_[row][i] = v[i];
169 >             }
170  
171 <        /**
172 <         * Sets a column of  this matrix
173 <         * @param col the column index
174 <         * @param v the vector to be set
175 <         */                
176 <         void setColum(unsigned int col, const 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 <                data_[j][col] = v[j];
153 <         }        
179 >                for (unsigned int j = 0; j < Col; j++)
180 >                    v[j] = this->data_[j][col];
181  
182 <        /**
183 <         * swap two rows of this matrix
157 <         * @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);
182 >                return v;
183 >            }
184  
185 <                for (unsigned int k = 0; k < Col; k++)
186 <                    std::swap(data_[i][k], data_[j][k]);
187 <        }
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  
167 –       /**
168 –         * 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 –        }
178 –
179 –        /**
180 –         * 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++)
192                  for (unsigned int j = 0; j < Col; j++)
193 <                    if (!equal(data_[i][j], m.data_[i][j]))
194 <                        return false;
193 >                    this->data_[j][col] = v[j];
194 >             }        
195  
196 <            return true;
197 <        }
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 <         * Tests if this matrix is not equal to matrix m
206 <         * @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 <        }
204 >                    for (unsigned int k = 0; k < Col; k++)
205 >                        std::swap(this->data_[i][k], this->data_[j][k]);
206 >            }
207  
208 <        /** Negates the value of this matrix in place. */          
209 <        inline void negate() {
210 <            for (unsigned int i = 0; i < Row; i++)
211 <                for (unsigned int j = 0; j < Col; j++)
212 <                    data_[i][j] = -data_[i][j];
213 <        }
214 <        
215 <        /**
216 <        * Sets the value of this matrix to the negation of matrix m.
217 <        * @param m the source matrix
218 <        */
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 <        }
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 multiplication of itself (*this *= s).
222 <        * @param s the scalar value
223 <        */
224 <        inline void mul( 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 multiplication of matrix m  (*this = s * m).
275 <        * @param s the scalar value
276 <        * @param m the matrix
277 <        */
278 <        inline void mul( double s, const RectMatrix<Real, Row, Col>& m ) {
279 <            for (unsigned int i = 0; i < Row; i++)
280 <                for (unsigned int j = 0; j < Col; j++)  
281 <                    data_[i][j] = s * m.data_[i][j];
282 <        }
233 >                return true;
234 >            }
235  
236 <        /**
237 <        * Sets the value of this matrix to the scalar division of itself  (*this /= s ).
238 <        * @param s the scalar value
239 <        */            
240 <        inline void div( double s) {
241 <            for (unsigned int i = 0; i < Row; i++)
242 <                for (unsigned int j = 0; j < Col; j++)  
243 <                    data_[i][j] /= s;
292 <        }
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 scalar division of matrix m  (*this = m /s).
247 <        * @param s the scalar value
248 <        * @param m the matrix
249 <        */
250 <        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 <        }
304 <
305 <        /**
306 <         *  Multiples a scalar into every element of this matrix.
307 <         * @param s the scalar value
308 <         */
309 <        RectMatrix<Real, Row, Col>& operator *=(const double s) {
310 <            this->mul(s);
311 <            return *this;
312 <        }
313 <
314 <        /**
315 <         *  Divides every element of this matrix by a scalar.
316 <         * @param s the scalar value
317 <         */
318 <        RectMatrix<Real, Row, Col>& operator /=(const double s) {
319 <            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 <        }
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 >            }
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 >            }
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 >            }
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 >            }
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 >            }
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 >             }
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 >            }
381 >
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;
391 >            }
392          
393          protected:
394              Real data_[Row][Col];

Diff Legend

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