SMatrix.hh

Go to the documentation of this file.

#ifndef __SMATRIX_HH
#define __SMATRIX_HH
// ********************************************************************
//
// source:
//
// type:      source code
//
// created:   20. Mar 2001
//
// author:    Thorsten Glebe
//            HERA-B Collaboration
//            Max-Planck-Institut fuer Kernphysik
//            Saupfercheckweg 1
//            69117 Heidelberg
//            Germany
//            E-mail: T.Glebe@mpi-hd.mpg.de
//
// Description: A fixed size two dimensional Matrix class
//
// changes:
// 20 Mar 2001 (TG) creation
// 21 Mar 2001 (TG) added operators +=, -=, *=, /=
// 26 Mar 2001 (TG) place_in_row(), place_in_col() added
// 02 Apr 2001 (TG) non-const Array() added
// 03 Apr 2001 (TG) invert() added
// 07 Apr 2001 (TG) CTOR from SVertex (dyadic product) added
// 09 Apr 2001 (TG) CTOR from array added
// 11 Apr 2001 (TG) rows(), cols(), size() replaced by rows, cols, size
// 25 Mai 2001 (TG) row(), col() added
// 04 Sep 2001 (TG) moved inlined functions to .icc file
// 11 Jan 2002 (TG) added operator==(), operator!=()
// 14 Jan 2002 (TG) added more operator==(), operator!=(), operator>(), operator<()
//
// ********************************************************************
#include <iosfwd>
 
template <class T, unsigned int D> class SVector;
 
// expression engine
#include "Expression.hh"
 
//==============================================================================
// SMatrix: column-wise storage
//==============================================================================
template <class T, unsigned int D1, unsigned int D2 = D1>
class SMatrix {
public:
  typedef T  value_type;
  
  SMatrix();
  SMatrix(const SMatrix<T,D1,D2>& rhs);
  template <class A>
  SMatrix(const Expr<A,T,D1,D2>& rhs);
  SMatrix(const T& rhs, const bool diagonal=false);
  SMatrix(const SVector<T,D1>& rhs);
  template <class A>
  SMatrix(const Expr<A,T,D1>& rhs);
  template <class T1>
  SMatrix(const T1* a, const bool triang=false, const unsigned int len=D1*D2);
 
  SMatrix<T,D1,D2>& operator=(const T& rhs);
  template <class A>
  SMatrix<T,D1,D2>& operator=(const Expr<A,T,D1,D2>& rhs);
 
  static const unsigned int rows = D1;
  static const unsigned int cols = D2;
  static const unsigned int size = D1*D2;
 
  T apply(unsigned int i) const;
  const T* Array() const;
  T* Array();
 
  bool operator==(const T& rhs) const;
  bool operator!=(const T& rhs) const;
  bool operator==(const SMatrix<T,D1,D2>& rhs) const;
  bool operator!=(const SMatrix<T,D1,D2>& rhs) const;
  template <class A>
  bool operator==(const Expr<A,T,D1,D2>& rhs) const;
  template <class A>
  bool operator!=(const Expr<A,T,D1,D2>& rhs) const;
 
  bool operator>(const T& rhs) const;
  bool operator<(const T& rhs) const;
  bool operator>(const SMatrix<T,D1,D2>& rhs) const;
  bool operator<(const SMatrix<T,D1,D2>& rhs) const;
  template <class A>
  bool operator>(const Expr<A,T,D1,D2>& rhs) const;
  template <class A>
  bool operator<(const Expr<A,T,D1,D2>& rhs) const;
 
  const T& operator()(unsigned int i, unsigned int j) const;
  T& operator()(unsigned int i, unsigned int j);
  SMatrix<T,D1,D2>& operator+=(const SMatrix<T,D1,D2>& rhs);
  template <class A>
  SMatrix<T,D1,D2>& operator+=(const Expr<A,T,D1,D2>& rhs);
  SMatrix<T,D1,D2>& operator-=(const SMatrix<T,D1,D2>& rhs);
  template <class A>
  SMatrix<T,D1,D2>& operator-=(const Expr<A,T,D1,D2>& rhs);
  SMatrix<T,D1,D2>& operator*=(const SMatrix<T,D1,D2>& rhs);
  template <class A>
  SMatrix<T,D1,D2>& operator*=(const Expr<A,T,D1,D2>& rhs);
  SMatrix<T,D1,D2>& operator/=(const SMatrix<T,D1,D2>& rhs);
  template <class A>
  SMatrix<T,D1,D2>& operator/=(const Expr<A,T,D1,D2>& rhs);
 
  bool sinvert();
  bool sdet(T& det);
  bool invert();
  bool det(T& det);
  template <unsigned int D>
  SMatrix<T,D1,D2>& place_in_row(const SVector<T,D>& rhs,
                 const unsigned int row,
                 const unsigned int col);
  template <class A, unsigned int D>
  SMatrix<T,D1,D2>& place_in_row(const Expr<A,T,D>& rhs,
                 const unsigned int row,
                 const unsigned int col);
  template <unsigned int D>
  SMatrix<T,D1,D2>& place_in_col(const SVector<T,D>& rhs,
                 const unsigned int row,
                 const unsigned int col);
  template <class A, unsigned int D>
  SMatrix<T,D1,D2>& place_in_col(const Expr<A,T,D>& rhs,
                 const unsigned int row,
                 const unsigned int col);
  template <unsigned int D3, unsigned int D4>
  SMatrix<T,D1,D2>& place_at(const SMatrix<T,D3,D4>& rhs,
                 const unsigned int row,
                 const unsigned int col);
  template <class A, unsigned int D3, unsigned int D4>
  SMatrix<T,D1,D2>& place_at(const Expr<A,T,D3,D4>& rhs,
                 const unsigned int row,
                 const unsigned int col);
  SVector<T,D2> row(const unsigned int therow) const;
  SVector<T,D1> col(const unsigned int thecol) const;
  std::ostream& print(std::ostream& os) const;
 
private:
  T array[D1*D2];
}; // end of class SMatrix
 
//==============================================================================
// operator<<
//==============================================================================
template <class T, unsigned int D1, unsigned int D2>
inline std::ostream& operator<<(std::ostream& os, const SMatrix<T,D1,D2>& rhs) {
  return rhs.print(os);
}
 
#include "SMatrix.icc"
// include Matrix-Vector multiplication
#include "MatrixFunctions.hh"
 
#endif