ViewVC Help

View File | Revision Log | Show Annotations | View Changeset | Root Listing

root/OpenMD/branches/development/src/math/RectMatrix.hpp

Comparing trunk/src/math/RectMatrix.hpp (file contents):
Revision 101 by tim, Mon Oct 18 23:13:23 2004 UTC vs.
Revision 1442 by gezelter, Mon May 10 17:28:26 2010 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. Redistributions of source code must retain the above copyright
10	+	*    notice, this list of conditions and the following disclaimer.
11	+	*
12	+	* 2. Redistributions in binary form must reproduce the above copyright
13	+	*    notice, this list of conditions and the following disclaimer in the
14	+	*    documentation and/or other materials provided with the
15	+	*    distribution.
16	+	*
17	+	* This software is provided "AS IS," without a warranty of any
18	+	* kind. All express or implied conditions, representations and
19	+	* warranties, including any implied warranty of merchantability,
20	+	* fitness for a particular purpose or non-infringement, are hereby
21	+	* excluded.  The University of Notre Dame and its licensors shall not
22	+	* be liable for any damages suffered by licensee as a result of
23	+	* using, modifying or distributing the software or its
24	+	* derivatives. In no event will the University of Notre Dame or its
25	+	* licensors be liable for any lost revenue, profit or data, or for
26	+	* direct, indirect, special, consequential, incidental or punitive
27	+	* damages, however caused and regardless of the theory of liability,
28	+	* arising out of the use of or inability to use software, even if the
29	+	* University of Notre Dame has been advised of the possibility of
30	+	* such damages.
31	+	*
32	+	* SUPPORT OPEN SCIENCE!  If you use OpenMD or its source code in your
33	+	* research, please cite the appropriate papers when you publish your
34	+	* work.  Good starting points are:
35	+	*
36	+	* [1]  Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).
37	+	* [2]  Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).
38	+	* [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 24107 (2008).
39	+	* [4]  Vardeman & Gezelter, in progress (2009).
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 {
55	>	namespace OpenMD {
56
57	<	/**
58	<	* @class RectMatrix RectMatrix.hpp "math/RectMatrix.hpp"
59	<	* @brief rectangular matrix class
60	<	*/
61	<	template<typename Real, unsigned int Row, unsigned int Col>
62	<	class RectMatrix {
63	<	public:
57	>	/**
58	>	* @class RectMatrix RectMatrix.hpp "math/RectMatrix.hpp"
59	>	* @brief rectangular matrix class
60	>	*/
61	>	template<typename Real, unsigned int Row, unsigned int Col>
62	>	class RectMatrix {
63	>	public:
64	>	typedef Real ElemType;
65	>	typedef Real* ElemPoinerType;
66	>
67	>	/** default constructor */
68	>	RectMatrix() {
69	>	for (unsigned int i = 0; i < Row; i++)
70	>	for (unsigned int j = 0; j < Col; j++)
71	>	this->data_[i][j] = 0.0;
72	>	}
73
74	<	/** default constructor */
75	<	RectMatrix() {
76	<	for (unsigned int i = 0; i < Row; i++)
77	<	for (unsigned int j = 0; j < Col; j++)
78	<	data_[i][j] = 0.0;
79	<	}
74	>	/** Constructs and initializes every element of this matrix to a scalar */
75	>	RectMatrix(Real s) {
76	>	for (unsigned int i = 0; i < Row; i++)
77	>	for (unsigned int j = 0; j < Col; j++)
78	>	this->data_[i][j] = s;
79	>	}
80
81	<	/** Constructs and initializes every element of this matrix to a scalar */
82	<	RectMatrix(Real s) {
83	<	for (unsigned int i = 0; i < Row; i++)
84	<	for (unsigned int j = 0; j < Col; j++)
85	<	data_[i][j] = s;
62	<	}
81	>	RectMatrix(Real* array) {
82	>	for (unsigned int i = 0; i < Row; i++)
83	>	for (unsigned int j = 0; j < Col; j++)
84	>	this->data_[i][j] = array[i * Row + j];
85	>	}
86
87	<	/** copy constructor */
88	<	RectMatrix(const RectMatrix<Real, Row, Col>& m) {
89	<	*this = m;
90	<	}
68	<
69	<	/** destructor*/
70	<	~RectMatrix() {}
71	<
72	<	/** copy assignment operator */
73	<	RectMatrix<Real, Row, Col>& operator =(const RectMatrix<Real, Row, Col>& m) {
74	<	if (this == &m)
75	<	return *this;
87	>	/** copy constructor */
88	>	RectMatrix(const RectMatrix<Real, Row, Col>& m) {
89	>	*this = m;
90	>	}
91
92	<	for (unsigned int i = 0; i < Row; i++)
93	<	for (unsigned int j = 0; j < Col; j++)
79	<	data_[i][j] = m.data_[i][j];
80	<	return *this;
81	<	}
82	<
83	<	/**
84	<	* Return the reference of a single element of this matrix.
85	<	* @return the reference of a single element of this matrix
86	<	* @param i row index
87	<	* @param j colum index
88	<	*/
89	<	double& operator()(unsigned int i, unsigned int j) {
90	<	//assert( i < Row && j < Col);
91	<	return data_[i][j];
92	<	}
92	>	/** destructor*/
93	>	~RectMatrix() {}
94
95	<	/**
96	<	* Return the value of a single element of this matrix.
97	<	* @return the value of a single element of this matrix
98	<	* @param i row index
99	<	* @param j colum index
100	<	*/
101	<	double operator()(unsigned int i, unsigned int j) const  {
95	>	/** copy assignment operator */
96	>	RectMatrix<Real, Row, Col>& operator =(const RectMatrix<Real, Row, Col>& m) {
97	>	if (this == &m)
98	>	return *this;
99	>
100	>	for (unsigned int i = 0; i < Row; i++)
101	>	for (unsigned int j = 0; j < Col; j++)
102	>	this->data_[i][j] = m.data_[i][j];
103	>	return *this;
104	>	}
105
106	<	return data_[i][j];
107	<	}
106	>	/**
107	>	* Return the reference of a single element of this matrix.
108	>	* @return the reference of a single element of this matrix
109	>	* @param i row index
110	>	* @param j Column index
111	>	*/
112	>	Real& operator()(unsigned int i, unsigned int j) {
113	>	//assert( i < Row && j < Col);
114	>	return this->data_[i][j];
115	>	}
116
117	<	/**
118	<	* Returns a row of  this matrix as a vector.
119	<	* @return a row of  this matrix as a vector
120	<	* @param row the row index
121	<	*/
122	<	Vector<Real, Row> getRow(unsigned int row) {
123	<	Vector<Real, Row> v;
117	>	/**
118	>	* Return the value of a single element of this matrix.
119	>	* @return the value of a single element of this matrix
120	>	* @param i row index
121	>	* @param j Column index
122	>	*/
123	>	Real operator()(unsigned int i, unsigned int j) const  {
124	>
125	>	return this->data_[i][j];
126	>	}
127
128	<	for (unsigned int i = 0; i < Row; i++)
129	<	v[i] = data_[row][i];
128	>	/**
129	>	* Copy the internal data to an array
130	>	* @param array the pointer of destination array
131	>	*/
132	>	void getArray(Real* array) {
133	>	for (unsigned int i = 0; i < Row; i++) {
134	>	for (unsigned int j = 0; j < Col; j++) {
135	>	array[i * Row + j] = this->data_[i][j];
136	>	}
137	>	}
138	>	}
139
116	–	return v;
117	–	}
140
141	<	/**
142	<	* Sets a row of  this matrix
143	<	* @param row the row index
144	<	* @param v the vector to be set
123	<	*/
124	<	void setRow(unsigned int row, const Vector<Real, Row>& v) {
141	>	/** Returns the pointer of internal array */
142	>	Real* getArrayPointer() {
143	>	return &this->data_[0][0];
144	>	}
145
146	<	for (unsigned int i = 0; i < Row; i++)
147	<	data_[row][i] = v[i];
148	<	}
146	>	/**
147	>	* Returns a row of  this matrix as a vector.
148	>	* @return a row of  this matrix as a vector
149	>	* @param row the row index
150	>	*/
151	>	Vector<Real, Row> getRow(unsigned int row) {
152	>	Vector<Real, Row> v;
153
154	<	/**
155	<	* Returns a column of  this matrix as a vector.
132	<	* @return a column of  this matrix as a vector
133	<	* @param col the column index
134	<	*/
135	<	Vector<Real, Col> getColum(unsigned int col) {
136	<	Vector<Real, Col> v;
154	>	for (unsigned int i = 0; i < Col; i++)
155	>	v[i] = this->data_[row][i];
156
157	<	for (unsigned int j = 0; j < Col; j++)
158	<	v[j] = data_[j][col];
157	>	return v;
158	>	}
159
160	<	return v;
161	<	}
162	<
163	<	/**
164	<	* Sets a column of  this matrix
165	<	* @param col the column index
147	<	* @param v the vector to be set
148	<	*/
149	<	void setColum(unsigned int col, const Vector<Real, Col>& v){
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 < Col; i++)
168	>	this->data_[row][i] = v[i];
169	>	}
170
171	<	/**
172	<	* swap two rows of this matrix
173	<	* @param i the first row
174	<	* @param j the second row
175	<	*/
176	<	void swapRow(unsigned int i, unsigned int j){
177	<	assert(i < Row && j < Row);
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 k = 0; k < Col; k++)
180	<	std::swap(data_[i][k], data_[j][k]);
165	<	}
179	>	for (unsigned int j = 0; j < Row; j++)
180	>	v[j] = this->data_[j][col];
181
182	<	/**
183	<	* 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	<	}
182	>	return v;
183	>	}
184
185	<	/**
186	<	* Tests if this matrix is identical to matrix m
187	<	* @return true if this matrix is equal to the matrix m, return false otherwise
188	<	* @m matrix to be compared
189	<	*
190	<	* @todo replace operator == by template function equal
185	<	*/
186	<	bool operator ==(const RectMatrix<Real, Row, Col>& m) {
187	<	for (unsigned int i = 0; i < Row; i++)
188	<	for (unsigned int j = 0; j < Col; j++)
189	<	if (!equal(data_[i][j], m.data_[i][j]))
190	<	return false;
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	<	return true;
193	<	}
192	>	for (unsigned int j = 0; j < Row; j++)
193	>	this->data_[j][col] = v[j];
194	>	}
195
196	<	/**
197	<	* Tests if this matrix is not equal to matrix m
198	<	* @return true if this matrix is not equal to the matrix m, return false otherwise
199	<	* @m matrix to be compared
200	<	*/
201	<	bool operator !=(const RectMatrix<Real, Row, Col>& m) {
202	<	return !(*this == m);
202	<	}
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	<	/** Negates the value of this matrix in place. */
205	<	inline void negate() {
206	<	for (unsigned int i = 0; i < Row; i++)
207	<	for (unsigned int j = 0; j < Col; j++)
208	<	data_[i][j] = -data_[i][j];
209	<	}
210	<
211	<	/**
212	<	* Sets the value of this matrix to the negation of matrix m.
213	<	* @param m the source matrix
214	<	*/
215	<	inline void negate(const RectMatrix<Real, Row, Col>& m) {
216	<	for (unsigned int i = 0; i < Row; i++)
217	<	for (unsigned int j = 0; j < Col; j++)
218	<	data_[i][j] = -m.data_[i][j];
219	<	}
220	<
221	<	/**
222	<	* Sets the value of this matrix to the sum of itself and m (*this += m).
223	<	* @param m the other matrix
224	<	*/
225	<	inline void add( const RectMatrix<Real, Row, Col>& m ) {
226	<	for (unsigned int i = 0; i < Row; i++)
227	<	for (unsigned int j = 0; j < Col; j++)
228	<	data_[i][j] += m.data_[i][j];
229	<	}
230	<
231	<	/**
232	<	* Sets the value of this matrix to the sum of m1 and m2 (*this = m1 + m2).
233	<	* @param m1 the first matrix
234	<	* @param m2 the second matrix
235	<	*/
236	<	inline void add( const RectMatrix<Real, Row, Col>& m1, const RectMatrix<Real, Row, Col>& m2 ) {
237	<	for (unsigned int i = 0; i < Row; i++)
238	<	for (unsigned int j = 0; j < Col; j++)
239	<	data_[i][j] = m1.data_[i][j] + m2.data_[i][j];
240	<	}
241	<
242	<	/**
243	<	* Sets the value of this matrix to the difference  of itself and m (*this -= m).
244	<	* @param m the other matrix
245	<	*/
246	<	inline void sub( const RectMatrix<Real, Row, Col>& m ) {
247	<	for (unsigned int i = 0; i < Row; i++)
248	<	for (unsigned int j = 0; j < Col; j++)
249	<	data_[i][j] -= m.data_[i][j];
250	<	}
251	<
252	<	/**
253	<	* Sets the value of this matrix to the difference of matrix m1 and m2 (*this = m1 - m2).
254	<	* @param m1 the first matrix
255	<	* @param m2 the second matrix
256	<	*/
257	<	inline void sub( const RectMatrix<Real, Row, Col>& m1, const RectMatrix<Real, Row, Col>& m2){
258	<	for (unsigned int i = 0; i < Row; i++)
259	<	for (unsigned int j = 0; j < Col; j++)
260	<	data_[i][j] = m1.data_[i][j] - m2.data_[i][j];
261	<	}
204	>	for (unsigned int k = 0; k < Col; k++)
205	>	std::swap(this->data_[i][k], this->data_[j][k]);
206	>	}
207
208	<	/**
209	<	* Sets the value of this matrix to the scalar multiplication of itself (*this *= s).
210	<	* @param s the scalar value
211	<	*/
212	<	inline void mul( 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(this->data_[k][i], this->data_[k][j]);
218	>	}
219
220	<	/**
221	<	* Sets the value of this matrix to the scalar multiplication of matrix m  (*this = s * m).
222	<	* @param s the scalar value
223	<	* @param m the matrix
224	<	*/
225	<	inline void mul( 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] = s * m.data_[i][j];
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(this->data_[i][j], m.data_[i][j]))
231	>	return false;
232
233	<	/**
234	<	* Sets the value of this matrix to the scalar division of itself  (*this /= s ).
286	<	* @param s the scalar value
287	<	*/
288	<	inline void div( double s) {
289	<	for (unsigned int i = 0; i < Row; i++)
290	<	for (unsigned int j = 0; j < Col; j++)
291	<	data_[i][j] /= s;
292	<	}
233	>	return true;
234	>	}
235
236	<	/**
237	<	* Sets the value of this matrix to the scalar division of matrix m  (*this = m /s).
238	<	* @param s the scalar value
239	<	* @param m the matrix
240	<	*/
241	<	inline void div( double s, const RectMatrix<Real, Row, Col>& m ) {
242	<	for (unsigned int i = 0; i < Row; i++)
243	<	for (unsigned int j = 0; j < Col; j++)
302	<	data_[i][j] = m.data_[i][j] / s;
303	<	}
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	<	*  Multiples a scalar into every element of this matrix.
247	<	* @param s the scalar value
248	<	*/
249	<	RectMatrix<Real, Row, Col>& operator *=(const double s) {
250	<	this->mul(s);
251	<	return *this;
252	<	}
253	<
254	<	/**
255	<	*  Divides every element of this matrix by a scalar.
256	<	* @param s the scalar value
257	<	*/
258	<	RectMatrix<Real, Row, Col>& operator /=(const double s) {
259	<	this->div(s);
260	<	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	>	/**
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	<	for (unsigned int i = 0; i < Row; i++)
263	<	for (unsigned int j = 0; j < Col; j++)
264	<	result(j, i) = data_[i][j];
262	>	/**
263	>	* Sets the value of this matrix to the sum of itself and m (*this += m).
264	>	* @param m the other matrix
265	>	*/
266	>	inline void add( const RectMatrix<Real, Row, Col>& m ) {
267	>	for (unsigned int i = 0; i < Row; i++)
268	>	for (unsigned int j = 0; j < Col; j++)
269	>	this->data_[i][j] += m.data_[i][j];
270	>	}
271	>
272	>	/**
273	>	* Sets the value of this matrix to the sum of m1 and m2 (*this = m1 + m2).
274	>	* @param m1 the first matrix
275	>	* @param m2 the second matrix
276	>	*/
277	>	inline void add( const RectMatrix<Real, Row, Col>& m1, const RectMatrix<Real, Row, Col>& m2 ) {
278	>	for (unsigned int i = 0; i < Row; i++)
279	>	for (unsigned int j = 0; j < Col; j++)
280	>	this->data_[i][j] = m1.data_[i][j] + m2.data_[i][j];
281	>	}
282	>
283	>	/**
284	>	* Sets the value of this matrix to the difference  of itself and m (*this -= m).
285	>	* @param m the other matrix
286	>	*/
287	>	inline void sub( const RectMatrix<Real, Row, Col>& m ) {
288	>	for (unsigned int i = 0; i < Row; i++)
289	>	for (unsigned int j = 0; j < Col; j++)
290	>	this->data_[i][j] -= m.data_[i][j];
291	>	}
292	>
293	>	/**
294	>	* Sets the value of this matrix to the difference of matrix m1 and m2 (*this = m1 - m2).
295	>	* @param m1 the first matrix
296	>	* @param m2 the second matrix
297	>	*/
298	>	inline void sub( const RectMatrix<Real, Row, Col>& m1, const RectMatrix<Real, Row, Col>& m2){
299	>	for (unsigned int i = 0; i < Row; i++)
300	>	for (unsigned int j = 0; j < Col; j++)
301	>	this->data_[i][j] = m1.data_[i][j] - m2.data_[i][j];
302	>	}
303
304	<	return result;
305	<	}
306	<
307	<	protected:
308	<	Real data_[Row][Col];
309	<	};
304	>	/**
305	>	* Sets the value of this matrix to the scalar multiplication of itself (*this *= s).
306	>	* @param s the scalar value
307	>	*/
308	>	inline void mul( Real s ) {
309	>	for (unsigned int i = 0; i < Row; i++)
310	>	for (unsigned int j = 0; j < Col; j++)
311	>	this->data_[i][j] *= s;
312	>	}
313
314	<	/** Negate the value of every element of this matrix. */
315	<	template<typename Real, unsigned int Row, unsigned int Col>
316	<	inline RectMatrix<Real, Row, Col> operator -(const RectMatrix<Real, Row, Col>& m) {
317	<	RectMatrix<Real, Row, Col> result(m);
314	>	/**
315	>	* Sets the value of this matrix to the scalar multiplication of matrix m  (*this = s * m).
316	>	* @param s the scalar value
317	>	* @param m the matrix
318	>	*/
319	>	inline void mul( Real s, const RectMatrix<Real, Row, Col>& m ) {
320	>	for (unsigned int i = 0; i < Row; i++)
321	>	for (unsigned int j = 0; j < Col; j++)
322	>	this->data_[i][j] = s * m.data_[i][j];
323	>	}
324
325	<	result.negate();
325	>	/**
326	>	* Sets the value of this matrix to the scalar division of itself  (*this /= s ).
327	>	* @param s the scalar value
328	>	*/
329	>	inline void div( Real s) {
330	>	for (unsigned int i = 0; i < Row; i++)
331	>	for (unsigned int j = 0; j < Col; j++)
332	>	this->data_[i][j] /= s;
333	>	}
334
335	<	return result;
335	>	/**
336	>	* Sets the value of this matrix to the scalar division of matrix m  (*this = m /s).
337	>	* @param s the scalar value
338	>	* @param m the matrix
339	>	*/
340	>	inline void div( Real s, const RectMatrix<Real, Row, Col>& m ) {
341	>	for (unsigned int i = 0; i < Row; i++)
342	>	for (unsigned int j = 0; j < Col; j++)
343	>	this->data_[i][j] = m.data_[i][j] / s;
344		}
345	<
345	>
346		/**
347	<	* Return the sum of two matrixes  (m1 + m2).
348	<	* @return the sum of two matrixes
349	<	* @param m1 the first matrix
350	<	* @param m2 the second matrix
351	<	*/
352	<	template<typename Real, unsigned int Row, unsigned int Col>
353	<	inline RectMatrix<Real, Row, Col> operator + (const RectMatrix<Real, Row, Col>& m1,const RectMatrix<Real, Row, Col>& m2) {
374	<	RectMatrix<Real, Row, Col> result;
347	>	*  Multiples a scalar into every element of this matrix.
348	>	* @param s the scalar value
349	>	*/
350	>	RectMatrix<Real, Row, Col>& operator *=(const Real s) {
351	>	this->mul(s);
352	>	return *this;
353	>	}
354
355	<	result.add(m1, m2);
355	>	/**
356	>	*  Divides every element of this matrix by a scalar.
357	>	* @param s the scalar value
358	>	*/
359	>	RectMatrix<Real, Row, Col>& operator /=(const Real s) {
360	>	this->div(s);
361	>	return *this;
362	>	}
363
364	<	return result;
364	>	/**
365	>	* Sets the value of this matrix to the sum of the other matrix and itself (*this += m).
366	>	* @param m the other matrix
367	>	*/
368	>	RectMatrix<Real, Row, Col>& operator += (const RectMatrix<Real, Row, Col>& m) {
369	>	add(m);
370	>	return *this;
371		}
372	<
372	>
373		/**
374	<	* Return the difference of two matrixes  (m1 - m2).
375	<	* @return the sum of two matrixes
376	<	* @param m1 the first matrix
377	<	* @param m2 the second matrix
378	<	*/
379	<	template<typename Real, unsigned int Row, unsigned int Col>
380	<	inline RectMatrix<Real, Row, Col> operator - (const RectMatrix<Real, Row, Col>& m1, const RectMatrix<Real, Row, Col>& m2) {
389	<	RectMatrix<Real, Row, Col> result;
374	>	* Sets the value of this matrix to the differerence of itself and the other matrix (*this -= m)
375	>	* @param m the other matrix
376	>	*/
377	>	RectMatrix<Real, Row, Col>& operator -= (const RectMatrix<Real, Row, Col>& m){
378	>	sub(m);
379	>	return *this;
380	>	}
381
382	<	result.sub(m1, m2);
382	>	/** Return the transpose of this matrix */
383	>	RectMatrix<Real,  Col, Row> transpose() const{
384	>	RectMatrix<Real,  Col, Row> result;
385	>
386	>	for (unsigned int i = 0; i < Row; i++)
387	>	for (unsigned int j = 0; j < Col; j++)
388	>	result(j, i) = this->data_[i][j];
389
390	<	return result;
390	>	return result;
391		}
392
393	<	/**
394	<	* Return the multiplication of scalra and  matrix  (m * s).
395	<	* @return the multiplication of a scalra and  a matrix
396	<	* @param m the matrix
400	<	* @param s the scalar
401	<	*/
402	<	template<typename Real, unsigned int Row, unsigned int Col>
403	<	inline RectMatrix<Real, Row, Col> operator *(const RectMatrix<Real, Row, Col>& m, Real s) {
404	<	RectMatrix<Real, Row, Col> result;
393	>	template<class MatrixType>
394	>	void setSubMatrix(unsigned int beginRow, unsigned int beginCol, const MatrixType& m) {
395	>	assert(beginRow + m.getNRow() -1 <= getNRow());
396	>	assert(beginCol + m.getNCol() -1 <= getNCol());
397
398	<	result.mul(s, m);
398	>	for (unsigned int i = 0; i < m.getNRow(); ++i)
399	>	for (unsigned int j = 0; j < m.getNCol(); ++j)
400	>	this->data_[beginRow+i][beginCol+j] = m(i, j);
401	>	}
402
403	<	return result;
403	>	template<class MatrixType>
404	>	void getSubMatrix(unsigned int beginRow, unsigned int beginCol, MatrixType& m) {
405	>	assert(beginRow + m.getNRow() -1 <= getNRow());
406	>	assert(beginCol + m.getNCol() - 1 <= getNCol());
407	>
408	>	for (unsigned int i = 0; i < m.getNRow(); ++i)
409	>	for (unsigned int j = 0; j < m.getNCol(); ++j)
410	>	m(i, j) = this->data_[beginRow+i][beginCol+j];
411		}
412	+
413	+	unsigned int getNRow() const {return Row;}
414	+	unsigned int getNCol() const {return Col;}
415
416	<	/**
417	<	* Return the multiplication of a scalra and  a matrix  (s * m).
418	<	* @return the multiplication of a scalra and  a matrix
414	<	* @param s the scalar
415	<	* @param m the matrix
416	<	*/
417	<	template<typename Real, unsigned int Row, unsigned int Col>
418	<	inline RectMatrix<Real, Row, Col> operator *(Real s, const RectMatrix<Real, Row, Col>& m) {
419	<	RectMatrix<Real, Row, Col> result;
416	>	protected:
417	>	Real data_[Row][Col];
418	>	};
419
420	<	result.mul(s, m);
420	>	/** Negate the value of every element of this matrix. */
421	>	template<typename Real, unsigned int Row, unsigned int Col>
422	>	inline RectMatrix<Real, Row, Col> operator -(const RectMatrix<Real, Row, Col>& m) {
423	>	RectMatrix<Real, Row, Col> result(m);
424
425	<	return result;
426	<	}
425	>	result.negate();
426	>
427	>	return result;
428	>	}
429
430	<	/**
431	<	* Return the multiplication of two matrixes  (m1 * m2).
432	<	* @return the multiplication of two matrixes
433	<	* @param m1 the first matrix
434	<	* @param m2 the second matrix
435	<	*/
436	<	template<typename Real, unsigned int Row, unsigned int Col, unsigned int SameDim>
437	<	inline RectMatrix<Real, Row, Col> operator *(const RectMatrix<Real, Row, SameDim>& m1, const RectMatrix<Real, SameDim, Col>& m2) {
438	<	RectMatrix<Real, Row, Col> result;
430	>	/**
431	>	* Return the sum of two matrixes  (m1 + m2).
432	>	* @return the sum of two matrixes
433	>	* @param m1 the first matrix
434	>	* @param m2 the second matrix
435	>	*/
436	>	template<typename Real, unsigned int Row, unsigned int Col>
437	>	inline RectMatrix<Real, Row, Col> operator + (const RectMatrix<Real, Row, Col>& m1,const RectMatrix<Real, Row, Col>& m2) {
438	>	RectMatrix<Real, Row, Col> result;
439
440	<	for (unsigned int i = 0; i < Row; i++)
437	<	for (unsigned int j = 0; j < Col; j++)
438	<	for (unsigned int k = 0; k < SameDim; k++)
439	<	result(i, j)  += m1(i, k) * m2(k, j);
440	>	result.add(m1, m2);
441
442	<	return result;
443	<	}
442	>	return result;
443	>	}
444
445	<	/**
446	<	* Return the multiplication of  a matrix and a vector  (m * v).
447	<	* @return the multiplication of a matrix and a vector
448	<	* @param m the matrix
449	<	* @param v the vector
450	<	*/
451	<	template<typename Real, unsigned int Row, unsigned int Col>
452	<	inline Vector<Real, Row> operator *(const RectMatrix<Real, Row, Col>& m, const Vector<Real, Col>& v) {
453	<	Vector<Real, Row> result;
445	>	/**
446	>	* Return the difference of two matrixes  (m1 - m2).
447	>	* @return the sum of two matrixes
448	>	* @param m1 the first matrix
449	>	* @param m2 the second matrix
450	>	*/
451	>	template<typename Real, unsigned int Row, unsigned int Col>
452	>	inline RectMatrix<Real, Row, Col> operator - (const RectMatrix<Real, Row, Col>& m1, const RectMatrix<Real, Row, Col>& m2) {
453	>	RectMatrix<Real, Row, Col> result;
454
455	<	for (unsigned int i = 0; i < Row ; i++)
456	<	for (unsigned int j = 0; j < Col ; j++)
457	<	result[i] += m(i, j) * v[j];
455	>	result.sub(m1, m2);
456	>
457	>	return result;
458	>	}
459	>
460	>	/**
461	>	* Return the multiplication of scalra and  matrix  (m * s).
462	>	* @return the multiplication of a scalra and  a matrix
463	>	* @param m the matrix
464	>	* @param s the scalar
465	>	*/
466	>	template<typename Real, unsigned int Row, unsigned int Col>
467	>	inline RectMatrix<Real, Row, Col> operator *(const RectMatrix<Real, Row, Col>& m, Real s) {
468	>	RectMatrix<Real, Row, Col> result;
469	>
470	>	result.mul(s, m);
471	>
472	>	return result;
473	>	}
474	>
475	>	/**
476	>	* Return the multiplication of a scalra and  a matrix  (s * m).
477	>	* @return the multiplication of a scalra and  a matrix
478	>	* @param s the scalar
479	>	* @param m the matrix
480	>	*/
481	>	template<typename Real, unsigned int Row, unsigned int Col>
482	>	inline RectMatrix<Real, Row, Col> operator *(Real s, const RectMatrix<Real, Row, Col>& m) {
483	>	RectMatrix<Real, Row, Col> result;
484	>
485	>	result.mul(s, m);
486	>
487	>	return result;
488	>	}
489	>
490	>	/**
491	>	* Return the multiplication of two matrixes  (m1 * m2).
492	>	* @return the multiplication of two matrixes
493	>	* @param m1 the first matrix
494	>	* @param m2 the second matrix
495	>	*/
496	>	template<typename Real, unsigned int Row, unsigned int Col, unsigned int SameDim>
497	>	inline RectMatrix<Real, Row, Col> operator *(const RectMatrix<Real, Row, SameDim>& m1, const RectMatrix<Real, SameDim, Col>& m2) {
498	>	RectMatrix<Real, Row, Col> result;
499	>
500	>	for (unsigned int i = 0; i < Row; i++)
501	>	for (unsigned int j = 0; j < Col; j++)
502	>	for (unsigned int k = 0; k < SameDim; k++)
503	>	result(i, j)  += m1(i, k) * m2(k, j);
504	>
505	>	return result;
506	>	}
507	>
508	>	/**
509	>	* Return the multiplication of  a matrix and a vector  (m * v).
510	>	* @return the multiplication of a matrix and a vector
511	>	* @param m the matrix
512	>	* @param v the vector
513	>	*/
514	>	template<typename Real, unsigned int Row, unsigned int Col>
515	>	inline Vector<Real, Row> operator *(const RectMatrix<Real, Row, Col>& m, const Vector<Real, Col>& v) {
516	>	Vector<Real, Row> result;
517	>
518	>	for (unsigned int i = 0; i < Row ; i++)
519	>	for (unsigned int j = 0; j < Col ; j++)
520	>	result[i] += m(i, j) * v[j];
521
522	<	return result;
523	<	}
522	>	return result;
523	>	}
524
525	<	/**
526	<	* Return the scalar division of matrix   (m / s).
527	<	* @return the scalar division of matrix
528	<	* @param m the matrix
529	<	* @param s the scalar
530	<	*/
531	<	template<typename Real, unsigned int Row, unsigned int Col>
532	<	inline RectMatrix<Real, Row, Col> operator /(const RectMatrix<Real, Row, Col>& m, Real s) {
533	<	RectMatrix<Real, Row, Col> result;
525	>	/**
526	>	* Return the scalar division of matrix   (m / s).
527	>	* @return the scalar division of matrix
528	>	* @param m the matrix
529	>	* @param s the scalar
530	>	*/
531	>	template<typename Real, unsigned int Row, unsigned int Col>
532	>	inline RectMatrix<Real, Row, Col> operator /(const RectMatrix<Real, Row, Col>& m, Real s) {
533	>	RectMatrix<Real, Row, Col> result;
534
535	<	result.div(s, m);
535	>	result.div(s, m);
536
537	<	return result;
538	<	}
537	>	return result;
538	>	}
539
540	<	/**
541	<	* Write to an output stream
542	<	*/
543	<	template<typename Real,  unsigned int Row, unsigned int Col>
544	<	std::ostream &operator<< ( std::ostream& o, const RectMatrix<Real, Row, Col>& m) {
545	<	for (unsigned int i = 0; i < Row ; i++) {
546	<	o << "("
547	<	for (unsigned int j = 0; j < Col ; j++) {
548	<	o << m(i, j) << "\t"
549	<	}
550	<	o << ")" << std::endl;
551	<	}
552	<	return o;
553	<	}
540	>	/**
541	>	* Write to an output stream
542	>	*/
543	>	template<typename Real,  unsigned int Row, unsigned int Col>
544	>	std::ostream &operator<< ( std::ostream& o, const RectMatrix<Real, Row, Col>& m) {
545	>	for (unsigned int i = 0; i < Row ; i++) {
546	>	o << "(";
547	>	for (unsigned int j = 0; j < Col ; j++) {
548	>	o << m(i, j);
549	>	if (j != Col -1)
550	>	o << "\t";
551	>	}
552	>	o << ")" << std::endl;
553	>	}
554	>	return o;
555	>	}
556		}
557		#endif //MATH_RECTMATRIX_HPP

Comparing trunk/src/math/RectMatrix.hpp (property svn:keywords):
Revision 101 by tim, Mon Oct 18 23:13:23 2004 UTC vs.
Revision 1442 by gezelter, Mon May 10 17:28:26 2010 UTC

#	Line 0 | Line 1
1	+	Author Id Revision Date

Diff Legend

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