B do@s:dZddlmZmZddlmZddlmZddlZ ddl Z ddl m Z ddl mZmZddlmZd d d d d dgZe dGdd d ZGdd d eZGdddeZddZdd ZddZdd ZddZddZddZdd Zd!d"Z d#d$Z!d/d%d&Z"d'd(Z#d0d)d*Z$Gd+d,d,eZ%Gd-d.d.eZ&dS)1z@ This module provides utility functions for the models package. )dequeUserDict)MutableMapping) signatureN) deprecated) isiterablecheck_broadcast)unitsExpressionTree AliasDictrpoly_map_domaincombellipse_extentz4.0c@seZdZdddddgZd"ddZd d Zd d Zed dZe ddZ e ddZ e ddZ ddZ ddZddZd#ddZddZd$d d!ZdS)%r leftrightvalueinputsoutputsNcCs:||_||_||_||_|dk r0||kr0|}||_dS)N)rrrrcopyr)selfrrrrrrc/work/yifan.wang/ringdown/master-ringdown-env/lib/python3.7/site-packages/astropy/modeling/utils.py__init__szExpressionTree.__init__cstfddjDS)Nc3s|]}|t|fVqdS)N)getattr).0slot)rrr *sz.ExpressionTree.__getstate__..)dict __slots__)rr)rr __getstate__'szExpressionTree.__getstate__cCs&x |D]\}}t|||q WdS)N)itemssetattr)rstaterrrrr __setstate__,szExpressionTree.__setstate__cCst|tr||S||fS)N) isinstancer )branchadictkeyrrr_recursive_lookup0s z ExpressionTree._recursive_lookupc sLi}tjts$fddjDSjdkrhjj}x.jD]$}j||\}}||f||<q>Wnjdkr jj}jj}xtjD]v\}}|t jjkr҈j|jj|\}}||f||<qj|jj|t jj\}}||f||<qWn<jj}x2jjD]&}j||\}}||f||<qW|S)zf Map the names of the inputs to this ExpressionTree to the inputs to the leaf models. csi|]}j|f|qSr)r)rinp)rrr =sz-ExpressionTree.inputs_map..|&) r$rstrrr inputs_mapr(r enumeratelen)rr.Z l_inputs_mapr)mZinp2Z r_inputs_mapir)rrr.6s4    zExpressionTree.inputs_mapc sLi}tjts$fddjDSjdkrhjj}x.jD]$}j||\}}||f||<q>Wnjdkr jj}jj}xtjD]v\}}|t jjkr҈j|jj|\}}||f||<qj|jj|t jj\}}||f||<qWn<jj}x2jjD]&}j||\}}||f||<qW|S)zh Map the names of the outputs to this ExpressionTree to the outputs to the leaf models. csi|]}j|f|qSr)r)rout)rrrr*csz.ExpressionTree.outputs_map..r+r,) r$rr-rr outputs_mapr(rr/r0)rr4Z r_outputs_mapr3r1Zout2Z l_outputs_mapr2r)rrr4\s4    zExpressionTree.outputs_mapcCs|jdko|jdkS)N)rr)rrrrisleafszExpressionTree.isleafccsRt|g}xB|rL|}|V|jdk r4||j|jdk r ||jq WdS)N)rpoprappendr)rstacknoderrrtraverse_preorders    z ExpressionTree.traverse_preorderccsNt}|}x>|s|dk rH|dk r2|||j}q |}|V|j}q WdS)N)rr7rr6r)rr8r9rrrtraverse_inorders zExpressionTree.traverse_inorderccst|g}d}x|r|d}|dks8||jks8||jkrh|jdk rP||jq|jdk r||jn,|j|kr|jdk r||jn |V|}qWdS)N)rrrr7r6)rr8lastr9rrrtraverse_postorders    z!ExpressionTree.traverse_postorderrcCsJt}|dkrdd}|dkr"d}d}x|D]}|jr^||||j|f|d7}q2||j}t|dkrvq2|} |} g} xV| | fD]J} | ddkr| | q| \} } || kr|dks| |kr| | | fqWt| dkr| \} } ||| d| ddfq2t| dkr0|| q2|| q2W|dS)a"Evaluate the expression represented by this tree. ``Operators`` should be a dictionary mapping operator names ('tensor', 'product', etc.) to a function that implements that operator for the correct number of operands. If given, ``getter`` is a function evaluated on each *leaf* node's value before applying the operator between them. This could be used, for example, to operate on an attribute of the node values rather than directly on the node values. The ``getter`` is passed both the index of the leaf (a count starting at 0 that is incremented after each leaf is found) and the leaf node itself. The ``start`` and ``stop`` arguments allow evaluating a sub-expression within the expression tree. NcSs|S)Nr)idxrrrrz)ExpressionTree.evaluate..rr<)rr>r5r7rr0r6extend)r operatorsgetterstartstopr8leaf_idxr9operatorrroperandsoperandr?rrrevaluates:      zExpressionTree.evaluatecCsXg}x8|j|jfD](}t|tr0||q||qW|j|j|d|ddS)NrrB)rr)rrr$r r7r __class__r)rchildrenchildrrrrs  zExpressionTree.copyc Csd}t}|dkrdd}x|D]}|jrH|||||d7}q$||j}|}|}|jdk r|jjs||jj|krd|d}|jdk r|jjs||jj|krd|d}|d||j|fq$Wd|S) NrcSs d|dS)N[]r)r2lrrrr@rAz2ExpressionTree.format_expression..rB() ) rr>r5r7rr6rrjoin) rZoperator_precedenceZ format_leafrIrKr9Z oper_orderrrrrrformat_expression s(   z ExpressionTree.format_expression)NNNN)NrN)N)__name__ __module__ __qualname__rrrr# staticmethodr(propertyr.r4r5r:r;r>rMrrYrrrrr s   & &    Rc@sLeZdZdZeZddZddZddZdd Z d d Z d d Z ddZ dS)r a= Creates a `dict` like object that wraps an existing `dict` or other `MutableMapping`, along with a `dict` of *key aliases* that translate between specific keys in this dict to different keys in the underlying dict. In other words, keys that do not have an associated alias are accessed and stored like a normal `dict`. However, a key that has an alias is accessed and stored to the "parent" dict via the alias. Parameters ---------- parent : dict-like The parent `dict` that aliased keys and accessed from and stored to. aliases : dict-like Maps keys in this dict to their associated keys in the parent dict. Examples -------- >>> parent = {'a': 1, 'b': 2, 'c': 3} >>> aliases = {'foo': 'a', 'bar': 'c'} >>> alias_dict = AliasDict(parent, aliases) >>> alias_dict['foo'] 1 >>> alias_dict['bar'] 3 Keys in the original parent dict are not visible if they were not aliased: >>> alias_dict['b'] Traceback (most recent call last): ... KeyError: 'b' Likewise, updates to aliased keys are reflected back in the parent dict: >>> alias_dict['foo'] = 42 >>> alias_dict['foo'] 42 >>> parent['a'] 42 However, updates/insertions to keys that are *not* aliased are not reflected in the parent dict: >>> alias_dict['qux'] = 99 >>> alias_dict['qux'] 99 >>> 'qux' in parent False In particular, updates on the `AliasDict` to a key that is equal to one of the aliased keys in the parent dict does *not* update the parent dict. For example, ``alias_dict`` aliases ``'foo'`` to ``'a'``. But assigning to a key ``'a'`` on the `AliasDict` does not impact the parent: >>> alias_dict['a'] = 'nope' >>> alias_dict['a'] 'nope' >>> parent['a'] 42 cCs||_||_t||_dS)N)_parent _store_type_storer_aliases)rparentaliasesrrrrus zAliasDict.__init__cCsB||jkr8y|j|j|Stk r6t|YnX|j|S)N)rbr_KeyErrorra)rr'rrr __getitem__zs  zAliasDict.__getitem__cCs*||jkr||j|j|<n ||j|<dS)N)rbr_ra)rr'rrrr __setitem__s zAliasDict.__setitem__cCsH||jkr|j}|dkrd|jjd}yt|dk}WnFtk r\tdd|Ddk}Yntk rvt|YnXt|r|st|t|dkr|t |dfS|t |Sd|jjd|jd }yt d d|D}Wntk rd }YnXt||krd }t|r |s(t||d d |DSdS)a% Validate a given bounding box sequence against the given model (which may be either a subclass of `~astropy.modeling.Model` or an instance thereof, so long as the ``.inputs`` attribute is defined. Currently this just checks that the bounding_box is either a 2-tuple of lower and upper bounds for 1-D models, or an N-tuple of 2-tuples for N-D models. This also returns a normalized version of the bounding_box input to ensure it is always an N-tuple (even for the 1-D case). rBzBounding box for z model must be a sequence of length 2 consisting of a lower and upper bound, or a 1-tuple containing such a sequence as its sole element.))rC)rBrCcSsg|] }|qSr)Zto_value)rbrrr sz)_BoundingBox.validate..rz0 model must be a sequence of length z (the number of model inputs) consisting of pairs of lower and upper bounds for those inputs on which to evaluate the model.cSsg|]}t|dkqS)rC)r0)rr2rrrr|sFcss|]}t|VqdS)N)tuple)rZboundsrrrrsz(_BoundingBox.validate..N) Zn_inputsrNrZnpshape TypeError ValueErrorrr0r}all)rvmodelZ bounding_boxndZMESSAGEZ valid_shaperrrvalidates0    z_BoundingBox.validatecCst|dtrt|SdSdS)NrrB)r$r}r0)rrrr dimensionsz_BoundingBox.dimensioncsVjdkr&tddgSjdkrJfddtjDStddS)z Given a resolution find the meshgrid approximation of the bounding box. Parameters ---------- resolution: float The resolution of the grid. rBrcs.g|]&}t|d|dqS)rrB)r~arange)rr2) resolutionrrrr|sz'_BoundingBox.domain..z)Bounding box must have positive dimensionN)rr~rranger)rrr)rrrdomains  z_BoundingBox.domain)N) rZr[r\rqrurtrz classmethodrr^rr __classcell__rr)rNrrrs   5 rrcsfddS)a Given a binary operator (as a callable of two arguments) ``oper`` and two callables ``f`` and ``g`` which accept the same arguments, returns a *new* function that takes the same arguments as ``f`` and ``g``, but passes the outputs of ``f`` and ``g`` in the given ``oper``. ``f`` and ``g`` are assumed to return tuples (which may be 1-tuples). The given operator is applied element-wise to tuple outputs). Example ------- >>> from operator import add >>> def prod(x, y): ... return (x * y,) ... >>> sum_of_prod = make_binary_operator_eval(add, prod, prod) >>> sum_of_prod(3, 5) (30,) cs(tfddt||||DS)Nc3s|]\}}||VqdS)Nr)rxy)operrrr0sz>make_binary_operator_eval....)r}zip)rparams)fgrrrr@/sz+make_binary_operator_eval..r)rrrr)rrrrmake_binary_operator_evalsrcCstj|tjd}tj|tjd}|jdks4|jdkr.)r~Z array2stringrX splitlines)rrrrrarray_repr_onelinefsrcCs:t||r2tdd|D}tdd|D}||S)aR For use with the join operator &: Combine left input/output labels with right input/output labels. If none of the labels conflict then this just returns a sum of tuples. However if *any* of the labels conflict, this appends '0' to the left-hand labels and '1' to the right-hand labels so there is no ambiguity). css|]}|dVqdS)0Nr)rrSrrrrysz!combine_labels..css|]}|dVqdS)1Nr)rrrrrrzs)set intersectionr})rrrrrcombine_labelsns rcCst| t||}|t|t||t|t|}t||t|}|t|t||t|t|}t|tjst|tjrtt||gSt||gS)a Calculates the extent of a box encapsulating a rotated 2D ellipse. Parameters ---------- a : float or `~astropy.units.Quantity` Major axis. b : float or `~astropy.units.Quantity` Minor axis. theta : float or `~astropy.units.Quantity` ['angle'] Rotation angle. If given as a floating-point value, it is assumed to be in radians. Returns ------- offsets : tuple The absolute value of the offset distances from the ellipse center that define its bounding box region, ``(dx, dy)``. Examples -------- .. plot:: :include-source: import numpy as np import matplotlib.pyplot as plt from astropy.modeling.models import Ellipse2D from astropy.modeling.utils import ellipse_extent, render_model amplitude = 1 x0 = 50 y0 = 50 a = 30 b = 10 theta = np.pi/4 model = Ellipse2D(amplitude, x0, y0, a, b, theta) dx, dy = ellipse_extent(a, b, theta) limits = [x0 - dx, x0 + dx, y0 - dy, y0 + dy] model.bounding_box = limits image = render_model(model) plt.imshow(image, cmap='binary', interpolation='nearest', alpha=.5, extent = limits) plt.show() ) r~Zarctan2tancossinr$uQuantityabs)ar{thetatZdxZdyrrrrs400cCsht|}g}g}xN|jD]@}|j|j|jfkr:td|j|jkrR| |q| |qW||fS)z Given a callable, determine the input variables and the parameters. Parameters ---------- func : callable Returns ------- inputs, params : tuple Each entry is a list of inspect.Parameter objects z)Signature must not have *args or **kwargs) r parametersvalueskindVAR_POSITIONAL VAR_KEYWORDrdefaultemptyr7)funcsigrrparamrrrget_inputs_and_paramss  rcCs |jdkr|j|S|j|S)N)unitrZquantityto)Z parameterrrrr_parameter_with_units  rcCs|dkr |S|||S)N)r)rZold_unitZnew_unitrrr_parameter_without_unitsrcCsbi}xX|D]P}g||<|dk r8||kr8|||||dk r ||kr ||||q W|S)N)rD)keysZeq1Zeq2eqr'rrr_combine_equivalency_dicts rcCs"t|tjr|tjSt|S)z Convert ``value`` to radian. )r$rrrZradr~Zdeg2rad)rrrr _to_radians  rcCs |dk r|||St|S)z3 Convert value with ``raw_unit`` to ``orig_unit``. N)rr~Zrad2deg)rZraw_unitZ orig_unitrrr _to_orig_unitsrcs,eZdZdZfddZfddZZS)_ConstraintsDictzv Wrapper around UserDict to allow updating the constraints on a Parameter when the dictionary is updated. csH||_||_i}x&|jD]}t||}t||||<qWt|dS)N)ruconstraint_typeZ param_namesrrsr)rrrcnamer)rNrrrs  z_ConstraintsDict.__init__cs,t||t|j|}t||j|dS)N)rsrgrrur!r)rr'rr)rNrrrgs z_ConstraintsDict.__setitem__)rZr[r\rqrrgrrr)rNrrs rcsJeZdZdZdiffdd ZfddZddZd d Zd d ZZ S) _SpecialOperatorsDicta Wrapper around UserDict to allow for better tracking of the Special Operators for CompoundModels. This dictionary is structured so that one cannot inadvertently overwrite an existing special operator. Parameters ---------- unique_id: int the last used unique_id for a SPECIAL OPERATOR special_operators: dict a dictionary containing the special_operators Notes ----- Direct setting of operators (`dict[key] = value`) into the dictionary has been deprecated in favor of the `.add(name, value)` method, so that unique dictionary keys can be generated and tracked consistently. rcst|||_dS)N)rsr _unique_id)r unique_idZspecial_operators)rNrrr,s z_SpecialOperatorsDict.__init__cs,||krtd|dnt||dS)NzSpecial operator "z" already exists)rrsrg)rr'r)rNrr _set_value0sz _SpecialOperatorsDict._set_valuecCs|||ttddS)Nz Special operator dictionary assignment has been deprecated. Please use `.add` instead, so that you can capture a unique key for your operator. )rwarningswarnDeprecationWarning)rr'rrrrrg6s z!_SpecialOperatorsDict.__setitem__cCs|jd7_|jS)NrB)r)rrrr_get_unique_id@sz$_SpecialOperatorsDict._get_unique_idcCs||f}||||S)a Adds a special operator to the dictionary, and then returns the unique key that the operator is stored under for later reference. Parameters ---------- operator_name: str the name for the operator operator: function the actual operator function which will be used Returns ------- the unique operator key for the dictionary `(operator_name, unique_id)` )rr)rZ operator_namerJr'rrraddEs  z_SpecialOperatorsDict.add) rZr[r\rqrrrgrrrrr)rNrrs   r)NN)NN)'rq collectionsrrcollections.abcrinspectrnumpyr~rZastropy.utils.decoratorsrZ astropy.utilsrrZastropyr r__all__r r r}rrrr rr rrrrrrrrrrrrrrrs>     k?