Description

template<typename FuncPtr = FreeMultiFunctionPtr>
class ROOT::Math::WrappedParamFunctionGen< FuncPtr >

WrappedParamGenFunction class to wrap any multi-dimensional function implementing the operator()(const double * ) in an interface-like IParamFunction, by fixing some of the variables and define them as parameters. i.e. transform any multi-dim function in a parametric function

Definition at line 140 of file WrappedParamFunction.h.

Inheritance diagram for ROOT::Math::WrappedParamFunctionGen< FuncPtr >:

[legend]

Collaboration diagram for ROOT::Math::WrappedParamFunctionGen< FuncPtr >:

[legend]

Public Types
typedef T	BackendType

typedef IBaseFunctionMultiDimTempl< double >	BaseFunc

Public Member Functions
	WrappedParamFunctionGen (const FuncPtr &func, unsigned int dim, unsigned int npar, const double par, const unsigned int idx)

	WrappedParamFunctionGen (FuncPtr &func, unsigned int dim, unsigned int npar, const double par, const unsigned int idx)

IMultiGenFunction *	Clone () const
	clone the function More...

unsigned int	NDim () const

unsigned int	NPar () const

double	operator() (const double *x) const

double	operator() (const double x, const double p) const

T	operator() (const T *x) const

virtual std::string	ParameterName (unsigned int i) const

const double *	Parameters () const

void	SetParameters (const double *p)

Private Member Functions
	WrappedParamFunctionGen (const WrappedParamFunctionGen &)

double	DoEval (const double *x) const
	evaluate the function (re-implement for being more efficient) More...

double	DoEvalPar (const double x, const double p) const

void	DoInit ()

WrappedParamFunctionGen &	operator= (const WrappedParamFunctionGen &)

void	SetParValues (unsigned int npar, const double *p) const

Private Attributes
unsigned int	fDim

FuncPtr	fFunc

std::vector< double >	fParams

std::vector< unsigned int >	fParIndices

std::vector< unsigned int >	fVarIndices

std::vector< double >	fX

Member Typedef Documentation

◆ BackendType

template<class T >

typedef T ROOT::Math::IBaseFunctionMultiDimTempl< T >::BackendType

inherited

Definition at line 66 of file IFunction.h.

◆ BaseFunc

typedef IBaseFunctionMultiDimTempl<double > ROOT::Math::IParametricFunctionMultiDimTempl< double >::BaseFunc

inherited

Definition at line 108 of file IParamFunction.h.

Constructor & Destructor Documentation

◆ WrappedParamFunctionGen() [1/3]

template<typename FuncPtr = FreeMultiFunctionPtr>

ROOT::Math::WrappedParamFunctionGen< FuncPtr >::WrappedParamFunctionGen	(	const FuncPtr &	func,
		unsigned int	dim,
		unsigned int	npar,
		const double *	par,
		const unsigned int *	idx
	)

inline

Constructor a wrapped function from a pointer to a generic callable object implemention operator()(const double *), the new function dimension, the number of parameters (number of fixed variables) and an array specifying the index of the fixed variables which becames parameters in the new API

Definition at line 149 of file WrappedParamFunction.h.

                                                                                                                                      :
       fFunc(func),
       fDim(dim),
       fParams(std::vector<double>(par,par+npar) ),
       fParIndices(std::vector<unsigned int>(idx, idx + npar) ),
       fX(std::vector<double>(npar+dim) )  // cached vector
    {
       DoInit();
    }

References ROOT::Math::WrappedParamFunctionGen< FuncPtr >::DoInit().

Referenced by ROOT::Math::WrappedParamFunctionGen< FuncPtr >::Clone().

Here is the call graph for this function:

◆ WrappedParamFunctionGen() [2/3]

template<typename FuncPtr = FreeMultiFunctionPtr>

ROOT::Math::WrappedParamFunctionGen< FuncPtr >::WrappedParamFunctionGen	(	FuncPtr &	func,
		unsigned int	dim,
		unsigned int	npar,
		const double *	par,
		const unsigned int *	idx
	)

inline

Constructor as before but taking now a non - const pointer to a callable object. This constructor is needed in the case FuncPtr is a std::unique_ptr which has a copy ctor taking non const objects

Definition at line 163 of file WrappedParamFunction.h.

                                                                                                                                :
       fFunc(func),
       fDim(dim),
       fParams(std::vector<double>(par,par+npar) ),
       fParIndices(std::vector<unsigned int>(idx, idx + npar) ),
       fX(std::vector<double>(npar+dim) ) // cached vector
    {
       DoInit();
    }

References ROOT::Math::WrappedParamFunctionGen< FuncPtr >::DoInit().

Here is the call graph for this function:

◆ WrappedParamFunctionGen() [3/3]

template<typename FuncPtr = FreeMultiFunctionPtr>

ROOT::Math::WrappedParamFunctionGen< FuncPtr >::WrappedParamFunctionGen ( const WrappedParamFunctionGen< FuncPtr > & )

private

Member Function Documentation

◆ Clone()

template<typename FuncPtr = FreeMultiFunctionPtr>

IMultiGenFunction* ROOT::Math::WrappedParamFunctionGen< FuncPtr >::Clone ( ) const

inlinevirtual

clone the function

Implements ROOT::Math::IBaseFunctionMultiDimTempl< T >.

Definition at line 174 of file WrappedParamFunction.h.

                                      {
       return new WrappedParamFunctionGen(fFunc, fDim, fParams.size(), fParams.empty() ? nullptr : &fParams.front(), fParIndices.empty() ? nullptr : &fParIndices.front());
    }

References ROOT::Math::WrappedParamFunctionGen< FuncPtr >::WrappedParamFunctionGen(), ROOT::Math::WrappedParamFunctionGen< FuncPtr >::fDim, ROOT::Math::WrappedParamFunctionGen< FuncPtr >::fFunc, ROOT::Math::WrappedParamFunctionGen< FuncPtr >::fParams, and ROOT::Math::WrappedParamFunctionGen< FuncPtr >::fParIndices.

Here is the call graph for this function:

◆ DoEval()

template<typename FuncPtr = FreeMultiFunctionPtr>

double ROOT::Math::WrappedParamFunctionGen< FuncPtr >::DoEval ( const double * x ) const

inlineprivatevirtual

evaluate the function (re-implement for being more efficient)

Reimplemented from ROOT::Math::IParametricFunctionMultiDimTempl< double >.

Definition at line 210 of file WrappedParamFunction.h.

                                          {
  
 //       std::cout << this << fDim << " x : ";
 //       std::ostream_iterator<double> oix(std::cout," ,  ");
 //       std::copy(x, x+fDim, oix);
 //       std::cout << std::endl;
 //       std::cout << "npar " << npar << std::endl;
 //       std::cout <<  fVarIndices.size() << std::endl;
 //       assert ( fVarIndices.size() == fDim);  // otherwise something is wrong
  
       for (unsigned int i = 0; i < fDim; ++i) {
          unsigned int j = fVarIndices[i];
          assert ( j  < NPar() + fDim);
          fX[ j ] = x[i];
       }
 //       std::cout << "X : (";
 //       std::ostream_iterator<double> oi(std::cout," ,  ");
 //       std::copy(fX.begin(), fX.end(), oi);
 //       std::cout << std::endl;
  
       return (*fFunc)( fX.empty() ? nullptr : &fX.front() );
    }

References ROOT::Math::WrappedParamFunctionGen< FuncPtr >::fDim, ROOT::Math::WrappedParamFunctionGen< FuncPtr >::fFunc, ROOT::Math::WrappedParamFunctionGen< FuncPtr >::fVarIndices, ROOT::Math::WrappedParamFunctionGen< FuncPtr >::fX, and ROOT::Math::WrappedParamFunctionGen< FuncPtr >::NPar().

Referenced by ROOT::Math::WrappedParamFunctionGen< FuncPtr >::DoEvalPar().

Here is the call graph for this function:

◆ DoEvalPar()

template<typename FuncPtr = FreeMultiFunctionPtr>

double ROOT::Math::WrappedParamFunctionGen< FuncPtr >::DoEvalPar	(	const double *	x,
		const double *	p
	)		const

inlineprivatevirtual

implement the required IParamFunction interface

Implements ROOT::Math::IParametricFunctionMultiDimTempl< double >.

Definition at line 237 of file WrappedParamFunction.h.

                                                                {
       SetParValues(NPar(), p);
       return DoEval(x);
    }

References ROOT::Math::WrappedParamFunctionGen< FuncPtr >::DoEval(), ROOT::Math::WrappedParamFunctionGen< FuncPtr >::NPar(), and ROOT::Math::WrappedParamFunctionGen< FuncPtr >::SetParValues().

Here is the call graph for this function:

◆ DoInit()

template<typename FuncPtr = FreeMultiFunctionPtr>

void ROOT::Math::WrappedParamFunctionGen< FuncPtr >::DoInit ( )

inlineprivate

Definition at line 243 of file WrappedParamFunction.h.

                  {
       // calculate variable indices and set in X the parameter values
       fVarIndices.reserve(fDim);
       unsigned int npar = NPar();
       for (unsigned int i = 0; i < npar + fDim; ++i) {
          bool isVar = true;
          for (unsigned int j = 0; j < npar; ++j) {
             if (fParIndices[j] == i) {
                isVar = false;
                break;
             }
          }
          if (isVar) fVarIndices.push_back(i);
       }
       assert ( fVarIndices.size() == fDim);  // otherwise something is wrong
  
 //       std::cout << "n variables " << fVarIndices.size() << std::endl;
 //       std::ostream_iterator<int> oi(std::cout,"  ");
 //       std::copy(fVarIndices.begin(), fVarIndices.end(), oi);
 //       std::cout << std::endl;
 //       assert( fVarIndices.size() == fDim);
 //       std::cout << this << std::endl;
  
       // set parameter values in fX
       SetParValues(npar, fParams.empty() ? nullptr : &fParams.front());
       for (unsigned int i = 0; i < npar; ++i) {
          unsigned int j = fParIndices[i];
          assert ( j  < npar + fDim);
          fX[j] = fParams[i];
       }
  
    }

References ROOT::Math::WrappedParamFunctionGen< FuncPtr >::fDim, ROOT::Math::WrappedParamFunctionGen< FuncPtr >::fParams, ROOT::Math::WrappedParamFunctionGen< FuncPtr >::fParIndices, ROOT::Math::WrappedParamFunctionGen< FuncPtr >::fVarIndices, ROOT::Math::WrappedParamFunctionGen< FuncPtr >::fX, ROOT::Math::WrappedParamFunctionGen< FuncPtr >::NPar(), and ROOT::Math::WrappedParamFunctionGen< FuncPtr >::SetParValues().

Referenced by ROOT::Math::WrappedParamFunctionGen< FuncPtr >::WrappedParamFunctionGen().

Here is the call graph for this function:

◆ NDim()

template<typename FuncPtr = FreeMultiFunctionPtr>

unsigned int ROOT::Math::WrappedParamFunctionGen< FuncPtr >::NDim ( ) const

inlinevirtual

Retrieve the dimension of the function

Implements ROOT::Math::IBaseFunctionMultiDimTempl< T >.

Definition at line 197 of file WrappedParamFunction.h.

197 { return fDim; }

References ROOT::Math::WrappedParamFunctionGen< FuncPtr >::fDim.

◆ NPar()

template<typename FuncPtr = FreeMultiFunctionPtr>

unsigned int ROOT::Math::WrappedParamFunctionGen< FuncPtr >::NPar ( ) const

inlinevirtual

Return the number of Parameters

Implements ROOT::Math::IBaseParam.

Definition at line 195 of file WrappedParamFunction.h.

195 { return fParams.size(); }

References ROOT::Math::WrappedParamFunctionGen< FuncPtr >::fParams.

Referenced by ROOT::Math::WrappedParamFunctionGen< FuncPtr >::DoEval(), ROOT::Math::WrappedParamFunctionGen< FuncPtr >::DoEvalPar(), ROOT::Math::WrappedParamFunctionGen< FuncPtr >::DoInit(), and ROOT::Math::WrappedParamFunctionGen< FuncPtr >::SetParameters().

◆ operator()() [1/3]

double ROOT::Math::IParametricFunctionMultiDimTempl< double >::operator() ( const T * x ) const

inlineinherited

Definition at line 125 of file IParamFunction.h.

          {
             return DoEval(x);
          }

◆ operator()() [2/3]

double ROOT::Math::IParametricFunctionMultiDimTempl< double >::operator()	(	const T *	x,
		const double *	p
	)		const

inlineinherited

Evaluate function at a point x and for given parameters p. This method does not change the internal status of the function (internal parameter values). If for some reason one prefers caching the parameter values, SetParameters(p) and then operator()(x) should be called. Use the pure virtual function DoEvalPar to implement it

Definition at line 120 of file IParamFunction.h.

          {
             return DoEvalPar(x, p);
          }

◆ operator()() [3/3]

template<class T >

T ROOT::Math::IBaseFunctionMultiDimTempl< T >::operator() ( const T * x ) const

inlineinherited

Evaluate the function at a point x[]. Use the pure virtual private method DoEval which must be implemented by the sub-classes

Definition at line 92 of file IFunction.h.

          {
             return DoEval(x);
          }

References ROOT::Math::IBaseFunctionMultiDimTempl< T >::DoEval().

Referenced by ROOT::Math::IGradientFunctionMultiDimTempl< T >::FdF().

Here is the call graph for this function:

◆ operator=()

template<typename FuncPtr = FreeMultiFunctionPtr>

WrappedParamFunctionGen& ROOT::Math::WrappedParamFunctionGen< FuncPtr >::operator= ( const WrappedParamFunctionGen< FuncPtr > & )

private

◆ ParameterName()

virtual std::string ROOT::Math::IBaseParam::ParameterName ( unsigned int i ) const

inlinevirtualinherited

Return the name of the i-th parameter (starting from zero) Overwrite if want to avoid the default name ("Par_0, Par_1, ...")

Definition at line 83 of file IParamFunction.h.

          {
             assert(i < NPar());
             return "Par_" + Util::ToString(i);
          }

References ROOT::Math::IBaseParam::NPar(), and ROOT::Math::Util::ToString().

Referenced by ROOT::Fit::FitConfig::CreateParamsSettings().

Here is the call graph for this function:

◆ Parameters()

template<typename FuncPtr = FreeMultiFunctionPtr>

const double* ROOT::Math::WrappedParamFunctionGen< FuncPtr >::Parameters ( ) const

inlinevirtual

Access the parameter values

Implements ROOT::Math::IBaseParam.

Definition at line 185 of file WrappedParamFunction.h.

                                      {
       return fParams.empty() ? nullptr : &fParams.front();
    }

References ROOT::Math::WrappedParamFunctionGen< FuncPtr >::fParams.

◆ SetParameters()

template<typename FuncPtr = FreeMultiFunctionPtr>

void ROOT::Math::WrappedParamFunctionGen< FuncPtr >::SetParameters ( const double * p )

inlinevirtual

Set the parameter values

Parameters

p	vector of doubles containing the parameter values.

to be defined: can user change number of params ? At the moment no.

Implements ROOT::Math::IBaseParam.

Definition at line 189 of file WrappedParamFunction.h.

                                          {
       unsigned int npar = NPar();
       std::copy(p, p+ npar, fParams.begin() );
       SetParValues(npar, p);
    }

References ROOT::Math::WrappedParamFunctionGen< FuncPtr >::fParams, ROOT::Math::WrappedParamFunctionGen< FuncPtr >::NPar(), and ROOT::Math::WrappedParamFunctionGen< FuncPtr >::SetParValues().

Here is the call graph for this function:

◆ SetParValues()

template<typename FuncPtr = FreeMultiFunctionPtr>

void ROOT::Math::WrappedParamFunctionGen< FuncPtr >::SetParValues	(	unsigned int	npar,
		const double *	p
	)		const

inlineprivate

Definition at line 278 of file WrappedParamFunction.h.

                                                                 {
       for (unsigned int i = 0; i < npar; ++i) {
          unsigned int j = fParIndices[i];
          assert ( j  < npar + fDim);
          fX[j] = p[i];
       }
    }