U e{j6@sVUdZddlmZddlZddlZddlmZmZmZm Z ddl Z ddl m Z m Z mZddlmZddlmZgZe edefZe eeedffZeeegefZde e d hZd ed <Gd d d ZddddddZeddddddddZdddddd Zd!d!d"d#d$Zed%d&ddd'd'd(d)d*Z ed%d&ddd'd'd(d+d,Z!dS)-z Comparison functions for `astropy.cosmology.Cosmology`. This module is **NOT** public API. To use these functions, import them from the top-level namespace -- :mod:`astropy.cosmology`. This module will be moved. ) annotationsN)AnyCallableTupleUnion)False_True_ndarray)table) Cosmology.zastropy.cosmologyzset[Any] _COSMO_AOKc@sBeZdZUdZdZejejfZde d<de d<dddd d Z d S) _CosmologyWrapperzq A private wrapper class to hide things from :mod:`numpy`. This should never be exposed to the user. wrappedztuple[type, ...]_cantbroadcastrrNone)rreturncCs ||_dSNr)selfrra/var/www/html/bwave/python/venv/lib/python3.8/site-packages/astropy/cosmology/funcs/comparison.py__init__:sz_CosmologyWrapper.__init__N) __name__ __module__ __qualname____doc__ __slots__r RowTabler__annotations__rrrrrr (s r intzCallable[[_CompFnT], np.ufunc])ninnoutrcCsddddd}|S)N_CompFnTznp.ufuncpyfuncrcSst|dd}|S)N)npZ frompyfunc)r%ZufuncrrrwrapperBsz_wrap_to_ufunc..wrapperr)r!r"r)rrr_wrap_to_ufuncAsr*r&r'r _FormatTyper )cosmoformatrcCst|tr|j}t|trJ|tkrFdttt}td|d||S|t krbt d|n|t krndn|}tj ||d}|S)aParse Cosmology-like input into Cosmologies, given a format hint. Parameters ---------- cosmo : |Cosmology|-like, positional-only |Cosmology| to parse. format : bool or None or str, positional-only Whether to allow, before equivalence is checked, the object to be converted to a |Cosmology|. This allows, e.g. a |Table| to be equivalent to a |Cosmology|. `False` (default) will not allow conversion. `True` or `None` will, and will use the auto-identification to try to infer the correct format. A `str` is assumed to be the correct format to use when converting. Returns ------- |Cosmology| or generator thereof Raises ------ TypeError If ``cosmo`` is not a |Cosmology| and ``format`` equals `False`. TypeError If ``cosmo`` is a |Cosmology| and ``format`` is not `None` or equal to `True`. /z*for parsing a Cosmology, 'format' must be z, not z9if 'format' is False, arguments must be a Cosmology, not Nr-) isinstancer rr r joinmapstr ValueErrorr TypeErrorrZ from_format)r,r-allowedoutrrr _parse_formatIs   r8object _FormatsTr )cosmosr-rcGsFttj|tdt|}dd|D}ddt||D}t||S)aParse Cosmology-like to |Cosmology|, using provided formats. ``format`` is broadcast to match the shape of the cosmology arguments. Note that the cosmology arguments are not broadcast against ``format``, so it cannot determine the output shape. Parameters ---------- *cosmos : |Cosmology|-like The objects to compare. Must be convertible to |Cosmology|, as specified by the corresponding ``format``. format : bool or None or str or array-like thereof, positional-only Whether to allow, before equivalence is checked, the object to be converted to a |Cosmology|. This allows, e.g. a |Table| to be equivalent to a |Cosmology|. `False` (default) will not allow conversion. `True` or `None` will, and will use the auto-identification to try to infer the correct format. A `str` is assumed to be the correct format to use when converting. Note ``format`` is broadcast as an object array to match the shape of ``cosmos`` so ``format`` cannot determine the output shape. Raises ------ TypeError If any in ``cosmos`` is not a |Cosmology| and the corresponding ``format`` equals `False`. )Zdtypecss|]}t|tjVqdSr)r0r r).0r,rrr sz!_parse_formats..cSs g|]\}}|s|nt|qSr)r )r<cwraprrr sz"_parse_formats..)r(Z broadcast_toarrayr9lenzipr8)r-r;formatsZtowrapZwcosmosrrr_parse_formats}s rEzCallable[..., Any]r$csPt|}tdd|jDt|dddddddfd d S) aDecorator to make wrapper function that parses |Cosmology|-like inputs. Parameters ---------- pyfunc : Python function object An arbitrary Python function. Returns ------- callable[..., Any] Wrapped `pyfunc`, as described above. Notes ----- All decorated functions should add the following to 'Parameters'. format : bool or None or str or array-like thereof, optional keyword-only Whether to allow the arguments to be converted to a |Cosmology|. This allows, e.g. a |Table| to be given instead a |Cosmology|. `False` (default) will not allow conversion. `True` or `None` will, and will use the auto-identification to try to infer the correct format. A `str` is assumed to be the correct format to use when converting. Note ``format`` is broadcast as an object array to match the shape of ``cosmos`` so ``format`` cannot determine the output shape. css|]}|jdkVqdS)rN)kind)r<prrrr=sz(_comparison_decorator..Fr/rr:bool)r;r-kwargsrcsLt|kr.tjjddt|dt|d|i}j||}|S)Nz takes z positional arguments but z were givenr-)rBr5 __wrapped__rrE)r-r;rIresultr!r)rrr)s  z&_comparison_decorator..wrapper)inspect signaturesum parametersvalues functoolswraps)r%sigrrLr_comparison_decorators  " rUFallow_equivalentrH)cosmo1cosmo2rWrcCs>|s||k}n,||}|tkr*||}|tkr6dn|}|S)a Return element-wise equality check on the cosmologies. .. note:: Cosmologies are currently scalar in their parameters. Parameters ---------- cosmo1, cosmo2 : |Cosmology|-like The objects to compare. Must be convertible to |Cosmology|, as specified by ``format``. format : bool or None or str or tuple thereof, optional keyword-only Whether to allow the arguments to be converted to a |Cosmology|. This allows, e.g. a |Table| to be given instead a |Cosmology|. `False` (default) will not allow conversion. `True` or `None` will, and will use the auto-identification to try to infer the correct format. A `str` is assumed to be the correct format to use when converting. Note ``format`` is broadcast as an object array to match the shape of ``cosmos`` so ``format`` cannot determine the output shape. allow_equivalent : bool, optional keyword-only Whether to allow cosmologies to be equal even if not of the same class. For example, an instance of |LambdaCDM| might have :math:`\Omega_0=1` and :math:`\Omega_k=0` and therefore be flat, like |FlatLambdaCDM|. Examples -------- Assuming the following imports >>> import astropy.units as u >>> from astropy.cosmology import FlatLambdaCDM Two identical cosmologies are equal. >>> cosmo1 = FlatLambdaCDM(70 * (u.km/u.s/u.Mpc), 0.3) >>> cosmo2 = FlatLambdaCDM(70 * (u.km/u.s/u.Mpc), 0.3) >>> cosmology_equal(cosmo1, cosmo2) True And cosmologies with different parameters are not. >>> cosmo3 = FlatLambdaCDM(70 * (u.km/u.s/u.Mpc), 0.4) >>> cosmology_equal(cosmo1, cosmo3) False Two cosmologies may be equivalent even if not of the same class. In these examples the |LambdaCDM| has :attr:`~astropy.cosmology.LambdaCDM.Ode0` set to the same value calculated in |FlatLambdaCDM|. >>> from astropy.cosmology import LambdaCDM >>> cosmo3 = LambdaCDM(70 * (u.km/u.s/u.Mpc), 0.3, 0.7) >>> cosmology_equal(cosmo1, cosmo3) False >>> cosmology_equal(cosmo1, cosmo3, allow_equivalent=True) True While in this example, the cosmologies are not equivalent. >>> cosmo4 = FlatLambdaCDM(70 * (u.km/u.s/u.Mpc), 0.3, Tcmb0=3 * u.K) >>> cosmology_equal(cosmo3, cosmo4, allow_equivalent=True) False Also, using the keyword argument, the notion of equality is extended to any Python object that can be converted to a |Cosmology|. >>> mapping = cosmo2.to_format("mapping") >>> cosmology_equal(cosmo1, mapping, format=True) True Either (or both) arguments can be |Cosmology|-like. >>> cosmology_equal(mapping, cosmo2, format=True) True The list of valid formats, e.g. the |Table| in this example, may be checked with ``Cosmology.from_format.list_formats()``. As can be seen in the list of formats, not all formats can be auto-identified by ``Cosmology.from_format.registry``. Objects of these kinds can still be checked for equality, but the correct format string must be used. >>> yml = cosmo2.to_format("yaml") >>> cosmology_equal(cosmo1, yml, format=(None, "yaml")) True This also works with an array of ``format`` matching the number of cosmologies. >>> cosmology_equal(mapping, yml, format=[True, "yaml"]) True F)Z __equiv__NotImplemented)rXrYrWeqrrrcosmology_equalsb   r\cCst|||d }|S)aTReturn element-wise cosmology non-equality check. .. note:: Cosmologies are currently scalar in their parameters. Parameters ---------- cosmo1, cosmo2 : |Cosmology|-like The objects to compare. Must be convertible to |Cosmology|, as specified by ``format``. out : ndarray, None, optional A location into which the result is stored. If provided, it must have a shape that the inputs broadcast to. If not provided or None, a freshly-allocated array is returned. format : bool or None or str or tuple thereof, optional keyword-only Whether to allow the arguments to be converted to a |Cosmology|. This allows, e.g. a |Table| to be given instead a Cosmology. `False` (default) will not allow conversion. `True` or `None` will, and will use the auto-identification to try to infer the correct format. A `str` is assumed to be the correct format to use when converting. ``format`` is broadcast to match the shape of the cosmology arguments. Note that the cosmology arguments are not broadcast against ``format``, so it cannot determine the output shape. allow_equivalent : bool, optional keyword-only Whether to allow cosmologies to be equal even if not of the same class. For example, an instance of |LambdaCDM| might have :math:`\Omega_0=1` and :math:`\Omega_k=0` and therefore be flat, like |FlatLambdaCDM|. See Also -------- astropy.cosmology.cosmology_equal Element-wise equality check, with argument conversion to Cosmology. rV)r\)rXrYrWZneqrrr_cosmology_not_equalOs)r])"r __future__rrRrMtypingrrrrnumpyr(rrr Zastropyr Zastropy.cosmology.corer __all__rHr3r+r:r#r rr r*r8rErUr\r]rrrrs2   3*3t