B q\@sdZddlZddlZddlZddlZddlmZmZddlZ ddl m Z m Z ddl mZddlmZddlmZmZdd lmZydd lmZd ZWnek rd ZYnXd ddddddgZegZeegZddlmZmZmZGddde Z!Gddde!Z"Gddde!e#Z$Gdddej%Z&ddZ'Gddde&d Z(Gd!d d e&d Z)Gd"ddZ*Gd#dde&d Z+Gd$dde(Z,Gd%dde(Z-Gd&dde&d Z.d5d'd(Z/d)d*Z0d+d,Z1d-d.Z2d/d0Z3d1d2Z4ere4ed3dd4dS)6a 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)reducewraps)poly_map_domain_combine_equivalency_dict)Quantity)AstropyUserWarning)SLSQPSimplex) leastsquare)iter_entry_pointsTFLinearLSQFitterLevMarLSQFitterFittingWithOutlierRemovalSLSQPLSQFitterSimplexLSQFitter JointFitterFitter)DEFAULT_MAXITER DEFAULT_EPS DEFAULT_ACCc@seZdZdZdS) ModelsErrorzBase class for model exceptionsN)__name__ __module__ __qualname____doc__rr7lib/python3.7/site-packages/astropy/modeling/fitting.pyr=src@seZdZdZdS)ModelLinearityErrorz= Raised when a non-linear model is passed to a linear fitter.N)rrrrrrrrrAsrc@seZdZdZdS)UnsupportedConstraintErrorzE Raised when a fitter does not support a type of constraint. N)rrrrrrrrrEsrcs&eZdZdZeZfddZZS) _FitterMetazD Currently just provides a registry for all Fitter classes. cs6t||||}t|s2|ds2|j||S)N_)super__new__inspectZ isabstract startswithregistryadd)mclsnamebasesmemberscls) __class__rrr#Rs z_FitterMeta.__new__)rrrrsetr&r# __classcell__rr)r-rr Ksr cstdfdd }|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~|jrtt|j||j} |jdk rt|tr~|j |jd| dd}t|tr|dk r|j |jd| dd}|j |||d}d} t|trd} |j } n t |} t|trd} |j } n t |} |dk r(t|trd} |j } n t |} |dkrF||| | f|}n||| | | f|}| rp|j|||d}|Stdn||||fd |i|SdS) N equivalenciesx)r0y)r1r2zFTz8This model does not support being fit to data with unitsr3)pop isinstancerZ _has_unitsZ_supports_unit_fittingrZinputsinput_units_equivalenciesZ input_unitstoZwithout_units_for_datavaluenpasarrayZwith_units_from_dataNotImplementedError)selfmodelr1r2r3kwargsr0Zdata_has_unitsZmodel_has_unitsr6Zadd_back_unitsZxdataZydataZzdataZ model_new)funcrrwrapperbsJ                z$fitter_unit_support..wrapper)N)r)r?r@r)r?rfitter_unit_support[sQrAc@s.eZdZdZddZddZejddZdS) 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.) ValueErrorr$isclass _opt_methodZ isfunction _stat_method)r< optimizer statisticrrr__init__s     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_paramsrE)r<fpsargsr=measZresrrrobjective_functions  zFitter.objective_functioncCs 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)r;)r<rrr__call__s zFitter.__call__N) rrrrrHrNabcabstractmethodrOrrrrrs ) metaclassc@sHeZdZdZdgZdZddZed ddZdd d Z e dd d Z dS)r a` 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. fixedTcCsddddd|_dS)N) residualsranksingular_valuesparams)fit_info)r<rrrrH szLinearLSQFitter.__init__NcCsZ|dkr"t|j|f|j}nt|j||f|j}|jrJ||S|d|fSdS)N.)r9array fit_deriv parameters col_fit_deriv)r=Z param_indicesr1r2drrr_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. NdomainwindowrIrx_domainy_domainx_windowgg?y_window) hasattrr_minmaxr`rrarbrcrd)r<r=r1r2ZxnewZynewrrr_map_domain_window s"   z"LinearLSQFitter._map_domain_windowcs|jstd|jstdt|dr.tdt|j||t\}j dkrh|dkrhtdt |||t j d}t j} | rƇfd d tt jD} tfd d | D} t |dkr<|\}}td r||}| r|j|d } |j| |d } nj|fj} |}|}n|\}}}tdrd|||\}}| r|j||d} |j| ||d} nj||fj} ||}t dkrj pd}|jdkrt|||j}|d|jd}n|dkr |jn|}n|}jr,t| j} | jdkrLtd t!j"| rtjrft| j} || #| }|dk rt dkr|dtj$f}||}|dk r,tj|t%d}t |t |krtd|jdkr| |ddtj$f9} ||ddtj$f}n| |ddtj$f9} ||}|dkrLt |t&|j'j(}| | )d}| |} t tj*+|}t dks|s|r|j,nt-d}tj./| ||||\}}}}ntj0| jdd|jdd|j'd}xdt1|j|jD]R\}}|j,}| |}||dtj$f}tj./|||\}}}}|j|dd<qW||j2d<||j2d<||j2d<|j|j}||j2d<tdr|j3krt45dt6t7|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 and keyword-only argument 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 compoundNz.Expected x, y and z for a 2 dimensional model.)n_modelsmodel_set_axiscsg|]}|kr|qSrr).0idx)fitparam_indicesrr {sz,LinearLSQFitter.__call__..csg|]}tj|jqSr)getattr param_namesr8)rlrm) model_copyrrrosr_)r1ra)r1r2rrrIz8{0} gives unsupported >2D derivative matrix for this x/y.)dtypez)x and weights should have the same lengthrTrUrVrW_orderz"The fit may be poorly conditioned )8fittablerBlinearrre_validate_constraintssupported_constraintscopy_model_to_fit_paramsn_inputs_convert_inputlenrkanyrSvaluesrangerqr9r:rhr^rZr[sum_of_implicit_termsndimrollaxisZreshapeshapeTZflattenr\formattyperdotZnewaxisfloatZfinforsZepssummaZgetmaskmasksliceZlinalgZlstsqZzerosziprXrtwarningswarnrrJ)r<r=r1r2r3weightsZrcondr!farg has_fixedZfixparam_indicesZ fixparamsZlhsZ fixderivsrZrhsZ model_axisZsclZmaskedgoodZlacoefZresidsrUZsvalZ model_rhsZ model_lacoefZ model_lhsZt_coefr)rnrrrrO:s'                        (      zLinearLSQFitter.__call__)NN)N)NNN) rrrrrxsupports_masked_inputrH staticmethodr^rhrArOrrrrr s  c@s4eZdZdZd ddZddZddZd d d Zd S)ra This class combines an outlier removal technique with a fitting procedure. Basically, given a number of iterations ``niter``, outliers are removed and fitting is performed for each iteration. Parameters ---------- fitter : An Astropy 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 : function 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) Number of iterations. outlier_kwargs : dict (optional) Keyword arguments for outlier_func. cKs||_||_||_||_dS)N)fitter outlier_funcniteroutlier_kwargs)r<rrrrrrrrHCsz"FittingWithOutlierRemoval.__init__cCsd|jj|jj|j|jS)NzRFitter: {0} Outlier function: {1} Num. of iterations: {2} Outlier func. args.: {3})rZfitter__class__rrrr)r<rrr__str__Is z!FittingWithOutlierRemoval.__str__cCs$d|jj|jjj|jj|j|jS)NzD{0}(fitter: {1}, outlier_func: {2}, niter: {3}, outlier_kwargs: {4}))rr-rrrrr)r<rrr__repr__Ps  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 | _|} xt |jD]} | |d d i}| sy|j| |f|j } Wntk rdkrPn`|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 rR|} |j| ffdd |D| jfd | i|} q|j| f|| fd | i|} qW| | 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,{0} cannot fit model sets with masked valuesrZaxisc3s|]}|kr|VqdS)Nr)rln)rkrr sz5FittingWithOutlierRemoval.__call__..Frrk)rsryzMoutlier_func did not accept axis argument; reverted to slow loop over models.c3s|]}|VqdS)Nr)rlc)rrrrs)r}rerrrBrrrrkrrtuplerr9rZ masked_arrayrZnomaskrr TypeErrorr4Z result_typerrdatarrr)r<r=r1r2r3rr>ZcoordsrZloopZ fitted_modelZ filtered_dataZfiltered_weightsrZ model_valsZdata_TZmask_TZ model_vals_TZrow_dataZrow_maskZ row_mod_valsZmasked_residualsr)rrkrrOXs'            z"FittingWithOutlierRemoval.__call__)r)NN)rrrrrHrrrOrrrrr)s  csZeZdZdZdddgZfddZddZed d ee e d fd d Z e dd dZ ZS)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``). rStiedboundsc s(dddddddddd |_tdS)N) ZnfevZfvecZfjacZipvtZqtfmessageierrZ param_jac param_cov)rXr"rH)r<)r-rrrHs 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]] rrrINri)rJr9ravel)r<rKrLr=rrMrrrrN(s  z"LevMarLSQFitter.objective_functionNFc  Cs,ddlm} t||j} | |ft|||} | jdks:| r@d} n|j} t| \}}| j|j || | | j |||dd \}}}}}t | ||j |||j d<||j d<||j d<|d krtd tt|t|kr|dk rt|j |f| d }t|t|}||||j d <n d|j 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 and keyword-only argument 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)optimizeNT)rLZDfunZ col_derivZmaxfevZepsfcnZxtolZ full_outputcov_xrr)rrirzLThe fit may be unsuccessful; check fit_info['message'] for more information.rir)scipyr_validate_modelrxr|rZ _wrap_derivrzleastsqrNr\rJrXupdaterrrr}r9r)r<r=r1r2r3rmaxiterZaccepsilonZestimate_jacobianrrrrZdfuncZ init_valuesr! fitparamsrZdinfoZmessrZsum_sqrsZdofrrrrO=s2-          zLevMarLSQFitter.__call__cs|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|dkrd dt |tj|f|DSj sd dt |tj||f|j j DSd d|tj||f|DSdS)av 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)r9r)rlr!rrrrosz/LevMarLSQFitter._wrap_deriv..csg|]}t|qSr)rp)rlr))r=rrroscSsg|] }|jqSr)rS)rlparrrrroscSsg|] }|jqSr)r)rlrrrrroscSsg|]}|jdk qS)F)r)rlrrrrrosTcSsg|]}t|qSr)r9r)rlr!rrrroscSsg|]}t|qSr)r9r)rlr!rrrroscSsg|]}t|qSr)r9r)rlr!rrrroscSsg|]}t|qSr)r9r)rlr!rrrros)r~rSrrrJr9rYrZr[r\rrrqlistwhereZ logical_orZ logical_notr:Znonzero)rWr=rr1r2r3ZfullZ full_derivZparsrSrZ fix_and_tieZindZresiduesr)r=rrs<  $    **zLevMarLSQFitter._wrap_deriv)N)rrrrrxrHrNrArrrrOrrr/rr)r-rrs  Lcs4eZdZdZejZfddZedddZZ S)rz SLSQP optimization algorithm and least squares statistic. Raises ------ ModelLinearityError A linear model is passed to a nonlinear fitter cstjttdi|_dS)N)rFrG)r"rHr r rX)r<)r-rrrHszSLSQPLSQFitter.__init__Nc KsZt||jj}t|||}||f|}t|\} } |j|j| |f|\} |_t|| |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 and keyword-only argument 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 )rrDrxr|rzrNrXrJ) r<r=r1r2r3rr>rrrp0r!rrrrrOs*    zSLSQPLSQFitter.__call__)NN) rrrrr rxrHrArOr/rr)r-rrs   cs4eZdZdZejZfddZedddZZ S)rz Simplex algorithm and least squares statistic. Raises ------ ModelLinearityError A linear model is passed to a nonlinear fitter cstjttdi|_dS)N)rFrG)r"rHr r rX)r<)r-rrrHszSimplexLSQFitter.__init__Nc KsZt||jj}t|||}||f|}t|\} } |j|j| |f|\} |_t|| |S)aG 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 and keyword-only argument 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 )rrDrxr|rzrNrXrJ) r<r=r1r2r3rr>rrrrr!rrrrrOs$     zSimplexLSQFitter.__call__)NN) rrrrr rxrHrArOr/rr)r-rr 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{)rlmrrrrogsz(JointFitter.__init__..) rmodelsinitvals jointparams _verify_inputrzr modeldimsr9rr)r<rZjointparametersrrrrrH_s   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, {} is givenriz1At least two parameters are expected, {} is givenz({} parameter(s) provided but {} expected)r}rrrrkeysr)r<jrrrrszJointFitter._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)r1r2rrrsz&JointFitter.__call__..z/Expected {} coordinates in args but {} providedcSs|d|dS)Nrr)r1r2rrrrs)rLNr)rrr}rrrBrrrNrrrrrrrqrrrrr9rYr[)r<rLrr!rrrr=rrrrrrrrrrrrrOs6             zJointFitter.__call__N) rrrrrHrzrNrrOrrrrrNs   1 cCstj|td}tj|td}|dk r2tj|td}|dkr|dkrj|j||krXtdt|||j}nB|jd||j|dd}|j|jkr|ksntd|dkr||f}n |||f}|S)zConvert inputs to float arrays.)rsNrzONumber of data sets (y array is expected to equal the number of parameter sets)z%x, y and z should have the same shape)r9Z asanyarrayrrrBrr)r1r2r3rjrkZz_shaperrrrr|s"    r|cCsnt|\}}t|j}t|j}tdd|jD}|sV|sV|sV||_dSt|}d}|j}xt |j D]\} } | |krqt|| d} || d} t t j | d} |||| }|j| dkr|j| \}}|dk rt||}|dk rt||}||j| <|| 7}qtW|rjxHt |j D]:\} } |j| r,|j| |}|| d} ||j| <q,WdS) zf Constructs the full list of model parameters from the fitted and constrained parameters. css|]}|dkVqdS))NNNr)rlbrrrrsz*_fitter_to_model_params..Nrrrr)NN)rzr~rrrSrr[r.r enumeraterqroperatormulr9ZfmaxZfmin)r=rKr!Zfit_param_indicesZhas_tiedrZ has_boundoffsetrrmr)rrsizerZ_minZ_maxr8rrrrJs>           rJcCsttt|j}t|js.t|jrt|j}|j }xPtt |jdddD]4\}}|j|st|j|rX||d}||=||=qXWt ||fS|j|fSdS)aP 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. NrIr) rrr}rqr~rSrrr[rrr9rY)r=rnrWrrmr)rrrrrzJs  "  rzcCsd}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.rSzfixed parameterrztied parametercss|]}t|dkVqdS))NNN)r)rlrrrrrqsz(_validate_constraints..rzbound parametereqconsZequalityineqconsZ inequalityN) r~rSrrrrrrr)rxr=rrrrrwcs    rwcCsL|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.) rurBrvrrrr}rwry)r=rxrrrrrr}s  rc Csx|D]}|j}y |}Wn@tk r\}z"ttdjt|j|dWdd}~XYqXt |s~ttd|qt |t r|j}|t |<t|qttd|qWdS)a} 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 : a list of `~pkg_resources.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,{type} error occurred in entry point {name}.)rr)Nz0Modeling entry point {0} expected to be a Class.zCModeling entry point {0} expected to extend astropy.modeling.Fitter)r)load Exceptionrrrrrrr$rC issubclassrglobals__all__append)Z entry_pointsZ entry_pointr)errrpopulate_entry_pointss$   &     rzastropy.modeling)groupr))Nrr)5rrPr$rr functoolsrrZnumpyr9ZutilsrrZ astropy.unitsrZastropy.utils.exceptionsrZ optimizersr r rGr Z pkg_resourcesr ZHAS_PKG ImportErrorrZ STATISTICSZ OPTIMIZERSrrrrrrrBrABCMetar rArr rrrrrr|rJrzrwrrrrrrs\      \F.TIGC 07,