[c@`s_dZddlmZmZmZmZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl mZmZddlmZmZddlZddlmZmZmZddlmZdd lmZmZdd lmZdd l m!Z!m"Z"m#Z#dd l$m%Z%dd lm&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,ddl-m.Z.ddl/m0Z0ddl1m2Z2ddlm3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9ddl:m;Z;m<Z<ddl=m>Z>m?Z?m@Z@ddddddgZAdeBfdYZCdZDde)e(ejEfdYZFejGeFd eHfd!YZId"eIfd#YZJd$eJfd%YZKd&eJfd'YZLd(ZMd)ZNd*ZOieMe jPd+6eMe jQd,6eMe jRd-6eMe jSd.6eMe jTd/6eNd06eOd16ZUd0fd1fd+d,fd-d.fd/fgZViZWx5eXeVD]'\ZYZZxeZD]Z[eYeWe[ud 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. i(tabsolute_importtunicode_literalstdivisiontprint_functionN(t defaultdictt OrderedDict(tchaintislicei(tindenttisinstancemethodtmetadata(tsix(tcopyregtzip(tTable(tQuantityt UnitsErrortdimensionless_unscaled(tquantity_asanyarray(t sharedmethodtfind_current_moduletInheritDocstringstOrderedDescriptorContainertcheck_broadcasttIncompatibleShapeErrort isiterable(tmake_function_with_signature(tsuppress(t signaturei(tcombine_labelstmake_binary_operator_evaltExpressionTreet AliasDicttget_inputs_and_paramst _BoundingBoxt_combine_equivalency_dict(t add_arrayt extract_array(t ParametertInputParameterErrortparam_repr_onelineuModelu FittableModeluFittable1DModeluFittable2DModelu custom_modeluModelDefinitionErrortModelDefinitionErrorcB`seZdZRS(u%Used for incorrect models definitions(t__name__t __module__t__doc__(((s4lib/python2.7/site-packages/astropy/modeling/core.pyR)8sc `sfdS(u Returns a function that evaluates a given Python arithmetic operator between two models. The operator should be given as a string, like ``'+'`` or ``'**'``. Any additional keyword arguments passed in are passed to `_CompoundModelMeta._from_operator`. c`stj||S(N(t_CompoundModelMetat_from_operator(tlefttright(tkwargstoper(s4lib/python2.7/site-packages/astropy/modeling/core.pytKs ((R2R1((R1R2s4lib/python2.7/site-packages/astropy/modeling/core.pyt _model_oper<st _ModelMetacB`s4eZdZeZeZeZdZ dZ dZ dZ dZ edZedZedZed Zd Zd Zd Zd ZdZedZedZedZedZedZedZedZe j!r&edZ"ngdZ#RS(u Metaclass for Model. Currently just handles auto-generating the param_names list based on Parameter descriptors declared at the class-level of Model subclasses. cC`s;d|kr|j|d>> from astropy.modeling.models import Rotation2D >>> SkyRotation = Rotation2D.rename('SkyRotation') >>> SkyRotation Name: SkyRotation (Rotation2D) Inputs: ('x', 'y') Outputs: ('x', 'y') Fittable parameters: ('angle',) >>> issubclass(SkyRotation, Rotation2D) True >>> r = SkyRotation(90) >>> isinstance(r, Rotation2D) True uasciiiu__main__u __qualname__u{0}.{1}( R tPY2t isinstancet text_typetencodeRR*RVtstrR+R?t __qualname__tformat(RKR:tmodtmodnametnew_cls((s4lib/python2.7/site-packages/astropy/modeling/core.pytrenames   cC`s`|jd}|dks.|jdtkr2dSt|trM|j}n||_|`dS(Nuinversei( tgettNoneRWtobjectRatpropertytfgett_inversetinverse(RKR<Rq((s4lib/python2.7/site-packages/astropy/modeling/core.pyRCs  cC`s |jd}|dks.|jdtkr2dSt|trM|j}nt|sytj ||}Wqt k r}t |j dqXn6t |}t|jdkr|j||}ntjrt|tjr|j}n||_|`dS(u 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. u bounding_boxiNi(RkRlRWRmRaRnRotcallableR"tvalidatet ValueErrorR)targsRRZt parameterst_create_bounding_box_subclassR R`ttypest MethodTypet__func__t _bounding_boxt bounding_box(RKR<R|texctsig((s4lib/python2.7/site-packages/astropy/modeling/core.pyRD s"      c`sfd}g}x{t|jjD]d\}}|dkrIq+n|j|jkrvtdj|jn|j|j|jfq+Wt |d|}t t dj|jt fi|d6S(u For Models that take optional arguments for defining their bounding box, we create a subclass of _BoundingBox 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. c`s|j|S(N(t_model(tselfR1(tfunc(s4lib/python2.7/site-packages/astropy/modeling/core.pyt__call__OsiuThe 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.uselfu_{0}BoundingBoxu__call__(uself( t enumerateRvtvaluestdefaulttemptyR)RfR:tappendRRVRdR"(RKRR~RR1tidxtparam((Rs4lib/python2.7/site-packages/astropy/modeling/core.pyRw8s" c `sd}d|krd|krt|dtrfd}|d}d|}t||ddtfdtjfdg}|||_nd |krtj  rj rt d t j j Dr^d}g}x~jD]]}j |j} j |j} | dk rDt| | d t} n|j|| fqWndj}i}fd } t| ||dd} || | _ndS(NcS`sU|j|_t||jj|_t|drQdj|j|j|_ndS(Nu __qualname__u{0}.{1}(R+tgetattrR*R,R?RfRe(twrapperRK((s4lib/python2.7/site-packages/astropy/modeling/core.pytupdate_wrapperjs  u__call__uinputsc`st|j||S(u+Evaluate this model on the supplied inputs.(R7R(RR[R1(RK(s4lib/python2.7/site-packages/astropy/modeling/core.pyR|suselfumodel_set_axisuwith_bounding_boxu fill_valueu equivalenciesu__init__cs`s|]}|jdk VqdS(N(RRl(t.0RP((s4lib/python2.7/site-packages/astropy/modeling/core.pys stcopyc`st|j||S(N(R7R=(RtparamsR1(RK(s4lib/python2.7/site-packages/astropy/modeling/core.pyR=st varkwargsukwargs(uself(umodel_set_axisN(u equivalenciesN(uself(uself(RaR@RRltFalsetnptnanRRFRGR>tallR t itervaluesRBRtunitRRR=( RKR<RRR[Rutnew_callR1t param_nameRRR=tnew_init((RKs4lib/python2.7/site-packages/astropy/modeling/core.pyREgs>          "   u+u-u*u/u**u|u&cC`stt|jg}|js)|dSd}yd||fd|jfd|jfg}|jr|jd|jfnx@||D]4\}}|d k r|jdj ||qqWdj |SWnt k r|dSXd S( u 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. icS`sg}xb|jdD]P}t|ts2qn%tj|sS|jjdrWPn|j|jqW|rdj |jdj |S|jSdS(Niu_u {0} ({1})u -> ( tmrot issubclasstModelRFRGR*RHRR:Rftjoin(RKR;tbase((s4lib/python2.7/site-packages/astropy/modeling/core.pytformat_inheritancesuNameuInputsuOutputsuFittable parametersu{0}: {1}u N( R7R5RMR_R[R]RBRRlRfRt Exception(RKtkeywordstpartsRtdefault_keywordstkeywordtvalue((s4lib/python2.7/site-packages/astropy/modeling/core.pyRLs"         ($R*R+R,tsetRIRR6RR>R8R=RMRRRYRnR:R\R^R_RjRCRDRwRER4t__add__t__sub__t__mul__t __truediv__t__pow__t__or__t__and__R R`t__div__RL(((s4lib/python2.7/site-packages/astropy/modeling/core.pyR5Os8        /  , / N        RcB`seZdZejZd=Zd>Zd?Zd@Z e Z e Z e ZejZdAZdAZdAZdAZdZe Ze ZdAZdZdZdZdZdZe d Z!e d Z"e d Z#e d Z$e d Z%e dZ&e dZ'e(j)re d Z*ne+dZ,e,j-dZ,e+dZ.e+dZ/e+dZ0e+dZ1e+dZ2e2j-dZ2e+dZ3e+dZ4e+dZ5e+dZ6e+dZ7e+dZ8e8j-dZ8e8j9dZ8e+d Z:e+d!Z;e;j-d"Z;e;j9d#Z;e+d$Z<d%Z=d&Z>e+d'Z?e+d(Z@eAjBd)ZCd*ZDdAdAd+ZEe+d,ZFeFj-d-ZFe+d.ZGeGj-d/ZGd0ZHd1ZId2ZJeKd3ZLeKd4ZMeKd5ZNd6ZOd7ZPd8ZQd9ZRe e d:ZSgiid;ZTgd<ZURS(Bu Base class for all models. This is an abstract class and should not be instantiated directly. This class sets the constraints and other properties for all individual parameters and performs parameter validation. 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 ueqconsuineqconsicO`sstt|j|jdd}|dk r=||_n|jdd|_|j||j||dS(Numetauname( R7RR=tpopRltmetat_namet_initialize_constraintst_initialize_parameters(RRuR1R((s4lib/python2.7/site-packages/astropy/modeling/core.pyR=s   cC`s |jS(N(t _format_repr(R((s4lib/python2.7/site-packages/astropy/modeling/core.pyRMscC`s |jS(N(t _format_str(R((s4lib/python2.7/site-packages/astropy/modeling/core.pyt__str__scC`s|jS(N(t _n_models(R((s4lib/python2.7/site-packages/astropy/modeling/core.pyt__len__scO`s,|j||\}}tg|D]}t|t^q"}|jdtdt}|jdt}|jdtj }d} |r-y |j } Wnt k rd} nX|j dkr| dk r| ddd} n| dkr |jt||} qE|j dkr%| g} ntj|djd tj} xst|D]e\} } tj| jd tj}tj| | | dk| | | dkd |}d| |`_ for more details. (t_model_set_axis(R((s4lib/python2.7/site-packages/astropy/modeling/core.pytmodel_set_axisUs cC`s |jS(u 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. (R(R((s4lib/python2.7/site-packages/astropy/modeling/core.pyt param_setscs cC`sT|js|jS|j|jddj}|j|jddj}|j||!S(u A flattened array of all parameter values in all parameter sets. Fittable parameters maintain this list and fitters modify it. iuslicei(RBt _parameterst_param_metricststarttstop(RRR((s4lib/python2.7/site-packages/astropy/modeling/core.pyRvos cC`s|js dS|j|jddj}|j|jddj}y)tj|j}||j||+Wn(tk r}t dj |nXdS(ul Assigning to this attribute updates the parameters array rather than replacing it. NiusliceiuJInput parameter values not compatible with the model parameters array: {0}( RBRRRRtarraytflattenRRtR'Rf(RRRRte((s4lib/python2.7/site-packages/astropy/modeling/core.pyRvs cC`s |jdS(uM A `dict` mapping parameter names to their fixed constraint. ufixed(t _constraints(R((s4lib/python2.7/site-packages/astropy/modeling/core.pytfixedscC`s |jdS(uL A `dict` mapping parameter names to their tied constraint. utied(R(R((s4lib/python2.7/site-packages/astropy/modeling/core.pyttiedscC`s |jdS(u A `dict` mapping parameter names to their upper and lower bounds as ``(min, max)`` tuples or ``[min, max]`` lists. ubounds(R(R((s4lib/python2.7/site-packages/astropy/modeling/core.pytboundsscC`s |jdS(u'List of parameter equality constraints.ueqcons(R(R((s4lib/python2.7/site-packages/astropy/modeling/core.pyteqconsscC`s |jdS(u)List of parameter inequality constraints.uineqcons(R(R((s4lib/python2.7/site-packages/astropy/modeling/core.pytineqconsscC`s?|jdk r|jS|jdk r/|jStddS(u 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. uHAn analytical inverse transform has not been implemented for this model.N(t _user_inverseRlRpR(R((s4lib/python2.7/site-packages/astropy/modeling/core.pyRqs  cC`s7t|ttdfs*tdn||_dS(NuThe ``inverse`` attribute may be assigned a `Model` instance or `None` (where `None` explicitly forces the model to have no inverse.(RaRRVRlRtR(RR((s4lib/python2.7/site-packages/astropy/modeling/core.pyRqs cC`s |`dS(u~ Resets the model's inverse to its default (if one exists, otherwise the model will have no inverse). N(R(R((s4lib/python2.7/site-packages/astropy/modeling/core.pyRqscC`s |jdk S(u 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(RRl(R((s4lib/python2.7/site-packages/astropy/modeling/core.pythas_user_inversescC`s|jdk r4|jtkr-tdn|jS|jdkrRtdnct|jtrk|jSt|jtjr|jS|jdd|}|j|d|SdS(u A `tuple` of length `n_inputs` defining the bounding box limits, or `None` 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:`bounding-boxes` The limits are ordered according to the `numpy` 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): File "", line 1, in File "astropy\modeling\core.py", line 980, in bounding_box "No bounding box is defined for this model (note: the " 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). uNo 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).u*No bounding box is defined for this model.RN(( t_user_bounding_boxRltNotImplementedRR{RaR"RxRy(RR|((s4lib/python2.7/site-packages/astropy/modeling/core.pyR|s?   cC`s|dkrd}t}n6t|jtrKt|jtrK|j}nt}|dk ry|j||}Wqtk r}t|j dqXn||_ dS(u2 Assigns the bounding box limits. iN( RlRRaR{RVRR"RsRtRuR(RR|RKR}((s4lib/python2.7/site-packages/astropy/modeling/core.pyR|Rs    cC`s d|_dS(N(RlR(R((s4lib/python2.7/site-packages/astropy/modeling/core.pyR|kscC`s |jdk S(u 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``. N(RRl(R((s4lib/python2.7/site-packages/astropy/modeling/core.pythas_user_bounding_boxosc  `s|j}fd|jD}fd|jD}|j||}xf|jD]X\}}t||}|jdk r]|jj |j |_ |j ddt q]q]W|S(u 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. c`s9i|]/}|dk rt|dt|qS(uunitN(RlRR(RR(R1(s4lib/python2.7/site-packages/astropy/modeling/core.pys s c`s9i|]/}|dk rt|dt|qS(uunitN(RlRR(RR(R1(s4lib/python2.7/site-packages/astropy/modeling/core.pys s tforceN( RR[R]t_parameter_units_for_data_unitstitemsRRRltquantityttoRt _set_unitR( RR1tmodelt inputs_unitt outputs_unittparameter_unitsR:Rt parameter((R1s4lib/python2.7/site-packages/astropy/modeling/core.pytwithout_units_for_data{s     c  `s|j}fd|jD}fd|jD}|j||}x<|jD].\}}t||}|j|dtq]W|S(u 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. c`s9i|]/}|dk rt|dt|qS(uunitN(RlRR(RR(R1(s4lib/python2.7/site-packages/astropy/modeling/core.pys s c`s9i|]/}|dk rt|dt|qS(uunitN(RlRR(RR(R1(s4lib/python2.7/site-packages/astropy/modeling/core.pys s R(RR[R]RRRRR( RR1RRRRR:RR((R1s4lib/python2.7/site-packages/astropy/modeling/core.pytwith_units_from_datas     cC`s8x1|jD]"}t||jdk r tSq WtSdS(N(RBRRRlRR(RR((s4lib/python2.7/site-packages/astropy/modeling/core.pyt _has_unitsscC`s t|dS(Nu_parameter_units_for_data_units(R?(R((s4lib/python2.7/site-packages/astropy/modeling/core.pyt_supports_unit_fittingscO`sdS(u+Evaluate the model on some input variables.N((RRuR1((s4lib/python2.7/site-packages/astropy/modeling/core.pyRscO`sdS(u 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). N((RRuR1((s4lib/python2.7/site-packages/astropy/modeling/core.pytsum_of_implicit_termsscC`sHy |j}Wntk r&d}nX|j}|dkrc|dkrc|dkrctdn|dkr|dk r|g}n|dk r|g}qn|dk r(tj|dt}t||kst |dk r|dj |j kr%tdq%q(tj |dj }n|dk rjtj|dt}|j |krjtdqjn|dk rtj g|D]4}tj|tj|d|ddf^qjtj}|\}}|dk r)t|dd} tj g|D]} t| | |^q} nGg|jD]*\} } t| | | | dd^q3}tj|} | ddd } |dkr|| }qDyt||| |}WqDtk rtd qDXng|dkr!|j }g|D]}t|^q}tj|}n|ddd }|||7}|S( ui 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:`bounding-boxes` u7If no bounding_box is set, coords or out must be input.iRiu!inconsistent shape of the output.u<the array and model must have the same number of dimensions.iNiukThe `bounding_box` is larger than the input out in one or more dimensions. Set `model.bounding_box = None`.(R|RRlR\RtRt asanyarraytfloatRZtAssertionErrorRRtndimRtmeantceiltastypetinttTR@R%tslicetmgridR$(RRtcoordsRRtbbtpdtpostdeltat sub_shapetct sub_coordsRPtdtlimitstim_shapeR((s4lib/python2.7/site-packages/astropy/modeling/core.pytrenders`)    $         M   (:     c`sxt|dr|jSt|jdrp|jjjjddrttfd|jDSndSdS(u 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 overriden since it will return the input units based on the annotations. u _input_unitsu__annotations__ureturnc3`s|]}||fVqdS(N((RR:(t annotations(s4lib/python2.7/site-packages/astropy/modeling/core.pys vsN( R?t _input_unitsRt__annotations__RRRlRSR[(R((Rs4lib/python2.7/site-packages/astropy/modeling/core.pyt input_unitscs  cC`s ||_dS(N(R(RR((s4lib/python2.7/site-packages/astropy/modeling/core.pyR{scC`sFt|dr|jSt|jdr>|jjjddSdSdS(u 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 overriden since it will return the return units based on the annotations. u _return_unitsu__annotations__ureturnN(R?t _return_unitsRRRkRl(R((s4lib/python2.7/site-packages/astropy/modeling/core.pyRs cC`s ||_dS(N(R (RR((s4lib/python2.7/site-packages/astropy/modeling/core.pyRsc O`s|jdd }|jdd }|d kr<|j}nt|}g|jD]}t||^qR}g|D]}tj|dt^qt}t ||j |||j |j d k rt |j ||j} xtt|D]} |j | } |j j| d } | d kr%qnt|| tr|| jj| d| | rt| dkss|jr|| j| d| | || Return a copy of this model with a new name. (RR(RR:t new_model((s4lib/python2.7/site-packages/astropy/modeling/core.pyRjs  cC`sdS(ub Return the number of components in a single model, which is obviously 1. i((R((s4lib/python2.7/site-packages/astropy/modeling/core.pyt n_submodelssc C`s(t|tr:t}dt|}|j||}nt}|j}tt|j |}i}x1|j D]&}|j |}t ||||\}}|dkrqqnt|d tj||j |((s4lib/python2.7/site-packages/astropy/modeling/core.pyRGLs:          c C`s|j}g}g}x|jD] }t||}|rF|j}n |j}||jd} | dk r|j| }n|jt j |t |dkrt j |g}n|r|r|j|ddk r|j|d} n |j } | dk rt|| }qn|j|qWt t|dksM|rst jt |dt} || (| St j |S(u 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. ubroadcast_shapeiuraw_unitRN(RRBRt _raw_valueRRkRltreshapeRRRRZRRRRRRm( RRRRSRtshapesR:RRR]Rtpsets((s4lib/python2.7/site-packages/astropy/modeling/core.pyRs4       c`sg|D]}t|^q}|jfdjDjdk rj|jdjjnxU|jD]G\}}||kr|||krqwn|jdj||qwWtdkr|jdjtndjj j dj |S( u 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. c3`s0|]&}dj|tt|VqdS(u{0}={1}N(RfR(R(RR:(R(s4lib/python2.7/site-packages/astropy/modeling/core.pys su name={0!r}u {0}={1!r}iu n_models={0}u <{0}({1})>u, N( ROtextendRBR:RlRRfRRZRDR*R(RRuR1tdefaultsRRRJR((Rs4lib/python2.7/site-packages/astropy/modeling/core.pyRs  c C`sod|jjfd|jfd|jfd|jfdt|fg}g||D]*\}}|d k rSdj||^qS}|jdt|dkrg|j D]}t ||j g^q}n(g|j D]}t ||j ^q}|rbt |d |j }x*|j D]}t ||j ||_ qW|jtt|d d nd j|S(u 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. uModeluNameuInputsuOutputsuModel set sizeu{0}: {1}u Parameters:itnamestwidthiu N(RDR*R:R[R]RZRlRfRRBRRRRRRdR( RRRRRRR:tcolumnst param_table((s4lib/python2.7/site-packages/astropy/modeling/core.pyRs(    $ +%"(ueqconsuineqcons(((N(VR*R+R,R&R:R4R@RBR[R]RR#RtfittabletlinearR tMetaDataRRlRpRR{RRR&R(R$R=RMRRRR4RRRRRRRR R`RRnR:tsetterR\R^RRRvRRRRRRqtdeleterRR|RRRRRtabctabstractmethodRRRRRRRRRRjR3R?RRRHRGRRR(((s4lib/python2.7/site-packages/astropy/modeling/core.pyRsz       [               Y + +  q l    1  S ECt FittableModelcB`s&eZdZeZdZeZeZ RS(u] Base class for models that can be fitted using the built-in fitting algorithms. N( R*R+R,RRmRlt fit_derivRt col_fit_derivRl(((s4lib/python2.7/site-packages/astropy/modeling/core.pyRss  tFittable1DModelcB`seZdZdZdZRS(u 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`. uxuy(ux(uy(R*R+R,R[R](((s4lib/python2.7/site-packages/astropy/modeling/core.pyRv0stFittable2DModelcB`seZdZdZdZRS(u 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`. uxuyuz(uxuy(uz(R*R+R,R[R](((s4lib/python2.7/site-packages/astropy/modeling/core.pyRw<sc`sfd}|S(Nc`s)t|d|d|d|dfS(Niii(R(tftg(R2(s4lib/python2.7/site-packages/astropy/modeling/core.pytopOs((R2Rz((R2s4lib/python2.7/site-packages/astropy/modeling/core.pyt_make_arithmetic_operatorHsc`s!fdddfS(Nc`sdd|||S(Ni((R[R(RxRy(s4lib/python2.7/site-packages/astropy/modeling/core.pyR3\sii((RxRy((RxRys4lib/python2.7/site-packages/astropy/modeling/core.pyt_composition_operatorUsc`s1fdddddfS(Nc`s2d|d |d|d|S(Nii((R[R(RxRy(s4lib/python2.7/site-packages/astropy/modeling/core.pyR3gsii((RxRy((RxRys4lib/python2.7/site-packages/astropy/modeling/core.pyt_join_operator`su+u-u*u/u**u|u&R-cB`s%eZdZdZdZdZdZdZdZ dZ dZ dZ dZ dZdZdZdZedZedZedZd Zeid Zed Zed Zd ZdZdZdZdZdZ dZ!e"dZ#RS(icC`sO|j|}t|ttjfr5|j|S|j|j|jSdS(N( t_normalize_indexRaR RRBt_get_submodelst _get_sliceRR(RKtindex((s4lib/python2.7/site-packages/astropy/modeling/core.pyt __getitem__scC`sE|jdk r5||jkr5|jt||St|dS(N(t_treeRlRBt_init_param_descriptorsRtAttributeError(RKtattr((s4lib/python2.7/site-packages/astropy/modeling/core.pyt __getattr__s  cC`sc|jdkr|jS|j}|j}d|fddt|fg}|jd|S(Nu Expressionu Componentsu R(RRlRLt_format_expressiont_format_componentsR(RKt expressiont componentsR((s4lib/python2.7/site-packages/astropy/modeling/core.pyRMs    cC`sytt|j}Wn<tk rWtttt|t|j}nX|j dk rx|j D]}|j |qqW|j n|S(ut Returns a list of attributes defined on a compound model, including all of its parameters. N(R7R-t__dir__RRURtdirRVRTRRlRBRtsort(RKtbasedirR:((s4lib/python2.7/site-packages/astropy/modeling/core.pyRs / cC`sMtt|j}t|trItt|ddd=WdQXn|S(Niiu _evaluate(R7R-RYRaR@RtKeyError(RKtrv((s4lib/python2.7/site-packages/astropy/modeling/core.pyRYs  cC`s|jdkri}g}xt|jD]\}}t|j}||kr|jdj||||dkr||}dj|||||s(t _fittableRlRR(RK((s4lib/python2.7/site-packages/astropy/modeling/core.pyRls"cG`s|jdkr@|jjtd|jd}t||_n||j }t||j}|j||}|j dkr|dS|SdS(Ntgetterii( t _evaluateRlRRtBINARY_OPERATORSt_model_evaluate_gettert staticmethodR\titerR^(RKRuRR[RR((s4lib/python2.7/site-packages/astropy/modeling/core.pyR s cC`sg}x||fD]u}t|ttfrJ|jtj|jqt|tru|jt|jq|jt|qWt|d|dd|d}t dj tj }tj d7_ t d} | r| j } nd} |j|||\} } |dkr3|jo-|j} nt} |joH|j}|}|ji|d 6td 6| d 6| d6| d6|d6t | d6||tf|}t|trt|tr|}|j||||_|j|jkr |j|_n td|S|S(u Given a Python operator (represented by a string, such as ``'+'`` or ``'*'``, and two model classes or instances, return a new compound model that evaluates the given operator on the outputs of the left and right input models. If either of the input models are a model *class* (i.e. a subclass of `~astropy.modeling.Model`) then the returned model is a new subclass of `~astropy.modeling.Model` that may be instantiated with any parameter values. If both input models are *instances* of a model, a new class is still created, but this method returns an *instance* of that class, taking the parameter values from the parameters of the input model instances. If given, the ``additional_members`` `dict` may provide additional class members that should be added to the generated `~astropy.modeling.Model` subclass. Some members that are generated by this method should not be provided by ``additional_members``. These include ``_tree``, ``inputs``, ``outputs``, ``linear``, ``standard_broadcasting``, and ``__module__`. This is currently for internal use only. R/iR0iuCompoundModel{0}iu__main__u|u+u-u_treeu _is_dynamicuinputsuoutputsulinearustandard_broadcastingu __module__u3Model sets must have the same number of components.(u|u+u-(RaR-t_CompoundModelRRR1RRRRdRft_nextidRR*t_check_inputs_and_outputsRmRR#tupdateRt_make_user_inverseRRRt(R9toperatorR/R0tadditional_memberstchildrentchildttreeR:RgRhR[R]RmR#R<Ritinstance((s4lib/python2.7/site-packages/astropy/modeling/core.pyR. sL        c C`s!|dkrl|j}|j}|j|jkrtdj|j|j|j|j|j|jqn|dkrt|j|j}t|j|j}nr|j}|j}|j|jks|j|jkrtdj||j|j|j|j|j|jn||fS(Nu|uUnsupported 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.u&uUnsupported operands for {0}: {1} (n_inputs={2}, n_outputs={3}) and {4} (n_inputs={5}, n_outputs={6}); models must have the same n_inputs and the same n_outputs for this operator(R[R]R^R\R)RfR:R(R9RR/R0R[R]((s4lib/python2.7/site-packages/astropy/modeling/core.pyR s(      cC`sm|dko|jp|js"dSy|j}|j}Wntk rLdSX|dkra||@S||BSdS(u Generates an inverse `Model` for this `_CompoundModel` when either model in the operation has a *custom inverse* that was manually assigned by the user. If either model has a custom inverse, and in particular if another `_CompoundModel` has a custom inverse, then none of that model's sub-models should be considered at all when computing the inverse. So in that case we just compute the inverse ahead of time and set it as the new compound model's custom inverse. Note, this use case only applies when combining model instances, since model classes don't currently have a notion of a "custom inverse" (though it could probably be supported by overriding the class's inverse property). TODO: Consider fixing things so the aforementioned class-based case works as well. However, for the present purposes this is good enough. u&u|N(u&u|(RRlRqR(R9RR/R0tleft_invt right_inv((s4lib/python2.7/site-packages/astropy/modeling/core.pyR s     cC`sQ|jdk r|jSg|jjD]}|jr&|j^q&}||_|S(N(t _submodelsRlRttraverse_postordertisleafR(RKRt submodels((s4lib/python2.7/site-packages/astropy/modeling/core.pyR s  c `sx|jD]}|j|\}}||}t||dt|trZj}n j}tfdtj D}j d|d|dj |}t |||q WdS(uy This routine sets up the names for all the parameters on a compound model, including figuring out unique names for those parameters and also mapping them back to their associated parameters of the underlying submodels. Setting this all up is costly, and only necessary for compound models that a user will directly interact with. For example when building an expression like:: >>> M = (Model1 + Model2) * Model3 # doctest: +SKIP the user will generally never interact directly with the temporary result of the subexpression ``(Model1 + Model2)``. So there's no need to setup all the parameters for that temporary throwaway. Only once the full expression is built and the user initializes or introspects ``M`` is it necessary to determine its full parameterization. c3`s$|]}|t|fVqdS(N(R(RRX(t orig_param(s4lib/python2.7/site-packages/astropy/modeling/core.pys  sR:RRN( RBt _param_mapRRlRaRRRRSR4RRtsetattr(RKRt submodel_idxtsubmodel_paramRRR:t new_param((Rs4lib/python2.7/site-packages/astropy/modeling/core.pyR s    cC`sg}i}|j}xvt|jD]b\}}|jsCq(nxD|jD]9}dj|||}|j|||f||E sN( t _slice_offsetRRRBRfRR@RARRSRt_param_map_inverse(RKRht param_mapt param_suffixRRRR:((s4lib/python2.7/site-packages/astropy/modeling/core.pyR s     cC`s|jjtS(N(Rtformat_expressiontOPERATOR_PRECEDENCE(RK((s4lib/python2.7/site-packages/astropy/modeling/core.pyRG scC`s#djdt|jDS(Nu cs`s'|]\}}dj||VqdS(u [{0}]: {1!r}N(Rf(RRR((s4lib/python2.7/site-packages/astropy/modeling/core.pys M s(RRR(RK((s4lib/python2.7/site-packages/astropy/modeling/core.pyRL s c`sfd}fd}t|tjr:||St|tr|jd krgtdn|jd k r|jnd}|jd k r|jn t j }t|t t j fr||}nt|t t j fr||}nt|tjr||}nt|tjr@||d}n||}|dkrZ|S|dkrutdnt||St|t t j fr|t j krtdj|n||Stdj|d S( u1 Converts an index given to __getitem__ to either an integer, or a slice with integer start and stop values. If the length of the slice is exactly 1 this converts the index to a simple integer lookup. Negative integers are converted to positive integers. c`sGyjj|SWn,tk rBtdjj|nXdS(Nu6Compound model {0} does not have a component named {1}(RRRtt IndexErrorRfR:(R:(RK(s4lib/python2.7/site-packages/astropy/modeling/core.pytget_index_from_name[ s  c`sP|dkrLtj|}|dkrCtdj|qL|}n|S(NiuModel index {0} out of range.(RZRRRf(Rt new_index(RK(s4lib/python2.7/site-packages/astropy/modeling/core.pytcheck_for_negative_indexc s   iu.Step not supported for compound model slicing.iu Empty slice of a compound model.uModel index {0} out of range.uQSubmodels can be indexed either by their integer order or their name (got {0!r}).N(iN(RaR t string_typesRtstepRlRtRRRZRR RRBRRfRC(RKRRRRRtlength((RKs4lib/python2.7/site-packages/astropy/modeling/core.pyR~P s@    '     c`sLi|j|d6tfdtD}|jj|d|d|S(u Return a new model build from a sub-expression of the expression represented by this model. Right now this is highly inefficient, as it creates a new temporary model for each operator that appears in the sub-expression. It would be better if this just built a new expression tree, and the new model instantiated directly from that tree. Once tree -> model instantiation is possible this should be fixed to use that instead. u _slice_offsetc3`s'|]}|t|dfVqdS(RN(R4(RR2(R<(s4lib/python2.7/site-packages/astropy/modeling/core.pys sRR(RRSRRR(RKRRt operators((R<s4lib/python2.7/site-packages/astropy/modeling/core.pyR s c`stjj}j}tt rytjry|dkrdfd}qfd}n<j|dkrfd}nfd}|||fS(Nic`s4tt|}|jt||fS(N(R@RRR(R[Rt param_values(Rtn_params(s4lib/python2.7/site-packages/astropy/modeling/core.pyRx s c`s1tt|}|jt||S(N(R@RRR(R[RR(RR(s4lib/python2.7/site-packages/astropy/modeling/core.pyRx s c`st|t|fS(N(RR(R[R(RR(s4lib/python2.7/site-packages/astropy/modeling/core.pyR3 sc`st|t|S(N(RR(R[R(RR(s4lib/python2.7/site-packages/astropy/modeling/core.pyR3 s(RZRBR\R^RaRR R(RRR\R^Rx((RRRs4lib/python2.7/site-packages/astropy/modeling/core.pyR s     N($R*R+RlRRRRRARRRRRRRRMRRYRnRRBRlRt classmethodR.RRRRRRRR~RRR(((s4lib/python2.7/site-packages/astropy/modeling/core.pyR-s>      k$, 1 6   F RcB`seZdZeZdZdZdZdZ e j d dkrRdZ ne dZedZe d Ze d Zed Ze d Zed ZdZRS(cC`sS|j}|j}d|fddt|fg}tt|jd|S(Nu Expressionu Componentsu R(RRRR7RR(RRRR((s4lib/python2.7/site-packages/astropy/modeling/core.pyR s    cC`s=t|j|}t|dr9|j||j}n|S(Nu__get__(RRDR?t__get__(RRR((s4lib/python2.7/site-packages/astropy/modeling/core.pyR s c`sx|jj|j}ttr:|j}n.|jjtfd|jD}|j||S(Nc3`s|]}|fVqdS(N((RR:(RR(s4lib/python2.7/site-packages/astropy/modeling/core.pys s(RDR~RaRRBRR@R?(RRRRB((RRs4lib/python2.7/site-packages/astropy/modeling/core.pyR s   iiicC`sAtdtk r*tdj|ntt|jSdS(NiuPickling of compound models is not possible using Python versions less than 2.7.3 due to a bug in Python. See http://docs.astropy.org/en/v1.0.4/known_issues.html#pickling-error-on-compound-models for more information (tried to pickle {0!r}).(RRt RuntimeErrorRfR7RRY(R((s4lib/python2.7/site-packages/astropy/modeling/core.pyRY s cC`s |jjS(N(RDR(R((s4lib/python2.7/site-packages/astropy/modeling/core.pyR scC`s t|jS(N(RZR(R((s4lib/python2.7/site-packages/astropy/modeling/core.pyR3 scC`s |jjS(N(RDRB(R((s4lib/python2.7/site-packages/astropy/modeling/core.pyRB scC`s |jjS(N(RDRl(R((s4lib/python2.7/site-packages/astropy/modeling/core.pyRl scG`s|jj|S(N(RDR(RRu((s4lib/python2.7/site-packages/astropy/modeling/core.pyR sc`sjdtfddD}tj|d- su+u-u*u/u**u&cS`stj||S(N(Rtor_(RR((s4lib/python2.7/site-packages/astropy/modeling/core.pyR31 su|ic`s<y|jSWn&tk r7tdj|nXdS(NuAll models in a composite model must have an inverse defined in order for the composite model to have an inverse. {0!r} does not have an inverse.(RqRRf(RR(R(s4lib/python2.7/site-packages/astropy/modeling/core.pyR5 s  R(u+u-u*u/u**(RSRtand_RR(RRtleaf_idxR((RRs4lib/python2.7/site-packages/astropy/modeling/core.pyRq$ s     cC`s |jjS(N(RDR(R((s4lib/python2.7/site-packages/astropy/modeling/core.pyRC sc C`sni}xat|jD]P\}}|j||}x/|D]'}|j||f}||||>> 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 u fit_deriviiRtu{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( RkRlRZR Rrt_custom_model_wrappert functoolstpartialRCRfR*(RuR1Rt((s4lib/python2.7/site-packages/astropy/modeling/core.pyt custom_modelQ sE%c C`stj|stdn|dk rItj| rItdn|j}t|\}}|dk rttj|t|krtdn|r|djf}nd}t d|D}t d}|r|j}nd}it |d 6|j d 6t d |Dd 6|d 6t|d6}|dk r`t||d siu__main__u __module__u__doc__cs`s|]}|jVqdS(N(R:(RR((s4lib/python2.7/site-packages/astropy/modeling/core.pys suinputsuoutputsuevaluateu fit_derivN(ux(R RrR)RlR*R!RZtget_function_defaultsR:RSRRdR,R@RRRVRs( RRtt model_nameR[Rt output_namesRgRhR<((s4lib/python2.7/site-packages/astropy/modeling/core.pyR s<     !        cC`s|j}|dk|dk@|dk@r8tdn|jdkrz|dk r_|g}n|dk rz|g}qzn|dk r|j}|j|jkrtdqn|dk rBtj|}t||jkrtdn|dk r)|dj |j kr?tdq?qBtj |dj }n|dk rtjg|D]4}tj |tj |d|ddf^q[j tj}\}}|dk rt|dd}tjg|D]} t| ||^q} nGg|jD]*\} } t| | | | dd^q } tj| } | ddd } |dkrt|| }qyt||| |}Wqtk rtd qXna|dkr|j }g|D]}t|^q} tj| }n|||ddd 7}|S( u0 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:`bounding-boxes` u7If no bounding_box is set, coords or arr must be input.iuDnumber of array dimensions inconsistent with number of model inputs.u?coordinate length inconsistent with the number of model inputs.iu3coordinate shape inconsistent with the array shape.iNiukThe `bounding_box` is larger than the input arr in one or more dimensions. Set `model.bounding_box = None`.(R|RlRtR\RRRRRZRRR R R R R R@R%RRR$(RtarrRRRRRRRRRRPRRRR((s4lib/python2.7/site-packages/astropy/modeling/core.pyt render_model sR           W 1:     c K`sg}x$t|D]\}}|j}|sD|jd|| n_inputs, the combination of all inputs and parameters must broadcast to the same shape, which will be used as the shape of all outputs. In this case some of the inputs had different shapes, so it is ambiguous how to format outputs for this model. Try using inputs that are all the same size and shape.i(i((RRRcR#RRRtRfR[R:RZRFRR^R\RRlRf( RRR[R1t broadcastsRR,t input_shapet max_broadcastRt broadcastt extra_outputs((s4lib/python2.7/site-packages/astropy/modeling/core.pyR)? s@         cC`s|d}t|}x_t|D]Q\}}||}|dk r#|s^|j||s"        44   (   *  O S =^ ;  A  8