+
class ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >
-
#include "SMatrix.h"
Display options:
Show inherited
Show non-public

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


 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<()


 for platform specific configurations

Function Members (Methods)

public:
~SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >()
floatapply(unsigned int i) const
const float*Array() const
float*Array()
const float&At(unsigned int i, unsigned int j) const
float&At(unsigned int i, unsigned int j)
float*begin()
float*begin() const
ROOT::Math::SVector<float,2>Col(unsigned int thecol) const
boolDet(float& det)
boolDet2(float& det) const
ROOT::Math::SVector<float,2>Diagonal() const
float*end()
float*end() const
ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >Inverse(int& ifail) const
boolInvert()
boolIsInUse(const float* p) const
ROOT::Math::SVector<float,3>LowerBlock() const
booloperator!=(const float& rhs) const
booloperator!=(const ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >& rhs) const
const float&operator()(unsigned int i, unsigned int j) const
float&operator()(unsigned int i, unsigned int j)
ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >&operator*=(const float& rhs)
ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >&operator+=(const float& rhs)
ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >&operator-=(const float& rhs)
ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >&operator/=(const float& rhs)
booloperator<(const float& rhs) const
ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >&operator=(ROOT::Math::SMatrixIdentity)
ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >&operator=(const float& rhs)
ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >&operator=(const ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >&)
booloperator==(const float& rhs) const
booloperator>(const float& rhs) const
ostream&Print(ostream& os) const
ROOT::Math::SVector<float,2>Row(unsigned int therow) const
ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >()
ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >(ROOT::Math::SMatrixIdentity)
ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >(const ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >& rhs)
ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >(const float& rhs)
ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >(const ROOT::Math::SVector<float,3>& v, bool lower = true)
ROOT::Math::SVector<float,3>UpperBlock() const

Data Members

public:
enum { kRows
kCols
kSize
};
public:
ROOT::Math::MatRepSym<float,2>fRep

Class Charts

Inheritance Inherited Members Includes Libraries
Class Charts

Function documentation

SMatrix<T,D1,D2,R>& operator=(const M& rhs)
Assign from another compatible matrix.
Possible Symmetirc to general but NOT vice-versa

SMatrix<T,D1,D2,R>& operator=(const Expr<A,T,D1,D2,R2>& rhs)
Assign from a matrix expression

SMatrix<T,D1,D2,R> & operator=(SMatrixIdentity )
Assign from an identity matrix

T apply(unsigned int i) const
 @name --- Access functions --- 
 access the parse tree with the index starting from zero and
following the C convention for the order in accessing
the matrix elements.
Same convention for general and symmetric matrices.

const T* Array()
 return read-only pointer to internal array
 return pointer to internal array
T* Array()
iterator begin()
 @name --- STL-like interface ---
The iterators access the matrix element in the order how they are
stored in memory. The C (row-major) convention is used, and in the
case of symmetric matrices the iterator spans only the lower diagonal
block. For example for a symmetric 3x3 matrices the order of the 6
elements \f${a_0,...a_5}\f$ is:
\f[
M = \left( \begin{array}{ccc}
a_0 & a_1 & a_3  \\
a_1 & a_2  & a_4  \\
a_3 & a_4 & a_5   \end{array} \right)
\f]

 STL iterator interface. 
iterator end()
 STL iterator interface. 
const_iterator begin()
 STL const_iterator interface. 
const_iterator end()
 STL const_iterator interface. 
bool operator==(const float& rhs) const
 @name --- Operators --- 
 element wise comparison
 element wise comparison
bool operator!=(const T& rhs)
 element wise comparison
bool operator!=(const SMatrix<T,D1,D2,R>& rhs)
 element wise comparison
 element wise comparison
bool operator>(const float& rhs) const
 element wise comparison
 element wise comparison
bool operator<(const float& rhs) const
 element wise comparison
const T& operator()(unsigned int i, unsigned int j)
read only access to matrix element, with indices starting from 0


read/write access to matrix element with indices starting from 0

T& operator()(unsigned int i, unsigned int j)
const T& At(unsigned int i, unsigned int j)
read only access to matrix element, with indices starting from 0.
Fuction will check index values and it will assert if they are wrong


read/write access to matrix element with indices starting from 0.
Fuction will check index values and it will assert if they are wrong

T& At(unsigned int i, unsigned int j)
SMatrix<T,D1,D2,R>& operator+=(const float& rhs)
addition with a scalar

SMatrix<T,D1,D2,R>& operator-=(const float& rhs)
subtraction with a scalar

SMatrix<T,D1,D2,R>& operator*=(const float& rhs)
multiplication with a scalar

SMatrix<T,D1,D2,R>& operator/=(const float& rhs)
division with a scalar

bool Invert()
 @name --- Linear Algebra Functions --- 

Invert a square Matrix ( this method changes the current matrix).
Return true if inversion is successfull.
The method used for general square matrices is the LU factorization taken from Dinv routine
from the CERNLIB (written in C++ from CLHEP authors)
In case of symmetric matrices Bunch-Kaufman diagonal pivoting method is used
(The implementation is the one written by the CLHEP authors)

SMatrix<T,D1,D2,R> Inverse(int& ifail) const
Invert a square Matrix and  returns a new matrix. In case the inversion fails
the current matrix is returned.
\param ifail . ifail will be set to 0 when inversion is successfull.
See ROOT::Math::SMatrix::Invert for the inversion algorithm

bool Det(float& det)
determinant of square Matrix via Dfact.
Return true when the calculation is successfull.
\param det will contain the calculated determinant value
\b Note: this will destroy the contents of the Matrix!

bool Det2(float& det) const
determinant of square Matrix via Dfact.
Return true when the calculation is successfull.
\param det will contain the calculated determinant value
\b Note: this will preserve the content of the Matrix!

SVector<T,D2> Row(unsigned int therow) const
return a full Matrix row as a vector (copy the content in a new vector)

SVector<T,D1> Col(unsigned int thecol) const
return a full Matrix column as a vector (copy the content in a new vector)

SVector<T,D1> Diagonal()
return diagonal elements of a matrix as a Vector.
It works only for squared matrices D1 == D2, otherwise it will produce a compile error

SubVector UpperBlock()
SubVector LowerBlock()
bool IsInUse(const float* p) const
 @name --- Other Functions --- 

Function to check if a matrix is sharing same memory location of the passed pointer
This function is used by the expression templates to avoid the alias problem during
expression evaluation. When  the matrix is in use, for example in operations
like A = B * A, a temporary object storing the intermediate result is automatically
created when evaluating the expression.


std::ostream& Print(ostream& os) const
 submatrices
 Print: used by operator<<()

Last update: Mon Jun 25 19:40:43 2007

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.