a ߙfbU@sddZddlZddlZddlZddlZddlZddlmZddl m Z ddl m Z ddl mZmZmZmZddlmZgd Zd Zd d Zd dZGdddZGdddZegZddZddZddZddZddZ ddZ!dd Z"Gd!d"d"e#Z$Gd#d$d$e$e%Z&Gd%d&d&e$e%Z'Gd'd(d(e$e(Z)Gd)d*d*e Z*Gd+d,d,Z+Gd-d.d.e+Z,d/d0Z-Gd1d2d2e,Z.Gd3d4d4e.Z/Gd5d6d6e0Z1Gd7d8d8e,e1d9Z2Gd:d;d;e2Z3Gdgd?gd@fdAgdBgdCfdDgdEgdFfdGgdHgdIfdJgdKgdLfdMgdNgdOfdPgdQgdRfdSgdTgdUfdVgdWgdXfdYgdZd[gd\fd]gd^gd_fd`gdagdbfdcgddgdefdfgdggdhfdigdjgdkfdlgdmgdnfdogdpgdqfdrgdsgdtfdugdvgdwfdxgdygdzfgZ5d{gd|gd}fd~gdgdfdgdgdfdgdgdfdgdgdfdgdgdfgZ6gddfddZ7ddddgdfddZ8ddZ9ddZ:e4dggddZ;e;ZWz*_normalize_equivalencies..zInvalid equivalence entry z: ) enumeratelen ValueErrorrcallableappend) equivalencies normalizediZequivfunittunitabr0r0r1_normalize_equivalenciesAs:      rGc@seZdZdZggifddZddZddZdd Zed d Z ed d Z eddZ ddZ ddZ ddZeddZddZddZeddZddZd d!Zd"S)# _UnitRegistryz2 Manages a registry of the enabled units. cCst|tr^|j|_|j|_|j|_|j|_|j|_dd|j D|_n6| | | | |||||dS)NcSsi|]\}}||qSr0)copy).0kvr0r0r1 ~r8z*_UnitRegistry.__init__..)r"rH_equivalenciesrI_aliases _all_units _registry_non_prefix_units_by_physical_typer+ _reset_units_reset_equivalencies_reset_aliasesrrr)selfinitr@aliasesr0r0r1__init__ps         z_UnitRegistry.__init__cCs t|_t|_i|_i|_dSr4)r$rPrRrQrSrWr0r0r1rTsz_UnitRegistry._reset_unitscCs t|_dSr4)r$rNr[r0r0r1rUsz"_UnitRegistry._reset_equivalenciescCs i|_dSr4rOr[r0r0r1rVsz_UnitRegistry._reset_aliasescCs|jSr4)rQr[r0r0r1registrysz_UnitRegistry.registrycCs|jSr4)rPr[r0r0r1 all_unitssz_UnitRegistry.all_unitscCs|jSr4)rRr[r0r0r1non_prefix_unitssz_UnitRegistry.non_prefix_unitscCs|||S)a! Sets the units enabled in the unit registry. These units are searched when using `UnitBase.find_equivalent_units`, for example. Parameters ---------- units : list of sequence, dict, or module This is a list of things in which units may be found (sequences, dicts or modules), or units themselves. The entire set will be "enabled" for searching through by methods like `UnitBase.find_equivalent_units` and `UnitBase.compose`. )rTr)rWr.r0r0r1rsz_UnitRegistry.set_enabled_unitscCst|}|D]}|jD]*}||jvr||j|krtd|q|jD]}||j|<qH|j|t|tsz|j || }|j |t |q dS)a< Adds to the set of units enabled in the unit registry. These units are searched when using `UnitBase.find_equivalent_units`, for example. Parameters ---------- units : list of sequence, dict, or module This is a list of things in which units may be found (sequences, dicts or modules), or units themselves. The entire set will be added to the "enabled" set for searching through by methods like `UnitBase.find_equivalent_units` and `UnitBase.compose`. zvObject with name {!r} already exists in namespace. Filter the set of units to avoid name clashes before enabling them.N)r2_namesrQr=r rPr%r"rrR_get_physical_type_idrS setdefaultr$)rWr.r/sthashr0r0r1rs       z_UnitRegistry.add_enabled_unitscCs|j|tS)z Get all units in the registry with the same physical type as the given unit. Parameters ---------- unit : UnitBase instance )rSgetrar$rWr/r0r0r1get_units_with_physical_types z*_UnitRegistry.get_units_with_physical_typecCs t|jSr4)r#rNr[r0r0r1r@sz_UnitRegistry.equivalenciescCs|||S)a Sets the equivalencies enabled in the unit registry. These equivalencies are used if no explicit equivalencies are given, both in unit conversion and in finding equivalent units. This is meant in particular for allowing angles to be dimensionless. Use with care. Parameters ---------- equivalencies : list of tuple List of equivalent pairs, e.g., as returned by `~astropy.units.equivalencies.dimensionless_angles`. )rUrrWr@r0r0r1rsz'_UnitRegistry.set_enabled_equivalenciescCst|}|jt|O_dS)a  Adds to the set of equivalencies enabled in the unit registry. These equivalencies are used if no explicit equivalencies are given, both in unit conversion and in finding equivalent units. This is meant in particular for allowing angles to be dimensionless. Use with care. Parameters ---------- equivalencies : list of tuple List of equivalent pairs, e.g., as returned by `~astropy.units.equivalencies.dimensionless_angles`. N)rGrNr$rhr0r0r1rsz'_UnitRegistry.add_enabled_equivalenciescCs|jSr4r\r[r0r0r1rYsz_UnitRegistry.aliasescCs|||dS)a Set aliases for units. Parameters ---------- aliases : dict of str, Unit The aliases to set. The keys must be the string aliases, and values must be the `astropy.units.Unit` that the alias will be mapped to. Raises ------ ValueError If the alias already defines a different unit. N)rVr)rWrYr0r0r1rsz!_UnitRegistry.set_enabled_aliasescCs|D]x\}}||jvrH||j|krHt|d|j|d|d||jvr||j|krt|d|j|d|dq|D]&\}}||jvr||jvr||j|<qdS)a Add aliases for units. Parameters ---------- aliases : dict of str, Unit The aliases to add. The keys must be the string aliases, and values must be the `astropy.units.Unit` that the alias will be mapped to. Raises ------ ValueError If the alias already defines a different unit. z already means z$, so cannot be used as an alias for .z already is an alias for N)r+rQr=rO)rWrYaliasr/r0r0r1r's z!_UnitRegistry.add_enabled_aliasesN)__name__ __module__ __qualname____doc__rZrTrUrVpropertyr]r^r_rrrgr@rrrYrrr0r0r0r1rHks,   &   rHc@s*eZdZggfddZddZddZdS) _UnitContextcCstt||ddS)N)rXr@)_unit_registriesr?rH)rWrXr@r0r0r1rZGs z_UnitContext.__init__cCsdSr4r0r[r0r0r1 __enter__Ksz_UnitContext.__enter__cCs tdSr4)rqpop)rWtypevaluetbr0r0r1__exit__Nsz_UnitContext.__exit__N)rkrlrmrZrrrwr0r0r0r1rpFsrpcCstdS)N)rqr0r0r0r1rUsrcCsttjd}t||S)a Sets the units enabled in the unit registry. These units are searched when using `UnitBase.find_equivalent_units`, for example. This may be used either permanently, or as a context manager using the ``with`` statement (see example below). Parameters ---------- units : list of sequence, dict, or module This is a list of things in which units may be found (sequences, dicts or modules), or units themselves. The entire set will be "enabled" for searching through by methods like `UnitBase.find_equivalent_units` and `UnitBase.compose`. Examples -------- >>> from astropy import units as u >>> with u.set_enabled_units([u.pc]): ... u.m.find_equivalent_units() ... Primary name | Unit definition | Aliases [ pc | 3.08568e+16 m | parsec , ] >>> u.m.find_equivalent_units() Primary name | Unit definition | Aliases [ AU | 1.49598e+11 m | au, astronomical_unit , Angstrom | 1e-10 m | AA, angstrom , cm | 0.01 m | centimeter , earthRad | 6.3781e+06 m | R_earth, Rearth , jupiterRad | 7.1492e+07 m | R_jup, Rjup, R_jupiter, Rjupiter , lsec | 2.99792e+08 m | lightsecond , lyr | 9.46073e+15 m | lightyear , m | irreducible | meter , micron | 1e-06 m | , pc | 3.08568e+16 m | parsec , solRad | 6.957e+08 m | R_sun, Rsun , ] r@)rprr@rr.contextr0r0r1rYs . rcCstt}t||S)a Adds to the set of units enabled in the unit registry. These units are searched when using `UnitBase.find_equivalent_units`, for example. This may be used either permanently, or as a context manager using the ``with`` statement (see example below). Parameters ---------- units : list of sequence, dict, or module This is a list of things in which units may be found (sequences, dicts or modules), or units themselves. The entire set will be added to the "enabled" set for searching through by methods like `UnitBase.find_equivalent_units` and `UnitBase.compose`. Examples -------- >>> from astropy import units as u >>> from astropy.units import imperial >>> with u.add_enabled_units(imperial): ... u.m.find_equivalent_units() ... Primary name | Unit definition | Aliases [ AU | 1.49598e+11 m | au, astronomical_unit , Angstrom | 1e-10 m | AA, angstrom , cm | 0.01 m | centimeter , earthRad | 6.3781e+06 m | R_earth, Rearth , ft | 0.3048 m | foot , fur | 201.168 m | furlong , inch | 0.0254 m | , jupiterRad | 7.1492e+07 m | R_jup, Rjup, R_jupiter, Rjupiter , lsec | 2.99792e+08 m | lightsecond , lyr | 9.46073e+15 m | lightyear , m | irreducible | meter , mi | 1609.34 m | mile , micron | 1e-06 m | , mil | 2.54e-05 m | thou , nmi | 1852 m | nauticalmile, NM , pc | 3.08568e+16 m | parsec , solRad | 6.957e+08 m | R_sun, Rsun , yd | 0.9144 m | yard , ] )rprrrzr0r0r1rs2  rcCstt}t||S)aV Sets the equivalencies enabled in the unit registry. These equivalencies are used if no explicit equivalencies are given, both in unit conversion and in finding equivalent units. This is meant in particular for allowing angles to be dimensionless. Use with care. Parameters ---------- equivalencies : list of tuple list of equivalent pairs, e.g., as returned by `~astropy.units.equivalencies.dimensionless_angles`. Examples -------- Exponentiation normally requires dimensionless quantities. To avoid problems with complex phases:: >>> from astropy import units as u >>> with u.set_enabled_equivalencies(u.dimensionless_angles()): ... phase = 0.5 * u.cycle ... np.exp(1j*phase) # doctest: +FLOAT_CMP )rprrr@r{r0r0r1rs  rcCstt}t||S)a> Adds to the equivalencies enabled in the unit registry. These equivalencies are used if no explicit equivalencies are given, both in unit conversion and in finding equivalent units. This is meant in particular for allowing angles to be dimensionless. Since no equivalencies are enabled by default, generally it is recommended to use `set_enabled_equivalencies`. Parameters ---------- equivalencies : list of tuple list of equivalent pairs, e.g., as returned by `~astropy.units.equivalencies.dimensionless_angles`. )rprrr|r0r0r1rs  rcCstt}t||S)a Set aliases for units. This is useful for handling alternate spellings for units, or misspelled units in files one is trying to read. Parameters ---------- aliases : dict of str, Unit The aliases to set. The keys must be the string aliases, and values must be the `astropy.units.Unit` that the alias will be mapped to. Raises ------ ValueError If the alias already defines a different unit. Examples -------- To temporarily allow for a misspelled 'Angstroem' unit:: >>> from astropy import units as u >>> with u.set_enabled_aliases({'Angstroem': u.Angstrom}): ... print(u.Unit("Angstroem", parse_strict="raise") == u.Angstrom) True )rprrrYr{r0r0r1rs  rcCstt}t||S)a[ Add aliases for units. This is useful for handling alternate spellings for units, or misspelled units in files one is trying to read. Since no aliases are enabled by default, generally it is recommended to use `set_enabled_aliases`. Parameters ---------- aliases : dict of str, Unit The aliases to add. The keys must be the string aliases, and values must be the `astropy.units.Unit` that the alias will be mapped to. Raises ------ ValueError If the alias already defines a different unit. Examples -------- To temporarily allow for a misspelled 'Angstroem' unit:: >>> from astropy import units as u >>> with u.add_enabled_aliases({'Angstroem': u.Angstrom}): ... print(u.Unit("Angstroem", parse_strict="raise") == u.Angstrom) True )rprrr}r0r0r1r#s  rc@seZdZdZdS)r z6 The base class for unit-specific exceptions. Nrkrlrmrnr0r0r0r1r Isr c@seZdZdZdS)UnitScaleErrorzg Used to catch the errors involving scaled units, which are not recognized by FITS format. Nr~r0r0r0r1rOsrc@seZdZdZdS)rz} Used specifically for errors related to converting between units or interpreting units in terms of other units. Nr~r0r0r0r1rWsrc@seZdZdZdS)rz Used specifically for errors in setting to units not allowed by a class. E.g., would be raised if the unit of an `~astropy.coordinates.Angle` instances were set to a non-angular unit. Nr~r0r0r0r1r^src@seZdZdZdS)r z4 The base class for unit-specific warnings. Nr~r0r0r0r1r gsr c@seZdZdZdZdZddZddZdd Zd d Z d d Z ddZ e ddZ e ddZe ddZe ddZe ddZe ddZejfddZddZed d!Zd"d#Zd$d%Zd&d'ZeZeZd(d)Zd*d+Zd,d-Z d.d/Z!d0d1Z"d2d3Z#d4d5Z$d6d7Z%d8d9Z&d:d;Z'dd?Z)d@dAZ*gfdBdCZ+gfdDdEZ,dFdGZ-gfdHdIZ.dJdKZ/e0gfdLdMZ1dNgfdOdPZ2e3fdQdRZ4ggdSdTdfdUdVZ5gddSdfdWdXZ6dYdZZ7e8d[d\Z9e8d]d^Z:e d_d`Z;gfdadbZgddefdfdgZ?dhdiZ@dS)jrz Abstract base class for units. Most of the arithmetic operations on units are defined in this base class. Should not be instantiated by users directly. iNcCs|Sr4r0)rWmemor0r0r1 __deepcopy__|szUnitBase.__deepcopy__cCs tj|S)z Generate latex representation of unit name. This is used by the IPython notebook to print a unit with a nice layout. Returns ------- Latex string ) unit_formatZLatex to_stringr[r0r0r1 _repr_latex_s zUnitBase._repr_latex_cCstj|dS)%Return string representation for unitZunicode_escape)rGenericrencoder[r0r0r1 __bytes__szUnitBase.__bytes__cCs tj|S)rrrrr[r0r0r1__str__szUnitBase.__str__cCstj|}d|dS)NzUnit("z")r)rWstringr0r0r1__repr__s zUnitBase.__repr__cCs,|}tdd|jD|j}t|}|S)z Returns an identifier that uniquely identifies the physical type of this unit. It is comprised of the bases and powers of this unit, without the scale. Since it is hashable, it is useful as a dictionary key. cSsg|] }|jqSr0namerJr6r0r0r1 r8z2UnitBase._get_physical_type_id..) decomposezipbasespowerstuple)rWr/rr0r0r1raszUnitBase._get_physical_type_idcCs tddS)E Returns all of the names associated with this unit. DCan not get names from unnamed units. Perhaps you meant to_string()?NAttributeErrorr[r0r0r1namesszUnitBase.namescCs tddS)O Returns the canonical (short) name associated with this unit. rNrr[r0r0r1rsz UnitBase.namecCs tddS)? Returns the alias (long) names for this unit. zFCan not get aliases from unnamed units. Perhaps you meant to_string()?Nrr[r0r0r1rYszUnitBase.aliasescCsdS)z/ Return the scale of the unit. r!r0r[r0r0r1scaleszUnitBase.scalecCs|gS)z/ Return the bases of the unit. r0r[r0r0r1rszUnitBase.basescCsdgS)z0 Return the powers of the unit. rr0r[r0r0r1rszUnitBase.powerscCst|}||S)a Output the unit in the given format as a string. 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. )r get_formatr)rWr fr0r0r1rs zUnitBase.to_stringcCs4z|j|dWSty.tt||YS0dS)z&Try to format units using a formatter.r N)rr=r str)rW format_specr0r0r1 __format__s zUnitBase.__format__cCs t|}|dur|tj7}|S)a: Normalizes equivalencies, ensuring each is a 4-tuple of the form:: (from_unit, to_unit, forward_func, backward_func) Parameters ---------- equivalencies : list of equivalency pairs, or None Returns ------- A normalized list, including possible global defaults set by, e.g., `set_enabled_equivalencies`, except when `equivalencies`=`None`, in which case the returned list is always empty. Raises ------ ValueError if an equivalency cannot be interpreted N)rGrr@)r@rAr0r0r1rGs z!UnitBase._normalize_equivalenciescCst|}td|g|gddS)NrF _error_check)rr)rWpr0r0r1__pow__szUnitBase.__pow__cCs|t|ttfrt|}t|trD|r,|Std||gddgddSzddlm}|d||WSt yvt YS0dS)NrrxFrQuantity r"bytesrrris_unityrquantityr TypeErrorNotImplementedrWmrr0r0r1__div__ s   zUnitBase.__div__cCsvt|ttfrt||Sz@ddlm}t|drH||}||}|WS|||dWSWntyptYS0dS)Nrrr/rx r"rrrrrhasattrrrrWrrr,r0r0r1__rdiv__s    zUnitBase.__rdiv__cCst|ttfrt|}t|trP|r,|S|r8|Std||gddgddSzddlm}|d||WSt yt YS0dS)NrFrrrrr0r0r1__mul__2s   zUnitBase.__mul__cCsrt|ttfrt||Sz> is not implemented. Did you mean to convert to a Quantity with unit {} using '<<'?)warningswarnr rr)rWrr0r0r1 __rrshift__]s zUnitBase.__rrshift__cCsJ|jdurDt|jgdd|jDdd|jD}tt||_|jS)NcSsg|] }|jqSr0rrr0r0r1rfr8z%UnitBase.__hash__..cSsg|] }t|qSr0rrr0r0r1rgr8)_hashrrrrrdr)rWpartsr0r0r1__hash__cs  zUnitBase.__hash__cCs|j}|dd|S)Nr)__dict__rIrs)rWstater0r0r1 __getstate__ks  zUnitBase.__getstate__c Csr||ur dSzt|dd}Wntttfy8tYS0t|tsHtSzt||WStylYdS0dS)NTsilent parse_strictF) rr=r rrr"rr_torWotherr0r0r1__eq__rs   zUnitBase.__eq__cCs ||k Sr4r0rr0r0r1__ne__szUnitBase.__ne__cCs|t|}|dkpt|SNr!rrrrWrrr0r0r1__le__szUnitBase.__le__cCs|t|}|dkpt|Srrrr0r0r1__ge__szUnitBase.__ge__cCs ||k Sr4r0rr0r0r1__lt__szUnitBase.__lt__cCs ||k Sr4r0rr0r0r1__gt__szUnitBase.__gt__cCs|dS)Ngr0r[r0r0r1__neg__szUnitBase.__neg__csDt|tr,tfdd|DSt|dd}|S)a Returns `True` if this unit is equivalent to ``other``. Parameters ---------- other : `~astropy.units.Unit`, str, or tuple The unit to convert to. If a tuple of units is specified, this method returns true if the unit matches any of those in the tuple. equivalencies : list of tuple A list of equivalence pairs to try if the units are not directly convertible. See :ref:`astropy: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 ------- bool c3s|]}j|dVqdS)ryN) is_equivalent)rJur@rWr0r1 sz)UnitBase.is_equivalent..rr)rGr"ranyr_is_equivalentrWrr@r0rr1rs   zUnitBase.is_equivalentc Cst|trdS||kr"dSt|r|}|}|D]p\}}}}|durz|||gWdSty|Yq0q>||r||s||r>||r>dSq>dS)aReturns `True` if this unit is equivalent to `other`. See `is_equivalent`, except that a proper Unit object should be given (i.e., no string) and that the equivalency list should be normalized using `_normalize_equivalencies`. FTN)r"rrar<rrr)rWrr@r/rErFZforwardZbackwardr0r0r1rs.  zUnitBase._is_equivalentc Csdd}|D]\}}}}|durbz,|||g} || j|dWSty^Yq0q z&||} ||} || || WStyYn0z&||} ||} || || WStyYq 0q dd} | |} | |}t| d|ddS) zd Internal function (used from `_get_converter`) to apply equivalence pairs. csfdd}|S)Ncst|Sr4_condition_argrLfuncscale1scale2r0r1convertszFUnitBase._apply_equivalencies..make_converter..convertr0)rrrrr0rr1make_convertersz5UnitBase._apply_equivalencies..make_converterNr!cSs<|d}|j}|dkr,d|d|d}n d|d}|S)NZunscaledunknown'z' ())r physical_type)r/unit_strrr0r0r1 get_err_strs   z2UnitBase._apply_equivalencies..get_err_strz and z are not convertible)rrr rr)rWr/rr@rrCrDrErFZratio_in_funitrrrrZ other_strr0r0r1_apply_equivalenciess<        zUnitBase._apply_equivalenciesc sz|Wnty Yn0dkr.tSfddSz|WSty}znt|dr|jD]L\}}||urpz$fddWWYd}~StyYqp0qp|WYd}~n d}~00dS)zGet a converter for values in ``self`` to ``other``. If no conversion is necessary, returns ``unit_scale_converter`` (which is used as a check in quantity helpers). r!cs t|Sr4rval)rr0r1r7r8z)UnitBase._get_converter..r@csjd|S)Nry)_get_converterr)rFr@rWrDr0r1r7%sN)rr unit_scale_converterrrGrr@r)rWrr@excrCrEr0)rFr@rrWrDr1rs(     $ zUnitBase._get_convertercCst||ur dSt|trZ|}|}|j|jkrZtddt|j|jDrZ|j|jStd|d|ddS)z Returns the scale to the specified unit. See `to`, except that a Unit object should be given (i.e., no string), and that all defaults are used, i.e., no equivalencies and value=1. r!css|]\}}||uVqdSr4r0)rJZ self_baseZ other_baser0r0r1rFr8zUnitBase._to..rz' is not a scaled version of 'N) r"rrrallrrrr)rWrZself_decomposedZother_decomposedr0r0r1r,s     z UnitBase._tocCs.||ur|turtS|jt||d|SdS)a Return the converted values in the specified unit. Parameters ---------- other : unit-like The unit to convert to. value : int, float, or scalar array-like, optional Value(s) in the current unit to be converted to the specified unit. If not provided, defaults to 1.0 equivalencies : list of tuple A list of equivalence pairs to try if the units are not directly convertible. See :ref:`astropy: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). Input value sequences are returned as numpy arrays. Raises ------ UnitsError If units are inconsistent ryN)UNITYrrrWrrur@r0r0r1toMs z UnitBase.tor!cCs|j|||dS)zI Alias for `to` for backward compatibility with pynbody. )rur@)rrr0r0r1in_unitsrszUnitBase.in_unitscCs tdS)aO Return a unit object composed of only irreducible units. Parameters ---------- bases : sequence of 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 ------- unit : `~astropy.units.CompositeUnit` New object containing only irreducible unit objects. N)NotImplementedErrorrWrr0r0r1ryszUnitBase.decomposer3rc shfdd}|}t|}||} | dur@t| tr<| | S||krX|g||<|gS|g} |D]\} } } }| dur|| r| j|j}| t| d|| n8|| r| j|j}| t|d|| qb|| rb| t|jqbg}t |j dkr,t |gt g}n t t g}D]} | }| D]}t |j dkrt |j |j D],\}}||rn| |} ||}qqn||}|| }t |j }||r|dkr|||n|||| fqLq<|D]2}t |r|d|d}|||<|Sq|jtddg}|D]d\}}} z|j|||d|d}Wntyg}Yn0|D]}|t |j || fqqHt |r2|jtdd|dd}t }|D]:\}}} ||krqn|| }||r||qt |r2|||<|S||sXtd|d }|||<||g||<|gS) Ncs|jD]}|vrdSqdS)NFTr)r/base namespacer0r1is_final_results z*UnitBase._compose..is_final_resultr!rrkeyr@r max_depthdepthcached_resultszCannot represent unit z in terms of the given units)rrdrer"rrrr?rr<rr$rrr%unionsortoperator itemgetter_composer ) rWr@rrrrrr/rcachedr.rCrDrErFrZpartial_resultsZ final_resultsZtunit_decomposedrrpowercomposedZfactoredZ len_basesZ final_resultresultsZ composed_listZ subcomposedZ min_lengthZ subresultsr,r0rr1rs                            zUnitBase._composecsdurt|ttf|ddfddfdd}||dur|||jd}t|d krtj}nDt|t rt || }n(t |r|t| }n |t|}d d }||j||d id S) a Return the simplest possible composite unit(s) that represent the given unit. Since there may be multiple equally simple compositions of the unit, a list of units is always returned. Parameters ---------- equivalencies : list of tuple A list of equivalence pairs to also list. See :ref:`astropy: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. units : set of `~astropy.units.Unit`, optional If not provided, any known units may be used to compose into. Otherwise, ``units`` is a dict, module or sequence containing the units to compose into. max_depth : int, optional The maximum recursion depth to use when composing into composite units. include_prefix_units : bool, optional When `True`, include prefixed units in the result. Default is `True` if a sequence is passed in to ``units``, `False` otherwise. Returns ------- units : list of `CompositeUnit` A list of candidate compositions. These will all be equally simple, but it may not be possible to automatically determine which of the candidates are better. NcSsLt|jdkr t|jdkr dS|jD] }|jD]}||kr0dSq0q&dS)NrTFr<r)rErFZabZbbr0r0r1has_bases_in_common:s   z-UnitBase.compose..has_bases_in_commoncs||rdSD]n\}}}}|durf||rF||rddSq||r||rdSq||rt|rdSqdS)NTF)rrr)r/rrCrDrErF)r@r r0r1has_bases_in_common_with_equivCs     z8UnitBase.compose..has_bases_in_common_with_equivcsDt}|D]4}t|tr s&t|ts |r ||q |Sr4)r$r"rrrr%)r.Zfiltered_namespacerD) decomposedrinclude_prefix_unitsr0r1 filter_unitsTs  z&UnitBase.compose..filter_unitsryrcSst|s gSt|}|jddd|jddd|jddd|jddd|d}|g}|ddD]"}t|t|kr|||}qn|S) NcSs t|jSr4)npabsrr5r0r0r1r7wr8z8UnitBase.compose..sort_results..rcSstt|jSr4)rsumrrr5r0r0r1r7xr8cSst|jdkS)Ng)rrrr5r0r0r1r7yr8cSs t|j Sr4)rrr5r0r0r1r7zr8rr)r<r#rrr?)r Z last_resultZfilteredr,r0r0r1 sort_resultsms z&UnitBase.compose..sort_resultsr)r"r#rrGr"_get_units_with_same_physical_typer<rr_r&r$r'r(r)r*r2r)rWr@r.rrrrr0)rr@r rrr1composes.(        zUnitBase.composecs@t|jfdd}|jd}|j|d}t||dd}|S)a Converts this unit into ones belonging to the given system. Since more than one result may be possible, a list is always returned. Parameters ---------- system : module The module that defines the unit system. Commonly used ones include `astropy.units.si` and `astropy.units.cgs`. To use your own module it must contain unit objects and a sequence member named ``bases`` containing the base units of the system. Returns ------- units : list of `CompositeUnit` The list is ranked so that units containing only the base units of that system will appear first. csJ|j}t|dkrtjSd}|D]}|vr |d7}q |tt|SdS)Nrr)rr<rinffloat)rZ compose_basesrrrr0r1scores  z!UnitBase.to_system..scorer)r.T)rreverse)r$rrrsorted)rWsystemrr6r r0rr1 to_systems     zUnitBase.to_systemcCsddlm}||dS)zL Returns a copy of the current `Unit` instance in SI units. r)sir)rr)rWrr0r0r1rs z UnitBase.sicCsddlm}||dS)zO Returns a copy of the current `Unit` instance with CGS units. r)cgsr)r r!r)rWr!r0r0r1r!s z UnitBase.cgscCsddlm}||S)a Physical type(s) dimensionally compatible with the unit. Returns ------- `~astropy.units.physical.PhysicalType` A representation of the physical type(s) of a unit. Examples -------- >>> from astropy import units as u >>> u.m.physical_type PhysicalType('length') >>> (u.m ** 2 / u.s).physical_type PhysicalType({'diffusivity', 'kinematic viscosity'}) Physical types can be compared to other physical types (recommended in packages) or to strings. >>> area = (u.m ** 2).physical_type >>> area == u.m.physical_type ** 2 True >>> area == "area" True `~astropy.units.physical.PhysicalType` objects can be used for dimensional analysis. >>> number_density = u.m.physical_type ** -3 >>> velocity = (u.m / u.s).physical_type >>> number_density * velocity PhysicalType('particle flux') r)physical)r r"Zget_physical_type)rWr"r0r0r1rs# zUnitBase.physical_typecCst}t||}|D]n\}}}}|durr||rN||vrN|||||r||vr|||q||r|tq|S)a Return a list of registered units with the same physical type as this unit. This function is used by Quantity to add its built-in conversions to equivalent units. This is a private method, since end users should be encouraged to use the more powerful `compose` and `find_equivalent_units` methods (which use this under the hood). Parameters ---------- equivalencies : list of tuple A list of equivalence pairs to also pull options from. See :ref:`astropy:unit_equivalencies`. It must already be normalized using `_normalize_equivalencies`. N)rr$rgrupdaterr%r)rWr@Z unit_registryr.rCrDrErFr0r0r1rs  z+UnitBase._get_units_with_same_physical_typec@s8eZdZdZdZdZdZddZddZe d d Z d S) zUnitBase.EquivalentUnitsListzb A class to handle pretty-printing the result of `find_equivalent_units`. )z Primary namezUnit definitionZAliasesr9zThere are no equivalent unitscst|dkr|jS||}|d|jdg|j}|D],}t|D]\}}t||t|||<qFq:dj|fdd|D}|dddgdd|ddDdg}d |SdS) Nrz) {{0:<{0}s}} | {{1:<{1}s}} | {{2:<{2}s}}csg|]}j|qSr0r )rJlinerr0r1r%r8z9UnitBase.EquivalentUnitsList.__repr__..r[cSsg|]}|dqS)z ,r0rr0r0r1r(r8] ) r<NO_EQUIV_UNITS_MSG_process_equivalent_unitsinsert HEADING_NAMESROW_LENr;maxr join)rWlinesZwidthsr$rBcolr0r%r1rs$     z%UnitBase.EquivalentUnitsList.__repr__c Cst|dkrd|jdSd}d}d|j}d|j}||j|j}||}|}|D]}||j|} || 7}qZ||SdS) zW Outputs a HTML table representation within Jupyter notebooks. rz

z

z#{}
z {}z {}z {}N)r<r)r-r r,r*) rWZ blank_tableZblank_row_containerZheading_row_contentZdata_row_contentZ heading_rowZ data_rowsZall_rowsrowZhtml_rowr0r0r1 _repr_html_,s"      z(UnitBase.EquivalentUnitsList._repr_html_cCsNg}|D]8}|}||jkr&d}||j|d|jfq||S)z\ Extract attributes, and sort, the equivalent units pre-formatting. Z irreduciblez, )rrrr?r/rYr)Zequiv_units_dataZprocessed_equiv_unitsrZirredr0r0r1r*Es  z6UnitBase.EquivalentUnitsList._process_equivalent_unitsN) rkrlrmrnr,r-r)rr3 staticmethodr*r0r0r0r1EquivalentUnitsListsr5FcCs.|j||d|d}tdd|D}||S)a4 Return a list of all the units that are the same type as ``self``. Parameters ---------- equivalencies : list of tuple A list of equivalence pairs to also list. See :ref:`astropy:unit_equivalencies`. Any list given, including an empty one, supersedes global defaults that may be in effect (as set by `set_enabled_equivalencies`) units : set of `~astropy.units.Unit`, optional If not provided, all defined units will be searched for equivalencies. Otherwise, may be a dict, module or sequence containing the units to search for equivalencies. include_prefix_units : bool, optional When `True`, include prefixed units in the result. Default is `False`. Returns ------- units : list of `UnitBase` A list of unit objects that match ``u``. A subclass of `list` (``EquivalentUnitsList``) is returned that pretty-prints the list of units when output. r)r@r.rrcss&|]}t|jdkr|jdVqdS)rrNr rr0r0r1rtsz1UnitBase.find_equivalent_units..)rr$r5)rWr@r.rr r0r0r1find_equivalent_unitsTszUnitBase.find_equivalent_unitscCsdS)zK Returns `True` if the unit is unscaled and dimensionless. Fr0r[r0r0r1rxszUnitBase.is_unity)ArkrlrmrnZ__array_priority__rrrrrrrarorrrYrrrrrrrr4rGrrr __truediv__ __rtruediv__rrrrrrrrrrrrrrrrrrrrrr$rrrrrrr!rrr#r5r6rr0r0r0r1rms           / &!% z -   % "E $rc@speZdZdZdddZddZddZed d Zed d Z ed dZ eddZ eddZ dddZ dS)rah The base class of units that have a name. Parameters ---------- st : str, list of str, 2-tuple The name of the unit. If a list of strings, the first element is the canonical (short) name, and the rest of the elements are aliases. If a tuple of lists, the first element is a list of short names, and the second element is a list of long names; all but the first short name are considered "aliases". Each name *should* be a valid Python identifier to make it easy to access, but this is not required. namespace : dict, optional When provided, inject the unit, and all of its aliases, in the given namespace dictionary. If a unit by the same name is already in the namespace, a ValueError is raised. doc : str, optional A docstring describing the unit. format : dict, optional A mapping to format-specific representations of this unit. For example, for the ``Ohm`` unit, it might be nice to have it displayed as ``\Omega`` by the ``latex`` formatter. In that case, `format` argument should be set to:: {'latex': r'\Omega'} Raises ------ ValueError If any of the given unit names are already in the registry. ValueError If any of the given unit names are not valid Python tokens. Ncs0t|tttfr0g|_g|_g|_nttrt dksNt ddfdddD|_t |jst dddd|_ddd|_n.rzmust provide at least one namez$st list must have at least one entry)rrZr"rrr` _short_names _long_namesrr<r=_format _generate_doctextwrapdedentZfillrn_inject)rWrcdocr rr0r;r1rZs:           zNamedUnit.__init__cCs2|j}t|jdkr&dj|ddS|dSdS)z Generate a docstring for the unit if the user didn't supply one. This is only used from the constructor and may be overridden in subclasses. rz {1} ({0})Nr3r)rr<r )rWrr0r0r1r?szNamedUnit._generate_doccCs|j||jS)a} Get a name for this unit that is specific to a particular format. Uses the dictionary passed into the `format` kwarg in the constructor. Parameters ---------- format : str The name of the format Returns ------- name : str The name of the unit for the given format. )r>rerrWr r0r0r1get_format_nameszNamedUnit.get_format_namecCs|jS)rr`r[r0r0r1rszNamedUnit.namescCs |jdS)rrrFr[r0r0r1rszNamedUnit.namecCs|jddS)rrNrFr[r0r0r1rYszNamedUnit.aliasescCs|jS)zK Returns all of the short names associated with this unit. )r<r[r0r0r1 short_namesszNamedUnit.short_namescCs|jS)zJ Returns all of the long names associated with this unit. )r=r[r0r0r1 long_names szNamedUnit.long_namescCsX|dur dS|jD],}||vr|||krtd|||q|jD] }|||<qFdS)zf Injects the unit, and all of its aliases, in the given namespace dictionary. Nz?Object with name {!r} already exists in given namespace ({!r}).)r`r=r )rWrrr0r0r1rBs  zNamedUnit._inject)NNN)N)rkrlrmrnrZr?rErorrrYrGrHrBr0r0r0r1rs' &      rcCsBtj}|d|vr ||dS||}|r:t|g|SdS)zV This is used to reconstruct units when passed around by multiprocessing. rN)rr]r)clsrZ registeredr]r/r0r0r1_recreate_irreducible_unit%s  rJc@s2eZdZdZddZeddZefddZdS) rz Irreducible units are the units that all other units are defined in terms of. Examples are meters, seconds, kilograms, amperes, etc. There is only once instance of such a unit per type. cCs*tj}t|jt|j|j|vf|fSr4)rr]rJ __class__r#rrr)rWr]r0r0r1 __reduce__Bs zIrreducibleUnit.__reduce__cCs|S)zkThe unit that this named unit represents. For an irreducible unit, that is always itself. r0r[r0r0r1 representsNszIrreducibleUnit.representsc Csxt|rt||vrt|D]N}z||}Wnty8Yq0t|rJ|St||gdgddSqtd|d|S)NrFrzUnit z/ can not be decomposed into the requested bases)r<rr rrr)rWrrrr0r0r1rVs    zIrreducibleUnit.decomposeN) rkrlrmrnrLrorMr$rr0r0r0r1r9s   rc@seZdZdZejZddZddZddZdd d Z d d Z e Z Z Z ZZZZZZZZZd dZddZdddZdddZddZddZdS)rz A unit that did not parse correctly. This allows for round-tripping it as a string, but no unit operations actually work on it. Parameters ---------- st : str The name of the unit. cCsdt|dS)NzUnrecognizedUnit(rrr[r0r0r1rzszUnrecognizedUnit.__repr__cCs|jddS)Nasciireplace)rrr[r0r0r1r}szUnrecognizedUnit.__bytes__cCs|jSr4rr[r0r0r1rszUnrecognizedUnit.__str__NcCs|jSr4rrDr0r0r1rszUnrecognizedUnit.to_stringcOstd|jdS)NzPThe unit {!r} is unrecognized, so all arithmetic operations with it are invalid.)r=r r)rWargskwargsr0r0r1_unrecognized_operators z'UnrecognizedUnit._unrecognized_operatorc CsHzt|dd}Wntttfy,tYS0t|t|oF|j|jkS)Nrr)rr=r rrr"rtrrr0r0r1rs  zUnrecognizedUnit.__eq__cCs ||k Sr4r0rr0r0r1rszUnrecognizedUnit.__ne__cCs||||kSr4)rGrr0r0r1rs zUnrecognizedUnit.is_equivalentcCs||td|jdS)NzGThe unit {!r} is unrecognized. It can not be converted to other units.)rGr=r rrr0r0r1rs  zUnrecognizedUnit._get_convertercCs|jSr4rrDr0r0r1rEsz UnrecognizedUnit.get_format_namecCsdS)NFr0r[r0r0r1rszUnrecognizedUnit.is_unity)N)N)N)rkrlrmrnobjectrLrrrrrRrrrr7r8rrrrrrrrrrrrErr0r0r0r1rjs0    rcs"eZdZdZdfdd ZZS)_UnitMetaClassz This metaclass exists because the Unit constructor should sometimes return instances that already exist. This "overrides" the constructor before the new instance is actually created, so we can return an existing one. r Nraisec sDt|dr|Sddlm}t||rXt|jr6|j}n"t|j|jj|jj |jj dd}t||rt|jrt|j}n"t|j|jj|jj |jj dd}t|t rt j |||||dSt|t r|St|ttfrt|dkrtS|durtj}t|}t|tr|d}z ||WSty8Ynty} z|d krTnb|tjurl|jd } nd } d || t| } |d krt| n |dkrt| tntdt |WYd} ~ Sd} ~ 00njt|t!t"t#j$t#j%frt|ggddSt|t&rddl'm(} | |S|dur2t)dnt)|ddS)NrarrF)rrr)r rrCrrNr r a'{}' did not parse as {}unit: {} If this is meant to be a custom unit, define it with 'u.def_unit'. To have it recognized inside a file reader or other code, enable it with 'u.add_enabled_units'. For details, see https://docs.astropy.org/en/latest/units/combining_and_defining.htmlrUrz2'parse_strict' must be 'warn', 'raise' or 'silent'r)StructuredUnitzNone is not a valid Unitz can not be converted to a Unit)*rrrr"rrur/rrrrrsuper__call__rrr<striprrrrdecodeparserrrr r=rrr rintrrZfloatingZintegerrZ structuredrWr) rWsrMr rrCrrreZ format_clausemsgrWrKr0r1rYs|                         z_UnitMetaClass.__call__)r NNNNrU)rkrlrmrnrY __classcell__r0r0rar1rTsrTc@sPeZdZdZdddZeddZefddZd d Z d d Z e d dZ dS)raU The main unit class. There are a number of different ways to construct a Unit, but always returns a `UnitBase` instance. If the arguments refer to an already-existing unit, that existing unit instance is returned, rather than a new one. - From a string:: Unit(s, format=None, parse_strict='silent') Construct from a string representing a (possibly compound) unit. The optional `format` keyword argument specifies the format the string is in, by default ``"generic"``. For a description of the available formats, see `astropy.units.format`. The optional ``parse_strict`` keyword controls what happens when an unrecognized unit string is passed in. It may be one of the following: - ``'raise'``: (default) raise a ValueError exception. - ``'warn'``: emit a Warning, and return an `UnrecognizedUnit` instance. - ``'silent'``: return an `UnrecognizedUnit` instance. - From a number:: Unit(number) Creates a dimensionless unit. - From a `UnitBase` instance:: Unit(unit) Returns the given unit unchanged. - From no arguments:: Unit() Returns the dimensionless unit. - The last form, which creates a new `Unit` is described in detail below. See also: https://docs.astropy.org/en/stable/units/ Parameters ---------- st : str or list of str The name of the unit. If a list, the first element is the canonical (short) name, and the rest of the elements are aliases. represents : UnitBase instance The unit that this named unit represents. doc : str, optional A docstring describing the unit. format : dict, optional A mapping to format-specific representations of this unit. For example, for the ``Ohm`` unit, it might be nice to have it displayed as ``\Omega`` by the ``latex`` formatter. In that case, `format` argument should be set to:: {'latex': r'\Omega'} namespace : dict, optional When provided, inject the unit (and all of its aliases) into the given namespace. Raises ------ ValueError If any of the given unit names are already in the registry. ValueError If any of the given unit names are not valid Python tokens. NcCs&t|}||_tj|||||ddS)NrrCr )r _representsrrZ)rWrcrMrCr rr0r0r1rZjs  z Unit.__init__cCs|jS)z)The unit that this named unit represents.)rdr[r0r0r1rMsszUnit.representscCs|jj|dS)Nr)rdrrr0r0r1rxszUnit.decomposecCs |jSr4)rdrr[r0r0r1r{sz Unit.is_unitycCs"|jdurt|j|jf|_|jSr4)rrdrrdr[r0r0r1r~s z Unit.__hash__csVfdd|D}dd|D}t|dkrB|ddkrB|d}ntd||dd}|S)Ncsg|]\}}|qSr0r0)rJr_rIr0r1rr8z/Unit._from_physical_type_id..cSsg|] \}}|qSr0r0)rJrer r0r0r1rr8rrFr)r<r)rIZphysical_type_idrrr/r0rfr1_from_physical_type_ids zUnit._from_physical_type_id)NNNN) rkrlrmrnrZrorMr$rrr classmethodrgr0r0r0r1rsU  r) metaclassc@seZdZdZdS)rz A unit that is simply a SI-prefixed version of another unit. For example, ``mm`` is a `PrefixUnit` of ``.001 * m``. The constructor is the same as for `Unit`. Nr~r0r0r0r1rsrcseZdZdZdZdedfddZfddZed d Z ed d Z ed dZ defddZ ddZ efddZddZZS)ra Create a composite unit using expressions of previously defined units. Direct use of this class is not recommended. Instead use the factory function `Unit` and arithmetic operators to compose units. Parameters ---------- scale : number A scaling factor for the unit. bases : sequence of `UnitBase` A sequence of units this unit is composed of. powers : sequence of numbers A sequence of powers (in parallel with ``bases``) for each of the base units. NFTc s|r.|D]}t|tstdqdd|D}|st|dkr|ddkr|d}|ddkr~||j9}|j|_|j|_nBdkrg|_g|_n,||j9}|j|_fdd|jD|_t ||_ n ||_ ||_||_|j ||ddS)Nz,bases must be sequence of UnitBase instancescSsg|] }t|qSr0)rrJrr0r0r1rr8z*CompositeUnit.__init__..rrcsg|]}tjt|qSr0)rmulr rjr r0r1rs)rr) r"rrr<rr_basesr_powersr_scale_expand_and_gather) rWrrrrdecompose_basesrrr/r0rlr1rZs:     zCompositeUnit.__init__cs4t|jrtS|jdkr,d|jdSdSdS)Nr!z#Unit(dimensionless with a scale of rzUnit(dimensionless))r<rmrXrror[rar0r1rs    zCompositeUnit.__repr__cCs|jS)z9 Return the scale of the composite unit. )ror[r0r0r1rszCompositeUnit.scalecCs|jS)z9 Return the bases of the composite unit. )rmr[r0r0r1rszCompositeUnit.basescCs|jS)z: Return the powers of the composite unit. )rnr[r0r0r1rszCompositeUnit.powersc sfdd}i|j}t|j|jD]|\}}|rF|vrF|jd}t|tr||j|9}t|j|jD]&\}}t||\} }||| ||}qlq&||||}q&ddDj dddd dD|_d dD|_t ||_dS) Nc s|rH|vrHD]6}z||||9}Wnty<Yq0|}qHq|vrpt||\}}|||<n||<|Sr4)rr r )r/r rrrErFrZ new_partsr0r1add_units  z2CompositeUnit._expand_and_gather..add_unitrcSsg|]}|ddkr|qS)rrr0rr0r0r1r r8z4CompositeUnit._expand_and_gather..cSs|d t|dddfS)Nrrrr )getattrr5r0r0r1r7 r8z2CompositeUnit._expand_and_gather..rcSsg|] }|dqSr9r0rr0r0r1r" r8cSsg|] }|dqS)rr0rr0r0r1r# r8) rorrmrnrr"rr r+rr) rWrrrsrrFrZb_subZp_subrEr0rrr1rps"   z CompositeUnit._expand_and_gathercCs"t|j|jdd|jddS)z< For compatibility with python copy module. N)rrormrnr[r0r0r1__copy__& szCompositeUnit.__copy__cCst|dkr|jdur|jS|jD]"}t|tr@t|r"||vr"q\q"t|dkrX||_|St|j|j|jd|d}t|dkr||_|S)NrT)rrq)r<_decomposed_cacherr"rrrr)rWrrr6r0r0r1r, s$    zCompositeUnit.decomposecCs |}t|jdko|jdkS)Nrr!)rr<rrrfr0r0r1r? szCompositeUnit.is_unity)rkrlrmrnrvr$rZrrorrrrprurrrbr0r0rar1rs  ,    )rYZyottagyCxDZZzettagPKDEZexagNgmCPZpetag4&k CTZteragmBGZgigageAMZmegag.ArKZkilog@@hZhectogY@ZdaZdekaZdecag$@dZdecig?cZcentig{Gz?rZmilligMbP?rmicrogư>r:Znanog& .>rZpicog-q=rZfemtogV瞯r+rbrHr<rr) rexcludesrprefixesZshortZfullZfactorrr prefixrjrrr0r0r1 _add_prefixesf s8  rcCsD|durt|||||d}nt||||d}|r@t||||d|S)a Factory function for defining new units. Parameters ---------- s : str or list of str The name of the unit. If a list, the first element is the canonical (short) name, and the rest of the elements are aliases. represents : UnitBase instance, optional The unit that this named unit represents. If not provided, a new `IrreducibleUnit` is created. doc : str, optional A docstring describing the unit. format : dict, optional A mapping to format-specific representations of this unit. For example, for the ``Ohm`` unit, it might be nice to have it displayed as ``\Omega`` by the ``latex`` formatter. In that case, `format` argument should be set to:: {'latex': r'\Omega'} prefixes : bool or list, optional When `True`, generate all of the SI prefixed versions of the unit as well. For example, for a given unit ``m``, will generate ``mm``, ``cm``, ``km``, etc. When a list, it is a list of prefix definitions of the form: (short_names, long_tables, factor) Default is `False`. This function always returns the base unit object, even if multiple scaled versions of the unit were created. exclude_prefixes : list of str, optional If any of the SI prefixes need to be excluded, they may be listed here. For example, ``Pa`` can be interpreted either as "petaannum" or "Pascal". Therefore, when defining the prefixes for ``a``, ``exclude_prefixes`` should be set to ``["P"]``. namespace : dict, optional When provided, inject the unit (and all of its aliases and prefixes), into the given namespace dictionary. Returns ------- unit : `~astropy.units.UnitBase` The newly-defined unit, or a matching unit that was already defined. Nrc)rrr)rrr)r^rMrCr rZexclude_prefixesrr,r0r0r1r s: rcCs>t|tjttttjfr|St|}|jj dvr:t d|S)at Validate value is acceptable for conversion purposes. Will convert into an array if not a scalar, and can be converted into an array Parameters ---------- value : int or float value, or sequence of such values Returns ------- Scalar value or numpy array Raises ------ ValueError If value is not as expected )rBrrzMValue not scalar compatible or convertible to an int, float, or complex array) r"rZndarrayrr]complexZvoidZarrayZdtypekindr=)ruZavaluer0r0r1r s   rcCs dt|S)zFunction that just multiplies the value by unity. This is a separate function so it can be recognized and discarded in unit conversion. r!rrr0r0r1r srr)>rnr(rr@rZnumpyrZastropy.utils.decoratorsrZastropy.utils.exceptionsrZastropy.utils.miscrZutilsrrrr r r r__all__rr2rGrHrprqrrrrrrrrr r=rrrrr rrrJrrrtrTrrrrZbinary_prefixesrrrrrr Zfitsr0r0r0r1s     *\ 58"#& '1Ai~ *                          : G