feat: systematize class names (#115)

* feat: update abstract ND pos / vel names
* feat: rename radial classes
* feat: rename cartesian 1d classes
* feat: rename cartesian 2d classes
* feat: rename polar 2d classes
* feat: rename Cartesian 3d classes
* feat: rename cylindrical 3d classes
* feat: rename abstract spherical 3d classes
* feat: rename spherical 3d classes
* feat: rename cartesian nd classes
* fix: astropy names

Signed-off-by: nstarman <nstarman@users.noreply.github.com>

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')
 

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')

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,57 +16,57 @@
 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"))
  )
 
  """
  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