U e{j:O@sdZddlmZddlZddlZddlmZmZm Z dgZ e dZ dd Z d d ZGd ddZGd ddejZddddddZdS)z6 This module defines structured units and quantities. ) annotationsN)UNITYUnitUnitBaseStructuredUnitOcCsJg}|jD]6}|j|d}|jr6||t|gq ||q t|S)z-Recursively extract field names from a dtype.r)namesfieldsappend_names_from_dtypetuple)dtyper namesubdtyperW/var/www/html/bwave/python/venv/lib/python3.8/site-packages/astropy/units/structured.pyr s  r cCsg}|D]}t|tr.t|dkr.||qt|trt|dkrt|dtrt|ddkrt|dtrt|ddkr||dt|dgqt|trt|dkrt|}ddd|D}|||gqtd|dqt|S) a[Recursively normalize, inferring upper level names for unadorned tuples. Generally, we want the field names to be organized like dtypes, as in ``(['pv', ('p', 'v')], 't')``. But we automatically infer upper field names if the list is absent from items like ``(('p', 'v'), 't')``, by concatenating the names inside the tuple. rrcSs"g|]}t|tr|dn|qSr) isinstancelist.0irrr 8sz$_normalize_names..zinvalid entry zY. Should be a name, tuple of names, or 2-element list of the form [name, tuple of names].) rstrlenr rr _normalize_namesjoin ValueError)r resultrZ new_tuplerrrr!s2     rcs6eZdZdZd?fdd ZddZeddZd d Zd d Z d dZ ddZ ddZ ddZ d@fdd ZdAddZeddZeddZddZed d!Zefd"d#Zgfd$d%Zgfd&d'Zejgfd(d)ZdBd+d,Zd-d.ZdZd/d0Zd1d2Zd3d4Z d5d6Z!d7d8Z"d9d:Z#d;d<Z$d=d>Z%Z&S)Cra Container for units for a structured Quantity. Parameters ---------- units : unit-like, tuple of unit-like, or `~astropy.units.StructuredUnit` Tuples can be nested. If a `~astropy.units.StructuredUnit` is passed in, it will be returned unchanged unless different names are requested. names : tuple of str, tuple or list; `~numpy.dtype`; or `~astropy.units.StructuredUnit`, optional Field names for the units, possibly nested. Can be inferred from a structured `~numpy.dtype` or another `~astropy.units.StructuredUnit`. For nested tuples, by default the name of the upper entry will be the concatenation of the names of the lower levels. One can pass in a list with the upper-level name and a tuple of lower-level names to avoid this. For tuples, not all levels have to be given; for any level not passed in, default field names of 'f0', 'f1', etc., will be used. Notes ----- It is recommended to initialze the class indirectly, using `~astropy.units.Unit`. E.g., ``u.Unit('AU,AU/day')``. When combined with a structured array to produce a structured `~astropy.units.Quantity`, array field names will take precedence. Generally, passing in ``names`` is needed only if the unit is used unattached to a `~astropy.units.Quantity` and one needs to access its fields. Examples -------- Various ways to initialize a `~astropy.units.StructuredUnit`:: >>> import astropy.units as u >>> su = u.Unit('(AU,AU/day),yr') >>> su Unit("((AU, AU / d), yr)") >>> su.field_names (['f0', ('f0', 'f1')], 'f1') >>> su['f1'] Unit("yr") >>> su2 = u.StructuredUnit(((u.AU, u.AU/u.day), u.yr), names=(('p', 'v'), 't')) >>> su2 == su True >>> su2.field_names (['pv', ('p', 'v')], 't') >>> su3 = u.StructuredUnit((su2['pv'], u.day), names=(['p_v', ('p', 'v')], 't')) >>> su3.field_names (['p_v', ('p', 'v')], 't') >>> su3.keys() ('p_v', 't') >>> su3.values() (Unit("(AU, AU / d)"), Unit("d")) Structured units share most methods with regular units:: >>> su.physical_type ((PhysicalType('length'), PhysicalType({'speed', 'velocity'})), PhysicalType('time')) >>> su.si Unit("((1.49598e+11 m, 1.73146e+06 m / s), 3.15576e+07 s)") Ncsd}|dk rxt|tr&|jj}|j}nRt|tjr`|js@tdtdd|jD}t |}nt|t sp|f}t |}t|t st |}t|tr|dks|j|kr|S| }n|f}|dkrt ddtt|D}nt|t|krtdg}t||D]^\}}t|tr0|||d}|d}n&t |}|dk rVt|trVtd ||qt|}|dkrtd d|D}tt ||d |_|S) Nz(dtype should be structured, with fields.cSsg|] }|tfqSr) DTYPE_OBJECTrrrrrrsz*StructuredUnit.__new__..css|]}d|VqdS)fNrrrrr sz)StructuredUnit.__new__..z,lengths of units and field names must match.rrzKunits do not match in depth with field names from dtype or structured unit.cSs&g|]}t|tr|dn|tfqSr)rrr"r#rrrrsr)rr_unitsr field_namesnpr r r r r rrvaluesrangerziprr super__new__array)clsunitsr rZ convertedunitrself __class__rrr-sX           zStructuredUnit.__new__cCsdS)z?When de-serializing, e.g. pickle, start with a blank structure.)rNrr2rrr__getnewargs__szStructuredUnit.__getnewargs__cCstdd|DS)z6Possibly nested tuple of the field names of the parts.css*|]"\}}t|tr||jgn|VqdSN)rrr')rrr1rrrr%sz-StructuredUnit.field_names..)r itemsr5rrrr'szStructuredUnit.field_namescCst|jjjSr7)rr&rr r5rrr__len__szStructuredUnit.__len__cCs |j|Sr7)r&)r2itemrrr __getitem__szStructuredUnit.__getitem__cCs |jSr7)r&r:r5rrrr)szStructuredUnit.valuescCs |jjjSr7r&rr r5rrrkeysszStructuredUnit.keyscCstt|jjj|jSr7)r r+r&rr r:r5rrrr8szStructuredUnit.itemsccs|jjjEdHdSr7r<r5rrr__iter__szStructuredUnit.__iter__cs^tfdd|D}t||jjd}|dk rF|||jfSt|j }||_|S)aqApply func recursively. Parameters ---------- func : callable Function to apply to all parts of the structured unit, recursing as needed. cls : type, optional If given, should be a subclass of `~numpy.void`. By default, will return a new `~astropy.units.StructuredUnit` instance. c3s|]}|VqdSr7rrpartfuncrrr%sz4StructuredUnit._recursively_apply..rN) r r)r(r.r&rviewr,r-r4)r2rBr/Zappliedresultsr!r3rAr_recursively_applys z!StructuredUnit._recursively_applyTcCs|rt|tr|d}q|tkr0tft|}n0t|trJt|t|kr`td|d|dg}t||D]f\\}}}t|tr| ||j |ddfqrt |}|j }|jdkrt t}| |||jfqrt |S)aGet structured dtype according to value, using our field names. This is useful since ``np.array(value)`` would treat tuples as lower levels of the array, rather than as elements of a structured array. The routine does presume that the type of the first tuple is representative of the rest. Used in ``_get_converter``. For the special value of ``UNITY``, all fields are assumed to be 1.0, and hence this will return an all-float dtype. rzcannot interpret value z for unit .F) enter_listsiu)rrrrr r r+r8rr _recursively_get_dtyper(r.rkindfloatshape)r2valuerGdescrrr1r@Z part_dtyperrrrIs&       z%StructuredUnit._recursively_get_dtypecCs|tdS)z*The `StructuredUnit` instance in SI units.sirEoperator attrgetterr5rrrrOszStructuredUnit.sicCs|tdS)z+The `StructuredUnit` instance in cgs units.cgsrPr5rrrrS$szStructuredUnit.cgscCs|jtdtdS)N_get_physical_type_idr/)rErQ methodcaller Structurer5rrrrT*sz$StructuredUnit._get_physical_type_idcCs|jtdtdS)z!Physical types of all the fields. physical_typerU)rErQrRrWr5rrrrX/szStructuredUnit.physical_typecCs|tjd|dS)a\The `StructuredUnit` composed of only irreducible units. Parameters ---------- bases : sequence of `~astropy.units.UnitBase`, optional The bases to decompose into. When not provided, decomposes down to any irreducible units. When provided, the decomposed result will only contain the given units. This will raises a `UnitsError` if it's not possible to do so. Returns ------- `~astropy.units.StructuredUnit` With the unit for each field containing only irreducible units. decompose)bases)rErQrV)r2rZrrrrY6szStructuredUnit.decomposecCslz t|}Wntk r"YdSXt|t|kr8dSt||D]\}}|j||dsJdSqJdS)a`True` if all fields are equivalent to the other's fields. Parameters ---------- other : `~astropy.units.StructuredUnit` The structured unit to compare with, or what can initialize one. equivalencies : list of tuple, optional A list of equivalence pairs to try if the units are not directly convertible. See :ref:`unit_equivalencies`. The list will be applied to all fields. Returns ------- bool F equivalenciesT)r Exceptionrr+r) is_equivalent)r2otherr\ self_part other_partrrrr^Is zStructuredUnit.is_equivalentcsNt|tsj|d}fddt|Dfdd}|S)Nr csg|]\}}|j|dqS)r[)_get_converter)rr`rar[rrrksz1StructuredUnit._get_converter..cs`t|dst||}t|}t|jjD]\}}|||||<q4|jrX|S|dS)Nrr) hasattrr(r.rIZ empty_liker+rr rL)rMr!rZ converter_) convertersr2rr converterps   z0StructuredUnit._get_converter..converter)rtyper4r+r))r2r_r\rfr)rer\r2rrcgs  zStructuredUnit._get_convertercCs |tjkrt}|j||d|S)aReturn values converted to the specified unit. Parameters ---------- other : `~astropy.units.StructuredUnit` The unit to convert to. If necessary, will be converted to a `~astropy.units.StructuredUnit` using the dtype of ``value``. value : array-like, optional Value(s) in the current unit to be converted to the specified unit. If a sequence, the first element must have entries of the correct type to represent all elements (i.e., not have, e.g., a ``float`` where other elements have ``complex``). If not given, assumed to have 1. in all fields. equivalencies : list of tuple, optional A list of equivalence pairs to try if the units are not directly convertible. See :ref:`unit_equivalencies`. This list is in addition to possible global defaults set by, e.g., `set_enabled_equivalencies`. Use `None` to turn off all equivalencies. Returns ------- values : scalar or array Converted value(s). Raises ------ UnitsError If units are inconsistent r[)r(_NoValuerrc)r2r_rMr\rrrto{s zStructuredUnit.togenericcs^fdd|D}t|dkr&dnd}drNdd|D}d|d}|d |S) aOutput the unit in the given format as a string. Units are separated by commas. Parameters ---------- format : `astropy.units.format.Base` instance or str The name of a format or a formatter object. If not provided, defaults to the generic format. Notes ----- Structured units can be written to all formats, but can be re-read only with 'generic'. csg|]}|qSr to_stringr?formatrrrsz,StructuredUnit.to_string..rz({})z({},)latexcSsg|]}|ddqS)rrr?rrrrs$z, )r)r startswithrnr)r2rnpartsZout_fmtrrmrrls   zStructuredUnit.to_stringcCs |dS)Nrorkr5rrr _repr_latex_szStructuredUnit._repr_latex_csttr4ztddWntk r2tYSXttrftfdd|D}|j||dStt rttSzddl m }||dWStk rtYSXdS) NsilentZ parse_strictc3s|]}|VqdSr7rr?r_rrr%sz)StructuredUnit.__mul__..rbrQuantity)r1) rrrr]NotImplementedrr r)r4rquantityry)r2r_ new_unitsryrrwr__mul__s     zStructuredUnit.__mul__cCs ||Sr7)r}r2r_rrr__rmul__szStructuredUnit.__rmul__csjttr4ztddWntk r2tYSXttrftfdd|D}|j||dStS)Nrurvc3s|]}|VqdSr7rr?rwrrr%sz-StructuredUnit.__truediv__..rb) rrrr]rzrr r)r4)r2r_r|rrwr __truediv__s   zStructuredUnit.__truediv__cCs<zddlm}|||dddWStk r6tYSXdS)NrrxFT)copyZsubok)r{ryr]rz)r2mryrrr __rlshift__s  zStructuredUnit.__rlshift__cCs|Sr7rkr5rrr__str__szStructuredUnit.__str__cCsd|dS)NzUnit("z")rkr5rrr__repr__szStructuredUnit.__repr__cCs6z t|}Wntk r$tYSX||kSr7)rr]rzr)r~rrr__eq__s   zStructuredUnit.__eq__cCsDt|t|s4z t|}Wntk r2tYSX||kSr7)rrgrr]rzr)r~rrr__ne__s   zStructuredUnit.__ne__)N)N)T)rj)'__name__ __module__ __qualname____doc__r-r6propertyr'r9r;r)r=r8r>rErIrOrSrTrXsetrYr^rcr(rhrirlrtZ__array_ufunc__r}rrrrrrr __classcell__rrr3rrDsF=B  #     %  c@s eZdZdZddZddZdS)rWaRSingle element structure for physical type IDs, etc. Behaves like a `~numpy.void` and thus mostly like a tuple which can also be indexed with field names, but overrides ``__eq__`` and ``__ne__`` to compare only the contents, not the field names. Furthermore, this way no `FutureWarning` about comparisons is given. cCs t|tjr|}||kSr7rr(voidr:r~rrrrs zStructure.__eq__cCs t|tjr|}||kSr7rr~rrrrs zStructure.__ne__N)rrrrrrrrrrrWsrWzUnitBase | StructuredUnitznp.dtype)r1rreturncCsdt|tr|Sg}|jD]8}|j|d}|jdk rF|t||q||qtt||jdS)a0Make a `StructuredUnit` of one unit, with the structure of a `numpy.dtype`. Parameters ---------- unit : UnitBase The unit that will be filled into the structure. dtype : `numpy.dtype` The structure for the StructuredUnit. Returns ------- StructuredUnit rNrb)rrr r r _structured_unit_like_dtyper )r1rr0rrrrrrs    r)r __future__rrQnumpyr(corerrr__all__rr"r rrrrWrrrrrs   #@