a 5gh{ @s^dZddlmZddlZddlmZddlmZ ddl m Z m Z m Z mZmZmZmZmZmZmZmZddlmZddlZddlmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%dd l&m'Z'm(Z(m)Z)dd l*m+Z+dd l,m-Z-de_.d gZ/Gd d d Z0dddddddZ1ddddddZ2GdddZ3GdddZ4ddZ5d dd!d"d#d$d!d%d&d' d(d)Z6dS)*z Minuit class. annotationsN)util) _replace_none) FCN MnContoursMnHesseMnMachinePrecisionMnMigradMnMinosMnPrint MnSimplex MnStrategyMnUserParameterStateFunctionMinimum)ErrordefAlreadySetWarning) UnionOptionalCallableTupleListDictIterableAny CollectionSetSized) UserBoundCost CostGradient)optional_module_for) ArrayLikeMinuitc @seZdZUdZdZded<ded<dZdZed d d d Z ed d ddZ edd ddZ edd ddZ edd ddZ edd ddZejdddddZedd dd Zejdddd!d Zedd d"d#Zejdddd$d#Zed%d d&d'Zejd(ddd)d'Zed(d d*d+Zejd(dd,d-d+Zed.d d/d0Zejd.ddd1d0Zed2d d3d4Zejd5dd6d7d4Zed8d d9d:Zejd5dd6d;d:ZedZejd5dd6d?d>Zed@d dAdBZejd5dd6dCdBZedDd dEdFZedd dGdHZed(d dIdJZed(d dKdLZed(d dMdNZedd dOdPZedd dQdRZedSd dTdUZ edSd dVdWZ!ed.d dXdYZ"ed.d dZd[Z#ed(d d\d]Z$ed(d d^d_Z%d`d`dadbdcdddeddfdgdhZ&didjdkdldmdnZ'dkd dodpZ(ddsd(d.dkdtdudvZ)ddsdkdwdxdyZ*ddsdkdwdzd{Z+dd|dsd}d}d5d~dkdddZ,dddddZ-ddsdkdwddZ.d`d`ddddsdkdddZ/ddd`dddqdrddd(ddd.d(d(d.dd ddZ0drdrddd.d.ddddZ1ddd`dddd(ddd.ddddZ2drdrddd.d.ddddZ3d(ddd.d.ddddZ4ddd`ddddd(ddd.ddddZ5ddddddZ6d`dddddqdrddddd(d(d.d(d(d.dd ddZ7d`dddddddcd(d(d.d}dddZ8d`ddd`ddcd(d.d}dddZ9dddddZ:dd ddZ;dd ddĄZddЄZ?dd dd҄Z@ddd ddԄZAd(d ddքZBd.d dd؄ZCddڄZDdd܄ZEddބZFddZGddZHdd(d(d(d(d(d.ddddZId`S)r"z&Function minimizer and error computer.)_fcn _strategy _tolerance _precision_values_errors_merrors_fixed_limits_fmin _covariance_var2pos_pos2var _init_state _last_statezOptional[mutil.FMin]r,zOptional[mutil.Matrix]r-??rreturncCs|jS)zCGet cost function (usually a least-squares or likelihood function).)r#selfr8^/mounts/lovelace/software/anaconda3/envs/metaDMG/lib/python3.9/site-packages/iminuit/minuit.pyfcnKsz Minuit.fcnz"Callable[[np.ndarray], np.ndarray]cCs|jjS)z+Get gradient function of the cost function.)r#gradientr6r8r8r9gradPsz Minuit.gradTuple[str, ...]cCs|jS)zMap variable index to name.r/r6r8r8r9pos2varUszMinuit.pos2varzDict[str, int]cCs|jS)zMap variable name to index.)r.r6r8r8r9var2posZszMinuit.var2poscCs|jS)z^ Get tuple of parameter names. This is an alias for :attr:`pos2var`. r>r6r8r8r9 parameters_szMinuit.parametersfloatcCs|jjS)a Access FCN increment above minimum that corresponds to one standard deviation. Default value is 1.0. `errordef` should be 1.0 for a least-squares cost function and 0.5 for a negative log-likelihood function. See section 1.5.1 on page 6 of the :download:`MINUIT2 User's Guide `. This parameter is also called *UP* in MINUIT documents. If FCN has an attribute ``errordef``, its value is used automatically and you should not set errordef by hand. Doing so will raise a ErrordefAlreadySetWarning. For the builtin cost functions in :mod:`iminuit.cost`, you don't need to set this value, because they all have the ``errordef`` attribute set. To make user code more readable, we provided two named constants:: m_lsq = Minuit(a_least_squares_function) m_lsq.errordef = Minuit.LEAST_SQUARES # == 1 m_nll = Minuit(a_likelihood_function) m_nll.errordef = Minuit.LIKELIHOOD # == 0.5 )r# _errordefr6r8r8r9errordefhszMinuit.errordefNone)valuer5cCsdt|jjdd}|dur0d|d}t|t|dkrHtd|d||j_|jr`||jj_ dS)NrDz1cost function has an errordef attribute equal to z3, you should not override this with Minuit.errordefrz errordef=z must be a positive number) getattrr#warningswarnr ValueErrorrCr,_srcrD)r7rFZ fcn_errordefmsgr8r8r9rDs  Optional[float]cCs|jS)a Access estimated precision of the cost function. Default: None. If set to None, Minuit assumes the cost function is computed in double precision. If the precision of the cost function is lower (because it computes in single precision, for example) set this to some multiple of the smallest relative change of a parameter that still changes the function. )r&r6r8r8r9 precisions zMinuit.precisioncCs"|dur|dkstd||_dS)Nrz+precision must be a positive number or None)rJr&r7rFr8r8r9rNscCs|jS)a Access tolerance for convergence with the EDM criterion. Minuit detects converge with the EDM criterion. EDM stands for *Estimated Distance to Minimum*, it is mathematically described in the `MINUIT paper`_. The EDM criterion is well suited for statistical cost functions, since it stops the minimization when parameter improvements become small compared to parameter uncertainties. The convergence is detected when `edm < edm_max`, where `edm_max` is calculated as * Migrad: edm_max = 0.002 * tol * errordef * Simplex: edm_max = tol * errordef Users can set `tol` (default: 0.1) to a different value to either speed up convergence at the cost of a larger error on the fitted parameters and possibly invalid estimates for parameter uncertainties or smaller values to get more accurate parameter values, although this should never be necessary as the default is fine. If the tolerance is set to a very small value or zero, Minuit will use an internal lower limit for the tolerance. To restore the default use, one can assign `None`. Under some circumstances, Migrad is allowed to violate edm_max by a factor of 10. Users should not try to detect convergence by comparing edm with edm_max, but query :attr:`iminuit.util.FMin.is_above_max_edm`. )r%r6r8r8r9tolsz Minuit.tolcCs(|durd}n|dkrtd||_dS)Ng?rztolerance must be non-negative)rJr%rOr8r8r9rPs rcCs|jS)a Access current minimization strategy. You can assign an integer: - 0: Fast. Does not check a user-provided gradient. Does not improve Hesse matrix at minimum. Extra call to :meth:`hesse` after :meth:`migrad` is always needed for good error estimates. If you pass a user-provided gradient to MINUIT, convergence is **faster**. - 1: Default. Checks user-provided gradient against numerical gradient. Checks and usually improves Hesse matrix at minimum. Extra call to :meth:`hesse` after :meth:`migrad` is usually superfluous. If you pass a user-provided gradient to MINUIT, convergence is **slower**. - 2: Careful. Like 1, but does extra checks of intermediate Hessian matrix during minimization. The effect in benchmarks is a somewhat improved accuracy at the cost of more function evaluations. A similar effect can be achieved by reducing the tolerance :attr:`tol` for convergence at any strategy level. )r$r6r8r8r9strategyszMinuit.strategyintcCs ||j_dSN)r$rQrOr8r8r9rQscCstjS)a Access current print level. You can assign an integer: - 0: quiet (default) - 1: print minimal debug messages to terminal - 2: print more debug messages to terminal - 3: print even more debug messages to terminal Warnings -------- Setting print_level has the unwanted side-effect of setting the level globally for all Minuit instances in the current Python session. r global_levelr6r8r8r9 print_levelszMinuit.print_level)levelr5cCs |t_dSrSrT)r7rWr8r8r9rVsboolcCs|jjS)z Access whether to raise runtime error if the function evaluates to NaN. If you set this to True, an error is raised whenever the function evaluates to NaN. r#Z _throw_nanr6r8r8r9 throw_nanszMinuit.throw_nancCs ||j_dSrSrYrOr8r8r9rZszmutil.ValueViewcCs|jS)a Access parameter values via an array-like view. Use to read or write current parameter values based on the parameter index or the parameter name as a string. If you change a parameter value and run :meth:`migrad`, the minimization will start from that value, similar for :meth:`hesse` and :meth:`minos`. See Also -------- errors, fixed, limits r'r6r8r8r9values sz Minuit.valuesrargsr5cCs||jdd<dSrSr[r7r^r8r8r9r\szmutil.ErrorViewcCs|jS)a Access parameter parabolic errors via an array-like view. Like :attr:`values`, but instead of reading or writing the values, you read or write the errors (which double as step sizes for MINUITs numerical gradient estimation). Only positive values are accepted when assigning to errors. See Also -------- values, fixed, limits r(r6r8r8r9errors s z Minuit.errorscCs||jdd<dSrSr`r_r8r8r9ra/szmutil.FixedViewcCs|jS)av Access whether parameters are fixed via an array-like view. Use to read or write the fixation state of a parameter based on the parameter index or the parameter name as a string. If you change the state and run :meth:`migrad`, :meth:`hesse`, or :meth:`minos`, the new state is used. In case of complex fits, it can help to fix some parameters first and only minimize the function with respect to the other parameters, then release the fixed parameters and minimize again starting from that state. See Also -------- values, errors, limits r*r6r8r8r9fixed3sz Minuit.fixedcCs||jdd<dSrSrbr_r8r8r9rcFszmutil.LimitViewcCs|jS)at Access parameter limits via a array-like view. Use to read or write the limits of a parameter based on the parameter index or the parameter name as a string. If you change the limits and run :meth:`migrad`, :meth:`hesse`, or :meth:`minos`, the new state is used. In case of complex fits, it can help to limit some parameters first, run Migrad, then remove the limits and run Migrad again. Limits will bias the result only if the best fit value is outside the limits, not if it is inside. Limits will affect the estimated Hesse uncertainties if the parameter is close to a limit. They do not affect the Minos uncertainties, because those are invariant to transformations and limits are implemented via a variable transformation. See Also -------- values, errors, fixed r+r6r8r8r9limitsJsz Minuit.limitscCs||jdd<dSrSrdr_r8r8r9re`s mutil.MErrorscCs|jS)z Return a dict-like with Minos data objects. The Minos data objects contain the full status information of the Minos run. See Also -------- util.MError util.MErrors )r)r6r8r8r9merrorsds zMinuit.merrorscCs|jS)a Return covariance matrix. The square-root of the diagonal elements of the covariance matrix correspond to a standard deviation for each parameter with 68 % coverage probability in the asymptotic limit (large samples). To get k standard deviations, multiply the covariance matrix with k^2. The submatrix formed by two parameters describes an ellipse. The asymptotic coverage probabilty of the standard ellipse is lower than 68 %. It can be computed from the :math:`\chi^2` distribution with 2 degrees of freedom. In general, to obtain a (hyper-)ellipsoid with coverage probability CL, one has to multiply the submatrix of the corresponding k parameters with a factor. For k = 1,2,3 and CL = 0.99 :: from scipy.stats import chi2 chi2(1).ppf(0.99) # 6.63... chi2(2).ppf(0.99) # 9.21... chi2(3).ppf(0.99) # 11.3... See Also -------- util.Matrix )r-r6r8r8r9 covariancerszMinuit.covariancecCs t|jS)zGet number of parameters.)lenr1r6r8r8r9nparsz Minuit.nparcCs|jt|jS)z?Get number of fitted parameters (fixed parameters not counted).)rjsumrcr6r8r8r9nfitsz Minuit.nfitcCs|j|jS)a Get number of degrees of freedom if cost function supports this. To support this feature, the cost function has to report the number of data points with a property called ``ndata``. Unbinned cost functions should return infinity. )r#Z_ndatarlr6r8r8r9ndofs z Minuit.ndofcCs|jS)zh Get function minimum data object. See Also -------- util.FMin )r,r6r8r8r9fmins z Minuit.fmincCs|j}|r|jSdS)z Get function value at minimum. This is an alias for :attr:`iminuit.util.FMin.fval`. See Also -------- util.FMin N)r,fval)r7fmr8r8r9ros z Minuit.fval mutil.ParamscCst|j|jS)z Get list of current parameter data objects. See Also -------- init_params, util.Params ) _get_paramsr1r)r6r8r8r9paramss z Minuit.paramscCst|jtS)z Get list of current parameter data objects set to the initial fit state. See Also -------- params, util.Params )rrr0mutilMErrorsr6r8r8r9 init_paramss zMinuit.init_paramscCs|jr|jjSdS)z Return True if the function minimum is valid. This is an alias for :attr:`iminuit.util.FMin.is_valid`. See Also -------- util.FMin F)r,is_validr6r8r8r9valids z Minuit.validcCs|jr|jjSdS)z Return True if the covariance matrix is accurate. This is an alias for :attr:`iminuit.util.FMin.has_accurate_covar`. See Also -------- util.FMin F)r,Zhas_accurate_covarr6r8r8r9accurates zMinuit.accuratecCs|jjS)z#Get total number of function calls.)r#_nfcnr6r8r8r9nfcnsz Minuit.nfcncCs|jjS)z#Get total number of gradient calls.)r#_ngradr6r8r8r9ngradsz Minuit.ngradN)r<namerzUnion[float, ArrayLike]zUnion[CostGradient, bool, None]zCollection[str])r:r^r<r~kwdsc s(d}t|dkr2t|dtr2d}t|d}n t|}~tj|dd|durt}t|dksx|rt|dkrtddt t|D}n(t|tkrfd d t |Dt|dkrt|dkrt d |rd d |dndt||_ dd t|D|_d|_td|_|dur:t|}n6|durbt|}|durptdn|durpd}|durt|tstdt|||t|dd|_t|j |||_t||_t||_t||_ t!||_"t|dd|_#|$%D]\}} | dur| |j&|<qdS)a Initialize Minuit object. This does not start the minimization or perform any other work yet. Algorithms are started by calling the corresponding methods. Parameters ---------- fcn : Function to minimize. See notes for details on what kind of functions are accepted. *args : Starting values for the minimization as positional arguments. See notes for details on how to set starting values. grad : callable, bool, or None, optional If grad is a callable, it must be a function that calculates the gradient and returns an iterable object with one entry for each parameter, which is the derivative of `fcn` for that parameter. If None (default), Minuit will call the function :func:`iminuit.util.gradient` on `fcn`. If this function returns a callable, it will be used, otherwise Minuit will internally compute the gradient numerically. Please see the documentation of :func:`iminuit.util.gradient` how gradients are detected. Passing a boolean override this detection. If grad=True is used, a ValueError is raised if no useable gradient is found. If grad=False, Minuit will internally compute the gradient numerically. name : sequence of str, optional If it is set, it overrides iminuit's function signature detection. **kwds : Starting values for the minimization as keyword arguments. See notes for details on how to set starting values. Notes ----- *Callables* By default, Minuit assumes that the callable `fcn` behaves like chi-square function, meaning that the function minimum in repeated identical random experiments is chi-square distributed up to an arbitrary additive constant. This is important for the correct error calculation. If `fcn` returns a log-likelihood, one should multiply the result with -2 to adapt it. If the function returns the negated log-likelihood, one can alternatively set the attribute `fcn.errordef` = :attr:`Minuit.LIKELIHOOD` or :attr:`Minuit.errordef` = :attr:`Minuit.LIKELIHOOD` after initialization to make Minuit calculate errors properly. Minuit reads the function signature of `fcn` to detect the number and names of the function parameters. Two kinds of function signatures are understood. a) Function with positional arguments. The function has positional arguments, one for each fit parameter. Example:: def fcn(a, b, c): ... The parameters a, b, c must accept a real number. iminuit automatically detects the parameters names in this case. More information about how the function signature is detected can be found in :func:`iminuit.util.describe`. b) Function with arguments passed as a single Numpy array. The function has a single argument which is a Numpy array. Example:: def fcn_np(x): ... To use this form, starting values need to be passed to Minuit in form as an array-like type, e.g. a numpy array, tuple or list. For more details, see "Parameter Keyword Arguments" further down. In some cases, the detection fails, for example, for a function like this:: def difficult_fcn(*args): ... To use such a function, set the `name` keyword as described further below. *Parameter initialization* Initial values for the minimization can be set with positional arguments or via keywords. This is best explained through an example:: def fcn(x, y): return (x - 2) ** 2 + (y - 3) ** 2 The following ways of passing starting values are equivalent:: Minuit(fcn, x=1, y=2) Minuit(fcn, y=2, x=1) # order is irrelevant when keywords are used ... Minuit(fcn, 1, 2) # ... but here the order matters Positional arguments can also be used if the function has no signature:: def fcn_no_sig(*args): # ... Minuit(fcn_no_sig, 1, 2) If the arguments are explicitly named with the `name` keyword described further below, keywords can be used for initialization:: Minuit(fcn_no_sig, x=1, y=2, name=("x", "y")) # this also works If the function accepts a single Numpy array, then the initial values must be passed as a single array-like object:: def fcn_np(x): return (x[0] - 2) ** 2 + (x[1] - 3) ** 2 Minuit(fcn_np, (1, 2)) Setting the values with keywords is not possible in this case. Minuit deduces the number of parameters from the length of the initialization sequence. See Also -------- migrad, hesse, minos, scan, simplex, iminuit.util.gradient FrTrNcss|]}d|VqdS)xNr8.0ir8r8r9 z"Minuit.__init__..csi|]\}}||qSr8r8)roldnewZ annotatedr8r9 rz#Minuit.__init__..zstarting value(s) are requiredz for [ ]cSsi|]\}}||qSr8r8)rrkr8r8r9rrz:gradient enforced, but iminuit.util.gradient returned Nonez'provided gradient is not a CostGradientrDr2rN)'ri isinstancernparrayrtZdescribelisttuplerangezip RuntimeErrorjoinr/ enumerater.rPrr$r;rJrrrGr#_make_init_stater0Z ValueViewr'Z ErrorViewr(Z FixedViewr*Z LimitViewr+rNresetitemsre) r7r:r<r~r^rZ array_callstartrlimr8rr9__init__sh               zMinuit.__init__z mutil.KeyzUnion[float, Iterable[float]]z'Minuit')keyrFr5cCst|j|}t|trt|dkr>|D]}|||q*qt|tsLJt|tsZJt |t |krrt dt ||D]\}}|||q|n|j ||j |||S)a  Fix parameter and set it to value. This is a convenience function to fix a parameter and set it to a value at the same time. It is equivalent to calling :attr:`fixed` and :attr:`values`. Parameters ---------- key : int, str, slice, list of int or str Key, which can be an index, name, slice, or list of indices or names. value : float or sequence of float Value(s) assigned to key(s). Returns ------- self rz'length of argument does not match slice)rtZ _key2indexr.rrZ_ndimfixtorrrirJrr1fix set_value)r7rrFindexrvr8r8r9rs  z Minuit.fixtocCs2|j|_d|_d|j_d|j_t|_d|_ |S)z Reset minimization state to initial state. Leaves :attr:`strategy`, :attr:`precision`, :attr:`tol`, :attr:`errordef`, :attr:`print_level` unchanged. Nr) r0r1r,r#rzr|rtrur)r-r6r8r8r9rs z Minuit.resetTz Optional[int])ncalliterate use_simplexr5c Cs|dkrtdt|j}|6t|j|jt|d|j|j |j ||}Wdn1s\0Y|j |_t |d|j |j|j|jdd|j|_||S)a Run Migrad minimization. Migrad from the Minuit2 library is a robust minimisation algorithm which earned its reputation in 40+ years of almost exclusive usage in high-energy physics. How Migrad works is described in the `Minuit paper`_. It uses first and approximate second derivatives to achieve quadratic convergence near the minimum. Parameters ---------- ncall : int or None, optional Approximate maximum number of calls before minimization will be aborted. If set to None, use the adaptive heuristic from the Minuit2 library (Default: None). Note: The limit may be slightly violated, because the condition is checked only after a full iteration of the algorithm, which usually performs several function calls. iterate : int, optional Automatically call Migrad up to N times if convergence was not reached (Default: 5). This simple heuristic makes Migrad converge more often even if the numerical precision of the cost function is low. Setting this to 1 disables the feature. use_simplex: bool, optional If we have to iterate, set this to True to call the Simplex algorithm before each call to Migrad (Default: True). This may improve convergence in pathological cases (which we are in when we have to iterate). See Also -------- simplex, scan rziterate must be at least 1rNZMigradT migrad_factor)rJrt_Timerr,_robust_low_level_fitr#r1 replace_noner$r%r&stateFMinr{r}rm _edm_goalrF_make_covariance)r7rrrtrpr8r8r9migrads4% "   z Minuit.migrad)rr5c Cst|j|j|j}|jdur$|j|_t|j}|"|t |d|j }Wdn1s\0Y|j |_t |d|j |j|j||j|_d|_t|_|S)a Run Simplex minimization. Simplex from the Minuit2 C++ library is a variant of the Nelder-Mead algorithm to find the minimum of a function. It does not make use of derivatives. `The Wikipedia has a good article on the Nelder-Mead method `_. Parameters ---------- ncall : Approximate maximum number of calls before minimization will be aborted. If set to None, use the adaptive heuristic from the Minuit2 library (Default: None). Note: The limit may be slightly violated, because the condition is checked only after a full iteration of the algorithm, which usually performs several function calls. Notes ----- The Simplex method usually converges more slowly than Migrad, but performs better in certain cases, the Rosenbrock function is a notable example. Unlike Migrad, the Simplex method does not have quadratic convergence near the minimum, so it is a good approach to run Migrad after Simplex to obtain an accurate solution in fewer steps. Simplex may also be useful to get close to the minimum from an unsuitable starting point. The convergence criterion for Simplex is also based on EDM, but the threshold is much more lax than that of Migrad (see :attr:`Minuit.tol` for details). This was made so that Simplex stops early when getting near the minimum, to give the user a chance to switch to the more efficient Migrad algorithm to finish the minimization. Early stopping can be avoided by setting Minuit.tol to an accordingly smaller value, however. NrZSimplex)r r#r1rQr&rNrtrr,rr%rrr{r}rmrrFr-rur))r7rsimplexrrpr8r8r9r/s&"  0  zMinuit.simplexc sj}|dur}t|d|jjkr>tj_tjdtj j<t j t D]j\}\}}j |}j|}j|r||f|<ql|tj kr||n||tj kr||n|f|<qldddfdd tj}|dWdn1s$0Y} tjjj| } | j_t| d jjj| |j_d_t_S) a Brute-force minimization. Scans the function on a regular hypercube grid, whose bounds are defined either by parameter limits if present or by Minuit.values +/- Minuit.errors. Minuit.errors are initialized to very small values by default, too small for this scan. They should be increased before running scan or limits should be set. The scan evaluates the function exactly at the limit boundary, so the function should be defined there. Parameters ---------- ncall : Approximate number of function calls to spend on the scan. The actual number will be close to this, the scan uses ncall^(1/npar) steps per cube dimension. If no value is given, a heuristic is used to set ncall. Notes ----- The scan can return an invalid minimum, this is not a cause for alarm. It just minimizes the cost function, the EDM value is only computed after the scan found a best point. If the best point still has a bad EDM value, the minimum is considered invalid. But even if it is considered valid, it is probably not accurate, since the tolerance is very lax. One should always run :meth:`migrad` after the scan. This implementation here does a full scan of the hypercube in Python. Originally, this was supposed to use MnScan from C++ Minuit2, but MnScan is unsuitable. It does a 1D scan with 41 steps (not configurable) for each parameter in sequence, so it is not actually scanning the full hypercube. It first scans one parameter, then starts the scan of the second parameter from the best value of the first and so on. This fails easily when the parameters are correlated. NrrRrE)iparr5cs|jkrRdj}|jkrN|j<djjdd<dS|\}}||kr|||<|dn(t||D]}||<|dqdS)Nr)rjr#r\rlinspace)rrlowupxiZlimsZnsteprunr7rr8r9rs   zMinuit.scan..runrZScan) rl_migrad_maxcallrRr1r0rremptyrjinfrrerr\rarcrtrr,rrr#rQrrr{r}rmrFr-rur)) r7rnrrrreredm_goalrpr8rr9scanisH2         (  z Minuit.scanzUnion[str, Callable]rzOptional[Dict[str, Any]])methodrhesshessp constraintsoptionsr5c- sz ddlm}m}m} m} m} Wn4tyT} z| jd7_WYd} ~ n d} ~ 00|durf}t j j ddt dt j ddt } | rGfddd}|}|}Gfdd d }nLGfd dd}Gd d d |}Gd dd|}Gfdd d }|jj}jj}|r>||nd}|rP||}r^||dur@t|tr|tdt|ts|g}nt|}t|D]\}}t|| r||j|_nzt|| r4| s<}d|<t |j|}|j|}|j|}t |jddf}| ||||j||<ntdq}g}g}g}d}j D]} | j!rnq^|| j"O}| j#durt j$ n| j#}!| j%durt j$n| j%}"|!dkr|!d|j&9}!n |!dkr|!d|j&9}!n|j&}!|"dkr|"d|j&9}"n"|"dkr|"d|j&9}"n|j& }"t '| j(|!|"}#|)|!|)|"|)|#q^|durx|rhd}n|rtd}nd}|pi}d}$d|vr||d<d}$|dvrd|vr||d<|$r|d=|dvrd|vr||d<|$r|d=|dvr|durd}t*+j,}%|%>|||||r2|||ddnd||||d Wdn1sZ0Yj-dkrxt.jj/d!7_/|rjj01d"d7_0d}&d}'d#vrĈj2}&nd$vr؈j3}&d}'t4|&r|&dusJ|&t 5j6}&t |pt }(|&durT|(rTrFfd%d&t 5j6D}&n |j7}&d}'|'rft j89|&}&|&durt :j6j6f}&d}j D],} | j!rq| j;d'|&||f<|d7}qd(vr̈j<})n6d)vrވj=})n$t >t ?|&d*}*| j7||*d+})j@dd,}+tAjBjCj7|&|)jjD|+jE||( },|,jF_Bt*G|,d-|d.jEjHjI|+|%j(_,|(rtJnjKjKdkrLS)/a+ Minimize with SciPy algorithms. Parameters ---------- method : str or Callable, optional Which scipy method to use. ncall : int, optional Function call limit. hess : Callable, optional Function that computes the Hessian matrix. It must use the exact same calling conversion as the original fcn (several arguments which are numbers or a single array argument). hessp : Callable, optional Function that computes the product of the Hessian matrix with a vector. It must use the same calling conversion as the original fcn (several arguments which are numbers or a single array argument) and end with another argument which is an arbitrary vector. constraints : scipy.optimize.LinearConstraint or scipy.optimize.NonlinearConstraint, optional Linear or non-linear constraints, see docs of :func:`scipy.optimize.minimize` look for the `constraints` parameter. The function used in the constraint must use the exact same calling convention as the original fcn, see hess parameter for details. No parameters may be omitted in the signature, even if those parameters are not used in the constraint. options : dict, optional A dictionary of solver options to pass to the SciPy minimizer through the `options` parameter of :func:`scipy.optimize.minimize`. See each solver method for the options it accepts. Notes ----- The call limit may be violated since many algorithms checks the call limit only after a full iteraction of their algorithm, which consists of several function calls. Some algorithms do not check the number of function calls at all, in this case the call limit acts on the number of iterations of the algorithm. This issue should be fixed in scipy. The SciPy minimizers use their own internal rule for convergence. The EDM criterion is evaluated only after the original algorithm already stopped. This means that usually SciPy minimizers will use more iterations than Migrad and the tolerance :attr:`tol` has no effect on SciPy minimizers. You can specify convergence tolerance and other options for the SciPy minimizers through the `options` parameter. Note that providing the SciPy options `"maxiter"`, `"maxfev"`, and/or `"maxfun"` (depending on the minimizer) takes precedence over providing a value for `ncall`. If you want to explicitly control the number of iterations or function evaluations for a particular SciPy minimizer, you should provide values for all of its relevant options. r)minimizeBoundsNonlinearConstraintLinearConstraint approx_fprimez: Please install scipy to use scipy minimizers in iminuit.NZdtypecs2eZdZdZddZjjr&ddZnddZdS)Minuit.scipy..Wrappedr:cSs ||_dSrSrr7r:r8r8r9r+s&Minuit.scipy..Wrapped.__init__cSs ||SrSrr7parr8r8r9__call__0s&Minuit.scipy..Wrapped.__call__cSs |j|SrSrrr8r8r9r5sN__name__ __module__ __qualname__ __slots__rr:Z _array_callrr8r6r8r9Wrapped(s  rcs2eZdZdZddZjjr&ddZnddZdS)"Minuit.scipy..WrappedHessprcSs ||_dSrSrrr8r8r9r>s+Minuit.scipy..WrappedHessp.__init__cSs |||SrSrr7rrr8r8r9rCs+Minuit.scipy..WrappedHessp.__call__cSs|jg||RSrSrrr8r8r9rHsNrr8r6r8r9 WrappedHessp;s  rcs8eZdZdZfddZjjr,ddZnddZdS)rr:freercs||_|_|_dSrSrrcfreecparr8r9rPsrcSs||j|j<||jSrSrrr:rr8r8r9rWs rcSs||j|j<|j|jSrSrrr8r8r9r]s Nrr8rrr7r8r9rMs  cseZdZfddZZS)z!Minuit.scipy..WrappedGradcst|}t||jSrS)superrrZ atleast_1dr)r7rg __class__r8r9rbs z*Minuit.scipy..WrappedGrad.__call__)rrrr __classcell__r8r8rr9 WrappedGradasrcs(eZdZfddZfddZZS)z!Minuit.scipy..WrappedHesscs8t|t|j|j|_t|j}||f|_dSrS)rrrouterrfreemrkshape)r7r:rrr8r9rgs  z*Minuit.scipy..WrappedHess.__init__cs$t|}t||j|jSrS)rrr atleast_2drZreshaper)r7rhrr8r9rms z*Minuit.scipy..WrappedHess.__call__)rrrrrrr8r8rr9 WrappedHessfs rcs8eZdZdZfddZjjr,ddZnddZdS)r)r:rrveccs$||_|_|_t|j|_dSrS)r:rrrZ zeros_likerrrr8r9rtsrcSs.||j|j<||j|j<||j|j|jSrSrrrr:rr8r8r9r|s  rcSs6||j|j<||j|j<|jg|j|jR|jSrSrrr8r8r9rs  Nrr8rr8r9rqs  z/setting constraints with dicts is not supportedzqsetting constraints with dicts is not supported, use LinearConstraint or NonlinearConstraint from scipy.optimize.FrSLSQPL-BFGS-BZBFGSmaxiterT)z Nelder-MeadZPowellZmaxfev)rZTNCZmaxfun)ZCOBYLArz trust-constrr8) keep_feasible)rZboundsjacrrrrZnfevZnjevhess_invrcsg|]}j|qSr8)r)rei)rrr8r9 $rz Minuit.scipy..r<rg|=)epsilonrzSciPy[r)Mscipy.optimizerrrrrModuleNotFoundErrorrLrrrrcrXr\allr#Z_gradrdictrJrrrZfuncopydotAlbubrr _mnprecisionrsis_fixed has_limits lower_limitr upper_limiteps2ZcliprFappendrtrr,rVprintrzr|getrrcallableeyerlrlinalginvZzeroserrorr<rsqrtZdiagrrr1ZtraforDr{rrr}rmrrQhesse)-r7rrrrrrrrrrrexcZno_fixed_parametersrrrrr:r<rcrshiftrr rprr lower_bound upper_boundr pZaiZbirZ added_maxiterrmatrixZ needs_invertZaccurate_covarrZdxrrpr8)rrrrr7r9scipys`<                           &                  z Minuit.scipyr)plotcKs|||jfi|S)a Visualize agreement of current model with data (requires matplotlib). This generates a plot of the data/model agreement, using the current parameter values, if the likelihood function supports this, otherwise AttributeError is raised. Parameters ---------- plot : Callable, optional This function tries to call the visualize method on the cost function, which accepts the current model parameters as an array-like and potentially further keyword arguments, and draws a visualization into the current matplotlib axes. If the cost function does not provide a visualize method or if you want to override it, pass the function here. kwargs : Other keyword arguments are forwarded to the plot function. See Also -------- Minuit.interactive ) _visualizer\)r7r#kwargsr8r8r9 visualize_szMinuit.visualizec Cs|jdkr tjdtjdd|S|rp|jdd}t|j|j |j |}t |d|j |j |j|d|_t|_|jdus~J|jj}t|j}t|j}|*||j|t|d|jjWdn1s0Y|j|_ t ||jj|j |j |j|jj|j|_||S) am Run Hesse algorithm to compute asymptotic errors. The Hesse method estimates the covariance matrix by inverting the matrix of `second derivatives (Hesse matrix) at the minimum `_. To get parameters correlations, you need to use this. The Minos algorithm is another way to estimate parameter uncertainties, see :meth:`minos`. Parameters ---------- ncall : Approximate upper limit for the number of calls made by the Hesse algorithm. If set to None, use the adaptive heuristic from the Minuit2 library (Default: None). Notes ----- The covariance matrix is asymptotically (in large samples) valid. By valid we mean that confidence intervals constructed from the errors contain the true value with a well-known coverage probability (68 % for each interval). In finite samples, this is likely to be true if your cost function looks like a hyperparabola around the minimum. In practice, the errors very likely have correct coverage if the results from Minos and Hesse methods agree. It is possible to construct artifical functions where this rule is violated, but in practice it should always work. See Also -------- minos rz&Hesse called with all parameters fixedr) stacklevelTrZExternalN)rlrHrIrtIMinuitWarning/_fmin_does_not_exist_or_last_state_was_modifiedrrr#r1r$rr{r}rmr,rur)rKrrQrrrr algorithmrFr)r7rrrprrr8r8r9rysJ#     8 z Minuit.hesse)clrzUnion[int, str])rAr+rr5cst|dd}rjdus*Jjj}jsLtdtjt|dkrrfddt j D}nFg}|D]<} |\}} j |rt d| tjqz||qztj} | tj|tj|j} |D]j} j| }| | t|dj} t| j|| j| j| j| j| j | j!| j"| j#| j$| j%| j&| j'| j(j)|<qWdn1sn0YWdn1s0Yjrj'j_*j+j_,| j-j_.S) a- Run Minos algorithm to compute confidence intervals. The Minos algorithm uses the profile likelihood method to compute (generally asymmetric) confidence intervals. It scans the negative log-likelihood or (equivalently) the least-squares cost function around the minimum to construct a confidence interval. Parameters ---------- *parameters : Names of parameters to generate Minos errors for. If no positional arguments are given, Minos is run for each parameter. cl : float or None, optional Confidence level of the interval. If not set or None, a standard interval is computed (default). A standard interval has about 68.3 % confidence, which is the probability of being within one standard deviation around the mean of a normal distribution. If 0 < cl < 1, the value is interpreted as the confidence level (a probability). For convenience, values cl >= 1 are interpreted as the probability content of a central symmetric interval covering that many standard deviations of a normal distribution. For example, cl=1 is interpreted as about 68.3 %, and cl=2 as 84.3 %, and so on. Using values other than 0.68, 0.9, 0.95, 0.99, 1, 2, 3, 4, 5 require the scipy module. ncall : int or None, optional Limit the number of calls made by Minos. If None, an adaptive internal heuristic of the Minuit2 library is used (Default: None). Notes ----- Asymptotically (large samples), the Minos interval has a coverage probability equal to the given confidence level. The coverage probability is the probability for the interval to contain the true value in repeated identical experiments. The interval is invariant to transformations and thus not distorted by parameter limits, unless the limits intersect with the confidence interval. As a rule-of-thumb: when the confidence intervals computed with the Hesse and Minos algorithms differ strongly, the Minos intervals are preferred. Otherwise, Hesse intervals are preferred. Running Minos is computationally expensive when there are many fit parameters. Effectively, it scans over one parameter in small steps and runs a full minimisation for all other parameters of the cost function for each scan point. This requires many more function evaluations than running the Hesse algorithm. rr2NFunction minimum is not valid: rcsg|]}j|s|qSr8rc)rrr6r8r9r rz Minuit.minos..z!Cannot scan over fixed parameter )/_cl_to_errordefr)rr,rKrxrreprrirrj_normalize_keyrcrHrIrtr(rr_TemporaryErrordefr#r rQr/rr%ZMErrornumberlowerupperrwZ lower_validZ upper_validZat_lower_limitZat_upper_limitZat_lower_max_fcnZat_upper_max_fcnZ lower_new_minZ upper_new_minr{minr)rzr}r|rF_time)r7r+rrAfactorrpZiparsrippnamerminosrmer8r6r9r:s^4      L   z Minuit.minosrFr)sizeboundgrid subtract_minrrrzUnion[float, UserBound]r!z)Tuple[np.ndarray, np.ndarray, np.ndarray]) vnamer=r>r?r@rrrr5c Cs ||\} } ~|dur:tj|td} | jdkr\tdn"|| |\} } tj| | |td} t| }tj t | t d}t |j }|| td}t| D]d\}}|| |t|j||||j|j||}|jstd| d|tj|j||<|j||<q|r|t|8}| ||fS)a Get Minos profile over a specified interval. Scans over one parameter and minimises the function with respect to all other parameters for each scan point. Parameters ---------- vname : int or str Parameter to scan over. size : int, optional Number of scanning points (Default: 100). Ignored if grid is set. bound : tuple of float or float, optional If bound is tuple, (left, right) scanning bound. If bound is a number, it specifies an interval of N :math:`\sigma` symmetrically around the minimum (Default: 2). Ignored if grid is set. grid : array-like, optional Parameter values on which to compute the profile. If grid is set, size and bound are ignored. subtract_min : bool, optional If true, subtract offset so that smallest value is zero (Default: False). ncall : int, optional Approximate maximum number of calls before minimization will be aborted. If set to 0, use the adaptive heuristic from the Minuit2 library (Default: 0). Note: The limit may be slightly violated, because the condition is checked only after a full iteration of the algorithm, which usually performs several function calls. iterate : int, optional Automatically call Migrad up to N times if convergence was not reached (Default: 5). This simple heuristic makes Migrad converge more often even if the numerical precision of the cost function is low. Setting this to 1 disables the feature. use_simplex: bool, optional If we have to iterate, set this to True to call the Simplex algorithm before each call to Migrad (Default: True). This may improve convergence in pathological cases (which we are in when we have to iterate). Returns ------- array of float Parameter values where the profile was computed. array of float Profile values. array of bool Whether minimisation in each point succeeded or not. See Also -------- profile, contour, mncontour Nrrgrid must be 1D array-likerzMIGRAD fails to converge for =)r0rrrBndimrJ_normalize_boundr empty_likerrirXrr1rrrrrr#r%r&rwrHrIrtr(ror5)r7rAr=r>r?r@rrrrr9rabystatusrrQrrrpr8r8r9 mnprofile9sD>         zMinuit.mnprofile)bandtextzTuple[np.ndarray, np.ndarray])rArLrMr5c KsJ||\}}~d|vr d|d<|j|fi|\}}} ||||||S)a Draw Minos profile over a specified interval (requires matplotlib). See :meth:`mnprofile` for details and shared arguments. The following additional arguments are accepted. Parameters ---------- vname: int or string Which variable to scan over, can be identified by index or name. band : bool, optional If true, show a band to indicate the Hesse error interval (Default: True). text : bool, optional If true, show text a title with the function value and the Hesse error (Default: True). **kwargs : Other keyword arguments are forwarded to :meth:`mnprofile`. Examples -------- .. plot:: plots/mnprofile.py :include-source: See Also -------- mnprofile, draw_profile, draw_contour, draw_mnmatrix r@T)r0rK _draw_profile) r7rArLrMr%rr9rrI_r8r8r9draw_mnprofiles zMinuit.draw_mnprofiled)r=r>r?r@)rAr=r>r?r@r5cCs||\}}~|dur:tj|td}|jdkr\tdn"|||\} } tj| | |td}t|} t|j } t |D]\} }|| |<| | | | <qz|r| t | 8} || fS)a Calculate 1D cost function profile over a range. A 1D scan of the cost function around the minimum, useful to inspect the minimum. For a fit with several free parameters this is not the same as the Minos profile computed by :meth:`mncontour`. Parameters ---------- vname : int or str Parameter to scan over. size : int, optional Number of scanning points (Default: 100). Ignored if grid is set. bound : tuple of float or float, optional If bound is tuple, (left, right) scanning bound. If bound is a number, it specifies an interval of N :math:`\sigma` symmetrically around the minimum (Default: 2). Ignored if grid is set. grid : array-like, optional Parameter values on which to compute the profile. If grid is set, size and bound are ignored. subtract_min : bool, optional If true, subtract offset so that smallest value is zero (Default: False). Returns ------- array of float Parameter values. array of float Function values. See Also -------- mnprofile, contour, mncontour NrrrB) r0rrrBrDrJrErrFr\rr#r5)r7rAr=r>r?r@rrrrGrHrIr\rvir8r8r9profiles +    zMinuit.profilec KsH||\}}~d|vr d|d<|j|fi|\}}||||||S)a^ Draw 1D cost function profile over a range (requires matplotlib). See :meth:`profile` for details and shared arguments. The following additional arguments are accepted. Parameters ---------- band : bool, optional If true, show a band to indicate the Hesse error interval (Default: True). text : bool, optional If true, show text a title with the function value and the Hesse error (Default: True). See Also -------- profile, draw_mnprofile, draw_contour, draw_mncontourprofile r@T)r0rSrN) r7rArLrMr%rr9rrIr8r8r9 draw_profiles zMinuit.draw_profile np.ndarray)rrrIrLrMr5c Csddlm}|j|}||||||d|j|}|j|dddd} d} ||jvr||j|j } ||j|j } n||j |} ||j |} | dur|r|j | | dd|r|j | dur|d |d nd |||| | |d d ||fS)Nrpyplotrr--)colorZ linestylez0.8)Z facecolorz = z.3gz{} = {:.3g} - {:.3g} + {:.3g}Zlarge)Zfontsize) matplotlibrWr/r#xlabelylabelr\axvlinergr3r4raZaxvspantitleformat) r7rrrIrLrMpltr9rZvminZvmaxr8r8r9rN%s4         zMinuit._draw_profile2z+Union[float, Iterable[Tuple[float, float]]]zTuple[ArrayLike, ArrayLike])rrIr=r>r?r@r5cCs||\}}||\} } ~~|durj|\} } tj| td} tj| td}| jdks`|jdkrtdnt|tr|\}}|||}|| |}n t|}|||}|| |}t|tr|\}}n|}|}t |d|d|} t |d|d|}tj t | t |ftd}t|j }t | D]@\}}|||<t |D]$\}}||| <|||||f<qDq,|r|t|8}| ||fS)aT Get a 2D contour of the function around the minimum. It computes the contour via a function scan over two parameters, while keeping all other parameters fixed. The related :meth:`mncontour` works differently: for each pair of parameter values in the scan, it minimises the function with the respect to all other parameters. This method is useful to inspect the function near the minimum to detect issues (the contours should look smooth). It is not a confidence region unless the function only has two parameters. Use :meth:`mncontour` to compute confidence regions. Parameters ---------- x : int or str First parameter for scan. y : int or str Second parameter for scan. size : int or tuple of int, optional Number of scanning points per parameter (Default: 50). A tuple is interpreted as the number of scanning points per parameter. Ignored if grid is set. bound : float or tuple of floats, optional If bound is 2x2 array, [[v1min,v1max],[v2min,v2max]]. If bound is a number, it specifies how many :math:`\sigma` symmetrically from minimum (minimum+- bound*:math:`\sigma`). (Default: 2). Ignored if grid is set. grid : tuple of array-like, optional Grid points to scan over. If grid is set, size and bound are ignored. subtract_min : Subtract minimum from return values (Default: False). Returns ------- array of float Parameter values of first parameter. array of float Parameter values of second parameter. 2D array of float Function values. See Also -------- mncontour, mnprofile, profile Nrrz(grid per parameter must be 1D array-liker)r0rrrBrDrJrrrErrrir\rr#r5)r7rrIr=r>r?r@ixxnameiyynamexgZygZxvZyvxbZybxrangeZyrangerZxsizeZysizeZzvr\rrjyir8r8r9contourSsB8        zMinuit.contour)rrIr5c sddlm}|\}}|\}}~~d|vr.rrX)rYZls) rZrWr0rkrTclabelr[r\axhliner\r])r7rrIr%r`rbrcrdreZvxZvyZvzrCSr8r6r9 draw_contours     zMinuit.draw_contour)r+r= interpolated experimentalrrr) rrIr+r=rrrsrrrr5c Cs||\} } ||\} } ~~t|dd}|r<||jsVtdt|j| | h|}|rxt d||r| || | |||| }n^t |j |B|jdusJt |j |jj|j}|| | |d}Wdn1s0Yt|}tj||dddd}||krtd Ndd lm}tddt|}|||d d }|tdd|}Wdn1s|0Y|S) a Get 2D Minos confidence region. This scans over two parameters and minimises all other free parameters for each scan point. This scan produces a statistical confidence region according to the `profile likelihood method `_ with a confidence level `cl`, which is asymptotically equal to the coverage probability of the confidence region according to `Wilks' theorem `. Note that 1D projections of the 2D confidence region are larger than 1D Minos intervals computed for the same confidence level. This is not an error, but a consequence of Wilks' theorem. The calculation is expensive since a numerical minimisation has to be performed at various points. Parameters ---------- x : str Variable name of the first parameter. y : str Variable name of the second parameter. cl : float or None, optional Confidence level of the contour. If not set or None, a standard 68 % contour is computed (default). If 0 < cl < 1, the value is interpreted as the confidence level (a probability). For convenience, values cl >= 1 are interpreted as the probability content of a central symmetric interval covering that many standard deviations of a normal distribution. For example, cl=1 is interpreted as 68.3 %, and cl=2 is 84.3 %, and so on. Using values other than 0.68, 0.9, 0.95, 0.99, 1, 2, 3, 4, 5 require the scipy module. size : int, optional Number of points on the contour to find (default: 100). Increasing this makes the contour smoother, but requires more computation time. interpolated : int, optional Number of interpolated points on the contour (default: 0). If you set this to a value larger than size, cubic spline interpolation is used to generate a smoother curve and the interpolated coordinates are returned. Values smaller than size are ignored. Good results can be obtained with size=20, interpolated=200. This requires scipy. experimental : bool, optional If true, use experimental implementation to compute contour, otherwise use MnContour from the Minuit2 library. The experimental implementation was found to succeed in cases where MnContour produced no reasonable result, but is slower and not yet well tested in practice. Use with caution and report back any issues via Github. ncall : int, optional This parameter only takes effect if ``experimental`` is True. Approximate maximum number of calls before minimization will be aborted. If set to 0, use the adaptive heuristic from the Minuit2 library (Default: 0). iterate : int, optional This parameter only takes effect if ``experimental`` is True. Automatically call Migrad up to N times if convergence was not reached (Default: 5). This simple heuristic makes Migrad converge more often even if the numerical precision of the cost function is low. Setting this to 1 disables the feature. use_simplex: bool, optional This parameter only takes effect if ``experimental`` is True. If we have to iterate, set this to True to call the Simplex algorithm before each call to Migrad (Default: True). This may improve convergence in pathological cases (which we are in when we have to iterate). Returns ------- array of float (N x 2) Contour points of the form [[x1, y1]...[xn, yn]]. Note that N = size + 1, the last point [xn, yn] is identical to [x1, y1]. This makes it easier to draw a closed contour. See Also -------- contour, mnprofile, profile r(\?r,z5mncontour can only be run on free parameters, not on Nrr)Zaxis interpolation) CubicSplineZperiodic)Zbc_type)r0r.r)rrxrr/r,_free_parametersrJ_experimental_mncontourr1r#rrKrQrZasarrayrr Zscipy.interpolatervrri)r7rrIr+r=rrrsrrrrbrcrdrer7parsceZmncptsrvrfZsplr8r8r9 mncontours>V .    2zMinuit.mncontourr+r=rrrs)rrIr+r=rrrsr5c CsVddlm}ddlm}ddlm} ddlm} ddlm} | |\} } | |\}}| |}dd t |D}g}g}g}|D]p}|j | |||||d }t |d }|d kr|d8}||||g|| jg| jg|| jggqt |t |ks"Jt |d t || ||||}|||| |||S)a  Draw 2D Minos confidence region (requires matplotlib). See :meth:`mncontour` for details on the interpretation of the region and for the parameters accepted by this function. Examples -------- .. plot:: plots/mncontour.py :include-source: Returns ------- ContourSet Instance of a ContourSet class from matplot.contour. See Also -------- mncontour, draw_contour, draw_mnmatrix, draw_profile r) __version__rV)Path) ContourSetr) parse_versioncSsg|]}t|dqSrtrrrr8r8r9rrz)Minuit.draw_mncontour..r}r)rr)rZr~rWZmatplotlib.pathrZmatplotlib.contourrZ_parse_versionrr0rt_iterater|rirZMOVETOZLINETOZ CLOSEPOLYZgcarnr[r\)r7rrIr+r=rrrsZmpl_version_stringr`rrrrbrcrdreZ mpl_versionclsZc_valZc_ptscodesr{Zn_linetocsr8r8r9draw_mncontourYsB        &,   zMinuit.draw_mncontour)r+r=rsfigsize)r+r=rsr5c" sRjstdtjfddjD}t|}|dkrFtdddt|D}t|dkrntdddl m }|j |||d d d \} } d d |D} tj |||dd|t|d} t |D]\} }|| | | fd}t |D]2\}}t|dd}t||}|j|d|dq|dd}tdD]V}j||d d\}}}||}||}|d|kr|d|krq|d9}qD| d7} |||d| |\}}g}t t||D]b\}\}}||kr ||d|kr |||d||kr||d|kr||q|r^tg||R}tg||R}||f| |<|d|dt| D]}||}|| | |f|jj|j|dddt |D]\}}j|||||d}| d7} t|dkrt|\}}|j||d|d||f||ffD]B\} }!| |!\}}tt| |}tt| |}||f| |!<q.q| || fd qqWdn1s0Yt |D]\} }| | | fj| || dkr| | df|| d| f |t| D]:}||}| || fj| || || fj!| |q q| | fS)a1 Draw matrix of Minos scans (requires matplotlib). This draws a matrix of Minos likelihood scans, meaning that the likelihood is minimized with respect to the parameters that are not scanned over. The diagonal cells of the matrix show the 1D scan, the off-diagonal cells show 2D scans for all unique pairs of parameters. The projected edges of the 2D contours do not align with the 1D intervals, because of Wilks' theorem. The levels for 2D confidence regions are higher. For more information on the interpretation of 2D confidence regions, see :meth:`mncontour`. Parameters ---------- cl : float or array-like of floats, optional See :meth:`mncontour`. size : int, optional See :meth:`mncontour` experimental : bool, optional See :meth:`mncontour` figsize : (float, float) or None, optional Width and height of figure in inches. Examples -------- .. plot:: plots/mnmatrix.py :include-source: Returns ------- fig, ax Figure and axes instances generated by matplotlib. See Also -------- mncontour, mnprofile, draw_mncontour, draw_contour, draw_profile r,csg|]}j|s|qSr8r-rr r6r8r9rrz(Minuit.draw_mnmatrix..rzall parameters are fixedcSsg|]}t|dqSrrrr8r8r9rrzcl must have at least one valuerVTF)rconstrained_layoutZsqueezecSsi|]}|tjtj fqSr8)rrrr8r8r9rrz(Minuit.draw_mnmatrix..rr)Z max_valuertC)rYr3r)r>r@g?r+)r+r=rsN)"rxrr/r,rArirtrrJrZrWZsubplots ProgressBarrZscar.maxrorrKr#rrr5Zylimr\r|rZ transposeZ set_visibleZset_xlimZ set_ylabelZ set_xlabelZset_ylim)"r7r+r=rsrryrjrr`figaxZprangebarrZpar1Zfmaxrfr>iterrrIokrGrHZextremesZxkZykriZpar2clir{rr r8r6r9 draw_mnmatrixs.            8  zMinuit.draw_mnmatrixcKs:||}tr ddlm}n ddlm}|||||S)a Interactive GUI for fitting. Starts a fitting application (requires PySide6, matplotlib) in which the fit is visualized and the parameters can be manipulated to find good starting parameters and to debug the fit. When called in a Jupyter notebook (requires ipywidgets, IPython, matplotlib), a fitting widget is returned instead, which can be displayed. Parameters ---------- plot : Callable, optional To visualize the fit, interactive tries to access the visualize method on the cost function, which accepts the current model parameters as an array-like and potentially further keyword arguments, and draws a visualization into the current matplotlib axes. If the cost function does not provide a visualize method or if you want to override it, pass the function here. raise_on_exception : bool, optional The default is to catch exceptions in the plot function and convert them into a plotted message. In unit tests, raise_on_exception should be set to True to allow detecting errors. **kwargs : Any other keyword arguments are forwarded to the plot function. Examples -------- .. plot:: plots/interactive.py :include-source: See Also -------- Minuit.visualize r) make_widget)r$rt is_jupyterZiminuit.ipywidgetrZiminuit.qtwidget)r7r#Zraise_on_exceptionr%rr8r8r9 interactive$ s )  zMinuit.interactivezSet[str]cCstdd|jDS)Ncss|]}|js|jVqdSrS)r r~rmpr8r8r9rX rz*Minuit._free_parameters..)setr1r6r8r8r9rwW szMinuit._free_parametersr cCst}|jdur|j|_|SrS)r r&eps)r7rr8r8r9r Z s zMinuit._mnprecisionzTuple[int, str])rr5cCs`t|tr:||jkr,td|d|jd||j|fS||jvrRtd||j||fS)Nz parameter z is out of range (max: )zunknown parameter )rrRrjrJr/r.)r7rr8r8r9r0` s   zMinuit._normalize_keystrz,Union[float, UserBound, Tuple[float, float]]zTuple[float, float])rAr>r5cCsTt|trt|S|js(tdtj|j|}|j |}||||||fS)Nz8Specified nsigma bound, but error matrix is not accurate) rrrtZ_normalize_limitryrHrIr(r\ra)r7rAr>rsigmar8r8r9rEi s    zMinuit._normalize_boundcCs&|jr"|j|jjjkr"t|j|_dSrS)r,r1rKrrr6r8r8r9_copy_state_if_neededx s zMinuit._copy_state_if_neededc Cs|jjr|jj}t|j}t|}|j|jkri}d}|jD]}|j s>|||j <|d7}q>| d| D].\}}| D]\} } ||| f||| f<q~qnn8t|}t |D]&}t |D]} ||| f||| f<qq||_nd|_dSNrr)r1Zhas_covariancerhrtZMatrixr.riZnrowrjr r2fillrrr-) r7ZcovmrZext2intrrrrrrir8r8r9r s*        zMinuit._make_covariancecCs(t|j|j|j}|r$|d9}|S)NgMb`?)rrPrDr r)r7rrr8r8r9r s zMinuit._edm_goalcCs|j}dd|d||S)NrQr)rl)r7rr8r8r9r szMinuit._migrad_maxcallcCs|j p|jjj|juSrS)r,rKrr1r6r8r8r9r) sz6Minuit._fmin_does_not_exist_or_last_state_was_modifiedcCshg}|jdur|t|j|t|j|jrD|t|j|jdur^|t|jd|S)z!Get detailed text representation.N )rnrr/rsrgrhrr7sr8r8r9__repr__ s  zMinuit.__repr__cCshg}|jdur|t|j|t|j|jrD|t|j|jdur^|t|jd|S)z&Get user-friendly text representation.Nr)rnrrrsrgrhrrr8r8r9__str__ s  zMinuit.__str__c Csd}|jdur||j7}||j7}|jr>||j7}|jdurV||j7}|jdurzddlm}ddl}tddf| | 6}|j |ddd| d|| 7}Wdn1s0YWdn1s0YWntttfyYn0|S)Nrrrrlsvg )r_Zdpi)rn _repr_html_rsrgrhZmatplotlib.pyplotrWio_TemporaryFigurer&StringIOZsavefigseekreadrAttributeErrorrJ)r7rr`rr8r8r9r s*       LzMinuit._repr_html_cCs"|r|dn|t|dS)Nz )rMr)r7r cycler8r8r9 _repr_pretty_ s zMinuit._repr_pretty_cCs>|jj}|dur:t|dr"|j}nd|jjd}t||S)Nr&zclass zX has no visualize method, please use the 'plot' keyword to pass a visualization function)r#hasattrr&rrr)r7r#ZpyfcnrLr8r8r9r$ s zMinuit._visualizezList[Tuple[float, float]])r7rbrdr=rrrr5c sddlm} jg jdus(Jtj jf jfg jf jfgg\} | dtd g} tjtj tj |ddD] fdd f dd } d} | | dkr| d kr| d9} q| d kr| tj tj fqd } | | dkr:| d kr:| d 9} q| d krT| | q|| | | fdd}| |j r||j n tj tj fq| S)Nr) root_scalarr3F)Zendpointcs|dt|dtf}|dd}j}|durjt|dt||d}|dd}|durt|dt||d}||fSr)rcossinrerr5)zrrrrI)centerrbphirr7ur8r9r^ s z,Minuit._experimental_mncontour..argsc sztj}|||}||d||dtj|jj}|jjjj Sr) rr1rrrr#r%r&rorC)rrZxyrp) r^r7rrbrdrr7rQrr8r9r s"    z,Minuit._experimental_mncontour..scangHz>g333333?g?gMbP?)ZbracketZxtol)rrr\rhrrZeigrrpirnanZ convergedroot)r7r7rbrdr=rrrrrrzrrGrHrr8) r^rr7rrbrdrrrr7rQrrr9rx s:      &zMinuit._experimental_mncontour)NrT)N)N)NNNNNN)N)N)NF)F)Jrrr__doc__r__annotations__Z LEAST_SQUARESZ LIKELIHOODpropertyr:r<r?r@rArDsetterrNrPrQrVrZr\rarcrergrhrjrlrmrnrorsrvrxryr{r}rrrrrrr"r&rr:rKrPrSrTrNrkrqr|rrrrwr r0rErrrrr)rrrrr$rxr8r8r8r9r"-sV            C#D:p Vq"i)B3a*$H 3     r=rUzDict[str, float]r)r?r^rr5c Cst|}|r |rTtd|n4|D]&}||vr$t|dd|dq$t|}t||krxt|dt|dt}t|D]4\}}|r||n||}t|} |||| q|S)NzFpositional arguments cannot be mixed with parameter keyword arguments z is not one of the parameters [rrz values given for z function parameter(s))rirrrrrtZ_guess_initial_stepadd) r?r^rnargskwrrrvalerrr8r8r9rI s0  rrfrq)mpsrgr5cs,dddfdd tfdd|DS)NrzOptional[Tuple[float, float]])r~r5cs |vr|}|j|jfSdSrS)r3r4)r~r;)rgr8r9get_mej s z_get_params..get_mec 3sR|]J}t|j|j|j|j|j|j|j|jr6|j nd|j rD|j nd VqdSrS) rtParamr2r~rFrZis_constr Zhas_lower_limitr Zhas_upper_limitrr)rr8r9rq s z_get_params..)rtZParams)rrgr8)rrgr9rri s  rrc@s:eZdZdddddZdddd Zd dd d d ZdS)r1rrB)r:r7cCs"|j|_||_|jj|9_dSrS)rCsavedr:)r7r:r7r8r8r9r sz_TemporaryErrordef.__init__rEr4cCsdSrSr8r6r8r8r9 __enter__ sz_TemporaryErrordef.__enter__objectr]cGs|j|j_dSrS)rr:rCr_r8r8r9__exit__ sz_TemporaryErrordef.__exit__Nrrrrrrr8r8r8r9r1 sr1c@s2eZdZddZddddZdddd d Zd S) rcCs,ddlm}||_|jj||fdd|_dS)NrrVT)rr)rZrWr`Zfigurer)r7wrr`r8r8r9r s z_TemporaryFigure.__init__rEr4cCsdSrSr8r6r8r8r9r sz_TemporaryFigure.__enter__rr]cGs|j|jdSrS)r`closerr_r8r8r9r sz_TemporaryFigure.__exit__Nrr8r8r8r9r src Cs d|krdksnJt|dur(|n|}|dkr>td|dkrp|dkrX|d}qddd d d |d }n d ddddddddd |d }|d krzddlm}Wn4ty}z|jd7_WYd}~n d}~00|dkr|d|d}|||}|S)Nrrzcl must be positiverr2rg'ns?gi@g~N@g%U"@)rt?ffffff?Gz?ggcq;@gUk@gs{B@gUk"@gȒK]@g fe@gyh'@g{U3@gϤAHc<@) rtrrrr2g@g@g@g@)chi2zT You set an uncommon cl value, scipy is needed to process it. Please install scipy.) rBrJrZ scipy.statsrrrLZcdfZppf)r+rjdefaultr7rrr8r8r9r. sL   r.rrRrrBrMrXr) r:rrrQ tolerancerNrrr5c Cst|||}|dur||_|||} td}t|| j|}| js| js|dkr|rt|| j|} |durn|| _| ||} t|| j|}|dur||_|||} |d8}q:| S)Nrr)r rNrrrwZhas_reached_call_limitr ) r:rrrQrrNrrrrprr8r8r9r s$     r)7r __future__rrHZiminuitrrtZ iminuit.utilrrZ iminuit._corerrrr r r r r rrrZiminuit.warningsrnumpyrtypingrrrrrrrrrrrZiminuit.typingrrrZiminuit._optional_dependenciesr Z numpy.typingr!rU__all__r"rrrr1rr.rr8r8r8r9sP   4 4   0  0