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 1930 by gezelter, Wed Jan 12 22:41:40 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 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 +                        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 >                        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 >                        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 >                        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 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 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] = 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 &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] = 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 >                    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  
151 –            for (unsigned int j = 0; j < Col; j++)
152 –                data_[j][col] = v[j];
153 –         }        
154 –
155 –        /**
156 –         * Tests if this matrix is identical to matrix m
157 –         * @return true if this matrix is equal to the matrix m, return false otherwise
158 –         * @m matrix to be compared
159 –         *
160 –         * @todo replace operator == by template function equal
161 –         */
162 –        bool operator ==(const RectMatrix<Real, Row, Col>& m) {
163 –            for (unsigned int i = 0; i < Row; i++)
179                  for (unsigned int j = 0; j < Col; j++)
180 <                    if (!equal(data_[i][j], m.data_[i][j]))
166 <                        return false;
180 >                    v[j] = data_[j][col];
181  
182 <            return true;
183 <        }
182 >                return v;
183 >            }
184  
185 <        /**
186 <         * Tests if this matrix is not equal to matrix m
187 <         * @return true if this matrix is not equal to the matrix m, return false otherwise
188 <         * @m matrix to be compared
189 <         */
190 <        bool operator !=(const RectMatrix<Real, Row, Col>& m) {
177 <            return !(*this == m);
178 <        }
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  
180 –        /** Negates the value of this matrix in place. */          
181 –        inline void negate() {
182 –            for (unsigned int i = 0; i < Row; i++)
192                  for (unsigned int j = 0; j < Col; j++)
193 <                    data_[i][j] = -data_[i][j];
194 <        }
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 <        }
193 >                    data_[j][col] = v[j];
194 >             }        
195  
196 <        /**
197 <        * Sets the value of this matrix to the scalar multiplication of itself (*this *= s).
198 <        * @param s the scalar value
199 <        */
200 <        inline void mul( double s ) {
201 <            for (unsigned int i = 0; i < Row; i++)
202 <                for (unsigned int j = 0; j < Col; j++)  
246 <                    data_[i][j] *= s;
247 <        }
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 matrix m  (*this = s * m).
206 <        * @param s the scalar value
252 <        * @param m the matrix
253 <        */
254 <        inline void mul( double s, const RectMatrix<Real, Row, Col>& m ) {
255 <            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 <        }
204 >                    for (unsigned int k = 0; k < Col; k++)
205 >                        std::swap(data_[i][k], data_[j][k]);
206 >            }
207  
208 <        /**
209 <        * Sets the value of this matrix to the scalar division of itself  (*this /= s ).
210 <        * @param s the scalar value
211 <        */            
212 <        inline void div( double s) {
213 <            for (unsigned int i = 0; i < Row; i++)
214 <                for (unsigned int j = 0; j < Col; j++)  
215 <                    data_[i][j] /= s;
216 <        }
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(data_[k][i], data_[k][j]);
218 >            }
219  
220 <        /**
221 <        * Sets the value of this matrix to the scalar division of matrix m  (*this = m /s).
222 <        * @param s the scalar value
223 <        * @param m the matrix
224 <        */
225 <        inline void div( double s, 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] / s;
229 <        }
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(data_[i][j], m.data_[i][j]))
231 >                            return false;
232  
233 <        /**
234 <         *  Multiples a scalar into every element of this matrix.
283 <         * @param s the scalar value
284 <         */
285 <        RectMatrix<Real, Row, Col>& operator *=(const double s) {
286 <            this->mul(s);
287 <            return *this;
288 <        }
233 >                return true;
234 >            }
235  
236 <        /**
237 <         *  Divides every element of this matrix by a scalar.
238 <         * @param s the scalar value
239 <         */
240 <        RectMatrix<Real, Row, Col>& operator /=(const double s) {
241 <            this->div(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 <         * Sets the value of this matrix to the sum of the other matrix and itself (*this += m).
247 <         * @param m the other matrix
248 <         */
249 <        RectMatrix<Real, Row, Col>& operator += (const RectMatrix<Real, Row, Col>& m) {
250 <            add(m);
305 <            return *this;
306 <         }
307 <
308 <        /**
309 <         * Sets the value of this matrix to the differerence of itself and the other matrix (*this -= m)
310 <         * @param m the other matrix
311 <         */
312 <        RectMatrix<Real, Row, Col>& operator -= (const RectMatrix<Real, Row, Col>& m){
313 <            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 >                        data_[i][j] = -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 >                        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 >                    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 >                    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 >                        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 >                        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 >                        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 >                        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 >                        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 >                        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) = data_[i][j];
389 >
390 >                return result;
391 >            }
392          
393          protected:
394              Real data_[Row][Col];
# Line 455 | Line 520 | namespace oopse {
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 << "("
523 >            o << "(";
524              for (unsigned int j = 0; j < Col ; j++) {
525 <                o << m(i, j) << "\t"
525 >                o << m(i, j);
526 >                if (j != Col -1)
527 >                    o << "\t";
528              }
529              o << ")" << std::endl;
530          }

Diff Legend

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