src/math/RectMatrix.hpp

 /*
 * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
 *
 * The University of Notre Dame grants you ("Licensee") a
 * non-exclusive, royalty free, license to use, modify and
 * redistribute this software in source and binary code form, provided
 * that the following conditions are met:
 *
 * 1. Acknowledgement of the program authors must be made in any
 *    publication of scientific results based in part on use of the
 *    program.  An acceptable form of acknowledgement is citation of
 *    the article in which the program was described (Matthew
 *    A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher
 *    J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented
 *    Parallel Simulation Engine for Molecular Dynamics,"
 *    J. Comput. Chem. 26, pp. 252-271 (2005))
 *
 * 2. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 3. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the
 *    distribution.
 *
 * This software is provided "AS IS," without a warranty of any
 * kind. All express or implied conditions, representations and
 * warranties, including any implied warranty of merchantability,
 * fitness for a particular purpose or non-infringement, are hereby
 * excluded.  The University of Notre Dame and its licensors shall not
 * be liable for any damages suffered by licensee as a result of
 * using, modifying or distributing the software or its
 * derivatives. In no event will the University of Notre Dame or its
 * licensors be liable for any lost revenue, profit or data, or for
 * direct, indirect, special, consequential, incidental or punitive
 * damages, however caused and regardless of the theory of liability,
 * arising out of the use of or inability to use software, even if the
 * University of Notre Dame has been advised of the possibility of
 * such damages.
 */
 
/**
 * @file RectMatrix.hpp
 * @author Teng Lin
 * @date 10/11/2004
 * @version 1.0
 */

#ifndef MATH_RECTMATRIX_HPP
#define MATH_RECTMATRIX_HPP
#include <math.h>
#include <cmath>
#include "Vector.hpp"

namespace oopse {

    /**
     * @class RectMatrix RectMatrix.hpp "math/RectMatrix.hpp"
     * @brief rectangular matrix class
     */
    template<typename Real, unsigned int Row, unsigned int Col> 
    class RectMatrix {
        public:
            typedef Real ElemType;
            typedef Real* ElemPoinerType;
            
            /** default constructor */
            RectMatrix() {
                for (unsigned int i = 0; i < Row; i++)
                    for (unsigned int j = 0; j < Col; j++)
                        data_[i][j] = 0.0;
             }

            /** Constructs and initializes every element of this matrix to a scalar */ 
            RectMatrix(Real s) {
                for (unsigned int i = 0; i < Row; i++)
                    for (unsigned int j = 0; j < Col; j++)
                        data_[i][j] = s;
            }

            RectMatrix(Real* array) {
                for (unsigned int i = 0; i < Row; i++)
                    for (unsigned int j = 0; j < Col; j++)
                        data_[i][j] = array[i * Row + j];
            }

            /** copy constructor */
            RectMatrix(const RectMatrix<Real, Row, Col>& m) {
                *this = m;
            }
            
            /** destructor*/
            ~RectMatrix() {}

            /** copy assignment operator */
            RectMatrix<Real, Row, Col>& operator =(const RectMatrix<Real, Row, Col>& m) {
                if (this == &m)
                    return *this;
                
                for (unsigned int i = 0; i < Row; i++)
                    for (unsigned int j = 0; j < Col; j++)
                        data_[i][j] = m.data_[i][j];
                return *this;
            }
            
            /**
             * Return the reference of a single element of this matrix.
             * @return the reference of a single element of this matrix 
             * @param i row index
             * @param j Column index
             */
            Real& operator()(unsigned int i, unsigned int j) {
                //assert( i < Row && j < Col);
                return data_[i][j];
            }

            /**
             * Return the value of a single element of this matrix.
             * @return the value of a single element of this matrix 
             * @param i row index
             * @param j Column index
             */        
            Real operator()(unsigned int i, unsigned int j) const  {
                
                return data_[i][j];  
            }

            /** 
             * Copy the internal data to an array
             * @param array the pointer of destination array
             */
            void getArray(Real* array) {
                for (unsigned int i = 0; i < Row; i++) {
                    for (unsigned int j = 0; j < Col; j++) {
                        array[i * Row + j] = data_[i][j];
                    }
                }
            }


            /** Returns the pointer of internal array */
            Real* getArrayPointer() {
                return &data_[0][0];
            }

            /**
             * Returns a row of  this matrix as a vector.
             * @return a row of  this matrix as a vector 
             * @param row the row index
             */                
            Vector<Real, Row> getRow(unsigned int row) {
                Vector<Real, Row> v;

                for (unsigned int i = 0; i < Row; i++)
                    v[i] = data_[row][i];

                return v;
            }

            /**
             * Sets a row of  this matrix
             * @param row the row index
             * @param v the vector to be set
             */                
             void setRow(unsigned int row, const Vector<Real, Row>& v) {

                for (unsigned int i = 0; i < Row; i++)
                    data_[row][i] = v[i];
             }

            /**
             * Returns a column of  this matrix as a vector.
             * @return a column of  this matrix as a vector 
             * @param col the column index
             */                
            Vector<Real, Col> getColumn(unsigned int col) {
                Vector<Real, Col> v;

                for (unsigned int j = 0; j < Col; j++)
                    v[j] = data_[j][col];

                return v;
            }

            /**
             * Sets a column of  this matrix
             * @param col the column index
             * @param v the vector to be set
             */                
             void setColumn(unsigned int col, const Vector<Real, Col>& v){

                for (unsigned int j = 0; j < Col; j++)
                    data_[j][col] = v[j];
             }         

            /**
             * swap two rows of this matrix
             * @param i the first row
             * @param j the second row
             */
            void swapRow(unsigned int i, unsigned int j){
                    assert(i < Row && j < Row);

                    for (unsigned int k = 0; k < Col; k++)
                        std::swap(data_[i][k], data_[j][k]);
            }

           /**
             * swap two Columns of this matrix
             * @param i the first Column
             * @param j the second Column
             */
            void swapColumn(unsigned int i, unsigned int j){
                    assert(i < Col && j < Col);
                    
                    for (unsigned int k = 0; k < Row; k++)
                        std::swap(data_[k][i], data_[k][j]);
            }

            /**
             * Tests if this matrix is identical to matrix m
             * @return true if this matrix is equal to the matrix m, return false otherwise
             * @m matrix to be compared
             *
             * @todo replace operator == by template function equal
             */
            bool operator ==(const RectMatrix<Real, Row, Col>& m) {
                for (unsigned int i = 0; i < Row; i++)
                    for (unsigned int j = 0; j < Col; j++)
                        if (!equal(data_[i][j], m.data_[i][j]))
                            return false;

                return true;
            }

            /**
             * Tests if this matrix is not equal to matrix m
             * @return true if this matrix is not equal to the matrix m, return false otherwise
             * @m matrix to be compared
             */
            bool operator !=(const RectMatrix<Real, Row, Col>& m) {
                return !(*this == m);
            }

            /** Negates the value of this matrix in place. */           
            inline void negate() {
                for (unsigned int i = 0; i < Row; i++)
                    for (unsigned int j = 0; j < Col; j++)
                        data_[i][j] = -data_[i][j];
            }
            
            /**
            * Sets the value of this matrix to the negation of matrix m.
            * @param m the source matrix
            */
            inline void negate(const RectMatrix<Real, Row, Col>& m) {
                for (unsigned int i = 0; i < Row; i++)
                    for (unsigned int j = 0; j < Col; j++)
                        data_[i][j] = -m.data_[i][j];        
            }
            
            /**
            * Sets the value of this matrix to the sum of itself and m (*this += m).
            * @param m the other matrix
            */
            inline void add( const RectMatrix<Real, Row, Col>& m ) {
                for (unsigned int i = 0; i < Row; i++)
                    for (unsigned int j = 0; j < Col; j++)        
                    data_[i][j] += m.data_[i][j];
            }
            
            /**
            * Sets the value of this matrix to the sum of m1 and m2 (*this = m1 + m2).
            * @param m1 the first matrix
            * @param m2 the second matrix
            */
            inline void add( const RectMatrix<Real, Row, Col>& m1, const RectMatrix<Real, Row, Col>& m2 ) {
                for (unsigned int i = 0; i < Row; i++)
                    for (unsigned int j = 0; j < Col; j++)        
                    data_[i][j] = m1.data_[i][j] + m2.data_[i][j];
            }
            
            /**
            * Sets the value of this matrix to the difference  of itself and m (*this -= m).
            * @param m the other matrix
            */
            inline void sub( const RectMatrix<Real, Row, Col>& m ) {
                for (unsigned int i = 0; i < Row; i++)
                    for (unsigned int j = 0; j < Col; j++)        
                        data_[i][j] -= m.data_[i][j];
            }
            
            /**
            * Sets the value of this matrix to the difference of matrix m1 and m2 (*this = m1 - m2).
            * @param m1 the first matrix
            * @param m2 the second matrix
            */
            inline void sub( const RectMatrix<Real, Row, Col>& m1, const RectMatrix<Real, Row, Col>& m2){
                for (unsigned int i = 0; i < Row; i++)
                    for (unsigned int j = 0; j < Col; j++)        
                        data_[i][j] = m1.data_[i][j] - m2.data_[i][j];
            }

            /**
            * Sets the value of this matrix to the scalar multiplication of itself (*this *= s).
            * @param s the scalar value
            */
            inline void mul( Real s ) {
                for (unsigned int i = 0; i < Row; i++)
                    for (unsigned int j = 0; j < Col; j++)  
                        data_[i][j] *= s;
            }

            /**
            * Sets the value of this matrix to the scalar multiplication of matrix m  (*this = s * m).
            * @param s the scalar value
            * @param m the matrix
            */
            inline void mul( Real s, const RectMatrix<Real, Row, Col>& m ) {
                for (unsigned int i = 0; i < Row; i++)
                    for (unsigned int j = 0; j < Col; j++)  
                        data_[i][j] = s * m.data_[i][j];
            }

            /**
            * Sets the value of this matrix to the scalar division of itself  (*this /= s ).
            * @param s the scalar value
            */             
            inline void div( Real s) {
                for (unsigned int i = 0; i < Row; i++)
                    for (unsigned int j = 0; j < Col; j++)  
                        data_[i][j] /= s;
            }

            /**
            * Sets the value of this matrix to the scalar division of matrix m  (*this = m /s).
            * @param s the scalar value
            * @param m the matrix
            */
            inline void div( Real s, const RectMatrix<Real, Row, Col>& m ) {
                for (unsigned int i = 0; i < Row; i++)
                    for (unsigned int j = 0; j < Col; j++)  
                        data_[i][j] = m.data_[i][j] / s;
            }

            /**
             *  Multiples a scalar into every element of this matrix.
             * @param s the scalar value
             */
            RectMatrix<Real, Row, Col>& operator *=(const Real s) {
                this->mul(s);
                return *this;
            }

            /**
             *  Divides every element of this matrix by a scalar.
             * @param s the scalar value
             */
            RectMatrix<Real, Row, Col>& operator /=(const Real s) {
                this->div(s);
                return *this;
            }

            /**
             * Sets the value of this matrix to the sum of the other matrix and itself (*this += m).
             * @param m the other matrix
             */
            RectMatrix<Real, Row, Col>& operator += (const RectMatrix<Real, Row, Col>& m) {
                add(m);
                return *this;
             }

            /**
             * Sets the value of this matrix to the differerence of itself and the other matrix (*this -= m) 
             * @param m the other matrix
             */
            RectMatrix<Real, Row, Col>& operator -= (const RectMatrix<Real, Row, Col>& m){
                sub(m);
                return *this;
            }

            /** Return the transpose of this matrix */
            RectMatrix<Real,  Col, Row> transpose() const{
                RectMatrix<Real,  Col, Row> result;
                
                for (unsigned int i = 0; i < Row; i++)
                    for (unsigned int j = 0; j < Col; j++)              
                        result(j, i) = data_[i][j];

                return result;
            }
        
        protected:
            Real data_[Row][Col];
    };

    /** Negate the value of every element of this matrix. */
    template<typename Real, unsigned int Row, unsigned int Col> 
    inline RectMatrix<Real, Row, Col> operator -(const RectMatrix<Real, Row, Col>& m) {
        RectMatrix<Real, Row, Col> result(m);

        result.negate();

        return result;
    }
    
    /**
    * Return the sum of two matrixes  (m1 + m2). 
    * @return the sum of two matrixes
    * @param m1 the first matrix
    * @param m2 the second matrix
    */ 
    template<typename Real, unsigned int Row, unsigned int Col> 
    inline RectMatrix<Real, Row, Col> operator + (const RectMatrix<Real, Row, Col>& m1,const RectMatrix<Real, Row, Col>& m2) {
        RectMatrix<Real, Row, Col> result;

        result.add(m1, m2);

        return result;
    }
    
    /**
    * Return the difference of two matrixes  (m1 - m2). 
    * @return the sum of two matrixes
    * @param m1 the first matrix
    * @param m2 the second matrix
    */
    template<typename Real, unsigned int Row, unsigned int Col> 
    inline RectMatrix<Real, Row, Col> operator - (const RectMatrix<Real, Row, Col>& m1, const RectMatrix<Real, Row, Col>& m2) {
        RectMatrix<Real, Row, Col> result;

        result.sub(m1, m2);

        return result;
    }

    /**
    * Return the multiplication of scalra and  matrix  (m * s). 
    * @return the multiplication of a scalra and  a matrix 
    * @param m the matrix
    * @param s the scalar
    */
    template<typename Real, unsigned int Row, unsigned int Col> 
    inline RectMatrix<Real, Row, Col> operator *(const RectMatrix<Real, Row, Col>& m, Real s) {
        RectMatrix<Real, Row, Col> result;

        result.mul(s, m);

        return result;
    }

    /**
    * Return the multiplication of a scalra and  a matrix  (s * m). 
    * @return the multiplication of a scalra and  a matrix 
    * @param s the scalar
    * @param m the matrix
    */
    template<typename Real, unsigned int Row, unsigned int Col> 
    inline RectMatrix<Real, Row, Col> operator *(Real s, const RectMatrix<Real, Row, Col>& m) {
        RectMatrix<Real, Row, Col> result;

        result.mul(s, m);

        return result;
    }
    
    /**
    * Return the multiplication of two matrixes  (m1 * m2). 
    * @return the multiplication of two matrixes
    * @param m1 the first matrix
    * @param m2 the second matrix
    */
    template<typename Real, unsigned int Row, unsigned int Col, unsigned int SameDim> 
    inline RectMatrix<Real, Row, Col> operator *(const RectMatrix<Real, Row, SameDim>& m1, const RectMatrix<Real, SameDim, Col>& m2) {
        RectMatrix<Real, Row, Col> result;

            for (unsigned int i = 0; i < Row; i++)
                for (unsigned int j = 0; j < Col; j++)
                    for (unsigned int k = 0; k < SameDim; k++)
                        result(i, j)  += m1(i, k) * m2(k, j);                

        return result;
    }
    
    /**
    * Return the multiplication of  a matrix and a vector  (m * v). 
    * @return the multiplication of a matrix and a vector
    * @param m the matrix
    * @param v the vector
    */
    template<typename Real, unsigned int Row, unsigned int Col>
    inline Vector<Real, Row> operator *(const RectMatrix<Real, Row, Col>& m, const Vector<Real, Col>& v) {
        Vector<Real, Row> result;

        for (unsigned int i = 0; i < Row ; i++)
            for (unsigned int j = 0; j < Col ; j++)            
                result[i] += m(i, j) * v[j];
            
        return result;                                                                 
    }

    /**
    * Return the scalar division of matrix   (m / s). 
    * @return the scalar division of matrix  
    * @param m the matrix
    * @param s the scalar
    */
    template<typename Real, unsigned int Row, unsigned int Col> 
    inline RectMatrix<Real, Row, Col> operator /(const RectMatrix<Real, Row, Col>& m, Real s) {
        RectMatrix<Real, Row, Col> result;

        result.div(s, m);

        return result;
    }    

    /**
     * Write to an output stream
     */
    template<typename Real,  unsigned int Row, unsigned int Col>
    std::ostream &operator<< ( std::ostream& o, const RectMatrix<Real, Row, Col>& m) {
        for (unsigned int i = 0; i < Row ; i++) {
            o << "(";
            for (unsigned int j = 0; j < Col ; j++) {
                o << m(i, j);
                if (j != Col -1)
                    o << "\t";
            }
            o << ")" << std::endl;
        }
        return o;        
    }    
}
#endif //MATH_RECTMATRIX_HPP
Revision:	1937
Committed:	Thu Jan 13 19:40:37 2005 UTC (19 years, 5 months ago) by tim
File size:	19452 byte(s)
Log Message:	port to SGI platform
#	User	Rev	Content
1	gezelter	1930	/*
2			* Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3	tim	1564	*
4	gezelter	1930	* 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	tim	1564	*/
41	gezelter	1930
42	tim	1564	/**
43			* @file RectMatrix.hpp
44			* @author Teng Lin
45			* @date 10/11/2004
46			* @version 1.0
47			*/
48
49			#ifndef MATH_RECTMATRIX_HPP
50			#define MATH_RECTMATRIX_HPP
51	tim	1937	#include <math.h>
52	tim	1567	#include <cmath>
53	tim	1564	#include "Vector.hpp"
54
55			namespace oopse {
56
57			/**
58			* @class RectMatrix RectMatrix.hpp "math/RectMatrix.hpp"
59			* @brief rectangular matrix class
60			*/
61			template<typename Real, unsigned int Row, unsigned int Col>
62			class RectMatrix {
63			public:
64	tim	1630	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	tim	1564
74	tim	1630	/** 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	tim	1564
81	tim	1644	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	tim	1630	/** copy constructor */
88			RectMatrix(const RectMatrix<Real, Row, Col>& m) {
89			*this = m;
90			}
91
92			/** destructor*/
93			~RectMatrix() {}
94	tim	1564
95	tim	1630	/** 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	tim	1564	return *this;
104	tim	1630	}
105	tim	1564
106	tim	1630	/**
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	gezelter	1930	* @param j Column index
111	tim	1630	*/
112			Real& operator()(unsigned int i, unsigned int j) {
113			//assert( i < Row && j < Col);
114			return data_[i][j];
115			}
116	tim	1564
117	tim	1630	/**
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	gezelter	1930	* @param j Column index
122	tim	1630	*/
123			Real operator()(unsigned int i, unsigned int j) const {
124
125			return data_[i][j];
126			}
127	tim	1564
128	tim	1644	/**
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
140
141	tim	1630	/** Returns the pointer of internal array */
142			Real* getArrayPointer() {
143			return &data_[0][0];
144			}
145	tim	1564
146	tim	1630	/**
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	tim	1564
154	tim	1630	for (unsigned int i = 0; i < Row; i++)
155			v[i] = data_[row][i];
156	tim	1564
157	tim	1630	return v;
158			}
159	tim	1564
160	tim	1630	/**
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	tim	1564
167	tim	1630	for (unsigned int i = 0; i < Row; i++)
168			data_[row][i] = v[i];
169			}
170	tim	1564
171	tim	1630	/**
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	gezelter	1930	Vector<Real, Col> getColumn(unsigned int col) {
177	tim	1630	Vector<Real, Col> v;
178	tim	1564
179	tim	1630	for (unsigned int j = 0; j < Col; j++)
180			v[j] = data_[j][col];
181	tim	1564
182	tim	1630	return v;
183			}
184	tim	1564
185	tim	1630	/**
186			* Sets a column of this matrix
187			* @param col the column index
188			* @param v the vector to be set
189			*/
190	gezelter	1930	void setColumn(unsigned int col, const Vector<Real, Col>& v){
191	tim	1564
192	tim	1630	for (unsigned int j = 0; j < Col; j++)
193			data_[j][col] = v[j];
194			}
195	tim	1594
196	tim	1630	/**
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	tim	1594
204	tim	1630	for (unsigned int k = 0; k < Col; k++)
205			std::swap(data_[i][k], data_[j][k]);
206			}
207	tim	1594
208	tim	1630	/**
209	gezelter	1930	* swap two Columns of this matrix
210			* @param i the first Column
211			* @param j the second Column
212	tim	1630	*/
213	gezelter	1930	void swapColumn(unsigned int i, unsigned int j){
214	tim	1630	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	tim	1564
220	tim	1630	/**
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	tim	1564
233	tim	1630	return true;
234			}
235	tim	1564
236	tim	1630	/**
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	tim	1564
245	tim	1630	/** 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			/**
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	tim	1564
304	tim	1630	/**
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	tim	1564
314	tim	1630	/**
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	tim	1564
325	tim	1630	/**
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	tim	1564
335	tim	1630	/**
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	tim	1564
346	tim	1630	/**
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	tim	1564
355	tim	1630	/**
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	tim	1564
364	tim	1630	/**
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	tim	1564
373	tim	1630	/**
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	tim	1564
382	tim	1630	/** Return the transpose of this matrix */
383	gezelter	1930	RectMatrix<Real, Col, Row> transpose() const{
384	tim	1630	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	tim	1564
393			protected:
394			Real data_[Row][Col];
395			};
396
397			/** Negate the value of every element of this matrix. */
398			template<typename Real, unsigned int Row, unsigned int Col>
399			inline RectMatrix<Real, Row, Col> operator -(const RectMatrix<Real, Row, Col>& m) {
400			RectMatrix<Real, Row, Col> result(m);
401
402			result.negate();
403
404			return result;
405			}
406
407			/**
408			* Return the sum of two matrixes (m1 + m2).
409			* @return the sum of two matrixes
410			* @param m1 the first matrix
411			* @param m2 the second matrix
412			*/
413			template<typename Real, unsigned int Row, unsigned int Col>
414			inline RectMatrix<Real, Row, Col> operator + (const RectMatrix<Real, Row, Col>& m1,const RectMatrix<Real, Row, Col>& m2) {
415			RectMatrix<Real, Row, Col> result;
416
417			result.add(m1, m2);
418
419			return result;
420			}
421
422			/**
423			* Return the difference of two matrixes (m1 - m2).
424			* @return the sum of two matrixes
425			* @param m1 the first matrix
426			* @param m2 the second matrix
427			*/
428			template<typename Real, unsigned int Row, unsigned int Col>
429			inline RectMatrix<Real, Row, Col> operator - (const RectMatrix<Real, Row, Col>& m1, const RectMatrix<Real, Row, Col>& m2) {
430			RectMatrix<Real, Row, Col> result;
431
432			result.sub(m1, m2);
433
434			return result;
435			}
436
437			/**
438			* Return the multiplication of scalra and matrix (m * s).
439			* @return the multiplication of a scalra and a matrix
440			* @param m the matrix
441			* @param s the scalar
442			*/
443			template<typename Real, unsigned int Row, unsigned int Col>
444			inline RectMatrix<Real, Row, Col> operator *(const RectMatrix<Real, Row, Col>& m, Real s) {
445			RectMatrix<Real, Row, Col> result;
446
447			result.mul(s, m);
448
449			return result;
450			}
451
452			/**
453			* Return the multiplication of a scalra and a matrix (s * m).
454			* @return the multiplication of a scalra and a matrix
455			* @param s the scalar
456			* @param m the matrix
457			*/
458			template<typename Real, unsigned int Row, unsigned int Col>
459			inline RectMatrix<Real, Row, Col> operator *(Real s, const RectMatrix<Real, Row, Col>& m) {
460			RectMatrix<Real, Row, Col> result;
461
462			result.mul(s, m);
463
464			return result;
465			}
466
467			/**
468			* Return the multiplication of two matrixes (m1 * m2).
469			* @return the multiplication of two matrixes
470			* @param m1 the first matrix
471			* @param m2 the second matrix
472			*/
473			template<typename Real, unsigned int Row, unsigned int Col, unsigned int SameDim>
474			inline RectMatrix<Real, Row, Col> operator *(const RectMatrix<Real, Row, SameDim>& m1, const RectMatrix<Real, SameDim, Col>& m2) {
475			RectMatrix<Real, Row, Col> result;
476
477			for (unsigned int i = 0; i < Row; i++)
478			for (unsigned int j = 0; j < Col; j++)
479			for (unsigned int k = 0; k < SameDim; k++)
480	tim	1569	result(i, j) += m1(i, k) * m2(k, j);
481	tim	1564
482			return result;
483			}
484
485			/**
486			* Return the multiplication of a matrix and a vector (m * v).
487			* @return the multiplication of a matrix and a vector
488			* @param m the matrix
489			* @param v the vector
490			*/
491			template<typename Real, unsigned int Row, unsigned int Col>
492			inline Vector<Real, Row> operator *(const RectMatrix<Real, Row, Col>& m, const Vector<Real, Col>& v) {
493			Vector<Real, Row> result;
494
495			for (unsigned int i = 0; i < Row ; i++)
496			for (unsigned int j = 0; j < Col ; j++)
497			result[i] += m(i, j) * v[j];
498
499			return result;
500			}
501
502			/**
503			* Return the scalar division of matrix (m / s).
504			* @return the scalar division of matrix
505			* @param m the matrix
506			* @param s the scalar
507			*/
508			template<typename Real, unsigned int Row, unsigned int Col>
509			inline RectMatrix<Real, Row, Col> operator /(const RectMatrix<Real, Row, Col>& m, Real s) {
510			RectMatrix<Real, Row, Col> result;
511
512			result.div(s, m);
513
514			return result;
515			}
516	tim	1586
517			/**
518			* Write to an output stream
519			*/
520			template<typename Real, unsigned int Row, unsigned int Col>
521			std::ostream &operator<< ( std::ostream& o, const RectMatrix<Real, Row, Col>& m) {
522			for (unsigned int i = 0; i < Row ; i++) {
523	tim	1603	o << "(";
524	tim	1586	for (unsigned int j = 0; j < Col ; j++) {
525	tim	1606	o << m(i, j);
526			if (j != Col -1)
527			o << "\t";
528	tim	1586	}
529			o << ")" << std::endl;
530			}
531			return o;
532			}
533	tim	1564	}
534			#endif //MATH_RECTMATRIX_HPP