B d. @s dZddlZddlZddlZddlZyddlmZWn ek rTddlmZYnXddl m Z m Z ddl Z ddlmZddlmZddlmZmZdd lmZmZdd lmZdd lmZmZmZd d dddddddg ZegZeegZGdddZ GdddZ!Gddde"Z#Gddde#Z$Gddde#e%Z&Gdddej'Z(dd Z)Gd!dde(d"Z*Gd#d d e(d"Z+Gd$ddZ,Gd%d d e(d"Z-Gd&dde*Z.Gd'dde*Z/Gd(dde(d"Z0d7d)d*Z1d+d,Z2d-d.Z3d/d0Z4d1d2Z5d3d4Z6d5d6Z7e7dS)8a This module implements classes (called Fitters) which combine optimization algorithms (typically from `scipy.optimize`) with statistic functions to perform fitting. Fitters are implemented as callable classes. In addition to the data to fit, the ``__call__`` method takes an instance of `~astropy.modeling.core.FittableModel` as input, and returns a copy of the model with its parameters determined by the optimizer. Optimization algorithms, called "optimizers" are implemented in `~astropy.modeling.optimizers` and statistic functions are in `~astropy.modeling.statistic`. The goal is to provide an easy to extend framework and allow users to easily create new fitters by combining statistics with optimizers. There are two exceptions to the above scheme. `~astropy.modeling.fitting.LinearLSQFitter` uses Numpy's `~numpy.linalg.lstsq` function. `~astropy.modeling.fitting.LevMarLSQFitter` uses `~scipy.optimize.leastsq` which combines optimization and statistic in one implementation. N) entry_points)reducewraps)Quantity)AstropyUserWarning)poly_map_domain_combine_equivalency_dict)SLSQPSimplex) leastsquare)DEFAULT_MAXITER DEFAULT_EPS DEFAULT_ACCLinearLSQFitterLevMarLSQFitterFittingWithOutlierRemovalSLSQPLSQFitterSimplexLSQFitter JointFitterFitterModelLinearityError ModelsErrorc@s0eZdZdZddZddZddZdd Zd S) Covariancez2Class for covariance matrix calculated by fitter. cCs||_||_dS)N) cov_matrix param_names)selfrrre/work/yifan.wang/ringdown/master-ringdown-env/lib/python3.7/site-packages/astropy/modeling/fitting.py__init__=szCovariance.__init__c Cstdd|jD}d}dd|d}xvt|jD]h\}}||dkr|j|}||dt||dtt |d|d|d d 7}q6|d 7}q6W| S) NcSsg|] }t|qSr)len).0xrrr Dsz%Covariance.pprint..z#parameter variances / covariances z Wsz)Covariance.__getitem__..rrcss|]}t|tVqdS)N)r=int)r!r?rrrr@YszDCovariance can be indexed by two parameter names or integer indices.)r ValueErrorallrindex TypeErrorr)rparamsi1i2rrr __getitem__Ss $ zCovariance.__getitem__N)__name__ __module__ __qualname____doc__rr8r;rIrrrrr:s rc@s8eZdZdZddZddZddZdd Zd d Zd S) StandardDeviationsz! Class for fitting uncertainties.cCs||_|||_dS)N)r _calc_stdsstds)rrrrrrrcszStandardDeviations.__init__cCsddt|D}|S)NcSs"g|]}|dkrt|ndqS)rN)r-sqrt)r!r"rrrr#jsz1StandardDeviations._calc_stds..)r-Zdiag)rrrPrrrrOgszStandardDeviations._calc_stdsc Cstdd|jD}d}d}x`t|jD]R\}}||dkrr|j|}|||d|t|tt||7}q(|d7}q(W| S)NcSsg|] }t|qSr)r )r!r"rrrr#nsz-StandardDeviations.pprint..zstandard deviations z {0}{1}| {2} rr%z...) r(rr)rPr+r r>r-r.r/) rr0r1r2r3r4r5Zstdr7rrrr8ms   zStandardDeviations.pprintcCs|jdddS)Nr9r:)r0r1)r8)rrrrr;{szStandardDeviations.__repr__cCs:t|tr|j|}nt|tr(|}ntd|j|S)Nz?Standard deviation can be indexed by parameter name or integer.)r=r>rrDrArErP)rr7r5rrrrI~s   zStandardDeviations.__getitem__N) rJrKrLrMrrOr8r;rIrrrrrN`s rNc@seZdZdZdS)rzBase class for model exceptionsN)rJrKrLrMrrrrrsc@seZdZdZdS)rz= Raised when a non-linear model is passed to a linear fitter.N)rJrKrLrMrrrrrsc@seZdZdZdS)UnsupportedConstraintErrorzE Raised when a fitter does not support a type of constraint. N)rJrKrLrMrrrrrRsrRcs&eZdZdZeZfddZZS) _FitterMetazD Currently just provides a registry for all Fitter classes. cs6t||||}t|s2|ds2|j||S)N_)super__new__inspect isabstract startswithregistryadd)mclsnamebasesmemberscls) __class__rrrVs z_FitterMeta.__new__)rJrKrLrMsetrZrV __classcell__rr)rarrSsrScstdfdd }|S)a& This is a decorator that can be used to add support for dealing with quantities to any __call__ method on a fitter which may not support quantities itself. This is done by temporarily removing units from all parameters then adding them back once the fitting has completed. Ncs|dd}t|tp(t|tp(t|t}|j}|s:|r|jrt|j||j} |jdk rt|tr|j |j|jd| |jdd}t|tr|dk r|j |j|jd| |jdd}|jd|i} |dk r|| |j d<|| |jd<n|| |j d<d| d<|j f| }d} t|tr2d} |j } n t |} t|trTd} |j } n t |} |dk rt|trd} |j }n t |}|dkr||| | f|}n||| | |f|}| r|jf| }|Stdn||||fd|i|SdS) N equivalenciesr)rdrzFTz9This model does not support being fit to data with units.)popr=rZ _has_unitsZ_supports_unit_fittingr inputsinput_units_equivalenciesZ input_unitstooutputsZwithout_units_for_datavaluer-asarrayZwith_units_from_dataNotImplementedError)rmodelr"yrekwargsrdZdata_has_unitsZmodel_has_unitsrhZ rename_dataZadd_back_unitsZxdataZydataZzdataZ model_new)funcrrwrappersZ                  z$fitter_unit_support..wrapper)N)r)rqrrr)rqrfitter_unit_supportsYrsc@s>eZdZdZgZddZddZeddZe j dd Z d S) rz Base class for all fitters. Parameters ---------- optimizer : callable A callable implementing an optimization algorithm statistic : callable Statistic function cCsl|dkrtd|dkr tdt|r4||_nt|rF||_ntdt|rb||_n||_dS)NzExpected an optimizer.zExpected a statistic function.z8Expected optimizer to be a callable class or a function.)rBrWisclass _opt_method isfunction _stat_method)r optimizer statisticrrrrs     zFitter.__init__cGs8|d}|d}t|||j||f|dd}|S)a Function to minimize. Parameters ---------- fps : list parameters returned by the fitter args : list [model, [other_args], [input coordinates]] other_args may include weights or any other quantities specific for a statistic Notes ----- The list of arguments (args) is set in the `__call__` method. Fitters may overwrite this method, e.g. when statistic functions require other arguments. rr)_fitter_to_model_paramsrw)rfpsargsrnmeasresrrrobjective_function*s  zFitter.objective_functioncGsdS)z When available, calculate and sets the parameter covariance matrix (model.cov_matrix) and standard deviations (model.stds). Nr)r}rrr_add_fitting_uncertaintiesDsz!Fitter._add_fitting_uncertaintiescCs tddS)z This method performs the actual fitting and modifies the parameter list of a model. Fitter subclasses should implement this method. z(Subclasses should implement this method.N)rm)rrrr__call__LszFitter.__call__N) rJrKrLrMsupported_constraintsrr staticmethodrabcabstractmethodrrrrrr s   ) metaclassc@s`eZdZdZdgZdZdddZeddZdd d Z edd d Z dddZ e dddZ d S)ra^ A class performing a linear least square fitting. Uses `numpy.linalg.lstsq` to do the fitting. Given a model and data, fits the model to the data and changes the model's parameters. Keeps a dictionary of auxiliary fitting information. Notes ----- Note that currently LinearLSQFitter does not support compound models. fixedTFcCsddddd|_||_dS)N) residualsranksingular_valuesrF)fit_info_calc_uncertainties)rcalc_uncertaintiesrrrrhs  zLinearLSQFitter.__init__cCs6|jd|jdkrdStj||jdkr2dSdS)z+Check if inverse of matrix can be obtained.rrFT)shaper-linalgZ matrix_rank)mrrr_is_invertibleps zLinearLSQFitter._is_invertibleNc st|j|}dpt|d} ||s*Stj||dkr"tdkrd} | rZ|j} tj j || d} d| ||g} tdkrg} xt tD]|} d} | r|jd| f } tj j || d} | dd}t|j| }| d| |t|d| f|dqWntdkrd} | rJtd tdStj j || dtj j || d} }dt| ||g} n|g} xvt tD]f} ||dd}d} jdkrt|d}|| }| dt||t|| |dgqWfd d | D}fd d jDt|dkrXt|d j_t|d _n(fdd |D_fdd |D_dS)z Calculate and parameter covariance matrix and standard deviations and set `cov_matrix` and `stds` attributes. FmaskNr)r.)model_set_axisr<z_Calculation of fitting uncertainties for 2D models with masked values not currently supported. csg|] }|qSrr)r!r)inv_x_dot_x_primerrr#sz>LinearLSQFitter._add_fitting_uncertainties..cs,g|]$}j|dkrj|dkr|qS)F)rtied)r!r")rnrrr#srcsg|]}t|jqSr)rr)r!cov)rnrrr#scsg|]}t|qSr)rN)r!r)free_param_namesrrr#s)r-dotThasattrrrinvr rmaarraycountrangeflattenrollaxisrappendsumwarningswarnrrrrrrNrP)rrnaZn_coeffr"roreresidsZ x_dot_x_primemaskedrZxxZRSSjZeval_yyyZeval_zZcovsr)rrrnrrysZ     6"  4z*LinearLSQFitter._add_fitting_uncertaintiescCsZ|dkr"t|j|f|j}nt|j||f|j}|jrJ||S|d|fSdS)N.)r-r fit_deriv parameters col_fit_deriv)rnZ param_indicesr"rodrrr_deriv_with_constraintss z'LinearLSQFitter._deriv_with_constraintscCs|dkr\t|dr.|jdkr.||g|_t|drL|jdkrLddg|_t||j|jSt|dr|jdkr||g|_t|dr|jdkr||g|_t|dr|jdkrd d g|_t|d r|j dkrd d g|_ t||j|j}t||j|j }||fSdS) zd Maps domain into window for a polynomial model which has these attributes. Ndomainwindowrzrx_domainy_domainx_windowgg?y_window) rrminr(rrrrrr)rrnr"roZxnewZynewrrr_map_domain_windows"   z"LinearLSQFitter._map_domain_windowc s|jstd|jstdt|dr.tdt|j||d_t \}j dkrn|dkrntdt |||t j d }tj} |dk rtj|td }| rfd d tt jD} tfd d | D} t |dkr|\}}|dk r.t |||j|jkrt ndj d \}}tdrF||}| rtt|j|d} |j| |d} ntj|fj} |}|}n|\}}}|dk rt ||||j|jkrt ndj d \}}}tdr|||\}}| r2t|j||d} |j| ||d} ntj||fj} ||}t dkrj ppd}|jdkrt|||j}|d|jd}n|dkr|j n|}|dk r8|jdkrt|||j}|d|jd}n,|j|jkr|dkr|j n|}n|!}n|!}|dk r8|!}j"rLt| j } t| jdkrrtd#t$j%| rj"rt| j } || &| }|dk rt dkr|dtj'f}||}|dk rb|jdkrD|j|jkr| dtj'f|ddtj'f} ||}n,| |ddtj'f9} ||ddtj'f}n| |ddtj'f9} ||}| | (d}| |} ttj)*|}|dk r|stt+| rtdd}|rt dks|dk r|jdkrtj,| jdd|jdd|j-d }| jdkr&t| dd}nt.| |jdd| j}xt/||j |j D]f\}}}|rl|j0nt1d}||}||dtj'f}|}tj23|||\}}}}|j |dd<qTWn>|r|j0nt1d}| |}tj23| ||||\}}}}||j4d<||j4d<||j4d<||j|jkr>|ddtj'fn|}||j4d<t5|!tdrt dkr| s|j6krt78dt9|j:rt |t |kr|;||t |||||d_S)a Fit data to this model. Parameters ---------- model : `~astropy.modeling.FittableModel` model to fit to x, y, z x : array Input coordinates y : array-like Input coordinates z : array-like, optional Input coordinates. If the dependent (``y`` or ``z``) co-ordinate values are provided as a `numpy.ma.MaskedArray`, any masked points are ignored when fitting. Note that model set fitting is significantly slower when there are masked points (not just an empty mask), as the matrix equation has to be solved for each model separately when their co-ordinate grids differ. weights : array, optional Weights for fitting. For data with Gaussian uncertainties, the weights should be 1/sigma. rcond : float, optional Cut-off ratio for small singular values of ``a``. Singular values are set to zero if they are smaller than ``rcond`` times the largest singular value of ``a``. equivalencies : list or None, optional, keyword-only List of *additional* equivalencies that are should be applied in case x, y and/or z have units. Default is None. Returns ------- model_copy : `~astropy.modeling.FittableModel` a copy of the input model with parameters set by the fitter z)Model must be a subclass of FittableModelzIModel is not linear in parameters, linear fit methods should not be used.Zsubmodel_namesz"Model must be simple, not compoundFr<Nz.Expected x, y and z for a 2 dimensional model.)n_modelsr)dtypecsg|]}|kr|qSrr)r!idx)fitparam_indicesrrr#+sz,LinearLSQFitter.__call__..csg|]}tj|jqSr)getattrrrk)r!r) model_copyrrr#2srr)r"r)r"rorrzz7{} gives unsupported >2D derivative matrix for this x/y.zFound NaNs in the coefficient matrix, which should not happen and would crash the lapack routine. Maybe check that weights are not null.rrrrF_orderz"The fit may be poorly conditioned T)<fittablerBlinearrr_validate_constraintsrcopysync_constraints_model_to_fit_paramsn_inputs_convert_inputr ranyrvaluesr-rlfloatrrndimrrrrsum_of_implicit_terms asanyarrayrZreshaperrrrr+typerJrZnewaxisrrZgetmaskisnanZzerosrZ broadcast_toziprslicerZlstsqrr{rrrrrr)rrnr"roreweightsZrcondrTfarg has_fixedZfixparam_indicesZ fixparamslhsZ fixderivsrrhsZ model_axisZsclrrZlacoefZ lhs_stackZ model_lhsZ model_rhsZ model_lacoefgoodZt_coefrrZsvalr)rrrrs (                               " (      (  zLinearLSQFitter.__call__)F)NN)NN)N)NNN)rJrKrLrMrsupports_masked_inputrrrrrrrsrrrrrrZs    C c@s4eZdZdZd ddZddZddZd d d Zd S)ra This class combines an outlier removal technique with a fitting procedure. Basically, given a maximum number of iterations ``niter``, outliers are removed and fitting is performed for each iteration, until no new outliers are found or ``niter`` is reached. Parameters ---------- fitter : `Fitter` An instance of any Astropy fitter, i.e., LinearLSQFitter, LevMarLSQFitter, SLSQPLSQFitter, SimplexLSQFitter, JointFitter. For model set fitting, this must understand masked input data (as indicated by the fitter class attribute ``supports_masked_input``). outlier_func : callable A function for outlier removal. If this accepts an ``axis`` parameter like the `numpy` functions, the appropriate value will be supplied automatically when fitting model sets (unless overridden in ``outlier_kwargs``), to find outliers for each model separately; otherwise, the same filtering must be performed in a loop over models, which is almost an order of magnitude slower. niter : int, optional Maximum number of iterations. outlier_kwargs : dict, optional Keyword arguments for outlier_func. Attributes ---------- fit_info : dict The ``fit_info`` (if any) from the last iteration of the wrapped ``fitter`` during the most recent fit. An entry is also added with the keyword ``niter`` that records the actual number of fitting iterations performed (as opposed to the user-specified maximum). r:cKs&||_||_||_||_ddi|_dS)Nniter)fitter outlier_funcroutlier_kwargsr)rrrrrrrrr:s z"FittingWithOutlierRemoval.__init__cCsd|jjj|jj|j|jS)NzRFitter: {0} Outlier function: {1} Num. of iterations: {2} Outlier func. args.: {3})r+rrarJrrr)rrrr__str__As z!FittingWithOutlierRemoval.__str__cCs$d|jj|jjj|jj|j|jS)NzD{0}(fitter: {1}, outlier_func: {2}, niter: {3}, outlier_kwargs: {4}))r+rarJrrrr)rrrrr;Hs  z"FittingWithOutlierRemoval.__repr__Nc st|dkrdn4t|jdr*|jjdk r@tdt|jj|j|dkrZ|f}|}n ||f}|}dk rdkr|j 7d|j krt fdd t |j D|j d<d } |j||||fd |i|} t j|} | jt jjkrd | _|} | j} d}xt d|jdD]}| |d d i}| sy|j| |f|j } Wntk rdkrdn`|j ddd} t jj| t | |dd } | jt jjkrd | _t | d}t | jd}YnX| r:t |d}xNt|||D]>\}}}|j||f|j }|j|jdd<|j|dd<qWtdt| |7} dkr| j|dk rf|} |j| ffdd |D| jfd | i|} n|j| f|| fd | i|} | j}|| krP|} qWd|i|_|jt |jdi| | jfS)a Parameters ---------- model : `~astropy.modeling.FittableModel` An analytic model which will be fit to the provided data. This also contains the initial guess for an optimization algorithm. x : array-like Input coordinates. y : array-like Data measurements (1D case) or input coordinates (2D case). z : array-like, optional Data measurements (2D case). weights : array-like, optional Weights to be passed to the fitter. kwargs : dict, optional Keyword arguments to be passed to the fitter. Returns ------- fitted_model : `~astropy.modeling.FittableModel` Fitted model after outlier removal. mask : `numpy.ndarray` Boolean mask array, identifying which points were used in the final fitting iteration (False) and which were found to be outliers or were masked in the input (True). rNrTz+{} cannot fit model sets with masked valuesrZaxisc3s|]}|kr|VqdS)Nr)r!n)rrrr@sz5FittingWithOutlierRemoval.__call__..Frr)rrzMoutlier_func did not accept axis argument; reverted to slow loop over models.c3s|]}|VqdS)Nr)r!c)rrrr@srr)!r rrrrBr+rrJrrrtuplerr-rZ masked_arrayrZnomaskrrrrErfZ result_typerrdatarrrrupdater)rrnr"rorerrpZcoordsrloopZ fitted_modelZ filtered_dataZfiltered_weightsZ last_n_maskedrZ model_valsZdata_TZmask_TZ model_vals_TZrow_dataZrow_maskZ row_mod_valsZmasked_residualsZ this_n_maskedr)rrrrPs&                  z"FittingWithOutlierRemoval.__call__)r:)NN)rJrKrLrMrrr;rrrrrrs ! csheZdZdZdddgZdfdd Zdd Zed d Ze d d e e e dfd dZ edddZZS)ra Levenberg-Marquardt algorithm and least squares statistic. Attributes ---------- fit_info : dict The `scipy.optimize.leastsq` result for the most recent fit (see notes). Notes ----- The ``fit_info`` dictionary contains the values returned by `scipy.optimize.leastsq` for the most recent fit, including the values from the ``infodict`` dictionary it returns. See the `scipy.optimize.leastsq` documentation for details on the meaning of these values. Note that the ``x`` return value is *not* included (as it is instead the parameter values of the returned model). Additionally, one additional element of ``fit_info`` is computed whenever a model is fit, with the key 'param_cov'. The corresponding value is the covariance matrix of the parameters as a 2D numpy array. The order of the matrix elements matches the order of the parameters in the fitted model (i.e., the same order as ``model.param_names``). rrboundsFc s.dddddddddd |_||_tdS)N) ZnfevZfvecZfjacZipvtZqtfmessageierrZ param_jac param_cov)rrrUr)rr)rarrrs zLevMarLSQFitter.__init__cGsf|d}|d}t|||d}|dkrDt||dd|St|||dd|SdS)z Function to minimize. Parameters ---------- fps : list parameters returned by the fitter args : list [model, [weights], [input coordinates]] rrrzNr<)r{r-ravel)rr|r}rnrr~rrrr)s  z"LevMarLSQFitter.objective_functioncs0fddjD}t||_t||_dS)z Set ``cov_matrix`` and ``stds`` attributes on model with parameter covariance matrix returned by ``optimize.leastsq``. cs,g|]$}j|dkrj|dkr|qS)F)rr)r!r")rnrrr#Fsz>LevMarLSQFitter._add_fitting_uncertainties..N)rrrrNrP)rnrrr)rnrr?s z*LevMarLSQFitter._add_fitting_uncertaintiesNc  Csfddlm} t||j} d| _| |ft|||} | jdks@| rFd} n|j} t| \}}| j |j || | | j |||dd \}}}}}t | ||j |||j d<||j d<||j d <|d krtd tt|t|kr$|dk r$t|j |f| d }t|t|}||||j d <n d|j d <|jdkr\|j d dk r\|| |j d d| _| S)a Fit data to this model. Parameters ---------- model : `~astropy.modeling.FittableModel` model to fit to x, y, z x : array input coordinates y : array input coordinates z : array, optional input coordinates weights : array, optional Weights for fitting. For data with Gaussian uncertainties, the weights should be 1/sigma. maxiter : int maximum number of iterations acc : float Relative error desired in the approximate solution epsilon : float A suitable step length for the forward-difference approximation of the Jacobian (if model.fjac=None). If epsfcn is less than the machine precision, it is assumed that the relative errors in the functions are of the order of the machine precision. estimate_jacobian : bool If False (default) and if the model has a fit_deriv method, it will be used. Otherwise the Jacobian will be estimated. If True, the Jacobian will be estimated in any case. equivalencies : list or None, optional, keyword-only List of *additional* equivalencies that are should be applied in case x, y and/or z have units. Default is None. Returns ------- model_copy : `~astropy.modeling.FittableModel` a copy of the input model with parameters set by the fitter r)optimizeFNT)r}ZDfunZ col_derivZmaxfevZepsfcnZxtolZ full_outputcov_xrr)rr<r:zLThe fit may be unsuccessful; check fit_info['message'] for more information.r<r)scipyr_validate_modelrrrr _wrap_derivrleastsqrrr{rrrrrr r-rrr)rrnr"rorermaxiteraccepsilonZestimate_jacobianrrrZdfunc init_valuesrT fitparamsrZdinfoZmessrZsum_sqrsZdofrrrrLs>.            zLevMarLSQFitter.__call__csT|dkr d}tjs*tjrdt||dkr|tj|fj}j slt ||j }qt ||}nJtddj||fjD}j st ||j }nt ||}fddj D}dd|D} dd|D} t tdd|Dd | } t| | } t| } j sHt|t| j } n|t| } d d| DS|dkry0td dt|tj|f|DStk rtd dt|ttj|f|d dDSXn^j s*ddt |tj||f|j j DSdd|tj||f|DSdS)au Wraps the method calculating the Jacobian of the function to account for model constraints. `scipy.optimize.leastsq` expects the function derivative to have the above signature (parlist, (argtuple)). In order to accommodate model constraints, instead of using p directly, we set the parameter list in this function. Ng?cSsg|]}t|qSr)r-r)r!rTrrrr#sz/LevMarLSQFitter._wrap_deriv..csg|]}t|qSr)r)r!r])rnrrr#scSsg|] }|jqSr)r)r!parrrrr#scSsg|] }|jqSr)r)r!rrrrr#scSsg|]}|jdk qS)F)r)r!rrrrr#sTcSsg|]}t|qSr)r-r)r!rTrrrr#scSsg|]}t|qSr)r-r)r!rTrrrr#scSsg|]}t|qSr)r-r)r!rTrrrr#srzrcSsg|]}t|qSr)r-r)r!rTrrrr#scSsg|]}t|qSr)r-r)r!rTrrrr#s)rrrrr{r-rrrrrrrlistwhere logical_orZ logical_notrlZnonzerorBZmoveaxisZ transpose)rFrnrr"rorefullZ full_derivZparsrrZ fix_and_tieindZresiduesr)rnrrsJ  $    *zLevMarLSQFitter._wrap_deriv)F)N)rJrKrLrMrrrrrrsr rrrrrcrr)rarrs   Scs4eZdZdZejZfddZedddZZ S)ra, Sequential Least Squares Programming (SLSQP) optimization algorithm and least squares statistic. Raises ------ ModelLinearityError A linear model is passed to a nonlinear fitter Notes ------ See also the `~astropy.modeling.optimizers.SLSQP` optimizer. cstjttdi|_dS)N)rxry)rUrr r r)r)rarrrszSLSQPLSQFitter.__init__Nc Ksft||jj}d|_t|||}||f|}t|\} } |j|j| |f|\} |_t|| d|_|S)a  Fit data to this model. Parameters ---------- model : `~astropy.modeling.FittableModel` model to fit to x, y, z x : array input coordinates y : array input coordinates z : array, optional input coordinates weights : array, optional Weights for fitting. For data with Gaussian uncertainties, the weights should be 1/sigma. kwargs : dict optional keyword arguments to be passed to the optimizer or the statistic verblevel : int 0-silent 1-print summary upon completion, 2-print summary after each iteration maxiter : int maximum number of iterations epsilon : float the step size for finite-difference derivative estimates acc : float Requested accuracy equivalencies : list or None, optional, keyword-only List of *additional* equivalencies that are should be applied in case x, y and/or z have units. Default is None. Returns ------- model_copy : `~astropy.modeling.FittableModel` a copy of the input model with parameters set by the fitter FT) rrurrrrrrr{) rrnr"rorerrprrrrTrrrrrs*    zSLSQPLSQFitter.__call__)NN) rJrKrLrMr rrrsrrcrr)rarrs  cs4eZdZdZejZfddZedddZZ S)rz Simplex algorithm and least squares statistic. Raises ------ `ModelLinearityError` A linear model is passed to a nonlinear fitter cstjttdi|_dS)N)rxry)rUrr r r)r)rarrr9szSimplexLSQFitter.__init__Nc Ksft||jj}d|_t|||}||f|}t|\} } |j|j| |f|\} |_t|| d|_|S)a9 Fit data to this model. Parameters ---------- model : `~astropy.modeling.FittableModel` model to fit to x, y, z x : array input coordinates y : array input coordinates z : array, optional input coordinates weights : array, optional Weights for fitting. For data with Gaussian uncertainties, the weights should be 1/sigma. kwargs : dict optional keyword arguments to be passed to the optimizer or the statistic maxiter : int maximum number of iterations acc : float Relative error in approximate solution equivalencies : list or None, optional, keyword-only List of *additional* equivalencies that are should be applied in case x, y and/or z have units. Default is None. Returns ------- model_copy : `~astropy.modeling.FittableModel` a copy of the input model with parameters set by the fitter FT) rrurrrrrrr{) rrnr"rorerrprrrrTrrrrr=s$     zSimplexLSQFitter.__call__)NN) rJrKrLrMr rrrsrrcrr)rarr,s   c@s8eZdZdZddZddZddZdd Zd d Zd S) raH Fit models which share a parameter. For example, fit two gaussians to two data sets but keep the FWHM the same. Parameters ---------- models : list a list of model instances jointparameters : list a list of joint parameters initvals : list a list of initial values cCsPt||_t||_||_|||_dd|jD|_t |j|_ dS)NcSsg|] }|jqSr)r)r!rrrrr#sz(JointFitter.__init__..) rmodelsinitvals jointparams _verify_inputrr modeldimsr-rr)rrZjointparametersrrrrrs   zJointFitter.__init__cCshg}||jxR|jD]H}|j}|j|}|j}x|D]}||d}||=qt|}g}t|}t|j}|d|}|d|=x|jD]}|j|} |d|jd} |d|jd=t|jt| } |d| } |d| =g} |j}xf|jD]\}|| kr| |}| ||gq||d}|j |j }| | d|| d|=qW|j | ddf| }| || dq1 models, z is givenr<z1At least two parameters are expected, {} is givenz({} parameter(s) provided but {} expected)r rrErkeysr+r)rrrrrrszJointFitter._verify_inputcGsZddlm}t|tdd|jkrDtdtdd|jt||j|j|j |d\|j dd<}|j dd}t|j }|d|}|d|=x|j D]}|j |}t|j t|} |d| } |d| =g} |j} xh|jD]^} | |kr|| }| ||gq| | d }|j|j}| | d|| d|=qWt| |_qWdS) zk Fit data to these models keeping some of the parameters common to the two models. r)rcSs|d|dS)Nrr)r"rorrrz&JointFitter.__call__..z/Expected {} coordinates in args but {} providedcSs|d|dS)Nrr)r"rorrrrr)r}Nr)rrr rrrBr+rrrrrrr rrrDrr r r-rr)rr}rrTrr rrnrrrrrrrDrrrrrrs6             zJointFitter.__call__N) rJrKrLrMrrrrrrrrrrps   2 cCs*tj|td}tj|td}|dk rBtj|td}|j|j}}n|j|j}}|dksb||jkr|phd|krvtd|||krtd|dkrt|||j}|jdd}n |jd||j|dd}|dkr||jkrtd||f}n0|j|jkr|ksntd |||f}|S) zConvert inputs to float arrays.)rNrrzmodel_set_axis out of rangezTNumber of data sets (y or z array) is expected to equal the number of parameter setsrzz"x and y should have the same shapez%x, y and z should have the same shape)r-rrrrrBr)r"rorerrZ data_ndimZ data_shaperrrrrs2       rcCst|\}}t|j}t|j}tdd|jD}|j}|s\|s\|s\||_dSt|}d}|j} xt |j D]\} } | |krqz| | d} | | d} t t j | d}||||}|j| dkr |j| \}}|dk rt||}|dk r t||}||| <||7}qzW||r|xNt |j D]@\} } |j| r8|j| |}| | d} ||| <|q8WdS) zf Constructs the full list of model parameters from the fitted and constrained parameters. css|]}|dkVqdS))NNNr)r!brrrr@Hsz*_fitter_to_model_params..Nrrrr)NN)rrrrrrrrbrr)rroperatormulr-ZfmaxZfminZ_array_to_parameters)rnr|rTZfit_param_indicesZhas_tiedrZ has_boundroffsetrrr]rrsizer_min_maxrkrrrr{>sD          r{cCsttt|j}t|js.t|jrt|j}|j }xPtt |jdddD]4\}}|j|st|j|rX||d}||=||=qXWt ||fS|j|fS)aO Convert a model instance's parameter array to an array that can be used with a fitter that doesn't natively support fixed or tied parameters. In particular, it removes fixed/tied parameters from the parameter array. These may be a subset of the model parameters, if some of them are held constant or tied. Nrzr) rrr rrrrrrrr)r-r)rnrrFrrr]rrrrr}s  "  rcCsd}t|jr(d|kr(t|dt|jrLd|krLt|dtdd|jDrzd|krzt|d |jrd |krt|d |jrd |krt|d dS)z@Make sure model constraints are supported by the current fitter.z(Optimizer cannot handle {0} constraints.rzfixed parameterrztied parametercss|]}t|dkVqdS))NNN)r)r!rrrrr@sz(_validate_constraints..rzbound parametereqconsZequalityineqconsZ inequalityN) rrrrRr+rrrr)rrnrrrrrs    rcCsL|jstd|jr"tdtnt|dkr6tdt|||}|S)zT Check that model and fitter are compatible and return a copy of the model. z%Model does not appear to be fittable.zEModel is linear in parameters; consider using linear fitting methods.rz7Non-linear fitters can only fit one data set at a time.) rrBrrrrr rr)rnrrrrrrs  rc Csx|D]}|j}y |}WnBtk r^}z$ttt|jd|dWdd}~XYqXt |sttd|dqt |t r|j}|t |<t |qttd|qWdS)aY This injects entry points into the `astropy.modeling.fitting` namespace. This provides a means of inserting a fitting routine without requirement of it being merged into astropy's core. Parameters ---------- entry_points : list of `~importlib.metadata.EntryPoint` entry_points are objects which encapsulate importable objects and are defined on the installation of a package. Notes ----- An explanation of entry points can be found `here ` z error occurred in entry point .NzModeling entry point z expected to be a Class.zBModeling entry point {} expected to extend astropy.modeling.Fitter)r]load ExceptionrrrrrJrWrt issubclassrglobals__all__rr+)r entry_pointr]errrpopulate_entry_pointss"  ,    r'cCs6t}t|dr"t|jddnt|dgdS)Nselectzastropy.modeling)group)rrr'r(get)eprrr _populate_eps r,)Nrr)8rMrrWrrimportlib.metadatar ImportErrorimportlib_metadata functoolsrrnumpyr-Z astropy.unitsrZastropy.utils.exceptionsrutilsrr Z optimizersr r ryr r rrr$Z STATISTICSZ OPTIMIZERSrrNr!rrrBrRABCMetarSrsrrrrrrrrr{rrrr'r,rrrrsb   &(dP@gcMD 9?(