#include "SMatrix.h"

ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >

class description - header file - source file - inheritance tree (.pdf)

class ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >

Inheritance Chart:
ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >
 

    public:

                                                                                       ~SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >()
                                                                                double apply(unsigned int i) const
                                                                         const double* Array() const
                                                                               double* Array()
            ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >::iterator begin()
      ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >::const_iterator begin() const
                                                         ROOT::Math::SVector<double,4> Col(unsigned int thecol) const
                                                                                  bool Det(double& det)
                                                                                  bool Det2(double& det) const
                                                         ROOT::Math::SVector<double,4> Diagonal() const
            ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >::iterator end()
      ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >::const_iterator end() const
                      ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> > Inverse(int& ifail) const
                                                                                  bool Invert()
                                                                                  bool IsInUse(const double* p) const
                                                 ROOT::Math::SVector<double,4*(4+1)/2> LowerBlock() const
                                                                                  bool operator!=(const double& rhs) const
                                                                                  bool operator!=(const ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >& rhs) const
                                                                         const double& operator()(unsigned int i, unsigned int j) const
                                                                               double& operator()(unsigned int i, unsigned int j)
                     ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >& operator*=(const double& rhs)
                     ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >& operator+=(const double& rhs)
                     ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >& operator-=(const double& rhs)
                     ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >& operator/=(const double& rhs)
                                                                                  bool operator<(const double& rhs) const
                     ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >& operator=(ROOT::Math::SMatrixIdentity)
                     ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >& operator=(const double& rhs)
                     ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >& operator=(const ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >&)
                                                                                  bool operator==(const double& rhs) const
                                                                                  bool operator>(const double& rhs) const
                                                                              ostream& Print(ostream& os) const
                                                         ROOT::Math::SVector<double,4> Row(unsigned int therow) const
                                                                                       SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >()
                                                                                       SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >(ROOT::Math::SMatrixIdentity)
                                                                                       SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >(const ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >& rhs)
                                                                                       SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >(const ROOT::Math::SVector<double,4*(4+1)/2>& v, bool lower = true)
                                                                                       SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >(const double& rhs)
                                                 ROOT::Math::SVector<double,4*(4+1)/2> UpperBlock() const

Data Members


    public:

      static const enum ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >:: kRows  
      static const enum ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >:: kCols  
      static const enum ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >:: kSize  
                                                           ROOT::Math::MatRepSym<double,4> fRep

Class Description

SMatrix<T,D1,D2,R>& operator=(const M& rhs)


SMatrix<T,D1,D2,R>& operator=(const Expr<A,T,D1,D2,R2>& rhs)




SMatrix<T,D1,D2,R> & operator=(SMatrixIdentity )




T apply(unsigned int i)




const T* Array()


/ return read-only pointer to internal array



T* Array()


/ return pointer to internal array



iterator begin()




iterator end()




const_iterator begin()




const_iterator end()




bool operator==(const T& rhs)


/ element wise comparison



bool operator!=(const T& rhs)


/ element wise comparison



bool operator!=(const SMatrix<T,D1,D2,R>& rhs)


/ element wise comparison



bool operator>(const T& rhs)


/ element wise comparison



bool operator<(const T& rhs)


/ element wise comparison



const T& operator()(unsigned int i, unsigned int j)




T& operator()(unsigned int i, unsigned int j)




SMatrix<T,D1,D2,R>& operator+=(const Expr<A,T,D1,D2,R2>& rhs)




SMatrix<T,D1,D2,R>& operator-=(const T& rhs)




SMatrix<T,D1,D2,R>& operator*=(const T& rhs)




SMatrix<T,D1,D2,R>& operator/=(const T& rhs)




bool Invert()




SMatrix<T,D1,D2,R> Inverse(int & ifail )




bool Det(T& det)




bool Det2(T& det)




SVector<T,D2> Row(unsigned int therow)




SVector<T,D1> Col(unsigned int thecol)




SVector<T,D1> Diagonal()




SubVector UpperBlock()




SubVector LowerBlock()




bool IsInUse(const T* p)




std::ostream& Print(std::ostream& os)


/ Print: used by operator<<()






Last update: Tue Jul 11 11:47:04 2006









ROOT page - Class index - Class Hierarchy - Top of the page









This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.