Logo ROOT  

Reference Guide
 
Loading...
Searching...
No Matches
MnHesse.cxx
Go to the documentation of this file.
1// @(#)root/minuit2:$Id$
2// Authors: M. Winkler, F. James, L. Moneta, A. Zsenei 2003-2005
3
4/**********************************************************************
5 * *
6 * Copyright (c) 2005 LCG ROOT Math team, CERN/PH-SFT *
7 * *
8 **********************************************************************/
9
10#include "Minuit2/MnHesse.h"
11#include "Minuit2/MnUserParameterState.h"
12#include "Minuit2/MnUserFcn.h"
13#include "Minuit2/FCNBase.h"
14#include "Minuit2/FCNGradientBase.h"
15#include "Minuit2/MnPosDef.h"
16#include "Minuit2/HessianGradientCalculator.h"
17#include "Minuit2/Numerical2PGradientCalculator.h"
18#include "Minuit2/InitialGradientCalculator.h"
19#include "Minuit2/AnalyticalGradientCalculator.h"
20#include "Minuit2/ExternalInternalGradientCalculator.h"
21#include "Minuit2/MinimumState.h"
22#include "Minuit2/VariableMetricEDMEstimator.h"
23#include "Minuit2/FunctionMinimum.h"
24#include "Minuit2/MnPrint.h"
25#include "Minuit2/MPIProcess.h"
26
27namespace ROOT {
28
29namespace Minuit2 {
30
31MnUserParameterState MnHesse::operator()(const FCNBase &fcn, const std::vector<double> &par,
32 const std::vector<double> &err, unsigned int maxcalls) const
33{
34 // interface from vector of params and errors
35 return (*this)(fcn, MnUserParameterState(par, err), maxcalls);
36}
37
38MnUserParameterState MnHesse::operator()(const FCNBase &fcn, const std::vector<double> &par, unsigned int nrow,
39 const std::vector<double> &cov, unsigned int maxcalls) const
40{
41 // interface from vector of params and covariance
42 return (*this)(fcn, MnUserParameterState(par, cov, nrow), maxcalls);
43}
44
45MnUserParameterState MnHesse::operator()(const FCNBase &fcn, const std::vector<double> &par,
46 const MnUserCovariance &cov, unsigned int maxcalls) const
47{
48 // interface from vector of params and covariance
49 return (*this)(fcn, MnUserParameterState(par, cov), maxcalls);
50}
51
52MnUserParameterState MnHesse::operator()(const FCNBase &fcn, const MnUserParameters &par, unsigned int maxcalls) const
53{
54 // interface from MnUserParameters
55 return (*this)(fcn, MnUserParameterState(par), maxcalls);
56}
57
58MnUserParameterState MnHesse::operator()(const FCNBase &fcn, const MnUserParameters &par, const MnUserCovariance &cov,
59 unsigned int maxcalls) const
60{
61 // interface from MnUserParameters and MnUserCovariance
62 return (*this)(fcn, MnUserParameterState(par, cov), maxcalls);
63}
64
65MnUserParameterState
66MnHesse::operator()(const FCNBase &fcn, const MnUserParameterState &state, unsigned int maxcalls) const
67{
68 // interface from MnUserParameterState
69 // create a new Minimum state and use that interface
70 unsigned int n = state.VariableParameters();
71 MnUserFcn mfcn(fcn, state.Trafo(), state.NFcn());
72 MnAlgebraicVector x(n);
73 for (unsigned int i = 0; i < n; i++)
74 x(i) = state.IntParameters()[i];
75 double amin = mfcn(x);
76 MinimumParameters par(x, amin);
77 // check if we can use analytical gradient
78 auto * gradFCN = dynamic_cast<const FCNGradientBase *>(&(fcn));
79 if (gradFCN) {
80 // no need to compute gradient here
81 MinimumState tmp = ComputeAnalytical(*gradFCN, MinimumState(par, MinimumError(MnAlgebraicSymMatrix(n), 1.), FunctionGradient(n),
82 state.Edm(), state.NFcn()), state.Trafo());
83 return MnUserParameterState(tmp, fcn.Up(), state.Trafo());
84 }
85 // case of numerical gradient
86 Numerical2PGradientCalculator gc(mfcn, state.Trafo(), fStrategy);
87 FunctionGradient gra = gc(par);
88 MinimumState tmp = ComputeNumerical(mfcn, MinimumState(par, MinimumError(MnAlgebraicSymMatrix(n), 1.), gra, state.Edm(), state.NFcn()),
89 state.Trafo(), maxcalls);
90 return MnUserParameterState(tmp, fcn.Up(), state.Trafo());
91}
92
93void MnHesse::operator()(const FCNBase &fcn, FunctionMinimum &min, unsigned int maxcalls) const
94{
95 // interface from FunctionMinimum to be used after minimization
96 // use last state from the minimization without the need to re-create a new state
97 // do not reset function calls and keep updating them
98 MnUserFcn mfcn(fcn, min.UserState().Trafo(), min.NFcn());
99 MinimumState st = (*this)(mfcn, min.State(), min.UserState().Trafo(), maxcalls);
100 min.Add(st);
101}
102
103MinimumState MnHesse::operator()(const MnFcn &mfcn, const MinimumState &st, const MnUserTransformation &trafo,
104 unsigned int maxcalls) const
105{
106 // check first if we have an analytical gradient
107 if (st.Gradient().IsAnalytical()) {
108 // check if we can compute analytical Hessian
109 auto * gradFCN = dynamic_cast<const FCNGradientBase *>(&(mfcn.Fcn()));
110 if (gradFCN && gradFCN->HasHessian()) {
111 return ComputeAnalytical(*gradFCN, st, trafo);
112 }
113 }
114 // case of numerical computation or only analytical first derivatives
115 return ComputeNumerical(mfcn, st, trafo, maxcalls);
116}
117MinimumState MnHesse::ComputeAnalytical(const FCNGradientBase & fcn, const MinimumState &st, const MnUserTransformation &trafo) const
118{
119 unsigned int n = st.Parameters().Vec().size();
120 MnAlgebraicSymMatrix vhmat(n);
121
122 MnPrint print("MnHesse");
123
124 const MnMachinePrecision &prec = trafo.Precision();
125
126 std::unique_ptr<AnalyticalGradientCalculator> hc;
127 if (fcn.gradParameterSpace() == GradientParameterSpace::Internal) {
128 hc = std::unique_ptr<AnalyticalGradientCalculator> (new ExternalInternalGradientCalculator(fcn,trafo));
129 } else {
130 hc = std::make_unique<AnalyticalGradientCalculator>(fcn,trafo);
131 }
132
133 bool ret = hc->Hessian(st.Parameters(), vhmat);
134 if (!ret) {
135 print.Error("Error computing analytical Hessian. MnHesse fails and will return a null matrix");
136 return MinimumState(st.Parameters(), MinimumError(vhmat, MinimumError::MnHesseFailed), st.Gradient(), st.Edm(),
137 st.NFcn());
138 }
139 MnAlgebraicVector g2(n);
140 for (unsigned int i = 0; i < n; i++)
141 g2(i) = vhmat(i,i);
142
143 // update Function gradient with new G2 found
144 FunctionGradient gr(st.Gradient().Grad(), g2);
145
146 // verify if matrix pos-def (still 2nd derivative)
147 print.Debug("Original error matrix", vhmat);
148
149 MinimumError tmpErr = MnPosDef()(MinimumError(vhmat, 1.), prec);
150 vhmat = tmpErr.InvHessian();
151
152 print.Debug("PosDef error matrix", vhmat);
153
154 int ifail = Invert(vhmat);
155 if (ifail != 0) {
156
157 print.Warn("Matrix inversion fails; will return diagonal matrix");
158
159 MnAlgebraicSymMatrix tmpsym(vhmat.Nrow());
160 for (unsigned int j = 0; j < n; j++) {
161 tmpsym(j,j) = 1. / g2(j);
162 }
163
164 return MinimumState(st.Parameters(), MinimumError(tmpsym, MinimumError::MnInvertFailed), gr, st.Edm(), st.NFcn());
165 }
166
167 VariableMetricEDMEstimator estim;
168
169 // if matrix is made pos def returns anyway edm
170 if (tmpErr.IsMadePosDef()) {
171 MinimumError err(vhmat, MinimumError::MnMadePosDef);
172 double edm = estim.Estimate(gr, err);
173 return MinimumState(st.Parameters(), err, gr, edm, st.NFcn());
174 }
175
176 // calculate edm for good errors
177 MinimumError err(vhmat, 0.);
178 // this use only grad values
179 double edm = estim.Estimate(gr, err);
180
181 print.Debug("Hessian is ACCURATE. New state:", "\n First derivative:", st.Gradient().Grad(),
182 "\n Covariance matrix:", vhmat, "\n Edm:", edm);
183
184 return MinimumState(st.Parameters(), err, gr, edm, st.NFcn());
185}
186
187
188MinimumState MnHesse::ComputeNumerical(const MnFcn &mfcn, const MinimumState &st, const MnUserTransformation &trafo,
189 unsigned int maxcalls) const
190{
191 // internal interface from MinimumState and MnUserTransformation
192 // Function who does the real Hessian calculations
193 MnPrint print("MnHesse");
194
195 const MnMachinePrecision &prec = trafo.Precision();
196 // make sure starting at the right place
197 double amin = mfcn(st.Vec());
198 double aimsag = std::sqrt(prec.Eps2()) * (std::fabs(amin) + mfcn.Up());
199
200 // diagonal Elements first
201
202 unsigned int n = st.Parameters().Vec().size();
203 if (maxcalls == 0)
204 maxcalls = 200 + 100 * n + 5 * n * n;
205
206 MnAlgebraicSymMatrix vhmat(n);
207 MnAlgebraicVector g2 = st.Gradient().G2();
208 MnAlgebraicVector gst = st.Gradient().Gstep();
209 MnAlgebraicVector grd = st.Gradient().Grad();
210 MnAlgebraicVector dirin = st.Gradient().Gstep();
211 MnAlgebraicVector yy(n);
212
213 // case gradient is not numeric (could be analytical or from FumiliGradientCalculator)
214
215 if (st.Gradient().IsAnalytical()) {
216 print.Info("Using analytical gradient but a numerical Hessian calculator - it could be not optimal");
217 Numerical2PGradientCalculator igc(mfcn, trafo, fStrategy);
218 // should we check here if numerical gradient is compatible with analytical one ?
219 FunctionGradient tmp = igc(st.Parameters());
220 gst = tmp.Gstep();
221 dirin = tmp.Gstep();
222 g2 = tmp.G2();
223 print.Warn("Analytical calculator ",grd," numerical ",tmp.Grad()," g2 ",g2);
224 }
225
226 MnAlgebraicVector x = st.Parameters().Vec();
227
228 print.Debug("Gradient is", st.Gradient().IsAnalytical() ? "analytical" : "numerical", "\n point:", x,
229 "\n fcn :", amin, "\n grad :", grd, "\n step :", gst, "\n g2 :", g2);
230
231 for (unsigned int i = 0; i < n; i++) {
232
233 double xtf = x(i);
234 double dmin = 8. * prec.Eps2() * (std::fabs(xtf) + prec.Eps2());
235 double d = std::fabs(gst(i));
236 if (d < dmin)
237 d = dmin;
238
239 print.Debug("Derivative parameter", i, "d =", d, "dmin =", dmin);
240
241 for (unsigned int icyc = 0; icyc < Ncycles(); icyc++) {
242 double sag = 0.;
243 double fs1 = 0.;
244 double fs2 = 0.;
245 for (unsigned int multpy = 0; multpy < 5; multpy++) {
246 x(i) = xtf + d;
247 fs1 = mfcn(x);
248 x(i) = xtf - d;
249 fs2 = mfcn(x);
250 x(i) = xtf;
251 sag = 0.5 * (fs1 + fs2 - 2. * amin);
252
253 print.Debug("cycle", icyc, "mul", multpy, "\tsag =", sag, "d =", d);
254
255 // Now as F77 Minuit - check that sag is not zero
256 if (sag != 0)
257 goto L30; // break
258 if (trafo.Parameter(i).HasLimits()) {
259 if (d > 0.5)
260 goto L26;
261 d *= 10.;
262 if (d > 0.5)
263 d = 0.51;
264 continue;
265 }
266 d *= 10.;
267 }
268
269 L26:
270 // get parameter name for i
271 // (need separate scope for avoiding compl error when declaring name)
272 print.Warn("2nd derivative zero for parameter", trafo.Name(trafo.ExtOfInt(i)),
273 "; MnHesse fails and will return diagonal matrix");
274
275 for (unsigned int j = 0; j < n; j++) {
276 double tmp = g2(j) < prec.Eps2() ? 1. : 1. / g2(j);
277 vhmat(j, j) = tmp < prec.Eps2() ? 1. : tmp;
278 }
279
280 return MinimumState(st.Parameters(), MinimumError(vhmat, MinimumError::MnHesseFailed), st.Gradient(), st.Edm(),
281 mfcn.NumOfCalls());
282
283 L30:
284 double g2bfor = g2(i);
285 g2(i) = 2. * sag / (d * d);
286 grd(i) = (fs1 - fs2) / (2. * d);
287 gst(i) = d;
288 dirin(i) = d;
289 yy(i) = fs1;
290 double dlast = d;
291 d = std::sqrt(2. * aimsag / std::fabs(g2(i)));
292 if (trafo.Parameter(i).HasLimits())
293 d = std::min(0.5, d);
294 if (d < dmin)
295 d = dmin;
296
297 print.Debug("g1 =", grd(i), "g2 =", g2(i), "step =", gst(i), "d =", d, "diffd =", std::fabs(d - dlast) / d,
298 "diffg2 =", std::fabs(g2(i) - g2bfor) / g2(i));
299
300 // see if converged
301 if (std::fabs((d - dlast) / d) < Tolerstp())
302 break;
303 if (std::fabs((g2(i) - g2bfor) / g2(i)) < TolerG2())
304 break;
305 d = std::min(d, 10. * dlast);
306 d = std::max(d, 0.1 * dlast);
307 }
308 vhmat(i, i) = g2(i);
309 if (mfcn.NumOfCalls() > maxcalls) {
310
311 // std::cout<<"maxcalls " << maxcalls << " " << mfcn.NumOfCalls() << " " << st.NFcn() << std::endl;
312 print.Warn("Maximum number of allowed function calls exhausted; will return diagonal matrix");
313
314 for (unsigned int j = 0; j < n; j++) {
315 double tmp = g2(j) < prec.Eps2() ? 1. : 1. / g2(j);
316 vhmat(j, j) = tmp < prec.Eps2() ? 1. : tmp;
317 }
318
319 return MinimumState(st.Parameters(), MinimumError(vhmat, MinimumError::MnReachedCallLimit), st.Gradient(),
320 st.Edm(), mfcn.NumOfCalls());
321 }
322 }
323
324 print.Debug("Second derivatives", g2);
325
326 if (fStrategy.Strategy() > 0) {
327 // refine first derivative
328 HessianGradientCalculator hgc(mfcn, trafo, fStrategy);
329 FunctionGradient gr = hgc(st.Parameters(), FunctionGradient(grd, g2, gst));
330 // update gradient and step values
331 grd = gr.Grad();
332 gst = gr.Gstep();
333 }
334
335 // off-diagonal Elements
336 // initial starting values
337 bool doCentralFD = fStrategy.HessianCentralFDMixedDerivatives();
338 if (n > 0) {
339 MPIProcess mpiprocOffDiagonal(n * (n - 1) / 2, 0);
340 unsigned int startParIndexOffDiagonal = mpiprocOffDiagonal.StartElementIndex();
341 unsigned int endParIndexOffDiagonal = mpiprocOffDiagonal.EndElementIndex();
342
343 unsigned int offsetVect = 0;
344 for (unsigned int in = 0; in < startParIndexOffDiagonal; in++)
345 if ((in + offsetVect) % (n - 1) == 0)
346 offsetVect += (in + offsetVect) / (n - 1);
347
348 for (unsigned int in = startParIndexOffDiagonal; in < endParIndexOffDiagonal; in++) {
349
350 int i = (in + offsetVect) / (n - 1);
351 if ((in + offsetVect) % (n - 1) == 0)
352 offsetVect += i;
353 int j = (in + offsetVect) % (n - 1) + 1;
354
355 if ((i + 1) == j || in == startParIndexOffDiagonal)
356 x(i) += dirin(i);
357
358 x(j) += dirin(j);
359
360 double fs1 = mfcn(x);
361 if(!doCentralFD) {
362 double elem = (fs1 + amin - yy(i) - yy(j)) / (dirin(i) * dirin(j));
363 vhmat(i, j) = elem;
364 x(j) -= dirin(j);
365 } else {
366 // three more function evaluations required for central fd
367 x(i) -= dirin(i); x(i) -= dirin(i);double fs3 = mfcn(x);
368 x(j) -= dirin(j); x(j) -= dirin(j);double fs4 = mfcn(x);
369 x(i) += dirin(i); x(i) += dirin(i);double fs2 = mfcn(x);
370 x(j) += dirin(j);
371 double elem = (fs1 - fs2 - fs3 + fs4)/(4.*dirin(i)*dirin(j));
372 vhmat(i, j) = elem;
373 }
374
375 if (j % (n - 1) == 0 || in == endParIndexOffDiagonal - 1)
376 x(i) -= dirin(i);
377 }
378
379 mpiprocOffDiagonal.SyncSymMatrixOffDiagonal(vhmat);
380 }
381
382 // verify if matrix pos-def (still 2nd derivative)
383 // Note that for cases of extreme spread of eigenvalues, numerical precision
384 // can mean the hessian is computed as being not pos-def
385 // but the inverse of it is.
386
387 print.Debug("Original error matrix", vhmat);
388
389 MinimumError tmpErr = MnPosDef()(MinimumError(vhmat, 1.), prec); // pos-def version of hessian
390
391 if(fStrategy.HessianForcePosDef()) {
392 vhmat = tmpErr.InvHessian();
393 }
394
395 print.Debug("PosDef error matrix", vhmat);
396
397 int ifail = Invert(vhmat);
398 if (ifail != 0) {
399
400 print.Warn("Matrix inversion fails; will return diagonal matrix");
401
402 MnAlgebraicSymMatrix tmpsym(vhmat.Nrow());
403 for (unsigned int j = 0; j < n; j++) {
404 double tmp = g2(j) < prec.Eps2() ? 1. : 1. / g2(j);
405 tmpsym(j, j) = tmp < prec.Eps2() ? 1. : tmp;
406 }
407
408 return MinimumState(st.Parameters(), MinimumError(tmpsym, MinimumError::MnInvertFailed), st.Gradient(), st.Edm(),
409 mfcn.NumOfCalls());
410 }
411
412 FunctionGradient gr(grd, g2, gst);
413 VariableMetricEDMEstimator estim;
414
415 // if matrix is made pos def returns anyway edm
416 if (tmpErr.IsMadePosDef()) {
417 MinimumError err(vhmat, fStrategy.HessianForcePosDef() ? MinimumError::MnMadePosDef : MinimumError::MnNotPosDef);
418 double edm = estim.Estimate(gr, err);
419 return MinimumState(st.Parameters(), err, gr, edm, mfcn.NumOfCalls());
420 }
421
422 // calculate edm for good errors
423 MinimumError err(vhmat, 0.);
424 double edm = estim.Estimate(gr, err);
425
426 print.Debug("Hessian is ACCURATE. New state:", "\n First derivative:", grd, "\n Second derivative:", g2,
427 "\n Gradient step:", gst, "\n Covariance matrix:", vhmat, "\n Edm:", edm);
428
429 return MinimumState(st.Parameters(), err, gr, edm, mfcn.NumOfCalls());
430}
431
432/*
433 MinimumError MnHesse::Hessian(const MnFcn& mfcn, const MinimumState& st, const MnUserTransformation& trafo) const {
434
435 const MnMachinePrecision& prec = trafo.Precision();
436 // make sure starting at the right place
437 double amin = mfcn(st.Vec());
438 // if(std::fabs(amin - st.Fval()) > prec.Eps2()) std::cout<<"function Value differs from amin by "<<amin -
439 st.Fval()<<std::endl;
440
441 double aimsag = std::sqrt(prec.Eps2())*(std::fabs(amin)+mfcn.Up());
442
443 // diagonal Elements first
444
445 unsigned int n = st.Parameters().Vec().size();
446 MnAlgebraicSymMatrix vhmat(n);
447 MnAlgebraicVector g2 = st.Gradient().G2();
448 MnAlgebraicVector gst = st.Gradient().Gstep();
449 MnAlgebraicVector grd = st.Gradient().Grad();
450 MnAlgebraicVector dirin = st.Gradient().Gstep();
451 MnAlgebraicVector yy(n);
452 MnAlgebraicVector x = st.Parameters().Vec();
453
454 for(unsigned int i = 0; i < n; i++) {
455
456 double xtf = x(i);
457 double dmin = 8.*prec.Eps2()*std::fabs(xtf);
458 double d = std::fabs(gst(i));
459 if(d < dmin) d = dmin;
460 for(int icyc = 0; icyc < Ncycles(); icyc++) {
461 double sag = 0.;
462 double fs1 = 0.;
463 double fs2 = 0.;
464 for(int multpy = 0; multpy < 5; multpy++) {
465 x(i) = xtf + d;
466 fs1 = mfcn(x);
467 x(i) = xtf - d;
468 fs2 = mfcn(x);
469 x(i) = xtf;
470 sag = 0.5*(fs1+fs2-2.*amin);
471 if(sag > prec.Eps2()) break;
472 if(trafo.Parameter(i).HasLimits()) {
473 if(d > 0.5) {
474 std::cout<<"second derivative zero for Parameter "<<i<<std::endl;
475 std::cout<<"return diagonal matrix "<<std::endl;
476 for(unsigned int j = 0; j < n; j++) {
477 vhmat(j,j) = (g2(j) < prec.Eps2() ? 1. : 1./g2(j));
478 return MinimumError(vhmat, 1., false);
479 }
480 }
481 d *= 10.;
482 if(d > 0.5) d = 0.51;
483 continue;
484 }
485 d *= 10.;
486 }
487 if(sag < prec.Eps2()) {
488 std::cout<<"MnHesse: internal loop exhausted, return diagonal matrix."<<std::endl;
489 for(unsigned int i = 0; i < n; i++)
490 vhmat(i,i) = (g2(i) < prec.Eps2() ? 1. : 1./g2(i));
491 return MinimumError(vhmat, 1., false);
492 }
493 double g2bfor = g2(i);
494 g2(i) = 2.*sag/(d*d);
495 grd(i) = (fs1-fs2)/(2.*d);
496 gst(i) = d;
497 dirin(i) = d;
498 yy(i) = fs1;
499 double dlast = d;
500 d = std::sqrt(2.*aimsag/std::fabs(g2(i)));
501 if(trafo.Parameter(i).HasLimits()) d = std::min(0.5, d);
502 if(d < dmin) d = dmin;
503
504 // see if converged
505 if(std::fabs((d-dlast)/d) < Tolerstp()) break;
506 if(std::fabs((g2(i)-g2bfor)/g2(i)) < TolerG2()) break;
507 d = std::min(d, 10.*dlast);
508 d = std::max(d, 0.1*dlast);
509 }
510 vhmat(i,i) = g2(i);
511 }
512
513 //off-diagonal Elements
514 for(unsigned int i = 0; i < n; i++) {
515 x(i) += dirin(i);
516 for(unsigned int j = i+1; j < n; j++) {
517 x(j) += dirin(j);
518 double fs1 = mfcn(x);
519 double elem = (fs1 + amin - yy(i) - yy(j))/(dirin(i)*dirin(j));
520 vhmat(i,j) = elem;
521 x(j) -= dirin(j);
522 }
523 x(i) -= dirin(i);
524 }
525
526 return MinimumError(vhmat, 0.);
527 }
528 */
529
530} // namespace Minuit2
531
532} // namespace ROOT
d
#define d(i)
Definition RSha256.hxx:102
TRangeDynCast
ROOT::Detail::TRangeCast< T, true > TRangeDynCast
TRangeDynCast is an adapter class that allows the typed iteration through a TCollection.
Definition TCollection.h:358
gc
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void gc
Definition TGWin32VirtualXProxy.cxx:130
ROOT::Minuit2::ExternalInternalGradientCalculator
Similar to the AnalyticalGradientCalculator, the ExternalInternalGradientCalculator supplies Minuit w...
Definition ExternalInternalGradientCalculator.h:30
ROOT::Minuit2::FCNBase
Interface (abstract class) defining the function to be minimized, which has to be implemented by the ...
Definition FCNBase.h:45
ROOT::Minuit2::FunctionMinimum
class holding the full result of the minimization; both internal and external (MnUserParameterState) ...
Definition FunctionMinimum.h:37
ROOT::Minuit2::HessianGradientCalculator
HessianGradientCalculator: class to calculate Gradient for Hessian.
Definition HessianGradientCalculator.h:30
ROOT::Minuit2::LASymMatrix
Class describing a symmetric matrix of size n.
Definition LASymMatrix.h:45
ROOT::Minuit2::MinimumError
MinimumError keeps the inv.
Definition MinimumError.h:28
ROOT::Minuit2::MinimumState
MinimumState keeps the information (position, Gradient, 2nd deriv, etc) after one minimization step (...
Definition MinimumState.h:27
ROOT::Minuit2::MnFcn
Wrapper class to FCNBase interface used internally by Minuit.
Definition MnFcn.h:30
ROOT::Minuit2::MnHesse::Tolerstp
double Tolerstp() const
Definition MnHesse.h:90
ROOT::Minuit2::MnHesse::Ncycles
unsigned int Ncycles() const
forward interface of MnStrategy
Definition MnHesse.h:89
ROOT::Minuit2::MnHesse::operator()
MnUserParameterState operator()(const FCNBase &, const std::vector< double > &, const std::vector< double > &, unsigned int maxcalls=0) const
low-level API
Definition MnHesse.cxx:31
ROOT::Minuit2::MnHesse::ComputeNumerical
MinimumState ComputeNumerical(const MnFcn &, const MinimumState &, const MnUserTransformation &, unsigned int maxcalls) const
internal function to compute the Hessian using numerical derivative computation
Definition MnHesse.cxx:188
ROOT::Minuit2::MnHesse::fStrategy
MnStrategy fStrategy
Definition MnHesse.h:101
ROOT::Minuit2::MnHesse::ComputeAnalytical
MinimumState ComputeAnalytical(const FCNGradientBase &, const MinimumState &, const MnUserTransformation &) const
internal function to compute the Hessian using an analytical computation or externally provided in th...
Definition MnHesse.cxx:117
ROOT::Minuit2::MnHesse::TolerG2
double TolerG2() const
Definition MnHesse.h:91
ROOT::Minuit2::MnMachinePrecision
Sets the relative floating point (double) arithmetic precision.
Definition MnMachinePrecision.h:32
ROOT::Minuit2::MnPosDef
Force the covariance matrix to be positive defined by adding extra terms in the diagonal.
Definition MnPosDef.h:25
ROOT::Minuit2::MnPrint::Debug
void Debug(const Ts &... args)
Definition MnPrint.h:147
ROOT::Minuit2::MnPrint::Error
void Error(const Ts &... args)
Definition MnPrint.h:129
ROOT::Minuit2::MnPrint::Info
void Info(const Ts &... args)
Definition MnPrint.h:141
ROOT::Minuit2::MnPrint::Warn
void Warn(const Ts &... args)
Definition MnPrint.h:135
ROOT::Minuit2::MnStrategy::Strategy
unsigned int Strategy() const
Definition MnStrategy.h:38
ROOT::Minuit2::MnStrategy::HessianCentralFDMixedDerivatives
unsigned int HessianCentralFDMixedDerivatives() const
Definition MnStrategy.h:48
ROOT::Minuit2::MnStrategy::HessianForcePosDef
unsigned int HessianForcePosDef() const
Definition MnStrategy.h:49
ROOT::Minuit2::MnUserCovariance
Class containing the covariance matrix data represented as a vector of size n*(n+1)/2 Used to hide in...
Definition MnUserCovariance.h:26
ROOT::Minuit2::MnUserFcn
Wrapper used by Minuit of FCN interface containing a reference to the transformation object.
Definition MnUserFcn.h:25
ROOT::Minuit2::MnUserParameterState
class which holds the external user and/or internal Minuit representation of the parameters and error...
Definition MnUserParameterState.h:33
ROOT::Minuit2::MnUserParameterState::IntParameters
const std::vector< double > & IntParameters() const
Definition MnUserParameterState.h:68
ROOT::Minuit2::MnUserParameterState::Trafo
const MnUserTransformation & Trafo() const
Definition MnUserParameterState.h:75
ROOT::Minuit2::MnUserParameters
API class for the user interaction with the parameters; serves as input to the minimizer as well as o...
Definition MnUserParameters.h:36
ROOT::Minuit2::MnUserTransformation
class dealing with the transformation between user specified parameters (external) and internal param...
Definition MnUserTransformation.h:38
ROOT::Minuit2::Numerical2PGradientCalculator
class performing the numerical gradient calculation
Definition Numerical2PGradientCalculator.h:32
x
Double_t x[n]
Definition legend1.C:17
n
const Int_t n
Definition legend1.C:16
gr
TGraphErrors * gr
Definition legend1.C:25
ROOT::Minuit2::Invert
int Invert(LASymMatrix &)
Definition LaInverse.cxx:21
ROOT::Minuit2::MnAlgebraicSymMatrix
LASymMatrix MnAlgebraicSymMatrix
Definition MnMatrixfwd.h:21
ROOT
tbb::task_arena is an alias of tbb::interface7::task_arena, which doesn't allow to forward declare tb...
Definition EExecutionPolicy.hxx:4