diff --git a/src/coordinax/_base.py b/src/coordinax/_base.py index a22d259..06b13c2 100644 --- a/src/coordinax/_base.py +++ b/src/coordinax/_base.py @@ -59,13 +59,13 @@ def _cartesian_cls(cls) -> type["AbstractVector"]: Examples -------- - >>> from coordinax import RadialVector, SphericalVector + >>> from coordinax import RadialPosition, SphericalPosition - >>> RadialVector._cartesian_cls - + >>> RadialPosition._cartesian_cls + - >>> SphericalVector._cartesian_cls - + >>> SphericalPosition._cartesian_cls + """ # TODO: something nicer than this for getting the corresponding class @@ -90,12 +90,12 @@ def constructor( -------- >>> import jax.numpy as jnp >>> from unxt import Quantity - >>> from coordinax import Cartesian3DVector + >>> from coordinax import CartesianPosition3D >>> xs = {"x": Quantity(1, "m"), "y": Quantity(2, "m"), "z": Quantity(3, "m")} - >>> vec = Cartesian3DVector.constructor(xs) + >>> vec = CartesianPosition3D.constructor(xs) >>> vec - Cartesian3DVector( + CartesianPosition3D( x=Quantity[PhysicalType('length')](value=f32[], unit=Unit("m")), y=Quantity[PhysicalType('length')](value=f32[], unit=Unit("m")), z=Quantity[PhysicalType('length')](value=f32[], unit=Unit("m")) @@ -103,9 +103,9 @@ def constructor( >>> xs = {"x": Quantity([1, 2], "m"), "y": Quantity([3, 4], "m"), ... "z": Quantity([5, 6], "m")} - >>> vec = Cartesian3DVector.constructor(xs) + >>> vec = CartesianPosition3D.constructor(xs) >>> vec - Cartesian3DVector( + CartesianPosition3D( x=Quantity[PhysicalType('length')](value=f32[2], unit=Unit("m")), y=Quantity[PhysicalType('length')](value=f32[2], unit=Unit("m")), z=Quantity[PhysicalType('length')](value=f32[2], unit=Unit("m")) @@ -134,21 +134,21 @@ def constructor( -------- >>> import jax.numpy as jnp >>> from unxt import Quantity - >>> from coordinax import Cartesian3DVector + >>> from coordinax import CartesianPosition3D >>> xs = Quantity([1, 2, 3], "meter") - >>> vec = Cartesian3DVector.constructor(xs) + >>> vec = CartesianPosition3D.constructor(xs) >>> vec - Cartesian3DVector( + CartesianPosition3D( x=Quantity[PhysicalType('length')](value=f32[], unit=Unit("m")), y=Quantity[PhysicalType('length')](value=f32[], unit=Unit("m")), z=Quantity[PhysicalType('length')](value=f32[], unit=Unit("m")) ) >>> xs = Quantity(jnp.array([[1, 2, 3], [4, 5, 6]]), "meter") - >>> vec = Cartesian3DVector.constructor(xs) + >>> vec = CartesianPosition3D.constructor(xs) >>> vec - Cartesian3DVector( + CartesianPosition3D( x=Quantity[PhysicalType('length')](value=f32[2], unit=Unit("m")), y=Quantity[PhysicalType('length')](value=f32[2], unit=Unit("m")), z=Quantity[PhysicalType('length')](value=f32[2], unit=Unit("m")) @@ -190,11 +190,11 @@ def __getitem__(self, index: Any) -> "Self": We assume the following imports: >>> from unxt import Quantity - >>> from coordinax import Cartesian2DVector + >>> from coordinax import CartesianPosition2D We can slice a vector: - >>> vec = Cartesian2DVector(x=Quantity([[1, 2], [3, 4]], "m"), + >>> vec = CartesianPosition2D(x=Quantity([[1, 2], [3, 4]], "m"), ... y=Quantity(0, "m")) >>> vec[0].x Quantity['length'](Array([1., 2.], dtype=float32), unit='m') @@ -212,11 +212,11 @@ def mT(self) -> "Self": # noqa: N802 We assume the following imports: >>> from unxt import Quantity - >>> from coordinax import Cartesian3DVector + >>> from coordinax import CartesianPosition3D We can transpose a vector: - >>> vec = Cartesian3DVector(x=Quantity([[0, 1], [2, 3]], "m"), + >>> vec = CartesianPosition3D(x=Quantity([[0, 1], [2, 3]], "m"), ... y=Quantity([[0, 1], [2, 3]], "m"), ... z=Quantity([[0, 1], [2, 3]], "m")) >>> vec.mT.x @@ -235,15 +235,15 @@ def ndim(self) -> int: We assume the following imports: >>> from unxt import Quantity - >>> from coordinax import Cartesian1DVector + >>> from coordinax import CartesianPosition1D We can get the number of dimensions of a vector: - >>> vec = Cartesian1DVector(x=Quantity([1, 2], "m")) + >>> vec = CartesianPosition1D(x=Quantity([1, 2], "m")) >>> vec.ndim 1 - >>> vec = Cartesian1DVector(x=Quantity([[1, 2], [3, 4]], "m")) + >>> vec = CartesianPosition1D(x=Quantity([[1, 2], [3, 4]], "m")) >>> vec.ndim 2 @@ -251,8 +251,8 @@ def ndim(self) -> int: see this by creating a 2D vector in which the components have different shapes: - >>> from coordinax import Cartesian2DVector - >>> vec = Cartesian2DVector(x=Quantity([[1, 2], [3, 4]], "m"), + >>> from coordinax import CartesianPosition2D + >>> vec = CartesianPosition2D(x=Quantity([[1, 2], [3, 4]], "m"), ... y=Quantity(0, "m")) >>> vec.ndim 2 @@ -272,15 +272,15 @@ def shape(self) -> Any: We assume the following imports: >>> from unxt import Quantity - >>> from coordinax import Cartesian1DVector + >>> from coordinax import CartesianPosition1D We can get the shape of a vector: - >>> vec = Cartesian1DVector(x=Quantity([1, 2], "m")) + >>> vec = CartesianPosition1D(x=Quantity([1, 2], "m")) >>> vec.shape (2,) - >>> vec = Cartesian1DVector(x=Quantity([[1, 2], [3, 4]], "m")) + >>> vec = CartesianPosition1D(x=Quantity([[1, 2], [3, 4]], "m")) >>> vec.shape (2, 2) @@ -288,8 +288,8 @@ def shape(self) -> Any: see this by creating a 2D vector in which the components have different shapes: - >>> from coordinax import Cartesian2DVector - >>> vec = Cartesian2DVector(x=Quantity([[1, 2], [3, 4]], "m"), + >>> from coordinax import CartesianPosition2D + >>> vec = CartesianPosition2D(x=Quantity([[1, 2], [3, 4]], "m"), ... y=Quantity(0, "m")) >>> vec.shape (2, 2) @@ -306,15 +306,15 @@ def size(self) -> int: We assume the following imports: >>> from unxt import Quantity - >>> from coordinax import Cartesian1DVector + >>> from coordinax import CartesianPosition1D We can get the size of a vector: - >>> vec = Cartesian1DVector(x=Quantity([1, 2], "m")) + >>> vec = CartesianPosition1D(x=Quantity([1, 2], "m")) >>> vec.size 2 - >>> vec = Cartesian1DVector(x=Quantity([[1, 2], [3, 4]], "m")) + >>> vec = CartesianPosition1D(x=Quantity([[1, 2], [3, 4]], "m")) >>> vec.size 4 @@ -322,8 +322,8 @@ def size(self) -> int: see this by creating a 2D vector in which the components have different shapes: - >>> from coordinax import Cartesian2DVector - >>> vec = Cartesian2DVector(x=Quantity([[1, 2], [3, 4]], "m"), + >>> from coordinax import CartesianPosition2D + >>> vec = CartesianPosition2D(x=Quantity([[1, 2], [3, 4]], "m"), ... y=Quantity(0, "m")) >>> vec.size 4 @@ -340,11 +340,11 @@ def T(self) -> "Self": # noqa: N802 We assume the following imports: >>> from unxt import Quantity - >>> from coordinax import Cartesian3DVector + >>> from coordinax import CartesianPosition3D We can transpose a vector: - >>> vec = Cartesian3DVector(x=Quantity([[0, 1], [2, 3]], "m"), + >>> vec = CartesianPosition3D(x=Quantity([[0, 1], [2, 3]], "m"), ... y=Quantity([[0, 1], [2, 3]], "m"), ... z=Quantity([[0, 1], [2, 3]], "m")) >>> vec.T.x @@ -373,13 +373,13 @@ def to_device(self, device: None | Device = None) -> "Self": >>> from jax import devices >>> from unxt import Quantity - >>> from coordinax import Cartesian1DVector + >>> from coordinax import CartesianPosition1D We can move a vector to a new device: - >>> vec = Cartesian1DVector(x=Quantity([1, 2], "m")) + >>> vec = CartesianPosition1D(x=Quantity([1, 2], "m")) >>> vec.to_device(devices()[0]) - Cartesian1DVector( + CartesianPosition1D( x=Quantity[PhysicalType('length')](value=f32[2], unit=Unit("m")) ) @@ -399,14 +399,14 @@ def flatten(self) -> "Self": We assume the following imports: >>> from unxt import Quantity - >>> from coordinax import Cartesian2DVector + >>> from coordinax import CartesianPosition2D We can flatten a vector: - >>> vec = Cartesian2DVector(x=Quantity([[1, 2], [3, 4]], "m"), + >>> vec = CartesianPosition2D(x=Quantity([[1, 2], [3, 4]], "m"), ... y=Quantity(0, "m")) >>> vec.flatten() - Cartesian2DVector( + CartesianPosition2D( x=Quantity[PhysicalType('length')](value=f32[4], unit=Unit("m")), y=Quantity[PhysicalType('length')](value=f32[1], unit=Unit("m")) ) @@ -434,15 +434,15 @@ def reshape(self, *shape: Any, order: str = "C") -> "Self": We assume the following imports: >>> from unxt import Quantity - >>> from coordinax import Cartesian2DVector + >>> from coordinax import CartesianPosition2D We can reshape a vector: - >>> vec = Cartesian2DVector(x=Quantity([[1, 2], [3, 4]], "m"), + >>> vec = CartesianPosition2D(x=Quantity([[1, 2], [3, 4]], "m"), ... y=Quantity(0, "m")) >>> vec.reshape(4) - Cartesian2DVector( + CartesianPosition2D( x=Quantity[PhysicalType('length')](value=f32[4], unit=Unit("m")), y=Quantity[PhysicalType('length')](value=f32[4], unit=Unit("m")) ) @@ -485,11 +485,11 @@ def asdict( We assume the following imports: >>> from unxt import Quantity - >>> from coordinax import Cartesian2DVector + >>> from coordinax import CartesianPosition2D We can get the vector as a mapping: - >>> vec = Cartesian2DVector(x=Quantity([[1, 2], [3, 4]], "m"), + >>> vec = CartesianPosition2D(x=Quantity([[1, 2], [3, 4]], "m"), ... y=Quantity(0, "m")) >>> vec.asdict() {'x': Quantity['length'](Array([[1., 2.], [3., 4.]], dtype=float32), unit='m'), @@ -507,15 +507,15 @@ def components(cls) -> tuple[str, ...]: -------- We assume the following imports: - >>> from coordinax import Cartesian2DVector, SphericalVector, RadialDifferential + >>> from coordinax import CartesianPosition2D, SphericalPosition, RadialVelocity We can get the components of a vector: - >>> Cartesian2DVector.components + >>> CartesianPosition2D.components ('x', 'y') - >>> SphericalVector.components + >>> SphericalPosition.components ('r', 'theta', 'phi') - >>> RadialDifferential.components + >>> RadialVelocity.components ('d_r',) """ @@ -572,9 +572,9 @@ def to_units(self, units: Any) -> "AbstractVector": >>> units = UnitSystem(u.m, u.s, u.kg, u.rad) - >>> vec = cx.Cartesian3DVector.constructor(Quantity([1, 2, 3], "km")) + >>> vec = cx.CartesianPosition3D.constructor(Quantity([1, 2, 3], "km")) >>> vec.to_units(units) - Cartesian3DVector( + CartesianPosition3D( x=Quantity[...](value=f32[], unit=Unit("m")), y=Quantity[...](value=f32[], unit=Unit("m")), z=Quantity[...](value=f32[], unit=Unit("m")) @@ -605,23 +605,23 @@ def to_units( Examples -------- >>> from unxt import Quantity - >>> from coordinax import Cartesian2DVector, SphericalVector + >>> from coordinax import CartesianPosition2D, SphericalPosition We can convert a vector to the given units: - >>> cart = Cartesian2DVector(x=Quantity(1, "m"), y=Quantity(2, "km")) + >>> cart = CartesianPosition2D(x=Quantity(1, "m"), y=Quantity(2, "km")) >>> cart.to_units({"length": "km"}) - Cartesian2DVector( + CartesianPosition2D( x=Quantity[...](value=f32[], unit=Unit("km")), y=Quantity[...](value=f32[], unit=Unit("km")) ) This also works for vectors with different units: - >>> sph = SphericalVector(r=Quantity(1, "m"), theta=Quantity(45, "deg"), + >>> sph = SphericalPosition(r=Quantity(1, "m"), theta=Quantity(45, "deg"), ... phi=Quantity(3, "rad")) >>> sph.to_units({"length": "km", "angle": "deg"}) - SphericalVector( + SphericalPosition( r=Distance(value=f32[], unit=Unit("km")), theta=Quantity[...](value=f32[], unit=Unit("deg")), phi=Quantity[...](value=f32[], unit=Unit("deg")) ) @@ -652,24 +652,24 @@ def to_units(self, _: Literal[ToUnitsOptions.consistent], /) -> "AbstractVector" Examples -------- >>> from unxt import Quantity - >>> from coordinax import Cartesian2DVector, SphericalVector + >>> from coordinax import CartesianPosition2D, SphericalPosition >>> from coordinax import ToUnitsOptions We can convert a vector to the given units: - >>> cart = Cartesian2DVector(x=Quantity(1, "m"), y=Quantity(2, "km")) + >>> cart = CartesianPosition2D(x=Quantity(1, "m"), y=Quantity(2, "km")) If all you want is to convert to consistent units, you can use ``"consistent"``: >>> cart.to_units(ToUnitsOptions.consistent) - Cartesian2DVector( + CartesianPosition2D( x=Quantity[PhysicalType('length')](value=f32[], unit=Unit("m")), y=Quantity[PhysicalType('length')](value=f32[], unit=Unit("m")) ) >>> sph.to_units(ToUnitsOptions.consistent) - SphericalVector( + SphericalPosition( r=Distance(value=f32[], unit=Unit("m")), theta=Quantity[...](value=f32[], unit=Unit("deg")), phi=Quantity[...](value=f32[], unit=Unit("deg")) ) @@ -700,9 +700,9 @@ def __str__(self) -> str: >>> from unxt import Quantity >>> import coordinax as cx - >>> vec = cx.Cartesian3DVector.constructor(Quantity([1, 2, 3], "m")) + >>> vec = cx.CartesianPosition3D.constructor(Quantity([1, 2, 3], "m")) >>> str(vec) - '' + '' """ cls_name = type(self).__name__ @@ -739,13 +739,13 @@ def constructor( # noqa: D417 -------- >>> import jax.numpy as jnp >>> from unxt import Quantity - >>> from coordinax import Cartesian3DVector + >>> from coordinax import CartesianPosition3D >>> x, y, z = Quantity(1, "meter"), Quantity(2, "meter"), Quantity(3, "meter") - >>> vec = Cartesian3DVector(x=x, y=y, z=z) - >>> cart = Cartesian3DVector.constructor(vec) + >>> vec = CartesianPosition3D(x=x, y=y, z=z) + >>> cart = CartesianPosition3D.constructor(vec) >>> cart - Cartesian3DVector( + CartesianPosition3D( x=Quantity[PhysicalType('length')](value=f32[], unit=Unit("m")), y=Quantity[PhysicalType('length')](value=f32[], unit=Unit("m")), z=Quantity[PhysicalType('length')](value=f32[], unit=Unit("m")) diff --git a/src/coordinax/_base_pos.py b/src/coordinax/_base_pos.py index 5623db8..8199c25 100644 --- a/src/coordinax/_base_pos.py +++ b/src/coordinax/_base_pos.py @@ -49,13 +49,13 @@ def differential_cls(cls) -> type["AbstractVelocity"]: Examples -------- - >>> from coordinax import RadialVector, SphericalVector + >>> from coordinax import RadialPosition, SphericalPosition - >>> RadialVector.differential_cls.__name__ - 'RadialDifferential' + >>> RadialPosition.differential_cls.__name__ + 'RadialVelocity' - >>> SphericalVector.differential_cls.__name__ - 'SphericalDifferential' + >>> SphericalPosition.differential_cls.__name__ + 'SphericalVelocity' """ raise NotImplementedError @@ -163,15 +163,15 @@ def represent_as(self, target: type[VT], /, *args: Any, **kwargs: Any) -> VT: We assume the following imports: >>> from unxt import Quantity - >>> from coordinax import Cartesian3DVector, SphericalVector + >>> from coordinax import CartesianPosition3D, SphericalPosition We can represent a vector as another type: >>> x, y, z = Quantity(1, "meter"), Quantity(2, "meter"), Quantity(3, "meter") - >>> vec = Cartesian3DVector(x=x, y=y, z=z) - >>> sph = vec.represent_as(SphericalVector) + >>> vec = CartesianPosition3D(x=x, y=y, z=z) + >>> sph = vec.represent_as(SphericalPosition) >>> sph - SphericalVector( + SphericalPosition( r=Distance(value=f32[], unit=Unit("m")), theta=Quantity[...](value=f32[], unit=Unit("rad")), phi=Quantity[...](value=f32[], unit=Unit("rad")) ) @@ -199,11 +199,11 @@ def norm(self) -> Quantity["length"]: -------- We assume the following imports: >>> from unxt import Quantity - >>> from coordinax import Cartesian3DVector + >>> from coordinax import CartesianPosition3D We can compute the norm of a vector >>> x, y, z = Quantity(1, "meter"), Quantity(2, "meter"), Quantity(3, "meter") - >>> vec = Cartesian3DVector(x=x, y=y, z=z) + >>> vec = CartesianPosition3D(x=x, y=y, z=z) >>> vec.norm() Quantity['length'](Array(3.7416575, dtype=float32), unit='m') diff --git a/src/coordinax/_base_vel.py b/src/coordinax/_base_vel.py index f7913d9..986d65b 100644 --- a/src/coordinax/_base_vel.py +++ b/src/coordinax/_base_vel.py @@ -43,13 +43,13 @@ def integral_cls(cls) -> type["AbstractPosition"]: Examples -------- - >>> from coordinax import RadialDifferential, SphericalDifferential + >>> from coordinax import RadialVelocity, SphericalVelocity - >>> RadialDifferential.integral_cls.__name__ - 'RadialVector' + >>> RadialVelocity.integral_cls.__name__ + 'RadialPosition' - >>> SphericalDifferential.integral_cls.__name__ - 'SphericalVector' + >>> SphericalVelocity.integral_cls.__name__ + 'SphericalPosition' """ raise NotImplementedError @@ -63,13 +63,13 @@ def __neg__(self) -> "Self": Examples -------- >>> from unxt import Quantity - >>> from coordinax import RadialDifferential - >>> dr = RadialDifferential(Quantity(1, "m/s")) + >>> from coordinax import RadialVelocity + >>> dr = RadialVelocity(Quantity(1, "m/s")) >>> -dr - RadialDifferential( d_r=Quantity[...]( value=i32[], unit=Unit("m / s") ) ) + RadialVelocity( d_r=Quantity[...]( value=i32[], unit=Unit("m / s") ) ) - >>> from coordinax import PolarDifferential - >>> dp = PolarDifferential(Quantity(1, "m/s"), Quantity(1, "mas/yr")) + >>> from coordinax import PolarVelocity + >>> dp = PolarVelocity(Quantity(1, "m/s"), Quantity(1, "mas/yr")) >>> neg_dp = -dp >>> neg_dp.d_r Quantity['speed'](Array(-1., dtype=float32), unit='m / s') @@ -89,12 +89,12 @@ def __mul__(self: "AbstractVelocity", other: Quantity) -> "AbstractPosition": Examples -------- >>> from unxt import Quantity - >>> from coordinax import RadialDifferential + >>> from coordinax import RadialVelocity - >>> dr = RadialDifferential(Quantity(1, "m/s")) + >>> dr = RadialVelocity(Quantity(1, "m/s")) >>> vec = dr * Quantity(2, "s") >>> vec - RadialVector(r=Distance(value=f32[], unit=Unit("m"))) + RadialPosition(r=Distance(value=f32[], unit=Unit("m"))) >>> vec.r Distance(Array(2., dtype=float32), unit='m') @@ -136,8 +136,8 @@ def __add__(self: "Self", other: Any, /) -> "Self": Examples -------- >>> from unxt import Quantity - >>> from coordinax import Cartesian3DVector, CartesianDifferential3D - >>> q = CartesianDifferential3D.constructor(Quantity([1, 2, 3], "km/s")) + >>> from coordinax import CartesianPosition3D, CartesianVelocity3D + >>> q = CartesianVelocity3D.constructor(Quantity([1, 2, 3], "km/s")) >>> q2 = q + q >>> q2.d_y Quantity['speed'](Array(4., dtype=float32), unit='km / s') @@ -157,8 +157,8 @@ def __sub__(self: "Self", other: Any, /) -> "Self": Examples -------- >>> from unxt import Quantity - >>> from coordinax import Cartesian3DVector, CartesianDifferential3D - >>> q = CartesianDifferential3D.constructor(Quantity([1, 2, 3], "km/s")) + >>> from coordinax import CartesianPosition3D, CartesianVelocity3D + >>> q = CartesianVelocity3D.constructor(Quantity([1, 2, 3], "km/s")) >>> q2 = q - q >>> q2.d_y Quantity['speed'](Array(0., dtype=float32), unit='km / s') diff --git a/src/coordinax/_d1/base.py b/src/coordinax/_d1/base.py index 8353839..4f13523 100644 --- a/src/coordinax/_d1/base.py +++ b/src/coordinax/_d1/base.py @@ -1,6 +1,6 @@ """Representation of coordinates in different systems.""" -__all__ = ["Abstract1DVector", "Abstract1DVectorDifferential"] +__all__ = ["AbstractPosition1D", "AbstractVelocity1D"] from abc import abstractmethod @@ -16,38 +16,38 @@ from coordinax._utils import classproperty -class Abstract1DVector(AbstractPosition): +class AbstractPosition1D(AbstractPosition): """Abstract representation of 1D coordinates in different systems.""" @classproperty @classmethod def _cartesian_cls(cls) -> type[AbstractVector]: - from .builtin import Cartesian1DVector + from .builtin import CartesianPosition1D - return Cartesian1DVector + return CartesianPosition1D @classproperty @classmethod @abstractmethod - def differential_cls(cls) -> type["Abstract1DVectorDifferential"]: + def differential_cls(cls) -> type["AbstractVelocity1D"]: raise NotImplementedError # TODO: move to the class in py3.11+ @AbstractPosition.constructor._f.dispatch # type: ignore[attr-defined, misc] # noqa: SLF001 def constructor( - cls: "type[Abstract1DVector]", x: Shaped[Quantity["length"], ""], / -) -> "Abstract1DVector": + cls: "type[AbstractPosition1D]", x: Shaped[Quantity["length"], ""], / +) -> "AbstractPosition1D": """Construct a 1D vector. Examples -------- >>> from unxt import Quantity - >>> from coordinax import Cartesian1DVector + >>> from coordinax import CartesianPosition1D - >>> q = Cartesian1DVector.constructor(Quantity(1, "kpc")) + >>> q = CartesianPosition1D.constructor(Quantity(1, "kpc")) >>> q - Cartesian1DVector( + CartesianPosition1D( x=Quantity[PhysicalType('length')](value=f32[1], unit=Unit("kpc")) ) @@ -55,18 +55,18 @@ def constructor( return cls(**{fields(cls)[0].name: x.reshape(1)}) -class Abstract1DVectorDifferential(AbstractVelocity): +class AbstractVelocity1D(AbstractVelocity): """Abstract representation of 1D differentials in different systems.""" @classproperty @classmethod def _cartesian_cls(cls) -> type[AbstractVector]: - from .builtin import CartesianDifferential1D + from .builtin import CartesianVelocity1D - return CartesianDifferential1D + return CartesianVelocity1D @classproperty @classmethod @abstractmethod - def integral_cls(cls) -> type[Abstract1DVector]: + def integral_cls(cls) -> type[AbstractPosition1D]: raise NotImplementedError diff --git a/src/coordinax/_d1/builtin.py b/src/coordinax/_d1/builtin.py index a3e5745..eb7af29 100644 --- a/src/coordinax/_d1/builtin.py +++ b/src/coordinax/_d1/builtin.py @@ -2,11 +2,11 @@ __all__ = [ # Position - "Cartesian1DVector", - "RadialVector", + "CartesianPosition1D", + "RadialPosition", # Differential - "CartesianDifferential1D", - "RadialDifferential", + "CartesianVelocity1D", + "RadialVelocity", ] from dataclasses import replace @@ -20,7 +20,7 @@ from unxt import AbstractDistance, Distance, Quantity import coordinax._typing as ct -from .base import Abstract1DVector, Abstract1DVectorDifferential +from .base import AbstractPosition1D, AbstractVelocity1D from coordinax._base_pos import AbstractPosition from coordinax._checks import check_r_non_negative from coordinax._utils import classproperty @@ -30,7 +30,7 @@ @final -class Cartesian1DVector(Abstract1DVector): +class CartesianPosition1D(AbstractPosition1D): """Cartesian vector representation.""" x: ct.BatchableLength = eqx.field( @@ -40,8 +40,8 @@ class Cartesian1DVector(Abstract1DVector): @classproperty @classmethod - def differential_cls(cls) -> type["CartesianDifferential1D"]: - return CartesianDifferential1D + def differential_cls(cls) -> type["CartesianVelocity1D"]: + return CartesianVelocity1D # ----------------------------------------------------- # Unary operations @@ -52,10 +52,10 @@ def __neg__(self) -> "Self": Examples -------- >>> from unxt import Quantity - >>> from coordinax import Cartesian1DVector - >>> q = Cartesian1DVector.constructor(Quantity([1], "kpc")) + >>> from coordinax import CartesianPosition1D + >>> q = CartesianPosition1D.constructor(Quantity([1], "kpc")) >>> -q - Cartesian1DVector( + CartesianPosition1D( x=Quantity[PhysicalType('length')](value=f32[], unit=Unit("kpc")) ) @@ -65,19 +65,19 @@ def __neg__(self) -> "Self": # ----------------------------------------------------- # Binary operations - def __add__(self, other: Any, /) -> "Cartesian1DVector": + def __add__(self, other: Any, /) -> "CartesianPosition1D": """Add two vectors. Examples -------- >>> from unxt import Quantity - >>> from coordinax import Cartesian1DVector, RadialVector + >>> from coordinax import CartesianPosition1D, RadialPosition - >>> q = Cartesian1DVector.constructor(Quantity([1], "kpc")) - >>> r = RadialVector.constructor(Quantity([1], "kpc")) + >>> q = CartesianPosition1D.constructor(Quantity([1], "kpc")) + >>> r = RadialPosition.constructor(Quantity([1], "kpc")) >>> qpr = q + r >>> qpr - Cartesian1DVector( + CartesianPosition1D( x=Quantity[PhysicalType('length')](value=f32[], unit=Unit("kpc")) ) >>> qpr.x @@ -85,25 +85,25 @@ def __add__(self, other: Any, /) -> "Cartesian1DVector": """ if not isinstance(other, AbstractPosition): - msg = f"Cannot add {Cartesian1DVector!r} and {type(other)!r}." + msg = f"Cannot add {CartesianPosition1D!r} and {type(other)!r}." raise TypeError(msg) - cart = other.represent_as(Cartesian1DVector) + cart = other.represent_as(CartesianPosition1D) return replace(self, x=self.x + cart.x) - def __sub__(self, other: Any, /) -> "Cartesian1DVector": + def __sub__(self, other: Any, /) -> "CartesianPosition1D": """Subtract two vectors. Examples -------- >>> from unxt import Quantity - >>> from coordinax import Cartesian1DVector, RadialVector + >>> from coordinax import CartesianPosition1D, RadialPosition - >>> q = Cartesian1DVector.constructor(Quantity([1], "kpc")) - >>> r = RadialVector.constructor(Quantity([1], "kpc")) + >>> q = CartesianPosition1D.constructor(Quantity([1], "kpc")) + >>> r = RadialPosition.constructor(Quantity([1], "kpc")) >>> qmr = q - r >>> qmr - Cartesian1DVector( + CartesianPosition1D( x=Quantity[PhysicalType('length')](value=f32[], unit=Unit("kpc")) ) >>> qmr.x @@ -111,10 +111,10 @@ def __sub__(self, other: Any, /) -> "Cartesian1DVector": """ if not isinstance(other, AbstractPosition): - msg = f"Cannot subtract {Cartesian1DVector!r} and {type(other)!r}." + msg = f"Cannot subtract {CartesianPosition1D!r} and {type(other)!r}." raise TypeError(msg) - cart = other.represent_as(Cartesian1DVector) + cart = other.represent_as(CartesianPosition1D) return replace(self, x=self.x - cart.x) @partial(jax.jit) @@ -124,9 +124,9 @@ def norm(self) -> ct.BatchableLength: Examples -------- >>> from unxt import Quantity - >>> from coordinax import Cartesian1DVector, RadialVector + >>> from coordinax import CartesianPosition1D, RadialPosition - >>> q = Cartesian1DVector.constructor(Quantity([-1], "kpc")) + >>> q = CartesianPosition1D.constructor(Quantity([-1], "kpc")) >>> q.norm() Quantity['length'](Array(1., dtype=float32), unit='kpc') @@ -135,7 +135,7 @@ def norm(self) -> ct.BatchableLength: @final -class RadialVector(Abstract1DVector): +class RadialPosition(AbstractPosition1D): """Radial vector representation.""" r: ct.BatchableDistance = eqx.field( @@ -151,8 +151,8 @@ def __check_init__(self) -> None: @classproperty @classmethod - def differential_cls(cls) -> type["RadialDifferential"]: - return RadialDifferential + def differential_cls(cls) -> type["RadialVelocity"]: + return RadialVelocity ############################################################################## @@ -160,7 +160,7 @@ def differential_cls(cls) -> type["RadialDifferential"]: @final -class CartesianDifferential1D(Abstract1DVectorDifferential): +class CartesianVelocity1D(AbstractVelocity1D): """Cartesian differential representation.""" d_x: ct.BatchableSpeed = eqx.field(converter=Quantity["speed"].constructor) @@ -168,18 +168,18 @@ class CartesianDifferential1D(Abstract1DVectorDifferential): @classproperty @classmethod - def integral_cls(cls) -> type[Cartesian1DVector]: - return Cartesian1DVector + def integral_cls(cls) -> type[CartesianPosition1D]: + return CartesianPosition1D @partial(jax.jit) - def norm(self, _: Abstract1DVector | None = None, /) -> ct.BatchableSpeed: + def norm(self, _: AbstractPosition1D | None = None, /) -> ct.BatchableSpeed: """Return the norm of the vector. Examples -------- >>> from unxt import Quantity - >>> from coordinax import CartesianDifferential1D - >>> q = CartesianDifferential1D.constructor(Quantity([-1], "km/s")) + >>> from coordinax import CartesianVelocity1D + >>> q = CartesianVelocity1D.constructor(Quantity([-1], "km/s")) >>> q.norm() Quantity['speed'](Array(1, dtype=int32), unit='km / s') @@ -188,7 +188,7 @@ def norm(self, _: Abstract1DVector | None = None, /) -> ct.BatchableSpeed: @final -class RadialDifferential(Abstract1DVectorDifferential): +class RadialVelocity(AbstractVelocity1D): """Radial differential representation.""" d_r: ct.BatchableSpeed = eqx.field(converter=Quantity["speed"].constructor) @@ -196,5 +196,5 @@ class RadialDifferential(Abstract1DVectorDifferential): @classproperty @classmethod - def integral_cls(cls) -> type[RadialVector]: - return RadialVector + def integral_cls(cls) -> type[RadialPosition]: + return RadialPosition diff --git a/src/coordinax/_d1/compat.py b/src/coordinax/_d1/compat.py index 2d9bdb5..5b09638 100644 --- a/src/coordinax/_d1/compat.py +++ b/src/coordinax/_d1/compat.py @@ -9,24 +9,22 @@ import quaxed.array_api as xp from unxt import Quantity -from .base import Abstract1DVector -from .builtin import Cartesian1DVector, CartesianDifferential1D +from .base import AbstractPosition1D +from .builtin import CartesianPosition1D, CartesianVelocity1D from coordinax._utils import dataclass_values, full_shaped ##################################################################### # Quantity -@conversion_method(type_from=Abstract1DVector, type_to=Quantity) # type: ignore[misc] -def vec_to_q(obj: Abstract1DVector, /) -> Shaped[Quantity["length"], "*batch 1"]: - """`coordinax.Abstract1DVector` -> `unxt.Quantity`.""" - cart = full_shaped(obj.represent_as(Cartesian1DVector)) +@conversion_method(type_from=AbstractPosition1D, type_to=Quantity) # type: ignore[misc] +def vec_to_q(obj: AbstractPosition1D, /) -> Shaped[Quantity["length"], "*batch 1"]: + """`coordinax.AbstractPosition1D` -> `unxt.Quantity`.""" + cart = full_shaped(obj.represent_as(CartesianPosition1D)) return xp.stack(tuple(dataclass_values(cart)), axis=-1) -@conversion_method(type_from=CartesianDifferential1D, type_to=Quantity) # type: ignore[misc] -def vec_diff_to_q( - obj: CartesianDifferential1D, / -) -> Shaped[Quantity["speed"], "*batch 1"]: - """`coordinax.CartesianDifferential1D` -> `unxt.Quantity`.""" +@conversion_method(type_from=CartesianVelocity1D, type_to=Quantity) # type: ignore[misc] +def vec_diff_to_q(obj: CartesianVelocity1D, /) -> Shaped[Quantity["speed"], "*batch 1"]: + """`coordinax.CartesianVelocity1D` -> `unxt.Quantity`.""" return xp.stack(tuple(dataclass_values(full_shaped(obj))), axis=-1) diff --git a/src/coordinax/_d1/operate.py b/src/coordinax/_d1/operate.py index 873ed71..4162eed 100644 --- a/src/coordinax/_d1/operate.py +++ b/src/coordinax/_d1/operate.py @@ -10,7 +10,7 @@ from unxt import Quantity -from .builtin import Cartesian1DVector +from .builtin import CartesianPosition1D from coordinax._typing import TimeBatchOrScalar from coordinax.operators._base import AbstractOperator, op_call_dispatch @@ -20,7 +20,7 @@ @op_call_dispatch def call(self: AbstractOperator, x: Q1, /) -> Q1: """Dispatch to the operator's `__call__` method.""" - return self(Cartesian1DVector.constructor(x)) + return self(CartesianPosition1D.constructor(x)) @op_call_dispatch @@ -28,5 +28,5 @@ def call( self: AbstractOperator, x: Q1, t: TimeBatchOrScalar, / ) -> tuple[Q1, TimeBatchOrScalar]: """Dispatch to the operator's `__call__` method.""" - vec, t = self(Cartesian1DVector.constructor(x), t) + vec, t = self(CartesianPosition1D.constructor(x), t) return convert(vec, Quantity), t diff --git a/src/coordinax/_d1/transform.py b/src/coordinax/_d1/transform.py index 8903b5c..5a7c40a 100644 --- a/src/coordinax/_d1/transform.py +++ b/src/coordinax/_d1/transform.py @@ -6,12 +6,12 @@ from plum import dispatch -from .base import Abstract1DVector, Abstract1DVectorDifferential +from .base import AbstractPosition1D, AbstractVelocity1D from .builtin import ( - Cartesian1DVector, - CartesianDifferential1D, - RadialDifferential, - RadialVector, + CartesianPosition1D, + CartesianVelocity1D, + RadialPosition, + RadialVelocity, ) from coordinax._base_pos import AbstractPosition @@ -21,56 +21,56 @@ @dispatch(precedence=1) def represent_as( - current: Cartesian1DVector, target: type[Cartesian1DVector], /, **kwargs: Any -) -> Cartesian1DVector: + current: CartesianPosition1D, target: type[CartesianPosition1D], /, **kwargs: Any +) -> CartesianPosition1D: """Self transform of 1D vectors.""" return current @dispatch(precedence=1) def represent_as( - current: RadialVector, target: type[RadialVector], /, **kwargs: Any -) -> RadialVector: + current: RadialPosition, target: type[RadialPosition], /, **kwargs: Any +) -> RadialPosition: """Self transform of 1D vectors.""" return current @dispatch def represent_as( - current: Abstract1DVector, target: type[Abstract1DVector], /, **kwargs: Any -) -> Abstract1DVector: - """Abstract1DVector -> Cartesian1D -> Abstract1DVector. + current: AbstractPosition1D, target: type[AbstractPosition1D], /, **kwargs: Any +) -> AbstractPosition1D: + """AbstractPosition1D -> Cartesian1D -> AbstractPosition1D. This is the base case for the transformation of 1D vectors. """ - cart1d = represent_as(current, Cartesian1DVector) + cart1d = represent_as(current, CartesianPosition1D) return represent_as(cart1d, target) @dispatch.multi( - (CartesianDifferential1D, type[CartesianDifferential1D], AbstractPosition), - (RadialDifferential, type[RadialDifferential], AbstractPosition), + (CartesianVelocity1D, type[CartesianVelocity1D], AbstractPosition), + (RadialVelocity, type[RadialVelocity], AbstractPosition), ) def represent_as( - current: Abstract1DVectorDifferential, - target: type[Abstract1DVectorDifferential], + current: AbstractVelocity1D, + target: type[AbstractVelocity1D], position: AbstractPosition, /, **kwargs: Any, -) -> Abstract1DVectorDifferential: +) -> AbstractVelocity1D: """Self transform of 1D Differentials.""" return current # ============================================================================= -# Cartesian1DVector +# CartesianPosition1D @dispatch def represent_as( - current: Cartesian1DVector, target: type[RadialVector], /, **kwargs: Any -) -> RadialVector: - """Cartesian1DVector -> RadialVector. + current: CartesianPosition1D, target: type[RadialPosition], /, **kwargs: Any +) -> RadialPosition: + """CartesianPosition1D -> RadialPosition. The `x` coordinate is converted to the radial coordinate `r`. """ @@ -78,14 +78,14 @@ def represent_as( # ============================================================================= -# RadialVector +# RadialPosition @dispatch def represent_as( - current: RadialVector, target: type[Cartesian1DVector], /, **kwargs: Any -) -> Cartesian1DVector: - """RadialVector -> Cartesian1DVector. + current: RadialPosition, target: type[CartesianPosition1D], /, **kwargs: Any +) -> CartesianPosition1D: + """RadialPosition -> CartesianPosition1D. The `r` coordinate is converted to the `x` coordinate of the 1D system. """ diff --git a/src/coordinax/_d2/base.py b/src/coordinax/_d2/base.py index 71c77f3..bb9ff22 100644 --- a/src/coordinax/_d2/base.py +++ b/src/coordinax/_d2/base.py @@ -1,6 +1,6 @@ """Representation of coordinates in different systems.""" -__all__ = ["Abstract2DVector", "Abstract2DVectorDifferential"] +__all__ = ["AbstractPosition2D", "AbstractVelocity2D"] from abc import abstractmethod @@ -11,35 +11,35 @@ from coordinax._utils import classproperty -class Abstract2DVector(AbstractPosition): +class AbstractPosition2D(AbstractPosition): """Abstract representation of 2D coordinates in different systems.""" @classproperty @classmethod def _cartesian_cls(cls) -> type[AbstractVector]: - from .builtin import Cartesian2DVector + from .builtin import CartesianPosition2D - return Cartesian2DVector + return CartesianPosition2D @classproperty @classmethod @abstractmethod - def differential_cls(cls) -> type["Abstract2DVectorDifferential"]: + def differential_cls(cls) -> type["AbstractVelocity2D"]: raise NotImplementedError -class Abstract2DVectorDifferential(AbstractVelocity): +class AbstractVelocity2D(AbstractVelocity): """Abstract representation of 2D vector differentials.""" @classproperty @classmethod def _cartesian_cls(cls) -> type[AbstractVector]: - from .builtin import CartesianDifferential2D + from .builtin import CartesianVelocity2D - return CartesianDifferential2D + return CartesianVelocity2D @classproperty @classmethod @abstractmethod - def integral_cls(cls) -> type[Abstract2DVector]: + def integral_cls(cls) -> type[AbstractPosition2D]: raise NotImplementedError diff --git a/src/coordinax/_d2/builtin.py b/src/coordinax/_d2/builtin.py index aa63171..6459951 100644 --- a/src/coordinax/_d2/builtin.py +++ b/src/coordinax/_d2/builtin.py @@ -2,11 +2,11 @@ __all__ = [ # Position - "Cartesian2DVector", - "PolarVector", + "CartesianPosition2D", + "PolarPosition", # Differential - "CartesianDifferential2D", - "PolarDifferential", + "CartesianVelocity2D", + "PolarVelocity", ] from dataclasses import replace @@ -20,7 +20,7 @@ from unxt import AbstractDistance, Distance, Quantity import coordinax._typing as ct -from .base import Abstract2DVector, Abstract2DVectorDifferential +from .base import AbstractPosition2D, AbstractVelocity2D from coordinax._base_pos import AbstractPosition from coordinax._checks import check_azimuth_range, check_r_non_negative from coordinax._converters import converter_azimuth_to_range @@ -31,7 +31,7 @@ @final -class Cartesian2DVector(Abstract2DVector): +class CartesianPosition2D(AbstractPosition2D): """Cartesian vector representation.""" x: ct.BatchableLength = eqx.field( @@ -46,8 +46,8 @@ class Cartesian2DVector(Abstract2DVector): @classproperty @classmethod - def differential_cls(cls) -> type["CartesianDifferential2D"]: - return CartesianDifferential2D + def differential_cls(cls) -> type["CartesianVelocity2D"]: + return CartesianVelocity2D # ----------------------------------------------------- # Unary operations @@ -58,9 +58,9 @@ def __neg__(self) -> "Self": Examples -------- >>> from unxt import Quantity - >>> from coordinax import Cartesian2DVector + >>> from coordinax import CartesianPosition2D - >>> q = Cartesian2DVector.constructor(Quantity([1, 2], "kpc")) + >>> q = CartesianPosition2D.constructor(Quantity([1, 2], "kpc")) >>> (-q).x Quantity['length'](Array(-1., dtype=float32), unit='kpc') @@ -70,46 +70,46 @@ def __neg__(self) -> "Self": # ----------------------------------------------------- # Binary operations - def __add__(self, other: Any, /) -> "Cartesian2DVector": + def __add__(self, other: Any, /) -> "CartesianPosition2D": """Add two vectors. Examples -------- >>> from unxt import Quantity - >>> from coordinax import Cartesian2DVector, PolarVector - >>> cart = Cartesian2DVector.constructor(Quantity([1, 2], "kpc")) - >>> polr = PolarVector(r=Quantity(3, "kpc"), phi=Quantity(90, "deg")) + >>> from coordinax import CartesianPosition2D, PolarPosition + >>> cart = CartesianPosition2D.constructor(Quantity([1, 2], "kpc")) + >>> polr = PolarPosition(r=Quantity(3, "kpc"), phi=Quantity(90, "deg")) >>> (cart + polr).x Quantity['length'](Array(0.9999999, dtype=float32), unit='kpc') """ if not isinstance(other, AbstractPosition): - msg = f"Cannot add {Cartesian2DVector!r} and {type(other)!r}." + msg = f"Cannot add {CartesianPosition2D!r} and {type(other)!r}." raise TypeError(msg) - cart = other.represent_as(Cartesian2DVector) + cart = other.represent_as(CartesianPosition2D) return replace(self, x=self.x + cart.x, y=self.y + cart.y) - def __sub__(self, other: Any, /) -> "Cartesian2DVector": + def __sub__(self, other: Any, /) -> "CartesianPosition2D": """Subtract two vectors. Examples -------- >>> from unxt import Quantity - >>> from coordinax import Cartesian2DVector, PolarVector - >>> cart = Cartesian2DVector.constructor(Quantity([1, 2], "kpc")) - >>> polr = PolarVector(r=Quantity(3, "kpc"), phi=Quantity(90, "deg")) + >>> from coordinax import CartesianPosition2D, PolarPosition + >>> cart = CartesianPosition2D.constructor(Quantity([1, 2], "kpc")) + >>> polr = PolarPosition(r=Quantity(3, "kpc"), phi=Quantity(90, "deg")) >>> (cart - polr).x Quantity['length'](Array(1.0000001, dtype=float32), unit='kpc') """ if not isinstance(other, AbstractPosition): - msg = f"Cannot subtract {Cartesian2DVector!r} and {type(other)!r}." + msg = f"Cannot subtract {CartesianPosition2D!r} and {type(other)!r}." raise TypeError(msg) - cart = other.represent_as(Cartesian2DVector) + cart = other.represent_as(CartesianPosition2D) return replace(self, x=self.x - cart.x, y=self.y - cart.y) @partial(jax.jit) @@ -119,8 +119,8 @@ def norm(self) -> ct.BatchableLength: Examples -------- >>> from unxt import Quantity - >>> from coordinax import Cartesian2DVector - >>> q = Cartesian2DVector.constructor(Quantity([3, 4], "kpc")) + >>> from coordinax import CartesianPosition2D + >>> q = CartesianPosition2D.constructor(Quantity([3, 4], "kpc")) >>> q.norm() Quantity['length'](Array(5., dtype=float32), unit='kpc') @@ -129,7 +129,7 @@ def norm(self) -> ct.BatchableLength: @final -class PolarVector(Abstract2DVector): +class PolarPosition(AbstractPosition2D): r"""Polar vector representation. Parameters @@ -163,8 +163,8 @@ def __check_init__(self) -> None: @classproperty @classmethod - def differential_cls(cls) -> type["PolarDifferential"]: - return PolarDifferential + def differential_cls(cls) -> type["PolarVelocity"]: + return PolarVelocity @partial(jax.jit) def norm(self) -> ct.BatchableLength: @@ -174,7 +174,7 @@ def norm(self) -> ct.BatchableLength: -------- >>> from unxt import Quantity >>> import coordinax as cx - >>> q = cx.PolarVector(r=Quantity(3, "kpc"), phi=Quantity(90, "deg")) + >>> q = cx.PolarPosition(r=Quantity(3, "kpc"), phi=Quantity(90, "deg")) >>> q.norm() Distance(Array(3., dtype=float32), unit='kpc') @@ -186,7 +186,7 @@ def norm(self) -> ct.BatchableLength: @final -class CartesianDifferential2D(Abstract2DVectorDifferential): +class CartesianVelocity2D(AbstractVelocity2D): """Cartesian differential representation.""" d_x: ct.BatchableSpeed = eqx.field( @@ -201,18 +201,18 @@ class CartesianDifferential2D(Abstract2DVectorDifferential): @classproperty @classmethod - def integral_cls(cls) -> type[Cartesian2DVector]: - return Cartesian2DVector + def integral_cls(cls) -> type[CartesianPosition2D]: + return CartesianPosition2D @partial(jax.jit) - def norm(self, _: Abstract2DVector | None = None, /) -> ct.BatchableSpeed: + def norm(self, _: AbstractPosition2D | None = None, /) -> ct.BatchableSpeed: """Return the norm of the vector. Examples -------- >>> from unxt import Quantity - >>> from coordinax import CartesianDifferential2D - >>> v = CartesianDifferential2D.constructor(Quantity([3, 4], "km/s")) + >>> from coordinax import CartesianVelocity2D + >>> v = CartesianVelocity2D.constructor(Quantity([3, 4], "km/s")) >>> v.norm() Quantity['speed'](Array(5., dtype=float32), unit='km / s') @@ -221,7 +221,7 @@ def norm(self, _: Abstract2DVector | None = None, /) -> ct.BatchableSpeed: @final -class PolarDifferential(Abstract2DVectorDifferential): +class PolarVelocity(AbstractVelocity2D): """Polar differential representation.""" d_r: ct.BatchableSpeed = eqx.field( @@ -236,5 +236,5 @@ class PolarDifferential(Abstract2DVectorDifferential): @classproperty @classmethod - def integral_cls(cls) -> type[PolarVector]: - return PolarVector + def integral_cls(cls) -> type[PolarPosition]: + return PolarPosition diff --git a/src/coordinax/_d2/compat.py b/src/coordinax/_d2/compat.py index 09c6ae8..0748207 100644 --- a/src/coordinax/_d2/compat.py +++ b/src/coordinax/_d2/compat.py @@ -9,24 +9,22 @@ import quaxed.array_api as xp from unxt import Quantity -from .base import Abstract2DVector -from .builtin import Cartesian2DVector, CartesianDifferential2D +from .base import AbstractPosition2D +from .builtin import CartesianPosition2D, CartesianVelocity2D from coordinax._utils import dataclass_values, full_shaped ##################################################################### # Quantity -@conversion_method(type_from=Abstract2DVector, type_to=Quantity) # type: ignore[misc] -def vec_to_q(obj: Abstract2DVector, /) -> Shaped[Quantity["length"], "*batch 2"]: - """`coordinax.Abstract2DVector` -> `unxt.Quantity`.""" - cart = full_shaped(obj.represent_as(Cartesian2DVector)) +@conversion_method(type_from=AbstractPosition2D, type_to=Quantity) # type: ignore[misc] +def vec_to_q(obj: AbstractPosition2D, /) -> Shaped[Quantity["length"], "*batch 2"]: + """`coordinax.AbstractPosition2D` -> `unxt.Quantity`.""" + cart = full_shaped(obj.represent_as(CartesianPosition2D)) return xp.stack(tuple(dataclass_values(cart)), axis=-1) -@conversion_method(type_from=CartesianDifferential2D, type_to=Quantity) # type: ignore[misc] -def vec_diff_to_q( - obj: CartesianDifferential2D, / -) -> Shaped[Quantity["speed"], "*batch 2"]: - """`coordinax.CartesianDifferential2D` -> `unxt.Quantity`.""" +@conversion_method(type_from=CartesianVelocity2D, type_to=Quantity) # type: ignore[misc] +def vec_diff_to_q(obj: CartesianVelocity2D, /) -> Shaped[Quantity["speed"], "*batch 2"]: + """`coordinax.CartesianVelocity2D` -> `unxt.Quantity`.""" return xp.stack(tuple(dataclass_values(full_shaped(obj))), axis=-1) diff --git a/src/coordinax/_d2/operate.py b/src/coordinax/_d2/operate.py index 32d699a..f2c1cef 100644 --- a/src/coordinax/_d2/operate.py +++ b/src/coordinax/_d2/operate.py @@ -10,7 +10,7 @@ from unxt import Quantity -from .builtin import Cartesian2DVector +from .builtin import CartesianPosition2D from coordinax._typing import TimeBatchOrScalar from coordinax.operators._base import AbstractOperator, op_call_dispatch @@ -20,7 +20,7 @@ @op_call_dispatch def call(self: AbstractOperator, x: Q2, /) -> Q2: """Dispatch to the operator's `__call__` method.""" - return self(Cartesian2DVector.constructor(x)) + return self(CartesianPosition2D.constructor(x)) @op_call_dispatch @@ -28,5 +28,5 @@ def call( self: AbstractOperator, x: Q2, t: TimeBatchOrScalar, / ) -> tuple[Q2, TimeBatchOrScalar]: """Dispatch to the operator's `__call__` method.""" - vec, t = self(Cartesian2DVector.constructor(x), t) + vec, t = self(CartesianPosition2D.constructor(x), t) return convert(vec, Quantity), t diff --git a/src/coordinax/_d2/transform.py b/src/coordinax/_d2/transform.py index 7107dd3..131797e 100644 --- a/src/coordinax/_d2/transform.py +++ b/src/coordinax/_d2/transform.py @@ -8,55 +8,55 @@ import quaxed.array_api as xp -from .base import Abstract2DVector, Abstract2DVectorDifferential +from .base import AbstractPosition2D, AbstractVelocity2D from .builtin import ( - Cartesian2DVector, - CartesianDifferential2D, - PolarDifferential, - PolarVector, + CartesianPosition2D, + CartesianVelocity2D, + PolarPosition, + PolarVelocity, ) from coordinax._base_pos import AbstractPosition @dispatch def represent_as( - current: Abstract2DVector, target: type[Abstract2DVector], /, **kwargs: Any -) -> Abstract2DVector: - """Abstract2DVector -> Cartesian2D -> Abstract2DVector. + current: AbstractPosition2D, target: type[AbstractPosition2D], /, **kwargs: Any +) -> AbstractPosition2D: + """AbstractPosition2D -> Cartesian2D -> AbstractPosition2D. This is the base case for the transformation of 2D vectors. """ - return represent_as(represent_as(current, Cartesian2DVector), target) + return represent_as(represent_as(current, CartesianPosition2D), target) @dispatch.multi( - (Cartesian2DVector, type[Cartesian2DVector]), - (PolarVector, type[PolarVector]), + (CartesianPosition2D, type[CartesianPosition2D]), + (PolarPosition, type[PolarPosition]), ) def represent_as( - current: Abstract2DVector, target: type[Abstract2DVector], /, **kwargs: Any -) -> Abstract2DVector: + current: AbstractPosition2D, target: type[AbstractPosition2D], /, **kwargs: Any +) -> AbstractPosition2D: """Self transform of 2D vectors.""" return current @dispatch.multi( - (CartesianDifferential2D, type[CartesianDifferential2D], AbstractPosition), - (PolarDifferential, type[PolarDifferential], AbstractPosition), + (CartesianVelocity2D, type[CartesianVelocity2D], AbstractPosition), + (PolarVelocity, type[PolarVelocity], AbstractPosition), ) def represent_as( - current: Abstract2DVectorDifferential, - target: type[Abstract2DVectorDifferential], + current: AbstractVelocity2D, + target: type[AbstractVelocity2D], position: AbstractPosition, /, **kwargs: Any, -) -> Abstract2DVectorDifferential: +) -> AbstractVelocity2D: """Self transform of 2D Differentials.""" return current # ============================================================================= -# Cartesian2DVector +# CartesianPosition2D # ----------------------------------------------- # 2D @@ -64,9 +64,9 @@ def represent_as( @dispatch def represent_as( - current: Cartesian2DVector, target: type[PolarVector], /, **kwargs: Any -) -> PolarVector: - """Cartesian2DVector -> PolarVector. + current: CartesianPosition2D, target: type[PolarPosition], /, **kwargs: Any +) -> PolarPosition: + """CartesianPosition2D -> PolarPosition. The `x` and `y` coordinates are converted to the radial coordinate `r` and the angular coordinate `phi`. @@ -77,7 +77,7 @@ def represent_as( # ============================================================================= -# PolarVector +# PolarPosition # ----------------------------------------------- # 2D @@ -85,9 +85,9 @@ def represent_as( @dispatch def represent_as( - current: PolarVector, target: type[Cartesian2DVector], /, **kwargs: Any -) -> Cartesian2DVector: - """PolarVector -> Cartesian2DVector.""" + current: PolarPosition, target: type[CartesianPosition2D], /, **kwargs: Any +) -> CartesianPosition2D: + """PolarPosition -> CartesianPosition2D.""" x = current.r.distance * xp.cos(current.phi) y = current.r.distance * xp.sin(current.phi) return target(x=x, y=y) diff --git a/src/coordinax/_d3/base.py b/src/coordinax/_d3/base.py index a0d83ec..31a531f 100644 --- a/src/coordinax/_d3/base.py +++ b/src/coordinax/_d3/base.py @@ -1,6 +1,6 @@ """Representation of coordinates in different systems.""" -__all__ = ["Abstract3DVector", "Abstract3DVectorDifferential"] +__all__ = ["AbstractPosition3D", "AbstractVelocity3D"] from abc import abstractmethod @@ -13,36 +13,36 @@ from coordinax._utils import classproperty -class Abstract3DVector(AbstractPosition): +class AbstractPosition3D(AbstractPosition): """Abstract representation of 3D coordinates in different systems.""" @override @classproperty @classmethod def _cartesian_cls(cls) -> type[AbstractVector]: - from .builtin import Cartesian3DVector + from .builtin import CartesianPosition3D - return Cartesian3DVector + return CartesianPosition3D @classproperty @classmethod @abstractmethod - def differential_cls(cls) -> type["Abstract3DVectorDifferential"]: + def differential_cls(cls) -> type["AbstractVelocity3D"]: raise NotImplementedError -class Abstract3DVectorDifferential(AbstractVelocity): +class AbstractVelocity3D(AbstractVelocity): """Abstract representation of 3D vector differentials.""" @classproperty @classmethod def _cartesian_cls(cls) -> type[AbstractVector]: - from .builtin import CartesianDifferential3D + from .builtin import CartesianVelocity3D - return CartesianDifferential3D + return CartesianVelocity3D @classproperty @classmethod @abstractmethod - def integral_cls(cls) -> type[Abstract3DVector]: + def integral_cls(cls) -> type[AbstractPosition3D]: raise NotImplementedError diff --git a/src/coordinax/_d3/builtin.py b/src/coordinax/_d3/builtin.py index d75ae81..f6055b9 100644 --- a/src/coordinax/_d3/builtin.py +++ b/src/coordinax/_d3/builtin.py @@ -2,11 +2,11 @@ __all__ = [ # Position - "Cartesian3DVector", - "CylindricalVector", + "CartesianPosition3D", + "CylindricalPosition", # Differential - "CartesianDifferential3D", - "CylindricalDifferential", + "CartesianVelocity3D", + "CylindricalVelocity", ] from dataclasses import replace @@ -20,7 +20,7 @@ from unxt import Quantity import coordinax._typing as ct -from .base import Abstract3DVector, Abstract3DVectorDifferential +from .base import AbstractPosition3D, AbstractVelocity3D from coordinax._base_pos import AbstractPosition from coordinax._base_vel import AdditionMixin from coordinax._checks import check_azimuth_range, check_r_non_negative @@ -32,7 +32,7 @@ @final -class Cartesian3DVector(Abstract3DVector): +class CartesianPosition3D(AbstractPosition3D): """Cartesian vector representation.""" x: ct.BatchableLength = eqx.field( @@ -52,8 +52,8 @@ class Cartesian3DVector(Abstract3DVector): @classproperty @classmethod - def differential_cls(cls) -> type["CartesianDifferential3D"]: - return CartesianDifferential3D + def differential_cls(cls) -> type["CartesianVelocity3D"]: + return CartesianVelocity3D # ----------------------------------------------------- # Unary operations @@ -64,8 +64,8 @@ def __neg__(self) -> "Self": Examples -------- >>> from unxt import Quantity - >>> from coordinax import Cartesian3DVector - >>> q = Cartesian3DVector.constructor(Quantity([1, 2, 3], "kpc")) + >>> from coordinax import CartesianPosition3D + >>> q = CartesianPosition3D.constructor(Quantity([1, 2, 3], "kpc")) >>> (-q).x Quantity['length'](Array(-1., dtype=float32), unit='kpc') @@ -75,15 +75,15 @@ def __neg__(self) -> "Self": # ----------------------------------------------------- # Binary operations - def __add__(self, other: Any, /) -> "Cartesian3DVector": + def __add__(self, other: Any, /) -> "CartesianPosition3D": """Add two vectors. Examples -------- >>> from unxt import Quantity - >>> from coordinax import Cartesian3DVector, SphericalVector - >>> q = Cartesian3DVector.constructor(Quantity([1, 2, 3], "kpc")) - >>> s = SphericalVector(r=Quantity(1, "kpc"), theta=Quantity(90, "deg"), + >>> from coordinax import CartesianPosition3D, SphericalPosition + >>> q = CartesianPosition3D.constructor(Quantity([1, 2, 3], "kpc")) + >>> s = SphericalPosition(r=Quantity(1, "kpc"), theta=Quantity(90, "deg"), ... phi=Quantity(0, "deg")) >>> (q + s).x Quantity['length'](Array(2., dtype=float32), unit='kpc') @@ -93,18 +93,18 @@ def __add__(self, other: Any, /) -> "Cartesian3DVector": msg = f"Cannot add {self._cartesian_cls!r} and {type(other)!r}." raise TypeError(msg) - cart = other.represent_as(Cartesian3DVector) + cart = other.represent_as(CartesianPosition3D) return replace(self, x=self.x + cart.x, y=self.y + cart.y, z=self.z + cart.z) - def __sub__(self, other: Any, /) -> "Cartesian3DVector": + def __sub__(self, other: Any, /) -> "CartesianPosition3D": """Subtract two vectors. Examples -------- >>> from unxt import Quantity - >>> from coordinax import Cartesian3DVector, SphericalVector - >>> q = Cartesian3DVector.constructor(Quantity([1, 2, 3], "kpc")) - >>> s = SphericalVector(r=Quantity(1, "kpc"), theta=Quantity(90, "deg"), + >>> from coordinax import CartesianPosition3D, SphericalPosition + >>> q = CartesianPosition3D.constructor(Quantity([1, 2, 3], "kpc")) + >>> s = SphericalPosition(r=Quantity(1, "kpc"), theta=Quantity(90, "deg"), ... phi=Quantity(0, "deg")) >>> (q - s).x Quantity['length'](Array(0., dtype=float32), unit='kpc') @@ -114,7 +114,7 @@ def __sub__(self, other: Any, /) -> "Cartesian3DVector": msg = f"Cannot subtract {self._cartesian_cls!r} and {type(other)!r}." raise TypeError(msg) - cart = other.represent_as(Cartesian3DVector) + cart = other.represent_as(CartesianPosition3D) return replace(self, x=self.x - cart.x, y=self.y - cart.y, z=self.z - cart.z) @partial(jax.jit) @@ -124,8 +124,8 @@ def norm(self) -> ct.BatchableLength: Examples -------- >>> from unxt import Quantity - >>> from coordinax import Cartesian3DVector - >>> q = Cartesian3DVector.constructor(Quantity([1, 2, 3], "kpc")) + >>> from coordinax import CartesianPosition3D + >>> q = CartesianPosition3D.constructor(Quantity([1, 2, 3], "kpc")) >>> q.norm() Quantity['length'](Array(3.7416575, dtype=float32), unit='kpc') @@ -134,7 +134,7 @@ def norm(self) -> ct.BatchableLength: @final -class CylindricalVector(Abstract3DVector): +class CylindricalPosition(AbstractPosition3D): """Cylindrical vector representation. This adheres to ISO standard 31-11. @@ -165,8 +165,8 @@ def __check_init__(self) -> None: @classproperty @classmethod - def differential_cls(cls) -> type["CylindricalDifferential"]: - return CylindricalDifferential + def differential_cls(cls) -> type["CylindricalVelocity"]: + return CylindricalVelocity @partial(jax.jit) def norm(self) -> ct.BatchableLength: @@ -175,8 +175,8 @@ def norm(self) -> ct.BatchableLength: Examples -------- >>> from unxt import Quantity - >>> from coordinax import CylindricalVector - >>> c = CylindricalVector(rho=Quantity(3, "kpc"), phi=Quantity(0, "deg"), + >>> from coordinax import CylindricalPosition + >>> c = CylindricalPosition(rho=Quantity(3, "kpc"), phi=Quantity(0, "deg"), ... z=Quantity(4, "kpc")) >>> c.norm() Quantity['length'](Array(5., dtype=float32), unit='kpc') @@ -190,7 +190,7 @@ def norm(self) -> ct.BatchableLength: @final -class CartesianDifferential3D(Abstract3DVectorDifferential, AdditionMixin): +class CartesianVelocity3D(AbstractVelocity3D, AdditionMixin): """Cartesian differential representation.""" d_x: ct.BatchableSpeed = eqx.field( @@ -210,18 +210,18 @@ class CartesianDifferential3D(Abstract3DVectorDifferential, AdditionMixin): @classproperty @classmethod - def integral_cls(cls) -> type[Cartesian3DVector]: - return Cartesian3DVector + def integral_cls(cls) -> type[CartesianPosition3D]: + return CartesianPosition3D @partial(jax.jit) - def norm(self, _: Abstract3DVector | None = None, /) -> ct.BatchableSpeed: + def norm(self, _: AbstractPosition3D | None = None, /) -> ct.BatchableSpeed: """Return the norm of the vector. Examples -------- >>> from unxt import Quantity - >>> from coordinax import CartesianDifferential3D - >>> c = CartesianDifferential3D(d_x=Quantity(1, "km/s"), + >>> from coordinax import CartesianVelocity3D + >>> c = CartesianVelocity3D(d_x=Quantity(1, "km/s"), ... d_y=Quantity(2, "km/s"), ... d_z=Quantity(3, "km/s")) >>> c.norm() @@ -232,7 +232,7 @@ def norm(self, _: Abstract3DVector | None = None, /) -> ct.BatchableSpeed: @final -class CylindricalDifferential(Abstract3DVectorDifferential): +class CylindricalVelocity(AbstractVelocity3D): """Cylindrical differential representation.""" d_rho: ct.BatchableSpeed = eqx.field( @@ -252,5 +252,5 @@ class CylindricalDifferential(Abstract3DVectorDifferential): @classproperty @classmethod - def integral_cls(cls) -> type[CylindricalVector]: - return CylindricalVector + def integral_cls(cls) -> type[CylindricalPosition]: + return CylindricalPosition diff --git a/src/coordinax/_d3/compat.py b/src/coordinax/_d3/compat.py index 4101ccb..7f7adf3 100644 --- a/src/coordinax/_d3/compat.py +++ b/src/coordinax/_d3/compat.py @@ -11,19 +11,19 @@ import quaxed.array_api as xp from unxt import Quantity -from .base import Abstract3DVector +from .base import AbstractPosition3D from .builtin import ( - Cartesian3DVector, - CartesianDifferential3D, - CylindricalDifferential, - CylindricalVector, + CartesianPosition3D, + CartesianVelocity3D, + CylindricalPosition, + CylindricalVelocity, ) from .sphere import ( - LonCosLatSphericalDifferential, - LonLatSphericalDifferential, - LonLatSphericalVector, - SphericalDifferential, - SphericalVector, + LonCosLatSphericalVelocity, + LonLatSphericalPosition, + LonLatSphericalVelocity, + SphericalPosition, + SphericalVelocity, ) from coordinax._utils import dataclass_values, full_shaped @@ -31,10 +31,10 @@ # Constructors -@Cartesian3DVector.constructor._f.register # noqa: SLF001 +@CartesianPosition3D.constructor._f.register # noqa: SLF001 def constructor( - cls: type[Cartesian3DVector], obj: apyc.BaseRepresentation -) -> Cartesian3DVector: + cls: type[CartesianPosition3D], obj: apyc.BaseRepresentation +) -> CartesianPosition3D: """Construct from a :class:`astropy.coordinates.BaseRepresentation`. Examples @@ -43,7 +43,7 @@ def constructor( >>> from astropy.coordinates import CartesianRepresentation >>> cart = CartesianRepresentation(1, 2, 3, unit="kpc") - >>> vec = cx.Cartesian3DVector.constructor(cart) + >>> vec = cx.CartesianPosition3D.constructor(cart) >>> vec.x Quantity['length'](Array(1., dtype=float32), unit='kpc') @@ -52,10 +52,10 @@ def constructor( return cls(x=obj.x, y=obj.y, z=obj.z) -@CylindricalVector.constructor._f.register # noqa: SLF001 +@CylindricalPosition.constructor._f.register # noqa: SLF001 def constructor( - cls: type[CylindricalVector], obj: apyc.BaseRepresentation -) -> CylindricalVector: + cls: type[CylindricalPosition], obj: apyc.BaseRepresentation +) -> CylindricalPosition: """Construct from a :class:`astropy.coordinates.BaseRepresentation`. Examples @@ -66,7 +66,7 @@ def constructor( >>> cyl = CylindricalRepresentation(rho=1 * u.kpc, phi=2 * u.deg, ... z=30 * u.pc) - >>> vec = cx.CylindricalVector.constructor(cyl) + >>> vec = cx.CylindricalPosition.constructor(cyl) >>> vec.rho Quantity['length'](Array(1., dtype=float32), unit='kpc') @@ -75,10 +75,10 @@ def constructor( return cls(rho=obj.rho, phi=obj.phi, z=obj.z) -@SphericalVector.constructor._f.register # noqa: SLF001 +@SphericalPosition.constructor._f.register # noqa: SLF001 def constructor( - cls: type[SphericalVector], obj: apyc.BaseRepresentation -) -> SphericalVector: + cls: type[SphericalPosition], obj: apyc.BaseRepresentation +) -> SphericalPosition: """Construct from a :class:`astropy.coordinates.BaseRepresentation`. Examples @@ -89,7 +89,7 @@ def constructor( >>> sph = PhysicsSphericalRepresentation(r=1 * u.kpc, theta=2 * u.deg, ... phi=3 * u.deg) - >>> vec = cx.SphericalVector.constructor(sph) + >>> vec = cx.SphericalPosition.constructor(sph) >>> vec.r Distance(Array(1., dtype=float32), unit='kpc') @@ -98,10 +98,10 @@ def constructor( return cls(r=obj.r, theta=obj.theta, phi=obj.phi) -@LonLatSphericalVector.constructor._f.register # noqa: SLF001 +@LonLatSphericalPosition.constructor._f.register # noqa: SLF001 def constructor( - cls: type[LonLatSphericalVector], obj: apyc.BaseRepresentation -) -> LonLatSphericalVector: + cls: type[LonLatSphericalPosition], obj: apyc.BaseRepresentation +) -> LonLatSphericalPosition: """Construct from a :class:`astropy.coordinates.BaseRepresentation`. Examples @@ -112,7 +112,7 @@ def constructor( >>> sph = SphericalRepresentation(lon=3 * u.deg, lat=2 * u.deg, ... distance=1 * u.kpc) - >>> vec = cx.LonLatSphericalVector.constructor(sph) + >>> vec = cx.LonLatSphericalPosition.constructor(sph) >>> vec.distance Distance(Array(1., dtype=float32), unit='kpc') @@ -124,10 +124,10 @@ def constructor( # ------------------------------------------------------------------- -@CartesianDifferential3D.constructor._f.register # noqa: SLF001 +@CartesianVelocity3D.constructor._f.register # noqa: SLF001 def constructor( - cls: type[CartesianDifferential3D], obj: apyc.CartesianDifferential -) -> CartesianDifferential3D: + cls: type[CartesianVelocity3D], obj: apyc.CartesianDifferential +) -> CartesianVelocity3D: """Construct from a :class:`astropy.coordinates.CartesianDifferential`. Examples @@ -137,7 +137,7 @@ def constructor( >>> from astropy.coordinates import CartesianDifferential >>> dcart = CartesianDifferential(1, 2, 3, unit="km/s") - >>> dif = cx.CartesianDifferential3D.constructor(dcart) + >>> dif = cx.CartesianVelocity3D.constructor(dcart) >>> dif.d_x Quantity['speed'](Array(1., dtype=float32), unit='km / s') @@ -145,11 +145,11 @@ def constructor( return cls(d_x=obj.d_x, d_y=obj.d_y, d_z=obj.d_z) -@CylindricalDifferential.constructor._f.register # noqa: SLF001 +@CylindricalVelocity.constructor._f.register # noqa: SLF001 def constructor( - cls: type[CylindricalDifferential], obj: apyc.CylindricalDifferential -) -> CylindricalDifferential: - """Construct from a :class:`astropy.coordinates.CylindricalDifferential`. + cls: type[CylindricalVelocity], obj: apyc.CylindricalDifferential +) -> CylindricalVelocity: + """Construct from a :class:`astropy.coordinates.CylindricalVelocity`. Examples -------- @@ -159,7 +159,7 @@ def constructor( >>> dcyl = apyc.CylindricalDifferential(d_rho=1 * u.km / u.s, d_phi=2 * u.mas/u.yr, ... d_z=2 * u.km / u.s) - >>> dif = cx.CylindricalDifferential.constructor(dcyl) + >>> dif = cx.CylindricalVelocity.constructor(dcyl) >>> dif.d_rho Quantity['speed'](Array(1., dtype=float32), unit='km / s') @@ -167,10 +167,10 @@ def constructor( return cls(d_rho=obj.d_rho, d_phi=obj.d_phi, d_z=obj.d_z) -@SphericalDifferential.constructor._f.register # noqa: SLF001 +@SphericalVelocity.constructor._f.register # noqa: SLF001 def constructor( - cls: type[SphericalDifferential], obj: apyc.PhysicsSphericalDifferential -) -> SphericalDifferential: + cls: type[SphericalVelocity], obj: apyc.PhysicsSphericalDifferential +) -> SphericalVelocity: """Construct from a :class:`astropy.coordinates.PhysicsSphericalDifferential`. Examples @@ -181,7 +181,7 @@ def constructor( >>> dsph = PhysicsSphericalDifferential(d_r=1 * u.km / u.s, d_theta=2 * u.mas/u.yr, ... d_phi=3 * u.mas/u.yr) - >>> dif = cx.SphericalDifferential.constructor(dsph) + >>> dif = cx.SphericalVelocity.constructor(dsph) >>> dif.d_r Quantity['speed'](Array(1., dtype=float32), unit='km / s') @@ -189,11 +189,11 @@ def constructor( return cls(d_r=obj.d_r, d_phi=obj.d_phi, d_theta=obj.d_theta) -@LonLatSphericalDifferential.constructor._f.register # noqa: SLF001 +@LonLatSphericalVelocity.constructor._f.register # noqa: SLF001 def constructor( - cls: type[LonLatSphericalDifferential], obj: apyc.SphericalDifferential -) -> LonLatSphericalDifferential: - """Construct from a :class:`astropy.coordinates.SphericalDifferential`. + cls: type[LonLatSphericalVelocity], obj: apyc.SphericalDifferential +) -> LonLatSphericalVelocity: + """Construct from a :class:`astropy.coordinates.SphericalVelocity`. Examples -------- @@ -204,7 +204,7 @@ def constructor( >>> dsph = SphericalDifferential(d_distance=1 * u.km / u.s, ... d_lon=2 * u.mas/u.yr, ... d_lat=3 * u.mas/u.yr) - >>> dif = cx.LonLatSphericalDifferential.constructor(dsph) + >>> dif = cx.LonLatSphericalVelocity.constructor(dsph) >>> dif.d_distance Quantity['speed'](Array(1., dtype=float32), unit='km / s') @@ -212,10 +212,10 @@ def constructor( return cls(d_distance=obj.d_distance, d_lon=obj.d_lon, d_lat=obj.d_lat) -@LonCosLatSphericalDifferential.constructor._f.register # noqa: SLF001 +@LonCosLatSphericalVelocity.constructor._f.register # noqa: SLF001 def constructor( - cls: type[LonCosLatSphericalDifferential], obj: apyc.SphericalCosLatDifferential -) -> LonCosLatSphericalDifferential: + cls: type[LonCosLatSphericalVelocity], obj: apyc.SphericalCosLatDifferential +) -> LonCosLatSphericalVelocity: """Construct from a :class:`astropy.coordinates.SphericalCosLatDifferential`. Examples @@ -227,9 +227,9 @@ def constructor( >>> dsph = SphericalCosLatDifferential(d_distance=1 * u.km / u.s, ... d_lon_coslat=2 * u.mas/u.yr, ... d_lat=3 * u.mas/u.yr) - >>> dif = cx.LonCosLatSphericalDifferential.constructor(dsph) + >>> dif = cx.LonCosLatSphericalVelocity.constructor(dsph) >>> dif - LonCosLatSphericalDifferential( + LonCosLatSphericalVelocity( d_lon_coslat=Quantity[...]( value=f32[], unit=Unit("mas / yr") ), d_lat=Quantity[...]( value=f32[], unit=Unit("mas / yr") ), d_distance=Quantity[...]( value=f32[], unit=Unit("km / s") ) @@ -247,27 +247,27 @@ def constructor( # Quantity -@conversion_method(Abstract3DVector, Quantity) # type: ignore[misc] -def vec_to_q(obj: Abstract3DVector, /) -> Shaped[Quantity["length"], "*batch 3"]: - """`coordinax.Abstract3DVector` -> `unxt.Quantity`. +@conversion_method(AbstractPosition3D, Quantity) # type: ignore[misc] +def vec_to_q(obj: AbstractPosition3D, /) -> Shaped[Quantity["length"], "*batch 3"]: + """`coordinax.AbstractPosition3D` -> `unxt.Quantity`. Examples -------- >>> from unxt import Quantity >>> import coordinax as cx - >>> vec = cx.Cartesian3DVector.constructor(Quantity([1, 2, 3], unit="kpc")) + >>> vec = cx.CartesianPosition3D.constructor(Quantity([1, 2, 3], unit="kpc")) >>> convert(vec, Quantity) Quantity['length'](Array([1., 2., 3.], dtype=float32), unit='kpc') - >>> vec = cx.SphericalVector(r=Quantity(1, unit="kpc"), + >>> vec = cx.SphericalPosition(r=Quantity(1, unit="kpc"), ... theta=Quantity(2, unit="deg"), ... phi=Quantity(3, unit="deg")) >>> convert(vec, Quantity) Quantity['length'](Array([0.03485167, 0.0018265 , 0.99939084], dtype=float32), unit='kpc') - >>> vec = cx.CylindricalVector(rho=Quantity(1, unit="kpc"), + >>> vec = cx.CylindricalPosition(rho=Quantity(1, unit="kpc"), ... phi=Quantity(2, unit="deg"), ... z=Quantity(3, unit="pc")) >>> convert(vec, Quantity) @@ -275,22 +275,20 @@ def vec_to_q(obj: Abstract3DVector, /) -> Shaped[Quantity["length"], "*batch 3"] unit='kpc') """ - cart = full_shaped(obj.represent_as(Cartesian3DVector)) + cart = full_shaped(obj.represent_as(CartesianPosition3D)) return xp.stack(tuple(dataclass_values(cart)), axis=-1) -@conversion_method(CartesianDifferential3D, Quantity) # type: ignore[misc] -def vec_diff_to_q( - obj: CartesianDifferential3D, / -) -> Shaped[Quantity["speed"], "*batch 3"]: - """`coordinax.CartesianDifferential3D` -> `unxt.Quantity`. +@conversion_method(CartesianVelocity3D, Quantity) # type: ignore[misc] +def vec_diff_to_q(obj: CartesianVelocity3D, /) -> Shaped[Quantity["speed"], "*batch 3"]: + """`coordinax.CartesianVelocity3D` -> `unxt.Quantity`. Examples -------- >>> from unxt import Quantity >>> import coordinax as cx - >>> dif = cx.CartesianDifferential3D.constructor(Quantity([1, 2, 3], unit="km/s")) + >>> dif = cx.CartesianVelocity3D.constructor(Quantity([1, 2, 3], unit="km/s")) >>> convert(dif, Quantity) Quantity['speed'](Array([1., 2., 3.], dtype=float32), unit='km / s') @@ -303,20 +301,20 @@ def vec_diff_to_q( # ===================================== -# Cartesian3DVector +# CartesianPosition3D -@conversion_method(Cartesian3DVector, apyc.BaseRepresentation) # type: ignore[misc] -@conversion_method(Cartesian3DVector, apyc.CartesianRepresentation) # type: ignore[misc] -def cart3_to_apycart3(obj: Cartesian3DVector, /) -> apyc.CartesianRepresentation: - """`coordinax.Cartesian3DVector` -> `astropy.CartesianRepresentation`. +@conversion_method(CartesianPosition3D, apyc.BaseRepresentation) # type: ignore[misc] +@conversion_method(CartesianPosition3D, apyc.CartesianRepresentation) # type: ignore[misc] +def cart3_to_apycart3(obj: CartesianPosition3D, /) -> apyc.CartesianRepresentation: + """`coordinax.CartesianPosition3D` -> `astropy.CartesianRepresentation`. Examples -------- >>> from unxt import Quantity >>> import coordinax as cx - >>> vec = cx.Cartesian3DVector.constructor(Quantity([1, 2, 3], unit="kpc")) + >>> vec = cx.CartesianPosition3D.constructor(Quantity([1, 2, 3], unit="kpc")) >>> convert(vec, apyc.CartesianRepresentation) @@ -333,9 +331,9 @@ def cart3_to_apycart3(obj: Cartesian3DVector, /) -> apyc.CartesianRepresentation ) -@conversion_method(apyc.CartesianRepresentation, Cartesian3DVector) # type: ignore[misc] -def apycart3_to_cart3(obj: apyc.CartesianRepresentation, /) -> Cartesian3DVector: - """`astropy.CartesianRepresentation` -> `coordinax.Cartesian3DVector`. +@conversion_method(apyc.CartesianRepresentation, CartesianPosition3D) # type: ignore[misc] +def apycart3_to_cart3(obj: apyc.CartesianRepresentation, /) -> CartesianPosition3D: + """`astropy.CartesianRepresentation` -> `coordinax.CartesianPosition3D`. Examples -------- @@ -344,32 +342,32 @@ def apycart3_to_cart3(obj: apyc.CartesianRepresentation, /) -> Cartesian3DVector >>> from astropy.coordinates import CartesianRepresentation >>> vec = CartesianRepresentation(1, 2, 3, unit="kpc") - >>> convert(vec, cx.Cartesian3DVector) - Cartesian3DVector( + >>> convert(vec, cx.CartesianPosition3D) + CartesianPosition3D( x=Quantity[PhysicalType('length')](value=f32[], unit=Unit("kpc")), y=Quantity[PhysicalType('length')](value=f32[], unit=Unit("kpc")), z=Quantity[PhysicalType('length')](value=f32[], unit=Unit("kpc")) ) """ - return Cartesian3DVector.constructor(obj) + return CartesianPosition3D.constructor(obj) # ===================================== -# CylindricalVector +# CylindricalPosition -@conversion_method(CylindricalVector, apyc.BaseRepresentation) # type: ignore[misc] -@conversion_method(CylindricalVector, apyc.CylindricalRepresentation) # type: ignore[misc] -def cyl_to_apycyl(obj: CylindricalVector, /) -> apyc.CylindricalRepresentation: - """`coordinax.CylindricalVector` -> `astropy.CylindricalRepresentation`. +@conversion_method(CylindricalPosition, apyc.BaseRepresentation) # type: ignore[misc] +@conversion_method(CylindricalPosition, apyc.CylindricalRepresentation) # type: ignore[misc] +def cyl_to_apycyl(obj: CylindricalPosition, /) -> apyc.CylindricalRepresentation: + """`coordinax.CylindricalPosition` -> `astropy.CylindricalRepresentation`. Examples -------- >>> from unxt import Quantity >>> import coordinax as cx - >>> vec = cx.CylindricalVector(rho=Quantity(1, unit="kpc"), + >>> vec = cx.CylindricalPosition(rho=Quantity(1, unit="kpc"), ... phi=Quantity(2, unit="deg"), ... z=Quantity(3, unit="pc")) >>> convert(vec, apyc.CylindricalRepresentation) @@ -388,9 +386,9 @@ def cyl_to_apycyl(obj: CylindricalVector, /) -> apyc.CylindricalRepresentation: ) -@conversion_method(apyc.CylindricalRepresentation, CylindricalVector) # type: ignore[misc] -def apycyl_to_cyl(obj: apyc.CylindricalRepresentation, /) -> CylindricalVector: - """`astropy.CylindricalRepresentation` -> `coordinax.CylindricalVector`. +@conversion_method(apyc.CylindricalRepresentation, CylindricalPosition) # type: ignore[misc] +def apycyl_to_cyl(obj: apyc.CylindricalRepresentation, /) -> CylindricalPosition: + """`astropy.CylindricalRepresentation` -> `coordinax.CylindricalPosition`. Examples -------- @@ -399,32 +397,32 @@ def apycyl_to_cyl(obj: apyc.CylindricalRepresentation, /) -> CylindricalVector: >>> from astropy.coordinates import CylindricalRepresentation >>> cyl = CylindricalRepresentation(rho=1 * u.kpc, phi=2 * u.deg, z=30 * u.pc) - >>> convert(cyl, cx.CylindricalVector) - CylindricalVector( + >>> convert(cyl, cx.CylindricalPosition) + CylindricalPosition( rho=Quantity[...](value=f32[], unit=Unit("kpc")), phi=Quantity[...](value=f32[], unit=Unit("deg")), z=Quantity[...](value=f32[], unit=Unit("pc")) ) """ - return CylindricalVector.constructor(obj) + return CylindricalPosition.constructor(obj) # ===================================== -# SphericalVector +# SphericalPosition -@conversion_method(SphericalVector, apyc.BaseRepresentation) # type: ignore[misc] -@conversion_method(SphericalVector, apyc.PhysicsSphericalRepresentation) # type: ignore[misc] -def sph_to_apysph(obj: SphericalVector, /) -> apyc.PhysicsSphericalRepresentation: - """`coordinax.SphericalVector` -> `astropy.PhysicsSphericalRepresentation`. +@conversion_method(SphericalPosition, apyc.BaseRepresentation) # type: ignore[misc] +@conversion_method(SphericalPosition, apyc.PhysicsSphericalRepresentation) # type: ignore[misc] +def sph_to_apysph(obj: SphericalPosition, /) -> apyc.PhysicsSphericalRepresentation: + """`coordinax.SphericalPosition` -> `astropy.PhysicsSphericalRepresentation`. Examples -------- >>> from unxt import Quantity >>> import coordinax as cx - >>> vec = cx.SphericalVector(r=Quantity(1, unit="kpc"), + >>> vec = cx.SphericalPosition(r=Quantity(1, unit="kpc"), ... theta=Quantity(2, unit="deg"), ... phi=Quantity(3, unit="deg")) >>> convert(vec, apyc.PhysicsSphericalRepresentation) @@ -439,9 +437,9 @@ def sph_to_apysph(obj: SphericalVector, /) -> apyc.PhysicsSphericalRepresentatio ) -@conversion_method(apyc.PhysicsSphericalRepresentation, SphericalVector) # type: ignore[misc] -def apysph_to_sph(obj: apyc.PhysicsSphericalRepresentation, /) -> SphericalVector: - """`astropy.PhysicsSphericalRepresentation` -> `coordinax.SphericalVector`. +@conversion_method(apyc.PhysicsSphericalRepresentation, SphericalPosition) # type: ignore[misc] +def apysph_to_sph(obj: apyc.PhysicsSphericalRepresentation, /) -> SphericalPosition: + """`astropy.PhysicsSphericalRepresentation` -> `coordinax.SphericalPosition`. Examples -------- @@ -451,32 +449,34 @@ def apysph_to_sph(obj: apyc.PhysicsSphericalRepresentation, /) -> SphericalVecto >>> sph = PhysicsSphericalRepresentation(r=1 * u.kpc, theta=2 * u.deg, ... phi=3 * u.deg) - >>> convert(sph, cx.SphericalVector) - SphericalVector( + >>> convert(sph, cx.SphericalPosition) + SphericalPosition( r=Distance(value=f32[], unit=Unit("kpc")), theta=Quantity[...](value=f32[], unit=Unit("deg")), phi=Quantity[...](value=f32[], unit=Unit("deg")) ) """ - return SphericalVector.constructor(obj) + return SphericalPosition.constructor(obj) # ===================================== -# LonLatSphericalVector +# LonLatSphericalPosition -@conversion_method(LonLatSphericalVector, apyc.BaseRepresentation) # type: ignore[misc] -@conversion_method(LonLatSphericalVector, apyc.PhysicsSphericalRepresentation) # type: ignore[misc] -def lonlatsph_to_apysph(obj: LonLatSphericalVector, /) -> apyc.SphericalRepresentation: - """`coordinax.LonLatSphericalVector` -> `astropy.SphericalRepresentation`. +@conversion_method(LonLatSphericalPosition, apyc.BaseRepresentation) # type: ignore[misc] +@conversion_method(LonLatSphericalPosition, apyc.PhysicsSphericalRepresentation) # type: ignore[misc] +def lonlatsph_to_apysph( + obj: LonLatSphericalPosition, / +) -> apyc.SphericalRepresentation: + """`coordinax.LonLatSphericalPosition` -> `astropy.SphericalRepresentation`. Examples -------- >>> from unxt import Quantity >>> import coordinax as cx - >>> vec = cx.LonLatSphericalVector(lon=Quantity(2, unit="deg"), + >>> vec = cx.LonLatSphericalPosition(lon=Quantity(2, unit="deg"), ... lat=Quantity(3, unit="deg"), ... distance=Quantity(1, unit="kpc")) >>> convert(vec, apyc.SphericalRepresentation) @@ -491,9 +491,11 @@ def lonlatsph_to_apysph(obj: LonLatSphericalVector, /) -> apyc.SphericalRepresen ) -@conversion_method(apyc.SphericalRepresentation, LonLatSphericalVector) # type: ignore[misc] -def apysph_to_lonlatsph(obj: apyc.SphericalRepresentation, /) -> LonLatSphericalVector: - """`astropy.SphericalRepresentation` -> `coordinax.LonLatSphericalVector`. +@conversion_method(apyc.SphericalRepresentation, LonLatSphericalPosition) # type: ignore[misc] +def apysph_to_lonlatsph( + obj: apyc.SphericalRepresentation, / +) -> LonLatSphericalPosition: + """`astropy.SphericalRepresentation` -> `coordinax.LonLatSphericalPosition`. Examples -------- @@ -503,34 +505,32 @@ def apysph_to_lonlatsph(obj: apyc.SphericalRepresentation, /) -> LonLatSpherical >>> sph = SphericalRepresentation(lon=2 * u.deg, lat=3 * u.deg, ... distance=1 * u.kpc) - >>> convert(sph, cx.LonLatSphericalVector) - LonLatSphericalVector( + >>> convert(sph, cx.LonLatSphericalPosition) + LonLatSphericalPosition( lon=Quantity[...](value=f32[], unit=Unit("deg")), lat=Quantity[...](value=f32[], unit=Unit("deg")), distance=Distance(value=f32[], unit=Unit("kpc")) ) """ - return LonLatSphericalVector.constructor(obj) + return LonLatSphericalPosition.constructor(obj) # ===================================== -# CartesianDifferential3D +# CartesianVelocity3D -@conversion_method(CartesianDifferential3D, apyc.BaseDifferential) # type: ignore[misc] -@conversion_method(CartesianDifferential3D, apyc.CartesianDifferential) # type: ignore[misc] -def diffcart3_to_apycart3( - obj: CartesianDifferential3D, / -) -> apyc.CartesianDifferential: - """`coordinax.CartesianDifferential3D` -> `astropy.CartesianDifferential`. +@conversion_method(CartesianVelocity3D, apyc.BaseDifferential) # type: ignore[misc] +@conversion_method(CartesianVelocity3D, apyc.CartesianDifferential) # type: ignore[misc] +def diffcart3_to_apycart3(obj: CartesianVelocity3D, /) -> apyc.CartesianDifferential: + """`coordinax.CartesianVelocity3D` -> `astropy.CartesianDifferential`. Examples -------- >>> from unxt import Quantity >>> import coordinax as cx - >>> dif = cx.CartesianDifferential3D.constructor(Quantity([1, 2, 3], unit="km/s")) + >>> dif = cx.CartesianVelocity3D.constructor(Quantity([1, 2, 3], unit="km/s")) >>> convert(dif, apyc.CartesianDifferential) @@ -544,12 +544,10 @@ def diffcart3_to_apycart3( @conversion_method( # type: ignore[misc] - apyc.CartesianDifferential, CartesianDifferential3D + apyc.CartesianDifferential, CartesianVelocity3D ) -def apycart3_to_diffcart3( - obj: apyc.CartesianDifferential, / -) -> CartesianDifferential3D: - """`astropy.CartesianDifferential` -> `coordinax.CartesianDifferential3D`. +def apycart3_to_diffcart3(obj: apyc.CartesianDifferential, /) -> CartesianVelocity3D: + """`astropy.CartesianDifferential` -> `coordinax.CartesianVelocity3D`. Examples -------- @@ -558,25 +556,25 @@ def apycart3_to_diffcart3( >>> from astropy.coordinates import CartesianDifferential >>> dcart = CartesianDifferential(1, 2, 3, unit="km/s") - >>> convert(dcart, cx.CartesianDifferential3D) - CartesianDifferential3D( + >>> convert(dcart, cx.CartesianVelocity3D) + CartesianVelocity3D( d_x=Quantity[...]( value=f32[], unit=Unit("km / s") ), d_y=Quantity[...]( value=f32[], unit=Unit("km / s") ), d_z=Quantity[...]( value=f32[], unit=Unit("km / s") ) ) """ - return CartesianDifferential3D.constructor(obj) + return CartesianVelocity3D.constructor(obj) # ===================================== -# CylindricalDifferential +# CylindricalVelocity -@conversion_method(CylindricalDifferential, apyc.BaseDifferential) # type: ignore[misc] -@conversion_method(CylindricalDifferential, apyc.CylindricalDifferential) # type: ignore[misc] -def diffcyl_to_apycyl(obj: CylindricalDifferential, /) -> apyc.CylindricalDifferential: - """`coordinax.CylindricalDifferential` -> `astropy.CylindricalDifferential`. +@conversion_method(CylindricalVelocity, apyc.BaseDifferential) # type: ignore[misc] +@conversion_method(CylindricalVelocity, apyc.CylindricalDifferential) # type: ignore[misc] +def diffcyl_to_apycyl(obj: CylindricalVelocity, /) -> apyc.CylindricalDifferential: + """`coordinax.CylindricalVelocity` -> `astropy.CylindricalDifferential`. Examples -------- @@ -584,7 +582,7 @@ def diffcyl_to_apycyl(obj: CylindricalDifferential, /) -> apyc.CylindricalDiffer >>> import coordinax as cx >>> import astropy.coordinates as apyc - >>> dif = cx.CylindricalDifferential(d_rho=Quantity(1, unit="km/s"), + >>> dif = cx.CylindricalVelocity(d_rho=Quantity(1, unit="km/s"), ... d_phi=Quantity(2, unit="mas/yr"), ... d_z=Quantity(3, unit="km/s")) >>> convert(dif, apyc.CylindricalDifferential) @@ -604,10 +602,10 @@ def diffcyl_to_apycyl(obj: CylindricalDifferential, /) -> apyc.CylindricalDiffer @conversion_method( # type: ignore[misc] - apyc.CylindricalDifferential, CylindricalDifferential + apyc.CylindricalDifferential, CylindricalVelocity ) -def apycyl_to_diffcyl(obj: apyc.CylindricalDifferential, /) -> CylindricalDifferential: - """`astropy.CylindricalDifferential` -> `coordinax.CylindricalDifferential`. +def apycyl_to_diffcyl(obj: apyc.CylindricalDifferential, /) -> CylindricalVelocity: + """`astropy.CylindricalVelocity` -> `coordinax.CylindricalVelocity`. Examples -------- @@ -617,34 +615,32 @@ def apycyl_to_diffcyl(obj: apyc.CylindricalDifferential, /) -> CylindricalDiffer >>> dcyl = apyc.CylindricalDifferential(d_rho=1 * u.km / u.s, d_phi=2 * u.mas/u.yr, ... d_z=2 * u.km / u.s) - >>> convert(dcyl, cx.CylindricalDifferential) - CylindricalDifferential( + >>> convert(dcyl, cx.CylindricalVelocity) + CylindricalVelocity( d_rho=Quantity[...]( value=f32[], unit=Unit("km / s") ), d_phi=Quantity[...]( value=f32[], unit=Unit("mas / yr") ), d_z=Quantity[...]( value=f32[], unit=Unit("km / s") ) ) """ - return CylindricalDifferential.constructor(obj) + return CylindricalVelocity.constructor(obj) # ===================================== -# SphericalDifferential +# SphericalVelocity -@conversion_method(SphericalDifferential, apyc.BaseDifferential) # type: ignore[misc] -@conversion_method(SphericalDifferential, apyc.PhysicsSphericalDifferential) # type: ignore[misc] -def diffsph_to_apysph( - obj: SphericalDifferential, / -) -> apyc.PhysicsSphericalDifferential: - """SphericalDifferential -> `astropy.PhysicsSphericalDifferential`. +@conversion_method(SphericalVelocity, apyc.BaseDifferential) # type: ignore[misc] +@conversion_method(SphericalVelocity, apyc.PhysicsSphericalDifferential) # type: ignore[misc] +def diffsph_to_apysph(obj: SphericalVelocity, /) -> apyc.PhysicsSphericalDifferential: + """SphericalVelocity -> `astropy.PhysicsSphericalDifferential`. Examples -------- >>> from unxt import Quantity >>> import coordinax as cx - >>> dif = cx.SphericalDifferential(d_r=Quantity(1, unit="km/s"), + >>> dif = cx.SphericalVelocity(d_r=Quantity(1, unit="km/s"), ... d_theta=Quantity(2, unit="mas/yr"), ... d_phi=Quantity(3, unit="mas/yr")) >>> convert(dif, apyc.PhysicsSphericalDifferential) @@ -664,12 +660,10 @@ def diffsph_to_apysph( @conversion_method( # type: ignore[misc] - apyc.PhysicsSphericalDifferential, SphericalDifferential + apyc.PhysicsSphericalDifferential, SphericalVelocity ) -def apysph_to_diffsph( - obj: apyc.PhysicsSphericalDifferential, / -) -> SphericalDifferential: - """`astropy.PhysicsSphericalDifferential` -> SphericalDifferential. +def apysph_to_diffsph(obj: apyc.PhysicsSphericalDifferential, /) -> SphericalVelocity: + """`astropy.PhysicsSphericalDifferential` -> SphericalVelocity. Examples -------- @@ -679,34 +673,34 @@ def apysph_to_diffsph( >>> dif = PhysicsSphericalDifferential(d_r=1 * u.km / u.s, d_theta=2 * u.mas/u.yr, ... d_phi=3 * u.mas/u.yr) - >>> convert(dif, cx.SphericalDifferential) - SphericalDifferential( + >>> convert(dif, cx.SphericalVelocity) + SphericalVelocity( d_r=Quantity[...]( value=f32[], unit=Unit("km / s") ), d_theta=Quantity[...]( value=f32[], unit=Unit("mas / yr") ), d_phi=Quantity[...]( value=f32[], unit=Unit("mas / yr") ) ) """ - return SphericalDifferential.constructor(obj) + return SphericalVelocity.constructor(obj) # ===================================== -# LonLatSphericalDifferential +# LonLatSphericalVelocity -@conversion_method(LonLatSphericalDifferential, apyc.BaseDifferential) # type: ignore[misc] -@conversion_method(LonLatSphericalDifferential, apyc.SphericalDifferential) # type: ignore[misc] +@conversion_method(LonLatSphericalVelocity, apyc.BaseDifferential) # type: ignore[misc] +@conversion_method(LonLatSphericalVelocity, apyc.SphericalDifferential) # type: ignore[misc] def difflonlatsph_to_apysph( - obj: LonLatSphericalDifferential, / + obj: LonLatSphericalVelocity, / ) -> apyc.SphericalDifferential: - """LonLatSphericalDifferential -> `astropy.SphericalDifferential`. + """LonLatSphericalVelocity -> `astropy.SphericalVelocity`. Examples -------- >>> from unxt import Quantity >>> import coordinax as cx - >>> dif = cx.LonLatSphericalDifferential(d_distance=Quantity(1, unit="km/s"), + >>> dif = cx.LonLatSphericalVelocity(d_distance=Quantity(1, unit="km/s"), ... d_lat=Quantity(2, unit="mas/yr"), ... d_lon=Quantity(3, unit="mas/yr")) >>> convert(dif, apyc.SphericalDifferential) @@ -726,12 +720,12 @@ def difflonlatsph_to_apysph( @conversion_method( # type: ignore[misc] - apyc.SphericalDifferential, LonLatSphericalDifferential + apyc.SphericalDifferential, LonLatSphericalVelocity ) def apysph_to_difflonlatsph( obj: apyc.SphericalDifferential, / -) -> LonLatSphericalDifferential: - """`astropy.SphericalDifferential` -> LonLatSphericalDifferential. +) -> LonLatSphericalVelocity: + """`astropy.coordinates.SphericalDifferential` -> LonLatSphericalVelocity. Examples -------- @@ -741,34 +735,34 @@ def apysph_to_difflonlatsph( >>> dif = SphericalDifferential(d_distance=1 * u.km / u.s, d_lat=2 * u.mas/u.yr, ... d_lon=3 * u.mas/u.yr) - >>> convert(dif, cx.LonLatSphericalDifferential) - LonLatSphericalDifferential( + >>> convert(dif, cx.LonLatSphericalVelocity) + LonLatSphericalVelocity( d_lon=Quantity[...]( value=f32[], unit=Unit("mas / yr") ), d_lat=Quantity[...]( value=f32[], unit=Unit("mas / yr") ), d_distance=Quantity[...]( value=f32[], unit=Unit("km / s") ) ) """ - return LonLatSphericalDifferential.constructor(obj) + return LonLatSphericalVelocity.constructor(obj) # ===================================== -# LonCosLatSphericalDifferential +# LonCosLatSphericalVelocity -@conversion_method(LonCosLatSphericalDifferential, apyc.BaseDifferential) # type: ignore[misc] -@conversion_method(LonCosLatSphericalDifferential, apyc.SphericalCosLatDifferential) # type: ignore[misc] +@conversion_method(LonCosLatSphericalVelocity, apyc.BaseDifferential) # type: ignore[misc] +@conversion_method(LonCosLatSphericalVelocity, apyc.SphericalCosLatDifferential) # type: ignore[misc] def diffloncoslatsph_to_apysph( - obj: LonCosLatSphericalDifferential, / + obj: LonCosLatSphericalVelocity, / ) -> apyc.SphericalCosLatDifferential: - """LonCosLatSphericalDifferential -> `astropy.SphericalCosLatDifferential`. + """LonCosLatSphericalVelocity -> `astropy.SphericalCosLatDifferential`. Examples -------- >>> from unxt import Quantity >>> import coordinax as cx - >>> dif = cx.LonCosLatSphericalDifferential(d_distance=Quantity(1, unit="km/s"), + >>> dif = cx.LonCosLatSphericalVelocity(d_distance=Quantity(1, unit="km/s"), ... d_lat=Quantity(2, unit="mas/yr"), ... d_lon_coslat=Quantity(3, unit="mas/yr")) >>> convert(dif, apyc.SphericalCosLatDifferential) @@ -788,12 +782,12 @@ def diffloncoslatsph_to_apysph( @conversion_method( # type: ignore[misc] - apyc.SphericalCosLatDifferential, LonCosLatSphericalDifferential + apyc.SphericalCosLatDifferential, LonCosLatSphericalVelocity ) def apysph_to_diffloncoslatsph( obj: apyc.SphericalCosLatDifferential, / -) -> LonCosLatSphericalDifferential: - """`astropy.SphericalCosLatDifferential` -> LonCosLatSphericalDifferential. +) -> LonCosLatSphericalVelocity: + """`astropy.SphericalCosLatDifferential` -> LonCosLatSphericalVelocity. Examples -------- @@ -804,12 +798,12 @@ def apysph_to_diffloncoslatsph( >>> dif = SphericalCosLatDifferential(d_distance=1 * u.km / u.s, ... d_lat=2 * u.mas/u.yr, ... d_lon_coslat=3 * u.mas/u.yr) - >>> convert(dif, cx.LonCosLatSphericalDifferential) - LonCosLatSphericalDifferential( + >>> convert(dif, cx.LonCosLatSphericalVelocity) + LonCosLatSphericalVelocity( d_lon_coslat=Quantity[...]( value=f32[], unit=Unit("mas / yr") ), d_lat=Quantity[...]( value=f32[], unit=Unit("mas / yr") ), d_distance=Quantity[...]( value=f32[], unit=Unit("km / s") ) ) """ - return LonCosLatSphericalDifferential.constructor(obj) + return LonCosLatSphericalVelocity.constructor(obj) diff --git a/src/coordinax/_d3/operate.py b/src/coordinax/_d3/operate.py index 31df95e..6122614 100644 --- a/src/coordinax/_d3/operate.py +++ b/src/coordinax/_d3/operate.py @@ -10,7 +10,7 @@ from unxt import Quantity -from .builtin import Cartesian3DVector +from .builtin import CartesianPosition3D from coordinax._typing import TimeBatchOrScalar from coordinax.operators._base import AbstractOperator, op_call_dispatch @@ -22,7 +22,7 @@ def call(self: AbstractOperator, q: Q3, /) -> Q3: r"""Operate on a 3D Quantity. `q` is the position vector. This is interpreted as a 3D CartesianVector. - See :class:`coordinax.Cartesian3DVector` for more details. + See :class:`coordinax.CartesianPosition3D` for more details. Returns ------- @@ -50,7 +50,8 @@ def call(self: AbstractOperator, q: Q3, /) -> Q3: """ return convert( - self(Cartesian3DVector.constructor(q)).represent_as(Cartesian3DVector), Quantity + self(CartesianPosition3D.constructor(q)).represent_as(CartesianPosition3D), + Quantity, ) @@ -69,7 +70,7 @@ def call( >>> op = cx.operators.GalileanSpatialTranslationOperator(Quantity([1, 2, 3], "kpc")) >>> op - GalileanSpatialTranslationOperator( translation=Cartesian3DVector( ... ) ) + GalileanSpatialTranslationOperator( translation=CartesianPosition3D( ... ) ) We can then apply the operator to a position: @@ -88,5 +89,5 @@ def call( Quantity['time'](Array(0., dtype=float32, ...), unit='Gyr')) """ - vec, t = self(Cartesian3DVector.constructor(x), t) + vec, t = self(CartesianPosition3D.constructor(x), t) return convert(vec, Quantity), t diff --git a/src/coordinax/_d3/sphere.py b/src/coordinax/_d3/sphere.py index c9c693f..12ded85 100644 --- a/src/coordinax/_d3/sphere.py +++ b/src/coordinax/_d3/sphere.py @@ -1,18 +1,18 @@ """Built-in vector classes.""" __all__ = [ - "AbstractSphericalVector", - "AbstractSphericalDifferential", + "AbstractSphericalPosition", + "AbstractSphericalVelocity", # Physics conventions - "SphericalVector", - "SphericalDifferential", + "SphericalPosition", + "SphericalVelocity", # Mathematics conventions - "MathSphericalVector", - "MathSphericalDifferential", + "MathSphericalPosition", + "MathSphericalVelocity", # Geographic / Astronomical conventions - "LonLatSphericalVector", - "LonLatSphericalDifferential", - "LonCosLatSphericalDifferential", + "LonLatSphericalPosition", + "LonLatSphericalVelocity", + "LonCosLatSphericalVelocity", ] from abc import abstractmethod @@ -27,7 +27,7 @@ from unxt import AbstractDistance, Distance, Quantity import coordinax._typing as ct -from .base import Abstract3DVector, Abstract3DVectorDifferential +from .base import AbstractPosition3D, AbstractVelocity3D from coordinax._checks import ( check_azimuth_range, check_polar_range, @@ -43,17 +43,17 @@ # Position -class AbstractSphericalVector(Abstract3DVector): +class AbstractSphericalPosition(AbstractPosition3D): """Abstract spherical vector representation.""" @classproperty @classmethod @abstractmethod - def differential_cls(cls) -> type["AbstractSphericalDifferential"]: ... + def differential_cls(cls) -> type["AbstractSphericalVelocity"]: ... @final -class SphericalVector(AbstractSphericalVector): +class SphericalPosition(AbstractSphericalPosition): """Spherical vector representation. .. note:: @@ -98,8 +98,8 @@ def __check_init__(self) -> None: @classproperty @classmethod - def differential_cls(cls) -> type["SphericalDifferential"]: - return SphericalDifferential + def differential_cls(cls) -> type["SphericalVelocity"]: + return SphericalVelocity @partial(jax.jit) def norm(self) -> ct.BatchableDistance: @@ -108,8 +108,8 @@ def norm(self) -> ct.BatchableDistance: Examples -------- >>> from unxt import Quantity - >>> from coordinax import SphericalVector - >>> s = SphericalVector(r=Quantity(3, "kpc"), theta=Quantity(90, "deg"), + >>> from coordinax import SphericalPosition + >>> s = SphericalPosition(r=Quantity(3, "kpc"), theta=Quantity(90, "deg"), ... phi=Quantity(0, "deg")) >>> s.norm() Distance(Array(3., dtype=float32), unit='kpc') @@ -119,7 +119,7 @@ def norm(self) -> ct.BatchableDistance: @final -class MathSphericalVector(AbstractSphericalVector): +class MathSphericalPosition(AbstractSphericalPosition): """Spherical vector representation. .. note:: @@ -164,8 +164,8 @@ def __check_init__(self) -> None: @classproperty @classmethod - def differential_cls(cls) -> type["MathSphericalDifferential"]: - return MathSphericalDifferential + def differential_cls(cls) -> type["MathSphericalVelocity"]: + return MathSphericalVelocity @partial(jax.jit) def norm(self) -> ct.BatchableDistance: @@ -174,8 +174,8 @@ def norm(self) -> ct.BatchableDistance: Examples -------- >>> from unxt import Quantity - >>> from coordinax import MathSphericalVector - >>> s = MathSphericalVector(r=Quantity(3, "kpc"), theta=Quantity(90, "deg"), + >>> from coordinax import MathSphericalPosition + >>> s = MathSphericalPosition(r=Quantity(3, "kpc"), theta=Quantity(90, "deg"), ... phi=Quantity(0, "deg")) >>> s.norm() Distance(Array(3., dtype=float32), unit='kpc') @@ -188,7 +188,7 @@ def norm(self) -> ct.BatchableDistance: @final -class LonLatSphericalVector(AbstractSphericalVector): +class LonLatSphericalPosition(AbstractSphericalPosition): """Spherical vector representation. .. note:: @@ -209,9 +209,9 @@ class LonLatSphericalVector(AbstractSphericalVector): >>> from unxt import Quantity >>> import coordinax as cx - >>> cx.LonLatSphericalVector(lon=Quantity(0, "deg"), lat=Quantity(0, "deg"), + >>> cx.LonLatSphericalPosition(lon=Quantity(0, "deg"), lat=Quantity(0, "deg"), ... distance=Quantity(3, "kpc")) - LonLatSphericalVector( + LonLatSphericalPosition( lon=Quantity[PhysicalType('angle')](value=f32[], unit=Unit("deg")), lat=Quantity[PhysicalType('angle')](value=f32[], unit=Unit("deg")), distance=Distance(value=f32[], unit=Unit("kpc")) @@ -221,7 +221,7 @@ class LonLatSphericalVector(AbstractSphericalVector): and the radial distance is non-negative. When initializing, the longitude is wrapped to the [0, 360) degrees range. - >>> vec = cx.LonLatSphericalVector(lon=Quantity(365, "deg"), + >>> vec = cx.LonLatSphericalPosition(lon=Quantity(365, "deg"), ... lat=Quantity(90, "deg"), ... distance=Quantity(3, "kpc")) >>> vec.lon @@ -232,7 +232,7 @@ class LonLatSphericalVector(AbstractSphericalVector): .. skip: next >>> try: - ... cx.LonLatSphericalVector(lon=Quantity(0, "deg"), lat=Quantity(100, "deg"), + ... cx.LonLatSphericalPosition(lon=Quantity(0, "deg"), lat=Quantity(100, "deg"), ... distance=Quantity(3, "kpc")) ... except Exception as e: ... print(e) @@ -243,7 +243,7 @@ class LonLatSphericalVector(AbstractSphericalVector): .. skip: next >>> try: - ... cx.LonLatSphericalVector(lon=Quantity(0, "deg"), lat=Quantity(0, "deg"), + ... cx.LonLatSphericalPosition(lon=Quantity(0, "deg"), lat=Quantity(0, "deg"), ... distance=Quantity(-3, "kpc")) ... except Exception as e: ... print(e) @@ -278,8 +278,8 @@ def __check_init__(self) -> None: @classproperty @classmethod - def differential_cls(cls) -> type["LonLatSphericalDifferential"]: - return LonLatSphericalDifferential + def differential_cls(cls) -> type["LonLatSphericalVelocity"]: + return LonLatSphericalVelocity @partial(jax.jit) def norm(self) -> ct.BatchableDistance: @@ -288,8 +288,8 @@ def norm(self) -> ct.BatchableDistance: Examples -------- >>> from unxt import Quantity - >>> from coordinax import LonLatSphericalVector - >>> s = LonLatSphericalVector(lon=Quantity(0, "deg"), lat=Quantity(90, "deg"), + >>> from coordinax import LonLatSphericalPosition + >>> s = LonLatSphericalPosition(lon=Quantity(0, "deg"), lat=Quantity(90, "deg"), ... distance=Quantity(3, "kpc")) >>> s.norm() Distance(Array(3., dtype=float32), unit='kpc') @@ -298,15 +298,15 @@ def norm(self) -> ct.BatchableDistance: return self.distance -@LonLatSphericalVector.constructor._f.register # type: ignore[attr-defined, misc] # noqa: SLF001 +@LonLatSphericalPosition.constructor._f.register # type: ignore[attr-defined, misc] # noqa: SLF001 def constructor( - cls: type[LonLatSphericalVector], + cls: type[LonLatSphericalPosition], *, lon: Quantity["angle"], lat: Quantity["angle"], distance: Distance, -) -> LonLatSphericalVector: - """Construct LonLatSphericalVector, allowing for out-of-range values. +) -> LonLatSphericalPosition: + """Construct LonLatSphericalPosition, allowing for out-of-range values. Examples -------- @@ -314,10 +314,10 @@ def constructor( Let's start with a valid input: - >>> cx.LonLatSphericalVector.constructor(lon=Quantity(0, "deg"), + >>> cx.LonLatSphericalPosition.constructor(lon=Quantity(0, "deg"), ... lat=Quantity(0, "deg"), ... distance=Quantity(3, "kpc")) - LonLatSphericalVector( + LonLatSphericalPosition( lon=Quantity[PhysicalType('angle')](value=f32[], unit=Unit("deg")), lat=Quantity[PhysicalType('angle')](value=f32[], unit=Unit("deg")), distance=Distance(value=f32[], unit=Unit("kpc")) @@ -326,7 +326,7 @@ def constructor( The distance can be negative, which wraps the longitude by 180 degrees and flips the latitude: - >>> vec = cx.LonLatSphericalVector.constructor(lon=Quantity(0, "deg"), + >>> vec = cx.LonLatSphericalPosition.constructor(lon=Quantity(0, "deg"), ... lat=Quantity(45, "deg"), ... distance=Quantity(-3, "kpc")) >>> vec.lon @@ -339,7 +339,7 @@ def constructor( The latitude can be outside the [-90, 90] deg range, causing the longitude to be shifted by 180 degrees: - >>> vec = cx.LonLatSphericalVector.constructor(lon=Quantity(0, "deg"), + >>> vec = cx.LonLatSphericalPosition.constructor(lon=Quantity(0, "deg"), ... lat=Quantity(-100, "deg"), ... distance=Quantity(3, "kpc")) >>> vec.lon @@ -349,7 +349,7 @@ def constructor( >>> vec.distance Distance(Array(3., dtype=float32), unit='kpc') - >>> vec = cx.LonLatSphericalVector.constructor(lon=Quantity(0, "deg"), + >>> vec = cx.LonLatSphericalPosition.constructor(lon=Quantity(0, "deg"), ... lat=Quantity(100, "deg"), ... distance=Quantity(3, "kpc")) >>> vec.lon @@ -362,7 +362,7 @@ def constructor( The longitude can be outside the [0, 360) deg range. This is wrapped to the [0, 360) deg range (actually the base constructor does this): - >>> vec = cx.LonLatSphericalVector.constructor(lon=Quantity(365, "deg"), + >>> vec = cx.LonLatSphericalPosition.constructor(lon=Quantity(365, "deg"), ... lat=Quantity(0, "deg"), ... distance=Quantity(3, "kpc")) >>> vec.lon @@ -370,7 +370,7 @@ def constructor( """ # 1) Convert the inputs - fields = LonLatSphericalVector.__dataclass_fields__ + fields = LonLatSphericalPosition.__dataclass_fields__ lon = fields["lon"].metadata["converter"](lon) lat = fields["lat"].metadata["converter"](lat) distance = fields["distance"].metadata["converter"](distance) @@ -397,17 +397,17 @@ def constructor( ############################################################################## -class AbstractSphericalDifferential(Abstract3DVectorDifferential): +class AbstractSphericalVelocity(AbstractVelocity3D): """Spherical differential representation.""" @classproperty @classmethod @abstractmethod - def integral_cls(cls) -> type[SphericalVector]: ... + def integral_cls(cls) -> type[SphericalPosition]: ... @final -class SphericalDifferential(Abstract3DVectorDifferential): +class SphericalVelocity(AbstractVelocity3D): """Spherical differential representation.""" d_r: ct.BatchableSpeed = eqx.field( @@ -427,12 +427,12 @@ class SphericalDifferential(Abstract3DVectorDifferential): @classproperty @classmethod - def integral_cls(cls) -> type[SphericalVector]: - return SphericalVector + def integral_cls(cls) -> type[SphericalPosition]: + return SphericalPosition @final -class MathSphericalDifferential(Abstract3DVectorDifferential): +class MathSphericalVelocity(AbstractVelocity3D): """Spherical differential representation.""" d_r: ct.BatchableSpeed = eqx.field( @@ -452,12 +452,12 @@ class MathSphericalDifferential(Abstract3DVectorDifferential): @classproperty @classmethod - def integral_cls(cls) -> type[MathSphericalVector]: - return MathSphericalVector + def integral_cls(cls) -> type[MathSphericalPosition]: + return MathSphericalPosition @final -class LonLatSphericalDifferential(Abstract3DVectorDifferential): +class LonLatSphericalVelocity(AbstractVelocity3D): """Spherical differential representation.""" d_lon: ct.BatchableAngularSpeed = eqx.field( @@ -477,12 +477,12 @@ class LonLatSphericalDifferential(Abstract3DVectorDifferential): @classproperty @classmethod - def integral_cls(cls) -> type[LonLatSphericalVector]: - return LonLatSphericalVector + def integral_cls(cls) -> type[LonLatSphericalPosition]: + return LonLatSphericalPosition @final -class LonCosLatSphericalDifferential(Abstract3DVectorDifferential): +class LonCosLatSphericalVelocity(AbstractVelocity3D): """Spherical differential representation.""" d_lon_coslat: ct.BatchableAngularSpeed = eqx.field( @@ -502,5 +502,5 @@ class LonCosLatSphericalDifferential(Abstract3DVectorDifferential): @classproperty @classmethod - def integral_cls(cls) -> type[LonLatSphericalVector]: - return LonLatSphericalVector + def integral_cls(cls) -> type[LonLatSphericalPosition]: + return LonLatSphericalPosition diff --git a/src/coordinax/_d3/transform.py b/src/coordinax/_d3/transform.py index cf2257b..b2c0218 100644 --- a/src/coordinax/_d3/transform.py +++ b/src/coordinax/_d3/transform.py @@ -9,22 +9,22 @@ import quaxed.array_api as xp from unxt import Quantity -from .base import Abstract3DVector, Abstract3DVectorDifferential +from .base import AbstractPosition3D, AbstractVelocity3D from .builtin import ( - Cartesian3DVector, - CartesianDifferential3D, - CylindricalDifferential, - CylindricalVector, + CartesianPosition3D, + CartesianVelocity3D, + CylindricalPosition, + CylindricalVelocity, ) from .sphere import ( - AbstractSphericalVector, - LonCosLatSphericalDifferential, - LonLatSphericalDifferential, - LonLatSphericalVector, - MathSphericalDifferential, - MathSphericalVector, - SphericalDifferential, - SphericalVector, + AbstractSphericalPosition, + LonCosLatSphericalVelocity, + LonLatSphericalPosition, + LonLatSphericalVelocity, + MathSphericalPosition, + MathSphericalVelocity, + SphericalPosition, + SphericalVelocity, ) from coordinax._base_pos import AbstractPosition @@ -34,22 +34,22 @@ @dispatch def represent_as( - current: Abstract3DVector, target: type[Abstract3DVector], /, **kwargs: Any -) -> Abstract3DVector: - """Abstract3DVector -> Cartesian3D -> Abstract3DVector.""" - return represent_as(represent_as(current, Cartesian3DVector), target) + current: AbstractPosition3D, target: type[AbstractPosition3D], /, **kwargs: Any +) -> AbstractPosition3D: + """AbstractPosition3D -> Cartesian3D -> AbstractPosition3D.""" + return represent_as(represent_as(current, CartesianPosition3D), target) @dispatch.multi( - (Cartesian3DVector, type[Cartesian3DVector]), - (CylindricalVector, type[CylindricalVector]), - (SphericalVector, type[SphericalVector]), - (LonLatSphericalVector, type[LonLatSphericalVector]), - (MathSphericalVector, type[MathSphericalVector]), + (CartesianPosition3D, type[CartesianPosition3D]), + (CylindricalPosition, type[CylindricalPosition]), + (SphericalPosition, type[SphericalPosition]), + (LonLatSphericalPosition, type[LonLatSphericalPosition]), + (MathSphericalPosition, type[MathSphericalPosition]), ) def represent_as( - current: Abstract3DVector, target: type[Abstract3DVector], /, **kwargs: Any -) -> Abstract3DVector: + current: AbstractPosition3D, target: type[AbstractPosition3D], /, **kwargs: Any +) -> AbstractPosition3D: """Self transforms for 3D vectors. Examples @@ -59,36 +59,36 @@ def represent_as( Cartesian to Cartesian: - >>> vec = cx.Cartesian3DVector.constructor(Quantity([1, 2, 3], "kpc")) - >>> cx.represent_as(vec, cx.Cartesian3DVector) is vec + >>> vec = cx.CartesianPosition3D.constructor(Quantity([1, 2, 3], "kpc")) + >>> cx.represent_as(vec, cx.CartesianPosition3D) is vec True Cylindrical to Cylindrical: - >>> vec = cx.CylindricalVector(rho=Quantity(1, "kpc"), phi=Quantity(2, "deg"), + >>> vec = cx.CylindricalPosition(rho=Quantity(1, "kpc"), phi=Quantity(2, "deg"), ... z=Quantity(3, "kpc")) - >>> cx.represent_as(vec, cx.CylindricalVector) is vec + >>> cx.represent_as(vec, cx.CylindricalPosition) is vec True Spherical to Spherical: - >>> vec = cx.SphericalVector(r=Quantity(1, "kpc"), theta=Quantity(2, "deg"), + >>> vec = cx.SphericalPosition(r=Quantity(1, "kpc"), theta=Quantity(2, "deg"), ... phi=Quantity(3, "deg")) - >>> cx.represent_as(vec, cx.SphericalVector) is vec + >>> cx.represent_as(vec, cx.SphericalPosition) is vec True LonLatSpherical to LonLatSpherical: - >>> vec = cx.LonLatSphericalVector(lon=Quantity(1, "deg"), lat=Quantity(2, "deg"), + >>> vec = cx.LonLatSphericalPosition(lon=Quantity(1, "deg"), lat=Quantity(2, "deg"), ... distance=Quantity(3, "kpc")) - >>> cx.represent_as(vec, cx.LonLatSphericalVector) is vec + >>> cx.represent_as(vec, cx.LonLatSphericalPosition) is vec True MathSpherical to MathSpherical: - >>> vec = cx.MathSphericalVector(r=Quantity(1, "kpc"), theta=Quantity(2, "deg"), + >>> vec = cx.MathSphericalPosition(r=Quantity(1, "kpc"), theta=Quantity(2, "deg"), ... phi=Quantity(3, "deg")) - >>> cx.represent_as(vec, cx.MathSphericalVector) is vec + >>> cx.represent_as(vec, cx.MathSphericalPosition) is vec True """ @@ -96,24 +96,24 @@ def represent_as( @dispatch.multi( - (CartesianDifferential3D, type[CartesianDifferential3D], AbstractPosition), - (CylindricalDifferential, type[CylindricalDifferential], AbstractPosition), - (SphericalDifferential, type[SphericalDifferential], AbstractPosition), - (LonLatSphericalDifferential, type[LonLatSphericalDifferential], AbstractPosition), + (CartesianVelocity3D, type[CartesianVelocity3D], AbstractPosition), + (CylindricalVelocity, type[CylindricalVelocity], AbstractPosition), + (SphericalVelocity, type[SphericalVelocity], AbstractPosition), + (LonLatSphericalVelocity, type[LonLatSphericalVelocity], AbstractPosition), ( - LonCosLatSphericalDifferential, - type[LonCosLatSphericalDifferential], + LonCosLatSphericalVelocity, + type[LonCosLatSphericalVelocity], AbstractPosition, ), - (MathSphericalDifferential, type[MathSphericalDifferential], AbstractPosition), + (MathSphericalVelocity, type[MathSphericalVelocity], AbstractPosition), ) def represent_as( - current: Abstract3DVectorDifferential, - target: type[Abstract3DVectorDifferential], + current: AbstractVelocity3D, + target: type[AbstractVelocity3D], position: AbstractPosition, /, **kwargs: Any, -) -> Abstract3DVectorDifferential: +) -> AbstractVelocity3D: """Self transforms for 3D differentials. Examples @@ -124,52 +124,52 @@ def represent_as( For these transformations the position does not matter since the self-transform returns the differential unchanged. - >>> vec = cx.Cartesian3DVector.constructor(Quantity([1, 2, 3], "kpc")) + >>> vec = cx.CartesianPosition3D.constructor(Quantity([1, 2, 3], "kpc")) Cartesian to Cartesian differential: - >>> dif = cx.CartesianDifferential3D.constructor(Quantity([1, 2, 3], "km/s")) - >>> cx.represent_as(dif, cx.CartesianDifferential3D, vec) is dif + >>> dif = cx.CartesianVelocity3D.constructor(Quantity([1, 2, 3], "km/s")) + >>> cx.represent_as(dif, cx.CartesianVelocity3D, vec) is dif True Cylindrical to Cylindrical differential: - >>> dif = cx.CylindricalDifferential(d_rho=Quantity(1, "km/s"), + >>> dif = cx.CylindricalVelocity(d_rho=Quantity(1, "km/s"), ... d_phi=Quantity(2, "mas/yr"), ... d_z=Quantity(3, "km/s")) - >>> cx.represent_as(dif, cx.CylindricalDifferential, vec) is dif + >>> cx.represent_as(dif, cx.CylindricalVelocity, vec) is dif True Spherical to Spherical differential: - >>> dif = cx.SphericalDifferential(d_r=Quantity(1, "km/s"), + >>> dif = cx.SphericalVelocity(d_r=Quantity(1, "km/s"), ... d_theta=Quantity(2, "mas/yr"), ... d_phi=Quantity(3, "mas/yr")) - >>> cx.represent_as(dif, cx.SphericalDifferential, vec) is dif + >>> cx.represent_as(dif, cx.SphericalVelocity, vec) is dif True LonLatSpherical to LonLatSpherical differential: - >>> dif = cx.LonLatSphericalDifferential(d_lon=Quantity(1, "mas/yr"), + >>> dif = cx.LonLatSphericalVelocity(d_lon=Quantity(1, "mas/yr"), ... d_lat=Quantity(2, "mas/yr"), ... d_distance=Quantity(3, "km/s")) - >>> cx.represent_as(dif, cx.LonLatSphericalDifferential, vec) is dif + >>> cx.represent_as(dif, cx.LonLatSphericalVelocity, vec) is dif True LonCosLatSpherical to LonCosLatSpherical differential: - >>> dif = cx.LonCosLatSphericalDifferential(d_lon_coslat=Quantity(1, "mas/yr"), + >>> dif = cx.LonCosLatSphericalVelocity(d_lon_coslat=Quantity(1, "mas/yr"), ... d_lat=Quantity(2, "mas/yr"), ... d_distance=Quantity(3, "km/s")) - >>> cx.represent_as(dif, cx.LonCosLatSphericalDifferential, vec) is dif + >>> cx.represent_as(dif, cx.LonCosLatSphericalVelocity, vec) is dif True MathSpherical to MathSpherical differential: - >>> dif = cx.MathSphericalDifferential(d_r=Quantity(1, "km/s"), + >>> dif = cx.MathSphericalVelocity(d_r=Quantity(1, "km/s"), ... d_theta=Quantity(2, "mas/yr"), ... d_phi=Quantity(3, "mas/yr")) - >>> cx.represent_as(dif, cx.MathSphericalDifferential, vec) is dif + >>> cx.represent_as(dif, cx.MathSphericalVelocity, vec) is dif True """ @@ -177,23 +177,23 @@ def represent_as( # ============================================================================= -# Cartesian3DVector +# CartesianPosition3D @dispatch def represent_as( - current: Cartesian3DVector, target: type[CylindricalVector], /, **kwargs: Any -) -> CylindricalVector: - """Cartesian3DVector -> CylindricalVector. + current: CartesianPosition3D, target: type[CylindricalPosition], /, **kwargs: Any +) -> CylindricalPosition: + """CartesianPosition3D -> CylindricalPosition. Examples -------- >>> from unxt import Quantity >>> import coordinax as cx - >>> vec = cx.Cartesian3DVector.constructor(Quantity([1, 2, 3], "km")) - >>> print(cx.represent_as(vec, cx.CylindricalVector)) - >> vec = cx.CartesianPosition3D.constructor(Quantity([1, 2, 3], "km")) + >>> print(cx.represent_as(vec, cx.CylindricalPosition)) + """ @@ -204,18 +204,18 @@ def represent_as( @dispatch def represent_as( - current: Cartesian3DVector, target: type[SphericalVector], /, **kwargs: Any -) -> SphericalVector: - """Cartesian3DVector -> SphericalVector. + current: CartesianPosition3D, target: type[SphericalPosition], /, **kwargs: Any +) -> SphericalPosition: + """CartesianPosition3D -> SphericalPosition. Examples -------- >>> from unxt import Quantity >>> import coordinax as cx - >>> vec = cx.Cartesian3DVector.constructor(Quantity([1, 2, 3], "km")) - >>> print(cx.represent_as(vec, cx.SphericalVector)) - >> vec = cx.CartesianPosition3D.constructor(Quantity([1, 2, 3], "km")) + >>> print(cx.represent_as(vec, cx.SphericalPosition)) + """ @@ -226,52 +226,55 @@ def represent_as( @dispatch.multi( - (Cartesian3DVector, type[LonLatSphericalVector]), - (Cartesian3DVector, type[MathSphericalVector]), + (CartesianPosition3D, type[LonLatSphericalPosition]), + (CartesianPosition3D, type[MathSphericalPosition]), ) def represent_as( - current: Cartesian3DVector, target: type[AbstractSphericalVector], /, **kwargs: Any -) -> AbstractSphericalVector: - """Cartesian3DVector -> AbstractSphericalVector. + current: CartesianPosition3D, + target: type[AbstractSphericalPosition], + /, + **kwargs: Any, +) -> AbstractSphericalPosition: + """CartesianPosition3D -> AbstractSphericalPosition. Examples -------- >>> from unxt import Quantity >>> import coordinax as cx - >>> vec = cx.Cartesian3DVector.constructor(Quantity([1, 2, 3], "km")) + >>> vec = cx.CartesianPosition3D.constructor(Quantity([1, 2, 3], "km")) - >>> print(cx.represent_as(vec, cx.LonLatSphericalVector)) - >> print(cx.represent_as(vec, cx.LonLatSphericalPosition)) + - >>> print(cx.represent_as(vec, cx.MathSphericalVector)) - >> print(cx.represent_as(vec, cx.MathSphericalPosition)) + """ - return represent_as(represent_as(current, SphericalVector), target) + return represent_as(represent_as(current, SphericalPosition), target) # ============================================================================= -# CylindricalVector +# CylindricalPosition @dispatch def represent_as( - current: CylindricalVector, target: type[Cartesian3DVector], /, **kwargs: Any -) -> Cartesian3DVector: - """CylindricalVector -> Cartesian3DVector. + current: CylindricalPosition, target: type[CartesianPosition3D], /, **kwargs: Any +) -> CartesianPosition3D: + """CylindricalPosition -> CartesianPosition3D. Examples -------- >>> from unxt import Quantity >>> import coordinax as cx - >>> vec = cx.CylindricalVector(rho=Quantity(1., "kpc"), phi=Quantity(90, "deg"), + >>> vec = cx.CylindricalPosition(rho=Quantity(1., "kpc"), phi=Quantity(90, "deg"), ... z=Quantity(1, "kpc")) - >>> print(cx.represent_as(vec, cx.Cartesian3DVector)) - >> print(cx.represent_as(vec, cx.CartesianPosition3D)) + """ @@ -283,19 +286,19 @@ def represent_as( @dispatch def represent_as( - current: CylindricalVector, target: type[SphericalVector], /, **kwargs: Any -) -> SphericalVector: - """CylindricalVector -> SphericalVector. + current: CylindricalPosition, target: type[SphericalPosition], /, **kwargs: Any +) -> SphericalPosition: + """CylindricalPosition -> SphericalPosition. Examples -------- >>> from unxt import Quantity >>> import coordinax as cx - >>> vec = cx.CylindricalVector(rho=Quantity(1., "kpc"), phi=Quantity(90, "deg"), + >>> vec = cx.CylindricalPosition(rho=Quantity(1., "kpc"), phi=Quantity(90, "deg"), ... z=Quantity(1, "kpc")) - >>> print(cx.represent_as(vec, cx.SphericalVector)) - >> print(cx.represent_as(vec, cx.SphericalPosition)) + """ @@ -305,53 +308,56 @@ def represent_as( @dispatch.multi( - (CylindricalVector, type[LonLatSphericalVector]), - (CylindricalVector, type[MathSphericalVector]), + (CylindricalPosition, type[LonLatSphericalPosition]), + (CylindricalPosition, type[MathSphericalPosition]), ) def represent_as( - current: CylindricalVector, target: type[AbstractSphericalVector], /, **kwargs: Any -) -> AbstractSphericalVector: - """CylindricalVector -> AbstractSphericalVector. + current: CylindricalPosition, + target: type[AbstractSphericalPosition], + /, + **kwargs: Any, +) -> AbstractSphericalPosition: + """CylindricalPosition -> AbstractSphericalPosition. Examples -------- >>> from unxt import Quantity >>> import coordinax as cx - >>> vec = cx.CylindricalVector(rho=Quantity(1., "kpc"), phi=Quantity(90, "deg"), + >>> vec = cx.CylindricalPosition(rho=Quantity(1., "kpc"), phi=Quantity(90, "deg"), ... z=Quantity(1, "kpc")) - >>> print(cx.represent_as(vec, cx.LonLatSphericalVector)) - >> print(cx.represent_as(vec, cx.LonLatSphericalPosition)) + - >>> print(cx.represent_as(vec, cx.MathSphericalVector)) - >> print(cx.represent_as(vec, cx.MathSphericalPosition)) + """ - return represent_as(represent_as(current, SphericalVector), target) + return represent_as(represent_as(current, SphericalPosition), target) # ============================================================================= -# SphericalVector +# SphericalPosition @dispatch def represent_as( - current: SphericalVector, target: type[Cartesian3DVector], /, **kwargs: Any -) -> Cartesian3DVector: - """SphericalVector -> Cartesian3DVector. + current: SphericalPosition, target: type[CartesianPosition3D], /, **kwargs: Any +) -> CartesianPosition3D: + """SphericalPosition -> CartesianPosition3D. Examples -------- >>> from unxt import Quantity >>> import coordinax as cx - >>> vec = cx.SphericalVector(r=Quantity(1., "kpc"), theta=Quantity(90, "deg"), + >>> vec = cx.SphericalPosition(r=Quantity(1., "kpc"), theta=Quantity(90, "deg"), ... phi=Quantity(90, "deg")) - >>> print(cx.represent_as(vec, cx.Cartesian3DVector)) - >> print(cx.represent_as(vec, cx.CartesianPosition3D)) + """ @@ -363,19 +369,19 @@ def represent_as( @dispatch def represent_as( - current: SphericalVector, target: type[CylindricalVector], /, **kwargs: Any -) -> CylindricalVector: - """SphericalVector -> CylindricalVector. + current: SphericalPosition, target: type[CylindricalPosition], /, **kwargs: Any +) -> CylindricalPosition: + """SphericalPosition -> CylindricalPosition. Examples -------- >>> from unxt import Quantity >>> import coordinax as cx - >>> vec = cx.SphericalVector(r=Quantity(1., "kpc"), theta=Quantity(90, "deg"), + >>> vec = cx.SphericalPosition(r=Quantity(1., "kpc"), theta=Quantity(90, "deg"), ... phi=Quantity(90, "deg")) - >>> print(cx.represent_as(vec, cx.CylindricalVector)) - >> print(cx.represent_as(vec, cx.CylindricalPosition)) + """ @@ -386,19 +392,19 @@ def represent_as( @dispatch def represent_as( - current: SphericalVector, target: type[LonLatSphericalVector], /, **kwargs: Any -) -> LonLatSphericalVector: - """SphericalVector -> LonLatSphericalVector. + current: SphericalPosition, target: type[LonLatSphericalPosition], /, **kwargs: Any +) -> LonLatSphericalPosition: + """SphericalPosition -> LonLatSphericalPosition. Examples -------- >>> from unxt import Quantity >>> import coordinax as cx - >>> vec = cx.SphericalVector(r=Quantity(1., "kpc"), theta=Quantity(90, "deg"), + >>> vec = cx.SphericalPosition(r=Quantity(1., "kpc"), theta=Quantity(90, "deg"), ... phi=Quantity(90, "deg")) - >>> print(cx.represent_as(vec, cx.LonLatSphericalVector)) - >> print(cx.represent_as(vec, cx.LonLatSphericalPosition)) + """ @@ -409,19 +415,19 @@ def represent_as( @dispatch def represent_as( - current: SphericalVector, target: type[MathSphericalVector], /, **kwargs: Any -) -> MathSphericalVector: - """SphericalVector -> MathSphericalVector. + current: SphericalPosition, target: type[MathSphericalPosition], /, **kwargs: Any +) -> MathSphericalPosition: + """SphericalPosition -> MathSphericalPosition. Examples -------- >>> from unxt import Quantity >>> import coordinax as cx - >>> vec = cx.SphericalVector(r=Quantity(1., "kpc"), theta=Quantity(90, "deg"), + >>> vec = cx.SphericalPosition(r=Quantity(1., "kpc"), theta=Quantity(90, "deg"), ... phi=Quantity(90, "deg")) - >>> print(cx.represent_as(vec, cx.MathSphericalVector)) - >> print(cx.represent_as(vec, cx.MathSphericalPosition)) + """ @@ -429,66 +435,75 @@ def represent_as( # ============================================================================= -# LonLatSphericalVector +# LonLatSphericalPosition @dispatch def represent_as( - current: LonLatSphericalVector, target: type[Cartesian3DVector], /, **kwargs: Any -) -> Cartesian3DVector: - """LonLatSphericalVector -> Cartesian3DVector. + current: LonLatSphericalPosition, + target: type[CartesianPosition3D], + /, + **kwargs: Any, +) -> CartesianPosition3D: + """LonLatSphericalPosition -> CartesianPosition3D. Examples -------- >>> from unxt import Quantity >>> import coordinax as cx - >>> vec = cx.LonLatSphericalVector(lon=Quantity(90, "deg"), lat=Quantity(0, "deg"), - ... distance=Quantity(1., "kpc")) - >>> print(cx.represent_as(vec, cx.Cartesian3DVector)) - >> vec = cx.LonLatSphericalPosition(lon=Quantity(90, "deg"), + ... lat=Quantity(0, "deg"), + ... distance=Quantity(1., "kpc")) + >>> print(cx.represent_as(vec, cx.CartesianPosition3D)) + """ - return represent_as(represent_as(current, SphericalVector), Cartesian3DVector) + return represent_as(represent_as(current, SphericalPosition), CartesianPosition3D) @dispatch def represent_as( - current: LonLatSphericalVector, target: type[CylindricalVector], /, **kwargs: Any -) -> CylindricalVector: - """LonLatSphericalVector -> CylindricalVector. + current: LonLatSphericalPosition, + target: type[CylindricalPosition], + /, + **kwargs: Any, +) -> CylindricalPosition: + """LonLatSphericalPosition -> CylindricalPosition. Examples -------- >>> from unxt import Quantity >>> import coordinax as cx - >>> vec = cx.LonLatSphericalVector(lon=Quantity(90, "deg"), lat=Quantity(0, "deg"), - ... distance=Quantity(1., "kpc")) - >>> print(cx.represent_as(vec, cx.CylindricalVector)) - >> vec = cx.LonLatSphericalPosition(lon=Quantity(90, "deg"), + ... lat=Quantity(0, "deg"), + ... distance=Quantity(1., "kpc")) + >>> print(cx.represent_as(vec, cx.CylindricalPosition)) + """ - return represent_as(represent_as(current, SphericalVector), target) + return represent_as(represent_as(current, SphericalPosition), target) @dispatch def represent_as( - current: LonLatSphericalVector, target: type[SphericalVector], /, **kwargs: Any -) -> SphericalVector: - """LonLatSphericalVector -> SphericalVector. + current: LonLatSphericalPosition, target: type[SphericalPosition], /, **kwargs: Any +) -> SphericalPosition: + """LonLatSphericalPosition -> SphericalPosition. Examples -------- >>> from unxt import Quantity >>> import coordinax as cx - >>> vec = cx.LonLatSphericalVector(lon=Quantity(90, "deg"), lat=Quantity(0, "deg"), - ... distance=Quantity(1., "kpc")) - >>> print(cx.represent_as(vec, cx.SphericalVector)) - >> vec = cx.LonLatSphericalPosition(lon=Quantity(90, "deg"), + ... lat=Quantity(0, "deg"), + ... distance=Quantity(1., "kpc")) + >>> print(cx.represent_as(vec, cx.SphericalPosition)) + """ @@ -498,24 +513,24 @@ def represent_as( # ============================================================================= -# MathSphericalVector +# MathSphericalPosition @dispatch def represent_as( - current: MathSphericalVector, target: type[Cartesian3DVector], /, **kwargs: Any -) -> Cartesian3DVector: - """MathSphericalVector -> Cartesian3DVector. + current: MathSphericalPosition, target: type[CartesianPosition3D], /, **kwargs: Any +) -> CartesianPosition3D: + """MathSphericalPosition -> CartesianPosition3D. Examples -------- >>> from unxt import Quantity >>> import coordinax as cx - >>> vec = cx.MathSphericalVector(r=Quantity(1., "kpc"), theta=Quantity(90, "deg"), + >>> vec = cx.MathSphericalPosition(r=Quantity(1., "kpc"), theta=Quantity(90, "deg"), ... phi=Quantity(90, "deg")) - >>> print(cx.represent_as(vec, cx.Cartesian3DVector)) - >> print(cx.represent_as(vec, cx.CartesianPosition3D)) + """ @@ -527,19 +542,19 @@ def represent_as( @dispatch def represent_as( - current: MathSphericalVector, target: type[CylindricalVector], /, **kwargs: Any -) -> CylindricalVector: - """MathSphericalVector -> CylindricalVector. + current: MathSphericalPosition, target: type[CylindricalPosition], /, **kwargs: Any +) -> CylindricalPosition: + """MathSphericalPosition -> CylindricalPosition. Examples -------- >>> from unxt import Quantity >>> import coordinax as cx - >>> vec = cx.MathSphericalVector(r=Quantity(1., "kpc"), theta=Quantity(90, "deg"), + >>> vec = cx.MathSphericalPosition(r=Quantity(1., "kpc"), theta=Quantity(90, "deg"), ... phi=Quantity(90, "deg")) - >>> print(cx.represent_as(vec, cx.CylindricalVector)) - >> print(cx.represent_as(vec, cx.CylindricalPosition)) + """ @@ -550,19 +565,19 @@ def represent_as( @dispatch def represent_as( - current: MathSphericalVector, target: type[SphericalVector], /, **kwargs: Any -) -> SphericalVector: - """MathSphericalVector -> SphericalVector. + current: MathSphericalPosition, target: type[SphericalPosition], /, **kwargs: Any +) -> SphericalPosition: + """MathSphericalPosition -> SphericalPosition. Examples -------- >>> from unxt import Quantity >>> import coordinax as cx - >>> vec = cx.MathSphericalVector(r=Quantity(1., "kpc"), theta=Quantity(90, "deg"), + >>> vec = cx.MathSphericalPosition(r=Quantity(1., "kpc"), theta=Quantity(90, "deg"), ... phi=Quantity(90, "deg")) - >>> print(cx.represent_as(vec, cx.SphericalVector)) - >> print(cx.represent_as(vec, cx.SphericalPosition)) + """ @@ -570,18 +585,18 @@ def represent_as( # ============================================================================= -# LonLatSphericalDifferential +# LonLatSphericalVelocity @dispatch def represent_as( - current: Abstract3DVectorDifferential, - target: type[LonCosLatSphericalDifferential], + current: AbstractVelocity3D, + target: type[LonCosLatSphericalVelocity], position: AbstractPosition | Quantity["length"], /, **kwargs: Any, -) -> LonCosLatSphericalDifferential: - """Abstract3DVectorDifferential -> LonCosLatSphericalDifferential. +) -> LonCosLatSphericalVelocity: + """AbstractVelocity3D -> LonCosLatSphericalVelocity. Examples -------- @@ -589,14 +604,15 @@ def represent_as( >>> from unxt import Quantity >>> import coordinax as cx - >>> vec = cx.LonLatSphericalVector(lon=Quantity(15, "deg"), lat=Quantity(10, "deg"), - ... distance=Quantity(1.5, "kpc")) - >>> dif = cx.LonLatSphericalDifferential(d_lon=Quantity(7, "mas/yr"), + >>> vec = cx.LonLatSphericalPosition(lon=Quantity(15, "deg"), + ... lat=Quantity(10, "deg"), + ... distance=Quantity(1.5, "kpc")) + >>> dif = cx.LonLatSphericalVelocity(d_lon=Quantity(7, "mas/yr"), ... d_lat=Quantity(0, "deg/Gyr"), ... d_distance=Quantity(-5, "km/s")) - >>> newdif = cx.represent_as(dif, cx.LonCosLatSphericalDifferential, vec) + >>> newdif = cx.represent_as(dif, cx.LonCosLatSphericalVelocity, vec) >>> newdif - LonCosLatSphericalDifferential( + LonCosLatSphericalVelocity( d_lon_coslat=Quantity[...]( value=f32[], unit=Unit("mas / yr") ), d_lat=Quantity[...]( value=f32[], unit=Unit("deg / Gyr") ), d_distance=Quantity[...]( value=f32[], unit=Unit("km / s") ) @@ -614,8 +630,8 @@ def represent_as( position ) - # Transform the differential to LonLatSphericalDifferential - current = represent_as(current, LonLatSphericalDifferential, posvec) + # Transform the differential to LonLatSphericalVelocity + current = represent_as(current, LonLatSphericalVelocity, posvec) # Transform the position to the required type posvec = represent_as(posvec, current.integral_cls) @@ -630,13 +646,13 @@ def represent_as( @dispatch def represent_as( - current: LonCosLatSphericalDifferential, - target: type[LonLatSphericalDifferential], + current: LonCosLatSphericalVelocity, + target: type[LonLatSphericalVelocity], position: AbstractPosition | Quantity["length"], /, **kwargs: Any, -) -> LonLatSphericalDifferential: - """LonCosLatSphericalDifferential -> LonLatSphericalDifferential.""" +) -> LonLatSphericalVelocity: + """LonCosLatSphericalVelocity -> LonLatSphericalVelocity.""" # Parse the position to an AbstractPosition if isinstance(position, AbstractPosition): posvec = position @@ -658,13 +674,13 @@ def represent_as( @dispatch def represent_as( - current: LonCosLatSphericalDifferential, - target: type[Abstract3DVectorDifferential], + current: LonCosLatSphericalVelocity, + target: type[AbstractVelocity3D], position: AbstractPosition | Quantity["length"], /, **kwargs: Any, -) -> Abstract3DVectorDifferential: - """LonCosLatSphericalDifferential -> Abstract3DVectorDifferential.""" +) -> AbstractVelocity3D: + """LonCosLatSphericalVelocity -> AbstractVelocity3D.""" # Parse the position to an AbstractPosition if isinstance(position, AbstractPosition): posvec = position @@ -672,7 +688,7 @@ def represent_as( posvec = current.integral_cls._cartesian_cls.constructor( # noqa: SLF001 position ) - # Transform the differential to LonLatSphericalDifferential - current = represent_as(current, LonLatSphericalDifferential, posvec) + # Transform the differential to LonLatSphericalVelocity + current = represent_as(current, LonLatSphericalVelocity, posvec) # Transform the position to the required type return represent_as(current, target, posvec) diff --git a/src/coordinax/_d4/base.py b/src/coordinax/_d4/base.py index db897b5..6f67d26 100644 --- a/src/coordinax/_d4/base.py +++ b/src/coordinax/_d4/base.py @@ -1,6 +1,6 @@ """Representation of coordinates in different systems.""" -__all__ = ["Abstract4DVector"] +__all__ = ["AbstractPosition4D"] from abc import abstractmethod @@ -14,7 +14,7 @@ from typing_extensions import Never -class Abstract4DVector(AbstractPosition): +class AbstractPosition4D(AbstractPosition): """Abstract representation of 4D coordinates in different systems.""" @classproperty diff --git a/src/coordinax/_d4/compat.py b/src/coordinax/_d4/compat.py index c6caf0b..4807f48 100644 --- a/src/coordinax/_d4/compat.py +++ b/src/coordinax/_d4/compat.py @@ -14,6 +14,6 @@ @conversion_method(type_from=FourVector, type_to=Quantity) # type: ignore[misc] def vec_to_q(obj: FourVector, /) -> Shaped[Quantity["length"], "*batch 4"]: - """`coordinax.Abstract3DVector` -> `unxt.Quantity`.""" + """`coordinax.AbstractPosition3D` -> `unxt.Quantity`.""" cart = convert(obj.q, Quantity) return xp.concat([obj.c * obj.t[..., None], cart], axis=-1) diff --git a/src/coordinax/_d4/operate.py b/src/coordinax/_d4/operate.py index 214aec0..53863c3 100644 --- a/src/coordinax/_d4/operate.py +++ b/src/coordinax/_d4/operate.py @@ -25,17 +25,17 @@ def call(self: AbstractOperator, v4: FourVector, /) -> FourVector: >>> op = cx.operators.GalileanSpatialTranslationOperator(Quantity([1, 2, 3], "kpc")) >>> op - GalileanSpatialTranslationOperator( translation=Cartesian3DVector( ... ) ) + GalileanSpatialTranslationOperator( translation=CartesianPosition3D( ... ) ) We can then apply the operator to a position: >>> pos = cx.FourVector.constructor(Quantity([0, 1.0, 2.0, 3.0], "kpc")) >>> pos - FourVector( t=Quantity[PhysicalType('time')](...), q=Cartesian3DVector( ... ) ) + FourVector( t=Quantity[PhysicalType('time')](...), q=CartesianPosition3D( ... ) ) >>> newpos = op(pos) >>> newpos - FourVector( t=Quantity[PhysicalType('time')](...), q=Cartesian3DVector( ... ) ) + FourVector( t=Quantity[PhysicalType('time')](...), q=CartesianPosition3D( ... ) ) >>> newpos.q.x Quantity['length'](Array(2., dtype=float32), unit='kpc') @@ -59,7 +59,7 @@ def call( >>> op = cx.operators.GalileanSpatialTranslationOperator(Quantity([1, 2, 3], "kpc")) >>> op - GalileanSpatialTranslationOperator( translation=Cartesian3DVector( ... ) ) + GalileanSpatialTranslationOperator( translation=CartesianPosition3D( ... ) ) We can then apply the operator to a position: diff --git a/src/coordinax/_d4/spacetime.py b/src/coordinax/_d4/spacetime.py index c728dd7..8a36e84 100644 --- a/src/coordinax/_d4/spacetime.py +++ b/src/coordinax/_d4/spacetime.py @@ -15,10 +15,10 @@ import quaxed.array_api as xp from unxt import Quantity -from .base import Abstract4DVector +from .base import AbstractPosition4D from coordinax._base import AbstractVector -from coordinax._d3.base import Abstract3DVector -from coordinax._d3.builtin import Cartesian3DVector +from coordinax._d3.base import AbstractPosition3D +from coordinax._d3.builtin import CartesianPosition3D from coordinax._typing import BatchableLength, BatchableTime, ScalarTime from coordinax._utils import classproperty @@ -30,7 +30,7 @@ @final -class FourVector(Abstract4DVector): +class FourVector(AbstractPosition4D): """3+1 vector representation. The 3+1 vector representation is a 4-vector with 3 spatial coordinates and 1 @@ -40,7 +40,7 @@ class FourVector(Abstract4DVector): ---------- t : Quantity[float, (*batch,), "time"] Time coordinate. - q : Abstract3DVector[float, (*batch, 3)] + q : AbstractPosition3D[float, (*batch, 3)] Spatial coordinates. c : Quantity[float, (), "speed"], optional Speed of light, by default ``Quantity(299_792.458, "km/s")``. @@ -48,7 +48,7 @@ class FourVector(Abstract4DVector): Examples -------- >>> from unxt import Quantity - >>> from coordinax import FourVector, Cartesian3DVector + >>> from coordinax import FourVector, CartesianPosition3D Create a 3+1 vector with a time and 3 spatial coordinates: @@ -56,17 +56,17 @@ class FourVector(Abstract4DVector): >>> w FourVector( t=Quantity[PhysicalType('time')](value=f32[], unit=Unit("s")), - q=Cartesian3DVector( ... ) + q=CartesianPosition3D( ... ) ) Note that we used a shortcut to create the 3D vector by passing a ``(*batch, 3)`` array to the `q` argument. This assumes that `q` is a - :class:`coordinax.Cartesian3DVector` and uses the - :meth:`coordinax.Cartesian3DVector.constructor` method to create the 3D vector. + :class:`coordinax.CartesianPosition3D` and uses the + :meth:`coordinax.CartesianPosition3D.constructor` method to create the 3D vector. We can also create the 3D vector explicitly: - >>> q = Cartesian3DVector(x=Quantity(1, "m"), y=Quantity(2, "m"), + >>> q = CartesianPosition3D(x=Quantity(1, "m"), y=Quantity(2, "m"), ... z=Quantity(3, "m")) >>> w = FourVector(t=Quantity(1, "s"), q=q) @@ -77,9 +77,11 @@ class FourVector(Abstract4DVector): ) """Time coordinate.""" - q: Abstract3DVector = eqx.field( + q: AbstractPosition3D = eqx.field( converter=lambda q: ( - q if isinstance(q, Abstract3DVector) else Cartesian3DVector.constructor(q) + q + if isinstance(q, AbstractPosition3D) + else CartesianPosition3D.constructor(q) ) ) """Spatial coordinates.""" @@ -134,7 +136,7 @@ def constructor( >>> vec FourVector( t=Quantity[PhysicalType('time')](value=f32[], unit=Unit("m s / km")), - q=Cartesian3DVector( ... ) + q=CartesianPosition3D( ... ) ) >>> xs = Quantity(jnp.array([[0, 1, 2, 3], [10, 4, 5, 6]]), "meter") @@ -142,7 +144,7 @@ def constructor( >>> vec FourVector( t=Quantity[PhysicalType('time')](value=f32[2], unit=Unit("m s / km")), - q=Cartesian3DVector( ... ) + q=CartesianPosition3D( ... ) ) >>> vec.x @@ -166,7 +168,7 @@ def __getattr__(self, name: str) -> Any: Examples -------- >>> from unxt import Quantity - >>> from coordinax import FourVector, Cartesian3DVector + >>> from coordinax import FourVector, CartesianPosition3D >>> w = FourVector(t=Quantity(1, "s"), q=Quantity([1, 2, 3], "m")) >>> w.x @@ -198,13 +200,13 @@ def __neg__(self) -> "FourVector": Examples -------- >>> from unxt import Quantity - >>> from coordinax import FourVector, Cartesian3DVector + >>> from coordinax import FourVector, CartesianPosition3D >>> w = FourVector(t=Quantity(1, "s"), q=Quantity([1, 2, 3], "m")) >>> -w FourVector( t=Quantity[PhysicalType('time')](value=f32[], unit=Unit("s")), - q=Cartesian3DVector( ... ) + q=CartesianPosition3D( ... ) ) """ @@ -219,7 +221,7 @@ def __add__(self, other: Any) -> "FourVector": Examples -------- >>> from unxt import Quantity - >>> from coordinax import FourVector, Cartesian3DVector + >>> from coordinax import FourVector, CartesianPosition3D >>> w1 = FourVector(t=Quantity(1, "s"), q=Quantity([1, 2, 3], "m")) >>> w2 = FourVector(t=Quantity(2, "s"), q=Quantity([4, 5, 6], "m")) @@ -227,7 +229,7 @@ def __add__(self, other: Any) -> "FourVector": >>> w3 FourVector( t=Quantity[PhysicalType('time')](value=f32[], unit=Unit("s")), - q=Cartesian3DVector( ... ) + q=CartesianPosition3D( ... ) ) >>> w3.t @@ -248,7 +250,7 @@ def __sub__(self, other: Any) -> "FourVector": Examples -------- >>> from unxt import Quantity - >>> from coordinax import FourVector, Cartesian3DVector + >>> from coordinax import FourVector, CartesianPosition3D >>> w1 = FourVector(t=Quantity(1, "s"), q=Quantity([1, 2, 3], "m")) >>> w2 = FourVector(t=Quantity(2, "s"), q=Quantity([4, 5, 6], "m")) @@ -256,7 +258,7 @@ def __sub__(self, other: Any) -> "FourVector": >>> w3 FourVector( t=Quantity[PhysicalType('time')](value=f32[], unit=Unit("s")), - q=Cartesian3DVector( ... ) + q=CartesianPosition3D( ... ) ) >>> w3.t @@ -280,7 +282,7 @@ def norm2(self) -> Shaped[Quantity["area"], "*#batch"]: Examples -------- >>> from unxt import Quantity - >>> from coordinax import FourVector, Cartesian3DVector + >>> from coordinax import FourVector, CartesianPosition3D >>> w = FourVector(t=Quantity(1, "s"), q=Quantity([1, 2, 3], "m")) >>> w.norm2() @@ -296,7 +298,7 @@ def norm(self) -> BatchableLength: Examples -------- >>> from unxt import Quantity - >>> from coordinax import FourVector, Cartesian3DVector + >>> from coordinax import FourVector, CartesianPosition3D >>> w = FourVector(t=Quantity(1, "s"), q=Quantity([1, 2, 3], "m")) >>> w.norm() diff --git a/src/coordinax/_dn/base.py b/src/coordinax/_dn/base.py index a6afb77..1f06313 100644 --- a/src/coordinax/_dn/base.py +++ b/src/coordinax/_dn/base.py @@ -1,6 +1,6 @@ """Representation of coordinates in different systems.""" -__all__ = ["AbstractNDVector", "AbstractNDVectorDifferential"] +__all__ = ["AbstractPositionND", "AbstractPositionNDDifferential"] from abc import abstractmethod @@ -19,15 +19,15 @@ from typing_extensions import Never -class AbstractNDVector(AbstractPosition): +class AbstractPositionND(AbstractPosition): """Abstract representation of N-D coordinates in different systems.""" @classproperty @classmethod def _cartesian_cls(cls) -> type[AbstractVector]: - from .builtin import CartesianNDVector + from .builtin import CartesianPositionND - return CartesianNDVector + return CartesianPositionND @classproperty @classmethod @@ -82,20 +82,20 @@ def reshape(self, *hape: Any, order: str = "C") -> "Self": return replace(self, q=self.q.reshape(*hape, self.q.shape[-1], order=order)) -class AbstractNDVectorDifferential(AbstractVelocity): +class AbstractPositionNDDifferential(AbstractVelocity): """Abstract representation of N-D vector differentials.""" @classproperty @classmethod def _cartesian_cls(cls) -> type[AbstractVector]: - from .builtin import CartesianDifferentialND + from .builtin import CartesianVelocityND - return CartesianDifferentialND + return CartesianVelocityND @classproperty @classmethod @abstractmethod - def integral_cls(cls) -> type[AbstractNDVector]: + def integral_cls(cls) -> type[AbstractPositionND]: raise NotImplementedError # =============================================================== diff --git a/src/coordinax/_dn/builtin.py b/src/coordinax/_dn/builtin.py index ebbb0d0..01c000f 100644 --- a/src/coordinax/_dn/builtin.py +++ b/src/coordinax/_dn/builtin.py @@ -2,9 +2,9 @@ __all__ = [ # Position - "CartesianNDVector", + "CartesianPositionND", # Differential - "CartesianDifferentialND", + "CartesianVelocityND", ] from dataclasses import replace @@ -19,7 +19,7 @@ from unxt import Quantity import coordinax._typing as ct -from .base import AbstractNDVector, AbstractNDVectorDifferential +from .base import AbstractPositionND, AbstractPositionNDDifferential from coordinax._base_pos import AbstractPosition from coordinax._utils import classproperty @@ -28,17 +28,17 @@ @final -class CartesianNDVector(AbstractNDVector): +class CartesianPositionND(AbstractPositionND): """N-dimensional Cartesian vector representation. Examples -------- >>> from unxt import Quantity - >>> from coordinax import CartesianNDVector + >>> from coordinax import CartesianPositionND A 1D vector: - >>> q = CartesianNDVector(Quantity([[1]], "kpc")) + >>> q = CartesianPositionND(Quantity([[1]], "kpc")) >>> q.q Quantity['length'](Array([[1.]], dtype=float32), unit='kpc') >>> q.shape @@ -46,7 +46,7 @@ class CartesianNDVector(AbstractNDVector): A 2D vector: - >>> q = CartesianNDVector(Quantity([1, 2], "kpc")) + >>> q = CartesianPositionND(Quantity([1, 2], "kpc")) >>> q.q Quantity['length'](Array([1., 2.], dtype=float32), unit='kpc') >>> q.shape @@ -54,7 +54,7 @@ class CartesianNDVector(AbstractNDVector): A 3D vector: - >>> q = CartesianNDVector(Quantity([1, 2, 3], "kpc")) + >>> q = CartesianPositionND(Quantity([1, 2, 3], "kpc")) >>> q.q Quantity['length'](Array([1., 2., 3.], dtype=float32), unit='kpc') >>> q.shape @@ -62,7 +62,7 @@ class CartesianNDVector(AbstractNDVector): A 4D vector: - >>> q = CartesianNDVector(Quantity([1, 2, 3, 4], "kpc")) + >>> q = CartesianPositionND(Quantity([1, 2, 3, 4], "kpc")) >>> q.q Quantity['length'](Array([1., 2., 3., 4.], dtype=float32), unit='kpc') >>> q.shape @@ -70,7 +70,7 @@ class CartesianNDVector(AbstractNDVector): A 5D vector: - >>> q = CartesianNDVector(Quantity([1, 2, 3, 4, 5], "kpc")) + >>> q = CartesianPositionND(Quantity([1, 2, 3, 4, 5], "kpc")) >>> q.q Quantity['length'](Array([1., 2., 3., 4., 5.], dtype=float32), unit='kpc') >>> q.shape @@ -90,8 +90,8 @@ class CartesianNDVector(AbstractNDVector): @classproperty @classmethod @override - def differential_cls(cls) -> type["CartesianDifferentialND"]: # type: ignore[override] - return CartesianDifferentialND + def differential_cls(cls) -> type["CartesianVelocityND"]: # type: ignore[override] + return CartesianVelocityND # ----------------------------------------------------- # Unary operations @@ -102,11 +102,11 @@ def __neg__(self) -> "Self": Examples -------- >>> from unxt import Quantity - >>> from coordinax import CartesianNDVector + >>> from coordinax import CartesianPositionND A 3D vector: - >>> q = CartesianNDVector(Quantity([1, 2, 3], "kpc")) + >>> q = CartesianPositionND(Quantity([1, 2, 3], "kpc")) >>> (-q).q Quantity['length'](Array([-1., -2., -3.], dtype=float32), unit='kpc') @@ -116,18 +116,18 @@ def __neg__(self) -> "Self": # ----------------------------------------------------- # Binary operations - def __add__(self, other: Any, /) -> "CartesianNDVector": + def __add__(self, other: Any, /) -> "CartesianPositionND": """Add two vectors. Examples -------- >>> from unxt import Quantity - >>> from coordinax import CartesianNDVector + >>> from coordinax import CartesianPositionND A 3D vector: - >>> q1 = CartesianNDVector(Quantity([1, 2, 3], "kpc")) - >>> q2 = CartesianNDVector(Quantity([2, 3, 4], "kpc")) + >>> q1 = CartesianPositionND(Quantity([1, 2, 3], "kpc")) + >>> q2 = CartesianPositionND(Quantity([2, 3, 4], "kpc")) >>> (q1 + q2).q Quantity['length'](Array([3., 5., 7.], dtype=float32), unit='kpc') @@ -136,21 +136,21 @@ def __add__(self, other: Any, /) -> "CartesianNDVector": msg = f"Cannot add {self._cartesian_cls!r} and {type(other)!r}." raise TypeError(msg) - cart = other.represent_as(CartesianNDVector) + cart = other.represent_as(CartesianPositionND) return replace(self, q=self.q + cart.q) - def __sub__(self, other: Any, /) -> "CartesianNDVector": + def __sub__(self, other: Any, /) -> "CartesianPositionND": """Subtract two vectors. Examples -------- >>> from unxt import Quantity - >>> from coordinax import CartesianNDVector + >>> from coordinax import CartesianPositionND A 3D vector: - >>> q1 = CartesianNDVector(Quantity([1, 2, 3], "kpc")) - >>> q2 = CartesianNDVector(Quantity([2, 3, 4], "kpc")) + >>> q1 = CartesianPositionND(Quantity([1, 2, 3], "kpc")) + >>> q2 = CartesianPositionND(Quantity([2, 3, 4], "kpc")) >>> (q1 - q2).q Quantity['length'](Array([-1., -1., -1.], dtype=float32), unit='kpc') @@ -159,7 +159,7 @@ def __sub__(self, other: Any, /) -> "CartesianNDVector": msg = f"Cannot subtract {self._cartesian_cls!r} and {type(other)!r}." raise TypeError(msg) - cart = other.represent_as(CartesianNDVector) + cart = other.represent_as(CartesianPositionND) return replace(self, q=self.q - cart.q) # ----------------------------------------------------- @@ -171,11 +171,11 @@ def norm(self) -> ct.BatchableLength: Examples -------- >>> from unxt import Quantity - >>> from coordinax import CartesianNDVector + >>> from coordinax import CartesianPositionND A 3D vector: - >>> q = CartesianNDVector(Quantity([1, 2, 3], "kpc")) + >>> q = CartesianPositionND(Quantity([1, 2, 3], "kpc")) >>> q.norm() Quantity['length'](Array(3.7416575, dtype=float32), unit='kpc') @@ -188,17 +188,17 @@ def norm(self) -> ct.BatchableLength: @final -class CartesianDifferentialND(AbstractNDVectorDifferential): +class CartesianVelocityND(AbstractPositionNDDifferential): """Cartesian differential representation. Examples -------- >>> from unxt import Quantity - >>> from coordinax import CartesianDifferentialND + >>> from coordinax import CartesianVelocityND A 1D vector: - >>> q = CartesianDifferentialND(Quantity([[1]], "km/s")) + >>> q = CartesianVelocityND(Quantity([[1]], "km/s")) >>> q.d_q Quantity['speed'](Array([[1.]], dtype=float32), unit='km / s') >>> q.shape @@ -206,7 +206,7 @@ class CartesianDifferentialND(AbstractNDVectorDifferential): A 2D vector: - >>> q = CartesianDifferentialND(Quantity([1, 2], "km/s")) + >>> q = CartesianVelocityND(Quantity([1, 2], "km/s")) >>> q.d_q Quantity['speed'](Array([1., 2.], dtype=float32), unit='km / s') >>> q.shape @@ -214,7 +214,7 @@ class CartesianDifferentialND(AbstractNDVectorDifferential): A 3D vector: - >>> q = CartesianDifferentialND(Quantity([1, 2, 3], "km/s")) + >>> q = CartesianVelocityND(Quantity([1, 2, 3], "km/s")) >>> q.d_q Quantity['speed'](Array([1., 2., 3.], dtype=float32), unit='km / s') >>> q.shape @@ -222,7 +222,7 @@ class CartesianDifferentialND(AbstractNDVectorDifferential): A 4D vector: - >>> q = CartesianDifferentialND(Quantity([1, 2, 3, 4], "km/s")) + >>> q = CartesianVelocityND(Quantity([1, 2, 3, 4], "km/s")) >>> q.d_q Quantity['speed'](Array([1., 2., 3., 4.], dtype=float32), unit='km / s') >>> q.shape @@ -230,7 +230,7 @@ class CartesianDifferentialND(AbstractNDVectorDifferential): A 5D vector: - >>> q = CartesianDifferentialND(Quantity([1, 2, 3, 4, 5], "km/s")) + >>> q = CartesianVelocityND(Quantity([1, 2, 3, 4, 5], "km/s")) >>> q.d_q Quantity['speed'](Array([1., 2., 3., 4., 5.], dtype=float32), unit='km / s') >>> q.shape @@ -249,21 +249,21 @@ class CartesianDifferentialND(AbstractNDVectorDifferential): @classproperty @classmethod - def integral_cls(cls) -> type[CartesianNDVector]: - return CartesianNDVector + def integral_cls(cls) -> type[CartesianPositionND]: + return CartesianPositionND @partial(jax.jit) - def norm(self, _: AbstractNDVector | None = None, /) -> ct.BatchableSpeed: + def norm(self, _: AbstractPositionND | None = None, /) -> ct.BatchableSpeed: """Return the norm of the vector. Examples -------- >>> from unxt import Quantity - >>> from coordinax import CartesianDifferentialND + >>> from coordinax import CartesianVelocityND A 3D vector: - >>> c = CartesianDifferentialND(Quantity([1, 2, 3], "km/s")) + >>> c = CartesianVelocityND(Quantity([1, 2, 3], "km/s")) >>> c.norm() Quantity['speed'](Array(3.7416575, dtype=float32), unit='km / s') diff --git a/src/coordinax/_dn/transform.py b/src/coordinax/_dn/transform.py index 71d7085..dceddab 100644 --- a/src/coordinax/_dn/transform.py +++ b/src/coordinax/_dn/transform.py @@ -7,8 +7,8 @@ from plum import dispatch from .builtin import ( - CartesianDifferentialND, - CartesianNDVector, + CartesianPositionND, + CartesianVelocityND, ) ############################################################################### @@ -17,19 +17,19 @@ @dispatch def represent_as( - current: CartesianNDVector, target: type[CartesianNDVector], /, **kwargs: Any -) -> CartesianNDVector: - """CartesianNDVector -> CartesianNDVector.""" + current: CartesianPositionND, target: type[CartesianPositionND], /, **kwargs: Any +) -> CartesianPositionND: + """CartesianPositionND -> CartesianPositionND.""" return current @dispatch def represent_as( - current: CartesianDifferentialND, - target: type[CartesianDifferentialND], - position: CartesianNDVector, + current: CartesianVelocityND, + target: type[CartesianVelocityND], + position: CartesianPositionND, /, **kwargs: Any, -) -> CartesianDifferentialND: - """CartesianDifferentialND -> CartesianDifferentialND.""" +) -> CartesianVelocityND: + """CartesianVelocityND -> CartesianVelocityND.""" return current diff --git a/src/coordinax/_transform/d1.py b/src/coordinax/_transform/d1.py index d730cae..935ce14 100644 --- a/src/coordinax/_transform/d1.py +++ b/src/coordinax/_transform/d1.py @@ -9,13 +9,13 @@ from unxt import Quantity -from coordinax._d1.builtin import Cartesian1DVector, RadialVector -from coordinax._d2.builtin import Cartesian2DVector, PolarVector -from coordinax._d3.builtin import Cartesian3DVector, CylindricalVector -from coordinax._d3.sphere import MathSphericalVector, SphericalVector +from coordinax._d1.builtin import CartesianPosition1D, RadialPosition +from coordinax._d2.builtin import CartesianPosition2D, PolarPosition +from coordinax._d3.builtin import CartesianPosition3D, CylindricalPosition +from coordinax._d3.sphere import MathSphericalPosition, SphericalPosition # ============================================================================= -# Cartesian1DVector +# CartesianPosition1D # ----------------------------------------------- @@ -24,14 +24,14 @@ @dispatch def represent_as( - current: Cartesian1DVector, - target: type[Cartesian2DVector], + current: CartesianPosition1D, + target: type[CartesianPosition2D], /, *, y: Quantity = Quantity(0.0, u.m), **kwargs: Any, -) -> Cartesian2DVector: - """Cartesian1DVector -> Cartesian2DVector. +) -> CartesianPosition2D: + """CartesianPosition1D -> CartesianPosition2D. The `x` coordinate is converted to the `x` coordinate of the 2D system. The `y` coordinate is a keyword argument and defaults to 0. @@ -41,15 +41,15 @@ def represent_as( >>> from unxt import Quantity >>> import coordinax as cx - >>> x = cx.Cartesian1DVector(x=Quantity(1.0, "km")) - >>> x2 = cx.represent_as(x, cx.Cartesian2DVector) + >>> x = cx.CartesianPosition1D(x=Quantity(1.0, "km")) + >>> x2 = cx.represent_as(x, cx.CartesianPosition2D) >>> x2 - Cartesian2DVector( x=Quantity[...](value=f32[], unit=Unit("km")), + CartesianPosition2D( x=Quantity[...](value=f32[], unit=Unit("km")), y=Quantity[...](value=f32[], unit=Unit("m")) ) >>> x2.y Quantity['length'](Array(0., dtype=float32), unit='m') - >>> x3 = cx.represent_as(x, cx.Cartesian3DVector, y=Quantity(14, "km")) + >>> x3 = cx.represent_as(x, cx.CartesianPosition3D, y=Quantity(14, "km")) >>> x3.y Quantity['length'](Array(14., dtype=float32), unit='km') @@ -59,14 +59,14 @@ def represent_as( @dispatch def represent_as( - current: Cartesian1DVector, - target: type[PolarVector], + current: CartesianPosition1D, + target: type[PolarPosition], /, *, phi: Quantity = Quantity(0.0, u.radian), **kwargs: Any, -) -> PolarVector: - """Cartesian1DVector -> PolarVector. +) -> PolarPosition: + """CartesianPosition1D -> PolarPosition. The `x` coordinate is converted to the radial coordinate `r`. The `phi` coordinate is a keyword argument and defaults to 0. @@ -76,15 +76,15 @@ def represent_as( >>> from unxt import Quantity >>> import coordinax as cx - >>> x = cx.Cartesian1DVector(x=Quantity(1.0, "km")) - >>> x2 = cx.represent_as(x, cx.PolarVector) + >>> x = cx.CartesianPosition1D(x=Quantity(1.0, "km")) + >>> x2 = cx.represent_as(x, cx.PolarPosition) >>> x2 - PolarVector( r=Distance(value=f32[], unit=Unit("km")), + PolarPosition( r=Distance(value=f32[], unit=Unit("km")), phi=Quantity[...](value=f32[], unit=Unit("rad")) ) >>> x2.phi Quantity['angle'](Array(0., dtype=float32), unit='rad') - >>> x3 = cx.represent_as(x, cx.PolarVector, phi=Quantity(14, "deg")) + >>> x3 = cx.represent_as(x, cx.PolarPosition, phi=Quantity(14, "deg")) >>> x3.phi Quantity['angle'](Array(14., dtype=float32), unit='deg') @@ -98,15 +98,15 @@ def represent_as( @dispatch def represent_as( - current: Cartesian1DVector, - target: type[Cartesian3DVector], + current: CartesianPosition1D, + target: type[CartesianPosition3D], /, *, y: Quantity = Quantity(0.0, u.m), z: Quantity = Quantity(0.0, u.m), **kwargs: Any, -) -> Cartesian3DVector: - """Cartesian1DVector -> Cartesian3DVector. +) -> CartesianPosition3D: + """CartesianPosition1D -> CartesianPosition3D. The `x` coordinate is converted to the `x` coordinate of the 3D system. The `y` and `z` coordinates are keyword arguments and default to 0. @@ -116,10 +116,10 @@ def represent_as( >>> from unxt import Quantity >>> import coordinax as cx - >>> x = cx.Cartesian1DVector(x=Quantity(1.0, "km")) - >>> x2 = cx.represent_as(x, cx.Cartesian3DVector) + >>> x = cx.CartesianPosition1D(x=Quantity(1.0, "km")) + >>> x2 = cx.represent_as(x, cx.CartesianPosition3D) >>> x2 - Cartesian3DVector( x=Quantity[...](value=f32[], unit=Unit("km")), + CartesianPosition3D( x=Quantity[...](value=f32[], unit=Unit("km")), y=Quantity[...](value=f32[], unit=Unit("m")), z=Quantity[...](value=f32[], unit=Unit("m")) ) >>> x2.y @@ -127,7 +127,7 @@ def represent_as( >>> x2.z Quantity['length'](Array(0., dtype=float32), unit='m') - >>> x3 = cx.represent_as(x, cx.Cartesian3DVector, y=Quantity(14, "km")) + >>> x3 = cx.represent_as(x, cx.CartesianPosition3D, y=Quantity(14, "km")) >>> x3.y Quantity['length'](Array(14., dtype=float32), unit='km') >>> x3.z @@ -139,15 +139,15 @@ def represent_as( @dispatch def represent_as( - current: Cartesian1DVector, - target: type[SphericalVector] | type[MathSphericalVector], + current: CartesianPosition1D, + target: type[SphericalPosition] | type[MathSphericalPosition], /, *, theta: Quantity = Quantity(0.0, u.radian), phi: Quantity = Quantity(0.0, u.radian), **kwargs: Any, -) -> SphericalVector | MathSphericalVector: - """Cartesian1DVector -> SphericalVector | MathSphericalVector. +) -> SphericalPosition | MathSphericalPosition: + """CartesianPosition1D -> SphericalPosition | MathSphericalPosition. The `x` coordinate is converted to the radial coordinate `r`. The `theta` and `phi` coordinates are keyword arguments and default to 0. @@ -157,12 +157,12 @@ def represent_as( >>> from unxt import Quantity >>> import coordinax as cx - SphericalVector: + SphericalPosition: - >>> x = cx.Cartesian1DVector(x=Quantity(1.0, "km")) - >>> x2 = cx.represent_as(x, cx.SphericalVector) + >>> x = cx.CartesianPosition1D(x=Quantity(1.0, "km")) + >>> x2 = cx.represent_as(x, cx.SphericalPosition) >>> x2 - SphericalVector( r=Distance(value=f32[], unit=Unit("km")), + SphericalPosition( r=Distance(value=f32[], unit=Unit("km")), theta=Quantity[...](value=f32[], unit=Unit("rad")), phi=Quantity[...](value=f32[], unit=Unit("rad")) ) >>> x2.phi @@ -170,17 +170,17 @@ def represent_as( >>> x2.theta Quantity['angle'](Array(0., dtype=float32), unit='rad') - >>> x3 = cx.represent_as(x, cx.SphericalVector, phi=Quantity(14, "deg")) + >>> x3 = cx.represent_as(x, cx.SphericalPosition, phi=Quantity(14, "deg")) >>> x3.phi Quantity['angle'](Array(14., dtype=float32), unit='deg') >>> x2.theta Quantity['angle'](Array(0., dtype=float32), unit='rad') - MathSphericalVector: + MathSphericalPosition: - >>> x2 = cx.represent_as(x, cx.MathSphericalVector) + >>> x2 = cx.represent_as(x, cx.MathSphericalPosition) >>> x2 - MathSphericalVector( r=Distance(value=f32[], unit=Unit("km")), + MathSphericalPosition( r=Distance(value=f32[], unit=Unit("km")), theta=Quantity[...](value=f32[], unit=Unit("rad")), phi=Quantity[...](value=f32[], unit=Unit("rad")) ) >>> x2.theta @@ -188,7 +188,7 @@ def represent_as( >>> x2.phi Quantity['angle'](Array(0., dtype=float32), unit='rad') - >>> x3 = cx.represent_as(x, cx.MathSphericalVector, phi=Quantity(14, "deg")) + >>> x3 = cx.represent_as(x, cx.MathSphericalPosition, phi=Quantity(14, "deg")) >>> x3.theta Quantity['angle'](Array(0., dtype=float32), unit='rad') >>> x3.phi @@ -200,15 +200,15 @@ def represent_as( @dispatch def represent_as( - current: Cartesian1DVector, - target: type[CylindricalVector], + current: CartesianPosition1D, + target: type[CylindricalPosition], /, *, phi: Quantity = Quantity(0.0, u.radian), z: Quantity = Quantity(0.0, u.m), **kwargs: Any, -) -> CylindricalVector: - """Cartesian1DVector -> CylindricalVector. +) -> CylindricalPosition: + """CartesianPosition1D -> CylindricalPosition. The `x` coordinate is converted to the radial coordinate `rho`. The `phi` and `z` coordinates are keyword arguments and default to 0. @@ -218,10 +218,10 @@ def represent_as( >>> from unxt import Quantity >>> import coordinax as cx - >>> x = cx.Cartesian1DVector(x=Quantity(1.0, "km")) - >>> x2 = cx.represent_as(x, cx.CylindricalVector) + >>> x = cx.CartesianPosition1D(x=Quantity(1.0, "km")) + >>> x2 = cx.represent_as(x, cx.CylindricalPosition) >>> x2 - CylindricalVector( rho=Quantity[...](value=f32[], unit=Unit("km")), + CylindricalPosition( rho=Quantity[...](value=f32[], unit=Unit("km")), phi=Quantity[...](value=f32[], unit=Unit("rad")), z=Quantity[...](value=f32[], unit=Unit("m")) ) >>> x2.phi @@ -229,7 +229,7 @@ def represent_as( >>> x2.z Quantity['length'](Array(0., dtype=float32), unit='m') - >>> x3 = cx.represent_as(x, cx.CylindricalVector, phi=Quantity(14, "deg")) + >>> x3 = cx.represent_as(x, cx.CylindricalPosition, phi=Quantity(14, "deg")) >>> x3.phi Quantity['angle'](Array(14., dtype=float32), unit='deg') >>> x3.z @@ -240,7 +240,7 @@ def represent_as( # ============================================================================= -# RadialVector +# RadialPosition # ----------------------------------------------- # 2D @@ -248,14 +248,14 @@ def represent_as( @dispatch def represent_as( - current: RadialVector, - target: type[Cartesian2DVector], + current: RadialPosition, + target: type[CartesianPosition2D], /, *, y: Quantity = Quantity(0.0, u.m), **kwargs: Any, -) -> Cartesian2DVector: - """RadialVector -> Cartesian2DVector. +) -> CartesianPosition2D: + """RadialPosition -> CartesianPosition2D. The `r` coordinate is converted to the cartesian coordinate `x`. The `y` coordinate is a keyword argument and defaults to 0. @@ -265,15 +265,15 @@ def represent_as( >>> from unxt import Quantity >>> import coordinax as cx - >>> x = cx.RadialVector(r=Quantity(1.0, "km")) - >>> x2 = cx.represent_as(x, cx.Cartesian2DVector) + >>> x = cx.RadialPosition(r=Quantity(1.0, "km")) + >>> x2 = cx.represent_as(x, cx.CartesianPosition2D) >>> x2 - Cartesian2DVector( x=Quantity[...](value=f32[], unit=Unit("km")), + CartesianPosition2D( x=Quantity[...](value=f32[], unit=Unit("km")), y=Quantity[...](value=f32[], unit=Unit("m")) ) >>> x2.y Quantity['length'](Array(0., dtype=float32), unit='m') - >>> x3 = cx.represent_as(x, cx.Cartesian2DVector, y=Quantity(14, "km")) + >>> x3 = cx.represent_as(x, cx.CartesianPosition2D, y=Quantity(14, "km")) >>> x3.y Quantity['length'](Array(14., dtype=float32), unit='km') @@ -283,14 +283,14 @@ def represent_as( @dispatch def represent_as( - current: RadialVector, - target: type[PolarVector], + current: RadialPosition, + target: type[PolarPosition], /, *, phi: Quantity = Quantity(0.0, u.radian), **kwargs: Any, -) -> PolarVector: - """RadialVector -> PolarVector. +) -> PolarPosition: + """RadialPosition -> PolarPosition. The `r` coordinate is converted to the radial coordinate `r`. The `phi` coordinate is a keyword argument and defaults to 0. @@ -300,15 +300,15 @@ def represent_as( >>> from unxt import Quantity >>> import coordinax as cx - >>> x = cx.RadialVector(r=Quantity(1.0, "km")) - >>> x2 = cx.represent_as(x, cx.PolarVector) + >>> x = cx.RadialPosition(r=Quantity(1.0, "km")) + >>> x2 = cx.represent_as(x, cx.PolarPosition) >>> x2 - PolarVector( r=Distance(value=f32[], unit=Unit("km")), + PolarPosition( r=Distance(value=f32[], unit=Unit("km")), phi=Quantity[...](value=f32[], unit=Unit("rad")) ) >>> x2.phi Quantity['angle'](Array(0., dtype=float32), unit='rad') - >>> x3 = cx.represent_as(x, cx.PolarVector, phi=Quantity(14, "deg")) + >>> x3 = cx.represent_as(x, cx.PolarPosition, phi=Quantity(14, "deg")) >>> x3.phi Quantity['angle'](Array(14., dtype=float32), unit='deg') @@ -322,15 +322,15 @@ def represent_as( @dispatch def represent_as( - current: RadialVector, - target: type[Cartesian3DVector], + current: RadialPosition, + target: type[CartesianPosition3D], /, *, y: Quantity = Quantity(0.0, u.m), z: Quantity = Quantity(0.0, u.m), **kwargs: Any, -) -> Cartesian3DVector: - """RadialVector -> Cartesian3DVector. +) -> CartesianPosition3D: + """RadialPosition -> CartesianPosition3D. The `r` coordinate is converted to the `x` coordinate of the 3D system. The `y` and `z` coordinates are keyword arguments and default to 0. @@ -340,10 +340,10 @@ def represent_as( >>> from unxt import Quantity >>> import coordinax as cx - >>> x = cx.RadialVector(r=Quantity(1.0, "km")) - >>> x2 = cx.represent_as(x, cx.Cartesian3DVector) + >>> x = cx.RadialPosition(r=Quantity(1.0, "km")) + >>> x2 = cx.represent_as(x, cx.CartesianPosition3D) >>> x2 - Cartesian3DVector( x=Quantity[...](value=f32[], unit=Unit("km")), + CartesianPosition3D( x=Quantity[...](value=f32[], unit=Unit("km")), y=Quantity[...](value=f32[], unit=Unit("m")), z=Quantity[...](value=f32[], unit=Unit("m")) ) >>> x2.y @@ -351,7 +351,7 @@ def represent_as( >>> x2.z Quantity['length'](Array(0., dtype=float32), unit='m') - >>> x3 = cx.represent_as(x, cx.Cartesian3DVector, y=Quantity(14, "km")) + >>> x3 = cx.represent_as(x, cx.CartesianPosition3D, y=Quantity(14, "km")) >>> x3.y Quantity['length'](Array(14., dtype=float32), unit='km') >>> x3.z @@ -363,15 +363,15 @@ def represent_as( @dispatch def represent_as( - current: RadialVector, - target: type[SphericalVector] | type[MathSphericalVector], + current: RadialPosition, + target: type[SphericalPosition] | type[MathSphericalPosition], /, *, theta: Quantity = Quantity(0.0, u.radian), phi: Quantity = Quantity(0.0, u.radian), **kwargs: Any, -) -> SphericalVector | MathSphericalVector: - """RadialVector -> SphericalVector | MathSphericalVector. +) -> SphericalPosition | MathSphericalPosition: + """RadialPosition -> SphericalPosition | MathSphericalPosition. The `r` coordinate is converted to the radial coordinate `r`. The `theta` and `phi` coordinates are keyword arguments and default to 0. @@ -381,13 +381,13 @@ def represent_as( >>> from unxt import Quantity >>> import coordinax as cx - >>> x = cx.RadialVector(r=Quantity(1.0, "km")) + >>> x = cx.RadialPosition(r=Quantity(1.0, "km")) - SphericalVector: + SphericalPosition: - >>> x2 = cx.represent_as(x, cx.SphericalVector) + >>> x2 = cx.represent_as(x, cx.SphericalPosition) >>> x2 - SphericalVector( r=Distance(value=f32[], unit=Unit("km")), + SphericalPosition( r=Distance(value=f32[], unit=Unit("km")), theta=Quantity[...](value=f32[], unit=Unit("rad")), phi=Quantity[...](value=f32[], unit=Unit("rad")) ) >>> x2.phi @@ -395,17 +395,17 @@ def represent_as( >>> x2.theta Quantity['angle'](Array(0., dtype=float32), unit='rad') - >>> x3 = cx.represent_as(x, cx.SphericalVector, phi=Quantity(14, "deg")) + >>> x3 = cx.represent_as(x, cx.SphericalPosition, phi=Quantity(14, "deg")) >>> x3.phi Quantity['angle'](Array(14., dtype=float32), unit='deg') >>> x3.theta Quantity['angle'](Array(0., dtype=float32), unit='rad') - MathSphericalVector: + MathSphericalPosition: - >>> x2 = cx.represent_as(x, cx.MathSphericalVector) + >>> x2 = cx.represent_as(x, cx.MathSphericalPosition) >>> x2 - MathSphericalVector( r=Distance(value=f32[], unit=Unit("km")), + MathSphericalPosition( r=Distance(value=f32[], unit=Unit("km")), theta=Quantity[...](value=f32[], unit=Unit("rad")), phi=Quantity[...](value=f32[], unit=Unit("rad")) ) >>> x2.theta @@ -413,7 +413,7 @@ def represent_as( >>> x2.phi Quantity['angle'](Array(0., dtype=float32), unit='rad') - >>> x3 = cx.represent_as(x, cx.MathSphericalVector, phi=Quantity(14, "deg")) + >>> x3 = cx.represent_as(x, cx.MathSphericalPosition, phi=Quantity(14, "deg")) >>> x3.theta Quantity['angle'](Array(0., dtype=float32), unit='rad') >>> x3.phi @@ -425,15 +425,15 @@ def represent_as( @dispatch def represent_as( - current: RadialVector, - target: type[CylindricalVector], + current: RadialPosition, + target: type[CylindricalPosition], /, *, phi: Quantity = Quantity(0.0, u.radian), z: Quantity = Quantity(0.0, u.m), **kwargs: Any, -) -> CylindricalVector: - """RadialVector -> CylindricalVector. +) -> CylindricalPosition: + """RadialPosition -> CylindricalPosition. The `r` coordinate is converted to the radial coordinate `rho`. The `phi` and `z` coordinates are keyword arguments and default to 0. @@ -443,10 +443,10 @@ def represent_as( >>> from unxt import Quantity >>> import coordinax as cx - >>> x = cx.RadialVector(r=Quantity(1.0, "km")) - >>> x2 = cx.represent_as(x, cx.CylindricalVector) + >>> x = cx.RadialPosition(r=Quantity(1.0, "km")) + >>> x2 = cx.represent_as(x, cx.CylindricalPosition) >>> x2 - CylindricalVector( rho=Quantity[...](value=f32[], unit=Unit("km")), + CylindricalPosition( rho=Quantity[...](value=f32[], unit=Unit("km")), phi=Quantity[...](value=f32[], unit=Unit("rad")), z=Quantity[...](value=f32[], unit=Unit("m")) ) >>> x2.phi @@ -454,7 +454,7 @@ def represent_as( >>> x2.z Quantity['length'](Array(0., dtype=float32), unit='m') - >>> x3 = cx.represent_as(x, cx.CylindricalVector, phi=Quantity(14, "deg")) + >>> x3 = cx.represent_as(x, cx.CylindricalPosition, phi=Quantity(14, "deg")) >>> x3.phi Quantity['angle'](Array(14., dtype=float32), unit='deg') >>> x3.z diff --git a/src/coordinax/_transform/d2.py b/src/coordinax/_transform/d2.py index cdbef6b..6b51273 100644 --- a/src/coordinax/_transform/d2.py +++ b/src/coordinax/_transform/d2.py @@ -11,28 +11,28 @@ import quaxed.array_api as xp from unxt import Quantity -from coordinax._d1.builtin import Cartesian1DVector, RadialVector -from coordinax._d2.base import Abstract2DVector -from coordinax._d2.builtin import Cartesian2DVector, PolarVector -from coordinax._d3.base import Abstract3DVector -from coordinax._d3.builtin import Cartesian3DVector, CylindricalVector -from coordinax._d3.sphere import MathSphericalVector, SphericalVector +from coordinax._d1.builtin import CartesianPosition1D, RadialPosition +from coordinax._d2.base import AbstractPosition2D +from coordinax._d2.builtin import CartesianPosition2D, PolarPosition +from coordinax._d3.base import AbstractPosition3D +from coordinax._d3.builtin import CartesianPosition3D, CylindricalPosition +from coordinax._d3.sphere import MathSphericalPosition, SphericalPosition from coordinax._exceptions import IrreversibleDimensionChange @dispatch.multi( - (Cartesian2DVector, type[CylindricalVector]), - (Cartesian2DVector, type[SphericalVector]), - (Cartesian2DVector, type[MathSphericalVector]), + (CartesianPosition2D, type[CylindricalPosition]), + (CartesianPosition2D, type[SphericalPosition]), + (CartesianPosition2D, type[MathSphericalPosition]), ) def represent_as( - current: Abstract2DVector, - target: type[Abstract3DVector], + current: AbstractPosition2D, + target: type[AbstractPosition3D], /, z: Quantity = Quantity(0.0, u.m), **kwargs: Any, -) -> Abstract3DVector: - """Abstract2DVector -> Cartesian2D -> Cartesian3D -> Abstract3DVector. +) -> AbstractPosition3D: + """AbstractPosition2D -> Cartesian2D -> Cartesian3D -> AbstractPosition3D. The 2D vector is in the xy plane. The `z` coordinate is a keyword argument and defaults to 0. @@ -42,49 +42,49 @@ def represent_as( >>> from unxt import Quantity >>> import coordinax as cx - >>> x = cx.Cartesian2DVector.constructor(Quantity([1.0, 2.0], "km")) + >>> x = cx.CartesianPosition2D.constructor(Quantity([1.0, 2.0], "km")) - >>> x2 = cx.represent_as(x, cx.CylindricalVector, z=Quantity(14, "km")) + >>> x2 = cx.represent_as(x, cx.CylindricalPosition, z=Quantity(14, "km")) >>> x2 - CylindricalVector( rho=Quantity[...](value=f32[], unit=Unit("km")), + CylindricalPosition( rho=Quantity[...](value=f32[], unit=Unit("km")), phi=Quantity[...](value=f32[], unit=Unit("rad")), z=Quantity[...](value=f32[], unit=Unit("km")) ) >>> x2.z Quantity['length'](Array(14., dtype=float32), unit='km') - >>> x3 = cx.represent_as(x, cx.SphericalVector, z=Quantity(14, "km")) + >>> x3 = cx.represent_as(x, cx.SphericalPosition, z=Quantity(14, "km")) >>> x3 - SphericalVector( r=Distance(value=f32[], unit=Unit("km")), + SphericalPosition( r=Distance(value=f32[], unit=Unit("km")), theta=Quantity[...](value=f32[], unit=Unit("rad")), phi=Quantity[...](value=f32[], unit=Unit("rad")) ) >>> x3.r Distance(Array(14.177447, dtype=float32), unit='km') - >>> x3 = cx.represent_as(x, cx.MathSphericalVector, z=Quantity(14, "km")) + >>> x3 = cx.represent_as(x, cx.MathSphericalPosition, z=Quantity(14, "km")) >>> x3 - MathSphericalVector( r=Distance(value=f32[], unit=Unit("km")), + MathSphericalPosition( r=Distance(value=f32[], unit=Unit("km")), theta=Quantity[...](value=f32[], unit=Unit("rad")), phi=Quantity[...](value=f32[], unit=Unit("rad")) ) >>> x3.r Distance(Array(14.177447, dtype=float32), unit='km') """ - cart2 = represent_as(current, Cartesian2DVector) - cart3 = represent_as(cart2, Cartesian3DVector, z=z) + cart2 = represent_as(current, CartesianPosition2D) + cart3 = represent_as(cart2, CartesianPosition3D, z=z) return represent_as(cart3, target) @dispatch.multi( - (PolarVector, type[Cartesian3DVector]), + (PolarPosition, type[CartesianPosition3D]), ) def represent_as( - current: Abstract2DVector, - target: type[Abstract3DVector], + current: AbstractPosition2D, + target: type[AbstractPosition3D], /, z: Quantity = Quantity(0.0, u.m), **kwargs: Any, -) -> Abstract3DVector: - """Abstract2DVector -> PolarVector -> Cylindrical -> Abstract3DVector. +) -> AbstractPosition3D: + """AbstractPosition2D -> PolarPosition -> Cylindrical -> AbstractPosition3D. The 2D vector is in the xy plane. The `z` coordinate is a keyword argument and defaults to 0. @@ -94,24 +94,24 @@ def represent_as( >>> from unxt import Quantity >>> import coordinax as cx - >>> x = cx.PolarVector(r=Quantity(1.0, "km"), phi=Quantity(10.0, "deg")) + >>> x = cx.PolarPosition(r=Quantity(1.0, "km"), phi=Quantity(10.0, "deg")) - >>> x2 = cx.represent_as(x, cx.Cartesian3DVector, z=Quantity(14, "km")) + >>> x2 = cx.represent_as(x, cx.CartesianPosition3D, z=Quantity(14, "km")) >>> x2 - Cartesian3DVector( x=Quantity[...](value=f32[], unit=Unit("km")), + CartesianPosition3D( x=Quantity[...](value=f32[], unit=Unit("km")), y=Quantity[...](value=f32[], unit=Unit("km")), z=Quantity[...](value=f32[], unit=Unit("km")) ) >>> x2.z Quantity['length'](Array(14., dtype=float32), unit='km') """ - polar = represent_as(current, PolarVector) - cyl = represent_as(polar, CylindricalVector, z=z) + polar = represent_as(current, PolarPosition) + cyl = represent_as(polar, CylindricalPosition, z=z) return represent_as(cyl, target) # ============================================================================= -# Cartesian2DVector +# CartesianPosition2D # ----------------------------------------------- @@ -120,9 +120,9 @@ def represent_as( @dispatch def represent_as( - current: Cartesian2DVector, target: type[Cartesian1DVector], /, **kwargs: Any -) -> Cartesian1DVector: - """Cartesian2DVector -> Cartesian1DVector. + current: CartesianPosition2D, target: type[CartesianPosition1D], /, **kwargs: Any +) -> CartesianPosition1D: + """CartesianPosition2D -> CartesianPosition1D. The `y` coordinate is dropped. @@ -132,13 +132,13 @@ def represent_as( >>> from unxt import Quantity >>> import coordinax as cx - >>> x = cx.Cartesian2DVector.constructor(Quantity([1.0, 2.0], "km")) + >>> x = cx.CartesianPosition2D.constructor(Quantity([1.0, 2.0], "km")) >>> with warnings.catch_warnings(): ... warnings.simplefilter("ignore") - ... x2 = cx.represent_as(x, cx.Cartesian1DVector, z=Quantity(14, "km")) + ... x2 = cx.represent_as(x, cx.CartesianPosition1D, z=Quantity(14, "km")) >>> x2 - Cartesian1DVector( x=Quantity[...](value=f32[], unit=Unit("km")) ) + CartesianPosition1D( x=Quantity[...](value=f32[], unit=Unit("km")) ) >>> x2.x Quantity['length'](Array(1., dtype=float32), unit='km') @@ -149,9 +149,9 @@ def represent_as( @dispatch def represent_as( - current: Cartesian2DVector, target: type[RadialVector], /, **kwargs: Any -) -> RadialVector: - """Cartesian2DVector -> RadialVector. + current: CartesianPosition2D, target: type[RadialPosition], /, **kwargs: Any +) -> RadialPosition: + """CartesianPosition2D -> RadialPosition. The `x` and `y` coordinates are converted to the radial coordinate `r`. @@ -160,13 +160,13 @@ def represent_as( >>> from unxt import Quantity >>> import coordinax as cx - >>> x = cx.Cartesian2DVector.constructor(Quantity([1.0, 2.0], "km")) + >>> x = cx.CartesianPosition2D.constructor(Quantity([1.0, 2.0], "km")) >>> with warnings.catch_warnings(): ... warnings.simplefilter("ignore") - ... x2 = cx.represent_as(x, cx.RadialVector, z=Quantity(14, "km")) + ... x2 = cx.represent_as(x, cx.RadialPosition, z=Quantity(14, "km")) >>> x2 - RadialVector(r=Distance(value=f32[], unit=Unit("km"))) + RadialPosition(r=Distance(value=f32[], unit=Unit("km"))) >>> x2.r Distance(Array(2.236068, dtype=float32), unit='km') @@ -181,14 +181,14 @@ def represent_as( @dispatch def represent_as( - current: Cartesian2DVector, - target: type[Cartesian3DVector], + current: CartesianPosition2D, + target: type[CartesianPosition3D], /, *, z: Quantity = Quantity(0.0, u.m), **kwargs: Any, -) -> Cartesian3DVector: - """Cartesian2DVector -> Cartesian3DVector. +) -> CartesianPosition3D: + """CartesianPosition2D -> CartesianPosition3D. The `x` and `y` coordinates are converted to the `x` and `y` coordinates of the 3D system. The `z` coordinate is a keyword argument and defaults to 0. @@ -198,11 +198,11 @@ def represent_as( >>> from unxt import Quantity >>> import coordinax as cx - >>> x = cx.Cartesian2DVector.constructor(Quantity([1.0, 2.0], "km")) + >>> x = cx.CartesianPosition2D.constructor(Quantity([1.0, 2.0], "km")) - >>> x2 = cx.represent_as(x, cx.Cartesian3DVector, z=Quantity(14, "km")) + >>> x2 = cx.represent_as(x, cx.CartesianPosition3D, z=Quantity(14, "km")) >>> x2 - Cartesian3DVector( x=Quantity[...](value=f32[], unit=Unit("km")), + CartesianPosition3D( x=Quantity[...](value=f32[], unit=Unit("km")), y=Quantity[...](value=f32[], unit=Unit("km")), z=Quantity[...](value=f32[], unit=Unit("km")) ) >>> x2.z @@ -213,7 +213,7 @@ def represent_as( # ============================================================================= -# PolarVector +# PolarPosition # ----------------------------------------------- # 1D @@ -221,9 +221,9 @@ def represent_as( @dispatch def represent_as( - current: PolarVector, target: type[Cartesian1DVector], /, **kwargs: Any -) -> Cartesian1DVector: - """PolarVector -> Cartesian1DVector. + current: PolarPosition, target: type[CartesianPosition1D], /, **kwargs: Any +) -> CartesianPosition1D: + """PolarPosition -> CartesianPosition1D. Examples -------- @@ -231,13 +231,13 @@ def represent_as( >>> from unxt import Quantity >>> import coordinax as cx - >>> x = cx.PolarVector(r=Quantity(1.0, "km"), phi=Quantity(10.0, "deg")) + >>> x = cx.PolarPosition(r=Quantity(1.0, "km"), phi=Quantity(10.0, "deg")) >>> with warnings.catch_warnings(): ... warnings.simplefilter("ignore") - ... x2 = cx.represent_as(x, cx.Cartesian1DVector) + ... x2 = cx.represent_as(x, cx.CartesianPosition1D) >>> x2 - Cartesian1DVector( x=Quantity[...](value=f32[], unit=Unit("km")) ) + CartesianPosition1D( x=Quantity[...](value=f32[], unit=Unit("km")) ) >>> x2.x Quantity['length'](Array(0.9848077, dtype=float32), unit='km') @@ -248,9 +248,9 @@ def represent_as( @dispatch def represent_as( - current: PolarVector, target: type[RadialVector], /, **kwargs: Any -) -> RadialVector: - """PolarVector -> RadialVector. + current: PolarPosition, target: type[RadialPosition], /, **kwargs: Any +) -> RadialPosition: + """PolarPosition -> RadialPosition. Examples -------- @@ -258,13 +258,13 @@ def represent_as( >>> from unxt import Quantity >>> import coordinax as cx - >>> x = cx.PolarVector(r=Quantity(1.0, "km"), phi=Quantity(10.0, "deg")) + >>> x = cx.PolarPosition(r=Quantity(1.0, "km"), phi=Quantity(10.0, "deg")) >>> with warnings.catch_warnings(): ... warnings.simplefilter("ignore") - ... x2 = cx.represent_as(x, cx.RadialVector) + ... x2 = cx.represent_as(x, cx.RadialPosition) >>> x2 - RadialVector(r=Distance(value=f32[], unit=Unit("km"))) + RadialPosition(r=Distance(value=f32[], unit=Unit("km"))) >>> x2.r Distance(Array(1., dtype=float32), unit='km') @@ -279,24 +279,24 @@ def represent_as( @dispatch def represent_as( - current: PolarVector, - target: type[SphericalVector], + current: PolarPosition, + target: type[SphericalPosition], /, theta: Quantity["angle"] = Quantity(0.0, u.radian), # type: ignore[name-defined] **kwargs: Any, -) -> SphericalVector: - """PolarVector -> SphericalVector. +) -> SphericalPosition: + """PolarPosition -> SphericalPosition. Examples -------- >>> from unxt import Quantity >>> import coordinax as cx - >>> x = cx.PolarVector(r=Quantity(1.0, "km"), phi=Quantity(10.0, "deg")) + >>> x = cx.PolarPosition(r=Quantity(1.0, "km"), phi=Quantity(10.0, "deg")) - >>> x2 = cx.represent_as(x, cx.SphericalVector, theta=Quantity(14, "deg")) + >>> x2 = cx.represent_as(x, cx.SphericalPosition, theta=Quantity(14, "deg")) >>> x2 - SphericalVector( r=Distance(value=f32[], unit=Unit("km")), + SphericalPosition( r=Distance(value=f32[], unit=Unit("km")), theta=Quantity[...](value=f32[], unit=Unit("deg")), phi=Quantity[...](value=f32[], unit=Unit("deg")) ) >>> x2.theta @@ -308,24 +308,24 @@ def represent_as( @dispatch def represent_as( - current: PolarVector, - target: type[MathSphericalVector], + current: PolarPosition, + target: type[MathSphericalPosition], /, phi: Quantity["angle"] = Quantity(0.0, u.radian), # type: ignore[name-defined] **kwargs: Any, -) -> MathSphericalVector: - """PolarVector -> MathSphericalVector. +) -> MathSphericalPosition: + """PolarPosition -> MathSphericalPosition. Examples -------- >>> from unxt import Quantity >>> import coordinax as cx - >>> x = cx.PolarVector(r=Quantity(1.0, "km"), phi=Quantity(10.0, "deg")) + >>> x = cx.PolarPosition(r=Quantity(1.0, "km"), phi=Quantity(10.0, "deg")) - >>> x2 = cx.represent_as(x, cx.MathSphericalVector, phi=Quantity(14, "deg")) + >>> x2 = cx.represent_as(x, cx.MathSphericalPosition, phi=Quantity(14, "deg")) >>> x2 - MathSphericalVector( r=Distance(value=f32[], unit=Unit("km")), + MathSphericalPosition( r=Distance(value=f32[], unit=Unit("km")), theta=Quantity[...](value=f32[], unit=Unit("deg")), phi=Quantity[...](value=f32[], unit=Unit("deg")) ) >>> x2.phi @@ -337,25 +337,25 @@ def represent_as( @dispatch def represent_as( - current: PolarVector, - target: type[CylindricalVector], + current: PolarPosition, + target: type[CylindricalPosition], /, *, z: Quantity["length"] = Quantity(0.0, u.m), # type: ignore[name-defined] **kwargs: Any, -) -> CylindricalVector: - """PolarVector -> CylindricalVector. +) -> CylindricalPosition: + """PolarPosition -> CylindricalPosition. Examples -------- >>> from unxt import Quantity >>> import coordinax as cx - >>> x = cx.PolarVector(r=Quantity(1.0, "km"), phi=Quantity(10.0, "deg")) + >>> x = cx.PolarPosition(r=Quantity(1.0, "km"), phi=Quantity(10.0, "deg")) - >>> x2 = cx.represent_as(x, cx.CylindricalVector, z=Quantity(14, "km")) + >>> x2 = cx.represent_as(x, cx.CylindricalPosition, z=Quantity(14, "km")) >>> x2 - CylindricalVector( rho=Quantity[...](value=f32[], unit=Unit("km")), + CylindricalPosition( rho=Quantity[...](value=f32[], unit=Unit("km")), phi=Quantity[...](value=f32[], unit=Unit("deg")), z=Quantity[...](value=f32[], unit=Unit("km")) ) >>> x2.z diff --git a/src/coordinax/_transform/d3.py b/src/coordinax/_transform/d3.py index d770e5e..9a90746 100644 --- a/src/coordinax/_transform/d3.py +++ b/src/coordinax/_transform/d3.py @@ -9,15 +9,15 @@ import quaxed.array_api as xp -from coordinax._d1.builtin import Cartesian1DVector, RadialVector -from coordinax._d2.base import Abstract2DVector -from coordinax._d2.builtin import Cartesian2DVector, PolarVector -from coordinax._d3.builtin import Cartesian3DVector, CylindricalVector -from coordinax._d3.sphere import MathSphericalVector, SphericalVector +from coordinax._d1.builtin import CartesianPosition1D, RadialPosition +from coordinax._d2.base import AbstractPosition2D +from coordinax._d2.builtin import CartesianPosition2D, PolarPosition +from coordinax._d3.builtin import CartesianPosition3D, CylindricalPosition +from coordinax._d3.sphere import MathSphericalPosition, SphericalPosition from coordinax._exceptions import IrreversibleDimensionChange # ============================================================================= -# Cartesian3DVector +# CartesianPosition3D # ----------------------------------------------- @@ -26,9 +26,9 @@ @dispatch def represent_as( - current: Cartesian3DVector, target: type[Cartesian1DVector], /, **kwargs: Any -) -> Cartesian1DVector: - """Cartesian3DVector -> Cartesian1DVector. + current: CartesianPosition3D, target: type[CartesianPosition1D], /, **kwargs: Any +) -> CartesianPosition1D: + """CartesianPosition3D -> CartesianPosition1D. The `y` and `z` coordinates are dropped. @@ -38,13 +38,13 @@ def represent_as( >>> from unxt import Quantity >>> import coordinax as cx - >>> x = cx.Cartesian3DVector.constructor(Quantity([1.0, 2.0, 3.0], "km")) + >>> x = cx.CartesianPosition3D.constructor(Quantity([1.0, 2.0, 3.0], "km")) >>> with warnings.catch_warnings(): ... warnings.simplefilter("ignore") - ... x2 = cx.represent_as(x, cx.Cartesian1DVector) + ... x2 = cx.represent_as(x, cx.CartesianPosition1D) >>> x2 - Cartesian1DVector( + CartesianPosition1D( x=Quantity[PhysicalType('length')](value=f32[], unit=Unit("km")) ) @@ -55,9 +55,9 @@ def represent_as( @dispatch def represent_as( - current: Cartesian3DVector, target: type[RadialVector], /, **kwargs: Any -) -> RadialVector: - """Cartesian3DVector -> RadialVector. + current: CartesianPosition3D, target: type[RadialPosition], /, **kwargs: Any +) -> RadialPosition: + """CartesianPosition3D -> RadialPosition. Examples -------- @@ -65,13 +65,13 @@ def represent_as( >>> from unxt import Quantity >>> import coordinax as cx - >>> x = cx.Cartesian3DVector.constructor(Quantity([1.0, 2.0, 3.0], "km")) + >>> x = cx.CartesianPosition3D.constructor(Quantity([1.0, 2.0, 3.0], "km")) >>> with warnings.catch_warnings(): ... warnings.simplefilter("ignore") - ... x2 = cx.represent_as(x, cx.RadialVector) + ... x2 = cx.represent_as(x, cx.RadialPosition) >>> x2 - RadialVector(r=Distance(value=f32[], unit=Unit("km"))) + RadialPosition(r=Distance(value=f32[], unit=Unit("km"))) """ warn("irreversible dimension change", IrreversibleDimensionChange, stacklevel=2) @@ -84,9 +84,9 @@ def represent_as( @dispatch def represent_as( - current: Cartesian3DVector, target: type[Cartesian2DVector], /, **kwargs: Any -) -> Cartesian2DVector: - """Cartesian3DVector -> Cartesian2DVector. + current: CartesianPosition3D, target: type[CartesianPosition2D], /, **kwargs: Any +) -> CartesianPosition2D: + """CartesianPosition3D -> CartesianPosition2D. Examples -------- @@ -94,13 +94,13 @@ def represent_as( >>> from unxt import Quantity >>> import coordinax as cx - >>> x = cx.Cartesian3DVector.constructor(Quantity([1.0, 2.0, 3.0], "km")) + >>> x = cx.CartesianPosition3D.constructor(Quantity([1.0, 2.0, 3.0], "km")) >>> with warnings.catch_warnings(): ... warnings.simplefilter("ignore") - ... x2 = cx.represent_as(x, cx.Cartesian2DVector) + ... x2 = cx.represent_as(x, cx.CartesianPosition2D) >>> x2 - Cartesian2DVector( x=Quantity[...](value=f32[], unit=Unit("km")), + CartesianPosition2D( x=Quantity[...](value=f32[], unit=Unit("km")), y=Quantity[...](value=f32[], unit=Unit("km")) ) """ @@ -109,12 +109,12 @@ def represent_as( @dispatch.multi( - (Cartesian3DVector, type[PolarVector]), + (CartesianPosition3D, type[PolarPosition]), ) def represent_as( - current: Cartesian3DVector, target: type[Abstract2DVector], /, **kwargs: Any -) -> Abstract2DVector: - """Cartesian3DVector -> Cartesian2D -> Abstract2DVector. + current: CartesianPosition3D, target: type[AbstractPosition2D], /, **kwargs: Any +) -> AbstractPosition2D: + """CartesianPosition3D -> Cartesian2D -> AbstractPosition2D. Examples -------- @@ -122,23 +122,23 @@ def represent_as( >>> from unxt import Quantity >>> import coordinax as cx - >>> x = cx.Cartesian3DVector.constructor(Quantity([1.0, 2.0, 3.0], "km")) + >>> x = cx.CartesianPosition3D.constructor(Quantity([1.0, 2.0, 3.0], "km")) >>> with warnings.catch_warnings(): ... warnings.simplefilter("ignore") - ... x2 = cx.represent_as(x, cx.PolarVector) + ... x2 = cx.represent_as(x, cx.PolarPosition) >>> x2 - PolarVector( r=Distance(value=f32[], unit=Unit("km")), + PolarPosition( r=Distance(value=f32[], unit=Unit("km")), phi=Quantity[...](value=f32[], unit=Unit("rad")) ) """ warn("irreversible dimension change", IrreversibleDimensionChange, stacklevel=2) - cart2 = represent_as(current, Cartesian2DVector) + cart2 = represent_as(current, CartesianPosition2D) return represent_as(cart2, target) # ============================================================================= -# CylindricalVector +# CylindricalPosition # ----------------------------------------------- @@ -147,9 +147,9 @@ def represent_as( @dispatch def represent_as( - current: CylindricalVector, target: type[Cartesian1DVector], /, **kwargs: Any -) -> Cartesian1DVector: - """CylindricalVector -> Cartesian1DVector. + current: CylindricalPosition, target: type[CartesianPosition1D], /, **kwargs: Any +) -> CartesianPosition1D: + """CylindricalPosition -> CartesianPosition1D. Examples -------- @@ -157,14 +157,14 @@ def represent_as( >>> from unxt import Quantity >>> import coordinax as cx - >>> x = cx.CylindricalVector(rho=Quantity(1.0, "km"), phi=Quantity(10.0, "deg"), + >>> x = cx.CylindricalPosition(rho=Quantity(1.0, "km"), phi=Quantity(10.0, "deg"), ... z=Quantity(14, "km")) >>> with warnings.catch_warnings(): ... warnings.simplefilter("ignore") - ... x2 = cx.represent_as(x, cx.Cartesian1DVector) + ... x2 = cx.represent_as(x, cx.CartesianPosition1D) >>> x2 - Cartesian1DVector( x=Quantity[...](value=f32[], unit=Unit("km")) ) + CartesianPosition1D( x=Quantity[...](value=f32[], unit=Unit("km")) ) """ warn("irreversible dimension change", IrreversibleDimensionChange, stacklevel=2) @@ -173,9 +173,9 @@ def represent_as( @dispatch def represent_as( - current: CylindricalVector, target: type[RadialVector], /, **kwargs: Any -) -> RadialVector: - """CylindricalVector -> RadialVector. + current: CylindricalPosition, target: type[RadialPosition], /, **kwargs: Any +) -> RadialPosition: + """CylindricalPosition -> RadialPosition. Examples -------- @@ -183,14 +183,14 @@ def represent_as( >>> from unxt import Quantity >>> import coordinax as cx - >>> x = cx.CylindricalVector(rho=Quantity(1.0, "km"), phi=Quantity(10.0, "deg"), + >>> x = cx.CylindricalPosition(rho=Quantity(1.0, "km"), phi=Quantity(10.0, "deg"), ... z=Quantity(14, "km")) >>> with warnings.catch_warnings(): ... warnings.simplefilter("ignore") - ... x2 = cx.represent_as(x, cx.RadialVector) + ... x2 = cx.represent_as(x, cx.RadialPosition) >>> x2 - RadialVector(r=Distance(value=f32[], unit=Unit("km"))) + RadialPosition(r=Distance(value=f32[], unit=Unit("km"))) """ warn("irreversible dimension change", IrreversibleDimensionChange, stacklevel=2) @@ -203,9 +203,9 @@ def represent_as( @dispatch def represent_as( - current: CylindricalVector, target: type[Cartesian2DVector], /, **kwargs: Any -) -> Cartesian2DVector: - """CylindricalVector -> Cartesian2DVector. + current: CylindricalPosition, target: type[CartesianPosition2D], /, **kwargs: Any +) -> CartesianPosition2D: + """CylindricalPosition -> CartesianPosition2D. Examples -------- @@ -213,14 +213,14 @@ def represent_as( >>> from unxt import Quantity >>> import coordinax as cx - >>> x = cx.CylindricalVector(rho=Quantity(1.0, "km"), phi=Quantity(10.0, "deg"), + >>> x = cx.CylindricalPosition(rho=Quantity(1.0, "km"), phi=Quantity(10.0, "deg"), ... z=Quantity(14, "km")) >>> with warnings.catch_warnings(): ... warnings.simplefilter("ignore") - ... x2 = cx.represent_as(x, cx.Cartesian2DVector) + ... x2 = cx.represent_as(x, cx.CartesianPosition2D) >>> x2 - Cartesian2DVector( x=Quantity[...](value=f32[], unit=Unit("km")), + CartesianPosition2D( x=Quantity[...](value=f32[], unit=Unit("km")), y=Quantity[...](value=f32[], unit=Unit("km")) ) """ @@ -232,9 +232,9 @@ def represent_as( @dispatch def represent_as( - current: CylindricalVector, target: type[PolarVector], /, **kwargs: Any -) -> PolarVector: - """CylindricalVector -> PolarVector. + current: CylindricalPosition, target: type[PolarPosition], /, **kwargs: Any +) -> PolarPosition: + """CylindricalPosition -> PolarPosition. Examples -------- @@ -242,14 +242,14 @@ def represent_as( >>> from unxt import Quantity >>> import coordinax as cx - >>> x = cx.CylindricalVector(rho=Quantity(1.0, "km"), phi=Quantity(10.0, "deg"), + >>> x = cx.CylindricalPosition(rho=Quantity(1.0, "km"), phi=Quantity(10.0, "deg"), ... z=Quantity(14, "km")) >>> with warnings.catch_warnings(): ... warnings.simplefilter("ignore") - ... x2 = cx.represent_as(x, cx.PolarVector) + ... x2 = cx.represent_as(x, cx.PolarPosition) >>> x2 - PolarVector( r=Distance(value=f32[], unit=Unit("km")), + PolarPosition( r=Distance(value=f32[], unit=Unit("km")), phi=Quantity[...](value=f32[], unit=Unit("deg")) ) """ @@ -258,7 +258,7 @@ def represent_as( # ============================================================================= -# SphericalVector +# SphericalPosition # ----------------------------------------------- @@ -267,9 +267,9 @@ def represent_as( @dispatch def represent_as( - current: SphericalVector, target: type[Cartesian1DVector], /, **kwargs: Any -) -> Cartesian1DVector: - """SphericalVector -> Cartesian1DVector. + current: SphericalPosition, target: type[CartesianPosition1D], /, **kwargs: Any +) -> CartesianPosition1D: + """SphericalPosition -> CartesianPosition1D. Examples -------- @@ -277,14 +277,14 @@ def represent_as( >>> from unxt import Quantity >>> import coordinax as cx - >>> x = cx.SphericalVector(r=Quantity(1.0, "km"), theta=Quantity(14, "deg"), + >>> x = cx.SphericalPosition(r=Quantity(1.0, "km"), theta=Quantity(14, "deg"), ... phi=Quantity(10.0, "deg")) >>> with warnings.catch_warnings(): ... warnings.simplefilter("ignore") - ... x2 = cx.represent_as(x, cx.Cartesian1DVector) + ... x2 = cx.represent_as(x, cx.CartesianPosition1D) >>> x2 - Cartesian1DVector( x=Quantity[...](value=f32[], unit=Unit("km")) ) + CartesianPosition1D( x=Quantity[...](value=f32[], unit=Unit("km")) ) """ warn("irreversible dimension change", IrreversibleDimensionChange, stacklevel=2) @@ -293,9 +293,9 @@ def represent_as( @dispatch def represent_as( - current: SphericalVector, target: type[RadialVector], /, **kwargs: Any -) -> RadialVector: - """SphericalVector -> RadialVector. + current: SphericalPosition, target: type[RadialPosition], /, **kwargs: Any +) -> RadialPosition: + """SphericalPosition -> RadialPosition. Examples -------- @@ -303,14 +303,14 @@ def represent_as( >>> from unxt import Quantity >>> import coordinax as cx - >>> x = cx.SphericalVector(r=Quantity(1.0, "km"), theta=Quantity(14, "deg"), + >>> x = cx.SphericalPosition(r=Quantity(1.0, "km"), theta=Quantity(14, "deg"), ... phi=Quantity(10.0, "deg")) >>> with warnings.catch_warnings(): ... warnings.simplefilter("ignore") - ... x2 = cx.represent_as(x, cx.RadialVector) + ... x2 = cx.represent_as(x, cx.RadialPosition) >>> x2 - RadialVector(r=Distance(value=f32[], unit=Unit("km"))) + RadialPosition(r=Distance(value=f32[], unit=Unit("km"))) """ warn("irreversible dimension change", IrreversibleDimensionChange, stacklevel=2) @@ -323,9 +323,9 @@ def represent_as( @dispatch def represent_as( - current: SphericalVector, target: type[Cartesian2DVector], /, **kwargs: Any -) -> Cartesian2DVector: - """SphericalVector -> Cartesian2DVector. + current: SphericalPosition, target: type[CartesianPosition2D], /, **kwargs: Any +) -> CartesianPosition2D: + """SphericalPosition -> CartesianPosition2D. Examples -------- @@ -333,14 +333,14 @@ def represent_as( >>> from unxt import Quantity >>> import coordinax as cx - >>> x = cx.SphericalVector(r=Quantity(1.0, "km"), theta=Quantity(14, "deg"), + >>> x = cx.SphericalPosition(r=Quantity(1.0, "km"), theta=Quantity(14, "deg"), ... phi=Quantity(10.0, "deg")) >>> with warnings.catch_warnings(): ... warnings.simplefilter("ignore") - ... x2 = cx.represent_as(x, cx.Cartesian2DVector) + ... x2 = cx.represent_as(x, cx.CartesianPosition2D) >>> x2 - Cartesian2DVector( x=Quantity[...](value=f32[], unit=Unit("km")), + CartesianPosition2D( x=Quantity[...](value=f32[], unit=Unit("km")), y=Quantity[...](value=f32[], unit=Unit("km")) ) """ @@ -352,9 +352,9 @@ def represent_as( @dispatch def represent_as( - current: SphericalVector, target: type[PolarVector], /, **kwargs: Any -) -> PolarVector: - """SphericalVector -> PolarVector. + current: SphericalPosition, target: type[PolarPosition], /, **kwargs: Any +) -> PolarPosition: + """SphericalPosition -> PolarPosition. Examples -------- @@ -362,14 +362,14 @@ def represent_as( >>> from unxt import Quantity >>> import coordinax as cx - >>> x = cx.SphericalVector(r=Quantity(1.0, "km"), theta=Quantity(14, "deg"), + >>> x = cx.SphericalPosition(r=Quantity(1.0, "km"), theta=Quantity(14, "deg"), ... phi=Quantity(10.0, "deg")) >>> with warnings.catch_warnings(): ... warnings.simplefilter("ignore") - ... x2 = cx.represent_as(x, cx.PolarVector) + ... x2 = cx.represent_as(x, cx.PolarPosition) >>> x2 - PolarVector( r=Distance(value=f32[], unit=Unit("km")), + PolarPosition( r=Distance(value=f32[], unit=Unit("km")), phi=Quantity[...](value=f32[], unit=Unit("deg")) ) """ @@ -378,7 +378,7 @@ def represent_as( # ============================================================================= -# MathSphericalVector +# MathSphericalPosition # ----------------------------------------------- @@ -387,9 +387,9 @@ def represent_as( @dispatch def represent_as( - current: MathSphericalVector, target: type[Cartesian1DVector], /, **kwargs: Any -) -> Cartesian1DVector: - """MathSphericalVector -> Cartesian1DVector. + current: MathSphericalPosition, target: type[CartesianPosition1D], /, **kwargs: Any +) -> CartesianPosition1D: + """MathSphericalPosition -> CartesianPosition1D. Examples -------- @@ -397,14 +397,14 @@ def represent_as( >>> from unxt import Quantity >>> import coordinax as cx - >>> x = cx.MathSphericalVector(r=Quantity(1.0, "km"), theta=Quantity(10.0, "deg"), + >>> x = cx.MathSphericalPosition(r=Quantity(1.0, "km"), theta=Quantity(10.0, "deg"), ... phi=Quantity(14, "deg")) >>> with warnings.catch_warnings(): ... warnings.simplefilter("ignore") - ... x2 = cx.represent_as(x, cx.Cartesian1DVector) + ... x2 = cx.represent_as(x, cx.CartesianPosition1D) >>> x2 - Cartesian1DVector( x=Quantity[...](value=f32[], unit=Unit("km")) ) + CartesianPosition1D( x=Quantity[...](value=f32[], unit=Unit("km")) ) """ warn("irreversible dimension change", IrreversibleDimensionChange, stacklevel=2) @@ -413,9 +413,9 @@ def represent_as( @dispatch def represent_as( - current: MathSphericalVector, target: type[RadialVector], /, **kwargs: Any -) -> RadialVector: - """MathSphericalVector -> RadialVector. + current: MathSphericalPosition, target: type[RadialPosition], /, **kwargs: Any +) -> RadialPosition: + """MathSphericalPosition -> RadialPosition. Examples -------- @@ -423,14 +423,14 @@ def represent_as( >>> from unxt import Quantity >>> import coordinax as cx - >>> x = cx.MathSphericalVector(r=Quantity(1.0, "km"), theta=Quantity(10.0, "deg"), + >>> x = cx.MathSphericalPosition(r=Quantity(1.0, "km"), theta=Quantity(10.0, "deg"), ... phi=Quantity(14, "deg")) >>> with warnings.catch_warnings(): ... warnings.simplefilter("ignore") - ... x2 = cx.represent_as(x, cx.RadialVector) + ... x2 = cx.represent_as(x, cx.RadialPosition) >>> x2 - RadialVector(r=Distance(value=f32[], unit=Unit("km"))) + RadialPosition(r=Distance(value=f32[], unit=Unit("km"))) """ warn("irreversible dimension change", IrreversibleDimensionChange, stacklevel=2) @@ -443,9 +443,9 @@ def represent_as( @dispatch def represent_as( - current: MathSphericalVector, target: type[Cartesian2DVector], /, **kwargs: Any -) -> Cartesian2DVector: - """MathSphericalVector -> Cartesian2DVector. + current: MathSphericalPosition, target: type[CartesianPosition2D], /, **kwargs: Any +) -> CartesianPosition2D: + """MathSphericalPosition -> CartesianPosition2D. Examples -------- @@ -453,14 +453,14 @@ def represent_as( >>> from unxt import Quantity >>> import coordinax as cx - >>> x = cx.MathSphericalVector(r=Quantity(1.0, "km"), theta=Quantity(10.0, "deg"), + >>> x = cx.MathSphericalPosition(r=Quantity(1.0, "km"), theta=Quantity(10.0, "deg"), ... phi=Quantity(14, "deg")) >>> with warnings.catch_warnings(): ... warnings.simplefilter("ignore") - ... x2 = cx.represent_as(x, cx.Cartesian2DVector) + ... x2 = cx.represent_as(x, cx.CartesianPosition2D) >>> x2 - Cartesian2DVector( x=Quantity[...](value=f32[], unit=Unit("km")), + CartesianPosition2D( x=Quantity[...](value=f32[], unit=Unit("km")), y=Quantity[...](value=f32[], unit=Unit("km")) ) """ @@ -472,9 +472,9 @@ def represent_as( @dispatch def represent_as( - current: MathSphericalVector, target: type[PolarVector], /, **kwargs: Any -) -> PolarVector: - """MathSphericalVector -> PolarVector. + current: MathSphericalPosition, target: type[PolarPosition], /, **kwargs: Any +) -> PolarPosition: + """MathSphericalPosition -> PolarPosition. Examples -------- @@ -482,14 +482,14 @@ def represent_as( >>> from unxt import Quantity >>> import coordinax as cx - >>> x = cx.MathSphericalVector(r=Quantity(1.0, "km"), theta=Quantity(10.0, "deg"), + >>> x = cx.MathSphericalPosition(r=Quantity(1.0, "km"), theta=Quantity(10.0, "deg"), ... phi=Quantity(14, "deg")) >>> with warnings.catch_warnings(): ... warnings.simplefilter("ignore") - ... x2 = cx.represent_as(x, cx.PolarVector) + ... x2 = cx.represent_as(x, cx.PolarPosition) >>> x2 - PolarVector( r=Distance(value=f32[], unit=Unit("km")), + PolarPosition( r=Distance(value=f32[], unit=Unit("km")), phi=Quantity[...](value=f32[], unit=Unit("deg")) ) """ diff --git a/src/coordinax/_transform/differentials.py b/src/coordinax/_transform/differentials.py index 251e5b3..204e3a1 100644 --- a/src/coordinax/_transform/differentials.py +++ b/src/coordinax/_transform/differentials.py @@ -14,9 +14,9 @@ from coordinax._base_pos import AbstractPosition from coordinax._base_vel import AbstractVelocity -from coordinax._d1.base import Abstract1DVectorDifferential -from coordinax._d2.base import Abstract2DVectorDifferential -from coordinax._d3.base import Abstract3DVectorDifferential +from coordinax._d1.base import AbstractVelocity1D +from coordinax._d2.base import AbstractVelocity2D +from coordinax._d3.base import AbstractVelocity3D from coordinax._utils import dataclass_items @@ -24,18 +24,18 @@ @dispatch.multi( # type: ignore[misc] # N-D -> N-D ( - Abstract1DVectorDifferential, - type[Abstract1DVectorDifferential], # type: ignore[misc] + AbstractVelocity1D, + type[AbstractVelocity1D], # type: ignore[misc] AbstractPosition | Quantity["length"], ), ( - Abstract2DVectorDifferential, - type[Abstract2DVectorDifferential], # type: ignore[misc] + AbstractVelocity2D, + type[AbstractVelocity2D], # type: ignore[misc] AbstractPosition | Quantity["length"], ), ( - Abstract3DVectorDifferential, - type[Abstract3DVectorDifferential], # type: ignore[misc] + AbstractVelocity3D, + type[AbstractVelocity3D], # type: ignore[misc] AbstractPosition | Quantity["length"], ), ) @@ -68,27 +68,27 @@ def represent_as( Let's start in 1D: - >>> q = cx.Cartesian1DVector(x=Quantity(1.0, "km")) - >>> p = cx.CartesianDifferential1D(d_x=Quantity(1.0, "km/s")) - >>> cx.represent_as(p, cx.RadialDifferential, q) - RadialDifferential( d_r=Quantity[...]( value=f32[], unit=Unit("km / s") ) ) + >>> q = cx.CartesianPosition1D(x=Quantity(1.0, "km")) + >>> p = cx.CartesianVelocity1D(d_x=Quantity(1.0, "km/s")) + >>> cx.represent_as(p, cx.RadialVelocity, q) + RadialVelocity( d_r=Quantity[...]( value=f32[], unit=Unit("km / s") ) ) Now in 2D: - >>> q = cx.Cartesian2DVector.constructor(Quantity([1.0, 2.0], "km")) - >>> p = cx.CartesianDifferential2D.constructor(Quantity([1.0, 2.0], "km/s")) - >>> cx.represent_as(p, cx.PolarDifferential, q) - PolarDifferential( + >>> q = cx.CartesianPosition2D.constructor(Quantity([1.0, 2.0], "km")) + >>> p = cx.CartesianVelocity2D.constructor(Quantity([1.0, 2.0], "km/s")) + >>> cx.represent_as(p, cx.PolarVelocity, q) + PolarVelocity( d_r=Quantity[...]( value=f32[], unit=Unit("km / s") ), d_phi=Quantity[...]( value=f32[], unit=Unit("rad / s") ) ) And in 3D: - >>> q = cx.Cartesian3DVector.constructor(Quantity([1.0, 2.0, 3.0], "km")) - >>> p = cx.CartesianDifferential3D.constructor(Quantity([1.0, 2.0, 3.0], "km/s")) - >>> cx.represent_as(p, cx.SphericalDifferential, q) - SphericalDifferential( + >>> q = cx.CartesianPosition3D.constructor(Quantity([1.0, 2.0, 3.0], "km")) + >>> p = cx.CartesianVelocity3D.constructor(Quantity([1.0, 2.0, 3.0], "km/s")) + >>> cx.represent_as(p, cx.SphericalVelocity, q) + SphericalVelocity( d_r=Quantity[...]( value=f32[], unit=Unit("km / s") ), d_theta=Quantity[...]( value=f32[], unit=Unit("rad / s") ), d_phi=Quantity[...]( value=f32[], unit=Unit("rad / s") ) @@ -97,9 +97,9 @@ def represent_as( If given a position as a Quantity, it will be converted to the appropriate Cartesian vector: - >>> p = cx.CartesianDifferential3D.constructor(Quantity([1.0, 2.0, 3.0], "km/s")) - >>> cx.represent_as(p, cx.SphericalDifferential, Quantity([1.0, 2.0, 3.0], "km")) - SphericalDifferential( + >>> p = cx.CartesianVelocity3D.constructor(Quantity([1.0, 2.0, 3.0], "km/s")) + >>> cx.represent_as(p, cx.SphericalVelocity, Quantity([1.0, 2.0, 3.0], "km")) + SphericalVelocity( d_r=Quantity[...]( value=f32[], unit=Unit("km / s") ), d_theta=Quantity[...]( value=f32[], unit=Unit("rad / s") ), d_phi=Quantity[...]( value=f32[], unit=Unit("rad / s") ) diff --git a/src/coordinax/operators/_funcs.py b/src/coordinax/operators/_funcs.py index c879552..5851fff 100644 --- a/src/coordinax/operators/_funcs.py +++ b/src/coordinax/operators/_funcs.py @@ -22,7 +22,7 @@ def simplify_op(op: AbstractOperator, /) -> AbstractOperator: >>> op = co.GalileanSpatialTranslationOperator(shift) >>> co.simplify_op(op) GalileanSpatialTranslationOperator( - translation=Cartesian3DVector( ... ) + translation=CartesianPosition3D( ... ) ) An operator with no effect can be simplified: diff --git a/src/coordinax/operators/_galilean/boost.py b/src/coordinax/operators/_galilean/boost.py index d980c90..0d419c0 100644 --- a/src/coordinax/operators/_galilean/boost.py +++ b/src/coordinax/operators/_galilean/boost.py @@ -15,8 +15,8 @@ from unxt import Quantity from .base import AbstractGalileanOperator -from coordinax._d3.base import Abstract3DVector -from coordinax._d3.builtin import CartesianDifferential3D +from coordinax._d3.base import AbstractPosition3D +from coordinax._d3.builtin import CartesianVelocity3D from coordinax._d4.spacetime import FourVector from coordinax.operators._base import AbstractOperator, op_call_dispatch from coordinax.operators._funcs import simplify_op @@ -37,11 +37,11 @@ class GalileanBoostOperator(AbstractGalileanOperator): Parameters ---------- - velocity : :class:`vector.CartesianDifferential3D` + velocity : :class:`vector.CartesianVelocity3D` The boost velocity. This parameters uses - :meth:`vector.CartesianDifferential3D.constructor` to enable a variety + :meth:`vector.CartesianVelocity3D.constructor` to enable a variety of more convenient input types. See - :class:`vector.CartesianDifferential3D` for details. + :class:`vector.CartesianVelocity3D` for details. Examples -------- @@ -49,36 +49,34 @@ class GalileanBoostOperator(AbstractGalileanOperator): >>> import quaxed.array_api as xp >>> from unxt import Quantity - >>> from coordinax import CartesianDifferential3D, Cartesian3DVector + >>> from coordinax import CartesianVelocity3D, CartesianPosition3D >>> import coordinax.operators as co We can then create a boost operator: >>> op = co.GalileanBoostOperator(Quantity([1.0, 2.0, 3.0], "m/s")) >>> op - GalileanBoostOperator( velocity=CartesianDifferential3D( ... ) ) + GalileanBoostOperator( velocity=CartesianVelocity3D( ... ) ) - Note that the velocity is a :class:`vector.CartesianDifferential3D`, which + Note that the velocity is a :class:`vector.CartesianVelocity3D`, which was constructed from a 1D array, using - :meth:`vector.CartesianDifferential3D.constructor`. We can also construct it + :meth:`vector.CartesianVelocity3D.constructor`. We can also construct it directly: - >>> boost = CartesianDifferential3D(d_x=Quantity(1, "m/s"), d_y=Quantity(2, "m/s"), + >>> boost = CartesianVelocity3D(d_x=Quantity(1, "m/s"), d_y=Quantity(2, "m/s"), ... d_z=Quantity(3, "m/s")) >>> op = co.GalileanBoostOperator(boost) >>> op - GalileanBoostOperator( velocity=CartesianDifferential3D( ... ) ) + GalileanBoostOperator( velocity=CartesianVelocity3D( ... ) ) """ - velocity: CartesianDifferential3D = eqx.field( - converter=CartesianDifferential3D.constructor - ) + velocity: CartesianVelocity3D = eqx.field(converter=CartesianVelocity3D.constructor) """The boost velocity. - This parameters uses :meth:`vector.CartesianDifferential3D.constructor` to + This parameters uses :meth:`vector.CartesianVelocity3D.constructor` to enable a variety of more convenient input types. See - :class:`vector.CartesianDifferential3D` for details. + :class:`vector.CartesianVelocity3D` for details. """ # ----------------------------------------------------- @@ -90,7 +88,7 @@ def is_inertial(self) -> Literal[True]: Examples -------- >>> from unxt import Quantity - >>> from coordinax import Cartesian3DVector, CartesianDifferential3D + >>> from coordinax import CartesianPosition3D, CartesianVelocity3D >>> from coordinax.operators import GalileanBoostOperator >>> op = GalileanBoostOperator(Quantity([1, 2, 3], "m/s")) @@ -107,12 +105,12 @@ def inverse(self) -> "GalileanBoostOperator": Examples -------- >>> from unxt import Quantity - >>> from coordinax import Cartesian3DVector, CartesianDifferential3D + >>> from coordinax import CartesianPosition3D, CartesianVelocity3D >>> from coordinax.operators import GalileanBoostOperator >>> op = GalileanBoostOperator(Quantity([1, 2, 3], "m/s")) >>> op.inverse - GalileanBoostOperator( velocity=CartesianDifferential3D( ... ) ) + GalileanBoostOperator( velocity=CartesianVelocity3D( ... ) ) >>> op.inverse.velocity.d_x Quantity['speed'](Array(-1., dtype=float32), unit='m / s') @@ -124,19 +122,19 @@ def inverse(self) -> "GalileanBoostOperator": @op_call_dispatch(precedence=1) def __call__( - self: "GalileanBoostOperator", q: Abstract3DVector, t: Quantity["time"], / - ) -> tuple[Abstract3DVector, Quantity["time"]]: + self: "GalileanBoostOperator", q: AbstractPosition3D, t: Quantity["time"], / + ) -> tuple[AbstractPosition3D, Quantity["time"]]: """Apply the boost to the coordinates. Examples -------- >>> from unxt import Quantity - >>> from coordinax import Cartesian3DVector, CartesianDifferential3D + >>> from coordinax import CartesianPosition3D, CartesianVelocity3D >>> from coordinax.operators import GalileanBoostOperator >>> op = GalileanBoostOperator(Quantity([1, 2, 3], "m/s")) - >>> q = Cartesian3DVector.constructor(Quantity([0, 0, 0], "m")) + >>> q = CartesianPosition3D.constructor(Quantity([0, 0, 0], "m")) >>> t = Quantity(1, "s") >>> newq, newt = op(q, t) >>> newt diff --git a/src/coordinax/operators/_galilean/composite.py b/src/coordinax/operators/_galilean/composite.py index 7e9f406..9488dad 100644 --- a/src/coordinax/operators/_galilean/composite.py +++ b/src/coordinax/operators/_galilean/composite.py @@ -69,26 +69,26 @@ class GalileanOperator(AbstractCompositeOperator, AbstractGalileanOperator): translation=GalileanTranslationOperator( translation=FourVector( t=Quantity[PhysicalType('time')](value=f32[], unit=Unit("kpc s / km")), - q=Cartesian3DVector( ... ) ) + q=CartesianPosition3D( ... ) ) ), - velocity=GalileanBoostOperator( velocity=CartesianDifferential3D( ... ) ) + velocity=GalileanBoostOperator( velocity=CartesianVelocity3D( ... ) ) ) Note that the translation is a :class:`coordinax.operators.GalileanTranslationOperator` with a :class:`vector.FourVector` translation, and the velocity is a :class:`coordinax.operators.GalileanBoostOperator` with a - :class:`vector.CartesianDifferential3D` velocity. We can also construct them + :class:`vector.CartesianVelocity3D` velocity. We can also construct them directly, which allows for other vector types. >>> op = cx.operators.GalileanOperator( ... translation=cx.operators.GalileanTranslationOperator( ... cx.FourVector(t=Quantity(2.5, "Gyr"), - ... q=cx.SphericalVector(r=Quantity(1, "kpc"), + ... q=cx.SphericalPosition(r=Quantity(1, "kpc"), ... theta=Quantity(90, "deg"), ... phi=Quantity(0, "rad") ) ) ), ... velocity=cx.operators.GalileanBoostOperator( - ... cx.CartesianDifferential3D(d_x=Quantity(1, "km/s"), + ... cx.CartesianVelocity3D(d_x=Quantity(1, "km/s"), ... d_y=Quantity(2, "km/s"), ... d_z=Quantity(3, "km/s"))) ... ) @@ -98,10 +98,10 @@ class GalileanOperator(AbstractCompositeOperator, AbstractGalileanOperator): translation=GalileanTranslationOperator( translation=FourVector( t=Quantity[PhysicalType('time')](value=f32[], unit=Unit("Gyr")), - q=SphericalVector( ... ) + q=SphericalPosition( ... ) ) ), - velocity=GalileanBoostOperator( velocity=CartesianDifferential3D( ... ) ) + velocity=GalileanBoostOperator( velocity=CartesianVelocity3D( ... ) ) ) Galilean operators can be applied to :class:`vector.FourVector`: @@ -111,7 +111,7 @@ class GalileanOperator(AbstractCompositeOperator, AbstractGalileanOperator): >>> new FourVector( t=Quantity[PhysicalType('time')](value=f32[], unit=Unit("kpc s / km")), - q=Cartesian3DVector( ... ) + q=CartesianPosition3D( ... ) ) >>> new.t.to_units("Gyr").value.round(2) Array(2.5, dtype=float32) @@ -119,9 +119,9 @@ class GalileanOperator(AbstractCompositeOperator, AbstractGalileanOperator): Quantity['length'](Array(3.5567803, dtype=float32), unit='kpc') Also the Galilean operators can also be applied to - :class:`vector.Abstract3DVector` and :class:`unxt.Quantity`: + :class:`vector.AbstractPosition3D` and :class:`unxt.Quantity`: - >>> q = cx.Cartesian3DVector.constructor(Quantity([0, 0, 0], "kpc")) + >>> q = cx.CartesianPosition3D.constructor(Quantity([0, 0, 0], "kpc")) >>> t = Quantity(0, "Gyr") >>> newq, newt = op(q, t) >>> newq.x @@ -165,9 +165,9 @@ class GalileanOperator(AbstractCompositeOperator, AbstractGalileanOperator): This parameters accepts either a :class:`coordinax.operators.GalileanBoostOperator` instance or any input that can be used to construct a - :class:`vector.CartesianDifferential3D`, using - :meth:`vector.CartesianDifferential3D.constructor`. See - :class:`vector.CartesianDifferential3D` for details. + :class:`vector.CartesianVelocity3D`, using + :meth:`vector.CartesianVelocity3D.constructor`. See + :class:`vector.CartesianVelocity3D` for details. """ @property diff --git a/src/coordinax/operators/_galilean/rotation.py b/src/coordinax/operators/_galilean/rotation.py index 1e71025..6025dce 100644 --- a/src/coordinax/operators/_galilean/rotation.py +++ b/src/coordinax/operators/_galilean/rotation.py @@ -19,8 +19,8 @@ from .base import AbstractGalileanOperator from coordinax._base import ToUnitsOptions -from coordinax._d3.base import Abstract3DVector -from coordinax._d3.builtin import Cartesian3DVector +from coordinax._d3.base import AbstractPosition3D +from coordinax._d3.builtin import CartesianPosition3D from coordinax.operators._base import AbstractOperator, op_call_dispatch from coordinax.operators._funcs import simplify_op from coordinax.operators._identity import IdentityOperator @@ -109,10 +109,10 @@ class GalileanRotationOperator(AbstractGalileanOperator): [-0.70710677, 0.70710677, 0. ]], dtype=float32), unit='m') - Translation operators can be applied to :class:`vector.Abstract3DVector`: + Translation operators can be applied to :class:`vector.AbstractPosition3D`: - >>> from coordinax import Cartesian3DVector - >>> q = Cartesian3DVector.constructor(q) # from the previous example + >>> from coordinax import CartesianPosition3D + >>> q = CartesianPosition3D.constructor(q) # from the previous example >>> newq, newt = op(q, t) >>> newq.x Quantity['length'](Array([ 0.70710677, -0.70710677], dtype=float32), unit='m') @@ -198,7 +198,7 @@ def __call__( -------- >>> import quaxed.array_api as xp >>> from unxt import Quantity - >>> from coordinax import Cartesian3DVector, CartesianDifferential3D + >>> from coordinax import CartesianPosition3D, CartesianVelocity3D >>> from coordinax.operators import GalileanRotationOperator >>> theta = Quantity(45, "deg") @@ -222,15 +222,15 @@ def __call__( @op_call_dispatch(precedence=1) def __call__( - self: "GalileanRotationOperator", q: Abstract3DVector, / - ) -> Abstract3DVector: + self: "GalileanRotationOperator", q: AbstractPosition3D, / + ) -> AbstractPosition3D: """Apply the boost to the coordinates. Examples -------- >>> import quaxed.array_api as xp >>> from unxt import Quantity - >>> from coordinax import Cartesian3DVector, CartesianDifferential3D + >>> from coordinax import CartesianPosition3D, CartesianVelocity3D >>> from coordinax.operators import GalileanRotationOperator >>> theta = Quantity(45, "deg") @@ -239,7 +239,7 @@ def __call__( ... [0, 0, 1]]) >>> op = GalileanRotationOperator(Rz) - >>> q = Cartesian3DVector.constructor(Quantity([1, 0, 0], "m")) + >>> q = CartesianPosition3D.constructor(Quantity([1, 0, 0], "m")) >>> t = Quantity(1, "s") >>> newq, newt = op(q, t) >>> newq.x @@ -251,28 +251,28 @@ def __call__( """ vec = convert( # Array[float, (N, 3)] - q.represent_as(Cartesian3DVector).to_units(ToUnitsOptions.consistent), + q.represent_as(CartesianPosition3D).to_units(ToUnitsOptions.consistent), Quantity, ) - rcart = Cartesian3DVector.constructor(vec_matmul(self.rotation, vec)) + rcart = CartesianPosition3D.constructor(vec_matmul(self.rotation, vec)) return rcart.represent_as(type(q)) @op_call_dispatch(precedence=1) def __call__( self: "GalileanRotationOperator", - q: Abstract3DVector, + q: AbstractPosition3D, t: Quantity["time"], /, - ) -> tuple[Abstract3DVector, Quantity["time"]]: + ) -> tuple[AbstractPosition3D, Quantity["time"]]: return self(q), t @op_call_dispatch(precedence=1) def __call__( self: "GalileanRotationOperator", - q: Abstract3DVector, + q: AbstractPosition3D, t: Quantity["time"], /, - ) -> tuple[Abstract3DVector, Quantity["time"]]: + ) -> tuple[AbstractPosition3D, Quantity["time"]]: return self(q), t diff --git a/src/coordinax/operators/_galilean/translation.py b/src/coordinax/operators/_galilean/translation.py index 6ebb66c..352cdc6 100644 --- a/src/coordinax/operators/_galilean/translation.py +++ b/src/coordinax/operators/_galilean/translation.py @@ -16,10 +16,10 @@ from .base import AbstractGalileanOperator from coordinax._base_pos import AbstractPosition -from coordinax._d1.builtin import Cartesian1DVector -from coordinax._d2.builtin import Cartesian2DVector -from coordinax._d3.base import Abstract3DVector -from coordinax._d3.builtin import Cartesian3DVector +from coordinax._d1.builtin import CartesianPosition1D +from coordinax._d2.builtin import CartesianPosition2D +from coordinax._d3.base import AbstractPosition3D +from coordinax._d3.builtin import CartesianPosition3D from coordinax._d4.spacetime import FourVector from coordinax.operators._base import AbstractOperator, op_call_dispatch from coordinax.operators._funcs import simplify_op @@ -40,11 +40,11 @@ def _converter_spatialtranslation(x: Any) -> AbstractPosition: shape: tuple[int, ...] = x.shape match shape: case (1,): - out = Cartesian1DVector.constructor(x) + out = CartesianPosition1D.constructor(x) case (2,): - out = Cartesian2DVector.constructor(x) + out = CartesianPosition2D.constructor(x) case (3,): - out = Cartesian3DVector.constructor(x) + out = CartesianPosition3D.constructor(x) case _: msg = f"Cannot convert {x} to a spatial translation vector." raise TypeError(msg) @@ -68,12 +68,12 @@ class GalileanSpatialTranslationOperator(AbstractGalileanOperator): Parameters ---------- - translation : :class:`vector.Abstract3DVector` + translation : :class:`vector.AbstractPosition3D` The spatial translation vector. This parameters accepts either a - :class:`vector.Abstract3DVector` instance or uses - :meth:`vector.Cartesian3DVector.constructor` to enable a variety of more + :class:`vector.AbstractPosition3D` instance or uses + :meth:`vector.CartesianPosition3D.constructor` to enable a variety of more convenient input types to create a Cartesian vector. See - :class:`vector.Cartesian3DVector` for details. + :class:`vector.CartesianPosition3D` for details. Examples -------- @@ -88,26 +88,26 @@ class GalileanSpatialTranslationOperator(AbstractGalileanOperator): >>> shift = Quantity([1.0, 2.0, 3.0], "kpc") >>> op = cx.operators.GalileanSpatialTranslationOperator(shift) >>> op - GalileanSpatialTranslationOperator( translation=Cartesian3DVector( ... ) ) + GalileanSpatialTranslationOperator( translation=CartesianPosition3D( ... ) ) - Note that the translation is a :class:`vector.Cartesian3DVector`, which was + Note that the translation is a :class:`vector.CartesianPosition3D`, which was constructed from a 1D array, using - :meth:`vector.Cartesian3DVector.constructor`. We can also construct it + :meth:`vector.CartesianPosition3D.constructor`. We can also construct it directly, which allows for other vector types. - >>> from coordinax import SphericalVector - >>> shift = SphericalVector(r=Quantity(1.0, "kpc"), + >>> from coordinax import SphericalPosition + >>> shift = SphericalPosition(r=Quantity(1.0, "kpc"), ... theta=Quantity(xp.pi/2, "rad"), ... phi=Quantity(0, "rad")) >>> op = cx.operators.GalileanSpatialTranslationOperator(shift) >>> op - GalileanSpatialTranslationOperator( translation=SphericalVector( ... ) ) + GalileanSpatialTranslationOperator( translation=SphericalPosition( ... ) ) Translation operators can be applied to :class:`vector.AbstractPosition`: - >>> q = cx.Cartesian3DVector.constructor(Quantity([0, 0, 0], "kpc")) + >>> q = cx.CartesianPosition3D.constructor(Quantity([0, 0, 0], "kpc")) >>> op(q) - Cartesian3DVector( ... ) + CartesianPosition3D( ... ) And to :class:`~unxt.Quantity`: @@ -126,9 +126,9 @@ class GalileanSpatialTranslationOperator(AbstractGalileanOperator): >>> op(q) Quantity['length'](Array([1.], dtype=float32), unit='kpc') - >>> vec = cx.Cartesian1DVector.constructor(q).represent_as(cx.RadialVector) + >>> vec = cx.CartesianPosition1D.constructor(q).represent_as(cx.RadialPosition) >>> op(vec) - RadialVector(r=Distance(value=f32[], unit=Unit("kpc"))) + RadialPosition(r=Distance(value=f32[], unit=Unit("kpc"))) - 2D: @@ -138,9 +138,9 @@ class GalileanSpatialTranslationOperator(AbstractGalileanOperator): >>> op(q) Quantity['length'](Array([1., 2.], dtype=float32), unit='kpc') - >>> vec = cx.Cartesian2DVector.constructor(q).represent_as(cx.PolarVector) + >>> vec = cx.CartesianPosition2D.constructor(q).represent_as(cx.PolarPosition) >>> op(vec) - PolarVector( r=Distance(value=f32[], unit=Unit("kpc")), + PolarPosition( r=Distance(value=f32[], unit=Unit("kpc")), phi=Quantity[...](value=f32[], unit=Unit("rad")) ) - 3D: @@ -151,9 +151,9 @@ class GalileanSpatialTranslationOperator(AbstractGalileanOperator): >>> op(q) Quantity['length'](Array([1., 2., 3.], dtype=float32), unit='kpc') - >>> vec = cx.Cartesian3DVector.constructor(q).represent_as(cx.SphericalVector) + >>> vec = cx.CartesianPosition3D.constructor(q).represent_as(cx.SphericalPosition) >>> op(vec) - SphericalVector( r=Distance(value=f32[], unit=Unit("kpc")), + SphericalPosition( r=Distance(value=f32[], unit=Unit("kpc")), theta=Quantity[...](value=f32[], unit=Unit("rad")), phi=Quantity[...](value=f32[], unit=Unit("rad")) ) @@ -172,7 +172,7 @@ class GalileanSpatialTranslationOperator(AbstractGalileanOperator): This parameters accepts either a :class:`vector.AbstracVector` instance or uses a Cartesian vector constructor to enable a variety of more convenient input types to create a Cartesian vector. See - :class:`vector.Cartesian3DVector.constructor` for an example when doing a 3D + :class:`vector.CartesianPosition3D.constructor` for an example when doing a 3D translation. """ @@ -185,10 +185,10 @@ def is_inertial(self) -> Literal[True]: Examples -------- >>> from unxt import Quantity - >>> from coordinax import Cartesian3DVector + >>> from coordinax import CartesianPosition3D >>> from coordinax.operators import GalileanSpatialTranslationOperator - >>> shift = Cartesian3DVector.constructor(Quantity([1, 1, 1], "kpc")) + >>> shift = CartesianPosition3D.constructor(Quantity([1, 1, 1], "kpc")) >>> op = GalileanSpatialTranslationOperator(shift) >>> op.is_inertial @@ -204,14 +204,14 @@ def inverse(self) -> "GalileanSpatialTranslationOperator": Examples -------- >>> from unxt import Quantity - >>> from coordinax import Cartesian3DVector + >>> from coordinax import CartesianPosition3D >>> from coordinax.operators import GalileanSpatialTranslationOperator - >>> shift = Cartesian3DVector.constructor(Quantity([1, 1, 1], "kpc")) + >>> shift = CartesianPosition3D.constructor(Quantity([1, 1, 1], "kpc")) >>> op = GalileanSpatialTranslationOperator(shift) >>> op.inverse - GalileanSpatialTranslationOperator( translation=Cartesian3DVector( ... ) ) + GalileanSpatialTranslationOperator( translation=CartesianPosition3D( ... ) ) >>> op.inverse.translation.x Quantity['length'](Array(-1., dtype=float32), unit='kpc') @@ -230,13 +230,13 @@ def __call__( Examples -------- >>> from unxt import Quantity - >>> from coordinax import Cartesian3DVector + >>> from coordinax import CartesianPosition3D >>> from coordinax.operators import GalileanSpatialTranslationOperator - >>> shift = Cartesian3DVector.constructor(Quantity([1, 1, 1], "kpc")) + >>> shift = CartesianPosition3D.constructor(Quantity([1, 1, 1], "kpc")) >>> op = GalileanSpatialTranslationOperator(shift) - >>> q = Cartesian3DVector.constructor(Quantity([1, 2, 3], "kpc")) + >>> q = CartesianPosition3D.constructor(Quantity([1, 2, 3], "kpc")) >>> t = Quantity(0, "Gyr") >>> newq = op(q) >>> newq.x @@ -257,13 +257,13 @@ def __call__( Examples -------- >>> from unxt import Quantity - >>> from coordinax import Cartesian3DVector + >>> from coordinax import CartesianPosition3D >>> from coordinax.operators import GalileanSpatialTranslationOperator - >>> shift = Cartesian3DVector.constructor(Quantity([1, 1, 1], "kpc")) + >>> shift = CartesianPosition3D.constructor(Quantity([1, 1, 1], "kpc")) >>> op = GalileanSpatialTranslationOperator(shift) - >>> q = Cartesian3DVector.constructor(Quantity([1, 2, 3], "kpc")) + >>> q = CartesianPosition3D.constructor(Quantity([1, 2, 3], "kpc")) >>> t = Quantity(0, "Gyr") >>> newq, newt = op(q, t) >>> newq.x @@ -335,22 +335,23 @@ class GalileanTranslationOperator(AbstractGalileanOperator): GalileanTranslationOperator( translation=FourVector( t=Quantity[PhysicalType('time')](value=f32[], unit=Unit("kpc s / km")), - q=Cartesian3DVector( ... ) ) + q=CartesianPosition3D( ... ) ) ) Note that the translation is a :class:`vector.FourVector`, which was constructed from a 1D array, using :meth:`vector.FourVector.constructor`. We can also construct it directly, which allows for other vector types. - >>> from coordinax import SphericalVector - >>> qshift = SphericalVector(r=Quantity(1.0, "kpc"), theta=Quantity(xp.pi/2, "rad"), - ... phi=Quantity(0, "rad")) + >>> from coordinax import SphericalPosition + >>> qshift = SphericalPosition(r=Quantity(1.0, "kpc"), + ... theta=Quantity(xp.pi/2, "rad"), + ... phi=Quantity(0, "rad")) >>> op = GalileanTranslationOperator(FourVector(t=Quantity(1.0, "Gyr"), q=qshift)) >>> op GalileanTranslationOperator( translation=FourVector( t=Quantity[PhysicalType('time')](value=f32[], unit=Unit("Gyr")), - q=SphericalVector( ... ) ) + q=SphericalPosition( ... ) ) ) Translation operators can be applied to :class:`vector.FourVector`: @@ -359,12 +360,12 @@ class GalileanTranslationOperator(AbstractGalileanOperator): >>> op(w) FourVector( t=Quantity[PhysicalType('time')](value=f32[], unit=Unit("kpc s / km")), - q=Cartesian3DVector( ... ) + q=CartesianPosition3D( ... ) ) - Also to :class:`vector.Abstract3DVector` and :class:`unxt.Quantity`: + Also to :class:`vector.AbstractPosition3D` and :class:`unxt.Quantity`: - >>> q = Cartesian3DVector.constructor(Quantity([0, 0, 0], "kpc")) + >>> q = CartesianPosition3D.constructor(Quantity([0, 0, 0], "kpc")) >>> t = Quantity(0, "Gyr") >>> newq, newt = op(q, t) >>> newq.x @@ -410,10 +411,10 @@ def inverse(self) -> "GalileanTranslationOperator": Examples -------- >>> from unxt import Quantity - >>> from coordinax import Cartesian3DVector, FourVector + >>> from coordinax import CartesianPosition3D, FourVector >>> from coordinax.operators import GalileanSpatialTranslationOperator - >>> qshift = Cartesian3DVector.constructor(Quantity([1, 1, 1], "kpc")) + >>> qshift = CartesianPosition3D.constructor(Quantity([1, 1, 1], "kpc")) >>> tshift = Quantity(1, "Gyr") >>> shift = FourVector(tshift, qshift) >>> op = GalileanTranslationOperator(shift) @@ -436,12 +437,12 @@ def __call__(self: "GalileanTranslationOperator", x: FourVector, /) -> FourVecto Examples -------- >>> from unxt import Quantity - >>> from coordinax import Cartesian3DVector, FourVector + >>> from coordinax import CartesianPosition3D, FourVector >>> from coordinax.operators import GalileanTranslationOperator Explicitly construct the translation operator: - >>> qshift = Cartesian3DVector.constructor(Quantity([1, 1, 1], "kpc")) + >>> qshift = CartesianPosition3D.constructor(Quantity([1, 1, 1], "kpc")) >>> tshift = Quantity(1, "Gyr") >>> shift = FourVector(tshift, qshift) >>> op = GalileanTranslationOperator(shift) @@ -467,26 +468,29 @@ def __call__(self: "GalileanTranslationOperator", x: FourVector, /) -> FourVecto @op_call_dispatch(precedence=1) def __call__( - self: "GalileanTranslationOperator", x: Abstract3DVector, t: Quantity["time"], / - ) -> tuple[Abstract3DVector, Quantity["time"]]: + self: "GalileanTranslationOperator", + x: AbstractPosition3D, + t: Quantity["time"], + /, + ) -> tuple[AbstractPosition3D, Quantity["time"]]: """Apply the translation to the coordinates. Examples -------- >>> from unxt import Quantity - >>> from coordinax import Cartesian3DVector, FourVector + >>> from coordinax import CartesianPosition3D, FourVector >>> from coordinax.operators import GalileanTranslationOperator Explicitly construct the translation operator: - >>> qshift = Cartesian3DVector.constructor(Quantity([1, 1, 1], "kpc")) + >>> qshift = CartesianPosition3D.constructor(Quantity([1, 1, 1], "kpc")) >>> tshift = Quantity(1, "Gyr") >>> shift = FourVector(tshift, qshift) >>> op = GalileanTranslationOperator(shift) Construct a vector to translate - >>> q = Cartesian3DVector.constructor(Quantity([1, 2, 3], "kpc")) + >>> q = CartesianPosition3D.constructor(Quantity([1, 2, 3], "kpc")) >>> t = Quantity(1, "Gyr") >>> newq, newt = op(q, t) diff --git a/src/coordinax/operators/_identity.py b/src/coordinax/operators/_identity.py index 6bd62b0..40da8bc 100644 --- a/src/coordinax/operators/_identity.py +++ b/src/coordinax/operators/_identity.py @@ -35,7 +35,7 @@ class IdentityOperator(AbstractOperator): And the common objects we will use: >>> q = Quantity([1, 2, 3], "kpc") - >>> vec = cx.Cartesian3DVector.constructor(q) + >>> vec = cx.CartesianPosition3D.constructor(q) The first call signature is for the case where the input is a vector: @@ -52,21 +52,21 @@ class IdentityOperator(AbstractOperator): - 1D: >>> q = Quantity([1], "kpc") - >>> vec = cx.Cartesian1DVector.constructor(q) + >>> vec = cx.CartesianPosition1D.constructor(q) >>> op(vec) is vec and op(q) is q True - 2D: >>> q = Quantity([1, 2], "kpc") - >>> vec = cx.Cartesian2DVector.constructor(q) + >>> vec = cx.CartesianPosition2D.constructor(q) >>> op(vec) is vec and op(q) is q True - - 3D (not using a `~coordinax.Cartesian3DVector` instance): + - 3D (not using a `~coordinax.CartesianPosition3D` instance): >>> q = Quantity([1, 2, 3], "kpc") - >>> vec = cx.Cartesian3DVector.constructor(q).represent_as(cx.SphericalVector) + >>> vec = cx.CartesianPosition3D.constructor(q).represent_as(cx.SphericalPosition) >>> op(vec) is vec and op(q) is q True @@ -97,10 +97,10 @@ def is_inertial(self) -> Literal[True]: Examples -------- >>> from unxt import Quantity - >>> from coordinax import Cartesian3DVector + >>> from coordinax import CartesianPosition3D >>> from coordinax.operators import IdentityOperator - >>> q = Cartesian3DVector.constructor(Quantity([1, 2, 3], "kpc")) + >>> q = CartesianPosition3D.constructor(Quantity([1, 2, 3], "kpc")) >>> t = Quantity(0, "Gyr") >>> op = IdentityOperator() >>> op.is_inertial @@ -116,7 +116,7 @@ def inverse(self) -> "IdentityOperator": Examples -------- >>> from unxt import Quantity - >>> from coordinax import Cartesian3DVector + >>> from coordinax import CartesianPosition3D >>> from coordinax.operators import IdentityOperator >>> op = IdentityOperator() @@ -141,10 +141,10 @@ def __call__(self: "IdentityOperator", x: AbstractPosition, /) -> AbstractPositi Examples -------- >>> from unxt import Quantity - >>> from coordinax import Cartesian3DVector + >>> from coordinax import CartesianPosition3D >>> from coordinax.operators import IdentityOperator - >>> q = Cartesian3DVector.constructor(Quantity([1, 2, 3], "kpc")) + >>> q = CartesianPosition3D.constructor(Quantity([1, 2, 3], "kpc")) >>> op = IdentityOperator() >>> op(q) is q True diff --git a/tests/test_base.py b/tests/test_base.py index 97c23ad..a187343 100644 --- a/tests/test_base.py +++ b/tests/test_base.py @@ -14,58 +14,58 @@ from unxt import AbstractQuantity from coordinax import ( - Abstract1DVector, - Abstract1DVectorDifferential, - Abstract2DVector, - Abstract2DVectorDifferential, - Abstract3DVector, - Abstract3DVectorDifferential, AbstractPosition, + AbstractPosition1D, + AbstractPosition2D, + AbstractPosition3D, AbstractVelocity, - Cartesian1DVector, - Cartesian2DVector, - Cartesian3DVector, - CartesianDifferential1D, - CartesianDifferential2D, - CartesianDifferential3D, - CylindricalDifferential, - CylindricalVector, + AbstractVelocity1D, + AbstractVelocity2D, + AbstractVelocity3D, + CartesianPosition1D, + CartesianPosition2D, + CartesianPosition3D, + CartesianVelocity1D, + CartesianVelocity2D, + CartesianVelocity3D, + CylindricalPosition, + CylindricalVelocity, IrreversibleDimensionChange, - PolarDifferential, - PolarVector, - RadialDifferential, - RadialVector, - SphericalDifferential, - SphericalVector, + PolarPosition, + PolarVelocity, + RadialPosition, + RadialVelocity, + SphericalPosition, + SphericalVelocity, ) from coordinax._utils import dataclass_items BUILTIN_VECTORS = [ # 1D - Cartesian1DVector, - RadialVector, + CartesianPosition1D, + RadialPosition, # 2D - Cartesian2DVector, - PolarVector, + CartesianPosition2D, + PolarPosition, # 3D - Cartesian3DVector, - SphericalVector, - CylindricalVector, + CartesianPosition3D, + SphericalPosition, + CylindricalPosition, ] BUILTIN_DIFFERENTIALS = [ # 1D - CartesianDifferential1D, - RadialDifferential, + CartesianVelocity1D, + RadialVelocity, # 2D - CartesianDifferential2D, - PolarDifferential, - # LnPolarDifferential, - # Log10PolarDifferential, + CartesianVelocity2D, + PolarVelocity, + # LnPolarVelocity, + # Log10PolarVelocity, # 3D - CartesianDifferential3D, - SphericalDifferential, - CylindricalDifferential, + CartesianVelocity3D, + SphericalVelocity, + CylindricalVelocity, ] @@ -75,10 +75,11 @@ def context_dimension_reduction( """Return a context manager that checks for dimensionality reduction.""" context: AbstractContextManager[Any] if ( - isinstance(vector, Abstract2DVector) and issubclass(target, Abstract1DVector) + isinstance(vector, AbstractPosition2D) + and issubclass(target, AbstractPosition1D) ) or ( - isinstance(vector, Abstract3DVector) - and issubclass(target, Abstract2DVector | Abstract1DVector) + isinstance(vector, AbstractPosition3D) + and issubclass(target, AbstractPosition2D | AbstractPosition1D) ): context = pytest.warns(IrreversibleDimensionChange) else: @@ -229,16 +230,16 @@ def test_represent_as(self, difntl, target, vector): # TODO: have all the conversions if ( ( - isinstance(difntl, Abstract1DVectorDifferential) - and not issubclass(target, Abstract1DVectorDifferential) + isinstance(difntl, AbstractVelocity1D) + and not issubclass(target, AbstractVelocity1D) ) or ( - isinstance(difntl, Abstract2DVectorDifferential) - and not issubclass(target, Abstract2DVectorDifferential) + isinstance(difntl, AbstractVelocity2D) + and not issubclass(target, AbstractVelocity2D) ) or ( - isinstance(difntl, Abstract3DVectorDifferential) - and not issubclass(target, Abstract3DVectorDifferential) + isinstance(difntl, AbstractVelocity3D) + and not issubclass(target, AbstractVelocity3D) ) ): pytest.xfail("Not implemented yet") diff --git a/tests/test_d1.py b/tests/test_d1.py index 39c8c2c..c728d95 100644 --- a/tests/test_d1.py +++ b/tests/test_d1.py @@ -9,259 +9,259 @@ from .test_base import AbstractPositionTest, AbstractVelocityTest -class Abstract1DVectorTest(AbstractPositionTest): - """Test :class:`coordinax.Abstract1DVector`.""" +class AbstractPosition1DTest(AbstractPositionTest): + """Test :class:`coordinax.AbstractPosition1D`.""" # TODO: Add tests -class TestCartesian1DVector(Abstract1DVectorTest): - """Test :class:`coordinax.Cartesian1DVector`.""" +class TestCartesianPosition1D(AbstractPosition1DTest): + """Test :class:`coordinax.CartesianPosition1D`.""" @pytest.fixture(scope="class") def vector(self) -> cx.AbstractPosition: """Return a vector.""" - return cx.Cartesian1DVector(x=Quantity([1, 2, 3, 4], "kpc")) + return cx.CartesianPosition1D(x=Quantity([1, 2, 3, 4], "kpc")) # ========================================================================== # represent_as def test_cartesian1d_to_cartesian1d(self, vector): - """Test ``coordinax.represent_as(Cartesian1DVector)``.""" + """Test ``coordinax.represent_as(CartesianPosition1D)``.""" # Jit can copy - newvec = vector.represent_as(cx.Cartesian1DVector) + newvec = vector.represent_as(cx.CartesianPosition1D) assert newvec == vector # The normal `represent_as` method should return the same object - newvec = cx.represent_as(vector, cx.Cartesian1DVector) + newvec = cx.represent_as(vector, cx.CartesianPosition1D) assert newvec is vector def test_cartesian1d_to_radial(self, vector): - """Test ``coordinax.represent_as(RadialVector)``.""" - radial = vector.represent_as(cx.RadialVector) + """Test ``coordinax.represent_as(RadialPosition)``.""" + radial = vector.represent_as(cx.RadialPosition) - assert isinstance(radial, cx.RadialVector) + assert isinstance(radial, cx.RadialPosition) assert qnp.array_equal(radial.r, Quantity([1, 2, 3, 4], "kpc")) def test_cartesian1d_to_cartesian2d(self, vector): - """Test ``coordinax.represent_as(Cartesian2DVector)``.""" + """Test ``coordinax.represent_as(CartesianPosition2D)``.""" cart2d = vector.represent_as( - cx.Cartesian2DVector, y=Quantity([5, 6, 7, 8], "km") + cx.CartesianPosition2D, y=Quantity([5, 6, 7, 8], "km") ) - assert isinstance(cart2d, cx.Cartesian2DVector) + assert isinstance(cart2d, cx.CartesianPosition2D) assert qnp.array_equal(cart2d.x, Quantity([1, 2, 3, 4], "kpc")) assert qnp.array_equal(cart2d.y, Quantity([5, 6, 7, 8], "km")) def test_cartesian1d_to_polar(self, vector): - """Test ``coordinax.represent_as(PolarVector)``.""" - polar = vector.represent_as(cx.PolarVector, phi=Quantity([0, 1, 2, 3], "rad")) + """Test ``coordinax.represent_as(PolarPosition)``.""" + polar = vector.represent_as(cx.PolarPosition, phi=Quantity([0, 1, 2, 3], "rad")) - assert isinstance(polar, cx.PolarVector) + assert isinstance(polar, cx.PolarPosition) assert qnp.array_equal(polar.r, Quantity([1, 2, 3, 4], "kpc")) assert qnp.array_equal(polar.phi, Quantity([0, 1, 2, 3], "rad")) def test_cartesian1d_to_cartesian3d(self, vector): - """Test ``coordinax.represent_as(Cartesian3DVector)``.""" + """Test ``coordinax.represent_as(CartesianPosition3D)``.""" cart3d = vector.represent_as( - cx.Cartesian3DVector, + cx.CartesianPosition3D, y=Quantity([5, 6, 7, 8], "km"), z=Quantity([9, 10, 11, 12], "m"), ) - assert isinstance(cart3d, cx.Cartesian3DVector) + assert isinstance(cart3d, cx.CartesianPosition3D) assert qnp.array_equal(cart3d.x, Quantity([1, 2, 3, 4], "kpc")) assert qnp.array_equal(cart3d.y, Quantity([5, 6, 7, 8], "km")) assert qnp.array_equal(cart3d.z, Quantity([9, 10, 11, 12], "m")) def test_cartesian1d_to_spherical(self, vector): - """Test ``coordinax.represent_as(SphericalVector)``.""" + """Test ``coordinax.represent_as(SphericalPosition)``.""" spherical = vector.represent_as( - cx.SphericalVector, + cx.SphericalPosition, theta=Quantity([4, 5, 6, 7], "rad"), phi=Quantity([0, 1, 2, 3], "rad"), ) - assert isinstance(spherical, cx.SphericalVector) + assert isinstance(spherical, cx.SphericalPosition) assert qnp.array_equal(spherical.r, Quantity([1, 2, 3, 4], "kpc")) assert qnp.array_equal(spherical.theta, Quantity([4, 5, 6, 7], "rad")) assert qnp.array_equal(spherical.phi, Quantity([0, 1, 2, 3], "rad")) def test_cartesian1d_to_cylindrical(self, vector): - """Test ``coordinax.represent_as(CylindricalVector)``.""" + """Test ``coordinax.represent_as(CylindricalPosition)``.""" cylindrical = vector.represent_as( - cx.CylindricalVector, + cx.CylindricalPosition, phi=Quantity([0, 1, 2, 3], "rad"), z=Quantity([4, 5, 6, 7], "m"), ) - assert isinstance(cylindrical, cx.CylindricalVector) + assert isinstance(cylindrical, cx.CylindricalPosition) assert qnp.array_equal(cylindrical.rho, Quantity([1, 2, 3, 4], "kpc")) assert qnp.array_equal(cylindrical.phi, Quantity([0, 1, 2, 3], "rad")) assert qnp.array_equal(cylindrical.z, Quantity([4, 5, 6, 7], "m")) -class TestRadialVector(Abstract1DVectorTest): - """Test :class:`coordinax.RadialVector`.""" +class TestRadialPosition(AbstractPosition1DTest): + """Test :class:`coordinax.RadialPosition`.""" @pytest.fixture(scope="class") def vector(self) -> cx.AbstractPosition: """Return a vector.""" - return cx.RadialVector(r=Quantity([1, 2, 3, 4], "kpc")) + return cx.RadialPosition(r=Quantity([1, 2, 3, 4], "kpc")) # ========================================================================== # represent_as def test_radial_to_cartesian1d(self, vector): - """Test ``coordinax.represent_as(Cartesian1DVector)``.""" - cart1d = vector.represent_as(cx.Cartesian1DVector) + """Test ``coordinax.represent_as(CartesianPosition1D)``.""" + cart1d = vector.represent_as(cx.CartesianPosition1D) - assert isinstance(cart1d, cx.Cartesian1DVector) + assert isinstance(cart1d, cx.CartesianPosition1D) assert qnp.array_equal(cart1d.x, Quantity([1, 2, 3, 4], "kpc")) def test_radial_to_radial(self, vector): - """Test ``coordinax.represent_as(RadialVector)``.""" + """Test ``coordinax.represent_as(RadialPosition)``.""" # Jit can copy - newvec = vector.represent_as(cx.RadialVector) + newvec = vector.represent_as(cx.RadialPosition) assert newvec == vector # The normal `represent_as` method should return the same object - newvec = cx.represent_as(vector, cx.RadialVector) + newvec = cx.represent_as(vector, cx.RadialPosition) assert newvec is vector def test_radial_to_cartesian2d(self, vector): - """Test ``coordinax.represent_as(Cartesian2DVector)``.""" + """Test ``coordinax.represent_as(CartesianPosition2D)``.""" cart2d = vector.represent_as( - cx.Cartesian2DVector, y=Quantity([5, 6, 7, 8], "km") + cx.CartesianPosition2D, y=Quantity([5, 6, 7, 8], "km") ) - assert isinstance(cart2d, cx.Cartesian2DVector) + assert isinstance(cart2d, cx.CartesianPosition2D) assert qnp.array_equal(cart2d.x, Quantity([1, 2, 3, 4], "kpc")) assert qnp.array_equal(cart2d.y, Quantity([5, 6, 7, 8], "km")) def test_radial_to_polar(self, vector): - """Test ``coordinax.represent_as(PolarVector)``.""" - polar = vector.represent_as(cx.PolarVector, phi=Quantity([0, 1, 2, 3], "rad")) + """Test ``coordinax.represent_as(PolarPosition)``.""" + polar = vector.represent_as(cx.PolarPosition, phi=Quantity([0, 1, 2, 3], "rad")) - assert isinstance(polar, cx.PolarVector) + assert isinstance(polar, cx.PolarPosition) assert qnp.array_equal(polar.r, Quantity([1, 2, 3, 4], "kpc")) assert qnp.array_equal(polar.phi, Quantity([0, 1, 2, 3], "rad")) def test_radial_to_cartesian3d(self, vector): - """Test ``coordinax.represent_as(Cartesian3DVector)``.""" + """Test ``coordinax.represent_as(CartesianPosition3D)``.""" cart3d = vector.represent_as( - cx.Cartesian3DVector, + cx.CartesianPosition3D, y=Quantity([5, 6, 7, 8], "km"), z=Quantity([9, 10, 11, 12], "m"), ) - assert isinstance(cart3d, cx.Cartesian3DVector) + assert isinstance(cart3d, cx.CartesianPosition3D) assert qnp.array_equal(cart3d.x, Quantity([1, 2, 3, 4], "kpc")) assert qnp.array_equal(cart3d.y, Quantity([5, 6, 7, 8], "km")) assert qnp.array_equal(cart3d.z, Quantity([9, 10, 11, 12], "m")) def test_radial_to_spherical(self, vector): - """Test ``coordinax.represent_as(SphericalVector)``.""" + """Test ``coordinax.represent_as(SphericalPosition)``.""" spherical = vector.represent_as( - cx.SphericalVector, + cx.SphericalPosition, theta=Quantity([4, 5, 6, 7], "rad"), phi=Quantity([0, 1, 2, 3], "rad"), ) - assert isinstance(spherical, cx.SphericalVector) + assert isinstance(spherical, cx.SphericalPosition) assert qnp.array_equal(spherical.r, Quantity([1, 2, 3, 4], "kpc")) assert qnp.array_equal(spherical.theta, Quantity([4, 5, 6, 7], "rad")) assert qnp.array_equal(spherical.phi, Quantity([0, 1, 2, 3], "rad")) def test_radial_to_cylindrical(self, vector): - """Test ``coordinax.represent_as(CylindricalVector)``.""" + """Test ``coordinax.represent_as(CylindricalPosition)``.""" cylindrical = vector.represent_as( - cx.CylindricalVector, + cx.CylindricalPosition, phi=Quantity([0, 1, 2, 3], "rad"), z=Quantity([4, 5, 6, 7], "m"), ) - assert isinstance(cylindrical, cx.CylindricalVector) + assert isinstance(cylindrical, cx.CylindricalPosition) assert qnp.array_equal(cylindrical.rho, Quantity([1, 2, 3, 4], "kpc")) assert qnp.array_equal(cylindrical.phi, Quantity([0, 1, 2, 3], "rad")) assert qnp.array_equal(cylindrical.z, Quantity([4, 5, 6, 7], "m")) -class Abstract1DVectorDifferentialTest(AbstractVelocityTest): - """Test :class:`coordinax.Abstract1DVectorDifferential`.""" +class AbstractVelocity1DTest(AbstractVelocityTest): + """Test :class:`coordinax.AbstractVelocity1D`.""" -class TestCartesianDifferential1D(Abstract1DVectorDifferentialTest): - """Test :class:`coordinax.CartesianDifferential1D`.""" +class TestCartesianVelocity1D(AbstractVelocity1DTest): + """Test :class:`coordinax.CartesianVelocity1D`.""" @pytest.fixture(scope="class") - def difntl(self) -> cx.CartesianDifferential1D: + def difntl(self) -> cx.CartesianVelocity1D: """Return a vector.""" - return cx.CartesianDifferential1D(d_x=Quantity([1.0, 2, 3, 4], "km/s")) + return cx.CartesianVelocity1D(d_x=Quantity([1.0, 2, 3, 4], "km/s")) @pytest.fixture(scope="class") - def vector(self) -> cx.Cartesian1DVector: + def vector(self) -> cx.CartesianPosition1D: """Return a vector.""" - return cx.Cartesian1DVector(x=Quantity([1.0, 2, 3, 4], "kpc")) + return cx.CartesianPosition1D(x=Quantity([1.0, 2, 3, 4], "kpc")) # ========================================================================== # represent_as @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_cartesian1d_to_cartesian1d(self, difntl, vector): - """Test ``difntl.represent_as(CartesianDifferential1D)``.""" + """Test ``difntl.represent_as(CartesianVelocity1D)``.""" # Jit can copy - newvec = difntl.represent_as(cx.CartesianDifferential1D, vector) + newvec = difntl.represent_as(cx.CartesianVelocity1D, vector) assert newvec == difntl # The normal `represent_as` method should return the same object - newvec = cx.represent_as(difntl, cx.CartesianDifferential1D, vector) + newvec = cx.represent_as(difntl, cx.CartesianVelocity1D, vector) assert newvec is difntl @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_cartesian1d_to_radial(self, difntl, vector): - """Test ``difntl.represent_as(RadialDifferential)``.""" - radial = difntl.represent_as(cx.RadialDifferential, vector) + """Test ``difntl.represent_as(RadialVelocity)``.""" + radial = difntl.represent_as(cx.RadialVelocity, vector) - assert isinstance(radial, cx.RadialDifferential) + assert isinstance(radial, cx.RadialVelocity) assert qnp.array_equal(radial.d_r, Quantity([1, 2, 3, 4], "km/s")) @pytest.mark.xfail(reason="Not implemented") @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_cartesian1d_to_cartesian2d(self, difntl, vector): - """Test ``difntl.represent_as(CartesianDifferential2D)``.""" + """Test ``difntl.represent_as(CartesianVelocity2D)``.""" cart2d = difntl.represent_as( - cx.CartesianDifferential2D, vector, d_y=Quantity([5, 6, 7, 8], "km") + cx.CartesianVelocity2D, vector, d_y=Quantity([5, 6, 7, 8], "km") ) - assert isinstance(cart2d, cx.CartesianDifferential2D) + assert isinstance(cart2d, cx.CartesianVelocity2D) assert qnp.array_equal(cart2d.d_x, Quantity([1, 2, 3, 4], "km/s")) assert qnp.array_equal(cart2d.d_y, Quantity([5, 6, 7, 8], "km/s")) @pytest.mark.xfail(reason="Not implemented") @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_cartesian1d_to_polar(self, difntl, vector): - """Test ``difntl.represent_as(PolarDifferential)``.""" + """Test ``difntl.represent_as(PolarVelocity)``.""" polar = difntl.represent_as( - cx.PolarDifferential, vector, d_phi=Quantity([0, 1, 2, 3], "rad") + cx.PolarVelocity, vector, d_phi=Quantity([0, 1, 2, 3], "rad") ) - assert isinstance(polar, cx.PolarDifferential) + assert isinstance(polar, cx.PolarVelocity) assert qnp.array_equal(polar.d_r, Quantity([1, 2, 3, 4], "km/s")) assert qnp.array_equal(polar.d_phi, Quantity([0, 1, 2, 3], "rad/s")) @pytest.mark.xfail(reason="Not implemented") @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_cartesian1d_to_cartesian3d(self, difntl, vector): - """Test ``difntl.represent_as(CartesianDifferential3D)``.""" + """Test ``difntl.represent_as(CartesianVelocity3D)``.""" cart3d = difntl.represent_as( - cx.CartesianDifferential3D, + cx.CartesianVelocity3D, vector, d_y=Quantity([5, 6, 7, 8], "km"), d_z=Quantity([9, 10, 11, 12], "m"), ) - assert isinstance(cart3d, cx.CartesianDifferential3D) + assert isinstance(cart3d, cx.CartesianVelocity3D) assert qnp.array_equal(cart3d.d_x, Quantity([1, 2, 3, 4], "kpc")) assert qnp.array_equal(cart3d.d_y, Quantity([5, 6, 7, 8], "km")) assert qnp.array_equal(cart3d.d_z, Quantity([9, 10, 11, 12], "m")) @@ -269,15 +269,15 @@ def test_cartesian1d_to_cartesian3d(self, difntl, vector): @pytest.mark.xfail(reason="Not implemented") @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_cartesian1d_to_spherical(self, difntl, vector): - """Test ``difntl.represent_as(SphericalDifferential)``.""" + """Test ``difntl.represent_as(SphericalVelocity)``.""" spherical = difntl.represent_as( - cx.SphericalDifferential, + cx.SphericalVelocity, vector, d_theta=Quantity([4, 5, 6, 7], "rad"), d_phi=Quantity([0, 1, 2, 3], "rad"), ) - assert isinstance(spherical, cx.SphericalDifferential) + assert isinstance(spherical, cx.SphericalVelocity) assert qnp.array_equal(spherical.d_r, Quantity([1, 2, 3, 4], "kpc")) assert spherical.d_theta == Quantity([4, 5, 6, 7], "rad") assert qnp.array_equal(spherical.d_phi, Quantity([0, 1, 2, 3], "rad")) @@ -285,91 +285,91 @@ def test_cartesian1d_to_spherical(self, difntl, vector): @pytest.mark.xfail(reason="Not implemented") @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_cartesian1d_to_cylindrical(self, difntl, vector): - """Test ``difntl.represent_as(CylindricalDifferential)``.""" + """Test ``difntl.represent_as(CylindricalVelocity)``.""" cylindrical = difntl.represent_as( - cx.CylindricalDifferential, + cx.CylindricalVelocity, vector, d_phi=Quantity([0, 1, 2, 3], "rad"), d_z=Quantity([4, 5, 6, 7], "m"), ) - assert isinstance(cylindrical, cx.CylindricalDifferential) + assert isinstance(cylindrical, cx.CylindricalVelocity) assert qnp.array_equal(cylindrical.d_rho, Quantity([1, 2, 3, 4], "kpc")) assert qnp.array_equal(cylindrical.d_phi, Quantity([0, 1, 2, 3], "rad")) assert qnp.array_equal(cylindrical.d_z, Quantity([4, 5, 6, 7], "m")) -class TestRadialDifferential(Abstract1DVectorDifferentialTest): - """Test :class:`coordinax.RadialDifferential`.""" +class TestRadialVelocity(AbstractVelocity1DTest): + """Test :class:`coordinax.RadialVelocity`.""" @pytest.fixture(scope="class") - def difntl(self) -> cx.RadialDifferential: + def difntl(self) -> cx.RadialVelocity: """Return a vector.""" - return cx.RadialDifferential(d_r=Quantity([1, 2, 3, 4], "km/s")) + return cx.RadialVelocity(d_r=Quantity([1, 2, 3, 4], "km/s")) @pytest.fixture(scope="class") - def vector(self) -> cx.RadialVector: + def vector(self) -> cx.RadialPosition: """Return a vector.""" - return cx.RadialVector(r=Quantity([1, 2, 3, 4], "kpc")) + return cx.RadialPosition(r=Quantity([1, 2, 3, 4], "kpc")) # ========================================================================== # represent_as @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_radial_to_cartesian1d(self, difntl, vector): - """Test ``difntl.represent_as(CartesianDifferential1D)``.""" - cart1d = difntl.represent_as(cx.CartesianDifferential1D, vector) + """Test ``difntl.represent_as(CartesianVelocity1D)``.""" + cart1d = difntl.represent_as(cx.CartesianVelocity1D, vector) - assert isinstance(cart1d, cx.CartesianDifferential1D) + assert isinstance(cart1d, cx.CartesianVelocity1D) assert qnp.array_equal(cart1d.d_x, Quantity([1, 2, 3, 4], "km/s")) @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_radial_to_radial(self, difntl, vector): - """Test ``difntl.represent_as(RadialDifferential)``.""" + """Test ``difntl.represent_as(RadialVelocity)``.""" # Jit can copy - newvec = difntl.represent_as(cx.RadialDifferential, vector) + newvec = difntl.represent_as(cx.RadialVelocity, vector) assert newvec == difntl # The normal `represent_as` method should return the same object - newvec = cx.represent_as(difntl, cx.RadialDifferential, vector) + newvec = cx.represent_as(difntl, cx.RadialVelocity, vector) assert newvec is difntl @pytest.mark.xfail(reason="Not implemented") @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_radial_to_cartesian2d(self, difntl, vector): - """Test ``difntl.represent_as(CartesianDifferential2D)``.""" + """Test ``difntl.represent_as(CartesianVelocity2D)``.""" cart2d = difntl.represent_as( - cx.CartesianDifferential2D, vector, d_y=Quantity([5, 6, 7, 8], "km") + cx.CartesianVelocity2D, vector, d_y=Quantity([5, 6, 7, 8], "km") ) - assert isinstance(cart2d, cx.CartesianDifferential2D) + assert isinstance(cart2d, cx.CartesianVelocity2D) assert qnp.array_equal(cart2d.d_x, Quantity([1, 2, 3, 4], "kpc")) assert qnp.array_equal(cart2d.d_y, Quantity([5, 6, 7, 8], "km")) @pytest.mark.xfail(reason="Not implemented") @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_radial_to_polar(self, difntl, vector): - """Test ``difntl.represent_as(PolarDifferential)``.""" + """Test ``difntl.represent_as(PolarVelocity)``.""" polar = difntl.represent_as( - cx.PolarDifferential, vector, d_phi=Quantity([0, 1, 2, 3], "rad") + cx.PolarVelocity, vector, d_phi=Quantity([0, 1, 2, 3], "rad") ) - assert isinstance(polar, cx.PolarDifferential) + assert isinstance(polar, cx.PolarVelocity) assert qnp.array_equal(polar.d_r, Quantity([1, 2, 3, 4], "kpc")) assert qnp.array_equal(polar.d_phi, Quantity([0, 1, 2, 3], "rad")) @pytest.mark.xfail(reason="Not implemented") @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_radial_to_cartesian3d(self, difntl, vector): - """Test ``difntl.represent_as(CartesianDifferential3D)``.""" + """Test ``difntl.represent_as(CartesianVelocity3D)``.""" cart3d = difntl.represent_as( - cx.CartesianDifferential3D, + cx.CartesianVelocity3D, vector, d_y=Quantity([5, 6, 7, 8], "km"), d_z=Quantity([9, 10, 11, 12], "m"), ) - assert isinstance(cart3d, cx.CartesianDifferential3D) + assert isinstance(cart3d, cx.CartesianVelocity3D) assert qnp.array_equal(cart3d.d_x, Quantity([1, 2, 3, 4], "kpc")) assert qnp.array_equal(cart3d.d_y, Quantity([5, 6, 7, 8], "km")) assert qnp.array_equal(cart3d.d_z, Quantity([9, 10, 11, 12], "m")) @@ -377,15 +377,15 @@ def test_radial_to_cartesian3d(self, difntl, vector): @pytest.mark.xfail(reason="Not implemented") @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_radial_to_spherical(self, difntl, vector): - """Test ``difntl.represent_as(SphericalDifferential)``.""" + """Test ``difntl.represent_as(SphericalVelocity)``.""" spherical = difntl.represent_as( - cx.SphericalDifferential, + cx.SphericalVelocity, vector, d_theta=Quantity([4, 5, 6, 7], "rad"), d_phi=Quantity([0, 1, 2, 3], "rad"), ) - assert isinstance(spherical, cx.SphericalDifferential) + assert isinstance(spherical, cx.SphericalVelocity) assert qnp.array_equal(spherical.d_r, Quantity([1, 2, 3, 4], "kpc")) assert spherical.d_theta == Quantity([4, 5, 6, 7], "rad") assert qnp.array_equal(spherical.d_phi, Quantity([0, 1, 2, 3], "rad")) @@ -393,15 +393,15 @@ def test_radial_to_spherical(self, difntl, vector): @pytest.mark.xfail(reason="Not implemented") @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_radial_to_cylindrical(self, difntl, vector): - """Test ``difntl.represent_as(CylindricalDifferential)``.""" + """Test ``difntl.represent_as(CylindricalVelocity)``.""" cylindrical = difntl.represent_as( - cx.CylindricalDifferential, + cx.CylindricalVelocity, vector, d_phi=Quantity([0, 1, 2, 3], "rad"), d_z=Quantity([4, 5, 6, 7], "m"), ) - assert isinstance(cylindrical, cx.CylindricalDifferential) + assert isinstance(cylindrical, cx.CylindricalVelocity) assert qnp.array_equal(cylindrical.d_rho, Quantity([1, 2, 3, 4], "kpc")) assert qnp.array_equal(cylindrical.d_phi, Quantity([0, 1, 2, 3], "rad")) assert qnp.array_equal(cylindrical.d_z, Quantity([4, 5, 6, 7], "m")) diff --git a/tests/test_d2.py b/tests/test_d2.py index 232fa24..b40f387 100644 --- a/tests/test_d2.py +++ b/tests/test_d2.py @@ -10,17 +10,17 @@ from .test_base import AbstractPositionTest, AbstractVelocityTest -class Abstract2DVectorTest(AbstractPositionTest): - """Test :class:`coordinax.Abstract2DVector`.""" +class AbstractPosition2DTest(AbstractPositionTest): + """Test :class:`coordinax.AbstractPosition2D`.""" -class TestCartesian2DVector: - """Test :class:`coordinax.Cartesian2DVector`.""" +class TestCartesianPosition2D: + """Test :class:`coordinax.CartesianPosition2D`.""" @pytest.fixture(scope="class") - def vector(self) -> cx.Cartesian2DVector: + def vector(self) -> cx.CartesianPosition2D: """Return a vector.""" - return cx.Cartesian2DVector( + return cx.CartesianPosition2D( x=Quantity([1, 2, 3, 4], "kpc"), y=Quantity([5, 6, 7, 8], "kpc") ) @@ -29,40 +29,40 @@ def vector(self) -> cx.Cartesian2DVector: @pytest.mark.filterwarnings("ignore:Irreversible dimension change") def test_cartesian2d_to_cartesian1d(self, vector): - """Test ``coordinax.represent_as(Cartesian1DVector)``.""" - cart1d = vector.represent_as(cx.Cartesian1DVector) + """Test ``coordinax.represent_as(CartesianPosition1D)``.""" + cart1d = vector.represent_as(cx.CartesianPosition1D) - assert isinstance(cart1d, cx.Cartesian1DVector) + assert isinstance(cart1d, cx.CartesianPosition1D) assert qnp.array_equal(cart1d.x, Quantity([1, 2, 3, 4], "kpc")) @pytest.mark.filterwarnings("ignore:Irreversible dimension change") def test_cartesian2d_to_radial(self, vector): - """Test ``coordinax.represent_as(RadialVector)``.""" - radial = vector.represent_as(cx.RadialVector) + """Test ``coordinax.represent_as(RadialPosition)``.""" + radial = vector.represent_as(cx.RadialPosition) - assert isinstance(radial, cx.RadialVector) + assert isinstance(radial, cx.RadialPosition) assert qnp.array_equal(radial.r, qnp.hypot(vector.x, vector.y)) def test_cartesian2d_to_cartesian2d(self, vector): - """Test ``coordinax.represent_as(Cartesian2DVector)``.""" - newvec = vector.represent_as(cx.Cartesian2DVector) + """Test ``coordinax.represent_as(CartesianPosition2D)``.""" + newvec = vector.represent_as(cx.CartesianPosition2D) assert newvec is vector def test_cartesian2d_to_cartesian2d(self, vector): - """Test ``coordinax.represent_as(Cartesian2DVector)``.""" + """Test ``coordinax.represent_as(CartesianPosition2D)``.""" # Jit can copy - newvec = vector.represent_as(cx.Cartesian2DVector) + newvec = vector.represent_as(cx.CartesianPosition2D) assert newvec == vector # The normal `represent_as` method should return the same object - newvec = cx.represent_as(vector, cx.Cartesian2DVector) + newvec = cx.represent_as(vector, cx.CartesianPosition2D) assert newvec is vector def test_cartesian2d_to_polar(self, vector): - """Test ``coordinax.represent_as(PolarVector)``.""" - polar = vector.represent_as(cx.PolarVector) + """Test ``coordinax.represent_as(PolarPosition)``.""" + polar = vector.represent_as(cx.PolarPosition) - assert isinstance(polar, cx.PolarVector) + assert isinstance(polar, cx.PolarPosition) assert qnp.array_equal(polar.r, qnp.hypot(vector.x, vector.y)) assert qnp.allclose( polar.phi, @@ -71,23 +71,23 @@ def test_cartesian2d_to_polar(self, vector): ) def test_cartesian2d_to_cartesian3d(self, vector): - """Test ``coordinax.represent_as(Cartesian3DVector)``.""" + """Test ``coordinax.represent_as(CartesianPosition3D)``.""" cart3d = vector.represent_as( - cx.Cartesian3DVector, z=Quantity([9, 10, 11, 12], "m") + cx.CartesianPosition3D, z=Quantity([9, 10, 11, 12], "m") ) - assert isinstance(cart3d, cx.Cartesian3DVector) + assert isinstance(cart3d, cx.CartesianPosition3D) assert qnp.array_equal(cart3d.x, Quantity([1, 2, 3, 4], "kpc")) assert qnp.array_equal(cart3d.y, Quantity([5, 6, 7, 8], "kpc")) assert qnp.array_equal(cart3d.z, Quantity([9, 10, 11, 12], "m")) def test_cartesian2d_to_spherical(self, vector): - """Test ``coordinax.represent_as(SphericalVector)``.""" + """Test ``coordinax.represent_as(SphericalPosition)``.""" spherical = vector.represent_as( - cx.SphericalVector, theta=Quantity([4, 5, 6, 7], "rad") + cx.SphericalPosition, theta=Quantity([4, 5, 6, 7], "rad") ) - assert isinstance(spherical, cx.SphericalVector) + assert isinstance(spherical, cx.SphericalPosition) assert qnp.array_equal(spherical.r, qnp.hypot(vector.x, vector.y)) assert qnp.allclose( spherical.phi, @@ -99,12 +99,12 @@ def test_cartesian2d_to_spherical(self, vector): ) def test_cartesian2d_to_cylindrical(self, vector): - """Test ``coordinax.represent_as(CylindricalVector)``.""" + """Test ``coordinax.represent_as(CylindricalPosition)``.""" cylindrical = vector.represent_as( - cx.CylindricalVector, z=Quantity([9, 10, 11, 12], "m") + cx.CylindricalPosition, z=Quantity([9, 10, 11, 12], "m") ) - assert isinstance(cylindrical, cx.CylindricalVector) + assert isinstance(cylindrical, cx.CylindricalPosition) assert qnp.array_equal(cylindrical.rho, qnp.hypot(vector.x, vector.y)) assert qnp.array_equal( cylindrical.phi, @@ -113,13 +113,13 @@ def test_cartesian2d_to_cylindrical(self, vector): assert qnp.array_equal(cylindrical.z, Quantity([9, 10, 11, 12], "m")) -class TestPolarVector: - """Test :class:`coordinax.PolarVector`.""" +class TestPolarPosition: + """Test :class:`coordinax.PolarPosition`.""" @pytest.fixture(scope="class") def vector(self) -> cx.AbstractPosition: """Return a vector.""" - return cx.PolarVector( + return cx.PolarPosition( r=Quantity([1, 2, 3, 4], "kpc"), phi=Quantity([0, 1, 2, 3], "rad") ) @@ -128,10 +128,10 @@ def vector(self) -> cx.AbstractPosition: @pytest.mark.filterwarnings("ignore:Irreversible dimension change") def test_polar_to_cartesian1d(self, vector): - """Test ``coordinax.represent_as(Cartesian1DVector)``.""" - cart1d = vector.represent_as(cx.Cartesian1DVector) + """Test ``coordinax.represent_as(CartesianPosition1D)``.""" + cart1d = vector.represent_as(cx.CartesianPosition1D) - assert isinstance(cart1d, cx.Cartesian1DVector) + assert isinstance(cart1d, cx.CartesianPosition1D) assert qnp.allclose( cart1d.x, Quantity([1.0, 1.0806047, -1.2484405, -3.95997], "kpc"), @@ -141,19 +141,19 @@ def test_polar_to_cartesian1d(self, vector): @pytest.mark.filterwarnings("ignore:Irreversible dimension change") def test_polar_to_radial(self, vector): - """Test ``coordinax.represent_as(RadialVector)``.""" - radial = vector.represent_as(cx.RadialVector) + """Test ``coordinax.represent_as(RadialPosition)``.""" + radial = vector.represent_as(cx.RadialPosition) - assert isinstance(radial, cx.RadialVector) + assert isinstance(radial, cx.RadialPosition) assert qnp.array_equal(radial.r, Quantity([1, 2, 3, 4], "kpc")) def test_polar_to_cartesian2d(self, vector): - """Test ``coordinax.represent_as(Cartesian2DVector)``.""" + """Test ``coordinax.represent_as(CartesianPosition2D)``.""" cart2d = vector.represent_as( - cx.Cartesian2DVector, y=Quantity([5, 6, 7, 8], "km") + cx.CartesianPosition2D, y=Quantity([5, 6, 7, 8], "km") ) - assert isinstance(cart2d, cx.Cartesian2DVector) + assert isinstance(cart2d, cx.CartesianPosition2D) assert qnp.array_equal( cart2d.x, Quantity([1.0, 1.0806046, -1.2484405, -3.95997], "kpc") ) @@ -168,22 +168,22 @@ def test_polar_to_cartesian2d(self, vector): ) def test_polar_to_polar(self, vector): - """Test ``coordinax.represent_as(PolarVector)``.""" + """Test ``coordinax.represent_as(PolarPosition)``.""" # Jit can copy - newvec = vector.represent_as(cx.PolarVector) + newvec = vector.represent_as(cx.PolarPosition) assert newvec == vector # The normal `represent_as` method should return the same object - newvec = cx.represent_as(vector, cx.PolarVector) + newvec = cx.represent_as(vector, cx.PolarPosition) assert newvec is vector def test_polar_to_cartesian3d(self, vector): - """Test ``coordinax.represent_as(Cartesian3DVector)``.""" + """Test ``coordinax.represent_as(CartesianPosition3D)``.""" cart3d = vector.represent_as( - cx.Cartesian3DVector, z=Quantity([9, 10, 11, 12], "m") + cx.CartesianPosition3D, z=Quantity([9, 10, 11, 12], "m") ) - assert isinstance(cart3d, cx.Cartesian3DVector) + assert isinstance(cart3d, cx.CartesianPosition3D) assert qnp.array_equal( cart3d.x, Quantity([1.0, 1.0806046, -1.2484405, -3.95997], "kpc") ) @@ -193,47 +193,47 @@ def test_polar_to_cartesian3d(self, vector): assert qnp.array_equal(cart3d.z, Quantity([9, 10, 11, 12], "m")) def test_polar_to_spherical(self, vector): - """Test ``coordinax.represent_as(SphericalVector)``.""" + """Test ``coordinax.represent_as(SphericalPosition)``.""" spherical = vector.represent_as( - cx.SphericalVector, theta=Quantity([4, 5, 6, 7], "rad") + cx.SphericalPosition, theta=Quantity([4, 5, 6, 7], "rad") ) - assert isinstance(spherical, cx.SphericalVector) + assert isinstance(spherical, cx.SphericalPosition) assert qnp.array_equal(spherical.r, Quantity([1, 2, 3, 4], "kpc")) assert qnp.array_equal(spherical.theta, Quantity([4, 5, 6, 7], "rad")) assert qnp.array_equal(spherical.phi, Quantity([0, 1, 2, 3], "rad")) def test_polar_to_cylindrical(self, vector): - """Test ``coordinax.represent_as(CylindricalVector)``.""" + """Test ``coordinax.represent_as(CylindricalPosition)``.""" cylindrical = vector.represent_as( - cx.CylindricalVector, z=Quantity([9, 10, 11, 12], "m") + cx.CylindricalPosition, z=Quantity([9, 10, 11, 12], "m") ) - assert isinstance(cylindrical, cx.CylindricalVector) + assert isinstance(cylindrical, cx.CylindricalPosition) assert qnp.array_equal(cylindrical.rho, Quantity([1, 2, 3, 4], "kpc")) assert qnp.array_equal(cylindrical.phi, Quantity([0, 1, 2, 3], "rad")) assert qnp.array_equal(cylindrical.z, Quantity([9, 10, 11, 12], "m")) -class Abstract2DVectorDifferentialTest(AbstractVelocityTest): - """Test :class:`coordinax.Abstract2DVectorDifferential`.""" +class AbstractVelocity2DTest(AbstractVelocityTest): + """Test :class:`coordinax.AbstractVelocity2D`.""" -class TestCartesianDifferential2D(Abstract2DVectorDifferentialTest): - """Test :class:`coordinax.CartesianDifferential2D`.""" +class TestCartesianVelocity2D(AbstractVelocity2DTest): + """Test :class:`coordinax.CartesianVelocity2D`.""" @pytest.fixture(scope="class") - def difntl(self) -> cx.CartesianDifferential2D: + def difntl(self) -> cx.CartesianVelocity2D: """Return a differential.""" - return cx.CartesianDifferential2D( + return cx.CartesianVelocity2D( d_x=Quantity([1, 2, 3, 4], "km/s"), d_y=Quantity([5, 6, 7, 8], "km/s"), ) @pytest.fixture(scope="class") - def vector(self) -> cx.Cartesian2DVector: + def vector(self) -> cx.CartesianPosition2D: """Return a vector.""" - return cx.Cartesian2DVector( + return cx.CartesianPosition2D( x=Quantity([1, 2, 3, 4], "kpc"), y=Quantity([5, 6, 7, 8], "km") ) @@ -243,38 +243,38 @@ def vector(self) -> cx.Cartesian2DVector: @pytest.mark.xfail(reason="Not implemented") @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_cartesian2d_to_cartesian1d(self, difntl, vector): - """Test ``difntl.represent_as(CartesianDifferential1D, vector)``.""" - cart1d = difntl.represent_as(cx.CartesianDifferential1D, vector) + """Test ``difntl.represent_as(CartesianVelocity1D, vector)``.""" + cart1d = difntl.represent_as(cx.CartesianVelocity1D, vector) - assert isinstance(cart1d, cx.CartesianDifferential1D) + assert isinstance(cart1d, cx.CartesianVelocity1D) assert qnp.array_equal(cart1d.d_x, Quantity([1, 2, 3, 4], "km/s")) @pytest.mark.xfail(reason="Not implemented") @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_cartesian2d_to_radial(self, difntl, vector): - """Test ``difntl.represent_as(RadialDifferential, vector)``.""" - radial = difntl.represent_as(cx.RadialDifferential, vector) + """Test ``difntl.represent_as(RadialVelocity, vector)``.""" + radial = difntl.represent_as(cx.RadialVelocity, vector) - assert isinstance(radial, cx.RadialDifferential) + assert isinstance(radial, cx.RadialVelocity) assert qnp.array_equal(radial.d_r, Quantity([1, 2, 3, 4], "km/s")) @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_cartesian2d_to_cartesian2d(self, difntl, vector): - """Test ``difntl.represent_as(CartesianDifferential2D, vector)``.""" + """Test ``difntl.represent_as(CartesianVelocity2D, vector)``.""" # Jit can copy - newvec = difntl.represent_as(cx.CartesianDifferential2D, vector) + newvec = difntl.represent_as(cx.CartesianVelocity2D, vector) assert newvec == difntl # The normal `represent_as` method should return the same object - newvec = cx.represent_as(difntl, cx.CartesianDifferential2D, vector) + newvec = cx.represent_as(difntl, cx.CartesianVelocity2D, vector) assert newvec is difntl @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_cartesian2d_to_polar(self, difntl, vector): - """Test ``difntl.represent_as(PolarDifferential, vector)``.""" - polar = difntl.represent_as(cx.PolarDifferential, vector) + """Test ``difntl.represent_as(PolarVelocity, vector)``.""" + polar = difntl.represent_as(cx.PolarVelocity, vector) - assert isinstance(polar, cx.PolarDifferential) + assert isinstance(polar, cx.PolarVelocity) assert qnp.array_equal(polar.d_r, Quantity([1, 2, 3, 4], "km/s")) assert qnp.array_equal( polar.d_phi, @@ -284,12 +284,12 @@ def test_cartesian2d_to_polar(self, difntl, vector): @pytest.mark.xfail(reason="Not implemented") @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_cartesian2d_to_cartesian3d(self, difntl, vector): - """Test ``difntl.represent_as(CartesianDifferential3D, vector)``.""" + """Test ``difntl.represent_as(CartesianVelocity3D, vector)``.""" cart3d = difntl.represent_as( - cx.CartesianDifferential3D, vector, d_z=Quantity([9, 10, 11, 12], "m/s") + cx.CartesianVelocity3D, vector, d_z=Quantity([9, 10, 11, 12], "m/s") ) - assert isinstance(cart3d, cx.CartesianDifferential3D) + assert isinstance(cart3d, cx.CartesianVelocity3D) assert qnp.array_equal(cart3d.d_x, Quantity([1, 2, 3, 4], "km/s")) assert qnp.array_equal(cart3d.d_y, Quantity([5, 6, 7, 8], "km/s")) assert qnp.array_equal(cart3d.d_z, Quantity([9, 10, 11, 12], "m/s")) @@ -297,12 +297,12 @@ def test_cartesian2d_to_cartesian3d(self, difntl, vector): @pytest.mark.xfail(reason="Not implemented") @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_cartesian2d_to_spherical(self, difntl, vector): - """Test ``difntl.represent_as(SphericalDifferential, vector)``.""" + """Test ``difntl.represent_as(SphericalVelocity, vector)``.""" spherical = difntl.represent_as( - cx.SphericalDifferential, vector, d_theta=Quantity([4, 5, 6, 7], "rad") + cx.SphericalVelocity, vector, d_theta=Quantity([4, 5, 6, 7], "rad") ) - assert isinstance(spherical, cx.SphericalDifferential) + assert isinstance(spherical, cx.SphericalVelocity) assert qnp.array_equal(spherical.d_r, Quantity([1, 2, 3, 4], "km/s")) assert qnp.array_equal(spherical.d_theta, Quantity([4, 5, 6, 7], "rad")) assert qnp.array_equal(spherical.d_phi, Quantity([5, 6, 7, 8], "km/s")) @@ -310,32 +310,32 @@ def test_cartesian2d_to_spherical(self, difntl, vector): @pytest.mark.xfail(reason="Not implemented") @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_cartesian2d_to_cylindrical(self, difntl, vector): - """Test ``difntl.represent_as(CylindricalDifferential, vector)``.""" + """Test ``difntl.represent_as(CylindricalVelocity, vector)``.""" cylindrical = difntl.represent_as( - cx.CylindricalDifferential, vector, d_z=Quantity([9, 10, 11, 12], "m/s") + cx.CylindricalVelocity, vector, d_z=Quantity([9, 10, 11, 12], "m/s") ) - assert isinstance(cylindrical, cx.CylindricalDifferential) + assert isinstance(cylindrical, cx.CylindricalVelocity) assert qnp.array_equal(cylindrical.d_rho, Quantity([1, 2, 3, 4], "km/s")) assert qnp.array_equal(cylindrical.d_phi, Quantity([5, 6, 7, 8], "km/s")) assert qnp.array_equal(cylindrical.d_z, Quantity([9, 10, 11, 12], "m/s")) -class TestPolarDifferential(Abstract2DVectorDifferentialTest): - """Test :class:`coordinax.PolarDifferential`.""" +class TestPolarVelocity(AbstractVelocity2DTest): + """Test :class:`coordinax.PolarVelocity`.""" @pytest.fixture(scope="class") - def difntl(self) -> cx.PolarDifferential: + def difntl(self) -> cx.PolarVelocity: """Return a differential.""" - return cx.PolarDifferential( + return cx.PolarVelocity( d_r=Quantity([1, 2, 3, 4], "km/s"), d_phi=Quantity([5, 6, 7, 8], "mas/yr"), ) @pytest.fixture(scope="class") - def vector(self) -> cx.PolarVector: + def vector(self) -> cx.PolarPosition: """Return a vector.""" - return cx.PolarVector( + return cx.PolarPosition( r=Quantity([1, 2, 3, 4], "kpc"), phi=Quantity([0, 1, 2, 3], "rad") ) @@ -345,27 +345,27 @@ def vector(self) -> cx.PolarVector: @pytest.mark.xfail(reason="Not implemented") @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_polar_to_cartesian1d(self, difntl, vector): - """Test ``difntl.represent_as(CartesianDifferential1D, vector)``.""" - cart1d = difntl.represent_as(cx.CartesianDifferential1D, vector) + """Test ``difntl.represent_as(CartesianVelocity1D, vector)``.""" + cart1d = difntl.represent_as(cx.CartesianVelocity1D, vector) - assert isinstance(cart1d, cx.CartesianDifferential1D) + assert isinstance(cart1d, cx.CartesianVelocity1D) assert qnp.array_equal(cart1d.d_x, Quantity([1, 2, 3, 4], "km/s")) @pytest.mark.xfail(reason="Not implemented") @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_polar_to_radial(self, difntl, vector): - """Test ``difntl.represent_as(RadialDifferential, vector)``.""" - radial = difntl.represent_as(cx.RadialDifferential, vector) + """Test ``difntl.represent_as(RadialVelocity, vector)``.""" + radial = difntl.represent_as(cx.RadialVelocity, vector) - assert isinstance(radial, cx.RadialDifferential) + assert isinstance(radial, cx.RadialVelocity) assert qnp.array_equal(radial.d_r, Quantity([1, 2, 3, 4], "km/s")) @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_polar_to_cartesian2d(self, difntl, vector): - """Test ``difntl.represent_as(CartesianDifferential2D, vector)``.""" - cart2d = difntl.represent_as(cx.CartesianDifferential2D, vector) + """Test ``difntl.represent_as(CartesianVelocity2D, vector)``.""" + cart2d = difntl.represent_as(cx.CartesianVelocity2D, vector) - assert isinstance(cart2d, cx.CartesianDifferential2D) + assert isinstance(cart2d, cx.CartesianVelocity2D) assert qnp.array_equal( cart2d.d_x, Quantity([1.0, -46.787014, -91.76889, -25.367176], "km/s") ) @@ -376,24 +376,24 @@ def test_polar_to_cartesian2d(self, difntl, vector): @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_polar_to_polar(self, difntl, vector): - """Test ``difntl.represent_as(PolarDifferential, vector)``.""" + """Test ``difntl.represent_as(PolarVelocity, vector)``.""" # Jit can copy - newvec = difntl.represent_as(cx.PolarDifferential, vector) + newvec = difntl.represent_as(cx.PolarVelocity, vector) assert newvec == difntl # The normal `represent_as` method should return the same object - newvec = cx.represent_as(difntl, cx.PolarDifferential, vector) + newvec = cx.represent_as(difntl, cx.PolarVelocity, vector) assert newvec is difntl @pytest.mark.xfail(reason="Not implemented") @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_polar_to_cartesian3d(self, difntl, vector): - """Test ``difntl.represent_as(CartesianDifferential3D, vector)``.""" + """Test ``difntl.represent_as(CartesianVelocity3D, vector)``.""" cart3d = difntl.represent_as( - cx.CartesianDifferential3D, vector, d_z=Quantity([9, 10, 11, 12], "m/s") + cx.CartesianVelocity3D, vector, d_z=Quantity([9, 10, 11, 12], "m/s") ) - assert isinstance(cart3d, cx.CartesianDifferential3D) + assert isinstance(cart3d, cx.CartesianVelocity3D) assert qnp.array_equal(cart3d.d_x, Quantity([1, 2, 3, 4], "km/s")) assert qnp.array_equal(cart3d.d_y, Quantity([5, 6, 7, 8], "km/s")) assert qnp.array_equal(cart3d.d_z, Quantity([9, 10, 11, 12], "m/s")) @@ -401,12 +401,12 @@ def test_polar_to_cartesian3d(self, difntl, vector): @pytest.mark.xfail(reason="Not implemented") @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_polar_to_spherical(self, difntl, vector): - """Test ``difntl.represent_as(SphericalDifferential, vector)``.""" + """Test ``difntl.represent_as(SphericalVelocity, vector)``.""" spherical = difntl.represent_as( - cx.SphericalDifferential, vector, d_theta=Quantity([4, 5, 6, 7], "rad") + cx.SphericalVelocity, vector, d_theta=Quantity([4, 5, 6, 7], "rad") ) - assert isinstance(spherical, cx.SphericalDifferential) + assert isinstance(spherical, cx.SphericalVelocity) assert qnp.array_equal(spherical.d_r, Quantity([1, 2, 3, 4], "km/s")) assert qnp.array_equal(spherical.d_theta, Quantity([4, 5, 6, 7], "rad")) assert qnp.array_equal(spherical.d_phi, Quantity([5, 6, 7, 8], "km/s")) @@ -414,12 +414,12 @@ def test_polar_to_spherical(self, difntl, vector): @pytest.mark.xfail(reason="Not implemented") @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_polar_to_cylindrical(self, difntl, vector): - """Test ``difntl.represent_as(CylindricalDifferential, vector)``.""" + """Test ``difntl.represent_as(CylindricalVelocity, vector)``.""" cylindrical = difntl.represent_as( - cx.CylindricalDifferential, vector, d_z=Quantity([9, 10, 11, 12], "m/s") + cx.CylindricalVelocity, vector, d_z=Quantity([9, 10, 11, 12], "m/s") ) - assert isinstance(cylindrical, cx.CylindricalDifferential) + assert isinstance(cylindrical, cx.CylindricalVelocity) assert qnp.array_equal(cylindrical.d_rho, Quantity([1, 2, 3, 4], "km/s")) assert qnp.array_equal(cylindrical.d_phi, Quantity([5, 6, 7, 8], "km/s")) assert qnp.array_equal(cylindrical.d_z, Quantity([9, 10, 11, 12], "m/s")) diff --git a/tests/test_d3.py b/tests/test_d3.py index 199a4db..a42f3ba 100644 --- a/tests/test_d3.py +++ b/tests/test_d3.py @@ -15,8 +15,8 @@ from .test_base import AbstractPositionTest, AbstractVelocityTest -class Abstract3DVectorTest(AbstractPositionTest): - """Test :class:`coordinax.Abstract3DVector`.""" +class AbstractPosition3DTest(AbstractPositionTest): + """Test :class:`coordinax.AbstractPosition3D`.""" # ========================================================================== # Unary operations @@ -55,13 +55,13 @@ def test_neg_compare_apy( # ) -class TestCartesian3DVector(Abstract3DVectorTest): - """Test :class:`coordinax.Cartesian3DVector`.""" +class TestCartesianPosition3D(AbstractPosition3DTest): + """Test :class:`coordinax.CartesianPosition3D`.""" @pytest.fixture(scope="class") def vector(self) -> cx.AbstractPosition: """Return a vector.""" - return cx.Cartesian3DVector( + return cx.CartesianPosition3D( x=Quantity([1, 2, 3, 4], "kpc"), y=Quantity([5, 6, 7, 8], "kpc"), z=Quantity([9, 10, 11, 12], "kpc"), @@ -77,67 +77,67 @@ def apyvector(self, vector: cx.AbstractPosition) -> apyc.CartesianRepresentation @pytest.mark.filterwarnings("ignore:Irreversible dimension change") def test_cartesian3d_to_cartesian1d(self, vector): - """Test ``coordinax.represent_as(Cartesian1DVector)``.""" - cart1d = vector.represent_as(cx.Cartesian1DVector) + """Test ``coordinax.represent_as(CartesianPosition1D)``.""" + cart1d = vector.represent_as(cx.CartesianPosition1D) - assert isinstance(cart1d, cx.Cartesian1DVector) + assert isinstance(cart1d, cx.CartesianPosition1D) assert qnp.array_equal(cart1d.x, Quantity([1, 2, 3, 4], "kpc")) @pytest.mark.filterwarnings("ignore:Irreversible dimension change") def test_cartesian3d_to_radial(self, vector): - """Test ``coordinax.represent_as(RadialVector)``.""" - radial = vector.represent_as(cx.RadialVector) + """Test ``coordinax.represent_as(RadialPosition)``.""" + radial = vector.represent_as(cx.RadialPosition) - assert isinstance(radial, cx.RadialVector) + assert isinstance(radial, cx.RadialPosition) assert qnp.array_equal( radial.r, Quantity([10.34408, 11.83216, 13.379088, 14.96663], "kpc") ) @pytest.mark.filterwarnings("ignore:Irreversible dimension change") def test_cartesian3d_to_cartesian2d(self, vector): - """Test ``coordinax.represent_as(Cartesian2DVector)``.""" + """Test ``coordinax.represent_as(CartesianPosition2D)``.""" cart2d = vector.represent_as( - cx.Cartesian2DVector, y=Quantity([5, 6, 7, 8], "km") + cx.CartesianPosition2D, y=Quantity([5, 6, 7, 8], "km") ) - assert isinstance(cart2d, cx.Cartesian2DVector) + assert isinstance(cart2d, cx.CartesianPosition2D) assert qnp.array_equal(cart2d.x, Quantity([1, 2, 3, 4], "kpc")) assert qnp.array_equal(cart2d.y, Quantity([5, 6, 7, 8], "kpc")) @pytest.mark.filterwarnings("ignore:Irreversible dimension change") def test_cartesian3d_to_polar(self, vector): - """Test ``coordinax.represent_as(PolarVector)``.""" - polar = vector.represent_as(cx.PolarVector, phi=Quantity([0, 1, 2, 3], "rad")) + """Test ``coordinax.represent_as(PolarPosition)``.""" + polar = vector.represent_as(cx.PolarPosition, phi=Quantity([0, 1, 2, 3], "rad")) - assert isinstance(polar, cx.PolarVector) + assert isinstance(polar, cx.PolarPosition) assert qnp.array_equal(polar.r, qnp.hypot(vector.x, vector.y)) assert qnp.array_equal( polar.phi, Quantity([1.3734008, 1.2490457, 1.1659045, 1.1071488], "rad") ) def test_cartesian3d_to_cartesian3d(self, vector): - """Test ``coordinax.represent_as(Cartesian3DVector)``.""" + """Test ``coordinax.represent_as(CartesianPosition3D)``.""" # Jit can copy - newvec = vector.represent_as(cx.Cartesian3DVector) + newvec = vector.represent_as(cx.CartesianPosition3D) assert newvec == vector # The normal `represent_as` method should return the same object - newvec = cx.represent_as(vector, cx.Cartesian3DVector) + newvec = cx.represent_as(vector, cx.CartesianPosition3D) assert newvec is vector def test_cartesian3d_to_cartesian3d_astropy(self, vector, apyvector): """Test Astropy equivalence.""" - newvec = vector.represent_as(cx.Cartesian3DVector) + newvec = vector.represent_as(cx.CartesianPosition3D) assert np.allclose(convert(newvec.x, APYQuantity), apyvector.x) assert np.allclose(convert(newvec.y, APYQuantity), apyvector.y) assert np.allclose(convert(newvec.z, APYQuantity), apyvector.z) def test_cartesian3d_to_spherical(self, vector): - """Test ``coordinax.represent_as(SphericalVector)``.""" - spherical = vector.represent_as(cx.SphericalVector) + """Test ``coordinax.represent_as(SphericalPosition)``.""" + spherical = vector.represent_as(cx.SphericalPosition) - assert isinstance(spherical, cx.SphericalVector) + assert isinstance(spherical, cx.SphericalPosition) assert qnp.array_equal( spherical.r, Quantity([10.34408, 11.83216, 13.379088, 14.96663], "kpc") ) @@ -152,7 +152,7 @@ def test_cartesian3d_to_spherical(self, vector): def test_cartesian3d_to_spherical_astropy(self, vector, apyvector): """Test Astropy equivalence.""" - sph = vector.represent_as(cx.SphericalVector) + sph = vector.represent_as(cx.SphericalPosition) apysph = apyvector.represent_as(apyc.PhysicsSphericalRepresentation) assert np.allclose(convert(sph.r, APYQuantity), apysph.r) @@ -160,10 +160,10 @@ def test_cartesian3d_to_spherical_astropy(self, vector, apyvector): assert np.allclose(convert(sph.phi, APYQuantity), apysph.phi) def test_cartesian3d_to_cylindrical(self, vector): - """Test ``coordinax.represent_as(CylindricalVector)``.""" - cylindrical = vector.represent_as(cx.CylindricalVector) + """Test ``coordinax.represent_as(CylindricalPosition)``.""" + cylindrical = vector.represent_as(cx.CylindricalPosition) - assert isinstance(cylindrical, cx.CylindricalVector) + assert isinstance(cylindrical, cx.CylindricalPosition) assert qnp.array_equal(cylindrical.rho, qnp.hypot(vector.x, vector.y)) assert qnp.array_equal( cylindrical.phi, @@ -173,7 +173,7 @@ def test_cartesian3d_to_cylindrical(self, vector): def test_cartesian3d_to_cylindrical_astropy(self, vector, apyvector): """Test Astropy equivalence.""" - cyl = vector.represent_as(cx.CylindricalVector) + cyl = vector.represent_as(cx.CylindricalPosition) apycyl = apyvector.represent_as(apyc.CylindricalRepresentation) assert np.allclose(convert(cyl.rho, APYQuantity), apycyl.rho) @@ -181,13 +181,13 @@ def test_cartesian3d_to_cylindrical_astropy(self, vector, apyvector): assert np.allclose(convert(cyl.z, APYQuantity), apycyl.z) -class TestCylindricalVector(Abstract3DVectorTest): - """Test :class:`coordinax.CylindricalVector`.""" +class TestCylindricalPosition(AbstractPosition3DTest): + """Test :class:`coordinax.CylindricalPosition`.""" @pytest.fixture(scope="class") def vector(self) -> cx.AbstractPosition: """Return a vector.""" - return cx.CylindricalVector( + return cx.CylindricalPosition( rho=Quantity([1, 2, 3, 4], "kpc"), phi=Quantity([0, 1, 2, 3], "rad"), z=Quantity([9, 10, 11, 12], "m"), @@ -203,10 +203,10 @@ def apyvector(self, vector: cx.AbstractPosition): @pytest.mark.filterwarnings("ignore:Irreversible dimension change") def test_cylindrical_to_cartesian1d(self, vector): - """Test ``coordinax.represent_as(Cartesian1DVector)``.""" - cart1d = vector.represent_as(cx.Cartesian1DVector) + """Test ``coordinax.represent_as(CartesianPosition1D)``.""" + cart1d = vector.represent_as(cx.CartesianPosition1D) - assert isinstance(cart1d, cx.Cartesian1DVector) + assert isinstance(cart1d, cx.CartesianPosition1D) assert qnp.allclose( cart1d.x, Quantity([1.0, 1.0806047, -1.2484405, -3.95997], "kpc"), @@ -215,18 +215,18 @@ def test_cylindrical_to_cartesian1d(self, vector): @pytest.mark.filterwarnings("ignore:Irreversible dimension change") def test_cylindrical_to_radial(self, vector): - """Test ``coordinax.represent_as(RadialVector)``.""" - radial = vector.represent_as(cx.RadialVector) + """Test ``coordinax.represent_as(RadialPosition)``.""" + radial = vector.represent_as(cx.RadialPosition) - assert isinstance(radial, cx.RadialVector) + assert isinstance(radial, cx.RadialPosition) assert qnp.array_equal(radial.r, Quantity([1, 2, 3, 4], "kpc")) @pytest.mark.filterwarnings("ignore:Irreversible dimension change") def test_cylindrical_to_cartesian2d(self, vector): - """Test ``coordinax.represent_as(Cartesian2DVector)``.""" - cart2d = vector.represent_as(cx.Cartesian2DVector) + """Test ``coordinax.represent_as(CartesianPosition2D)``.""" + cart2d = vector.represent_as(cx.CartesianPosition2D) - assert isinstance(cart2d, cx.Cartesian2DVector) + assert isinstance(cart2d, cx.CartesianPosition2D) assert qnp.array_equal( cart2d.x, Quantity([1.0, 1.0806046, -1.2484405, -3.95997], "kpc") ) @@ -236,18 +236,18 @@ def test_cylindrical_to_cartesian2d(self, vector): @pytest.mark.filterwarnings("ignore:Irreversible dimension change") def test_cylindrical_to_polar(self, vector): - """Test ``coordinax.represent_as(PolarVector)``.""" - polar = vector.represent_as(cx.PolarVector) + """Test ``coordinax.represent_as(PolarPosition)``.""" + polar = vector.represent_as(cx.PolarPosition) - assert isinstance(polar, cx.PolarVector) + assert isinstance(polar, cx.PolarPosition) assert qnp.array_equal(polar.r, Quantity([1, 2, 3, 4], "kpc")) assert qnp.array_equal(polar.phi, Quantity([0, 1, 2, 3], "rad")) def test_cylindrical_to_cartesian3d(self, vector): - """Test ``coordinax.represent_as(Cartesian3DVector)``.""" - cart3d = vector.represent_as(cx.Cartesian3DVector) + """Test ``coordinax.represent_as(CartesianPosition3D)``.""" + cart3d = vector.represent_as(cx.CartesianPosition3D) - assert isinstance(cart3d, cx.Cartesian3DVector) + assert isinstance(cart3d, cx.CartesianPosition3D) assert qnp.array_equal( cart3d.x, Quantity([1.0, 1.0806046, -1.2484405, -3.95997], "kpc") ) @@ -258,7 +258,7 @@ def test_cylindrical_to_cartesian3d(self, vector): def test_cylindrical_to_cartesian3d_astropy(self, vector, apyvector): """Test Astropy equivalence.""" - cart3d = vector.represent_as(cx.Cartesian3DVector) + cart3d = vector.represent_as(cx.CartesianPosition3D) apycart3 = apyvector.represent_as(apyc.CartesianRepresentation) assert np.allclose(convert(cart3d.x, APYQuantity), apycart3.x) @@ -266,35 +266,35 @@ def test_cylindrical_to_cartesian3d_astropy(self, vector, apyvector): assert np.allclose(convert(cart3d.z, APYQuantity), apycart3.z) def test_cylindrical_to_spherical(self, vector): - """Test ``coordinax.represent_as(SphericalVector)``.""" - spherical = vector.represent_as(cx.SphericalVector) + """Test ``coordinax.represent_as(SphericalPosition)``.""" + spherical = vector.represent_as(cx.SphericalPosition) - assert isinstance(spherical, cx.SphericalVector) + assert isinstance(spherical, cx.SphericalPosition) assert qnp.array_equal(spherical.r, Quantity([1, 2, 3, 4], "kpc")) assert qnp.array_equal(spherical.theta, Quantity(xp.full(4, xp.pi / 2), "rad")) assert qnp.array_equal(spherical.phi, Quantity([0, 1, 2, 3], "rad")) def test_cylindrical_to_spherical_astropy(self, vector, apyvector): """Test Astropy equivalence.""" - sph = vector.represent_as(cx.SphericalVector) + sph = vector.represent_as(cx.SphericalPosition) apysph = apyvector.represent_as(apyc.PhysicsSphericalRepresentation) assert np.allclose(convert(sph.r, APYQuantity), apysph.r) assert np.allclose(convert(sph.theta, APYQuantity), apysph.theta) assert np.allclose(convert(sph.phi, APYQuantity), apysph.phi) def test_cylindrical_to_cylindrical(self, vector): - """Test ``coordinax.represent_as(CylindricalVector)``.""" + """Test ``coordinax.represent_as(CylindricalPosition)``.""" # Jit can copy - newvec = vector.represent_as(cx.CylindricalVector) + newvec = vector.represent_as(cx.CylindricalPosition) assert newvec == vector # The normal `represent_as` method should return the same object - newvec = cx.represent_as(vector, cx.CylindricalVector) + newvec = cx.represent_as(vector, cx.CylindricalPosition) assert newvec is vector def test_cylindrical_to_cylindrical_astropy(self, vector, apyvector): """Test Astropy equivalence.""" - cyl = vector.represent_as(cx.CylindricalVector) + cyl = vector.represent_as(cx.CylindricalPosition) apycyl = apyvector.represent_as(apyc.CylindricalRepresentation) assert np.allclose(convert(cyl.rho, APYQuantity), apycyl.rho) @@ -302,13 +302,13 @@ def test_cylindrical_to_cylindrical_astropy(self, vector, apyvector): assert np.allclose(convert(cyl.z, APYQuantity), apycyl.z) -class TestSphericalVector(Abstract3DVectorTest): - """Test :class:`coordinax.SphericalVector`.""" +class TestSphericalPosition(AbstractPosition3DTest): + """Test :class:`coordinax.SphericalPosition`.""" @pytest.fixture(scope="class") - def vector(self) -> cx.SphericalVector: + def vector(self) -> cx.SphericalPosition: """Return a vector.""" - return cx.SphericalVector( + return cx.SphericalPosition( r=Quantity([1, 2, 3, 4], "kpc"), theta=Quantity([0, 36, 142, 180], "deg"), phi=Quantity([0, 65, 135, 270], "deg"), @@ -324,10 +324,10 @@ def apyvector(self, vector: cx.AbstractPosition): @pytest.mark.filterwarnings("ignore:Irreversible dimension change") def test_spherical_to_cartesian1d(self, vector): - """Test ``coordinax.represent_as(Cartesian1DVector)``.""" - cart1d = vector.represent_as(cx.Cartesian1DVector) + """Test ``coordinax.represent_as(CartesianPosition1D)``.""" + cart1d = vector.represent_as(cx.CartesianPosition1D) - assert isinstance(cart1d, cx.Cartesian1DVector) + assert isinstance(cart1d, cx.CartesianPosition1D) assert qnp.allclose( cart1d.x, Quantity([0, 0.49681753, -1.3060151, -4.1700245e-15], "kpc"), @@ -336,20 +336,20 @@ def test_spherical_to_cartesian1d(self, vector): @pytest.mark.filterwarnings("ignore:Irreversible dimension change") def test_spherical_to_radial(self, vector): - """Test ``coordinax.represent_as(RadialVector)``.""" - radial = vector.represent_as(cx.RadialVector) + """Test ``coordinax.represent_as(RadialPosition)``.""" + radial = vector.represent_as(cx.RadialPosition) - assert isinstance(radial, cx.RadialVector) + assert isinstance(radial, cx.RadialPosition) assert qnp.array_equal(radial.r, Quantity([1, 2, 3, 4], "kpc")) @pytest.mark.filterwarnings("ignore:Irreversible dimension change") def test_spherical_to_cartesian2d(self, vector): - """Test ``coordinax.represent_as(Cartesian2DVector)``.""" + """Test ``coordinax.represent_as(CartesianPosition2D)``.""" cart2d = vector.represent_as( - cx.Cartesian2DVector, y=Quantity([5, 6, 7, 8], "km") + cx.CartesianPosition2D, y=Quantity([5, 6, 7, 8], "km") ) - assert isinstance(cart2d, cx.Cartesian2DVector) + assert isinstance(cart2d, cx.CartesianPosition2D) assert qnp.array_equal( cart2d.x, Quantity([0, 0.49681753, -1.3060151, -4.1700245e-15], "kpc"), @@ -360,10 +360,10 @@ def test_spherical_to_cartesian2d(self, vector): @pytest.mark.filterwarnings("ignore:Irreversible dimension change") def test_spherical_to_polar(self, vector): - """Test ``coordinax.represent_as(PolarVector)``.""" - polar = vector.represent_as(cx.PolarVector, phi=Quantity([0, 1, 2, 3], "rad")) + """Test ``coordinax.represent_as(PolarPosition)``.""" + polar = vector.represent_as(cx.PolarPosition, phi=Quantity([0, 1, 2, 3], "rad")) - assert isinstance(polar, cx.PolarVector) + assert isinstance(polar, cx.PolarPosition) assert qnp.array_equal( polar.r, Quantity([0.0, 1.1755705, 1.8469844, -3.4969111e-07], "kpc"), @@ -371,10 +371,10 @@ def test_spherical_to_polar(self, vector): assert qnp.array_equal(polar.phi, Quantity([0.0, 65.0, 135.0, 270.0], "deg")) def test_spherical_to_cartesian3d(self, vector): - """Test ``coordinax.represent_as(Cartesian3DVector)``.""" - cart3d = vector.represent_as(cx.Cartesian3DVector) + """Test ``coordinax.represent_as(CartesianPosition3D)``.""" + cart3d = vector.represent_as(cx.CartesianPosition3D) - assert isinstance(cart3d, cx.Cartesian3DVector) + assert isinstance(cart3d, cx.CartesianPosition3D) assert qnp.array_equal( cart3d.x, Quantity([0, 0.49681753, -1.3060151, -4.1700245e-15], "kpc") ) @@ -387,7 +387,7 @@ def test_spherical_to_cartesian3d(self, vector): def test_spherical_to_cartesian3d_astropy(self, vector, apyvector): """Test Astropy equivalence.""" - cart3d = vector.represent_as(cx.Cartesian3DVector) + cart3d = vector.represent_as(cx.CartesianPosition3D) apycart3 = apyvector.represent_as(apyc.CartesianRepresentation) assert np.allclose(convert(cart3d.x, APYQuantity), apycart3.x) @@ -395,12 +395,12 @@ def test_spherical_to_cartesian3d_astropy(self, vector, apyvector): assert np.allclose(convert(cart3d.z, APYQuantity), apycart3.z) def test_spherical_to_cylindrical(self, vector): - """Test ``coordinax.represent_as(CylindricalVector)``.""" + """Test ``coordinax.represent_as(CylindricalPosition)``.""" cyl = vector.represent_as( - cx.CylindricalVector, z=Quantity([9, 10, 11, 12], "m") + cx.CylindricalPosition, z=Quantity([9, 10, 11, 12], "m") ) - assert isinstance(cyl, cx.CylindricalVector) + assert isinstance(cyl, cx.CylindricalPosition) assert qnp.array_equal( cyl.rho, Quantity([0.0, 1.1755705, 1.8469844, 3.4969111e-07], "kpc"), @@ -411,9 +411,9 @@ def test_spherical_to_cylindrical(self, vector): ) def test_spherical_to_cylindrical_astropy(self, vector, apyvector): - """Test ``coordinax.represent_as(CylindricalVector)``.""" + """Test ``coordinax.represent_as(CylindricalPosition)``.""" cyl = vector.represent_as( - cx.CylindricalVector, z=Quantity([9, 10, 11, 12], "m") + cx.CylindricalPosition, z=Quantity([9, 10, 11, 12], "m") ) apycyl = apyvector.represent_as(apyc.CylindricalRepresentation) @@ -426,18 +426,18 @@ def test_spherical_to_cylindrical_astropy(self, vector, apyvector): assert np.allclose(convert(cyl.phi, APYQuantity), apycyl.phi) def test_spherical_to_spherical(self, vector): - """Test ``coordinax.represent_as(SphericalVector)``.""" + """Test ``coordinax.represent_as(SphericalPosition)``.""" # Jit can copy - newvec = vector.represent_as(cx.SphericalVector) + newvec = vector.represent_as(cx.SphericalPosition) assert newvec == vector # The normal `represent_as` method should return the same object - newvec = cx.represent_as(vector, cx.SphericalVector) + newvec = cx.represent_as(vector, cx.SphericalPosition) assert newvec is vector def test_spherical_to_spherical_astropy(self, vector, apyvector): """Test Astropy equivalence.""" - sph = vector.represent_as(cx.SphericalVector) + sph = vector.represent_as(cx.SphericalPosition) apysph = apyvector.represent_as(apyc.PhysicsSphericalRepresentation) assert np.allclose(convert(sph.r, APYQuantity), apysph.r) @@ -445,26 +445,26 @@ def test_spherical_to_spherical_astropy(self, vector, apyvector): assert np.allclose(convert(sph.phi, APYQuantity), apysph.phi) def test_spherical_to_mathspherical(self, vector): - """Test ``coordinax.represent_as(MathSphericalVector)``.""" - newvec = cx.represent_as(vector, cx.MathSphericalVector) + """Test ``coordinax.represent_as(MathSphericalPosition)``.""" + newvec = cx.represent_as(vector, cx.MathSphericalPosition) assert qnp.array_equal(newvec.r, vector.r) assert qnp.array_equal(newvec.theta, vector.phi) assert qnp.array_equal(newvec.phi, vector.theta) def test_spherical_to_lonlatspherical(self, vector): - """Test ``coordinax.represent_as(LonLatSphericalVector)``.""" + """Test ``coordinax.represent_as(LonLatSphericalPosition)``.""" llsph = vector.represent_as( - cx.LonLatSphericalVector, z=Quantity([9, 10, 11, 12], "m") + cx.LonLatSphericalPosition, z=Quantity([9, 10, 11, 12], "m") ) - assert isinstance(llsph, cx.LonLatSphericalVector) + assert isinstance(llsph, cx.LonLatSphericalPosition) assert qnp.array_equal(llsph.lon, vector.phi) assert qnp.array_equal(llsph.lat, Quantity(90, "deg") - vector.theta) assert qnp.array_equal(llsph.distance, vector.r) def test_spherical_to_lonlatspherical_astropy(self, vector, apyvector): """Test Astropy equivalence.""" - llsph = vector.represent_as(cx.LonLatSphericalVector) + llsph = vector.represent_as(cx.LonLatSphericalPosition) apycart3 = apyvector.represent_as(apyc.SphericalRepresentation) assert np.allclose(convert(llsph.distance, APYQuantity), apycart3.distance) @@ -472,8 +472,8 @@ def test_spherical_to_lonlatspherical_astropy(self, vector, apyvector): assert np.allclose(convert(llsph.lat, APYQuantity), apycart3.lat) -class Abstract3DVectorDifferentialTest(AbstractVelocityTest): - """Test :class:`coordinax.Abstract2DVectorDifferential`.""" +class AbstractVelocity3DTest(AbstractVelocityTest): + """Test :class:`coordinax.AbstractVelocity2D`.""" # ========================================================================== # Unary operations @@ -485,34 +485,34 @@ def test_neg_compare_apy( assert all(representation_equal(convert(-difntl, type(apydifntl)), -apydifntl)) -class TestCartesianDifferential3D(Abstract3DVectorDifferentialTest): - """Test :class:`coordinax.CartesianDifferential3D`.""" +class TestCartesianVelocity3D(AbstractVelocity3DTest): + """Test :class:`coordinax.CartesianVelocity3D`.""" @pytest.fixture(scope="class") - def difntl(self) -> cx.CartesianDifferential3D: + def difntl(self) -> cx.CartesianVelocity3D: """Return a differential.""" - return cx.CartesianDifferential3D( + return cx.CartesianVelocity3D( d_x=Quantity([5, 6, 7, 8], "km/s"), d_y=Quantity([9, 10, 11, 12], "km/s"), d_z=Quantity([13, 14, 15, 16], "km/s"), ) @pytest.fixture(scope="class") - def vector(self) -> cx.Cartesian3DVector: + def vector(self) -> cx.CartesianPosition3D: """Return a vector.""" - return cx.Cartesian3DVector( + return cx.CartesianPosition3D( x=Quantity([1, 2, 3, 4], "kpc"), y=Quantity([5, 6, 7, 8], "kpc"), z=Quantity([9, 10, 11, 12], "kpc"), ) @pytest.fixture(scope="class") - def apydifntl(self, difntl: cx.CartesianDifferential3D): + def apydifntl(self, difntl: cx.CartesianVelocity3D): """Return an Astropy differential.""" return convert(difntl, apyc.CartesianDifferential) @pytest.fixture(scope="class") - def apyvector(self, vector: cx.Cartesian3DVector): + def apyvector(self, vector: cx.CartesianPosition3D): """Return an Astropy vector.""" return convert(vector, apyc.CartesianRepresentation) @@ -521,56 +521,56 @@ def apyvector(self, vector: cx.Cartesian3DVector): @pytest.mark.xfail(reason="Not implemented") @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_cartesian3d_to_cartesian1d(self, difntl, vector): - """Test ``coordinax.represent_as(Cartesian1DVector)``.""" - cart1d = difntl.represent_as(cx.CartesianDifferential1D, vector) + """Test ``coordinax.represent_as(CartesianPosition1D)``.""" + cart1d = difntl.represent_as(cx.CartesianVelocity1D, vector) - assert isinstance(cart1d, cx.CartesianDifferential1D) + assert isinstance(cart1d, cx.CartesianVelocity1D) assert qnp.array_equal(cart1d.d_x, Quantity([1, 2, 3, 4], "km/s")) @pytest.mark.xfail(reason="Not implemented") @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_cartesian3d_to_radial(self, difntl, vector): - """Test ``coordinax.represent_as(RadialVector)``.""" - radial = difntl.represent_as(cx.RadialVector, vector) + """Test ``coordinax.represent_as(RadialPosition)``.""" + radial = difntl.represent_as(cx.RadialPosition, vector) - assert isinstance(radial, cx.RadialVector) + assert isinstance(radial, cx.RadialPosition) assert qnp.array_equal(radial.d_r, Quantity([1, 2, 3, 4], "km/s")) @pytest.mark.xfail(reason="Not implemented") @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_cartesian3d_to_cartesian2d(self, difntl, vector): - """Test ``coordinax.represent_as(Cartesian2DVector)``.""" - cart2d = difntl.represent_as(cx.CartesianDifferential2D, vector) + """Test ``coordinax.represent_as(CartesianPosition2D)``.""" + cart2d = difntl.represent_as(cx.CartesianVelocity2D, vector) - assert isinstance(cart2d, cx.CartesianDifferential2D) + assert isinstance(cart2d, cx.CartesianVelocity2D) assert qnp.array_equal(cart2d.d_x, Quantity([1, 2, 3, 4], "km/s")) assert qnp.array_equal(cart2d.d_y, Quantity([5, 6, 7, 8], "km/s")) @pytest.mark.xfail(reason="Not implemented") @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_cartesian3d_to_polar(self, difntl, vector): - """Test ``coordinax.represent_as(PolarVector)``.""" - polar = difntl.represent_as(cx.PolarVector, vector) + """Test ``coordinax.represent_as(PolarPosition)``.""" + polar = difntl.represent_as(cx.PolarPosition, vector) - assert isinstance(polar, cx.PolarVector) + assert isinstance(polar, cx.PolarPosition) assert qnp.array_equal(polar.d_r, Quantity([1, 2, 3, 4], "km/s")) assert qnp.array_equal(polar.d_phi, Quantity([5, 6, 7, 8], "mas/yr")) def test_cartesian3d_to_cartesian3d(self, difntl, vector): - """Test ``coordinax.represent_as(Cartesian3DVector)``.""" + """Test ``coordinax.represent_as(CartesianPosition3D)``.""" # Jit can copy - newvec = difntl.represent_as(cx.CartesianDifferential3D, vector) + newvec = difntl.represent_as(cx.CartesianVelocity3D, vector) assert newvec == difntl # The normal `represent_as` method should return the same object - newvec = cx.represent_as(difntl, cx.CartesianDifferential3D, vector) + newvec = cx.represent_as(difntl, cx.CartesianVelocity3D, vector) assert newvec is difntl def test_cartesian3d_to_cartesian3d_astropy( self, difntl, vector, apydifntl, apyvector ): """Test Astropy equivalence.""" - cart3 = difntl.represent_as(cx.CartesianDifferential3D, vector) + cart3 = difntl.represent_as(cx.CartesianVelocity3D, vector) apycart3 = apydifntl.represent_as(apyc.CartesianDifferential, apyvector) assert np.allclose(convert(cart3.d_x, APYQuantity), apycart3.d_x) @@ -578,10 +578,10 @@ def test_cartesian3d_to_cartesian3d_astropy( assert np.allclose(convert(cart3.d_z, APYQuantity), apycart3.d_z) def test_cartesian3d_to_spherical(self, difntl, vector): - """Test ``coordinax.represent_as(SphericalDifferential)``.""" - spherical = difntl.represent_as(cx.SphericalDifferential, vector) + """Test ``coordinax.represent_as(SphericalVelocity)``.""" + spherical = difntl.represent_as(cx.SphericalVelocity, vector) - assert isinstance(spherical, cx.SphericalDifferential) + assert isinstance(spherical, cx.SphericalVelocity) assert qnp.allclose( spherical.d_r, Quantity([16.1445, 17.917269, 19.657543, 21.380898], "km/s"), @@ -606,7 +606,7 @@ def test_cartesian3d_to_spherical_astropy( self, difntl, vector, apydifntl, apyvector ): """Test Astropy equivalence.""" - sph = difntl.represent_as(cx.SphericalDifferential, vector) + sph = difntl.represent_as(cx.SphericalVelocity, vector) apysph = apydifntl.represent_as(apyc.PhysicsSphericalDifferential, apyvector) assert np.allclose(convert(sph.d_r, APYQuantity), apysph.d_r) @@ -614,10 +614,10 @@ def test_cartesian3d_to_spherical_astropy( assert np.allclose(convert(sph.d_phi, APYQuantity), apysph.d_phi, atol=1e-7) def test_cartesian3d_to_cylindrical(self, difntl, vector): - """Test ``coordinax.represent_as(CylindricalDifferential)``.""" - cylindrical = difntl.represent_as(cx.CylindricalDifferential, vector) + """Test ``coordinax.represent_as(CylindricalVelocity)``.""" + cylindrical = difntl.represent_as(cx.CylindricalVelocity, vector) - assert isinstance(cylindrical, cx.CylindricalDifferential) + assert isinstance(cylindrical, cx.CylindricalVelocity) assert qnp.array_equal( cylindrical.d_rho, Quantity([9.805807, 11.384199, 12.86803, 14.310835], "km/s"), @@ -637,41 +637,43 @@ def test_cartesian3d_to_cylindrical_astropy( self, difntl, vector, apydifntl, apyvector ): """Test Astropy equivalence.""" - cyl = difntl.represent_as(cx.CylindricalDifferential, vector) + cyl = difntl.represent_as(cx.CylindricalVelocity, vector) apycyl = apydifntl.represent_as(apyc.CylindricalDifferential, apyvector) assert np.allclose(convert(cyl.d_rho, APYQuantity), apycyl.d_rho) assert np.allclose(convert(cyl.d_phi, APYQuantity), apycyl.d_phi) assert np.allclose(convert(cyl.d_z, APYQuantity), apycyl.d_z) -class TestCylindricalDifferential(Abstract3DVectorDifferentialTest): - """Test :class:`coordinax.CylindricalDifferential`.""" +class TestCylindricalVelocity(AbstractVelocity3DTest): + """Test :class:`coordinax.CylindricalVelocity`.""" @pytest.fixture(scope="class") - def difntl(self) -> cx.CylindricalDifferential: + def difntl(self) -> cx.CylindricalVelocity: """Return a differential.""" - return cx.CylindricalDifferential( + return cx.CylindricalVelocity( d_rho=Quantity([5, 6, 7, 8], "km/s"), d_phi=Quantity([9, 10, 11, 12], "mas/yr"), d_z=Quantity([13, 14, 15, 16], "km/s"), ) @pytest.fixture(scope="class") - def vector(self) -> cx.CylindricalVector: + def vector(self) -> cx.CylindricalPosition: """Return a vector.""" - return cx.CylindricalVector( + return cx.CylindricalPosition( rho=Quantity([1, 2, 3, 4], "kpc"), phi=Quantity([0, 1, 2, 3], "rad"), z=Quantity([9, 10, 11, 12], "kpc"), ) @pytest.fixture(scope="class") - def apydifntl(self, difntl: cx.CylindricalDifferential): + def apydifntl(self, difntl: cx.CylindricalVelocity): """Return an Astropy differential.""" return convert(difntl, apyc.CylindricalDifferential) @pytest.fixture(scope="class") - def apyvector(self, vector: cx.CylindricalVector) -> apyc.CylindricalRepresentation: + def apyvector( + self, vector: cx.CylindricalPosition + ) -> apyc.CylindricalRepresentation: """Return an Astropy vector.""" return convert(vector, apyc.CylindricalRepresentation) @@ -680,46 +682,46 @@ def apyvector(self, vector: cx.CylindricalVector) -> apyc.CylindricalRepresentat @pytest.mark.xfail(reason="Not implemented") @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_cylindrical_to_cartesian1d(self, difntl, vector): - """Test ``coordinax.represent_as(Cartesian1DVector)``.""" - cart1d = difntl.represent_as(cx.CartesianDifferential1D, vector) + """Test ``coordinax.represent_as(CartesianPosition1D)``.""" + cart1d = difntl.represent_as(cx.CartesianVelocity1D, vector) - assert isinstance(cart1d, cx.CartesianDifferential1D) + assert isinstance(cart1d, cx.CartesianVelocity1D) assert qnp.array_equal(cart1d.d_x, Quantity([1, 2, 3, 4], "km/s")) @pytest.mark.xfail(reason="Not implemented") @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_cylindrical_to_radial(self, difntl, vector): - """Test ``coordinax.represent_as(RadialVector)``.""" - radial = difntl.represent_as(cx.RadialVector, vector) + """Test ``coordinax.represent_as(RadialPosition)``.""" + radial = difntl.represent_as(cx.RadialPosition, vector) - assert isinstance(radial, cx.RadialVector) + assert isinstance(radial, cx.RadialPosition) assert qnp.array_equal(radial.d_r, Quantity([1, 2, 3, 4], "km/s")) @pytest.mark.xfail(reason="Not implemented") @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_cylindrical_to_cartesian2d(self, difntl, vector): - """Test ``coordinax.represent_as(Cartesian2DVector)``.""" - cart2d = difntl.represent_as(cx.CartesianDifferential2D, vector) + """Test ``coordinax.represent_as(CartesianPosition2D)``.""" + cart2d = difntl.represent_as(cx.CartesianVelocity2D, vector) - assert isinstance(cart2d, cx.CartesianDifferential2D) + assert isinstance(cart2d, cx.CartesianVelocity2D) assert qnp.array_equal(cart2d.d_x, Quantity([1, 2, 3, 4], "km/s")) assert qnp.array_equal(cart2d.d_y, Quantity([5, 6, 7, 8], "km/s")) @pytest.mark.xfail(reason="Not implemented") @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_cylindrical_to_polar(self, difntl, vector): - """Test ``coordinax.represent_as(PolarVector)``.""" - polar = difntl.represent_as(cx.PolarVector, vector) + """Test ``coordinax.represent_as(PolarPosition)``.""" + polar = difntl.represent_as(cx.PolarPosition, vector) - assert isinstance(polar, cx.PolarVector) + assert isinstance(polar, cx.PolarPosition) assert qnp.array_equal(polar.d_r, Quantity([1, 2, 3, 4], "km/s")) assert qnp.array_equal(polar.d_phi, Quantity([5, 6, 7, 8], "mas/yr")) def test_cylindrical_to_cartesian3d(self, difntl, vector, apydifntl, apyvector): - """Test ``coordinax.represent_as(Cartesian3DVector)``.""" - cart3d = difntl.represent_as(cx.CartesianDifferential3D, vector) + """Test ``coordinax.represent_as(CartesianPosition3D)``.""" + cart3d = difntl.represent_as(cx.CartesianVelocity3D, vector) - assert isinstance(cart3d, cx.CartesianDifferential3D) + assert isinstance(cart3d, cx.CartesianVelocity3D) assert qnp.array_equal( cart3d.d_x, Quantity([5.0, -76.537544, -145.15944, -40.03075], "km/s") ) @@ -735,10 +737,10 @@ def test_cylindrical_to_cartesian3d(self, difntl, vector, apydifntl, apyvector): assert np.allclose(convert(cart3d.d_z, APYQuantity), apycart3.d_z) def test_cylindrical_to_spherical(self, difntl, vector): - """Test ``coordinax.represent_as(SphericalDifferential)``.""" - dsph = difntl.represent_as(cx.SphericalDifferential, vector) + """Test ``coordinax.represent_as(SphericalVelocity)``.""" + dsph = difntl.represent_as(cx.SphericalVelocity, vector) - assert isinstance(dsph, cx.SphericalDifferential) + assert isinstance(dsph, cx.SphericalVelocity) assert qnp.array_equal( dsph.d_r, Quantity([13.472646, 14.904826, 16.313278, 17.708754], "km/s"), @@ -759,47 +761,47 @@ def test_cylindrical_to_spherical_astropy( self, difntl, vector, apydifntl, apyvector ): """Test Astropy equivalence.""" - sph = difntl.represent_as(cx.SphericalDifferential, vector) + sph = difntl.represent_as(cx.SphericalVelocity, vector) apysph = apydifntl.represent_as(apyc.PhysicsSphericalDifferential, apyvector) assert np.allclose(convert(sph.d_r, APYQuantity), apysph.d_r) assert np.allclose(convert(sph.d_theta, APYQuantity), apysph.d_theta) assert np.allclose(convert(sph.d_phi, APYQuantity), apysph.d_phi) def test_cylindrical_to_cylindrical(self, difntl, vector): - """Test ``coordinax.represent_as(CylindricalDifferential)``.""" + """Test ``coordinax.represent_as(CylindricalVelocity)``.""" # Jit can copy - newvec = difntl.represent_as(cx.CylindricalDifferential, vector) + newvec = difntl.represent_as(cx.CylindricalVelocity, vector) assert newvec == difntl # The normal `represent_as` method should return the same object - newvec = cx.represent_as(difntl, cx.CylindricalDifferential, vector) + newvec = cx.represent_as(difntl, cx.CylindricalVelocity, vector) assert newvec is difntl def test_cylindrical_to_cylindrical(self, difntl, vector, apydifntl, apyvector): """Test Astropy equivalence.""" - cyl = difntl.represent_as(cx.CylindricalDifferential, vector) + cyl = difntl.represent_as(cx.CylindricalVelocity, vector) apycyl = apydifntl.represent_as(apyc.CylindricalDifferential, apyvector) assert np.allclose(convert(cyl.d_rho, APYQuantity), apycyl.d_rho) assert np.allclose(convert(cyl.d_phi, APYQuantity), apycyl.d_phi) assert np.allclose(convert(cyl.d_z, APYQuantity), apycyl.d_z) -class TestSphericalDifferential(Abstract3DVectorDifferentialTest): - """Test :class:`coordinax.SphericalDifferential`.""" +class TestSphericalVelocity(AbstractVelocity3DTest): + """Test :class:`coordinax.SphericalVelocity`.""" @pytest.fixture(scope="class") - def difntl(self) -> cx.SphericalDifferential: + def difntl(self) -> cx.SphericalVelocity: """Return a differential.""" - return cx.SphericalDifferential( + return cx.SphericalVelocity( d_r=Quantity([5, 6, 7, 8], "km/s"), d_theta=Quantity([13, 14, 15, 16], "mas/yr"), d_phi=Quantity([9, 10, 11, 12], "mas/yr"), ) @pytest.fixture(scope="class") - def vector(self) -> cx.SphericalVector: + def vector(self) -> cx.SphericalPosition: """Return a vector.""" - return cx.SphericalVector( + return cx.SphericalPosition( r=Quantity([1, 2, 3, 4], "kpc"), theta=Quantity([3, 63, 90, 179.5], "deg"), phi=Quantity([0, 42, 160, 270], "deg"), @@ -807,14 +809,14 @@ def vector(self) -> cx.SphericalVector: @pytest.fixture(scope="class") def apydifntl( - self, difntl: cx.SphericalDifferential + self, difntl: cx.SphericalVelocity ) -> apyc.PhysicsSphericalDifferential: """Return an Astropy differential.""" return convert(difntl, apyc.PhysicsSphericalDifferential) @pytest.fixture(scope="class") def apyvector( - self, vector: cx.SphericalVector + self, vector: cx.SphericalPosition ) -> apyc.PhysicsSphericalRepresentation: """Return an Astropy vector.""" return convert(vector, apyc.PhysicsSphericalRepresentation) @@ -824,46 +826,46 @@ def apyvector( @pytest.mark.xfail(reason="Not implemented") @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_spherical_to_cartesian1d(self, difntl, vector): - """Test ``coordinax.represent_as(Cartesian1DVector)``.""" - cart1d = difntl.represent_as(cx.CartesianDifferential1D, vector) + """Test ``coordinax.represent_as(CartesianPosition1D)``.""" + cart1d = difntl.represent_as(cx.CartesianVelocity1D, vector) - assert isinstance(cart1d, cx.CartesianDifferential1D) + assert isinstance(cart1d, cx.CartesianVelocity1D) assert qnp.array_equal(cart1d.d_x, Quantity([1, 2, 3, 4], "km/s")) @pytest.mark.xfail(reason="Not implemented") @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_spherical_to_radial(self, difntl, vector): - """Test ``coordinax.represent_as(RadialVector)``.""" - radial = difntl.represent_as(cx.RadialVector, vector) + """Test ``coordinax.represent_as(RadialPosition)``.""" + radial = difntl.represent_as(cx.RadialPosition, vector) - assert isinstance(radial, cx.RadialVector) + assert isinstance(radial, cx.RadialPosition) assert qnp.array_equal(radial.d_r, Quantity([1, 2, 3, 4], "km/s")) @pytest.mark.xfail(reason="Not implemented") @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_spherical_to_cartesian2d(self, difntl, vector): - """Test ``coordinax.represent_as(Cartesian2DVector)``.""" - cart2d = difntl.represent_as(cx.CartesianDifferential2D, vector) + """Test ``coordinax.represent_as(CartesianPosition2D)``.""" + cart2d = difntl.represent_as(cx.CartesianVelocity2D, vector) - assert isinstance(cart2d, cx.CartesianDifferential2D) + assert isinstance(cart2d, cx.CartesianVelocity2D) assert qnp.array_equal(cart2d.d_x, Quantity([1, 2, 3, 4], "km/s")) assert qnp.array_equal(cart2d.d_y, Quantity([5, 6, 7, 8], "km/s")) @pytest.mark.xfail(reason="Not implemented") @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_spherical_to_polar(self, difntl, vector): - """Test ``coordinax.represent_as(PolarVector)``.""" - polar = difntl.represent_as(cx.PolarVector, vector) + """Test ``coordinax.represent_as(PolarPosition)``.""" + polar = difntl.represent_as(cx.PolarPosition, vector) - assert isinstance(polar, cx.PolarVector) + assert isinstance(polar, cx.PolarPosition) assert qnp.array_equal(polar.d_r, Quantity([1, 2, 3, 4], "km/s")) assert qnp.array_equal(polar.d_phi, Quantity([5, 6, 7, 8], "mas/yr")) def test_spherical_to_cartesian3d(self, difntl, vector): - """Test ``coordinax.represent_as(Cartesian3DVector)``.""" - cart3d = difntl.represent_as(cx.CartesianDifferential3D, vector) + """Test ``coordinax.represent_as(CartesianPosition3D)``.""" + cart3d = difntl.represent_as(cx.CartesianVelocity3D, vector) - assert isinstance(cart3d, cx.CartesianDifferential3D) + assert isinstance(cart3d, cx.CartesianVelocity3D) assert qnp.allclose( cart3d.d_x, Quantity([61.803337, -7.770853, -60.081947, 1.985678], "km/s"), @@ -884,7 +886,7 @@ def test_spherical_to_cartesian3d_astropy( self, difntl, vector, apydifntl, apyvector ): """Test Astropy equivalence.""" - cart3d = difntl.represent_as(cx.CartesianDifferential3D, vector) + cart3d = difntl.represent_as(cx.CartesianVelocity3D, vector) apycart3 = apydifntl.represent_as(apyc.CartesianDifferential, apyvector) assert np.allclose(convert(cart3d.d_x, APYQuantity), apycart3.d_x) @@ -892,10 +894,10 @@ def test_spherical_to_cartesian3d_astropy( assert np.allclose(convert(cart3d.d_z, APYQuantity), apycart3.d_z) def test_spherical_to_cylindrical(self, difntl, vector): - """Test ``coordinax.represent_as(CylindricalDifferential)``.""" - cylindrical = difntl.represent_as(cx.CylindricalDifferential, vector) + """Test ``coordinax.represent_as(CylindricalVelocity)``.""" + cylindrical = difntl.represent_as(cx.CylindricalVelocity, vector) - assert isinstance(cylindrical, cx.CylindricalDifferential) + assert isinstance(cylindrical, cx.CylindricalVelocity) assert qnp.allclose( cylindrical.d_rho, Quantity([61.803337, 65.60564, 6.9999905, -303.30875], "km/s"), @@ -916,35 +918,35 @@ def test_spherical_to_cylindrical_astropy( self, difntl, vector, apydifntl, apyvector ): """Test Astropy equivalence.""" - cyl = difntl.represent_as(cx.CylindricalDifferential, vector) + cyl = difntl.represent_as(cx.CylindricalVelocity, vector) apycyl = apydifntl.represent_as(apyc.CylindricalDifferential, apyvector) assert np.allclose(convert(cyl.d_rho, APYQuantity), apycyl.d_rho) assert np.allclose(convert(cyl.d_phi, APYQuantity), apycyl.d_phi) assert np.allclose(convert(cyl.d_z, APYQuantity), apycyl.d_z) def test_spherical_to_spherical(self, difntl, vector): - """Test ``coordinax.represent_as(SphericalDifferential)``.""" + """Test ``coordinax.represent_as(SphericalVelocity)``.""" # Jit can copy - newvec = difntl.represent_as(cx.SphericalDifferential, vector) + newvec = difntl.represent_as(cx.SphericalVelocity, vector) assert newvec == difntl # The normal `represent_as` method should return the same object - newvec = cx.represent_as(difntl, cx.SphericalDifferential, vector) + newvec = cx.represent_as(difntl, cx.SphericalVelocity, vector) assert newvec is difntl def test_spherical_to_spherical_astropy(self, difntl, vector, apydifntl, apyvector): """Test Astropy equivalence.""" - sph = difntl.represent_as(cx.SphericalDifferential, vector) + sph = difntl.represent_as(cx.SphericalVelocity, vector) apysph = apydifntl.represent_as(apyc.PhysicsSphericalDifferential, apyvector) assert np.allclose(convert(sph.d_r, APYQuantity), apysph.d_r) assert np.allclose(convert(sph.d_theta, APYQuantity), apysph.d_theta) assert np.allclose(convert(sph.d_phi, APYQuantity), apysph.d_phi) def test_spherical_to_lonlatspherical(self, difntl, vector): - """Test ``coordinax.represent_as(LonLatSphericalDifferential)``.""" - llsph = difntl.represent_as(cx.LonLatSphericalDifferential, vector) + """Test ``coordinax.represent_as(LonLatSphericalVelocity)``.""" + llsph = difntl.represent_as(cx.LonLatSphericalVelocity, vector) - assert isinstance(llsph, cx.LonLatSphericalDifferential) + assert isinstance(llsph, cx.LonLatSphericalVelocity) assert qnp.array_equal(llsph.d_distance, difntl.d_r) assert qnp.array_equal(llsph.d_lon, difntl.d_phi) assert qnp.allclose( @@ -957,7 +959,7 @@ def test_spherical_to_lonlatspherical_astropy( self, difntl, vector, apydifntl, apyvector ): """Test Astropy equivalence.""" - cart3d = difntl.represent_as(cx.LonLatSphericalDifferential, vector) + cart3d = difntl.represent_as(cx.LonLatSphericalVelocity, vector) apycart3 = apydifntl.represent_as(apyc.SphericalDifferential, apyvector) assert np.allclose(convert(cart3d.d_distance, APYQuantity), apycart3.d_distance) @@ -966,9 +968,9 @@ def test_spherical_to_lonlatspherical_astropy( def test_spherical_to_mathspherical(self, difntl, vector): """Test ``coordinax.represent_as(MathSpherical)``.""" - llsph = difntl.represent_as(cx.MathSphericalDifferential, vector) + llsph = difntl.represent_as(cx.MathSphericalVelocity, vector) - assert isinstance(llsph, cx.MathSphericalDifferential) + assert isinstance(llsph, cx.MathSphericalVelocity) assert qnp.array_equal(llsph.d_r, difntl.d_r) assert qnp.array_equal(llsph.d_phi, difntl.d_theta) assert qnp.array_equal(llsph.d_theta, difntl.d_phi) diff --git a/tests/test_jax_ops.py b/tests/test_jax_ops.py index 32ad1ef..c9c08fa 100644 --- a/tests/test_jax_ops.py +++ b/tests/test_jax_ops.py @@ -12,14 +12,14 @@ from coordinax._base_pos import VECTOR_CLASSES from coordinax._utils import dataclass_items -VECTOR_CLASSES_3D = [c for c in VECTOR_CLASSES if issubclass(c, cx.Abstract3DVector)] +VECTOR_CLASSES_3D = [c for c in VECTOR_CLASSES if issubclass(c, cx.AbstractPosition3D)] # TODO: cycle through all representations @pytest.fixture(params=VECTOR_CLASSES_3D) def q(request) -> cx.AbstractPosition: """Fixture for 3D Vectors.""" - q = cx.Cartesian3DVector.constructor(Quantity([1, 2, 3], unit=u.kpc)) + q = cx.CartesianPosition3D.constructor(Quantity([1, 2, 3], unit=u.kpc)) return q.represent_as(request.param)