a ߙfb@sdZddlZddlZddlZddlZddlZddlZddlZddlZddl m Z m Z ddlm Z ddlm Z ddlZddlmZmZddlmZddlmZmZmZdd lmZdd lmZmZmZmZmZdd l m!Z!dd l"m#Z#m$Z$d dl%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+d dl,m-Z-m.Z.d dl/m0Z0m1Z1m2Z2m3Z3gdZ4ddZ5Gddde6Z7Gdddej8Z9Gddde9dZ:Gddde:Z;Gddde;Zd#d$Z?d%d&Z@e>ejAe>ejBe>ejCe>ejDe>ejEe?e@d'ZFe+ZGd(d)ZHGd*d+d+e:ZId,d-ZJd.d/ZKd0d1ZLd2d3ZMgd4ZNiZOePeND]\ZQZReRD]ZSeQeOeS<qLq@[Q[S[RdGd5d6ZTdHd8d9ZUdId:d;ZVdd<d=d>ZWd?d@ZXdJdAdBZYdKdCdDZZdEdFZ[dS)Lad This module defines base classes for all models. The base class of all models is `~astropy.modeling.Model`. `~astropy.modeling.FittableModel` is the base class for all fittable models. Fittable models can be linear or nonlinear in a regression analysis sense. All models provide a `__call__` method which performs the transformation in a purely mathematical way, i.e. the models are unitless. Model instances can represent either a single model, or a "model set" representing multiple copies of the same type of model, but with potentially different values of the parameters in each model making up the set. N) defaultdictdeque) signature)chain)indentmetadata)Table)Quantity UnitsErrordimensionless_unscaled)quantity_asanyarray) sharedmethodfind_current_modulecheck_broadcastIncompatibleShapeError isiterable)make_function_with_signature) add_array extract_array)combine_labelsmake_binary_operator_evalget_inputs_and_params_combine_equivalency_dict_ConstraintsDict_SpecialOperatorsDict)ModelBoundingBoxCompoundBoundingBox) ParameterInputParameterErrorparam_repr_oneline_tofloat) Model FittableModelFittable1DModelFittable2DModel CompoundModel fix_inputs custom_modelModelDefinitionErrorbind_bounding_boxbind_compound_bounding_boxc sfddS)z Returns a function that evaluates a given Python arithmetic operator between two models. The operator should be given as a string, like ``'+'`` or ``'**'``. cst||fiSN)r&)leftrightkwargsoper4lib/python3.9/site-packages/astropy/modeling/core.py:z_model_oper..r2)r1r0r2r/r3 _model_oper4sr6c@seZdZdZdS)r)z&Used for incorrect models definitions.N)__name__ __module__ __qualname____doc__r2r2r2r3r)=sr)cseZdZdZdZfddZfddZddZd d Zd d Z e d dZ e ddZ d&ddZ ddZddZddZfddZedZedZedZedZed Zed!Zed"Zed#Zgffd$d% ZZS)' _ModelMetaz Metaclass for Model. Currently just handles auto-generating the param_names list based on Parameter descriptors declared at the class-level of Model subclasses. Fc sd|vr|j|d<dtdfdtdfdtdfdtd fd td fd td fdtdfdtdfg}dd|D|d<|D]\}}|||<qt||||}t|d}|D](} | jD]} t| trt| j |}qqtt |}|j rt |dr t ||_n t ||_|S)N _is_dynamic__add__+__sub__-__mul__* __truediv__/__pow__**__or__|__and__& _fix_inputsr'cSs i|]\}}t|tr||qSr2) isinstancer.0kvr2r2r3 hs  z&_ModelMeta.__new__.. _parameters_ _param_names)r<r6itemssuper__new__list__mro__ issubclassr"rRdictfromkeyshasattrtuplerS param_names) mclsnamebasesmembersZ opermethodsZ opermethodZopercallclsr^basetbase __class__r2r3rVYs4                  z_ModelMeta.__new__c sxtt||||||||i}|D]6}|jD]*}t|tr:|j D]\}}|||<qRq:q0| ||dSr,) rUr;__init___create_inverse_property_create_bounding_box_propertyrXrYr"rRrT_handle_special_methods) rcr`rarbpdictrdreparnamevalrfr2r3rhs    z_ModelMeta.__init__cCs|S)z3 Custom repr for Model subclasses. )_format_cls_reprrcr2r2r3__repr__sz_ModelMeta.__repr__cCs|t|dS)z Repr for IPython's pretty printer. By default IPython "pretty prints" classes, so we need to implement this so that IPython displays the custom repr for Models. N)textrepr)rcpcycler2r2r3 _repr_pretty_sz_ModelMeta._repr_pretty_cCsb|js |jSt|j}t|D]}|dr||=qdD]}||vr8||=q8t||j|j|ffS)N_abc_)rh__call__)r<r7rZ__dict__rW startswithtype __bases__)rcrbkeyr2r2r3 __reduce__s   z_ModelMeta.__reduce__cCs|jS)z The name of this model class--equivalent to ``cls.__name__``. This attribute is provided for symmetry with the `Model.name` attribute of model instances. )r7rpr2r2r3r`s z_ModelMeta.namecCs|jdpt| S)z A class-level property that determines whether the class is a concrete implementation of a Model--i.e. it is not some abstract base class or internal implementation detail (i.e. begins with '_'). _)r7rzinspect isabstractrpr2r2r3 _is_concretesz_ModelMeta._is_concreteNcCstd}|r|j}nd}|dur&|j}|dur6|j}nBt|tsJtdn.t|t|jkrxt|jdt|jd|dur|j }nBt|tstdn.t|t|j krt|jdt|j dt ||f||d }||_ ||_ |S) a Creates a copy of this model class with a new name, inputs or outputs. The new class is technically a subclass of the original class, so that instance and type checks will still work. For example:: >>> from astropy.modeling.models import Rotation2D >>> SkyRotation = Rotation2D.rename('SkyRotation') >>> SkyRotation Name: SkyRotation (Rotation2D) N_inputs: 2 N_outputs: 2 Fittable parameters: ('angle',) >>> issubclass(SkyRotation, Rotation2D) True >>> r = SkyRotation(90) >>> isinstance(r, Rotation2D) True __main__Nz+Expected 'inputs' to be a tuple of strings.z expects z inputsz,Expected 'outputs' to be a tuple of strings.z outputs)inputsoutputs) rr7r`rrLr] TypeErrorlen ValueErrorrr{r8r9)rcr`rrmodmodnameZnew_clsr2r2r3renames,    z_ModelMeta.renamecCsB|d}|dus |jdtur$dSt|tr4|j}||_|`dS)Ninverser)getr|objectrLpropertyfget_inverser)rcrbrr2r2r3ris  z#_ModelMeta._create_inverse_propertyc Cs|d}|dus |jdtur$dSt|tr4|j}t|szt||}Wqt y~}zt |j dWYd}~qd}~00n"t |}t |jdkr|||}||_|`dS)z Takes any bounding_box defined on a concrete Model subclass (either as a fixed tuple or a property or method) and wraps it in the generic getter/setter interface for the bounding_box attribute. bounding_boxNrr)rr|rrLrrcallablervalidaterr)argsrr parameters_create_bounding_box_subclass _bounding_boxr)rcrbrexcsigr2r2r3rj s  & z(_ModelMeta._create_bounding_box_propertycsfdd}g}t|jD]@\}}|dkr0q|j|jurLtd|j||j|jfq||_ t |jdt fd|iS)a For Models that take optional arguments for defining their bounding box, we create a subclass of ModelBoundingBox with a ``__call__`` method that supports those additional arguments. Takes the function's Signature as an argument since that is already computed in _create_bounding_box_property, so no need to duplicate that effort. cs|jfi|Sr,)Z_model)selfr0funcr2r3rxLsz:_ModelMeta._create_bounding_box_subclass..__call__rzThe bounding_box method for {0} is not correctly defined: If defined as a method all arguments to that method (besides self) must be keyword arguments with default values that can be used to compute a default bounding box.rrx) enumeratervaluesdefaultemptyr)formatr`appendZ __signature__r{r)rcrrrxr0idxparamr2rr3r5s   z(_ModelMeta._create_bounding_box_subclasscsDdd}d|vr~d|vr~t|dtr~|ddkr~fdd}d}td d d tjfd d g}t|||ddd}|||_d|vr@ts@j r@t dd| Drd}g}| D]8\}} | j } | j} | durt| | dd} ||| fqndt|}i}fdd} t| ||dd} || | _dS)NcSs:|j|_t||jj|_t|dr6|jd|j|_dS)Nr9.)r8getattrr7r:r\r9)wrapperrcr2r2r3update_wrappergs z:_ModelMeta._handle_special_methods..update_wrapperrxn_inputsrcst|j|i|S)z+Evaluate this model on the supplied inputs.)rUrx)rrr0rgrcr2r3rxxsz4_ModelMeta._handle_special_methods..__call__r)model_set_axisN)with_bounding_boxF fill_value) equivalenciesN) inputs_mapNr new_inputs)Zvarargs varkwargsrhcss|]}|jduVqdSr,rrNrtr2r2r3 r5z5_ModelMeta._handle_special_methods..Fcopycst|j|i|Sr,)rUrh)rparamsr0rr2r3rhsz4_ModelMeta._handle_special_methods..__init__r0)r)rLintrZnpnanrrxrrrRallrrTrunitr rr]keysrh)rcrbrlrrxrr0Znew_call param_nameZ param_valrrrhZnew_initrfrpr3rkdsN      z"_ModelMeta._handle_special_methodsr>r@rBrDrFrHrJr'cstg}|js|dSdd}znd||fd|jfd|jfg}|jrX|d|jf||D]$\}}|dur`||d |q`d |WSty|dYS0dS) Internal implementation of ``__repr__``. This is separated out for ease of use by subclasses that wish to override the default ``__repr__`` while keeping the same basic formatting. rcSspg}|ddD]8}t|ts&qnt|s<|jdr@qN||jq|rj|jdd |dS|jS)Nrrz (z -> )) mrorYr"rrr7rzrr`join)rcrardr2r2r3format_inheritances   z7_ModelMeta._format_cls_repr..format_inheritanceNameZN_inputsZ N_outputszFittable parametersN:  ) rUrqrr n_outputsr^rr Exception)rckeywordspartsrdefault_keywordskeywordvaluerfr2r3ros&     z_ModelMeta._format_cls_repr)NNN)r7r8r9r:r<rVrhrqrvr~rr`rrrirjrrkr6r=r?rArCrErGrIrKro __classcell__r2r2rfr3r;As2 +     2(/ Tr;csbeZdZdZejZdZdZdZ dZ dZ dZ dZ dZeZdZdZdZdZdZdZdZdZdZdZdZddd fd d Zd d ZddZe ddZ!e!j"ddZ!e ddZ#e#j"ddZ#e ddZ e ddZ ddZ$ddZ%e ddZ&e d d!Z'e d"d#Z(d$d%Z)d&d'Z*d(d)Z+e,d*d+Z-fd,d-Z.d.d/Z/dd0d1Z0e d2d3Z1d4d5Z2d6d7Z3d8d9Z4d:d;Z5dd?Z7d@dAZ8dBdCZ9e dDdEZ:e:j"dFdEZ:e dGdHZ;e dIdJZe>j"dPdOZ>e dQdRZ?e dSdTZ@e dUdVZAe dWdXZBe dYdZZCd[d\ZDe d]d^ZEeEj"d_d^ZEeEjFd`d^ZEe dadbZGe dcddZHeHj"deddZHdfdgZIeHjFdhddZHe didjZJe dkdlZKeKj"dmdlZKe dndoZLeLj"dpdoZLe dqdrZMdsdtZNdudvZOdwdxZPdydzZQe d{d|ZRe d}d~ZSeTjUddZVddZWdddZXe ddZYe ddZZddZ[e,ddZ\ddZ]dddddZ^dddZ_ddZ`e,ddZaddZbddZcddZdddZeddZfegddZhdddZie ddZjddZkddZlddZmddZnddZoddZpddZqdddZrgiifddZsgifddZtZuS)r"ad Base class for all models. This is an abstract class and should not be instantiated directly. The following initialization arguments apply to the majority of Model subclasses by default (exceptions include specialized utility models like `~astropy.modeling.mappings.Mapping`). Parametric models take all their parameters as arguments, followed by any of the following optional keyword arguments: Parameters ---------- name : str, optional A human-friendly name associated with this model instance (particularly useful for identifying the individual components of a compound model). meta : dict, optional An optional dict of user-defined metadata to attach to this model. How this is used and interpreted is up to the user or individual use case. n_models : int, optional If given an integer greater than 1, a *model set* is instantiated instead of a single model. This affects how the parameter arguments are interpreted. In this case each parameter must be given as a list or array--elements of this array are taken along the first axis (or ``model_set_axis`` if specified), such that the Nth element is the value of that parameter for the Nth model in the set. See the section on model sets in the documentation for more details. model_set_axis : int, optional This argument only applies when creating a model set (i.e. ``n_models > 1``). It changes how parameter values are interpreted. Normally the first axis of each input parameter array (properly the 0th axis) is taken as the axis corresponding to the model sets. However, any axis of an input array may be taken as this "model set axis". This accepts negative integers as well--for example use ``model_set_axis=-1`` if the last (most rapidly changing) axis should be associated with the model sets. Also, ``model_set_axis=False`` can be used to tell that a given input should be used to evaluate all the models in the model set. fixed : dict, optional Dictionary ``{parameter_name: bool}`` setting the fixed constraint for one or more parameters. `True` means the parameter is held fixed during fitting and is prevented from updates once an instance of the model has been created. Alternatively the `~astropy.modeling.Parameter.fixed` property of a parameter may be used to lock or unlock individual parameters. tied : dict, optional Dictionary ``{parameter_name: callable}`` of parameters which are linked to some other parameter. The dictionary values are callables providing the linking relationship. Alternatively the `~astropy.modeling.Parameter.tied` property of a parameter may be used to set the ``tied`` constraint on individual parameters. bounds : dict, optional A dictionary ``{parameter_name: value}`` of lower and upper bounds of parameters. Keys are parameter names. Values are a list or a tuple of length 2 giving the desired range for the parameter. Alternatively the `~astropy.modeling.Parameter.min` and `~astropy.modeling.Parameter.max` or ~astropy.modeling.Parameter.bounds` properties of a parameter may be used to set bounds on individual parameters. eqcons : list, optional List of functions of length n such that ``eqcons[j](x0, *args) == 0.0`` in a successfully optimized problem. ineqcons : list, optional List of functions of length n such that ``ieqcons[j](x0, *args) >= 0.0`` is a successfully optimized problem. Examples -------- >>> from astropy.modeling import models >>> def tie_center(model): ... mean = 50 * model.stddev ... return mean >>> tied_parameters = {'mean': tie_center} Specify that ``'mean'`` is a tied parameter in one of two ways: >>> g1 = models.Gaussian1D(amplitude=10, mean=5, stddev=.3, ... tied=tied_parameters) or >>> g1 = models.Gaussian1D(amplitude=10, mean=5, stddev=.3) >>> g1.mean.tied False >>> g1.mean.tied = tie_center >>> g1.mean.tied Fixed parameters: >>> g1 = models.Gaussian1D(amplitude=10, mean=5, stddev=.3, ... fixed={'stddev': True}) >>> g1.stddev.fixed True or >>> g1 = models.Gaussian1D(amplitude=10, mean=5, stddev=.3) >>> g1.stddev.fixed False >>> g1.stddev.fixed = True >>> g1.stddev.fixed True )eqconsineqconsr2rTFNr)metar`c st||dur ||_||_|jj}|D]F}t|tr2|j D],\}}t |} || _ ||jvrJ| |j|<qJq2||||}|||||dSr,)rUrh_default_inputs_outputsr_namergrXrYr"rRrTrdeepcopymodelry_initialize_constraints_initialize_setters_initialize_parameters_initialize_slices_initialize_unit_support) rrr`rr0rrcrmrnZnewparrfr2r3rhs$       zModel.__init__cCs|jdkr"|jdkr"d|_d|_nz|jdkrD|jdkrDd|_d|_nXz8tddt|jD|_td dt|jD|_Wntyd |_d |_Yn0dS) Nr)x)yr)rr)zcss|]}dt|VqdSrNstrrNrr2r2r3rr5z0Model._default_inputs_outputs..css|]}dt|VqdSrrrr2r2r3rr5r2)rr_inputs_outputsr]rangerrr2r2r3rs zModel._default_inputs_outputscsDt|dr@fdd|jD}|D]\}}t|||q*S)z| This exists to inject defaults for settable properties for models originating from `custom_model`. _settable_propertiescsi|]\}}|||qSr2)pop)rNr`rr0r2r3rQsz-Model._initialize_setters..)r\rrTsetattr)rr0Zsettersr`rr2rr3rs  zModel._initialize_setterscCs|jSr,rrr2r2r3rsz Model.inputscCs<t||jkr*td|jdt|d||_|dS)N Expected z number of inputs, got r)rrrrrrrnr2r2r3rscCs|jSr,)rrr2r2r3rsz Model.outputscCs4t||jkr*td|jdt|d||_dS)Nrz number of outputs, got r)rrrrrr2r2r3rsc Cslt|jdrdt|jjtrdzt|jjWStybzt|jWYSty\YYdS0Yn0|jjS)Nrr) r\rgrLrrrrrAttributeErrorrr2r2r3rs  zModel.n_inputsc Cslt|jdrdt|jjtrdzt|jjWStybzt|jWYSty\YYdS0Yn0|jjS)Nrr) r\rgrLrrrrrrrr2r2r3rs  zModel.n_outputscCstS)z This is a hook which customises the behavior of modeling.separable. This allows complex subclasses to customise the separability matrix. If it returns `NotImplemented` the default behavior is used. )NotImplementedrr2r2r3_calculate_separability_matrix&sz$Model._calculate_separability_matrixcsHtjtr"fddjD_tjtrDfddjD_dS)z Convert self._input_units_strict and self.input_units_allow_dimensionless to dictionaries mapping input name to a boolean value. csi|] }|jqSr2)_input_units_strictrNr}rr2r3rQ6sz2Model._initialize_unit_support..csi|] }|jqSr2) _input_units_allow_dimensionlessrrr2r3rQ:sN)rLrboolrrrr2rr3r/s    zModel._initialize_unit_supportcs8|jttr$fdd|jDStt|jS)a} Enforce strict units on inputs to evaluate. If this is set to True, input values to evaluate will be in the exact units specified by input_units. If the input quantities are convertible to input_units, they are converted. If this is a dictionary then it should map input name to a bool to set strict input units for that parameter. csi|] }|qSr2r2rrnr2r3rQHr5z,Model.input_units_strict..)rrLrrrZziprrr2rr3input_units_strict=s  zModel.input_units_strictcs8|jttr$fdd|jDStt|jS)a\ Allow dimensionless input (and corresponding output). If this is True, input values to evaluate will gain the units specified in input_units. If this is a dictionary then it should map input name to a bool to allow dimensionless numbers for that input. Only has an effect if input_units is defined. csi|] }|qSr2r2rrr2r3rQWr5z9Model.input_units_allow_dimensionless..)rrLrrrZrrrr2rr3input_units_allow_dimensionlessKs  z%Model.input_units_allow_dimensionlesscCs*dd|jddD}t|dkp(t|S)a True if this model has been created with `~astropy.units.Quantity` objects or if there are no parameters. This can be used to determine if this model should be evaluated with `~astropy.units.Quantity` or regular floats. cSsg|]}t|tqSr2rLr rr2r2r3 cr5z'Model.uses_quantity..T)unitsr) _param_setsrany)rZpisqr2r2r3 uses_quantityZs zModel.uses_quantitycCs|Sr,) _format_reprrr2r2r3rqfszModel.__repr__cCs|Sr,) _format_strrr2r2r3__str__isz Model.__str__cCs|jSr,) _n_modelsrr2r2r3__len__lsz Model.__len__cCstdd|DS)Ncss|]}|dkr|VqdS)rNr2rNitemr2r2r3rqr5z$Model._strip_ones..)r])Zintupr2r2r3 _strip_onesoszModel._strip_onescsZt|tr|j}|j}|dur2||jvr2|j|}t|}|jdurT||||j|d}|dkrnd}t |j }|dkrd}|j|d}t ||ks| || |krt d||t ||||jdurt|tr|j|_|j|_n||_n.t|ts td|jd|j|_|j|_n$|dvrH||j|<nt||dS) Nshaper2rsizez_Value for parameter {0} does not match shape or size expected by model ({1}, {2}) vs ({3}, {4})zThe 'z]' parameter should be given as a Quantity because it was originally initialized as a Quantity)fittablelinear)rLr&rSr^ryr! _validator_param_metricsrarrayrr rrrrr _unitrr r`rU __setattr__)rattrrr^rZeshapeZvshapeZesizerfr2r3rssF            zModel.__setattr__cs<j|i|\}}jdddfdd}||||fS)zZ Model specific input setup that needs to occur prior to model evaluation T)rawrcsjt|Sr,)evaluaterrrrr2r3rsz%Model._pre_evaluate..evaluate)prepare_inputsr)rrr0rbroadcasted_shapesrr2rr3 _pre_evaluateszModel._pre_evaluatecCsPd}t|tr|rLz |j}Wnty.Yn0t|trLt|tsL||}|S)as Return the ``bounding_box`` of a model if it exists or ``None`` otherwise. Parameters ---------- with_bbox : The value of the ``with_bounding_box`` keyword argument when calling the model. Default is `True` for usage when looking up the model's ``bounding_box`` without risk of error. N)rLrrNotImplementedErrorr)r with_bboxbboxr2r2r3get_bounding_boxs   zModel.get_bounding_boxcCs|jS)zDThe inputs used to determine input_shape for bounding_box evaluation)rrr2r2r3 _argnamesszModel._argnamescCst|}|r|rt||dkr._keyword2positionalz#Missing input arguments - expected z, got z$Too many input arguments - expected r)rrrrrrW) rrr0r/Zn_argsrZ n_all_argsnew_argsrOr2r2r3r.<s,        z'Model._get_renamed_inputs_as_positionalcCs|jS)z+User-provided name for this model instance.rrr2r2r3r`tsz Model.namecCs ||_dS)z"Assign a (new) name to this model.Nr1rr2r2r3r`zscCs|jS)a0 The index of the model set axis--that is the axis of a parameter array that pertains to which model a parameter value pertains to--as specified when the model was initialized. See the documentation on :ref:`astropy:modeling-model-sets` for more details. )_model_set_axisrr2r2r3rs zModel.model_set_axiscCs|S)z Return parameters as a pset. This is a list with one item per parameter set, which is an array of that parameter's values across all parameter sets, with the last axis associated with the parameter set. )rrr2r2r3 param_setss zModel.param_setscCsN|js |jS||j|jddj}|j|jddj}|j||S)z A flattened array of all parameter values in all parameter sets. Fittable parameters maintain this list and fitters modify it. rslice)r^ _parameters_parameters_to_arrayrstartstop)rr8r9r2r2r3rs zModel.parametersc Cs|js dS|j|jddj}|j|jddj}z t|}||j||<Wn2ty}zt d |WYd}~n d}~00| dS)zl Assigning to this attribute updates the parameters array rather than replacing it. Nrr4r5zJInput parameter values not compatible with the model parameters array: {0}) r^rr8r9rrZflattenr6rrr_array_to_parameters)rrr8r9er2r2r3rscCst|dsd|_|jS)a+ This is a boolean property that indicates whether or not accessing constraints automatically check the constituent models current values. It defaults to True on creation of a model, but for fitting purposes it should be set to False for performance reasons. _sync_constraintsT)r\r<rr2r2r3sync_constraintss zModel.sync_constraintscCst|tstd||_dS)Nz5sync_constraints only accepts True or False as values)rLrrr<rrr2r2r3r=s cCs"t|dr|jrt|d|_|jS)zO A ``dict`` mapping parameter names to their fixed constraint. _fixedfixed)r\r=rr?rr2r2r3r@s z Model.fixedcCs"t|dr|jrt|d|_|jS)z A ``dict`` mapping parameter names to their upper and lower bounds as ``(min, max)`` tuples or ``[min, max]`` lists. _boundsbounds)r\r=rrArr2r2r3rBs z Model.boundscCs"t|dr|jrt|d|_|jS)zN A ``dict`` mapping parameter names to their tied constraint. _tiedtied)r\r=rrCrr2r2r3rDs z Model.tiedcCs |jdS)z'List of parameter equality constraints.r _mconstraintsrr2r2r3rsz Model.eqconscCs |jdS)z)List of parameter inequality constraints.rrErr2r2r3rszModel.ineqconscCs$z |jWntyYdS0dS)z\ Returns True if the model has an analytic or user inverse defined. FT)rrrr2r2r3 has_inverses   zModel.has_inversecCsF|jdur|jS|jdur:|}|tur:|js6d|_|StddS)a Returns a new `~astropy.modeling.Model` instance which performs the inverse transform, if an analytic inverse is defined for this model. Even on models that don't have an inverse defined, this property can be set with a manually-defined inverse, such a pre-computed or experimentally determined inverse (often given as a `~astropy.modeling.polynomial.PolynomialModel`, but not by requirement). A custom inverse can be deleted with ``del model.inverse``. In this case the model's inverse is reset to its default, if a default exists (otherwise the default is to raise `NotImplementedError`). Note to authors of `~astropy.modeling.Model` subclasses: To define an inverse for a model simply override this property to return the appropriate model representing the inverse. The machinery that will make the inverse manually-overridable is added automatically by the base class. NzUNo analytical or user-supplied inverse transform has been implemented for this model.) _user_inverserr_has_inverse_bounding_boxrr)rresultr2r2r3r s  z Model.inversecCs$t|ttdfstd||_dS)NzThe ``inverse`` attribute may be assigned a `Model` instance or `None` (where `None` explicitly forces the model to have no inverse.)rLr"r{rrHr>r2r2r3r-s cCs z|`WntyYn0dS)z~ Resets the model's inverse to its default (if one exists, otherwise the model will have no inverse). N)rHrrr2r2r3r7s cCs |jduS)z A flag indicating whether or not a custom inverse model has been assigned to this model by a user, via assignment to ``model.inverse``. N)rHrr2r2r3has_user_inverseCszModel.has_user_inversecCs|jdur"|jturtd|jS|jdur6tdnNt|jtrH|jSt|jtjrft||S|jd|d}|j||dSdS)a A `tuple` of length `n_inputs` defining the bounding box limits, or raise `NotImplementedError` for no bounding_box. The default limits are given by a ``bounding_box`` property or method defined in the class body of a specific model. If not defined then this property just raises `NotImplementedError` by default (but may be assigned a custom value by a user). ``bounding_box`` can be set manually to an array-like object of shape ``(model.n_inputs, 2)``. For further usage, see :ref:`astropy:bounding-boxes` The limits are ordered according to the `numpy` ``'C'`` indexing convention, and are the reverse of the model input order, e.g. for inputs ``('x', 'y', 'z')``, ``bounding_box`` is defined: * for 1D: ``(x_low, x_high)`` * for 2D: ``((y_low, y_high), (x_low, x_high))`` * for 3D: ``((z_low, z_high), (y_low, y_high), (x_low, x_high))`` Examples -------- Setting the ``bounding_box`` limits for a 1D and 2D model: >>> from astropy.modeling.models import Gaussian1D, Gaussian2D >>> model_1d = Gaussian1D() >>> model_2d = Gaussian2D(x_stddev=1, y_stddev=1) >>> model_1d.bounding_box = (-5, 5) >>> model_2d.bounding_box = ((-6, 6), (-5, 5)) Setting the bounding_box limits for a user-defined 3D `custom_model`: >>> from astropy.modeling.models import custom_model >>> def const3d(x, y, z, amp=1): ... return amp ... >>> Const3D = custom_model(const3d) >>> model_3d = Const3D() >>> model_3d.bounding_box = ((-6, 6), (-5, 5), (-4, 4)) To reset ``bounding_box`` to its default limits just delete the user-defined value--this will reset it back to the default defined on the class: >>> del model_1d.bounding_box To disable the bounding box entirely (including the default), set ``bounding_box`` to `None`: >>> model_1d.bounding_box = None >>> model_1d.bounding_box # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): NotImplementedError: No bounding box is defined for this model (note: the bounding box was explicitly disabled for this model; use `del model.bounding_box` to restore the default bounding box, if one is defined for this model). NzNo bounding box is defined for this model (note: the bounding box was explicitly disabled for this model; use `del model.bounding_box` to restore the default bounding box, if one is defined for this model).z*No bounding box is defined for this model.r2r) _user_bounding_boxrrrrLrtypes MethodTyper)rrr2r2r3rKs <    zModel.bounding_boxc Cs|durd}t}n>t|ts&t|tr,t}n$t|jtrLt|jtrL|j}nt}|durz|||}Wn2t y}zt |j dWYd}~n d}~00||_ dS)z2 Assigns the bounding box limits. Nr) rrLrrZrr{rYrrrrrM)rrrcrr2r2r3rs$   $cGs"t|jtr||j_ntddS)Nz/The bounding_box for this model is not compound)rLrMrZ slice_args RuntimeErrorrrr2r2r3set_slice_argss  zModel.set_slice_argscCs d|_dSr,rMrr2r2r3rscCs |jduSz A flag indicating whether or not a custom bounding_box has been assigned to this model by a user, via assignment to ``model.bounding_box``. NrSrr2r2r3has_user_bounding_boxszModel.has_user_bounding_boxcCs|jS)zD Fitter should set covariance matrix, if available. ) _cov_matrixrr2r2r3 cov_matrixszModel.cov_matrixcs|_fddjD}t|tkrg}|D] }|ddt|jDq.t|D]2\}t |}fdd|D|_ t ||qXnBddt|jD}|D]&}t |}| d|_ t ||qdS)Ncs,g|]$}j|durj|dur|qS)F)r@rDrrr2r3rsz$Model.cov_matrix..cSs"g|]}|dkrt|ndqSrNrZsqrtrNrr2r2r3rr5csg|] }|qSr2r2r)rtr2r3rr5cSs"g|]}|dkrt|ndqSrXrYrZr2r2r3rr5r) rVr^r{rWrrZdiagrWrrZstdrr)rZcovZunfix_untied_paramsZ param_stdscrparr2)rtrr3rWs    cCs|jS)zV Standard deviation of parameters, if covariance matrix is available. _stdsrr2r2r3stdssz Model.stdscCs ||_dSr,r])rr_r2r2r3r_scCs&|jdur|jStd|jjdS)z0 A flag indicating whether a model is separable.Nz4The "separable" property is not defined for model {}) _separablerrrgr7rr2r2r3 separables zModel.separablec  s|}fdd|jD}fdd|jD}|||}|D]:\}}t||}|jdurD|j|j |_ |j dddqDt |t r| |S)a Return an instance of the model for which the parameter values have been converted to the right units for the data, then the units have been stripped away. The input and output Quantity objects should be given as keyword arguments. Notes ----- This method is needed in order to be able to fit models with units in the parameters, since we need to temporarily strip away the units from the model during the fitting (which might be done by e.g. scipy functions). The units that the parameters should be converted to are not necessarily the units of the input data, but are derived from them. Model subclasses that want fitting to work in the presence of quantities need to define a ``_parameter_units_for_data_units`` method that takes the input and output units (as two dictionaries) and returns a dictionary giving the target units for each parameter. cs*i|]"}|dur|t|dtqSNrrr rNinprr2r3rQ sz0Model.without_units_for_data..cs*i|]"}|dur|t|dtqSrbrcrNoutrr2r3rQ#sNTZforce)rrr_parameter_units_for_data_unitsrTrrZquantitytor _set_unitrLr&strip_units_from_tree rr0rZ inputs_unitZ outputs_unitZparameter_unitsr`r parameterr2rr3without_units_for_datas$     zModel.without_units_for_datac sd|j}|dus|ikr`fdd|jD}|fi||jdkrHffddt|jD}|S)a Return a dictionary of output units for this model given a dictionary of fitting inputs and outputs The input and output Quantity objects should be given as keyword arguments. Notes ----- This method is needed in order to be able to fit models with units in the parameters, since we need to temporarily strip away the units from the model during the fitting (which might be done by e.g. scipy functions). This method will force extra model evaluations, which maybe computationally expensive. To avoid this, one can add a return_units property to the model, see :ref:`astropy:models_return_units`. Ncsi|]}||qSr2r2rdrr2r3rQIr5z&Model.output_units..rcs"i|]\}}|t|dtqS)rrc)rNindexrg)rr2r3rQOs) return_unitsrrrr)rr0rrr2)r0rr3 output_units2s  zModel.output_unitscCs4|jD](}|jD]}t||}|jdddqqdS)NTrh) _leaflistr^rrk)rrrmr\r2r2r3rlTs   zModel.strip_units_from_treec  sj|}fdd|jD}fdd|jD}|||}|D] \}}t||}|j|ddqD|S)a Return an instance of the model which has units for which the parameter values are compatible with the data units specified. The input and output Quantity objects should be given as keyword arguments. Notes ----- This method is needed in order to be able to fit models with units in the parameters, since we need to temporarily strip away the units from the model during the fitting (which might be done by e.g. scipy functions). The units that the parameters will gain are not necessarily the units of the input data, but are derived from them. Model subclasses that want fitting to work in the presence of quantities need to define a ``_parameter_units_for_data_units`` method that takes the input and output units (as two dictionaries) and returns a dictionary giving the target units for each parameter. cs*i|]"}|dur|t|dtqSrbrcrdrr2r3rQrsz.Model.with_units_from_data..cs*i|]"}|dur|t|dtqSrbrcrfrr2r3rQusTrh)rrrrirTrrkrmr2rr3with_units_from_dataZs   zModel.with_units_from_datacCs&|jD]}t||jdurdSqdS)NTF)r^rr)rrr2r2r3 _has_unitss zModel._has_unitscCs t|dS)Nri)r\rr2r2r3_supports_unit_fittingszModel._supports_unit_fittingcOsdS)z+Evaluate the model on some input variables.Nr2rrr0r2r2r3rszModel.evaluatecOsdS)a Evaluate the sum of any implicit model terms on some input variables. This includes any fixed terms used in evaluating a linear model that do not have corresponding parameters exposed to the user. The prototypical case is `astropy.modeling.functional_models.Shift`, which corresponds to a function y = a + bx, where b=1 is intrinsically fixed by the type of model, such that sum_of_implicit_terms(x) == x. This method is needed by linear fitters to correct the dependent variable for the implicit term(s) when solving for the remaining terms (ie. a = y - bx). Nr2rwr2r2r3sum_of_implicit_termsszModel.sum_of_implicit_termsc sz |j}Wnty d}Yn0t|tr4|}|j}|durZ|durZ|durZtd|dkr~|durp|g}|dur~|g}|durtj|td}t ||ksJ|dur|dj |j krtdnt |dj }|durt|}|j |krtd|durt dd |Dtj}|\}|dur^t|d dt fd d |D}nd d |jD}tj|}|ddd }|dur||}n2zt|||}WntytdYn0nB|dur|j } dd | D}tj|}|ddd }|||7}|S)} Evaluate a model at fixed positions, respecting the ``bounding_box``. The key difference relative to evaluating the model directly is that this method is limited to a bounding box if the `Model.bounding_box` attribute is set. Parameters ---------- out : `numpy.ndarray`, optional An array that the evaluated model will be added to. If this is not given (or given as ``None``), a new array will be created. coords : array-like, optional An array to be used to translate from the model's input coordinates to the ``out`` array. It should have the property that ``self(coords)`` yields the same shape as ``out``. If ``out`` is not specified, ``coords`` will be used to determine the shape of the returned array. If this is not provided (or None), the model will be evaluated on a grid determined by `Model.bounding_box`. Returns ------- out : `numpy.ndarray` The model added to ``out`` if ``out`` is not ``None``, or else a new array from evaluating the model over ``coords``. If ``out`` and ``coords`` are both `None`, the returned array is limited to the `Model.bounding_box` limits. If `Model.bounding_box` is `None`, ``arr`` or ``coords`` must be passed. Raises ------ ValueError If ``coords`` are not given and the the `Model.bounding_box` of this model is not set. Examples -------- :ref:`astropy:bounding-boxes` N7If no bounding_box is set, coords or out must be input.rZdtyper!inconsistent shape of the output..rcsg|]}t|qSr2rrNr[posZ sub_shaper2r3rscSs(g|] \}}t||||ddqSr r4rNrtdr2r2r3rr5r5kThe `bounding_box` is larger than the input out in one or more dimensions. Set `model.bounding_box = None`.cSsg|] }t|qSr2rrNir2r2r3rr5)rrrLrrrr asanyarrayfloatrrzerosndimrastyperTr]mgridr rrgcoordsrrpddelta sub_coordslimitsim_shaper2rr3rendersn*                  z Model.rendercsZt|dr|jSt|jdrR|jjddrVtfdd|jDSndSdS)a This property is used to indicate what units or sets of units the evaluate method expects, and returns a dictionary mapping inputs to units (or `None` if any units are accepted). Model sub-classes can also use function annotations in evaluate to indicate valid input units, in which case this property should not be overridden since it will return the input units based on the annotations. _input_units__annotations__returnNc3s|]}||fVqdSr,r2rNr` annotationsr2r3r.r5z$Model.input_units..)r\rrrrrrZrrr2rr3 input_unitss    zModel.input_unitscCs4t|dr|jSt|jdr,|jjddSdSdS)a This property is used to indicate what units or sets of units the output of evaluate should be in, and returns a dictionary mapping outputs to units (or `None` if any units are accepted). Model sub-classes can also use function annotations in evaluate to indicate valid output units, in which case this property should not be overridden since it will return the return units based on the annotations. _return_unitsrrN)r\rrrrrr2r2r3rq3s  zModel.return_unitsc Ksg}t|D]\}}|j}|s,|d||<|s6|}nd}|D]} z|jrXt|| j} n|} Wn0tytd|j||| j | jYn0t | t |kr| }q>t | t |kr>t || }q>| |q |j |jkr |j |j} |s| d||dg| ||ffS)Nr r2zaself input argument {0!r} of shape {1!r} cannot be broadcast with parameter {2!r} of shape {3!r}.r)rrreshapestandard_broadcastingrrrrrr`rmaxrrrextend) rrrr0Z broadcastsrrr"Z max_broadcastrZ broadcastZ extra_outputsr2r2r3_prepare_inputs_single_modelGs>       z"Model._prepare_inputs_single_modelcCslt|dkr|S|dkr@t||}|d|||ddS|t|krXt|d}||dd}|S)z Given a shape tuple as the first input, construct a new one by removing that particular axis from the shape and all preceeding axes. Negative axis numbers are permittted, where the axis is relative to the last axis. rNr)r)rZaxisr2r2r3_remove_axes_from_shapevs    zModel._remove_axes_from_shapecKs$g}g}|j}t|D]\}} d} |jdkrX|durX| jd|| j|dd} n| j} |D]z} zt| || j|Wn8tytd|j || | j || j|Yn0t | jdt | krb|| j|} qbt | } |dur^t | | kr&dt | | }d|}|| j}|}n,| t | }| jd|d| j|d}| |}nt | | krt | | }|j}d|}| jd|d|| j|dd}| |}n$| j t | d}t| ||d}||||q|j|jkr||g|j|j||ffS)Nr2rFzbModel input argument {0!r} of shape {1!r} cannot be broadcast with parameter {2!r} of shape {3!r}.r )rrrrrrrrrrr`rrrrrollaxisrrrr)rrrZmodel_set_axis_inputr0ZreshapedpivotsZmodel_set_axis_paramrrZmax_param_shaper"rZ input_ndimZ n_new_axesnew_axesZ new_shapepivotZ new_inputr2r2r3_prepare_inputs_model_setsx             zModel._prepare_inputs_model_set)rrcs|durj}fddjD}dd|D}|j||dd}|||}jdkrxj||fi|Sj|||fi|SdS)a This method is used in `~astropy.modeling.Model.__call__` to ensure that all the inputs to the model can be broadcast into compatible shapes (if one or both of them are input as arrays), particularly if there are more than one parameter sets. This also makes sure that (if applicable) the units of the input will be compatible with the evaluate method. Ncsg|]}t|qSr2rrrr2r3rr5z(Model.prepare_inputs..cSsg|]}tj|tdqS)r{)rrr)rNrr2r2r3rr5rr) rr^r&rr_validate_input_unitsrrr)rrrrr0rrr2rr3rs   zModel.prepare_inputsc Cst|}|jp|jj}|jdur|rVi}|D]$\}}||ur.||d||d<q.n|}t|j||j}tt |D],} |j| } |j | d} | durqvt || t r\|| j j| || drt |dks|j| r|| j| || d|| <nb| tur,td||j| || j || j jn.td||j| || j || j j| | jqv|j| sv| turv| durvt|| dkrvtd||j| | | jqv|S)Nrr)rz[{0}: Units of input '{1}', {2} ({3}),could not be converted to required dimensionless inputza{0}: Units of input '{1}', {2} ({3}), could not be converted to required input units of {4} ({5})zg{0}: Units of input '{1}', (dimensionless), could not be converted to required input units of {2} ({3}))rWr`rgr7rrrinput_units_equivalenciesrrrrLr rZ is_equivalentrrjr r rZ physical_typerrr) rrrrr`ZedictrmappingrrZ input_nameZ input_unitr2r2r3rsj            zModel._validate_input_unitscsjtdd|D}|jrf|rf|jdkrBt|jsB|jd|jin|jtfddt||jD}|S)NcSsg|]}t|tqSr2rrr2r2r3rLr5z/Model._process_output_units..rrcs&g|]\}}t||dddqS)NT)Zsubok)r r)rNrgZout_namerqr2r3rTs)rrqrrrr]r)rrrZinputs_are_quantityr2rr3r)Ks   zModel._process_output_unitsc Csb|dur^|s|Sz ||WSty\z|WYStyV|YYS0Yn0|Sr,)rrr)outputbroadcast_shaper2r2r3_prepare_output_single_modelXs   z"Model._prepare_output_single_modelc Csft|}t|D]L\}}zt|d}Wn"ttfyJ|d|}Yn0|||||<qt|SNr)rWrrrrrr])rrrrrrr2r2r3_prepare_outputs_single_modelhsz#Model._prepare_outputs_single_modelcCsl|d}|dus|dur|j}t|}t|D]4\}}||}||jkr.||kr.t|||||<q.t|S)NrF)rrWrrrrr])rrrrrrrrr2r2r3_prepare_outputs_model_setts z Model._prepare_outputs_model_setcOs6|dd}t|dkr$|||S||||SdS)Nrr)rrrr)rrrr0rr2r2r3r(s   zModel.prepare_outputscCs t|S)z Return a copy of this model. Uses a deep copy so that all model attributes, including parameter values, are copied as well. )rrrr2r2r3rsz Model.copycCs|S)z4 Return a deep copy of this model. rrr2r2r3rszModel.deepcopycCs|}||_|S)z> Return a copy of this model with a new name. )rr)rr`Z new_modelr2r2r3rsz Model.renamec sXddlm}|}dur.|jdur,|jnifdd|jDD]}|durD|tkrDtdqDttrt |jkrdd d d |jd }t|fd d|jDt |j krd |j d t }t|t fddt|jD} || ||d} |j| _|j| _| |B}durT|jdurL|jnifdd|jDD]"}|durd|tkrdtdqdttrt |jkrdd dd |jd }t|fdd|jDt |jkrd|jd t }t|t fddt|jD} || } |j| _|j| _|| B}|S)a Attach units to this (unitless) model. Parameters ---------- input_units : dict or tuple, optional Input units to attach. If dict, each key is the name of a model input, and the value is the unit to attach. If tuple, the elements are units to attach in order corresponding to `Model.inputs`. return_units : dict or tuple, optional Output units to attach. If dict, each key is the name of a model output, and the value is the unit to attach. If tuple, the elements are units to attach in order corresponding to `Model.outputs`. input_units_equivalencies : dict, optional Default equivalencies to apply to input values. If set, this should be a dictionary where each key is a string that corresponds to one of the model inputs. input_units_allow_dimensionless : bool or dict, optional Allow dimensionless input. If this is True, input values to evaluate will gain the units specified in input_units. If this is a dictionary then it should map input name to a bool to allow dimensionless numbers for that input. Returns ------- `CompoundModel` A `CompoundModel` composed of the current model plus `~astropy.modeling.mappings.UnitsMapping` model(s) that attach the units. Raises ------ ValueError If the current model already has units. Examples -------- Wrapping a unitless model to require and convert units: >>> from astropy.modeling.models import Polynomial1D >>> from astropy import units as u >>> poly = Polynomial1D(1, c0=1, c1=2) >>> model = poly.coerce_units((u.m,), (u.s,)) >>> model(u.Quantity(10, u.m)) # doctest: +FLOAT_CMP >>> model(u.Quantity(1000, u.cm)) # doctest: +FLOAT_CMP >>> model(u.Quantity(10, u.cm)) # doctest: +FLOAT_CMP Wrapping a unitless model but still permitting unitless input: >>> from astropy.modeling.models import Polynomial1D >>> from astropy import units as u >>> poly = Polynomial1D(1, c0=1, c1=2) >>> model = poly.coerce_units((u.m,), (u.s,), input_units_allow_dimensionless=True) >>> model(u.Quantity(10, u.m)) # doctest: +FLOAT_CMP >>> model(10) # doctest: +FLOAT_CMP r) UnitsMappingNcsg|]}|qSr2rr model_unitsr2r3rr5z&Model.coerce_units..z>Cannot specify input_units for model with existing input unitszinput_units keys (, z) do not match model inputs (rcsg|] }|qSr2r2rrr2r3rr5z5input_units length does not match n_inputs: expected z , received c3s |]\}}||fVqdSr,rrNrrrr2r3r r5z%Model.coerce_units..)rrcsg|]}|qSr2rrrr2r3r r5z@Cannot specify return_units for model with existing output unitszreturn_units keys (z) do not match model outputs (csg|] }|qSr2r2rrr2r3r" r5z7return_units length does not match n_outputs: expected c3s |]\}}||fVqdSr,rrrr2r3r+ r5)Zmappingsrrrr rrLrZrsetrrrr]rrrqr) rrrqrrrrJrmessagerZ input_mappingZreturn_mappingr2)rrrqr3 coerce_unitss~D           zModel.coerce_unitscCsdS)zb Return the number of components in a single model, which is obviously 1. rr2rr2r2r3 n_submodels3 szModel.n_submodelscCsl|jD]8}||i}|D]\}}t||}t|||qqi|_|jD]}||g}||j|<qLdS)z Pop parameter constraint values off the keyword arguments passed to `Model.__init__` and store them in private instance attributes. N)parameter_constraintsrrTrrrFmodel_constraints)rr0Z constraintrZckeyZcvaluerr2r2r3r; s     zModel._initialize_constraintscCs|dd}|dus:t|ttjfr,|dks:td||dd}|durj|durd|dkrdd}qd}n(|dustt|tjstd|t }t |t |j krt d |j jt |j t |||_tt|_t|D]P\}}|durq|j |}||t|ts"t|td } n|} ||| q|j D]h}||vr:||vrft d |j j|||} | dur~q:t| td } ||||| q:|j D]}||vr||dq|r|D]} t d |j j| q|dur|dkr|rd} |dkr t|} n|d} |j D]z} t|| } t| }|| krdtd | || |t| |} |dur| j|}n"| j||kr.td| ||q.|| n|durd}|d||_ |D]*} t|| }|j!dur|!||j"qdS)a  Initialize the _parameters array that stores raw parameter values for all parameter sets for use with vectorized fitting algorithms; on FittableModels the _param_name attributes actually just reference slices of this array. n_modelsNrzn_models must be either None (in which case it is determined from the model_set_axis of the parameter initial values) or it must be a positive integer (got {0!r})rrFzmodel_set_axis must be either False or an integer specifying the parameter array axis to map to each model in a set of models (got {0!r}).zA{0}.__init__() takes at most {1} positional arguments ({2} given)r{z6{0}.__init__() got multiple values for parameter {1!r}z2{0}.__init__() got an unrecognized parameter {1!r}zAll parameter values must be arrays of dimension at least {0} for model_set_axis={1} (the value given for {2!r} is only {3}-dimensional)zInconsistent dimensions for parameter {0!r} for {1} model sets. The length of axis {2} must be the same for all input parameter values)#rrLrrintegerrr issubdtyper{rrr^rrgr7r2rrZrraddrr r_initialize_parameter_valueabsrrrrr_check_param_broadcastrr r)rrr0rrrrargrrkwargmax_ndimZmin_ndimr` param_ndimrr2r2r3rL s                               zModel._initialize_parameterscCst|tr||j|<dSt||}|durX|j}|durLtd|jj||}|j }nt|t rp|j }|j }nd}|dur|j durt d|jj|||_ d|_|jdur |dur|||}n ||}t|t r|j |_t|j |_nd|_t||_n t||_dS)zAMostly deals with consistency checks and determining unit issues.Nz3{0}.__init__() requires a value for parameter {1!r}z6{0}.__init__() requires a Quantity for parameter {1!r})rLrryrrrrrgr7rr rrr internal_unit_setterrr_internal_valueZ_value)rrrrrrZ_valr2r2r3r sD       z!Model._initialize_parameter_valuec Cs|j}d}|jD]b}t||}|j}t|}t|}t|||}|||d<|||d<|||d<||7}qtj|tj d|_ dSNrr4rr r{ rr^rrrr rr4rZfloat64r6 r param_metricsZ total_sizer`rrZ param_size param_shapeZ param_slicer2r2r3r s        zModel._initialize_slicescCsT|j}|jD]B}t||}|j}t|tjs8t|g}||j ||d<q dS)Nr4) rr^rrrLrZndarrayrZravelr6rrr`rrr2r2r3r7 s    zModel._parameters_to_arraycCsF|j}|jD]4}t||}|j||d}||d|_||_q dS)Nr4r)rr^rr6rrrr2r2r3r:& s   zModel._array_to_parametersc Csg}|j}|jD]}t||}|j}t|}t|}|dur||krd||} |dkrd| |} n$|d|d| ||dd} | |j|d<|| q||qz t |Wn\t y} zB| j \} } }}|j| }|j|}t d || ||WYd} ~ n d} ~ 00dS)a{ This subroutine checks that all parameter arrays can be broadcast against each other, and determines the shapes parameters must have in order to broadcast correctly. If model_set_axis is None this merely checks that the parameters broadcast and returns an empty dict if so. This mode is only used for single model sets. Nr rrrzParameter {0!r} of shape {1!r} cannot be broadcast with parameter {2!r} of shape {3!r}. All parameter arrays must have shapes that are mutually compatible according to the broadcasting rules.)r2r^rrrrrrrrrrrr)rrr%rr`rrrrrrrZshape_aZ shape_a_idxZshape_bZ shape_b_idxZparam_aZparam_br2r2r3r. s>           zModel._check_param_broadcastc Csg}g}|jD]}t||}|r.|jr.|j}n|j}|j|d}|durV||}|t |t |dkr~t |g}|r|r|j dur|j } n|j} | durt|| }||qt t|dks|rt jt |td} || dd<| St |S)a Implementation of the Model.param_sets property. This internal implementation has a ``raw`` argument which controls whether or not to return the raw parameter values (i.e. the values that are actually stored in the ._parameters array, as opposed to the values displayed to users. In most cases these are one in the same but there are currently a few exceptions. Note: This is notably an overcomplicated device and may be removed entirely in the near future. rNrr{)r^rrrrrrrrrrrrrrr rrr) rrrrZshapesr`rrrrZpsetsr2r2r3re s2          zModel._param_setscsdd|D}|fddjDjdurD|dj|D]2\}}||vrj|||krjqL||d|qLtdkr|d td jjd d |d S)rcSsg|] }t|qSr2)rs)rNar2r2r3r r5z&Model._format_repr..c3s&|]}|dtt|VqdS)=N)r rrrr2r3r sz%Model._format_repr..Nzname=rrz n_models=<(rz)>) rr^r`rrTrrgr7r)rrr0defaultsrrrr2rr3r s   zModel._format_reprc sdjjfdjfdjfdjfdtfg}dd|D}|D]:\}}||vrh|||krhqB||d|qB|d td krfd djD}nfd djD}|rt |jd }jD]} t | j || _ q|t t |ddd|S)z Internal implementation of ``__str__``. This is separated out for ease of use by subclasses that wish to override the default ``__str__`` while keeping the same basic formatting. r"rZInputsZOutputszModel set sizecSs&g|]\}}|dur|d|qS)Nrr2)rNrrr2r2r3r sz%Model._format_str..rz Parameters:rcsg|]}t|jgqSr2rrrrr2r3r scsg|]}t|jqSr2rrrr2r3r s)names)widthr)rgr7r`rrrlowerrr^rrrrrr) rrrrrrrcolumnsZ param_tabler`r2rr3r s6        zModel._format_str)T)NN)NN)NNNF)FF)vr7r8r9r:r constraintsrrr^rrrr r r`rZMetaDatarrrHrrMrIrrrrrVr^rhrrrrsetterrrrrrrrqrr staticmethodrrrrrr$r&r"r'r+r-rxr.r`rr3rr=r@rBrDrrrGrdeleterrKrrRrUrWr_rarorrrlrtrurvabcabstractmethodrrxrrrqrrrrrr)rrrr(rrr rrrrrrrr7r:rrrrrr2r2rfr3r"sRw             +   8               !    U        -"*    v  / D% [       +7 =r") metaclassc@s eZdZdZdZdZdZdZdS)r#z] Base class for models that can be fitted using the built-in fitting algorithms. FNT)r7r8r9r:r  fit_deriv col_fit_derivr r2r2r2r3r# s  r#c@seZdZdZdZdZdZdS)r$z Base class for one-dimensional fittable models. This class provides an easier interface to defining new models. Examples can be found in `astropy.modeling.functional_models`. rTN)r7r8r9r:rrr`r2r2r2r3r$ sr$c@seZdZdZdZdZdS)r%z Base class for two-dimensional fittable models. This class provides an easier interface to defining new models. Examples can be found in `astropy.modeling.functional_models`. rrN)r7r8r9r:rrr2r2r2r3r% sr%csfdd}|S)Ncs"t|d|d|d|dfS)Nrrr)rfgr1r2r3op sz%_make_arithmetic_operator..opr2)r1rr2rr3_make_arithmetic_operator s rcsfddddfS)Ncsdd|||Srr2rrrr2r3r4+ r5z'_composition_operator..rrr2rr2rr3_composition_operator$ s  rcs,fddddddfS)Ncs4d|dd|d|dd|S)Nrrr2rrr2r3r46 sz _join_operator..rrr2rr2rr3_join_operator/ s r)r>r@rBrDrFrHrJcCs t||Sr,)SPECIAL_OPERATORSr)Zsop_nameZsopr2r2r3_add_special_operatorH srcsheZdZdZdqddZddZddZd d Zd d Zd dZ ddZ ddZ e ddZ e ddZddZddZe ddZddZdd Ze d!d"Zd#d$Zd%d&Zd'd(Zd)d*Ze d+d,Zejd-d,Ze d.d/Zejd0d/Ze d1d2Zejd3d2Ze d4d5Zejd6d5Zdrd8d9Zdsd:d;Zdd?Z!d@dAZ"e dBdCZ#e dDdEZ$e dFdGZ%e&dHZ'e&dIZ(e&dJZ)e&dKZ*e&dLZ+e&dMZ,e&dNZ-dOdPZ.dQdRZ/e0dSdTZ1dUdVZ2dWdXZ3e dYdZZ4e d[d\Z5e d]d^Z6e d_d`Z7e dadbZ8dcddZ9e dedfZ:dtdgdhZ;didjZfdodpZ?Z@S)ur&z Base class for compound models. While it can be used directly, the recommended way to combine models is through the model operators. Nc Cspd|jd<d|_||_||_||_d|_d|_d|_d|_d|_ d|_ d|_ |dkrlt |t |krlt dt ||_|dkr|j|jks|jrt d|j|_|dvs|tvr|j|jks|j|jkrtd|j|_|j|_|j|_|j|_n|dkr>|j|j|_|j|j|_t|j|j|_t|j|j|_n|dkr|j|jkrztd |j|j|j|j|j|j|j|_|j|_|j|_|j|_nr|dkrt|tst d t|tst d |jt ||_|j|_|j|_t|j}|}g}|D]}t !t"|t j#r^||jks8|d kr@t d ||vrRt d|$|nHt|t%r ||jvr~t d|j&|} | |vrt d|$| q |'|(|D] } || =qt)||_z|jj*+|||_*Wnt,yYn0n td|j||_d|_-d|_.d|_/|dvrD|j0o>|j0|_0nd|_0g|_1g|_2t |jj3|_4|5dS)NrSr'z1Both operands must have equal values for n_modelsz=model_set_axis must be False or 0 and consistent for operands)r>r@rBrDrFz6Both operands must match numbers of inputs and outputsrJrHzUnsupported operands for |: {0} (n_inputs={1}, n_outputs={2}) and {3} (n_inputs={4}, n_outputs={5}); n_outputs for the left-hand model must match n_inputs for the right-hand model.zGFirst argument to "fix_inputs" must be an instance of an astropy Model.z:Expected a dictionary for second argument of "fix_inputs".rz@Substitution key integer value not among possible input choices.z3Duplicate specification of same input (index/name).z9Substitution key string not among possible input choices.zIllegal operator: )rHr>r@F)6ryZ _n_submodelsrr-r.rrMrs_tdictr6rRrrrrrr2rrrr)rrrrr`rLr"rZrrWrrrr{rrrrpsortreverser]rr'r _fittablerrr rrr n_left_params_map_parameters) rrr-r.r`Z newinputsrZ input_indr}indr2r2r3rhT s                      zCompoundModel.__init__cCs|d|jjSr,)r-rrQr2r2r3_get_left_inputs_from_args sz(CompoundModel._get_left_inputs_from_argscCsR|j}|dkr*||jj|jj|jjS|dks:|dkr>dS|d|jjSdS)NrJrHr')rr-rr.rrrr2r2r3_get_right_inputs_from_args s z)CompoundModel._get_right_inputs_from_argscCsN|j}|dkr0|jj|jj}||||jS||jj|jj|jSdS)NrJrr-rr.r)rrrrr2r2r3_get_left_params_from_args s z(CompoundModel._get_left_params_from_argscCsR|j}|dkrdS|dkr8||jj|jj|jdS||jj|jdSdS)Nr'rJrrr2r2r3_get_right_params_from_args s z)CompoundModel._get_right_params_from_argsc Cs|jdkr8t|d|jj|jj}|jj|jj}nt|d|jj}|jj}|jD]X}||d}|durx|}n0z ||}WntytdYn0|d7}||qZ||fS)NrJzMissing parameter or inputr) rrWr-rr.r^rrr)rrr0r0Zargs_posrZkw_valuerr2r2r3)_get_kwarg_model_parameters_as_positional s       z7CompoundModel._get_kwarg_model_parameters_as_positionalcKs|j}|dkrttj||S|dkr2ttj||S|dkrHttj||S|dkr^ttj||S|dkrtttj||S|dkrt|t s|f}t|t s|f}||S|t vrtt |||St ddS)Nr>r@rBrDrFrJzUnrecognized operator {op}) rbinary_operationoperatorrsubmultruedivpowrLr]rr))rleftvalrightvalkwrr2r2r3_apply_operators_to_value_lists s(  z-CompoundModel._apply_operators_to_value_listsc s|j}|||\}}||}||}|dkrztt|jjt|jj fdd|j Dfddt |D}|jj t||}|dkr|S||}||}|dkrt|tr|j j t||S|j j |g|RSn|j j t||} |j|| fi|S)Nr'cs0i|](\}}tt|tjr"|n||qSr2)rrr{rrNr}r) pos_indexr2r3rQ% sz*CompoundModel.evaluate..cs(g|] \}}|vr |n|qSr2)r)rNrre) fixed_inputsr2r3r) sz*CompoundModel.evaluate..rH)rrrrrZrr-rrrr.rTrr itertoolsrrrrLr]r) rrrrZ left_inputsZ left_paramsr Z right_inputsZ right_paramsr r2)rrr3r s.       zCompoundModel.evaluatecCs|jdur|t|jSr,)rs_make_leaflistrrr2r2r3r@ s zCompoundModel.n_submodelscCsh|jdur|dd|jD}d}g}|D]0}|durT|d||d7}q.||q.t|S)z6 Return the names of submodels in a ``CompoundModel``.NcSsg|] }|jqSr2r`rr2r2r3rK r5z0CompoundModel.submodel_names..rZNone_r)rsrrr])rrZ nonecountZnewnamesrr2r2r3submodel_namesF s   zCompoundModel.submodel_namescCs:tdtz|jj}|jj}Wnty4YdS0dS)zR if both members of this compound model have inverses return True zICompoundModel.both_inverses_exist is deprecated. Use has_inverse instead.FT)warningswarnZAstropyDeprecationWarningr-rr.r)rZlinvZrinvr2r2r3both_inverses_existV s  z!CompoundModel.both_inverses_existcs<dvr"ddDd<fdd}||dfS)a CompoundModel specific input setup that needs to occur prior to model evaluation. Note ---- All of the _pre_evaluate for each component model will be performed at the time that the individual model is evaluated. rcSs$g|]\}}|d|d|ffqSrrr2rr2r2r3ry sz/CompoundModel._pre_evaluate..rcsj|iSr,) _evaluaterr0rr2r3r} sz-CompoundModel._pre_evaluate..evaluateNrrT)rrr0rr2rr3rh s  zCompoundModel._pre_evaluatecCsdS)zONo inputs should be used to determine input_shape when handling compound modelsr2r2rr2r2r3r szCompoundModel._argnamescKs$||dur |jdkr |dS|S)z CompoundModel specific post evaluation processing of outputs Note ---- All of the _post_evaluate for each component model will be performed at the time that the individual model is evaluated. Nrr)rrr*r2r2r3r+ s zCompoundModel._post_evaluatecOs4|j}|dkr|dkrF|j|i|}|dkr@|j|i|}q~d}n8|j|d|jji|}|j||jjdi|}|dkr|j||fi|S|dkrt|tr|j|i|S|j|fi|Sn^|j}t|}g}g} |D]V} t t | t j r| | n$t| tr8|jj| } | | | || qg} g} t|D]R}||jvr\|j|} | t|krtd| | | ||||=q\| rtt| | }|tt|\}}|t|}|r tt|| }||D]\} }|| |q|j|i|SdS)Nr'rJrHz6Keyword argument duplicates positional value supplied.)rr-r.rrrLr]rWrrrr{rrrrrprrrrinsert)rrrrr r ZsubsZnewargsZsubindsZsubvalsr}rZkwindZkwvalZkwkeyr0Z kwindsortedZ kwvalsortedsubargsrnr2r2r3r s^           zCompoundModel._evaluatecCs|jS)z$ An ordered list of parameter names.)rSrr2r2r3r^ szCompoundModel.param_namescCs&i}g}t|d||||_||_dS)N)make_subtree_dictrsr)rtdictleaflistr2r2r3r s zCompoundModel._make_leaflistcCs4|dkr t||jvr |j|Std|ddS)z If someone accesses an attribute not already defined, map the parameters, and then see if the requested attribute is one of the parameters __setstate__z Attribute "z " not foundN)rrSryrr`r2r2r3 __getattr__ s   zCompoundModel.__getattr__c Csf|jdur||j}|j}t|tr$|jr8td|jdurdt|jtr\| |j}qh|j}nd}|j durt|j tr| |j }q|j d}n t |d}|j dkrtd|dkrt ||}|dkrt ||}||kr|}n8|D]*}||\}}} ||kr| |kr|Sqt dt t|t jr@||St|trZ|| |StddS)Nz1Steps in slices not supported for compound modelsrrzSlice endpoint cannot be 0z$No appropriate subtree matches slicez2index must be integer, slice, or model name string)rsrrrLr4steprr8r_str_index_to_intr9rrrrr{rr) rrpr#r"r8r9r}nodeZleftindZrightindr2r2r3 __getitem__ sF             zCompoundModel.__getitem__cCsrg}t|jD]"\}}t|dd|kr||qt|dkrNtd|dt|dkrjtd|||dS)Nr`rzNo component with name 'z' foundrz:Multiple components found using '{}' as name at indices {})rrsrrrrr)rZ str_indexfoundZnleafleafr2r2r3r( s   zCompoundModel._str_index_to_intcCs|jS)z! The number of inputs of a model.Z _n_inputsrr2r2r3r) szCompoundModel.n_inputscCs ||_dSr,r-r>r2r2r3r. scCs|jS)z" The number of outputs of a model.Z _n_outputsrr2r2r3r2 szCompoundModel.n_outputscCs ||_dSr,r.r>r2r2r3r7 scCs|jSr,Z_eqconsrr2r2r3r; szCompoundModel.eqconscCs ||_dSr,r/r>r2r2r3r? scCs|jSr,r/rr2r2r3rC szCompoundModel.ineqconscCs ||_dSr,r/r>r2r2r3rG sFcCsxg}t|jtr"||j|}n ||jg}t|jtrL||j|}n ||jg}|rj||jn |||S)z/ Postorder traversal of the CompoundModel tree.)rLr-r&traverse_postorderr.rr)rZinclude_operatorresr2r2r3r0K s     z CompoundModel.traverse_postordercCs"d}t}|durdd}|D]}t|tsJ|||||d7}q"|}|}|jtvrt|j}t|trt|jtrt|jj|krd|d}t|j trt|j j|krd|d}|d ||j|fq"d|d }d|d }|d |jd||fq"d |S) NrcSs d|dS)N[]r2)rlr2r2r3r4a r5z2CompoundModel._format_expression..rrr z((z),z))r ) rr0rLr&rrrOPERATOR_PRECEDENCEr-r.r)rZ format_leafZleaf_idxZoperandsr)r.r-Z oper_orderr2r2r3_format_expression\ s6           z CompoundModel._format_expressioncCs,|jdur|dddt|jDS)Nz css|]\}}d||VqdS)z [{0}]: {1!r}N)r)rNrmr2r2r3r sz3CompoundModel._format_components..)rRrrrrsrr2r2r3_format_components~ s   z CompoundModel._format_componentscs6|}|}d|fddt|fg}tj|dS)NZ ExpressionZ Componentsr)r)r7r9rrUr)rZ expressionZ componentsrrfr2r3r s zCompoundModel.__str__cCs ||_|Sr,rr%r2r2r3r szCompoundModel.renamecCsdS)NFr2rr2r2r3isleaf szCompoundModel.isleafcCs<|jdkr|jj|jjBS|jdkr4|jj|jj@StSdS)NrHrJ)rr.rr-rrr2r2r3r s   zCompoundModel.inversecCs8|jdur2|jdur|tdd|jD|_|jS)z0 Set the fittable attribute on a compound model.Ncss|] }|jVqdSr,)r rNr8r2r2r3r r5z)CompoundModel.fittable..)rrsrrrr2r2r3r  s   zCompoundModel.fittabler>r@rBrDrFrHrJcCs|jdurdS|jdur |i|_i}g|_t|jD]b\}}t|ts:|jD]H}t ||}|d|}||j |<||j|<|j |||f||<qRq:i|_ ||_ tdd|D|_|t|j|_dS)a2 Map all the constituent model parameters to the compound object, renaming as necessary by appending a suffix number. This can be an expensive operation, particularly for a complex expression tree. All the corresponding parameter attributes are created that one expects for the Model class. The parameter objects that the attributes point to are the same objects as in the constiutent models. Changes made to parameter values to either are seen by both. Prior to calling this, none of the associated attributes will exist. This method must be called to make the model usable by fitting engines. If oldnames=True, then parameters are named as in the original implementation of compound models. Nrcss|]\}}||fVqdSr,r2rMr2r2r3r r5z0CompoundModel._map_parameters..)r6rsrrRrSrrLrZr^rryrrZ _param_maprT_param_map_inverserr])rZ param_mapZlindexr,rrZnew_param_namer2r2r3r s*        zCompoundModel._map_parametersc Cs|j}d}|jD]j}t||}|j}t|}t|}t|||}i||<|||d<|||d<|||d<||7}qtj|tj d|_ dSrrrr2r2r3r s        z CompoundModel._initialize_slicescCst|tr||S||fSr,r,)branchZadictr}r2r2r3_recursive_lookup s zCompoundModel._recursive_lookupc s<i}tjts$fddjDSjdkr|tjtrDj}jD],}tjtrh||||<qJj|f||<qJnjdkrhtjtrj}tjtrj}tjD]\}}|t jjkrtjtr|jj|||<njjj|f||<qtjtrB|jj|t jj||<qjjj|t jjf||<qnЈjdkrt j }fdd|D}t t jj }|D]}||q|D]$}jjj|f|jj|<qnRtjtrj}jjD]0}tjtr&||||<nj|f||<q|S)zf Map the names of the inputs to this ExpressionTree to the inputs to the leaf models. csi|]}||fqSr2r2rdrr2r3rQ r5z,CompoundModel.inputs_map..rHrJr'cs,g|]$}t|tr$tjj|n|qSr2)rLrrWr-rrprrr2r3rr5z,CompoundModel.inputs_map..)rLrrrr-r&rr.rrrWrrrremove) rrZ l_inputs_mapreZ r_inputs_maprZ fixed_indrZinp_indr2rr3r sL            "& $  zCompoundModel.inputs_mapc Cs^|jdur|i}t|jD]8\}}|||}|D]}|j||f}||||<q8q |Sr,)rsrrrir<) rrrrZunits_for_dataZimodelrZunits_for_data_leafZ param_leafrr2r2r3ri%s  z-CompoundModel._parameter_units_for_data_unitscs*|fddD}|r&|SdS)Ncs:i|]2\}\}}|djdur||dj|qSrXrrNr}rZorig_keyrr2r3rQ3s z-CompoundModel.input_units..r)rZinput_units_dictr2rAr3r0s zCompoundModel.input_unitscs*|fddD}|s&dS|S)Ncs:i|]2\}\}}|djdur||dj|qSrX)rr@rAr2r3rQ=s z;CompoundModel.input_units_equivalencies..r)rZinput_units_equivalencies_dictr2rAr3r:s z'CompoundModel.input_units_equivalenciescs|fddDS)Ncs(i|] \}\}}||dj|qSr)rr@rAr2r3rQJs zACompoundModel.input_units_allow_dimensionless..rrr2rAr3rGs z-CompoundModel.input_units_allow_dimensionlesscs|fddDS)Ncs(i|] \}\}}||dj|qSrB)rr@rAr2r3rQPs z4CompoundModel.input_units_strict..rrr2rAr3rMs z CompoundModel.input_units_strictcs|fddDS)Ncs:i|]2\}\}}|djdur||dj|qSrXrr@ outputs_mapr2r3rQVs z.CompoundModel.return_units..)rDrTrr2rCr3rqSs zCompoundModel.return_unitscsi}tjts$fddjDSjdkr|tjtrDj}jD],}tjtrh||||<qJj|f||<qJnVjdkrhtjtrj}tjtrj}tjD]\}}|t jjkrtjtr|jj|||<njjj|f||<qtjtrB|jj|t jj||<qjjj|t jjf||<qnjjdkr~jStjtrj}jjD]2}tjtr||||<nj|f||<q|S)zh Map the names of the outputs to this ExpressionTree to the outputs to the leaf models. csi|]}||fqSr2r2rfrr2r3rQ`r5z-CompoundModel.outputs_map..rHrJr') rLrrrr.r&rDr-rr)rrDZ r_outputs_maprgZ l_outputs_maprr2rr3rDZs@            "&    zCompoundModel.outputs_mapcCs |jduSrTrSrr2r2r3rUsz#CompoundModel.has_user_bounding_boxc s|}|j}|dur.|dur.|dur.td|dkrR|durD|g}|durR|g}|durtj|td}t||ksxJ|dur|dj|jkrtdnt|dj}|durt|}|j |krtd|durt dd |D t j }|\}|dur2t|d dt fd d |D}nd d |j D}tj|}|ddd }|durn||}n2zt|||}WntytdYn0nB|dur|j} dd | D}tj|}|ddd }|||7}|S)ryNrzrr{rr|r}cSs0g|](}t|t|d|ddfqSr~rrr2r2r3rsz(CompoundModel.render..rcsg|]}t|qSr2rrrr2r3rscSs(g|] \}}t||||ddqSr rrr2r2r3rr5r5rcSsg|] }t|qSr2rrr2r2r3rr5)rrrrrrrrrrrrrrr]rrrr2rr3rsd*              zCompoundModel.rendercsfdd|D}|rt|dkr4td|}t|t|krTtd|j|jksl|j|jkrttdt|}|r|}|ddD]}t||}qt ||d|t |j |j |j |jd }|dd}q~|Std dS) a< Construct a new `~astropy.modeling.CompoundModel` instance from an existing CompoundModel, replacing the named submodel with a new model. In order to ensure that inverses and names are kept/reconstructed, it's necessary to rebuild the CompoundModel from the replaced node all the way back to the base. The original CompoundModel is left untouched. Parameters ---------- name : str name of submodel to be replaced model : `~astropy.modeling.Model` replacement model cs g|]}t|ddkr|qS)r`Nrr;rr2r3rsz2CompoundModel.replace_submodel..rzMore than one submodel named z6New and old models must have equal values for n_modelszDNew model must match numbers of inputs and outputs of existing modelNr5rzNo submodels found named )r0rrrrr_get_submodel_pathrrrr&rr-r.r`)rr`rZ submodelsZ old_modeltreer=r)r2rr3replace_submodels.     zCompoundModel.replace_submodelcCsVt|j||}||_||_|jD]0}t||}t||}|j|_|j|jddq dS)z Provides a work-around to properly set the sub models and respective parameters's units/values when using ``without_units_for_data`` or ``without_units_for_data`` methods. TrhN) r&rr-r.r^rrrkr)rr-r.rr`Zmodel_parameterrnr2r2r3#_set_sub_models_and_parameter_units1s   z1CompoundModel._set_sub_models_and_parameter_unitsc s||jdvrf|}fdd|jD}|jjfi|jjfi|jdkrfdd|jjD}fdd|jjD}n0fdd|jjD}fdd|jjD}|||||jjfi|}t |t r|d |d <|d |d <|d }|jjfi|}t |t rP|d |d <|d |d <|d }| |||||fSt jfiSdS)a See `~astropy.modeling.Model.without_units_for_data` for overview of this method. Notes ----- This modifies the behavior of the base method to account for the case where the sub-models of a compound model have different output units. This is only valid for compound * and / compound models as in that case it is reasonable to mix the output units. It does this by modifying the output units of each sub model by using the output units of the other sub model so that we can apply the original function and get the desired result. Additional data has to be output in the mixed output unit case so that the units can be properly rebuilt by `~astropy.modeling.CompoundModel.with_units_from_data`. Outside the mixed output units, this method is identical to the base method. rBrDcsi|]}||qSr2r2rdrr2r3rQ[r5z8CompoundModel.without_units_for_data..rBcs*i|]"}|dur|||qSr,r2rfr0 right_unitsr2r3rQascs*i|]"}|dur|||qSr,r2rfr0 left_unitsr2r3rQcscs*i|]"}|dur|||qSr,r2rfrJr2r3rQfscs.i|]&}|dur|d||qS)Nrr2rfrLr2r3rQhsr _left_kwargsr _right_kwargsrN) rrrr-rrr.rupdaterorLr]rHrU)rr0rr left_kwargs right_kwargsr-r.rf)r0rMrKr3roCsB              z$CompoundModel.without_units_for_datac sp|jdvrZ|d}|d}|jjfi|}|jjfi|}|}||||Stjfi|SdS)a See `~astropy.modeling.Model.with_units_from_data` for overview of this method. Notes ----- This modifies the behavior of the base method to account for the case where the sub-models of a compound model have different output units. This is only valid for compound * and / compound models as in that case it is reasonable to mix the output units. In order to do this it requires some additional information output by `~astropy.modeling.CompoundModel.without_units_for_data` passed as keyword arguments under the keywords ``_left_kwargs`` and ``_right_kwargs``. Outside the mixed output units, this method is identical to the base method. rIrNrON)rrr-rtr.rrHrU)rr0rQrRr-r.rrfr2r3rts    z"CompoundModel.with_units_from_data)N)F)N)NN)Ar7r8r9r:rhrrrrrrrrrrrrrr+rr^rr&r*r(rrrrrr0r7r9rrr:rr r6r=r?rArCrErGrIrrrr>rrirrrrrqrDrUrrGrHrortrr2r2rfr3r&L s x   #    @ -           "    - 2      - p0 =r&c Cspt|dd|krgSzdgt|j|WSttfy>Yn0zdgt|j|WSttfyjYn0dS)zpFind the route down a CompoundModel's tree to the model with the specified name (whether it's a leaf or not)r`Nr-r.)rrEr-rrr.)rr`r2r2r3rEsrEcs:t|tr0t|tr0tfddt||DS||S)zP Perform binary operation. Operands may be matching tuples of operands. csg|]}|d|dqSrr2r binoperatorr2r3rsz$binary_operation..)rLr]r)rTr-r.r2rSr3rs  rcCs8t|tr0||jt|j|t|j|ndSdS)z7 Recursive function to collect operators used. N)rLr&rrget_opsr-r.)rFZopsetr2r2r3rUs    rUcCsdt|ds||nJt|}t|j|d||t|j|d||t|d}|||f||<dS)a Traverse a tree noting each node by a key that indicates all the left/right choices necessary to reach that node. Each key will reference a tuple that contains: - reference to the compound model for that node. - left most index contained within that subtree (relative to all indices for the whole tree) - right most index contained within that subtree r:r4rrN)r\rrr!r-r.)rFZnodepathr"r#Z leftmostindZ rightmostindr2r2r3r!s   r!))r')rH)rJ)r>r@rI)rFcCs\td||}|durX|dur2tdd|D}t|||}|j||}|||_|S)a4 This function creates a compound model with one or more of the input values of the input model assigned fixed values (scalar or array). Parameters ---------- modelinstance : `~astropy.modeling.Model` instance This is the model that one or more of the model input values will be fixed to some constant value. values : dict A dictionary where the key identifies which input to fix and its value is the value to fix it at. The key may either be the name of the input or a number reflecting its order in the inputs. Examples -------- >>> from astropy.modeling.models import Gaussian2D >>> g = Gaussian2D(1, 2, 3, 4, 5) >>> gv = fix_inputs(g, {0: 2.5}) Results in a 1D function equivalent to Gaussian2D(1, 2, 3, 4, 5)(x=2.5, y) r'NcSsg|] }|dfqS)Tr2rr2r2r3rr5zfix_inputs..)r&r]rrr selector_argsZget_fixed_valuesr) modelinstancerbounding_boxesrWrrZ _selectorr2r2r3r's  r'CcCstj|||d|_dS)a Set a validated bounding box to a model instance. Parameters ---------- modelinstance : `~astropy.modeling.Model` instance This is the model that the validated bounding box will be set on. bounding_box : tuple A bounding box tuple, see :ref:`astropy:bounding-boxes` for details order : str, optional The ordering of the bounding box tuple, can be either ``'C'`` or ``'F'``. orderN)rrr)rXrr\r2r2r3r*sr*cCstj|||||d|_dS)a Add a validated compound bounding box to a model instance. Parameters ---------- modelinstance : `~astropy.modeling.Model` instance This is the model that the validated compound bounding box will be set on. bounding_boxes : dict A dictionary of bounding box tuples, see :ref:`astropy:bounding-boxes` for details. selector_args : list List of selector argument tuples to define selection for compound bounding box, see :ref:`astropy:bounding-boxes` for details. create_selector : callable, optional An optional callable with interface (selector_value, model) which can generate a bounding box based on a selector value and model if there is no bounding box in the compound bounding box listed under that selector value. Default is ``None``, meaning new bounding box entries will not be automatically generated. order : str, optional The ordering of the bounding box tuple, can be either ``'C'`` or ``'F'``. r[N)rrr)rXrYrWZcreate_selectorr\r2r2r3r+s r+rcGsLt|dkr(t|dr(t|d|dS|s:tjt|dStdtdS)aD Create a model from a user defined function. The inputs and parameters of the model will be inferred from the arguments of the function. This can be used either as a function or as a decorator. See below for examples of both usages. The model is separable only if there is a single input. .. note:: All model parameters have to be defined as keyword arguments with default values in the model function. Use `None` as a default argument value if you do not want to have a default value for that parameter. The standard settable model properties can be configured by default using keyword arguments matching the name of the property; however, these values are not set as model "parameters". Moreover, users cannot use keyword arguments matching non-settable model properties, with the exception of ``n_outputs`` which should be set to the number of outputs of your function. Parameters ---------- func : function Function which defines the model. It should take N positional arguments where ``N`` is dimensions of the model (the number of independent variable in the model), and any number of keyword arguments (the parameters). It must return the value of the model (typically as an array, but can also be a scalar for scalar inputs). This corresponds to the `~astropy.modeling.Model.evaluate` method. fit_deriv : function, optional Function which defines the Jacobian derivative of the model. I.e., the derivative with respect to the *parameters* of the model. It should have the same argument signature as ``func``, but should return a sequence where each element of the sequence is the derivative with respect to the corresponding argument. This corresponds to the :meth:`~astropy.modeling.FittableModel.fit_deriv` method. Examples -------- Define a sinusoidal model function as a custom 1D model:: >>> from astropy.modeling.models import custom_model >>> import numpy as np >>> def sine_model(x, amplitude=1., frequency=1.): ... return amplitude * np.sin(2 * np.pi * frequency * x) >>> def sine_deriv(x, amplitude=1., frequency=1.): ... return 2 * np.pi * amplitude * np.cos(2 * np.pi * frequency * x) >>> SineModel = custom_model(sine_model, fit_deriv=sine_deriv) Create an instance of the custom model and evaluate it:: >>> model = SineModel() >>> model(0.25) 1.0 This model instance can now be used like a usual astropy model. The next example demonstrates a 2D Moffat function model, and also demonstrates the support for docstrings (this example could also include a derivative, but it has been omitted for simplicity):: >>> @custom_model ... def Moffat2D(x, y, amplitude=1.0, x_0=0.0, y_0=0.0, gamma=1.0, ... alpha=1.0): ... """Two dimensional Moffat function.""" ... rr_gg = ((x - x_0) ** 2 + (y - y_0) ** 2) / gamma ** 2 ... return amplitude * (1 + rr_gg) ** (-alpha) ... >>> print(Moffat2D.__doc__) Two dimensional Moffat function. >>> model = Moffat2D() >>> model(1, 1) # doctest: +FLOAT_CMP 0.3333333333333333 rrr]z{0} takes at most one positional argument (the callable/function to be turned into a model. When used as a decorator it should be passed keyword arguments only (if any).N)rr_custom_model_wrapper functoolspartialrrr7)rrr2r2r3r(;sNr(c st|\}}dgddttD}fddttD}i}i}i}|D]d}|jvrn|j||j<qR|j|vr|j||j<qR|j|vrtd|jd|dqR|j||j<qR||||fS)a Processes the inputs to the `custom_model`'s function into the appropriate categories. Parameters ---------- func : callable Returns ------- inputs : list list of evaluation inputs special_params : dict dictionary of model properties which require special treatment settable_params : dict dictionary of defaults for settable model properties params : dict dictionary of model parameters set by `custom_model`'s function rcSs(g|] \}}t|tr|jdur|qSr,rLrfsetrNrrr2r2r3rs z(_custom_model_inputs..cs0g|](\}}t|tr|jdur|vr|qSr,rarcZspecialr2r3rs z Parameter 'z' cannot be a model property: r)rvarsr"rTr`rr) rrrZsettableZ propertiesspecial_paramssettable_paramsrrr2rdr3_custom_model_inputss     rhc Cst|std|dur(t|s(td|j}t|\}}}}|dur`t|jt|kr`tddd|D}td}|r|j}nd}t||j t|| d d t ||d } |durt || d <| |t |tf| } t|d krd nd| _| S)a7 Internal implementation `custom_model`. When `custom_model` is called as a function its arguments are passed to this function, and the result of this function is returned. When `custom_model` is used as a decorator a partial evaluation of this function is returned by `custom_model`. zDfunc is not callable; it must be a function or other callable objectNzFfit_deriv not callable; it must be a function or other callable objectzDderivative function should accept same number of parameters as func.cSsi|]\}}|t||dqS)r)r)rNrrr2r2r3rQsz)_custom_model_wrapper..rrrr)r8r:rrrrrTF)rr)r7rhr __defaults__rTrrr:rrrPr{r#r`) rrZ model_namerrfrgrrrrbrcr2r2r3r^sD     r^c s|j}|du|du@|du@r&td|jdkrL|dur>|g}|durL|g}|durp|}|j|jkrptd|durt|}t||jkrtd|dur|dj|jkrtdnt |dj}|durtdd |D t j }\}|dur.t |d dtfd d |D}nd d |j D}tj|}|ddd }|durj||}n2zt|||}WntytdYn0n>|dur|j}dd |D}tj|}|||ddd 7}|S)a@ Evaluates a model on an input array. Evaluation is limited to a bounding box if the `Model.bounding_box` attribute is set. Parameters ---------- model : `Model` Model to be evaluated. arr : `numpy.ndarray`, optional Array on which the model is evaluated. coords : array-like, optional Coordinate arrays mapping to ``arr``, such that ``arr[coords] == arr``. Returns ------- array : `numpy.ndarray` The model evaluated on the input ``arr`` or a new array from ``coords``. If ``arr`` and ``coords`` are both `None`, the returned array is limited to the `Model.bounding_box` limits. If `Model.bounding_box` is `None`, ``arr`` or ``coords`` must be passed. Examples -------- :ref:`astropy:bounding-boxes` Nz6If no bounding_box is set,coords or arr must be input.rzDnumber of array dimensions inconsistent with number of model inputs.z?coordinate length inconsistent with the number of model inputs.rz3coordinate shape inconsistent with the array shape.cSs0g|](}t|t|d|ddfqSr~rrr2r2r3r:sz render_model..rcsg|]}t|qSr2rrrr2r3r?scSs(g|] \}}t||||ddqSr rrr2r2r3rBr5r5zkThe `bounding_box` is larger than the input arr in one or more dimensions. Set `model.bounding_box = None`.cSsg|] }t|qSr2rrr2r2r3rTr5)rrrrrrrrrrrrrr]rr) rZarrrrrrrrrr2rr3 render_models\             rjcCs|`|S)a This is a convenience function intended to disable automatic generation of the inverse in compound models by disabling one of the constituent model's inverse. This is to handle cases where user provided inverse functions are not compatible within an expression. Example: compound_model.inverse = hide_inverse(m1) + m2 + m3 This will insure that the defined inverse itself won't attempt to build its own inverse, which would otherwise fail in this example (e.g., m = m1 + m2 + m3 happens to raises an exception for this reason.) Note that this permanently disables it. To prevent that either copy the model or restore the inverse later. )rrLr2r2r3 hide_inverse\srk)NN)rZ)NrZ)N)NN)\r:rrrrr_ZnumbersrrN collectionsrrrrZnumpyrZ astropy.utilsrrZ astropy.tablerZ astropy.unitsr r r Zastropy.units.utilsr r rrrrZastropy.utils.codegenrZastropy.nddata.utilsrrZutilsrrrrrrrrrrrrr r!__all__r6rr)ABCMetar;r"r#r$r%rrrrrr r r ZBINARY_OPERATORSrrr&rErrUr!Z_ORDER_OF_OPERATORSr6rropsrr'r*r+r(rhr^rjrkr2r2r2r3s        8      ^   #  Z, : a