1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
// @(#)root/mathmore:$Id$
// Author: L. Moneta June 2009
/**********************************************************************
* *
* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *
* *
* *
**********************************************************************/
// Header file for class MinimTransformFunction
#ifndef ROOT_Math_MinimTransformFunction
#define ROOT_Math_MinimTransformFunction
#include "Math/IFunction.h"
#include "Math/MinimTransformVariable.h"
#include <vector>
#include <map>
namespace ROOT {
namespace Math {
/**
MinimTransformFunction class to perform a transformations on the
variables to deal with fixed or limited variables (support both double and single bounds)
The class manages the passed function pointer
@ingroup MultiMin
*/
class MinimTransformFunction : public IMultiGradFunction {
public:
typedef ROOT::Math::IMultiGradFunction BaseGradFunc;
typedef ROOT::Math::IMultiGradFunction::BaseFunc BaseFunc;
/**
Constructor from a IMultiGradFunction interface (which is managed by the class)
vector specifying the variable types (free, bounded or fixed, defined in enum EMinimVariableTypes )
variable values (used for the fixed ones) and a map with the bounds (for the bounded variables)
*/
MinimTransformFunction ( const IMultiGradFunction * f, const std::vector<ROOT::Math::EMinimVariableType> & types, const std::vector<double> & values,
const std::map<unsigned int, std::pair<double, double> > & bounds);
/**
Destructor (delete function pointer)
*/
~MinimTransformFunction () {
if (fFunc) delete fFunc;
}
// method inherited from IFunction interface
unsigned int NDim() const { return fIndex.size(); }
unsigned int NTot() const { return fFunc->NDim(); }
/// clone: not supported (since unique_ptr used in the fVariables)
IMultiGenFunction * Clone() const {
return 0;
}
/// transform from internal to external
/// result is cached also inside the class
const double * Transformation( const double * x) const {
Transformation(x, &fX[0]);
return &fX.front();
}
/// transform from internal to external
void Transformation( const double * xint, double * xext) const;
/// inverse transformation (external -> internal)
void InvTransformation(const double * xext, double * xint) const;
/// inverse transformation for steps (external -> internal) at external point x
void InvStepTransformation(const double * x, const double * sext, double * sint) const;
///transform gradient vector (external -> internal) at internal point x
void GradientTransformation(const double * x, const double *gExt, double * gInt) const;
///transform covariance matrix (internal -> external) at internal point x
/// use row storages for matrices m(i,j) = rep[ i * dim + j]
void MatrixTransformation(const double * x, const double *covInt, double * covExt) const;
// return original function
const IMultiGradFunction *OriginalFunction() const { return fFunc; }
private:
/// function evaluation
virtual double DoEval(const double * x) const {
#ifndef DO_THREADSAFE
return (*fFunc)(Transformation(x));
#else
std::vector<double> xext(fVariables.size() );
Transformation(x, &xext[0]);
return (*fFunc)(&xext[0]);
#endif
}
/// calculate derivatives
virtual double DoDerivative (const double * x, unsigned int icoord ) const {
const MinimTransformVariable & var = fVariables[ fIndex[icoord] ];
double dExtdInt = (var.IsLimited() ) ? var.DerivativeIntToExt( x[icoord] ) : 1.0;
double deriv = fFunc->Derivative( Transformation(x) , fIndex[icoord] );
//std::cout << "Derivative icoord (ext)" << fIndex[icoord] << " dtrafo " << dExtdInt << " " << deriv << std::endl;
return deriv * dExtdInt;
}
// copy constructor for this class (disable by having it private)
MinimTransformFunction( const MinimTransformFunction & ) :
BaseFunc(), BaseGradFunc()
{}
// assignment operator for this class (disable by having it private)
MinimTransformFunction & operator= ( const MinimTransformFunction & ) {
return *this;
}
private:
mutable std::vector<double> fX; // internal cached of external values
std::vector<MinimTransformVariable> fVariables; // vector of variable settings and tranformation function
std::vector<unsigned int> fIndex; // vector with external indices for internal variables
const IMultiGradFunction * fFunc; // user function
};
} // end namespace Math
} // end namespace ROOT
#endif /* ROOT_Math_MinimTransformFunction */
|
