VtSymMatrix.hh

Go to the documentation of this file.

#ifndef __VTSYMMATRIX
#define __VTSYMMATRIX
// *****************************************************************************
//
// source:
//
// type:      source code
//
// created:   21. Aug 2000
//
// 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: class for symmetric matrices
//
// changes:
// 21 Aug 2000 (TG) creation
// 04 Sep 2000 (TG) modified return type of dsinv()
// 10 Okt 2000 (TG) copy() member function added.
// 17 Okt 2000 (TG) copy constructor added, comments added
// 24 Okt 2000 (TG) added operator+=, operator-= (on matrices)
// 27 Okt 2000 (TG) modified operator<< for CINT
// 05 Feb 2001 (TG) renamed Assert() to VtAssert()
//
// *****************************************************************************
 
#include "VtSqMatrix.hh"
 
#ifdef WIN32
#   include "Rtypes.h"
#endif
 
void Dsinv1(int *idim, double *a, int *n, int *ifail);
void Dsfact1(int *idim, double *a, int *n, int *ifail, double *det, int *jfail);
 
namespace MATRIX {
  class VtVector;
 
  //============================================================================
  // Class VtSymMatrix: base class for covariance matrices (symm, pos. def.)
  //============================================================================
  class VtSymMatrix : public VtSqMatrix {
  public:
    VtSymMatrix(const unsigned int dim) : VtSqMatrix(dim) {}
    VtSymMatrix(const unsigned int dim, double diag);
    VtSymMatrix(const VtSymMatrix& rhs);
    VtSymMatrix(const VtSqMatrix& rhs) : VtSqMatrix(rhs) {
      //      Assert();
    }
    VtSymMatrix(const VtMatrix& rhs) : VtSqMatrix(rhs) {
      //      Assert();
    }
    virtual ~VtSymMatrix();
   
    bool invert(const bool use_momentum);
    bool VtDsinv(int dim = 0);
    const VtSymMatrix dsinv(int dim = 0) const;
    virtual double det() const;
    double product(const VtVector& rhs, unsigned int dim = 0) const;
    const VtSymMatrix product(const VtMatrix& rhs) const;
    virtual void place_at(const VtMatrix& rhs,
              const unsigned int row,
              const unsigned int col);
    void copy(const VtSymMatrix& rhs);
 
    const VtSymMatrix& operator=(const VtSymMatrix& rhs);
 
    const VtSymMatrix&   operator+=(const double rhs);
    const VtSymMatrix&   operator-=(const double rhs);
    const VtSymMatrix&   operator*=(const double rhs);
    const VtSymMatrix&   operator/=(const double rhs);
    const VtSymMatrix& operator+=(const VtSymMatrix& rhs);
    const VtSymMatrix& operator-=(const VtSymMatrix& rhs);
 
    const VtSymMatrix  operator+(const VtSymMatrix& rhs) const;
    const VtSqMatrix   operator+(const VtSqMatrix&  rhs) const;
    const VtMatrix     operator+(const VtMatrix&    rhs) const;
    const VtSymMatrix  operator-(const VtSymMatrix& rhs) const;
    const VtSymMatrix  operator-(void)                   const;
    const VtSqMatrix   operator-(const VtSqMatrix&  rhs) const;
    const VtMatrix     operator-(const VtMatrix&    rhs) const;
    const VtSqMatrix   operator*(const VtSymMatrix& rhs) const;
    const VtSqMatrix   operator*(const VtSqMatrix&  rhs) const;
    const VtMatrix     operator*(const VtMatrix&    rhs) const;
    const VtVector     operator*(const VtVector&    rhs) const;
 
    virtual void print(std::ostream& os) const;
 
  private:
    void VtAssert(void);
 
#ifdef WIN32
  ClassDef(VtSymMatrix,0)
#endif
  };
  
  //============================================================================
  // operator<<
  //============================================================================
  inline std::ostream& operator<< ( std::ostream& os, const VtSymMatrix& t ) {
    t.print(os);
    return os;
  }
 
} // end of namespace MATRIX
#endif