#include "SMatrix.h"

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

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

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

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

    public:

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

Data Members


    public:

      static const enum ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepSym<float,4> >:: kRows  
      static const enum ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepSym<float,4> >:: kCols  
      static const enum ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepSym<float,4> >:: kSize  
                                                          ROOT::Math::MatRepSym<float,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:14 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.