Tools/Math/LA_Matrix.h

Go to the documentation of this file.

//------------------------------------------------------------------------------
/**
 * @file LA_Matrix.h
 * Contains class LinAlg::Matrix
 *
 * @author <a href="mailto:stefanuhrig@gmx.net">Stefan Uhrig</a>
 */
//------------------------------------------------------------------------------
#ifndef LINALG_MATRIX_H_INCLUDED
#define LINALG_MATRIX_H_INCLUDED
//------------------------------------------------------------------------------
#include <cstdlib>
#include <iosfwd>
#include <string>
#include "Tools/Streams/InOut.h"
#include "LA_Exception.h"
#include "LA_Vector.h"
#include "Matrix.h"
//------------------------------------------------------------------------------
namespace LA
{
//------------------------------------------------------------------------------
/**
 * Represents a nxm Matrix with entries of type double. 
 *
 * @author <a href="mailto:stefanuhrig@gmx.net">Stefan Uhrig</a>
 */
class Matrix
{
public:
  /**
   * Standard constructor. Contructs an empty matrix.
   */
  Matrix();
  
  /**
   * Constructs a nxm matrix and initializes all entries to 0.0.
   * @param rows Number of rows (n)
   * @param columns Number of columns (m)
   */
  Matrix(int rows, int columns);
  
  /**
   * Constructs a nxm matrix and initializes the entries to the values
   * in the passed array (row major).
   * @param rows Number of rows (n)
   * @param columns Number of columns (m)
   * @param M Array with values that are used to initialize the matrix.
   */
  Matrix(int rows, int columns, const double* M);
  
  /**
   * Copy contructor.
   * @param M Matrix to copy.
   * @return Reference to this matrix.
   */
  Matrix(const Matrix& M);
  
  /**
   * Copy contructor.
   * @param M Matrix to copy.
   * @return Reference to this matrix.
   */
  Matrix(const Matrix3x3<double>& M);

  /**
   * Returns a nxn identity matrix.
   * @param dim Dimension of matrix (n).
   * @return Identity matrix.
   */
  static Matrix identity(int dim);
  
  /**
   * Destructor.
   */
  virtual ~Matrix();

public:
  /**
   * Copy operator.
   * @param M Matrix to copy.
   * @return Reference to this matrix.
   */
  Matrix& operator=(const Matrix& M);

  /**
   * Copy operator.
   * @param M Matrix3x3 to copy.
   * @return Reference to this matrix.
   */
  Matrix& operator=(const Matrix3x3<double>& M);
  
  /**
   * Recreates this matrix as nxm matrix and initializes all values to 0.0.
   * @param rows Number of rows (n).
   * @param columns Number of columns (m).
   */
  void create(int rows, int columns);
  
  /**
   * Recreates this matrix as nxm matrix and initializes the entries to
   * the values in the passed array (row major).
   * @param rows Number of rows (n).
   * @param columns Number of columns (m).
   * @param M Array with values that are used to initialize the matrix.
   */
  void create(int rows, int columns, const double* M);
  
  /**
   * Constant element access operator.
   * @param row Index of row (zero-based).
   * @return Constant reference to appropriate row vector.
   */
  const Vector& operator[](int row) const;
  
  /**
   * Element access operator.
   * @param row Index of row (zero-based).
   * @return Reference to appropriate row vector.
   */
  Vector& operator[](int row);
  
  /**
   * Constant element access operator.
   * @param row Index of row (one-based).
   * @return Constant reference to appropriate row vector.
   */
  const Vector& operator()(int row) const;
  
  /**
   * Element access operator.
   * @param row Index of row (one-based).
   * @return Reference to appropriate row vector.
   */
  Vector& operator()(int row);
  
  /**
   * Constant element access operator.
   * @param row Index of row (one-based).
   * @param column Index of column (one-based).
   * @return Constant reference to appropriate entry.
   */
  const double& operator()(int row, int column) const;
  
  /**
   * Element access operator.
   * @param row Index of row (one-based).
   * @param column Index of column (one-based).
   * @return Reference to appropriate entry.
   */
  double& operator()(int row, int column);
  
  /**
   * Returns the number of rows (n).
   * @return Number of rows (n).
   */
  int rows() const;
  
  /**
   * Returns the number of columns (m).
   * @return Number of columns (m).
   */
  int columns() const;

  /**
   * Returns a row vector.
   * @param index Index of row (one-based).
   * @return Row vector with specified index.
   */
  Vector get_row(int index) const;
  
  /**
   * Sets a row vector.
   * @param index Index of row (one-based).
   * @param v Vector the row is set to.
   */
  void set_row(int index, const Vector& v);
  
  /**
   * Returns a column vector.
   * @param index Index of column (one-based).
   * @return Column vector with specified index.
   */
  Vector get_column(int index) const;
  
  /**
   * Sets a column vector.
   * @param index Index of column (one-based).
   * @param v Vector the column is set to.
   */
  void set_column(int index, const Vector& v);

  /**
   * Retrieves a submatrix.
   * @param rowstart The index of the row where to start (one-based).
   * @param rowlength The number of rows to extract.
   * @param columnstart The index of the column where to start (one-based).
   * @param columnlength The number of columns to extract.
   * @return The appropriate submatrix.
   */
  Matrix get_sub(int rowstart, int rowlength,
                 int columnstart, int columnlength) const;

  /**
   * Sets a submatrix
   * @param rowstart The row where to start
   * @param columnstart The column where to start
   * @param M The submatrix to set.
   */
  void set_sub(int rowstart, int columnstart, const Matrix& M);

  /**
   * Adds a matrix to this matrix.
   * @param M Matrix to add.
   * @return Reference to this matrix.
   */
  Matrix& operator+=(const Matrix& M);
  
  /**
   * Subtracts a matrix from this matrix.
   * @param M Matrix to subtract.
   * @return Reference to this matrix.
   */
  Matrix& operator-=(const Matrix& M);
  
  /**
   * Multiplies this matrix with another matrix.
   * @param M Matrix to multiply this matrix with.
   * @return Reference to this matrix.
   */
  Matrix& operator*=(const Matrix& M);
  
  /**
   * Multiplies all entries of this matrix with the passed scalar.
   * @param s Scalar to multiply this matrix with.
   * @return Reference to this matrix.
   */
  Matrix& operator*=(const double& s);
  
  /**
   * Divides this matrix by the passed matrix (multiplies this matrix with
   * the inverse of the passed matrix).
   * @param M Matrix to divide this matrix by.
   * @return Reference to this matrix.
   */
  Matrix& operator/=(const Matrix& M);
  
  /**
   * Divides all entries of this matrix by the passed scalar.
   * @param s Scalar to divide this matrix by.
   * @return Reference to this matrix.
   */
  Matrix& operator/=(const double& s);

  /**
   * Transposes the matrix.
   */
  void transpose();
  
  /**
   * Returns the transposition of this matrix.
   * @return Transposition of this matrix.
   */
  Matrix transposition() const;
  
  /**
   * Returns the transposition of this matrix.
   * @return Transposition of this matrix.
   */
  Matrix T() const;
  
  /**
   * Inverts this matrix.
   */
  void invert();
  
  /**
   * Returns the inverse of this matrix.
   * @return Inverse of this matrix.
   */
  Matrix inverse() const;
  
  /**
   * Solves the linear equation Ax=b where A is this matrix.
   * @param b A vector.
   * @return The solution vector x.
   */
  Vector solve(const Vector& b);

  /**
   * Returns the determinant of this matrix.
   * @return The determinant of this matrix.
   */
  double det() const;

  /**
   * Returns a human-readable representation of the matrix.
   * @return Human-readable representation of the matrix.
   */
  std::string asString() const;

private:
  void destroy();

private:
  int r;
  int c;
  Vector* content;

  friend Matrix operator+(const Matrix& M1, const Matrix& M2);
  friend Matrix operator-(const Matrix& M1, const Matrix& M2);
  friend Matrix operator*(const Matrix& M1, const Matrix& M2);
  friend Vector operator*(const Matrix& M, const Vector& v);
  friend Matrix operator*(const Matrix& M, const double& s);
  friend Matrix operator*(const double& s, const Matrix& M);
  friend Matrix operator/(const Matrix& M, const double& s);
  friend Matrix operator/(const Matrix& M1, const Matrix& M2);
  friend Matrix transpose(const Matrix& M);
  friend Matrix invert(const Matrix& M);
  friend Matrix inv(const Matrix& M);
  friend double det(const Matrix& M);
  friend Out& operator<<(Out& stream, const Matrix& M);
  friend In& operator>>(In& stream, Matrix& M);
};
//------------------------------------------------------------------------------

/**
 * Adds to matrices.
 * @param M1 First matrix.
 * @param M2 Second matrix.
 * @return M1 + M2.
 */
Matrix operator+(const Matrix& M1, const Matrix& M2);

/**
 * Subtracts to matrices.
 * @param M1 First matrix.
 * @param M2 Second matrix.
 * @return M1 - M2.
 */
Matrix operator-(const Matrix& M1, const Matrix& M2);

/**
 * Multiplies to matrices.
 * @param M1 First matrix.
 * @param M2 Second matrix.
 * @return M1*M2.
 */
Matrix operator*(const Matrix& M1, const Matrix& M2);

/**
 * Multiplies a matrix with a vector.
 * @param M A matrix.
 * @param v A vector.
 * @return M*v.
 */
Vector operator*(const Matrix& M, const Vector& v);

/**
 * Multiplies a matrix with a scalar.
 * @param M Matrix.
 * @param s Scalar.
 * @return M*s.
 */
Matrix operator*(const Matrix& M, const double& s);

/**
 * Multiplies a matrix with a scalar.
 * @param s Scalar.
 * @param M Matrix.
 * @return s*M.
 */
Matrix operator*(const double& s, const Matrix& M);

/**
 * Divides a matrix by a scalar.
 * @param M Matrix.
 * @param s Scalar.
 * @return M/s.
 */
Matrix operator/(const Matrix& M, const double& s);

/**
 * Divides a matrix by another matrix (same as multiplying with the inverse).
 * @param M1 First matrix.
 * @param M2 Second matrix.
 * @return M1/M2 (M1*inv(M2))
 */
Matrix operator/(const Matrix& M1, const Matrix& M2);

/**
 * Returns the transposition of a matrix.
 * @param M Matrix.
 * @return Transposition of matrix.
 */
Matrix transpose(const Matrix& M);

/**
 * Returns the inverse of a matrix.
 * @param M Matrix.
 * @return Inverse of matrix.
 */
Matrix invert(const Matrix& M);

/**
 * Returns the inverse of a matrix.
 * @param M Matrix.
 * @return Inverse of matrix.
 */
Matrix inv(const Matrix& M);

/**
 * Returns the determinant of a matrix.
 * @param M Matrix.
 * @return Determinant of matrix.
 */
double det(const Matrix& M);
//------------------------------------------------------------------------------

/**
 * Prints a user-readable representation of a matrix.
 * @param out An ostream.
 * @param M Matrix to output.
 * @return Reference to passed ostream.
 */
std::ostream& operator<<(std::ostream& out, const Matrix& M);

/**
 * Out operator for GT-streams.
 * @param stream Out-stream.
 * @param v Vector to output.
 * @return Reference to passed Out-stream.
 */
Out& operator<<(Out& stream, const Matrix& M);

/**
 * In operator for GT-streams.
 * @param stream In-stream.
 * @param v Vector to read to.
 * @return Reference to passed In-stream.
 */
In& operator>>(In& stream, Matrix& M);
//------------------------------------------------------------------------------
}
//------------------------------------------------------------------------------
#endif
//------------------------------------------------------------------------------

---