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