class TMVA::Tools

 Return an enum representing the fundamental type passed in.

Function Members (Methods)

public:
~Tools()
Bool_tCheckSplines(const TH1*, const TSpline*)
const TString&Color(const TString&)
voidComputeStat(TTree* theTree, const TString theVarName, Double_t&, Double_t&, Double_t&, Double_t&, Double_t&, Double_t&, Bool_t norm = kFALSE)
Double_tComputeVariance(Double_t sumx2, Double_t sumx, Int_t nx)
Bool_tContainsRegularExpression(const TString& s)
voidFormattedOutput(const TMatrixD&, const vector<TString>&, TMVA::MsgLogger& logger)
voidFormattedOutput(const vector<Double_t>&, const vector<TString>&, const TString titleVars, const TString titleValues, TMVA::MsgLogger& logger, TString format = "%+1.3f")
const TMatrixD*GetCorrelationMatrix(const TMatrixD* covMat)
Int_tGetIndexMaxElement(vector<Double_t>&)
Int_tGetIndexMinElement(vector<Double_t>&)
Double_tGetSeparation(const TH1& S, const TH1& B) const
Double_tGetSeparation(const TMVA::PDF& pdfS, const TMVA::PDF& pdfB) const
TMatrixD*GetSQRootMatrix(TMatrixDSym* symMat)
static TMVA::Tools&Instance()
TMVA::MsgLogger&Logger() const
vector<Double_t>MVADiff(vector<Double_t>&, vector<Double_t>&)
Double_tNormHist(TH1* theHist, Double_t norm = 1.0)
Double_tNormVariable(Double_t x, Double_t xmin, Double_t xmax)
vector<Int_t>*ParseANNOptionString(TString theOptions, Int_t nvar, vector<Int_t>* nodes)
TList*ParseFormatLine(TString theString, const char* sep = ":")
TH1*ProjNormTH1F(TTree* theTree, TString theVarName, TString name, Int_t nbins, Double_t xmin, Double_t xmax, TString cut)
voidReadFloatArbitraryPrecision(Float_t& val, istream& is)
TStringReplaceRegularExpressions(const TString& s, const TString& replace = "+")
voidROOTVersionMessage(TMVA::MsgLogger& logger)
voidScale(vector<Double_t>&, Double_t)
voidScale(vector<Float_t>&, Float_t)
voidTMVAVersionMessage(TMVA::MsgLogger& logger)
voidTMVAWelcomeMessage()
voidTMVAWelcomeMessage(TMVA::MsgLogger& logger, TMVA::Tools::EWelcomeMessage m = kStandardWelcomeMsg)
TMVA::ToolsTools(const TMVA::Tools&)
voidUsefulSortAscending(vector<std::vector<Double_t> >&)
voidUsefulSortAscending(vector<Double_t>&)
voidUsefulSortDescending(vector<Double_t>&)
voidUsefulSortDescending(vector<std::vector<Double_t> >&, vector<TString>* vs = 0)
voidWriteFloatArbitraryPrecision(Float_t val, ostream& os)
private:
TMVA::ToolsTools()

Data Members

public:
enum EWelcomeMessage { kStandardWelcomeMsg
kIsometricWelcomeMsg
kBlockWelcomeMsg
kLeanWelcomeMsg
kLogoWelcomeMsg
kSmall1WelcomeMsg
kSmall2WelcomeMsg
kOriginalWelcomeMsgColor
kOriginalWelcomeMsgBW
};
public:
TMVA::MsgLogger*fLogger
const TStringfRegexp
static TMVA::Tools*fgTools

Class Charts

Inheritance Inherited Members Includes Libraries
Class Charts

Function documentation

Double_t ComputeVariance(Double_t sumx2, Double_t sumx, Int_t nx)




 Tools(const TMVA::Tools& )




 ~Tools()


 destructor





Tools& Instance()


 accessor to single instance




{ return fgTools?*(fgTools): *(fgTools = new Tools()); }






void ComputeStat(TTree* theTree, const TString theVarName, Double_t& , Double_t& , Double_t& , Double_t& , Double_t& , Double_t& , Bool_t norm = kFALSE)


 simple statistics operations on tree entries





TH1* ProjNormTH1F(TTree* theTree, TString theVarName, TString name, Int_t nbins, Double_t xmin, Double_t xmax, TString cut)


 creates histograms normalized to one





TList* ParseFormatLine(TString theString, const char* sep = ":")


 parser for TString phrase with items separated by a character





std::vector<Int_t>* ParseANNOptionString(TString theOptions, Int_t nvar, vector<Int_t>* nodes)


 parse option string for ANN methods





const TMatrixD* GetCorrelationMatrix(const TMatrixD* covMat)


 turns covariance into correlation matrix





Bool_t CheckSplines(const TH1* , const TSpline* )


 check spline quality by comparison with initial histogram





Double_t NormVariable(Double_t x, Double_t xmin, Double_t xmax)


 normalization of variable output





Double_t GetSeparation( const TH1& S, const TH1& B )


 return separation of two histograms or PDFs





Double_t GetSeparation( const PDF& pdfS, const PDF& pdfB )




std::vector<Double_t> MVADiff(vector<Double_t>& , vector<Double_t>& )


 vector rescaling





void Scale( std::vector<Double_t>&, Double_t )




void Scale( std::vector<Float_t>&,  Float_t  )




void UsefulSortDescending(vector<std::vector<Double_t> >& , vector<TString>* vs = 0)


 re-arrange a vector of arrays (vectors) in a way such that the first array
 is ordered, and the other arrays reshuffeld accordingly





void UsefulSortAscending( std::vector< std::vector<Double_t> >& )




void UsefulSortDescending(vector<Double_t>& )




void UsefulSortAscending( std::vector<Double_t>& )




Int_t GetIndexMaxElement(vector<Double_t>& )




Int_t GetIndexMinElement(vector<Double_t>& )




Bool_t ContainsRegularExpression(const TString& s)


 check if input string contains regular expression





TString ReplaceRegularExpressions(const TString& s, const TString& replace = "+")




void FormattedOutput(const vector<Double_t>& , const vector<TString>& , const TString titleVars, const TString titleValues, TMVA::MsgLogger& logger, TString format = "%+1.3f")


 routines for formatted output -----------------





void WriteFloatArbitraryPrecision(Float_t val, ostream& os)




void ReadFloatArbitraryPrecision(Float_t& val, istream& is)




const TString& Color(const TString& )




void TMVAWelcomeMessage()




void TMVAWelcomeMessage(TMVA::MsgLogger& logger, TMVA::Tools::EWelcomeMessage m = kStandardWelcomeMsg)




void TMVAVersionMessage(TMVA::MsgLogger& logger)




void ROOTVersionMessage(TMVA::MsgLogger& logger)







Author:  Andreas Hoecker,  Joerg Stelzer,  Helge Voss,  Kai Voss 

Last change: root/tmva $Id: Tools.h 26085 2008-11-05 16:34:45Z pcanal $   

Last generated: 2008-11-11 12:37

Copyright   (c) 2005:                                                            *




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.