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++)
          this->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++)
          this->data_[i][j] = s;
    }

    RectMatrix(Real* array) {
      for (unsigned int i = 0; i < Row; i++)
        for (unsigned int j = 0; j < Col; j++)
          this->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++)
          this->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 this->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 this->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] = this->data_[i][j];
        }
      }
    }


    /** Returns the pointer of internal array */
    Real* getArrayPointer() {
      return &this->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] = this->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++)
        this->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] = this->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++)
        this->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(this->data_[i][k], this->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(this->data_[k][i], this->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(this->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++)
          this->data_[i][j] = -this->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++)
          this->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++)        
          this->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++)        
          this->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++)        
          this->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++)        
          this->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++)  
          this->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++)  
          this->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++)  
          this->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++)  
          this->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) = this->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:	2204
Committed:	Fri Apr 15 22:04:00 2005 UTC (19 years, 2 months ago) by gezelter
File size:	16379 byte(s)
Log Message:	xemacs has been drafted to perform our indentation services
#	User	Rev	Content
1	gezelter	2204	/*
2	gezelter	1930	* 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	gezelter	2204	/**
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	tim	1630
67	gezelter	2204	/** 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	tim	1564
74	gezelter	2204	/** 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	tim	1564
81	gezelter	2204	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	tim	1644
87	gezelter	2204	/** copy constructor */
88			RectMatrix(const RectMatrix<Real, Row, Col>& m) {
89			*this = m;
90			}
91	tim	1630
92	gezelter	2204	/** destructor*/
93			~RectMatrix() {}
94	tim	1564
95	gezelter	2204	/** copy assignment operator */
96			RectMatrix<Real, Row, Col>& operator =(const RectMatrix<Real, Row, Col>& m) {
97			if (this == &m)
98			return *this;
99	tim	1630
100	gezelter	2204	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	tim	1564
106	gezelter	2204	/**
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	tim	1564
117	gezelter	2204	/**
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	tim	1630
125	gezelter	2204	return this->data_[i][j];
126			}
127	tim	1564
128	gezelter	2204	/**
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	tim	1644
140
141	gezelter	2204	/** Returns the pointer of internal array */
142			Real* getArrayPointer() {
143			return &this->data_[0][0];
144			}
145	tim	1564
146	gezelter	2204	/**
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	gezelter	2204	for (unsigned int i = 0; i < Row; i++)
155			v[i] = this->data_[row][i];
156	tim	1564
157	gezelter	2204	return v;
158			}
159	tim	1564
160	gezelter	2204	/**
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	gezelter	2204	for (unsigned int i = 0; i < Row; i++)
168			this->data_[row][i] = v[i];
169			}
170	tim	1564
171	gezelter	2204	/**
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	tim	1564
179	gezelter	2204	for (unsigned int j = 0; j < Col; j++)
180			v[j] = this->data_[j][col];
181	tim	1564
182	gezelter	2204	return v;
183			}
184	tim	1564
185	gezelter	2204	/**
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	tim	1564
192	gezelter	2204	for (unsigned int j = 0; j < Col; j++)
193			this->data_[j][col] = v[j];
194			}
195	tim	1594
196	gezelter	2204	/**
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	gezelter	2204	for (unsigned int k = 0; k < Col; k++)
205			std::swap(this->data_[i][k], this->data_[j][k]);
206			}
207	tim	1594
208	gezelter	2204	/**
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	tim	1630
216	gezelter	2204	for (unsigned int k = 0; k < Row; k++)
217			std::swap(this->data_[k][i], this->data_[k][j]);
218			}
219	tim	1564
220	gezelter	2204	/**
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	tim	1564
233	gezelter	2204	return true;
234			}
235	tim	1564
236	gezelter	2204	/**
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	gezelter	2204	/** 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	tim	1630
252	gezelter	2204	/**
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	tim	1630
262	gezelter	2204	/**
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	tim	1630
272	gezelter	2204	/**
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	tim	1630
283	gezelter	2204	/**
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	tim	1630
293	gezelter	2204	/**
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	tim	1564
304	gezelter	2204	/**
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	tim	1564
314	gezelter	2204	/**
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	tim	1564
325	gezelter	2204	/**
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	tim	1564
335	gezelter	2204	/**
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	tim	1564
346	gezelter	2204	/**
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	gezelter	2204	/**
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	gezelter	2204	/**
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	gezelter	2204	/**
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	gezelter	2204	/** Return the transpose of this matrix */
383			RectMatrix<Real, Col, Row> transpose() const{
384			RectMatrix<Real, Col, Row> result;
385	tim	1630
386	gezelter	2204	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	tim	1630
390	gezelter	2204	return result;
391			}
392	tim	1564
393	gezelter	2204	protected:
394			Real data_[Row][Col];
395			};
396	tim	1564
397	gezelter	2204	/** 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	tim	1564
402	gezelter	2204	result.negate();
403	tim	1564
404	gezelter	2204	return result;
405			}
406	tim	1564
407	gezelter	2204	/**
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	tim	1564
417	gezelter	2204	result.add(m1, m2);
418	tim	1564
419	gezelter	2204	return result;
420			}
421	tim	1564
422	gezelter	2204	/**
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	tim	1564
432	gezelter	2204	result.sub(m1, m2);
433	tim	1564
434	gezelter	2204	return result;
435			}
436	tim	1564
437	gezelter	2204	/**
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	tim	1564
447	gezelter	2204	result.mul(s, m);
448	tim	1564
449	gezelter	2204	return result;
450			}
451	tim	1564
452	gezelter	2204	/**
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	tim	1564
462	gezelter	2204	result.mul(s, m);
463	tim	1564
464	gezelter	2204	return result;
465			}
466	tim	1564
467	gezelter	2204	/**
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	tim	1564
477	gezelter	2204	for (unsigned int i = 0; i < Row; i++)
478			for (unsigned int j = 0; j < Col; j++)
479			for (unsigned int k = 0; k < SameDim; k++)
480			result(i, j) += m1(i, k) * m2(k, j);
481	tim	1564
482	gezelter	2204	return result;
483			}
484	tim	1564
485	gezelter	2204	/**
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	tim	1564
495	gezelter	2204	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	tim	1564
499	gezelter	2204	return result;
500			}
501	tim	1564
502	gezelter	2204	/**
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	tim	1564
512	gezelter	2204	result.div(s, m);
513	tim	1564
514	gezelter	2204	return result;
515			}
516	tim	1586
517	gezelter	2204	/**
518			* Write to an output stream
519			*/
520			template<typename Real, unsigned int Row, unsigned int Col>
521			std::ostream &operator<< ( std::ostream& o, const RectMatrix<Real, Row, Col>& m) {
522			for (unsigned int i = 0; i < Row ; i++) {
523			o << "(";
524			for (unsigned int j = 0; j < Col ; j++) {
525			o << m(i, j);
526			if (j != Col -1)
527			o << "\t";
528			}
529			o << ")" << std::endl;
530			}
531			return o;
532			}
533	tim	1564	}
534			#endif //MATH_RECTMATRIX_HPP