339static const char charal[29] =
" .ABCDEFGHIJKLMNOPQRSTUVWXYZ";
453 gROOT->GetListOfSpecials()->Add(
this);
480 gROOT->GetListOfSpecials()->Add(
this);
490 Error(
"TMinuit",
"can not copy construct TMinuit");
503 if (
gROOT !=
nullptr &&
gROOT->GetListOfSpecials() !=
nullptr)
gROOT->GetListOfSpecials()->Remove(
this);
585 for (
int i = 0; i <
fMaxpar; i++) {
665 Warning(
"Contour",
"Cannot find more than 4 points, no TGraph returned");
673 Warning(
"Contour",
"Returning a TGraph with %d points only",
npfound);
682 if ((
h =
gROOT->GetPluginManager()->FindHandler(
"TMinuitGraph"))) {
683 if (
h->LoadPlugin() != -1)
832 mnexcm(
"FIX", tmp, 1, err );
885 mnexcm(
"MIGRAD", tmp, 0, err );
899 mnexcm(
"RELEASE", tmp, 1, err );
911 mnexcm(
"SET ERRDEF", &
up, 1, err );
938 m->SetParamPtrs(args);
957 mnexcm(
"SET PRINT", tmp, 1, err );
979 Printf(
" FIRST CALL TO USER FUNCTION AT NEW START POINT, WITH IFLAG=4.");
1050 if (
naa == -1)
return;
1052 if (
naa > 1 ||
nb == 1)
return;
1057 if (
nb << 1 !=
naa)
return;
1078 for (i = 1; i <=
fNpar; ++i) {
1112 for (i = 1; i <=
fMaxext; ++i) {
1133 static const char *
const clabel =
"0123456789ABCDEFGHIJ";
1140 Int_t i,
ngrid,
ixmid,
nparx, ix,
nx,
ny,
ki1,
ki2,
ixzero, iy,
ics;
1176 if (
nx < 11)
nx = 11;
1177 if (
ny < 11)
ny = 11;
1178 if (
nx >= 115)
nx = 114;
1195 for (i = 1; i <= 20; ++i) {
contur[i-1] =
fAmin +
fUp*(i-1)*(i-1); }
1205 for (ix = 1; ix <=
nx + 1; ++ix) {
1221 for (iy = 1; iy <=
ny; ++iy) {
1234 for (ix = 1; ix <=
nx + 1; ++ix) {
1241 for (ix = 1; ix <=
nx; ++ix) {
1268 Printf(
" %12.4g%s%12.4g",xlo,(
const char*)
chln,xup);
1273 Printf(
" X-AXIS: PARAMETER %3d %s ONE COLUMN=%12.4g"
1282 Printf(
" INVALID PARAMETER NUMBER(S) REQUESTED. IGNORED.");
1318 lenbuf =
crdbuf.Length();
1323 for (i = 1; i <=
TMath::Min(20,lenbuf); ++i) {
1324 if (
crdbuf[i-1] ==
'\'')
break;
1325 if (
crdbuf[i-1] ==
' ') {
1333 if (
ipos > lenbuf) {
1334 Printf(
" BLANK COMMAND IGNORED.");
1367 Printf(
" COMMAND CANNOT BE INTERPRETED");
1404 Int_t nall,
iold,
line,
mpar,
ierr,
inew,
move, next, i,
j,
nfcol,
iercr;
1405 Int_t idist=0,
npcol,
kints,
i2,
i1,
lr,
nfcnco=0,
ki1,
ki2,
ki3,
ke3;
1431 Printf(
" START MNCONTOUR CALCULATION OF %4d POINTS ON CONTOUR.",
nptu);
1436 Printf(
" EACH POINT IS A MINIMUM WITH RESPECT TO PARAMETER %3d %s",
ke3,(
const char*)
fCpnam[
ke3-1]);
1438 Printf(
" EACH POINT IS A MINIMUM WITH RESPECT TO THE OTHER %3d VARIABLE PARAMETERS.",
fNpar - 2);
1448 mnwarn(
"W",
"MNContour ",
"Contour squeezed by parameter limits.");
1457 mnwarn(
"W",
"MNContour ",
"Contour squeezed by parameter limits.");
1468 mnwarn(
"W",
"MNContour ",
"Contour squeezed by parameter limits.");
1476 mnwarn(
"W",
"MNContour ",
"Contour squeezed by parameter limits.");
1486 Printf(
" Plot of four points found by MINOS");
1492 for (i = 2; i <=
nall; ++i) {
1510 for (i = 1; i <=
mpar; ++i) {
fXt[i-1] =
fX[i-1]; }
1513 for (i = 1; i <=
mpar; ++i) {
1560 Printf(
" MNCONT CANNOT FIND NEXT POINT ON CONTOUR. ONLY %3d POINTS FOUND.",
nowpts);
1564 mnwarn(
"W",
"MNContour ",
"Cannot find midpoint, try closer.");
1590 for (i = 2; i <=
nall; ++i) {
1625 for (i = 1; i <=
mpar; ++i) {
1644 Printf(
" INVALID PARAMETER NUMBERS.");
1647 Printf(
" LESS THAN FOUR POINTS REQUESTED.");
1653 Printf(
" MNCONT UNABLE TO FIND FOUR POINTS.");
1681 char *
cnull =
nullptr;
1682 const char *
cnumer =
"123456789-.0+";
1685 Int_t ifld,
iend,
lend, left,
nreq,
ipos,
kcmnd,
nextb,
ic,
ibegin,
ltoadd;
1720 Printf(
" MINUIT WARNING: INPUT DATA WORD TOO LONG.");
1747 for (
ic = 1;
ic <= 13; ++
ic) {
1771 Printf(
" MINUIT WARNING IN MNCRCK: ");
1772 Printf(
" COMMAND HAS INPUT %5d NUMERIC FIELDS, BUT MINUIT CAN ACCEPT ONLY%3d",
nreq,
mxp);
1829 for (ik = 1; ik <= 2; ++ik) {
1835 if (
fKe2cr == 0)
continue;
1841 if (
zdir == 0)
continue;
1893 mnwarn(
"D",
"MNCROS ",
"Looking for slope of the right sign");
1895 for (it = 1; it <=
maxlk; ++it) {
1920 mnwarn(
"W",
"MNCROS ",
"Cannot find slope of the right sign");
1960 for (i = 1; i <= 3; ++i) {
1985 if (
coeff[2] <= 0) {
1986 mnwarn(
"D",
"MNCROS ",
"Curvature is negative near contour line.");
1990 mnwarn(
"D",
"MNCROS ",
"Problem 2, impossible determinant");
2000 Printf(
" MNCONTour problem 1");
2023 for (i = 1; i <= 3; ++i) {
2099 for (i = 1; i <=
ipt; ++i) {
2113 Printf(
"POINTS LABELLED '+' WERE TOO HIGH TO PLOT.");
2116 Printf(
"RIGHTMOST POINT IS UP AGAINST LIMIT.");
2136 Printf(
" FUNCTION MUST BE MINIMIZED BEFORE CALLING %s",(
const char*)
fCfrom);
2143 mnwarn(
"W",
fCfrom,
"NO ERROR MATRIX. WILL IMPROVISE.");
2144 for (i = 1; i <=
fNpar; ++i) {
2146 for (
j = 1;
j <= i-1; ++
j) {
2151 if (
fG2[i-1] <= 0) {
2200 Printf(
" FIRST DERIVATIVE DEBUG PRINTOUT. MNDERI");
2201 Printf(
" PAR DERIV STEP MINSTEP OPTSTEP D1-D2 2ND DRV");
2218 for (i = 1; i <=
fNpar; ++i) {
2231 if (
fGstep[i-1] < 0 && step > .5) step = .5;
2245 fX[i-1] =
xtf + step;
2249 fX[i-1] =
xtf - step;
2329 if (
l < 1)
goto L25;
2331 for (k = 1; k <=
l; ++k) {
2338 if (
gl > 1
e-35)
goto L30;
2346 if (
f >= 0)
gl = -
gl;
2351 for (
j = 1;
j <=
l; ++
j) {
2355 if (
j >=
l)
goto L47;
2363 for (
j = 1;
j <=
l; ++
j) {
2367 for (k = 1; k <=
j; ++k) {
2377 for (i = 1; i <=
n; ++i) {
2381 for (
j = 1;
j <=
l; ++
j) {
2389 if (
l == 0)
continue;
2391 for (
j = 1;
j <=
l; ++
j) {
2398 for (i = 2; i <=
n; ++i) {
2405 for (
l = 1;
l <=
n; ++
l) {
2409 for (m1 =
l; m1 <=
n; ++m1) {
2418 if (
j ==
mits)
return;
2426 for (i =
l; i <=
n; ++i) {
work[i] -=
h; }
2433 for (
i1 =
l;
i1 <= m1; ++
i1) {
2455 for (k = 1; k <=
n; ++k) {
2469 for (i = 1; i <=
n1; ++i) {
2473 for (
j =
i1;
j <=
n; ++
j) {
2479 if (k == i)
continue;
2483 for (
j = 1;
j <=
n; ++
j) {
2516 if (
fISW[1] < 1)
return;
2518 Printf(
" EXTERNAL ERROR MATRIX. NDIM=%4d NPAR=%3d ERR DEF=%g",ndim,
fNpar,
fUp);
2525 Printf(
" USER-DIMENSIONED ARRAY EMAT NOT BIG ENOUGH. REDUCED MATRIX CALCULATED.");
2533 Printf(
" ELEMENTS ABOVE DIAGONAL ARE NOT PRINTED.");
2536 for (i = 1; i <=
npard; ++i) {
2539 for (
j = 1;
j <= i; ++
j) {
2548 for (i = 1; i <=
npard; ++i) {
2554 if (
k2 > iz)
k2 = iz;
2590 if (eplus ==
fUndefi) eplus = 0;
2598 if (
fISW[1] < 2)
return;
2668 static const char *
const cname[40] = {
2726 if (
lk > 20)
lk = 20;
2743 for (i = 1; i <=
lnow; ++i) {
2755 for (i =
lnow + 1; i <=
kll; ++i) {
2761 Printf(
" ERROR: ABOVE CALL TO MNEXCM TRIED TO PASS MORE THAN %d PARAMETERS.",
fMaxpar);
2779 for (i = 1; i <=
nntot; ++i) {
2787 if (
fCword(0,4) ==
"MINO") i = 5;
2788 if (i != 6 && i != 7 && i != 8 && i != 23) {
2803 case 10:
goto L1000;
2804 case 11:
goto L1100;
2805 case 12:
goto L1200;
2806 case 13:
goto L1300;
2807 case 14:
goto L1400;
2808 case 15:
goto L1500;
2809 case 16:
goto L1600;
2810 case 17:
goto L1700;
2811 case 18:
goto L1800;
2812 case 19:
goto L1900;
2813 case 20:
goto L1900;
2814 case 21:
goto L1900;
2815 case 22:
goto L2200;
2816 case 23:
goto L2300;
2817 case 24:
goto L2400;
2818 case 25:
goto L1900;
2819 case 26:
goto L2600;
2820 case 27:
goto L3300;
2821 case 28:
goto L3300;
2822 case 29:
goto L3300;
2823 case 30:
goto L3300;
2824 case 31:
goto L3300;
2825 case 32:
goto L3300;
2826 case 33:
goto L3300;
2827 case 34:
goto L3400;
2828 case 35:
goto L3500;
2829 case 36:
goto L3600;
2830 case 37:
goto L3700;
2831 case 38:
goto L3800;
2832 case 39:
goto L3900;
2833 case 40:
goto L4000;
2850 if (
fISW[3] >= 1)
return;
2852 if (
fISW[0] == 1)
return;
2853 if (
fCword(0,3) ==
"MIG")
return;
2858 if (
fISW[0] == 1)
return;
2878 Printf(
" TOO MANY FUNCTION CALLS. MINOS GIVES UP");
2898 Printf(
"%s: NO PARAMETERS REQUESTED ",(
const char*)
fCword);
2903 chwhy =
" IS UNDEFINED.";
2907 chwhy =
" IS CONSTANT. ";
2911 chwhy =
" ALREADY FIXED.";
2917 chwhy =
" ALREADY VARIABLE.";
2940 if (it > 1 || it < 0)
goto L1005;
2951 Printf(
" IGNORED. UNKNOWN ARGUMENT:%4d",it);
2982 Printf(
"%s: NO PARAMETERS REQUESTED ",(
const char*)
fCword);
3040 if (
fISW[4] >= 0)
Printf(
" CALL TO USER FUNCTION WITH IFLAG = 3");
3052 Printf(
" MINUIT MEMORY CLEARED. NO PARAMETERS NOW DEFINED.");
3088 if (step <= 0) step = 2;
3091 for (i = 1; i <=
fNpar; ++i) {
3102 Printf(
" BLANK COMMAND IGNORED.");
3108 Printf(
" THE *COVARIANCE* COMMAND IS OSBSOLETE. THE COVARIANCE MATRIX IS NOW SAVED IN A DIFFERENT FORMAT WITH THE *SAVE* COMMAND AND READ IN WITH:*SET COVARIANCE*");
3136 Printf(
" OBSOLETE COMMAND:%s PLEASE USE:%s",(
const char*)
fCword
3172 Int_t kold,
nold,
ndex,
knew,
iext, i,
j,
m,
n,
lc, ik;
3179 Printf(
" MINUIT ERROR. ARGUMENT TO MNFIXP=%4d",
iint);
3185 Printf(
" MINUIT CANNOT FIX PARAMETER %4d MAXIMUM NUMBER THAT CAN BE FIXED IS %d",
iext,
fMaxpar);
3205 for (ik =
iext + 1; ik <=
fNu; ++ik) {
3219 if (
fISW[1] <= 0)
return;
3221 if (
fNpar <= 0)
return;
3222 for (i = 1; i <=
nold; ++i) {
3231 for (i = 1; i <=
nold; ++i) {
3232 for (
j = 1;
j <= i; ++
j) {
3262 Printf(
" CALL TO MNFREE IGNORED. ARGUMENT GREATER THAN ONE");
3265 Printf(
" CALL TO MNFREE IGNORED. THERE ARE NO FIXED PARAMETERS");
3267 if (k == 1 || k == 0)
goto L40;
3272 Printf(
" IGNORED. PARAMETER SPECIFIED IS ALREADY VARIABLE.");
3278 Printf(
" PARAMETER %4d NOT FIXED. CANNOT BE RELEASED.",
ka);
3291 for (i = ik + 1; i <=
fNpfix; ++i) {
3312 for (ik =
fNu; ik >=
ir; --ik) {
3343 Printf(
" PARAMETER %4d %s RESTORED TO VARIABLE.",
ir,
3346 if (k == 0)
goto L40;
3384 Printf(
" CHECK OF GRADIENT CALCULATION IN FCN");
3385 Printf(
" PARAMETER G(IN FCN) G(MINUIT) DG(MINUIT) AGREEMENT");
3390 const char *
cwd =
"GOOD";
3402 Printf(
" %5d %10s%12.4e%12.4e%12.4e %s",i
3403 ,(
const char*)
fCpnam[i-1]
3407 Printf(
" AGREEMENT=NONE MEANS FCN DID NOT CALCULATE THE DERIVATIVE");
3410 Printf(
" MINUIT DOES NOT ACCEPT DERIVATIVE CALCULATIONS BY FCN");
3411 Printf(
" TO FORCE ACCEPTANCE, ENTER *SET GRAD 1*");
3446 Printf(
" ==>List of MINUIT Interactive commands:");
3447 Printf(
" CLEar Reset all parameter names and values undefined");
3448 Printf(
" CONtour Make contour map of the user function");
3449 Printf(
" EXIT Exit from Interactive Minuit");
3450 Printf(
" FIX Cause parameter(s) to remain constant");
3451 Printf(
" HESse Calculate the Hessian or error matrix.");
3452 Printf(
" IMPROVE Search for a new minimum around current minimum");
3453 Printf(
" MIGrad Minimize by the method of Migrad");
3454 Printf(
" MINImize MIGRAD + SIMPLEX method if Migrad fails");
3455 Printf(
" MINOs Exact (non-linear) parameter error analysis");
3456 Printf(
" MNContour Calculate one MINOS function contour");
3457 Printf(
" PARameter Define or redefine new parameters and values");
3458 Printf(
" RELease Make previously FIXed parameters variable again");
3459 Printf(
" REStore Release last parameter fixed");
3460 Printf(
" SAVe Save current parameter values on a file");
3461 Printf(
" SCAn Scan the user function by varying parameters");
3462 Printf(
" SEEk Minimize by the method of Monte Carlo");
3463 Printf(
" SET Set various MINUIT constants or conditions");
3464 Printf(
" SHOw Show values of current constants or conditions");
3465 Printf(
" SIMplex Minimize by the method of Simplex");
3475 Printf(
" Resets all parameter names and values to undefined.");
3476 Printf(
" Must normally be followed by a PARameters command or ");
3477 Printf(
" equivalent, in order to define parameter values.");
3485 Printf(
" ***>CONTOUR <par1> <par2> [devs] [ngrid]");
3486 Printf(
" Instructs Minuit to trace contour lines of the user function");
3487 Printf(
" with respect to the two parameters whose external numbers");
3488 Printf(
" are <par1> and <par2>.");
3489 Printf(
" Other variable parameters of the function, if any, will have");
3490 Printf(
" their values fixed at the current values during the contour");
3491 Printf(
" tracing. The optional parameter [devs] (default value 2.)");
3492 Printf(
" gives the number of standard deviations in each parameter");
3493 Printf(
" which should lie entirely within the plotting area.");
3494 Printf(
" Optional parameter [ngrid] (default value 25 unless page");
3495 Printf(
" size is too small) determines the resolution of the plot,");
3496 Printf(
" i.e. the number of rows and columns of the grid at which the");
3497 Printf(
" function will be evaluated. [See also MNContour.]");
3506 Printf(
" Signals the end of a data block (i.e., the end of a fit),");
3507 Printf(
" and implies that execution should continue, because another");
3508 Printf(
" Data Block follows. A Data Block is a set of Minuit data");
3509 Printf(
" consisting of");
3511 Printf(
" (2) One or more Parameter Definitions,");
3512 Printf(
" (3) A blank line, and");
3513 Printf(
" (4) A set of Minuit Commands.");
3514 Printf(
" The END command is used when more than one Data Block is to");
3515 Printf(
" be used with the same FCN function. It first causes Minuit");
3516 Printf(
" to issue a CALL FCN with IFLAG=3, in order to allow FCN to");
3517 Printf(
" perform any calculations associated with the final fitted");
3518 Printf(
" parameter values, unless a CALL FCN 3 command has already");
3519 Printf(
" been executed at the current FCN value.");
3528 Printf(
" Signals the end of execution.");
3529 Printf(
" The EXIT command first causes Minuit to issue a CALL FCN");
3530 Printf(
" with IFLAG=3, to allow FCN to perform any calculations");
3531 Printf(
" associated with the final fitted parameter values, unless a");
3532 Printf(
" CALL FCN 3 command has already been executed.");
3540 Printf(
" ***>FIX} <parno> [parno] ... [parno]");
3541 Printf(
" Causes parameter(s) <parno> to be removed from the list of");
3542 Printf(
" variable parameters, and their value(s) will remain constant");
3543 Printf(
" during subsequent minimizations, etc., until another command");
3544 Printf(
" changes their value(s) or status.");
3552 Printf(
" ***>HESse [maxcalls]");
3553 Printf(
" Calculate, by finite differences, the Hessian or error matrix.");
3554 Printf(
" That is, it calculates the full matrix of second derivatives");
3555 Printf(
" of the function with respect to the currently variable");
3556 Printf(
" parameters, and inverts it, printing out the resulting error");
3557 Printf(
" matrix. The optional argument [maxcalls] specifies the");
3558 Printf(
" (approximate) maximum number of function calls after which");
3559 Printf(
" the calculation will be stopped.");
3567 Printf(
" ***>IMPROVE [maxcalls]");
3568 Printf(
" If a previous minimization has converged, and the current");
3569 Printf(
" values of the parameters therefore correspond to a local");
3570 Printf(
" minimum of the function, this command requests a search for");
3571 Printf(
" additional distinct local minima.");
3572 Printf(
" The optional argument [maxcalls] specifies the (approximate");
3573 Printf(
" maximum number of function calls after which the calculation");
3574 Printf(
" will be stopped.");
3582 Printf(
" ***>MIGrad [maxcalls] [tolerance]");
3583 Printf(
" Causes minimization of the function by the method of Migrad,");
3584 Printf(
" the most efficient and complete single method, recommended");
3585 Printf(
" for general functions (see also MINImize).");
3586 Printf(
" The minimization produces as a by-product the error matrix");
3587 Printf(
" of the parameters, which is usually reliable unless warning");
3588 Printf(
" messages are produced.");
3589 Printf(
" The optional argument [maxcalls] specifies the (approximate)");
3590 Printf(
" maximum number of function calls after which the calculation");
3591 Printf(
" will be stopped even if it has not yet converged.");
3592 Printf(
" The optional argument [tolerance] specifies required tolerance");
3593 Printf(
" on the function value at the minimum.");
3594 Printf(
" The default tolerance is 0.1, and the minimization will stop");
3595 Printf(
" when the estimated vertical distance to the minimum (EDM) is");
3596 Printf(
" less than 0.001*[tolerance]*UP (see [SET ERRordef]).");
3604 Printf(
" ***>MINImize [maxcalls] [tolerance]");
3605 Printf(
" Causes minimization of the function by the method of Migrad,");
3606 Printf(
" as does the MIGrad command, but switches to the SIMplex method");
3607 Printf(
" if Migrad fails to converge. Arguments are as for MIGrad.");
3608 Printf(
" Note that command requires four characters to be unambiguous.");
3616 Printf(
" ***>MINOs [maxcalls] [parno] [parno] ...");
3617 Printf(
" Causes a Minos error analysis to be performed on the parameters");
3618 Printf(
" whose numbers [parno] are specified. If none are specified,");
3619 Printf(
" Minos errors are calculated for all variable parameters.");
3620 Printf(
" Minos errors may be expensive to calculate, but are very");
3621 Printf(
" reliable since they take account of non-linearities in the");
3622 Printf(
" problem as well as parameter correlations, and are in general");
3624 Printf(
" The optional argument [maxcalls] specifies the (approximate)");
3625 Printf(
" maximum number of function calls per parameter requested,");
3626 Printf(
" after which the calculation will stop for that parameter.");
3634 Printf(
" ***>MNContour <par1> <par2> [npts]");
3635 Printf(
" Calculates one function contour of FCN with respect to");
3636 Printf(
" parameters par1 and par2, with FCN minimized always with");
3637 Printf(
" respect to all other NPAR-2 variable parameters (if any).");
3638 Printf(
" Minuit will try to find npts points on the contour (default 20)");
3639 Printf(
" If only two parameters are variable at the time, it is not");
3640 Printf(
" necessary to specify their numbers. To calculate more than");
3641 Printf(
" one contour, it is necessary to SET ERRordef to the appropriate");
3642 Printf(
" value and issue the MNContour command for each contour.");
3650 Printf(
" ***>PARameters");
3651 Printf(
" followed by one or more parameter definitions.");
3652 Printf(
" Parameter definitions are of the form:");
3653 Printf(
" <number> ''name'' <value> <step> [lolim] [uplim] ");
3655 Printf(
" 3 ''K width'' 1.2 0.1");
3656 Printf(
" the last definition is followed by a blank line or a zero.");
3664 Printf(
" ***>RELease <parno> [parno] ... [parno]");
3665 Printf(
" If <parno> is the number of a previously variable parameter");
3666 Printf(
" which has been fixed by a command: FIX <parno>, then that");
3667 Printf(
" parameter will return to variable status. Otherwise a warning");
3668 Printf(
" message is printed and the command is ignored.");
3669 Printf(
" Note that this command operates only on parameters which were");
3670 Printf(
" at one time variable and have been FIXed. It cannot make");
3671 Printf(
" constant parameters variable; that must be done by redefining");
3672 Printf(
" the parameter with a PARameters command.");
3680 Printf(
" ***>REStore [code]");
3681 Printf(
" If no [code] is specified, this command restores all previously");
3682 Printf(
" FIXed parameters to variable status. If [code]=1, then only");
3683 Printf(
" the last parameter FIXed is restored to variable status.");
3684 Printf(
" If code is neither zero nor one, the command is ignored.");
3693 Printf(
" Signals the end of a data block, and instructs Minuit to return");
3694 Printf(
" to the program which called it. The RETurn command first");
3695 Printf(
" causes Minuit to CALL FCN with IFLAG=3, in order to allow FCN");
3696 Printf(
" to perform any calculations associated with the final fitted");
3697 Printf(
" parameter values, unless a CALL FCN 3 command has already been");
3698 Printf(
" executed at the current FCN value.");
3707 Printf(
" Causes the current parameter values to be saved on a file in");
3708 Printf(
" such a format that they can be read in again as Minuit");
3709 Printf(
" parameter definitions. If the covariance matrix exists, it is");
3710 Printf(
" also output in such a format. The unit number is by default 7,");
3711 Printf(
" or that specified by the user in their call to MINTIO or");
3712 Printf(
" MNINIT. The user is responsible for opening the file previous");
3713 Printf(
" to issuing the [SAVe] command (except where this can be done");
3714 Printf(
" interactively).");
3722 Printf(
" ***>SCAn [parno] [numpts] [from] [to]");
3723 Printf(
" Scans the value of the user function by varying parameter");
3724 Printf(
" number [parno], leaving all other parameters fixed at the");
3725 Printf(
" current value. If [parno] is not specified, all variable");
3726 Printf(
" parameters are scanned in sequence.");
3727 Printf(
" The number of points [numpts] in the scan is 40 by default,");
3728 Printf(
" and cannot exceed 100. The range of the scan is by default");
3729 Printf(
" 2 standard deviations on each side of the current best value,");
3730 Printf(
" but can be specified as from [from] to [to].");
3731 Printf(
" After each scan, if a new minimum is found, the best parameter");
3732 Printf(
" values are retained as start values for future scans or");
3733 Printf(
" minimizations. The curve resulting from each scan is plotted");
3734 Printf(
" on the output unit in order to show the approximate behaviour");
3735 Printf(
" of the function.");
3736 Printf(
" This command is not intended for minimization, but is sometimes");
3737 Printf(
" useful for debugging the user function or finding a");
3738 Printf(
" reasonable starting point.");
3746 Printf(
" ***>SEEk [maxcalls] [devs]");
3747 Printf(
" Causes a Monte Carlo minimization of the function, by choosing");
3748 Printf(
" random values of the variable parameters, chosen uniformly");
3749 Printf(
" over a hypercube centered at the current best value.");
3750 Printf(
" The region size is by default 3 standard deviations on each");
3751 Printf(
" side, but can be changed by specifying the value of [devs].");
3759 Printf(
" ***>SET <option_name>");
3761 Printf(
" Informs Minuit that it is running in batch mode.");
3764 Printf(
" SET EPSmachine <accuracy>");
3765 Printf(
" Informs Minuit that the relative floating point arithmetic");
3766 Printf(
" precision is <accuracy>. Minuit determines the nominal");
3767 Printf(
" precision itself, but the SET EPSmachine command can be");
3768 Printf(
" used to override Minuit own determination, when the user");
3769 Printf(
" knows that the FCN function value is not calculated to");
3770 Printf(
" the nominal machine accuracy. Typical values of <accuracy>");
3771 Printf(
" are between 10**-5 and 10**-14.");
3774 Printf(
" SET ERRordef <up>");
3775 Printf(
" Sets the value of UP (default value= 1.), defining parameter");
3776 Printf(
" errors. Minuit defines parameter errors as the change");
3777 Printf(
" in parameter value required to change the function value");
3778 Printf(
" by UP. Normally, for chisquared fits UP=1, and for negative");
3779 Printf(
" log likelihood, UP=0.5.");
3782 Printf(
" SET GRAdient [force]");
3783 Printf(
" Informs Minuit that the user function is prepared to");
3784 Printf(
" calculate its own first derivatives and return their values");
3785 Printf(
" in the array GRAD when IFLAG=2 (see specs of FCN).");
3786 Printf(
" If [force] is not specified, Minuit will calculate");
3787 Printf(
" the FCN derivatives by finite differences at the current");
3788 Printf(
" point and compare with the user calculation at that point,");
3789 Printf(
" accepting the user values only if they agree.");
3790 Printf(
" If [force]=1, Minuit does not do its own derivative");
3791 Printf(
" calculation, and uses the derivatives calculated in FCN.");
3794 Printf(
" SET INPut [unitno] [filename]");
3795 Printf(
" Causes Minuit, in data-driven mode only, to read subsequent");
3796 Printf(
" commands (or parameter definitions) from a different input");
3797 Printf(
" file. If no [unitno] is specified, reading reverts to the");
3798 Printf(
" previous input file, assuming that there was one.");
3799 Printf(
" If [unitno] is specified, and that unit has not been opened,");
3800 Printf(
" then Minuit attempts to open the file [filename]} if a");
3801 Printf(
" name is specified. If running in interactive mode and");
3802 Printf(
" [filename] is not specified and [unitno] is not opened,");
3803 Printf(
" Minuit prompts the user to enter a file name.");
3804 Printf(
" If the word REWIND is added to the command (note:no blanks");
3805 Printf(
" between INPUT and REWIND), the file is rewound before");
3806 Printf(
" reading. Note that this command is implemented in standard");
3807 Printf(
" Fortran 77 and the results may depend on the system;");
3808 Printf(
" for example, if a filename is given under VM/CMS, it must");
3809 Printf(
" be preceded by a slash.");
3812 Printf(
" SET INTeractive");
3813 Printf(
" Informs Minuit that it is running interactively.");
3816 Printf(
" SET LIMits [parno] [lolim] [uplim]");
3817 Printf(
" Allows the user to change the limits on one or all");
3818 Printf(
" parameters. If no arguments are specified, all limits are");
3819 Printf(
" removed from all parameters. If [parno] alone is specified,");
3820 Printf(
" limits are removed from parameter [parno].");
3821 Printf(
" If all arguments are specified, then parameter [parno] will");
3822 Printf(
" be bounded between [lolim] and [uplim].");
3823 Printf(
" Limits can be specified in either order, Minuit will take");
3824 Printf(
" the smaller as [lolim] and the larger as [uplim].");
3825 Printf(
" However, if [lolim] is equal to [uplim], an error condition");
3829 Printf(
" SET LINesperpage");
3830 Printf(
" Sets the number of lines for one page of output.");
3831 Printf(
" Default value is 24 for interactive mode");
3834 Printf(
" SET NOGradient");
3835 Printf(
" The inverse of SET GRAdient, instructs Minuit not to");
3836 Printf(
" use the first derivatives calculated by the user in FCN.");
3839 Printf(
" SET NOWarnings");
3840 Printf(
" Suppresses Minuit warning messages.");
3843 Printf(
" SET OUTputfile <unitno>");
3844 Printf(
" Instructs Minuit to write further output to unit <unitno>.");
3847 Printf(
" SET PAGethrow <integer>");
3848 Printf(
" Sets the carriage control character for ``new page'' to");
3849 Printf(
" <integer>. Thus the value 1 produces a new page, and 0");
3850 Printf(
" produces a blank line, on some devices (see TOPofpage)");
3854 Printf(
" SET PARameter <parno> <value>");
3855 Printf(
" Sets the value of parameter <parno> to <value>.");
3856 Printf(
" The parameter in question may be variable, fixed, or");
3857 Printf(
" constant, but must be defined.");
3860 Printf(
" SET PRIntout <level>");
3861 Printf(
" Sets the print level, determining how much output will be");
3862 Printf(
" produced. Allowed values and their meanings are displayed");
3863 Printf(
" after a SHOw PRInt command, and are currently <level>=:");
3864 Printf(
" [-1] no output except from SHOW commands");
3865 Printf(
" [0] minimum output");
3866 Printf(
" [1] default value, normal output");
3867 Printf(
" [2] additional output giving intermediate results.");
3868 Printf(
" [3] maximum output, showing progress of minimizations.");
3869 Printf(
" Note: See also the SET WARnings command.");
3872 Printf(
" SET RANdomgenerator <seed>");
3873 Printf(
" Sets the seed of the random number generator used in SEEk.");
3874 Printf(
" This can be any integer between 10000 and 900000000, for");
3875 Printf(
" example one which was output from a SHOw RANdom command of");
3876 Printf(
" a previous run.");
3879 Printf(
" SET STRategy <level>");
3880 Printf(
" Sets the strategy to be used in calculating first and second");
3881 Printf(
" derivatives and in certain minimization methods.");
3882 Printf(
" In general, low values of <level> mean fewer function calls");
3883 Printf(
" and high values mean more reliable minimization.");
3884 Printf(
" Currently allowed values are 0, 1 (default), and 2.");
3888 Printf(
" Informs Minuit that the next input line is to be considered");
3889 Printf(
" the (new) title for this task or sub-task. This is for");
3890 Printf(
" the convenience of the user in reading their output.");
3894 Printf(
" Instructs Minuit to output warning messages when suspicious");
3895 Printf(
" conditions arise which may indicate unreliable results.");
3896 Printf(
" This is the default.");
3899 Printf(
" SET WIDthpage");
3900 Printf(
" Informs Minuit of the output page width.");
3901 Printf(
" Default values are 80 for interactive jobs");
3909 Printf(
" ***>SHOw <option_name>");
3910 Printf(
" All SET XXXX commands have a corresponding SHOw XXXX command.");
3911 Printf(
" In addition, the SHOw commands listed starting here have no");
3912 Printf(
" corresponding SET command for obvious reasons.");
3915 Printf(
" SHOw CORrelations");
3916 Printf(
" Calculates and prints the parameter correlations from the");
3917 Printf(
" error matrix.");
3920 Printf(
" SHOw COVariance");
3921 Printf(
" Prints the (external) covariance (error) matrix.");
3924 Printf(
" SHOw EIGenvalues");
3925 Printf(
" Calculates and prints the eigenvalues of the covariance");
3929 Printf(
" SHOw FCNvalue");
3930 Printf(
" Prints the current value of FCN.");
3938 Printf(
" ***>SIMplex [maxcalls] [tolerance]");
3939 Printf(
" Performs a function minimization using the simplex method of");
3940 Printf(
" Nelder and Mead. Minimization terminates either when the");
3941 Printf(
" function has been called (approximately) [maxcalls] times,");
3942 Printf(
" or when the estimated vertical distance to minimum (EDM) is");
3943 Printf(
" less than [tolerance].");
3944 Printf(
" The default value of [tolerance] is 0.1*UP(see SET ERRordef).");
3961 Printf(
" Same as EXIT.");
3969 Printf(
" ***>TOPofpage");
3970 Printf(
" Causes Minuit to write the character specified in a");
3971 Printf(
" SET PAGethrow command (default = 1) to column 1 of the output");
3972 Printf(
" file, which may or may not position your output medium to");
3973 Printf(
" the top of a page depending on the device and system.");
3977 Printf(
" Unknown MINUIT command. Type HELP for list of commands.");
3996 Double_t df,
aimsag,
fs1,
tlrstp,
fs2,
stpinm,
g2i,
sag=0,
xtf,
xti,
xtj;
3997 Int_t icyc,
ncyc,
ndex,
idrv,
iext,
npar2, i,
j,
ifail,
npard,
nparx,
id,
multpy;
4018 Printf(
" START COVARIANCE MATRIX CALCULATION.");
4034 Printf(
" PAR D GSTEP D G2 GRD SAG ");
4048 for (
id = 1;
id <=
npard; ++
id) {
4051 if (
fG2[i-1] == 0) {
4052 mnwarn(
"W",
"HESSE",
Form(
"Second derivative enters zero, param %d",
iext));
4082 if (
d >= .5)
goto L26;
4084 if (
d > .5)
d = .51;
4123 ndex = i*(i + 1) / 2;
4135 for (i = 1; i <=
fNpar; ++i) {
4136 for (
j = 1;
j <= i-1; ++
j) {
4147 ndex = i*(i-1) / 2 +
j;
4155 for (i = 1; i <=
fNpar; ++i) {
4156 for (
j = 1;
j <= i; ++
j) {
4157 ndex = i*(i-1) / 2 +
j;
4164 mnwarn(
"W",
"HESSE",
"Matrix inversion fails.");
4170 for (i = 1; i <=
fNpar; ++i) {
4173 for (
j = 1;
j <= i-1; ++
j) {
4185 Printf(
" COVARIANCE MATRIX CALCULATED SUCCESSFULLY");
4194 Printf(
" MNHESS FAILS AND WILL RETURN DIAGONAL MATRIX. ");
4196 for (i = 1; i <=
fNpar; ++i) {
4198 for (
j = 1;
j <= i-1; ++
j) {
4233 for (i = 1; i <=
fNpar; ++i) {
4270 mnwarn(
"D",
"MNHES1",
"Step size too small for 1st drv.");
4306 if (
fNpar <= 0)
return;
4320 for (i = 1; i <=
fNpar; ++i) {
4323 for (
j = 1;
j <= i; ++
j) {
4324 ndex = i*(i-1) / 2 +
j;
4332 for (i = 1; i <=
fNpar; ++i) {
4334 for (
j = 1;
j <= i; ++
j) {
4342 for (i = 1; i <=
fNpar; ++i) {
4350 Printf(
"START ATTEMPT NO.%2d TO FIND NEW MINIMUM",loop);
4360 for (i = 1; i <=
fNpar; ++i) {
4389 for (i = 1; i <=
fNpar; ++i) {
4399 for (i = 1; i <=
fNpar; ++i) {
4418 for (i = 1; i <=
fNpar; ++i) {
4431 Printf(
" AN IMPROVEMENT ON THE PREVIOUS MINIMUM HAS BEEN FOUND");
4438 for (i = 1; i <=
fNpar; ++i) {
4448 for (i = 1; i <=
fNpar; ++i) {
4466 Printf(
" IMPROVE HAS FOUND A TRULY NEW MINIMUM");
4467 Printf(
" *************************************");
4473 Printf(
" COVARIANCE MATRIX WAS NOT POSITIVE-DEFINITE");
4479 for (i = 1; i <=
fNpar; ++i) {
4488 Printf(
" IMPROVE HAS RETURNED TO REGION OF ORIGINAL MINIMUM");
4547 fCovmes[0] =
"NO ERROR MATRIX ";
4548 fCovmes[1] =
"ERR MATRIX APPROXIMATE";
4549 fCovmes[2] =
"ERR MATRIX NOT POS-DEF";
4550 fCovmes[3] =
"ERROR MATRIX ACCURATE ";
4588 for (i = 1; i <= 100; ++i) {
4596 Printf(
" MNINIT UNABLE TO DETERMINE ARITHMETIC PRECISION. WILL ASSUME:%g",
fEpsmac);
4626 if (
i2 > 0)
goto L30;
4637 Printf(
" LIMITS NOT CHANGED FOR FIXED PARAMETER:%4d",
inu);
4644 Printf(
" LIMITS REMOVED FROM PARAMETER :%3d",
inu);
4667 Printf(
" PARAMETER %3d IS NOT VARIABLE.",
i2);
4673 Printf(
" REQUEST TO CHANGE LIMITS ON FIXED PARAMETER:%3d",
i2);
4677 Printf(
" MINUIT BUG IN MNLIMS. SEE F. JAMES");
4685 Printf(
" LIMITS REMOVED FROM PARAMETER %2d",
i2);
4698 Printf(
" NO LIMITS SPECIFIED. PARAMETER %3d IS ALREADY UNLIMITED. NO CHANGE.",
i2);
4711 else fGstep[kint-1] = -.1;
4714 if (
fCstatu !=
"NO CHANGE ") {
4758 Printf(
" MNLINE start point not consistent, F values, parameters=");
4773 for (i = 1; i <=
fNpar; ++i) {
4774 if (step[i-1] != 0) {
4779 fX[i-1] = start[i-1] + step[i-1];
4822 for (i = 1; i <=
fNpar; ++i) {
fX[i-1] = start[i-1] +
slam*step[i-1]; }
4854 if (
coeff[2] <= 0) {
4885 for (i = 1; i <=
fNpar; ++i) {
fX[i-1] = start[i-1] +
slam*step[i-1]; }
4913 }
while (f3 >=
fvmax);
4927 }
while (
nxypt < 12);
4933 cmess =
" LINE SEARCH HAS EXHAUSTED THE LIMIT OF FUNCTION CALLS ";
4934 Printf(
" MNLINE DEBUG: steps=");
4940 if (
l70 &&
ldebug)
cmess =
" LINE SEARCH HAS ATTAINED TOLERANCE ";
4941 if (
l80 &&
ldebug)
cmess =
" STEP SIZE AT ARITHMETICALLY ALLOWED MINIMUM";
4944 for (i = 1; i <=
fNpar; ++i) {
4946 fX[i-1] = start[i-1] +
fDirin[i-1];
4950 mnwarn(
"D",
"MNLINE",
" LINE MINIMUM IN BACKWARDS DIRECTION");
4953 mnwarn(
"D",
"MNLINE",
" LINE SEARCH FINDS NO IMPROVEMENT ");
4980 Printf(
" MNMATU: NPAR=0");
4994 if (
fNpar <= 1)
return;
5000 Printf(
" PARAMETER CORRELATION COEFFICIENTS ");
5001 ctemp =
" NO. GLOBAL";
5002 for (
id = 1;
id <=
nparm; ++
id) {
5006 for (i = 1; i <=
fNpar; ++i) {
5008 ndi = i*(i + 1) / 2;
5013 ndj =
j*(
j + 1) / 2;
5018 for (it = 1; it <=
nparm; ++it) {
5022 if (i <=
nparm)
continue;
5031 if (i <=
nparm)
break;
5058 if (
fNpar <= 0)
return;
5075 Printf(
" START MIGRAD MINIMIZATION. STRATEGY %2d. CONVERGENCE WHEN EDM .LT.%9.2e",
fIstrat,
rhotol);
5100 for (i = 1; i <=
fNpar; ++i) {
5107 for (i = 1; i <=
fNpar; ++i) {
5108 if (
fG2[i-1] > 0)
continue;
5114 mnwarn(
"D",
"MNMIGR",
"Negative G2 line search");
5123 for (i = 1; i <=
fNpar; ++i) {
5125 for (
j = 1;
j <= i-1; ++
j) {
5130 if (
fG2[i-1] <= 0)
fG2[i-1] = 1;
5135 Printf(
" DEBUG MNMIGR, STARTING MATRIX DIAGONAL, VHMAT=");
5150 for (i = 1; i <=
fNpar; ++i) {
5154 for (
j = 1;
j <= i-1; ++
j) {
5163 mnwarn(
"W",
"MIGRAD",
"STARTING MATRIX NOT POS-DEFINITE.");
5179 for (i = 1; i <=
fNpar; ++i) {
5192 mnwarn(
"D",
"MIGRAD",
" FIRST DERIVATIVES OF FCN ARE ALL ZERO");
5197 mnwarn(
"D",
"MIGRAD",
" NEWTON STEP NOT DESCENT.");
5198 if (
npsdf == 1)
goto L1;
5222 for (i = 1; i <=
fNpar; ++i) {
5242 mnwarn(
"D",
"MIGRAD",
"NOT POS-DEF. EDM OR GVG NEGATIVE.");
5251 if (
iswtr >= 3 || (
iswtr == 2 && iter % 10 == 1)) {
5256 mnwarn(
"D",
"MIGRAD",
"NO CHANGE IN FIRST DERIVATIVES OVER LAST STEP");
5259 mnwarn(
"D",
"MIGRAD",
"FIRST DERIVATIVES INCREASING ALONG SEARCH LINE");
5265 for (
kk = 1;
kk <= 10; ++
kk) {
5271 for (i = 1; i <=
fNpar; ++i) {
5272 for (
j = 1;
j <= i; ++
j) {
5276 ndex = i*(i-1) / 2 +
j;
5284 Printf(
" RELATIVE CHANGE IN COV. MATRIX=%5.1f per cent",
fDcovar*100);
5288 for (
kk = 1;
kk <= 10; ++
kk) {
5293 for (i = 1; i <=
fNpar; ++i) {
5296 for (i = 1; i <=
fNpar; ++i) {
5297 for (
j = 1;
j <= i; ++
j) {
5298 ndex = i*(i-1) / 2 +
j;
5306 for (i = 1; i <=
fNpar; ++i) {
5320 Printf(
" CALL LIMIT EXCEEDED IN MIGRAD.");
5327 Printf(
" MIGRAD FAILS TO FIND IMPROVEMENT");
5333 Printf(
" MACHINE ACCURACY LIMITS FURTHER IMPROVEMENT.");
5339 Printf(
" MIGRAD FAILS WITH STRATEGY=0. WILL TRY WITH STRATEGY=1.");
5347 Printf(
" MIGRAD TERMINATED WITHOUT CONVERGENCE.");
5355 Printf(
" MIGRAD MINIMIZATION HAS CONVERGED.");
5360 Printf(
" MIGRAD WILL VERIFY CONVERGENCE AND ERROR MATRIX.");
5402 if (
knt >= 7)
break;
5404 if (
ilax == 0)
break;
5408 Printf(
" PARAMETER NUMBER %3d NOT A VARIABLE. IGNORED.",
ilax);
5441 Printf(
" NEW MINIMUM FOUND. GO BACK TO MINIMIZATION STEP.");
5442 Printf(
" =================================================");
5452 Printf(
" THERE ARE NO MINOS ERRORS TO CALCULATE.");
5486 for (i = 1; i <=
mpar; ++i) {
fXt[i-1] =
fX[i-1]; }
5489 for (i = 1; i <=
mpar; ++i) {
5502 ndex = it*(it + 1) / 2;
5505 for (i = 1; i <=
mpar; ++i) {
5506 if (i == it)
continue;
5515 Printf(
" MINUIT ERROR. CANNOT FIX PARAMETER %4d INTERNAL %3d",
ilax,it);
5531 Printf(
" DETERMINATION OF %sTIVE MINOS ERROR FOR PARAMETER %d %s"
5536 mnwarn(
"D",
"MINOS",
"NO COVARIANCE MATRIX.");
5547 if ( (
delu == 0 &&
ut == 0) ||
5550 for (i = 1; i <=
fNpar; ++i) {
5572 Printf(
" THE %4sTIVE MINOS ERROR OF PARAMETER %3d %10s, IS %12.4e"
5580 Printf(
" THE %4sTIVE MINOS ERROR OF PARAMETER %3d, %s EXCEEDS ITS LIMIT."
5588 Printf(
" THE %4sTIVE MINOS ERROR %4d REQUIRES MORE THAN %5d FUNCTION CALLS."
5595 Printf(
" %4sTIVE MINOS ERROR NOT CALCULATED FOR PARAMETER %d"
5602 Printf(
" **************************************************************************");
5618 for (i = 1; i <=
mpar; ++i) {
5676 Printf(
" MINUIT USER ERROR. PARAMETER NUMBER IS %3d ALLOWED RANGE IS ONE TO %4d",k,
fMaxext);
5684 for (ix = 1; ix <=
fNpfix; ++ix) {
5688 mnwarn(
"W",
"PARAM DEF",
"REDEFINING A FIXED PARAMETER.");
5690 Printf(
" CANNOT RELEASE. MAX NPAR EXCEEDED.");
5701 Printf(
" PARAMETER DEFINITIONS:");
5702 Printf(
" NO. NAME VALUE STEP SIZE LIMITS");
5708 Printf(
" %5d %-10s %13.5e constant",k,(
const char*)
cnamk,
uk);
5713 if (
a == 0 &&
b == 0) {
5717 Printf(
" %5d %-10s %13.5e%13.5e no limits",k,(
const char*)
cnamk,
uk,
wk);
5730 Printf(
" MINUIT USER ERROR. TOO MANY VARIABLE PARAMETERS.");
5735 Printf(
" USER ERROR IN MINUIT PARAMETER");
5737 Printf(
" UPPER AND LOWER LIMITS EQUAL.");
5744 mnwarn(
"W",
"PARAM DEF",
"PARAMETER LIMITS WERE REVERSED.");
5753 mnwarn(
"W",
"PARAM DEF",
"STARTING VALUE OUTSIDE LIMITS.");
5756 mnwarn(
"W",
"PARAM DEF",
"STARTING VALUE IS AT LIMIT.");
5774 for (ix = 1; ix <= k-1; ++ix) {
if (
fNiofex[ix-1] > 0) ++
lastin; }
5893 if (k <= 0)
goto L210;
5928 if (k == 0)
goto L210;
5958 Double_t a,
f, s, t,
y,
s2,
x2,
x3,
x4,
y2,
cz[3],
xm,
xy,
x2y;
5963 for (i = 1; i <= 3; ++i) {
cz[i - 1] = 0; }
5978 for (i = 1; i <=
npar2p; ++i) {
5991 if (
a == 0)
goto L10;
6003 for (i = 1; i <= 3; ++i) {
coef2p[i - 1] =
cz[i - 1]; }
6030 chbuf2 =
" IS AT ITS LOWER ALLOWED LIMIT.";
6033 chbuf2 =
" IS AT ITS UPPER ALLOWED LIMIT.";
6038 if (
yy2 > 1)
chbuf2 =
" BROUGHT BACK INSIDE LIMITS.";
6067 if ((
h =
gROOT->GetPluginManager()->FindHandler(
"TMinuitGraph"))) {
6069 if (
h->LoadPlugin() != -1)
6092 if (
nxypt <= 1)
return;
6098 for (i = 1; i <=
km1; ++i) {
6101 for (
j = 1;
j <=
ni; ++
j) {
6102 if (ypt[
j-1] > ypt[
j])
continue;
6114 if (
iquit == 0)
break;
6119 for (i = 1; i <=
nxypt; ++i) {
6120 if (xpt[i-1] >
xmax)
xmax = xpt[i-1];
6121 if (xpt[i-1] <
xmin)
xmin = xpt[i-1];
6146 for (i = 1; i <=
nxypt; ++i) {
6147 xpt[i-1] =
ax*xpt[i-1] +
bx;
6148 ypt[i-1] = any -
ay*ypt[i-1] -
by;
6158 for (i = 1; i <=
ny; ++i) {
6175 ix =
Int_t(xpt[k-1]);
6278 chnam =
"undefined";
6313 Printf(
" THERE ARE CURRENTLY NO PARAMETERS DEFINED");
6323 for (k = 1; k <= 6; ++k) {
6324 colhdu[k-1] =
"UNDEFINED";
6325 colhdl[k-1] =
"COLUMN HEAD";
6339 Printf(
" FCN=%s FROM %8s STATUS=%10s %6d CALLS %9d TOTAL"
6345 Printf(
" EDM=%s STRATEGY=%2d %s"
6351 Printf(
" EDM=%s STRATEGY=%2d ERROR MATRIX UNCERTAINTY %5.1f per cent"
6355 if (
ikode == 0)
return;
6358 for (i = 1; i <=
fNu; ++i) {
6359 if (
fNvarl[i-1] < 0)
continue;
6360 for (
ic = 10;
ic >= 1; --
ic) {
6374 colhdl[1] =
" NEGATIVE ";
6375 colhdl[2] =
" POSITIVE ";
6380 colhdu[1] =
" INTERNAL ";
6381 colhdl[1] =
" STEP SIZE ";
6382 colhdu[2] =
" INTERNAL ";
6391 colhdl[2] =
" DERIVATIVE ";
6394 colhdu[0] =
" PARABOLIC ";
6398 colhdl[1] =
" NEGATIVE ";
6399 colhdl[2] =
" POSITIVE ";
6403 if (
fISW[1] < 3)
colhdu[0] =
" APPROXIMATE ";
6404 if (
fISW[1] < 1)
colhdu[0] =
" CURRENT GUESS";
6406 Printf(
" EXT PARAMETER %-14s%-14s%-14s",(
const char*)
colhdu[0]
6408 ,(
const char*)
colhdu[2]);
6409 Printf(
" NO. NAME VALUE %-14s%-14s%-14s",(
const char*)
colhdl[0]
6411 ,(
const char*)
colhdl[2]);
6413 for (i = 1; i <=
fNu; ++i) {
6414 if (
fNvarl[i-1] < 0)
continue;
6417 if (
l == 0)
goto L55;
6420 cx2 =
"PLEASE GET X..";
6421 cx3 =
"PLEASE GET X..";
6439 cx3 =
"** at limit **";
6444 if (
x2 == 0)
cx2 =
" ";
6447 if (
x3 == 0)
cx3 =
" ";
6450 if (
cx2 ==
"PLEASE GET X..")
cx2.Form(
"%14.5e",
x2);
6451 if (
cx3 ==
"PLEASE GET X..")
cx3.Form(
"%14.5e",
x3);
6452 Printf(
"%4d %-11s%14.5e%14.5e%-14s%-14s",i
6454 ,(
const char*)
cx2,(
const char*)
cx3);
6459 Printf(
" WARNING - - ABOVE PARAMETER IS AT LIMIT.");
6465 colhdu[0] =
" constant ";
6468 Printf(
"%4d %-11s%14.5e%-14s%14.5e%14.5e",i
6472 Printf(
"%4d %-11s%14.5e%s",i
6499 for (i = 1; i <=
fNpar; ++i) {
6500 ndex = i*(i + 1) / 2;
6513 for (i = 1; i <=
fNpar; ++i) {
6522 for (
j = 1;
j <= i; ++
j) {
6537 Printf(
" EIGENVALUES OF SECOND-DERIVATIVE MATRIX:");
6572 for (i = 1; i <=
fNpar; ++i) {
fX[i-1] =
pnew[i-1]; }
6583 for (i = 1; i <=
fNpar; ++i) {
6596 Printf(
" FUNCTION VALUE DOES NOT SEEM TO DEPEND ON ANY OF THE %d VARIABLE PARAMETERS.",
fNpar);
6597 Printf(
" VERIFY THAT STEP SIZES ARE BIG ENOUGH AND CHECK FCN LOGIC.");
6598 Printf(
" *******************************************************************************");
6599 Printf(
" *******************************************************************************");
6617 static std::atomic<Int_t>
g_iseed( 12345 );
6670 for (i = 1; i <=
fNpar; ++i) {
6691 Printf(
"mnsave is dummy in TMinuit");
6788 Printf(
"%dSCAN OF PARAMETER NO. %d, %s"
6793 Printf(
" REQUESTED RANGE OUTSIDE LIMITS FOR PARAMETER %d",ipar);
6824 if (alpha <= 0) alpha = 3;
6826 Printf(
" MNSEEK: MONTE CARLO MINIMIZATION USING METROPOLIS ALGORITHM");
6828 Printf(
" MAXIMUM STEP SIZE IS %9.3f ERROR BARS.",alpha);
6840 for (ipar = 1; ipar <=
fNpar; ++ipar) {
6849 fDirin[ipar-1] = 6.2831859999999997;
6858 for (ipar = 1; ipar <=
fNpar; ++ipar) {
6888 Printf(
" MNSEEK: %5d SUCCESSIVE UNSUCCESSFUL TRIALS.",
ifail);
6911 static const char *
const cname[30] = {
6946 "-1: NO OUTPUT EXCEPT FROM SHOW ",
6947 " 0: REDUCED OUTPUT ",
6948 " 1: NORMAL OUTPUT ",
6949 " 2: EXTRA OUTPUT FOR PROBLEM CASES",
6950 " 3: MAXIMUM OUTPUT "};
6953 " 0: MINIMIZE THE NUMBER OF CALLS TO FUNCTION",
6954 " 1: TRY TO BALANCE SPEED AGAINST RELIABILITY",
6955 " 2: MAKE SURE MINIMUM TRUE, ERRORS CORRECT "};
6958 "REPORT ALL EXCEPTIONAL CONDITIONS ",
6959 "MNLINE: LINE SEARCH MINIMIZATION ",
6960 "MNDERI: FIRST DERIVATIVE CALCULATIONS ",
6961 "MNHESS: SECOND DERIVATIVE CALCULATIONS ",
6962 "MNMIGR: COVARIANCE MATRIX UPDATES ",
6963 "MNHES1: FIRST DERIVATIVE UNCERTAINTIES ",
6964 "MNCONT: MNCONTOUR PLOT (MNCROS SEARCH) "};
6976 for (i = 1; i <=
nntot; ++i) {
6996 switch ((
int)
kname) {
7014 case 18:
goto L3000;
7016 case 20:
goto L3000;
7021 case 25:
goto L3000;
7022 case 26:
goto L1900;
7046 Printf(
" UNDEFINED PARAMETER NUMBER. IGNORED.");
7077 for (i = 1; i <=
fNpar; ++i) {
7105 mnwarn(
"W",
"SHO",
"SHO");
7113 Printf(
" MINUIT RANDOM NUMBER SEED SET TO %d",
jseed);
7173 mnwarn(
"D",
"SHO",
"SHO");
7176 Printf(
" UNKNOWN DEBUG OPTION %d REQUESTED. IGNORED",
idbopt);
7189 switch ((
int)
kname) {
7199 case 10:
goto L1100;
7200 case 11:
goto L1110;
7201 case 12:
goto L1120;
7202 case 13:
goto L1130;
7203 case 14:
goto L1130;
7204 case 15:
goto L1150;
7205 case 16:
goto L1160;
7206 case 17:
goto L1170;
7207 case 18:
goto L1180;
7208 case 19:
goto L1190;
7209 case 20:
goto L1200;
7210 case 21:
goto L1210;
7211 case 22:
goto L1220;
7212 case 23:
goto L1100;
7213 case 24:
goto L1100;
7214 case 25:
goto L1250;
7215 case 26:
goto L1900;
7216 case 27:
goto L1270;
7217 case 28:
goto L1270;
7218 case 29:
goto L1290;
7219 case 30:
goto L1300;
7249 Printf(
" ALLOWED PRINT LEVELS ARE:");
7260 Printf(
" NOGRAD IS SET. DERIVATIVES NOT COMPUTED IN FCN.");
7262 Printf(
" GRAD IS SET. USER COMPUTES DERIVATIVES IN FCN.");
7267 Printf(
" ERRORS CORRESPOND TO FUNCTION CHANGE OF %g",
fUp);
7291 cmode =
"BATCH MODE ";
7292 if (
fISW[5] == 1)
cmode =
"INTERACTIVE MODE";
7294 Printf(
" INPUT NOW BEING READ IN %s FROM UNIT NO. %d FILENAME: %s"
7307 cwarn =
"SUPPRESSED";
7324 Printf(
" TITLE OF CURRENT TASK IS:%s",(
const char*)
fCtitl);
7328 Printf(
" ALLOWED STRATEGIES ARE:");
7350 Printf(
" NO PAGE THROWS IN MINUIT OUTPUT");
7358 Printf(
" THERE ARE NO MINOS ERRORS CURRENTLY VALID.");
7365 Printf(
" FLOATING-POINT NUMBERS ASSUMED ACCURATE TO %g",
fEpsmac);
7373 Printf(
" THIS IS MINUIT VERSION:%s",(
const char*)
fCvrsn);
7377 for (
id = 0;
id <= 6; ++
id) {
7380 Printf(
" DEBUG OPTION %3d IS %3s :%s"
7381 ,
id,(
const char*)
copt,(
const char*)
cdbopt[
id]);
7396 Printf(
" THE COMMAND:%10s IS UNKNOWN.",(
const char*)
fCword);
7405 Printf(
" THE FORMAT OF THE %4s COMMAND IS:",(
const char*)
ckind);
7406 Printf(
" %s xxx [numerical arguments if any]",(
const char*)
ckind);
7407 Printf(
" WHERE xxx MAY BE ONE OF THE FOLLOWING:");
7415 Printf(
" ABOVE COMMAND IS ILLEGAL. IGNORED");
7429 static constexpr Double_t alpha = 1;
7430 static constexpr Double_t beta = .5;
7431 static constexpr Double_t gamma = 2;
7442 if (
fNpar <= 0)
return;
7451 rho2 = rho1 + alpha*gamma;
7454 Printf(
" START SIMPLEX MINIMIZATION. CONVERGENCE WHEN EDM .LT. %g",
fEpsi);
7456 for (i = 1; i <=
fNpar; ++i) {
7469 for (i = 1; i <=
fNpar; ++i) {
7482 if (kg == 1)
goto L8;
7486 if (
nf < 3)
goto L4;
7496 if (ns < 6)
goto L4;
7521 for (i = 1; i <=
fNpar; ++i) {
7531 for (i = 1; i <=
fNpar; ++i) {
7539 rho = (rho2*
y1 - rho1*
y2)*.5 / (
y1 -
y2);
7542 for (i = 1; i <=
fNpar; ++i) {
7575 for (i = 1; i <=
fNpar; ++i) {
7588 Printf(
" SIMPLEX MINIMIZATION HAS CONVERGED.");
7594 Printf(
" SIMPLEX TERMINATES WITHOUT CONVERGENCE.");
7600 for (i = 1; i <=
fNpar; ++i) {
7668 static const TString cpt =
" ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890./;:[]$%*_!@#&+()";
7672 for (i = 1; i <=
l; ++i) {
7673 for (
ic = 1;
ic <= 80; ++
ic) {
7705 if (
n < 1)
goto L100;
7708 for (i = 1; i <=
n; ++i) {
7713 for (i = 1; i <=
n; ++i) {
7714 for (
j = 1;
j <=
n; ++
j) {
7719 for (i = 1; i <=
n; ++i) {
7722 if (
a[k + k*
l] != 0)
fVERTq[k-1] = 1 /
a[k + k*
l];
7729 else if (
km1 == 0)
goto L50;
7732 for (
j = 1;
j <=
km1; ++
j) {
7738 if (k -
n < 0)
goto L51;
7739 else if (k -
n == 0)
goto L60;
7749 for (
j = 1;
j <=
n; ++
j) {
7754 for (
j = 1;
j <=
n; ++
j) {
7755 for (k = 1; k <=
j; ++k) {
7788 if (
corg(0,3) !=
"SHO" ||
cmes(0,3) !=
"SHO") {
7794 Printf(
" MINUIT WARNING IN %s",(
const char*)
corg);
7795 Printf(
" ============== %s",(
const char*)
cmes);
7801 Printf(
" MINUIT DEBUG FOR %s",(
const char*)
corg);
7802 Printf(
" =============== %s ",(
const char*)
cmes);
7827 englsh =
" WAS SUPPRESSED. ";
7834 Printf(
" ONLY THE MOST RECENT 10 WILL BE LISTED BELOW.");
7838 Printf(
" CALLS ORIGIN MESSAGE");
7839 for (i = 1; i <= nm; ++i) {
7879 for (i = 1; i <=
fNpar; ++i) {
7882 for (
j = 1;
j <= i; ++
j) {
int Int_t
Signed integer 4 bytes (int)
long Longptr_t
Integer large enough to hold a pointer (platform-dependent)
double Double_t
Double 8 bytes.
ROOT::Detail::TRangeCast< T, true > TRangeDynCast
TRangeDynCast is an adapter class that allows the typed iteration through a TCollection.
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t r
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t result
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize id
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char cname
Option_t Option_t TPoint TPoint const char x2
Option_t Option_t TPoint TPoint const char x1
Option_t Option_t TPoint xy
Option_t Option_t TPoint TPoint const char y2
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize fs
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void reg
Option_t Option_t TPoint TPoint const char y1
static const char charal[29]
void InteractiveFCNm(Int_t &npar, Double_t *gin, Double_t &f, Double_t *u, Int_t flag)
Static function called when SetFCN is called in interactive mode.
R__EXTERN TMinuit * gMinuit
R__EXTERN TVirtualMutex * gROOTMutex
char * Form(const char *fmt,...)
Formats a string in a circular formatting buffer.
void Printf(const char *fmt,...)
Formats a string in a circular formatting buffer and prints the string.
#define R__LOCKGUARD(mutex)
Method or function calling interface.
virtual void mnderi()
Calculates the first derivatives of FCN (GRD)
virtual void mnvert(Double_t *a, Int_t l, Int_t m, Int_t n, Int_t &ifail)
Inverts a symmetric matrix.
virtual Int_t GetParameter(Int_t parNo, Double_t ¤tValue, Double_t ¤tError) const
return parameter value and error
virtual Int_t FixParameter(Int_t parNo)
fix a parameter
virtual void mnbins(Double_t a1, Double_t a2, Int_t naa, Double_t &bl, Double_t &bh, Int_t &nb, Double_t &bwid)
Compute reasonable histogram intervals.
virtual Int_t GetNumPars() const
returns the total number of parameters that have been defined as fixed or free.
virtual void mnpsdf()
Calculates the eigenvalues of v to see if positive-def.
virtual Int_t GetNumFixedPars() const
returns the number of currently fixed parameters
virtual void mnpfit(Double_t *parx2p, Double_t *pary2p, Int_t npar2p, Double_t *coef2p, Double_t &sdev2p)
To fit a parabola to npar2p points.
virtual Int_t Release(Int_t parNo)
release a parameter
virtual void mnpars(TString &crdbuf, Int_t &icondn)
Implements one parameter definition.
virtual void mnimpr()
Attempts to improve on a good local minimum.
virtual void BuildArrays(Int_t maxpar=15)
Create internal Minuit arrays for the maxpar parameters.
virtual void mnwerr()
Calculates the WERR, external parameter errors.
virtual void mnrset(Int_t iopt)
Resets function value and errors to UNDEFINED.
virtual void mneig(Double_t *a, Int_t ndima, Int_t n, Int_t mits, Double_t *work, Double_t precis, Int_t &ifault)
Compute matrix eigen values.
virtual void mnsimp()
Minimization using the simplex method of Nelder and Mead.
TMethodCall * GetMethodCall() const
TMinuit()
Minuit normal constructor.
virtual void mnamin()
Initialize AMIN.
virtual Int_t SetErrorDef(Double_t up)
To get the n-sigma contour the error def parameter "up" has to set to n^2.
virtual void mncler()
Resets the parameter list to UNDEFINED.
virtual void mnplot(Double_t *xpt, Double_t *ypt, char *chpt, Int_t nxypt, Int_t npagwd, Int_t npagln)
Plots points in array xypt onto one page with labelled axes.
virtual Int_t Migrad()
invokes the MIGRAD minimizer
virtual void mncomd(const char *crdbin, Int_t &icondn)
Reads a command string and executes.
TString * fCpnam
Character to be plotted at the X,Y contour positions.
TMethodCall * fMethodCall
virtual void mngrad()
Interprets the SET GRAD command.
~TMinuit() override
Minuit default destructor.
virtual void mnrazz(Double_t ynew, Double_t *pnew, Double_t *y, Int_t &jh, Int_t &jl)
Called only by MNSIMP (and MNIMPR) to add a new point.
virtual void mnmnos()
Performs a MINOS error analysis.
virtual void mnline(Double_t *start, Double_t fstart, Double_t *step, Double_t slope, Double_t toler)
Perform a line search from position START.
virtual void mncuve()
Makes sure that the current point is a local minimum.
virtual void mnscan()
Scans the values of FCN as a function of one parameter.
virtual void DeleteArrays()
Delete internal Minuit arrays.
TObject * Clone(const char *newname="") const override
Make a clone of an object using the Streamer facility.
TString fWarmes[kMAXWARN]
virtual void mnsave()
Writes current parameter values and step sizes onto file ISYSSA.
virtual void mnmatu(Int_t kode)
Prints the covariance matrix v when KODE=1.
virtual void mnlims()
Interprets the SET LIM command, to reset the parameter limits.
void(* fFCN)(Int_t &npar, Double_t *gin, Double_t &f, Double_t *u, Int_t flag)
virtual void SetMaxIterations(Int_t maxiter=500)
virtual void SetFCN(void(*fcn)(Int_t &, Double_t *, Double_t &f, Double_t *, Int_t))
To set the address of the minimization function.
virtual void mncont(Int_t ke1, Int_t ke2, Int_t nptu, Double_t *xptu, Double_t *yptu, Int_t &ierrf)
Find points along a contour where FCN is minimum.
virtual void mninit(Int_t i1, Int_t i2, Int_t i3)
Main initialization member function for MINUIT.
virtual void mnseek()
Performs a rough (but global) minimization by monte carlo search.
virtual void mncalf(Double_t *pvec, Double_t &ycalf)
Transform FCN to find further minima.
virtual Int_t Command(const char *command)
Execute a Minuit command.
virtual void mnpout(Int_t iuext, TString &chnam, Double_t &val, Double_t &err, Double_t &xlolim, Double_t &xuplim, Int_t &iuint) const
Provides the user with information concerning the current status.
virtual Int_t Eval(Int_t npar, Double_t *grad, Double_t &fval, Double_t *par, Int_t flag)
Evaluate the minimisation function Input parameters:
virtual void mnmigr()
Performs a local function minimization.
virtual void mnemat(Double_t *emat, Int_t ndim)
Calculates the external error matrix from the internal matrix.
virtual void mnrn15(Double_t &val, Int_t &inseed)
This is a super-portable random number generator.
virtual void mnerrs(Int_t number, Double_t &eplus, Double_t &eminus, Double_t &eparab, Double_t &gcc)
Utility routine to get MINOS errors.
virtual void mnexin(Double_t *pint)
Transforms the external parameter values U to internal values.
virtual void mnexcm(const char *comand, Double_t *plist, Int_t llist, Int_t &ierflg)
Interprets a command and takes appropriate action.
virtual void mnhelp(TString comd)
HELP routine for MINUIT interactive commands.
virtual Int_t SetPrintLevel(Int_t printLevel=0)
set Minuit print level.
Bool_t mnunpt(TString &cfname)
Returns .TRUE.
virtual void mnhess()
Calculates the full second-derivative matrix of FCN.
virtual void mneval(Double_t anext, Double_t &fnext, Int_t &ierev)
Evaluates the function being analysed by MNCROS.
virtual void mnset()
Interprets the commands that start with SET and SHOW.
virtual void mndxdi(Double_t pint, Int_t ipar, Double_t &dxdi)
Calculates the transformation factor between ext/internal values.
virtual void mntiny(Double_t epsp1, Double_t &epsbak)
To find the machine precision.
virtual void mninex(Double_t *pint)
Transforms from internal coordinates (PINT) to external (U)
virtual void mnpint(Double_t &pexti, Int_t i, Double_t &pinti)
Calculates the internal parameter value PINTI.
virtual void mnfixp(Int_t iint, Int_t &ierr)
Removes parameter IINT from the internal parameter list.
virtual void mnmnot(Int_t ilax, Int_t ilax2, Double_t &val2pl, Double_t &val2mi)
Performs a MINOS error analysis on one parameter.
virtual void mncrck(TString crdbuf, Int_t maxcwd, TString &comand, Int_t &lnc, Int_t mxp, Double_t *plist, Int_t &llist, Int_t &ierr, Int_t isyswr)
Cracks the free-format input.
virtual Int_t DefineParameter(Int_t parNo, const char *name, Double_t initVal, Double_t initErr, Double_t lowerLimit, Double_t upperLimit)
Define a parameter.
virtual void mnstat(Double_t &fmin, Double_t &fedm, Double_t &errdef, Int_t &npari, Int_t &nparx, Int_t &istat)
Returns concerning the current status of the minimization.
virtual void mnwarn(const char *copt, const char *corg, const char *cmes)
Prints Warning messages.
virtual void mnprin(Int_t inkode, Double_t fval)
Prints the values of the parameters at the time of the call.
TString fOrigin[kMAXWARN]
virtual void mncros(Double_t &aopt, Int_t &iercr)
Find point where MNEVAL=AMIN+UP.
virtual Int_t GetNumFreePars() const
returns the number of currently free parameters
virtual void mnhes1()
Calculate first derivatives (GRD) and uncertainties (DGRD)
virtual void mnfree(Int_t k)
Restores one or more fixed parameter(s) to variable status.
virtual void mncntr(Int_t ke1, Int_t ke2, Int_t &ierrf)
Print function contours in two variables, on line printer.
virtual TObject * Contour(Int_t npoints=10, Int_t pa1=0, Int_t pa2=1)
Creates a TGraph object describing the n-sigma contour of a TMinuit fit.
virtual void mnparm(Int_t k, TString cnamj, Double_t uk, Double_t wk, Double_t a, Double_t b, Int_t &ierflg)
Implements one parameter definition.
The TNamed class is the base class for all named ROOT classes.
TObject * Clone(const char *newname="") const override
Make a clone of an object using the Streamer facility.
Mother of all ROOT objects.
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
virtual void Execute(const char *method, const char *params, Int_t *error=nullptr)
Execute method on this object with the given parameter string, e.g.
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
void ToUpper()
Change string to upper case.
static TString Format(const char *fmt,...)
Static method which formats a string using a printf style format descriptor and return a TString.
Short_t Max(Short_t a, Short_t b)
Returns the largest of a and b.
Double_t ASin(Double_t)
Returns the principal value of the arc sine of x, expressed in radians.
Double_t ATan(Double_t)
Returns the principal value of the arc tangent of x, expressed in radians.
Double_t Log(Double_t x)
Returns the natural logarithm of x.
Double_t Sqrt(Double_t x)
Returns the square root of x.
LongDouble_t Power(LongDouble_t x, LongDouble_t y)
Returns x raised to the power y.
Short_t Min(Short_t a, Short_t b)
Returns the smallest of a and b.
Double_t Cos(Double_t)
Returns the cosine of an angle of x radians.
Double_t Sin(Double_t)
Returns the sine of an angle of x radians.
Double_t Log10(Double_t x)
Returns the common (base-10) logarithm of x.
Short_t Abs(Short_t d)
Returns the absolute value of parameter Short_t d.