a 5gh@sdZddlmZddlZddlmZddlmZddlm Z m Z m Z ddl m Z mZmZmZddlmZmZmZddlZdd lmZmZdd lmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*ddl+Z+dd l,m-Z-ddl.Z.ddl/Z/e'd Z0d Z1Gddde+j2Z3dddddZ4Gddde3Z5Gddde3Z6Gddde3Z7Gddde3Z8dddd d!Z9Gd"d#d#ej:Z;Gd$d%d%ZZ?Gd*d+d+Z@Gd,d-d-eZAe Bd.d/d0d1d2d3d4d5ZCGd6d7d7ZDe Bd8d9d:d;dd>d/d?d@dAZFddCdDdEdFdGdHZGed/dIdJdKdLZHed/dDdMdNdOdLZHdBddPdLZHdQdRZIdSdTZJdUdVZKdWdXdYdZd[ZLd\d\d]d^d_ZMd`dadbdcdddeZNd`dfddcdgdhZOd`didjdcdkdlZPdddmdndoZQdpdqZRdrd d dsdtduZSGdvdwdwZTdxdyZUdd}d~ZVddDdddZWdddmddZXddDdddZYdDdddZZd\d\dddZ[d\d\d\d\dddZ\dS)z Data classes and utilities used by :class:`iminuit.Minuit`. You can look up the interface of data classes that iminuit uses here.  annotationsN) OrderedDict) Namespace) _repr_html _repr_text _deprecated)Key UserBoundCost CostGradient)IMinuitWarningHesseFailedWarningPerformanceWarning)NDArray ArrayLike)overloadAnyListUnionDictIterable GeneratorTupleOptionalCallable CollectionSequenceTypeVar Annotatedget_args get_origin) monotonicT)r rr ValueView FixedView LimitViewMatrixFMinParamParamsMErrorMErrorsmake_func_codemake_with_signaturemerge_signaturesdescribegradientis_positive_definitec@seZdZdZdZd)dddddZd d d d Zdd d dZej dddddZ ej ddddddZ dddddZ ddddddZ dddd d!Zd"d d#d$Zd%d d&d'Zd(S)* BasicViewz Array-like view of parameter state. Derived classes need to implement methods _set and _get to access specific properties of the parameter state. :meta private: _minuit_ndimrrint)minuitndimcCs||_||_dSNr4)selfr8r9r<\/mounts/lovelace/software/anaconda3/envs/metaDMG/lib/python3.9/site-packages/iminuit/util.py__init__KszBasicView.__init__rreturnccs"tt|D]}||Vq dS)zGet iterator over values.N)rangelen_getr;ir<r<r=__iter__PszBasicView.__iter__cCs|jjS)zGet number of paramters.)r5Znparr;r<r<r=__len__UszBasicView.__len__)idxr@cCstSr:NotImplemented)r;rIr<r<r=rCYszBasicView._getNone)rIvaluer@cCstdSr:rJ)r;rIrMr<r<r=_set]szBasicView._setr keyr@cs4tjj|}t|tr*fdd|DS|S)a Get values of the view. Parameters ---------- key: int, str, slice, list of int or str If the key is an int or str, return corresponding value. If it is a slice, list of int or str, return the corresponding subset. csg|]}|qSr<rC.0rErGr<r= mz)BasicView.__getitem__..) _key2indexr5_var2pos isinstancelistrC)r;rPindexr<rGr= __getitem__as  zBasicView.__getitem__)rPrMr@cCs|jt|jj|}t|trt||jkrH|D]}|||q4qt|t|kr`t dt ||D]\}}|||qjn |||dS)zFAssign new value at key, which can be index, parameter name, or slice.z'length of argument does not match sliceN) r5Z_copy_state_if_neededrVrWrXrYr6rNrB ValueErrorzip)r;rPrMrZrEvr<r<r= __setitem__ps  zBasicView.__setitem__objectboolotherr@cCs"t||\}}tt||kS)z$Return true if all values are equal.)npZbroadcast_arraysraall)r;rcabr<r<r=__eq__szBasicView.__eq__strcCsFd|jj}t|jj|D]\}}|d|d|7}q|d7}|S)!Get detailed text representation.< =>) __class____name__r]r5_pos2var)r;skr^r<r<r=__repr__s zBasicView.__repr__zDict[str, float]csfddtjjDS)zObtain dict representation.csi|]\}}||qSr<rQ)rSrErsrGr<r= rUz%BasicView.to_dict..) enumerater5rqrGr<rGr=to_dictszBasicView.to_dictN)r)rp __module__ __qualname____doc__ __slots__r>rFrHabcabstractmethodrCrNr[r_rhrtrwr<r<r<r=r3?s r3rr7objr@cCs8d}t|tr4|d7}|D]}|dur|}qqq4q|S)NrrXr)rndxr<r<r=r6s r6c@s2eZdZdZdddddZddddd d Zd S) r$z$Array-like view of parameter values.r7floatrEr@cCs|jj|jSr:)r5 _last_staterMrDr<r<r=rCszValueView._getrLrErMr@cCs|jj||dSr:)r5r set_valuer;rErMr<r<r=rNszValueView._setNrprxryrzrCrNr<r<r<r=r$sr$c@s2eZdZdZdddddZddddd d Zd S) ErrorViewz$Array-like view of parameter errors.r7rrcCs|jj|jSr:)r5rerrorrDr<r<r=rCszErrorView._getrLrcCs0|dkrtdtt|}|jj||dS)NrzRAssigned errors must be positive. Non-positive values are replaced by a heuristic.)warningswarnr _guess_initial_stepr5r set_errorrr<r<r=rNszErrorView._setNrr<r<r<r=rsrc@s@eZdZdZdddddZddddd d Zd d d dZdS)r%z0Array-like view of whether parameters are fixed.r7rarcCs|jj|jSr:)r5ris_fixedrDr<r<r=rCszFixedView._getrL)rEfixr@cCs&|r|jj|n|jj|dSr:)r5rrrelease)r;rErr<r<r=rNszFixedView._setrYr?csfddttDS)z#Return list with inverted elements.csg|]}| qSr<rQrRrGr<r=rTrUz(FixedView.__invert__..)rArBrGr<rGr= __invert__szFixedView.__invert__N)rprxryrzrCrNrr<r<r<r=r%sr%csHeZdZdZddfdd Zdddd d Zdd d d ddZZS)r&z$Array-like view of parameter limits.r)r8cstt||ddS)Nr)superr&r>)r;r8ror<r=r>szLimitView.__init__r7Tuple[float, float]rcCs2|jj|}|jr|jntj |jr*|jntjfSr:)r5rhas_lower_limit lower_limitrdinfhas_upper_limit upper_limit)r;rEpr<r<r=rCs zLimitView._getr rL)rEargr@cCs|jj}||j}||j}||t|\}}|tj krl|tjkrl||kr\||q| |||n0|tj kr| ||n|tjkr| ||||kr|}n ||kr|}| ||| ||dSr:)r5rrMrZ remove_limits_normalize_limitrdrrZ set_limitsZset_lower_limitZset_upper_limitrr)r;rErstatevalerrlowhighr<r<r=rNs&         zLimitView._set)rprxryrzr>rCrN __classcell__r<r<rr=r&sr&zOptional[Iterable]r)limr@cCs\|durtj tjfS|\}}|dur.tj }|dur.z parameters must be tuple or dict) rXdicttuplerv TypeErrorrBr__new__rW)clsrvar2posnrrr<r=r s  zMatrix.__new__rLr~cCs"|duri|_nt|di|_dS)zFor internal use.NrW)rWgetattr)r;rr<r<r=__array_finalize__szMatrix.__array_finalize__z3Union[Key, Tuple[Key, Key], Iterable[Key], NDArray]rrOcs|jfddt|tr6|}t||fSt|ttfrTt|St|trt|tj sfdd|D}t|j }tj ||j St|S)zGet matrix element at key.csZt|tr|St|tr6t|j|j|jSt|trVtfdd|DS|S)Nc3s|]}|VqdSr:r<rSrstrafor<r= +rUz4Matrix.__getitem__..trafo..)rXrislicestartstopsteprrPrrr<r=r%s   z!Matrix.__getitem__..trafocsg|] }|qSr<r<rrr<r=rT6rUz&Matrix.__getitem__..) rWrXrrr[rirrrdndarrayr#)r;rPslindex2trrr=r[s zMatrix.__getitem__zDict[Tuple[str, str], float]r?cCsXt|j}i}t|D]<\}}t|t|D]$}||}t|||f|||f<q,q|S)z Convert matrix to dict. Since the matrix is symmetric, the dict only contains the upper triangular matrix. )rrWrvrArBr)r;namesdrEpijZpjr<r<r=rw;s zMatrix.to_dictz'Tuple[List[List[str]], Tuple[str, ...]]cs`t|j}t|g}t|t|D].\}||gfddtDq(||fS)a Convert matrix to tabular format. The output is consumable by the external `tabulate `_ module. Examples -------- >>> import tabulate as tab >>> from iminuit import Minuit >>> m = Minuit(lambda x, y: x ** 2 + y ** 2, x=1, y=2).migrad() >>> tab.tabulate(*m.covariance.to_table()) x y -- --- --- x 1 -0 y -0 4 csg|]}|qSr<r<)rSrrErZnumsr<r=rTarUz#Matrix.to_table..)rrWrZ matrix_formatrBrvappendrA)r;rtabnamer<rr=to_tableJs  (zMatrix.to_tablecCs.|}t|d}|t||d}|S)z Compute and return correlation matrix. If the matrix is already a correlation matrix, this effectively returns a copy of the original matrix. ?g0.++)copyrddiagouter)r;rfrr<r<r= correlationdszMatrix.correlationcstt|S)rj)rr'__str__rGrr<r=rtpszMatrix.__repr__cCs|jdkrt|St|S)&Get user-friendly text representation.)r9reprrmatrixrGr<r<r=rts zMatrix.__str__cCs t|Sr:)rrrGr<r<r= _repr_html_zszMatrix._repr_html_cCs"|r|dn|t|dS)Nz textrir;rcycler<r<r= _repr_pretty_}s zMatrix._repr_pretty_cs t\}}}||||jffS)z,Get representation for pickling and copying.)r __reduce__rW)r;Zrestoreargsrrr<r=rszMatrix.__reduce__cs|\}|_t|dS)zRestore from pickled state.N)rWr __setstate__)r;rrr<r=rs zMatrix.__setstate__)rprxryrzr{rrr[rwrrrtrrrrrrr<r<rr=r's   r'c@seZdZdZdZdddddddddd Zedd d d Zedd d dZedd ddZ edd ddZ edd ddZ edd ddZ edd ddZ edd ddZedd ddZedd ddZedd d d!Zedd d"d#Zedd d$d%Zedd d&d'Zedd d(d)Zedd d*d+Zedd d,d-Zedd d.d/Zedd d0d1Zd2dd3d4d5Zdd d6d7Zdd d8d9Zdd d:d;Zdddd?Zd@S)Ar(a Function minimum view. This object provides detailed metadata about the function minimum. Inspect this to check what exactly happened if the fit did not converge. Use the attribute :attr:`iminuit.Minuit.fmin` to get the best fit values, their uncertainties, or the function value at the minimum. For convenience, you can also get a basic OK from :class:`iminuit.Minuit` with the methods :attr:`iminuit.Minuit.valid` and :attr:`iminuit.Minuit.accurate`. See Also -------- :attr:`iminuit.Minuit.values` :attr:`iminuit.Minuit.errors` :attr:`iminuit.Minuit.merrors` :attr:`iminuit.Minuit.covariance` :attr:`iminuit.Minuit.fval` :attr:`iminuit.Minuit.valid` :attr:`iminuit.Minuit.accurate` )_src _algorithm_has_parameters_at_limit_nfcn_ngrad_ndof _edm_goal_timerrir7r)fmin algorithmnfcnngradndofedm_goaltimec Cs||_||_d|_|jD]h}|js|js*q|j} |j} |jrB|j nt j } |j rV|j nt j } |jt| | | | d| kO_q||_||_||_||_||_dS)NFr)rrrrr has_limitsrMrrrrdrrrminrrrrr) r;rrrrrrrmpr^eZlbZubr<r<r=r>s   &z FMin.__init__r?cCs|jS)z.relaxed_equalc3s|]}|VqdSr:r<rrcrr;r<r=rrUzFMin.__eq__..rer{r;rcr<rr=rhsz FMin.__eq__cCsLd}tt|D].}|dr qt||}|d|d|7}q|d7}|S)rjzrrr<r<r=rs zFMin._repr_pretty_N)rprxryrzr{r>propertyrrrrrrrrrrrrrrrrrrrrhrtrrrr<r<r<r=r(s\         r(c@seZdZdZdZddddZddd d d Zd d ddZeddZ eddZ eddZ d d ddZ ddddddZ dS)r)z#Data object for a single Parameter.) numberrrMrmerrorZis_constrrrz;Union[int, str, float, Optional[Tuple[float, float]], bool]rcGs<t|t|jksJt|j|D]\}}t|||q"dSr:rBr{r]setattrr;rrsrr<r<r=r>szParam.__init__r`rarbcstfddjDS)$Return True if all values are equal.c3s"|]}t|t|kVqdSr:rrrcr;r<r=rrUzParam.__eq__..rrr<rr=rhsz Param.__eq__rir?cCs@g}|jD]"}t||}||d|q dd|dS)rjrmzParam(z, ))r{rrjoin)r;pairsrsr^r<r<r=rts   zParam.__repr__cCs |jp |jS)z8Query whether the parameter has an lower or upper limit.)rrrGr<r<r=rszParam.has_limitscCs |jduS)z*Query whether parameter has a lower limit.N)rrGr<r<r=rszParam.has_lower_limitcCs |jduS)z+Query whether parameter has an upper limit.N)rrGr<r<r=rszParam.has_upper_limitcCs t|gSrrparamsrGr<r<r=rsz Param.__str__rrLrcCs"|r|dn|t|dS)Nz Param(...)rrr<r<r=rs zParam._repr_pretty_N)rprxryrzr{r>rhrtr rrrrrr<r<r<r=r)s     r)csDeZdZdZdZddZddZfddZd d Zd d Z Z S) r*z,Tuple-like holder of parameter data objects.r<cCs t|Sr:)rrrGr<r<r=rszParams._repr_html_c Csgd}g}t|D]\}}|j}||g}|j}|rVtj|j|jg|R\}} } } nt|j|j\}} d} d} ||| | | |jdur|jnd|jdur|jnd|j rdndg7}| |q||fS)a Convert parameter data to a tabular format. The output is consumable by the external `tabulate `_ module. Examples -------- >>> import tabulate as tab >>> from iminuit import Minuit >>> m = Minuit(lambda x, y: x ** 2 + (y / 2) ** 2 + 1, x=0, y=0) >>> m.fixed["x"] = True >>> m.migrad().minos() >>> tab.tabulate(*m.params.to_table()) pos name value error error- error+ limit- limit+ fixed ----- ------ ------- ------- -------- -------- -------- -------- ------- 0 x 0 0.1 yes 1 y 0 1.4 -1.0 1.0 ) posrrMrzerror-zerror+zlimit-zlimit+fixedNyes) rvrr rZ pdg_formatrMrrrrr) r;headerrrErrrowmerrZmelZmeur<r<r=rs, "  zParams.to_tablecs>t|tr.t|D]\}}|j|krq*q|}tt||S);Get item at key, which can be an index or a parameter name.)rXrirvrrr*r[)r;rPrErrr<r=r[/s   zParams.__getitem__cCs t|SrrrGr<r<r=r8szParams.__str__cCs"|r|dn|t|dS)Nz Params(...)rrr<r<r=r<s zParams._repr_pretty_) rprxryrzr{rrr[rrrr<r<rr=r*s6 r*c@sneZdZdZdZddddZddd d d Zd d ddZd d ddZd d ddZ ddddddZ dS)r+a* Minos data object. Attributes ---------- number : int Parameter index. name : str Parameter name. lower : float Lower error. upper : float Upper error. is_valid : bool Whether Minos computation was successful. lower_valid : bool Whether downward scan was successful. upper_valid : bool Whether upward scan was successful. at_lower_limit : bool Whether scan reached lower limit. at_upper_limit : bool Whether scan reached upper limit. at_lower_max_fcn : bool Whether allowed number of function evaluations was exhausted. at_upper_max_fcn : bool Whether allowed number of function evaluations was exhausted. lower_new_min : float Parameter value for new minimum, if one was found in downward scan. upper_new_min : float Parameter value for new minimum, if one was found in upward scan. nfcn : int Number of function calls. min : float Function value at the new minimum. )r rlowerupperrZ lower_validZ upper_validZat_lower_limitZat_upper_limitZat_lower_max_fcnZat_upper_max_fcnZ lower_new_minZ upper_new_minrrzUnion[int, str, float, bool]r cGs<t|t|jksJt|j|D]\}}t|||q"dSr:r rr<r<r=r>{szMError.__init__r`rarbcstfddjDS)rc3s"|]}t|t|kVqdSr:rrrr<r=rrUz MError.__eq__..rrr<rr=rhsz MError.__eq__rir?cCsBd}t|jD]&\}}t||}|d|d|7}q|d7}|S)rjzrrr<r<r=rs zMError._repr_pretty_N) rprxryrzr{r>rhrtrrrr<r<r<r=r+Cs% r+c@s<eZdZdZdZddZddZddZd d Zd d Z d S)r,z9Dict-like map from parameter name to Minos result object.r<cCs t|Sr:r$rGr<r<r=rszMErrors._repr_html_cCs dddd|DdS)rjz .z >)rvaluesrGr<r<r=rtszMErrors.__repr__cCs t|Srr"rGr<r<r=rszMErrors.__str__cCs"|r|dn|t|dS)Nz rrr<r<r=rs zMErrors._repr_pretty_cCsht|tr\|dkr|t|7}|dks2|t|kr:tdt|D]\}}||krBqXqB|}t||S)rrzindex out of range)rXr7rB IndexErrorrvrr[)r;rPrErsr<r<r=r[s  zMErrors.__getitem__N) rprxryrzr{rrtrrr[r<r<r<r=r,sr,z0use jacobi.propagate instead from jacobi libraryrzCollection[float]zCollection[Collection[float]]zTuple[NDArray, NDArray])fnrcovr@c Csddlm}t|}t|dkr,tdt|}|jd|jdkrRtdd}t||d}t |dks~td ||}t||||} t d | | |} |t|dkrt | n| fS) a Numerically propagates the covariance into a new space. This function is deprecated and will be removed. Please use jacobi.propagate from the jacobi library, which is more accurate. The signatures of the two functions are compatible, so it is a drop-in replacement. Parameters ---------- fn: callable Vectorized function that computes y = fn(x). x: array-like with shape (N,) Input vector. cov: array-like with shape (N, N) Covariance matrix of input vector. Returns ------- y, ycov y is the result of fn(x) ycov is the propagated covariance matrix. r) approx_fprimerzcov must be 2D array-likerzcov must have shape (N, N)g|=rz;diagonal elements of covariance matrix must be non-negativezij,kl,jl) Zscipy.optimizer*rdZ atleast_1dr9r\ atleast_2dshaperreZeinsumZsqueeze) r(rr)r*ZvxZvcovtoldxyZjacZycovr<r<r= propagates   r0c@s$eZdZddZddZddZdS)_TimercCs|r |jnd|_dS)Ng)rrM)r;rr<r<r=r>sz_Timer.__init__cCs|jt7_dSr:)rMr"rGr<r<r= __enter__sz_Timer.__enter__cGst|j|_dSr:)r"rMr;rr<r<r=__exit__sz_Timer.__exit__N)rprxryr>r2r4r<r<r<r=r1sr1zUse of ``func_code`` attribute to declare parameters is deprecated. Use ``_parameters`` instead, which is a dict of parameter names to limits.zCollection[str]r)rr@cCstt|t|dS)z Make a func_code object to fake a function signature. Example:: def f(a, b): ... f.func_code = make_func_code(["x", "y"]) ) co_varnames co_argcount)rrrB)rr<r<r=r-sr-ri)callablevarnames replacementsr@c stddr|t}t|}|t|kr4td||d|<|D]\}}||}|||<qHfddt|DGfddd}|S) a Return new callable with altered signature. Parameters ---------- callable: Original callable with positional arguments, whose names shall be changed. *varnames: sequence of str Replace the first N argument names with these. **replacements: mapping of str to str, optional Replace old argument name (key) with new argument name (value). Returns ------- Callable with positional-only arguments. Trz'varnames longer than original signatureNcsi|]\}}||qSr<r<)rSnewold)parsr<r=ru'rUz'make_with_signature..cs(eZdZddZdddfdd ZdS)z#make_with_signature..CallercSs ||_dSr:) _parameters)r;rr<r<r=r>*sz,make_with_signature..Caller.__init__r)rr@cs|Sr:r<r3r7r<r=__call__-sz,make_with_signature..Caller.__call__N)rprxryr>r?r<r>r<r=Caller)sr@)r0rYrBr\itemsrZr]) r7r8r9rrr;r:rEr@r<)r7r<r=r. s     r.FzIterable[Callable]razTuple[Any, List[List[int]]]) callablesrr@c Csg}g}g}|D]p}g}tt|ddD]H\}\}} ||vrR|||q,|t||||| q,||q|rddt||D|fS||fS)a Merge signatures of callables with positional arguments. This is best explained by an example:: def f(x, y, z): ... def g(x, p): ... parameters, mapping = merge_signatures(f, g) # parameters is ('x', 'y', 'z', 'p') # mapping is ([0, 1, 2], [0, 3]) Parameters ---------- callables : Callables whose parameters can be extracted with :func:`describe`. annotations : bool, optional Whether to return the annotions. Default is False, for backward compatibility. Returns ------- tuple(parameters, mapping) parameters is the tuple of the merged parameter names. mapping contains the mapping of parameters indices from the merged signature to the original signatures. TrcSsi|]\}}||qSr<r<)rSrsrfr<r<r=rubrUz$merge_signatures..)rvr0rArrZrBr]) rBrrannsmappingfZamaprErsannr<r<r=r/3s    r/z List[str])r7r@cCsdSr:r<r>r<r<r=r0fsr0z(Dict[str, Optional[Tuple[float, float]]])r7rr@cCsdSr:r<)r7rr<r<r=r0jscCsLt|dkr|riSgSt|dip:t|p:t|p:t|}|rD|St|S)a Attempt to extract the function argument names and annotations. Parameters ---------- callable : callable Callable whose parameter names should be extracted. annotations : bool, optional Whether to also extract annotations. Default is false. Returns ------- list or dict If annotate is False, return list of strings with the parameters names if successful and an empty list otherwise. If annotations is True, return a dict, which maps parameter names to annotations. For parameters without annotations, the dict maps to None. Notes ----- Parameter names are extracted with the following three methods, which are attempted in order. The first to succeed determines the result. 1. Using ``obj._parameters``, which is a dict that maps parameter names to parameter limits or None if the parameter has to limits. Users are encouraged to use this mechanism to provide signatures for objects that otherwise would not have a detectable signature. Example:: def f(*args): # no signature x, y = args return (x - 2) ** 2 + (y - 3) ** 2 f._parameters = {"x": None, "y": (1, 4)} Here, the first parameter is declared to have no limits (values from minus to plus infinity are allowed), while the second parameter is declared to have limits, it cannot be smaller than 1 or larger than 4. Note: In the past, the ``func_code`` attribute was used for a similar purpose as ``_parameters``. It is still supported for legacy code, but should not be used anymore in new code, since it does not support declaring parameter limits. If an objects has a ``func_code`` attribute, it is used to detect the parameters. Example:: from iminuit.util import make_func_code def f(*args): # no signature x, y = args return (x - 2) ** 2 + (y - 3) ** 2 # deprecated, make_func_code will raise a warning f.func_code = make_func_code(("x", "y")) 2. Using :func:`inspect.signature`. The :mod:`inspect` module provides a general function to extract the signature of a Python callable. It works on most callables, including Functors like this:: class MyLeastSquares: def __call__(self, a, b): ... Limits are supported via annotations, using the Annotated type that was introduced in Python-3.9 and can be obtained from the external package typing_extensions in Python-3.8. In the following example, the second parameter has a lower limit at 0, because it must be positive:: from typing import Annotated def my_cost_function(a: float, b: Annotated[float, 0:]): ... There are no standard annotations yet at the time of this writing. iminuit supports the annotations Gt, Ge, Lt, Le from the external package annotated-types, and interprets slice notation as limits. 3. Using the docstring. The docstring is textually parsed to detect the parameter names. This requires that a docstring is present which follows the Python standard formatting for function signatures. Here is a contrived example which is parsed correctly: fn(a, b: float, int c, d=1, e: float=2.2, double e=3). Ambiguous cases with positional and keyword argument are handled in the following way:: def fcn(a, b, *args, **kwargs): ... # describe returns [a, b]; # *args and **kwargs are ignored def fcn(a, b, c=1): ... # describe returns [a, b, c]; # positional arguments with default values are detected rr=)_address_of_cfuncr_describe_impl_func_code_describe_impl_inspect_describe_impl_docstringrY)r7rrr<r<r=r0ps]   cCs.t|dr*|j}dd|jd|jDSiS)N func_codecSsi|] }|dqSr:r<r%r<r<r=rurUz,_describe_impl_func_code..)hasattrrKr5r6)r7fcr<r<r=rHs rHcCstzt|}Wnty$iYS0i}|jD]:\}}|jtjjurNqp|jtjjur`qpt |j ||<q4|Sr:) inspect signaturer\rrAkind ParameterVAR_POSITIONAL VAR_KEYWORD _get_limit annotation)r7rOrrZparr<r<r=rIs  rIc s6t|}|duriSz |j}Wnty6iYS0|d}||}|dkrViS|t|7}d}t||dD]6\}}|dkr|d7}n|dkr|d8}|dkrvqqvdd||||dD}t|r|dd}z| d} |d| }Wnt yYn0d d d d d fd d|DS)N(rrrcSsg|]}|dqS)z [])stripr%r<r<r=rTrUz,_describe_impl_docstring..,z*argsri)rrr@cSsn|d}|dkr|d|}|d}|dkr@|d|S|}|d}|dkrj||dS|S)Nrmr:rl)findrX)rrrEr<r<r=extract/s    z)_describe_impl_docstring..extractcsi|]}|dkr|dqS)*Nr<r%r\r<r=ru@rUz,_describe_impl_docstring..) rNgetdocrpAttributeErrorr[rBrvsplitismethodrZr\) r7docrtokenrZnbraceZichchrArEr<r^r=rJs<           rJz'Union[type, Annotated[float, Any], str]zOptional[Tuple[float, float]])rUr@c Cs:ddlm}t|tr|t|krBt|S)Nr)rXrirBr')rrPrEr<r<r=_key2index_items  rwr zUnion[int, List[int]]csdurtttSttr,tSttszttrztdtrhfddttDfddDSt S)N.rcsg|]}|r|qSr<r<rrr<r=rTrUz_key2index..csg|]}t|qSr<)rwr)rr<r=rTrU) rYrArBrXrrvrirrarw)rrPr<)rPrr=rVs  rV)fcnr@cCsVddlm}m}m}m}m}m}|||||}t|dd}t||rR|||j SdS)Nr)c_void_pc_doublec_uint32POINTER CFUNCTYPEcastctypes) rryrzr{r|r}r~rrXrM)rxryrzr{r|r}Z ctypes_castZc_sigr<r<r=rGs     rGccs&t|ts|Vn|D] }|VqdSr:r)rxir<r<r=_iterates rz Optional[T])rr^r@cCs|dur |S|Sr:r<)rr^r<r<r= _replace_nonesrc@sVeZdZUdZdZded<ded<ddZdd Zd d Zd d Z ddZ ddZ dS) ProgressBarzZ Simple progress bar. Renders as nice HTML progressbar in Jupyter notebooks. rr7rM max_valuecCs(|jdd|dd|jdS)N d.0f %_outwriteflush)r;Zfractionr<r<r=_updateszProgressBar._updatecCs|jd|jdS)Nz rrGr<r<r=_finishs zProgressBar._finishcs||_tj|_zt(tdtddlm }Wdn1sF0Yt |j|rddl m m fdd|_fdd|_WntyYn0||jdS) z Initialize bar. Parameters ---------- max_value: int Total number of entries. ignorer) OutStreamN)displayHTMLcs*dd|ddd|ddddS)Nz rTclearr<)r^rrr<r=sz&ProgressBar.__init__..csdddS)NrTrr<r<rr<r=rrU)rsysstdoutrrcatch_warnings simplefilterDeprecationWarningZipykernel.iostreamrrXIPython.displayrrrrModuleNotFoundErrorrM)r;rrr<rr=r>s   *  zProgressBar.__init__cGs|S)zNoop.r<r3r<r<r=r2szProgressBar.__enter__cGs |dS)zClean up the bar.N)rr3r<r<r=r4szProgressBar.__exit__cCs$|j|7_||j|j|S)zIncrement progress.)rMrr)r;r^r<r<r=__add__szProgressBar.__add__N) rprxryrzrM__annotations__rrr>r2r4rr<r<r<r=rs  "rcCs|jdksJ|dur ||fgSg}d}d}d}t|}||kr||sR|d7}q8|d}||krt||rt|d7}qZ|||||||||df|||7}|d}q8|S)Nrr)r9rBr)maskZxeZmaskedsegmentsrfrgamrr<r<r=_histogram_segmentss&  *  r{Gzt? cst}t|||}||} t| } t| } ddt|| D|dd} |dd} d}t| r|d7}||krd|dtd}t|t qt||krd |dtd}t|t qd | | }||} t| t| } t| t| } t|| D]\}}||<qd t fd d | Dt t fd d | Dt }t | |}t | | }||| | k||t ||k@}| |} | |} ||}t | |} t || } q`t}|t|S)NcSsi|]\}}||qSr<r<)rSryir<r<r=ru%rUz#_smart_sampling..rrzIteration limit z% in smart sampling reached, produced z pointsz Time limit rc3s|]}|VqdSr:r<)rSZair/r<r=r@rUz"_smart_sampling..c3s|]}|VqdSr:r<)rSZbirr<r=rArU)r"rdZlinspacermaxr]rBrrRuntimeWarningZfromiterrrtrrYrAsortZ transpose)rEZxminZxmaxrr-maxiterZmaxtimet0rZynewZyminZymaxrfrgZnitermsgZxnewrrZyintZdyr.rZxyr<rr=_smart_samplings^         $  rr)rr@cCsdt|}|ddkrdSt|}tt|}t|t|}t|t|}||kS)NrF)rdrdifflogZstdmean)rZd_linZd_logZ lin_rel_stdZ log_rel_stdr<r<r=_detect_log_spacingTs   rr zOptional[CostGradient]cCs2t|dd}t|dd}|r.t|tr.|r.|SdS)ah Return a callable which computes the gradient of fcn or None. Parameters ---------- fcn: Cost Cost function which may provide a callable gradient. How the gradient is detected is specified below in the Notes. Notes ----- This function checks whether the following attributes exist: `fcn.grad` and `fcn.has_grad`. If `fcn.grad` exists and is a CostGradient, it is returned unless `fcn.has_grad` exists and is False. If no useable gradient is detected, None is returned. Returns ------- callable or None The gradient function or None gradNhas_gradT)rrXr )rxrrr<r<r=r1`s   r1r)mr@cCsLt|}t|j|krHztj|WntjjyBYdS0dSdS)aE Return True if argument is a positive definite matrix. This test is somewhat expensive, because we attempt a cholesky decomposition. Parameters ---------- m : array-like Matrix to be tested. Returns ------- bool True if matrix is positive definite and False otherwise. FT)rdr+rer#ZlinalgZcholeskyZ LinAlgError)rr<r<r=r2}s r2r?cCsJzddlm}|}|dWSty2YdStyDYdS0dS)Nr) get_ipythonZkernelF)ZIPythonrZ has_trait ImportErrorr`)ripr<r<r= is_jupyters    rcCs.|dkr dnd}t|tjkr*|tjjS|S)Nrrr)rtrdrr float_infor)rsignr<r<r= _make_finites r)rvminvmaxr@cCs$t|r t|r d||SdS)Nrs)rdr)rrrr<r<r=_widget_guess_initial_steps r)F)rrrr)]rz __future__rrN collectionsrargparserrkrrrZiminuit.typingr r r r Ziminuit.warningsr rrnumpyrdZ numpy.typingrrrfrrrrrrrrrrrrrrr r!r|rr"rrr#__all__ABCr3r6r$rr%r&rrr'r(r)rr*r+r, deprecatedr0r1r-r.r/r0rHrIrJrTrrvrwrVrGrrrrrrr1r2rrrr<r<r<r=s   H S  ' &>RY$-  *3m K: C 5