From 6ac51454ec20b3ad6715ed43b1aab03f3d86550a Mon Sep 17 00:00:00 2001 From: nstarman Date: Tue, 19 Mar 2024 09:51:44 -0400 Subject: [PATCH 1/4] refactor: cleanup Signed-off-by: nstarman --- tests/test_base.py | 2 +- tests/test_d1.py | 336 ++++++++++++------------- tests/test_d3.py | 597 ++++++++++++++++++++++----------------------- 3 files changed, 454 insertions(+), 481 deletions(-) diff --git a/tests/test_base.py b/tests/test_base.py index d4965d5d..5ae9330c 100644 --- a/tests/test_base.py +++ b/tests/test_base.py @@ -228,7 +228,7 @@ def test_represent_as(self, difntl, target, vector): This just tests that the machiner works. """ - # TODO: have all the convertsions + # TODO: have all the conversions if ( ( isinstance(difntl, Abstract1DVectorDifferential) diff --git a/tests/test_d1.py b/tests/test_d1.py index 879deaed..deec458a 100644 --- a/tests/test_d1.py +++ b/tests/test_d1.py @@ -1,43 +1,27 @@ """Test :mod:`coordinax._d1`.""" -import astropy.units as u import pytest import quaxed.numpy as qnp from unxt import Quantity +import coordinax as cx from .test_base import AbstractVectorDifferentialTest, AbstractVectorTest -from coordinax import ( - AbstractVector, - Cartesian1DVector, - Cartesian2DVector, - Cartesian3DVector, - CartesianDifferential1D, - CartesianDifferential2D, - CartesianDifferential3D, - CylindricalDifferential, - CylindricalVector, - PolarDifferential, - PolarVector, - RadialDifferential, - RadialVector, - SphericalDifferential, - SphericalVector, - represent_as, -) class Abstract1DVectorTest(AbstractVectorTest): """Test :class:`coordinax.Abstract1DVector`.""" + # TODO: Add tests + class TestCartesian1DVector(Abstract1DVectorTest): """Test :class:`coordinax.Cartesian1DVector`.""" @pytest.fixture(scope="class") - def vector(self) -> AbstractVector: + def vector(self) -> cx.AbstractVector: """Return a vector.""" - return Cartesian1DVector(x=Quantity([1, 2, 3, 4], u.kpc)) + return cx.Cartesian1DVector(x=Quantity([1, 2, 3, 4], "kpc")) # ========================================================================== # represent_as @@ -45,137 +29,139 @@ def vector(self) -> AbstractVector: def test_cartesian1d_to_cartesian1d(self, vector): """Test ``coordinax.represent_as(Cartesian1DVector)``.""" # Jit can copy - newvec = vector.represent_as(Cartesian1DVector) + newvec = vector.represent_as(cx.Cartesian1DVector) assert newvec == vector # The normal `represent_as` method should return the same object - newvec = represent_as(vector, Cartesian1DVector) + newvec = cx.represent_as(vector, cx.Cartesian1DVector) assert newvec is vector def test_cartesian1d_to_radial(self, vector): """Test ``coordinax.represent_as(RadialVector)``.""" - radial = vector.represent_as(RadialVector) + radial = vector.represent_as(cx.RadialVector) - assert isinstance(radial, RadialVector) - assert qnp.array_equal(radial.r, Quantity([1, 2, 3, 4], u.kpc)) + assert isinstance(radial, cx.RadialVector) + assert qnp.array_equal(radial.r, Quantity([1, 2, 3, 4], "kpc")) def test_cartesian1d_to_cartesian2d(self, vector): """Test ``coordinax.represent_as(Cartesian2DVector)``.""" - cart2d = vector.represent_as(Cartesian2DVector, y=Quantity([5, 6, 7, 8], u.km)) + cart2d = vector.represent_as( + cx.Cartesian2DVector, y=Quantity([5, 6, 7, 8], "km") + ) - assert isinstance(cart2d, Cartesian2DVector) - assert qnp.array_equal(cart2d.x, Quantity([1, 2, 3, 4], u.kpc)) - assert qnp.array_equal(cart2d.y, Quantity([5, 6, 7, 8], u.km)) + assert isinstance(cart2d, cx.Cartesian2DVector) + 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(PolarVector, phi=Quantity([0, 1, 2, 3], u.rad)) + polar = vector.represent_as(cx.PolarVector, phi=Quantity([0, 1, 2, 3], "rad")) - assert isinstance(polar, PolarVector) - assert qnp.array_equal(polar.r, Quantity([1, 2, 3, 4], u.kpc)) - assert qnp.array_equal(polar.phi, Quantity([0, 1, 2, 3], u.rad)) + assert isinstance(polar, cx.PolarVector) + 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_lnpolar(self, vector): # """Test ``coordinax.represent_as(LnPolarVector)``.""" - # lnpolar = vector.to_lnpolar(phi=Quantity([0, 1, 2, 3], u.rad)) + # lnpolar = vector.to_lnpolar(phi=Quantity([0, 1, 2, 3], "rad")) # assert isinstance(lnpolar, LnPolarVector) - # assert lnpolar.lnr == xp.log(Quantity([1, 2, 3, 4], u.kpc)) - # assert qnp.array_equal(lnpolar.phi, Quantity([0, 1, 2, 3], u.rad)) + # assert lnpolar.lnr == xp.log(Quantity([1, 2, 3, 4], "kpc")) + # assert qnp.array_equal(lnpolar.phi, Quantity([0, 1, 2, 3], "rad")) # def test_cartesian1d_to_log10polar(self, vector): # """Test ``coordinax.represent_as(Log10PolarVector)``.""" - # log10polar = vector.to_log10polar(phi=Quantity([0, 1, 2, 3], u.rad)) + # log10polar = vector.to_log10polar(phi=Quantity([0, 1, 2, 3], "rad")) # assert isinstance(log10polar, Log10PolarVector) - # assert log10polar.log10r == xp.log10(Quantity([1, 2, 3, 4], u.kpc)) - # assert qnp.array_equal(log10polar.phi, Quantity([0, 1, 2, 3], u.rad)) + # assert log10polar.log10r == xp.log10(Quantity([1, 2, 3, 4], "kpc")) + # assert qnp.array_equal(log10polar.phi, Quantity([0, 1, 2, 3], "rad")) def test_cartesian1d_to_cartesian3d(self, vector): """Test ``coordinax.represent_as(Cartesian3DVector)``.""" cart3d = vector.represent_as( - Cartesian3DVector, - y=Quantity([5, 6, 7, 8], u.km), - z=Quantity([9, 10, 11, 12], u.m), + cx.Cartesian3DVector, + y=Quantity([5, 6, 7, 8], "km"), + z=Quantity([9, 10, 11, 12], "m"), ) - assert isinstance(cart3d, Cartesian3DVector) - assert qnp.array_equal(cart3d.x, Quantity([1, 2, 3, 4], u.kpc)) - assert qnp.array_equal(cart3d.y, Quantity([5, 6, 7, 8], u.km)) - assert qnp.array_equal(cart3d.z, Quantity([9, 10, 11, 12], u.m)) + assert isinstance(cart3d, cx.Cartesian3DVector) + 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)``.""" spherical = vector.represent_as( - SphericalVector, - phi=Quantity([0, 1, 2, 3], u.rad), - theta=Quantity([4, 5, 6, 7], u.rad), + cx.SphericalVector, + phi=Quantity([0, 1, 2, 3], "rad"), + theta=Quantity([4, 5, 6, 7], "rad"), ) - assert isinstance(spherical, SphericalVector) - assert qnp.array_equal(spherical.r, Quantity([1, 2, 3, 4], u.kpc)) - assert qnp.array_equal(spherical.phi, Quantity([0, 1, 2, 3], u.rad)) - assert qnp.array_equal(spherical.theta, Quantity([4, 5, 6, 7], u.rad)) + assert isinstance(spherical, cx.SphericalVector) + assert qnp.array_equal(spherical.r, Quantity([1, 2, 3, 4], "kpc")) + assert qnp.array_equal(spherical.phi, Quantity([0, 1, 2, 3], "rad")) + assert qnp.array_equal(spherical.theta, Quantity([4, 5, 6, 7], "rad")) def test_cartesian1d_to_cylindrical(self, vector): """Test ``coordinax.represent_as(CylindricalVector)``.""" cylindrical = vector.represent_as( - CylindricalVector, - phi=Quantity([0, 1, 2, 3], u.rad), - z=Quantity([4, 5, 6, 7], u.m), + cx.CylindricalVector, + phi=Quantity([0, 1, 2, 3], "rad"), + z=Quantity([4, 5, 6, 7], "m"), ) - assert isinstance(cylindrical, CylindricalVector) - assert qnp.array_equal(cylindrical.rho, Quantity([1, 2, 3, 4], u.kpc)) - assert qnp.array_equal(cylindrical.phi, Quantity([0, 1, 2, 3], u.rad)) - assert qnp.array_equal(cylindrical.z, Quantity([4, 5, 6, 7], u.m)) + assert isinstance(cylindrical, cx.CylindricalVector) + 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`.""" @pytest.fixture(scope="class") - def vector(self) -> AbstractVector: + def vector(self) -> cx.AbstractVector: """Return a vector.""" - from coordinax import RadialVector - - return RadialVector(r=Quantity([1, 2, 3, 4], u.kpc)) + return cx.RadialVector(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(Cartesian1DVector) + cart1d = vector.represent_as(cx.Cartesian1DVector) - assert isinstance(cart1d, Cartesian1DVector) - assert qnp.array_equal(cart1d.x, Quantity([1, 2, 3, 4], u.kpc)) + assert isinstance(cart1d, cx.Cartesian1DVector) + assert qnp.array_equal(cart1d.x, Quantity([1, 2, 3, 4], "kpc")) def test_radial_to_radial(self, vector): """Test ``coordinax.represent_as(RadialVector)``.""" # Jit can copy - newvec = vector.represent_as(RadialVector) + newvec = vector.represent_as(cx.RadialVector) assert newvec == vector # The normal `represent_as` method should return the same object - newvec = represent_as(vector, RadialVector) + newvec = cx.represent_as(vector, cx.RadialVector) assert newvec is vector def test_radial_to_cartesian2d(self, vector): """Test ``coordinax.represent_as(Cartesian2DVector)``.""" - cart2d = vector.represent_as(Cartesian2DVector, y=Quantity([5, 6, 7, 8], u.km)) + cart2d = vector.represent_as( + cx.Cartesian2DVector, y=Quantity([5, 6, 7, 8], "km") + ) - assert isinstance(cart2d, Cartesian2DVector) - assert qnp.array_equal(cart2d.x, Quantity([1, 2, 3, 4], u.kpc)) - assert qnp.array_equal(cart2d.y, Quantity([5, 6, 7, 8], u.km)) + assert isinstance(cart2d, cx.Cartesian2DVector) + 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(PolarVector, phi=Quantity([0, 1, 2, 3], u.rad)) + polar = vector.represent_as(cx.PolarVector, phi=Quantity([0, 1, 2, 3], "rad")) - assert isinstance(polar, PolarVector) - assert qnp.array_equal(polar.r, Quantity([1, 2, 3, 4], u.kpc)) - assert qnp.array_equal(polar.phi, Quantity([0, 1, 2, 3], u.rad)) + assert isinstance(polar, cx.PolarVector) + 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_lnpolar(self, vector): # """Test ``coordinax.represent_as(LnPolarVector)``.""" @@ -188,41 +174,41 @@ def test_radial_to_polar(self, vector): def test_radial_to_cartesian3d(self, vector): """Test ``coordinax.represent_as(Cartesian3DVector)``.""" cart3d = vector.represent_as( - Cartesian3DVector, - y=Quantity([5, 6, 7, 8], u.km), - z=Quantity([9, 10, 11, 12], u.m), + cx.Cartesian3DVector, + y=Quantity([5, 6, 7, 8], "km"), + z=Quantity([9, 10, 11, 12], "m"), ) - assert isinstance(cart3d, Cartesian3DVector) - assert qnp.array_equal(cart3d.x, Quantity([1, 2, 3, 4], u.kpc)) - assert qnp.array_equal(cart3d.y, Quantity([5, 6, 7, 8], u.km)) - assert qnp.array_equal(cart3d.z, Quantity([9, 10, 11, 12], u.m)) + assert isinstance(cart3d, cx.Cartesian3DVector) + 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)``.""" spherical = vector.represent_as( - SphericalVector, - phi=Quantity([0, 1, 2, 3], u.rad), - theta=Quantity([4, 5, 6, 7], u.rad), + cx.SphericalVector, + phi=Quantity([0, 1, 2, 3], "rad"), + theta=Quantity([4, 5, 6, 7], "rad"), ) - assert isinstance(spherical, SphericalVector) - assert qnp.array_equal(spherical.r, Quantity([1, 2, 3, 4], u.kpc)) - assert qnp.array_equal(spherical.phi, Quantity([0, 1, 2, 3], u.rad)) - assert qnp.array_equal(spherical.theta, Quantity([4, 5, 6, 7], u.rad)) + assert isinstance(spherical, cx.SphericalVector) + assert qnp.array_equal(spherical.r, Quantity([1, 2, 3, 4], "kpc")) + assert qnp.array_equal(spherical.phi, Quantity([0, 1, 2, 3], "rad")) + assert qnp.array_equal(spherical.theta, Quantity([4, 5, 6, 7], "rad")) def test_radial_to_cylindrical(self, vector): """Test ``coordinax.represent_as(CylindricalVector)``.""" cylindrical = vector.represent_as( - CylindricalVector, - phi=Quantity([0, 1, 2, 3], u.rad), - z=Quantity([4, 5, 6, 7], u.m), + cx.CylindricalVector, + phi=Quantity([0, 1, 2, 3], "rad"), + z=Quantity([4, 5, 6, 7], "m"), ) - assert isinstance(cylindrical, CylindricalVector) - assert qnp.array_equal(cylindrical.rho, Quantity([1, 2, 3, 4], u.kpc)) - assert qnp.array_equal(cylindrical.phi, Quantity([0, 1, 2, 3], u.rad)) - assert qnp.array_equal(cylindrical.z, Quantity([4, 5, 6, 7], u.m)) + assert isinstance(cylindrical, cx.CylindricalVector) + 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(AbstractVectorDifferentialTest): @@ -233,14 +219,14 @@ class TestCartesianDifferential1D(Abstract1DVectorDifferentialTest): """Test :class:`coordinax.CartesianDifferential1D`.""" @pytest.fixture(scope="class") - def difntl(self) -> CartesianDifferential1D: + def difntl(self) -> cx.CartesianDifferential1D: """Return a vector.""" - return CartesianDifferential1D(d_x=Quantity([1.0, 2, 3, 4], u.km / u.s)) + return cx.CartesianDifferential1D(d_x=Quantity([1.0, 2, 3, 4], "km/s")) @pytest.fixture(scope="class") - def vector(self) -> Cartesian1DVector: + def vector(self) -> cx.Cartesian1DVector: """Return a vector.""" - return Cartesian1DVector(x=Quantity([1.0, 2, 3, 4], u.kpc)) + return cx.Cartesian1DVector(x=Quantity([1.0, 2, 3, 4], "kpc")) # ========================================================================== # represent_as @@ -249,106 +235,106 @@ def vector(self) -> Cartesian1DVector: def test_cartesian1d_to_cartesian1d(self, difntl, vector): """Test ``difntl.represent_as(CartesianDifferential1D)``.""" # Jit can copy - newvec = difntl.represent_as(CartesianDifferential1D, vector) + newvec = difntl.represent_as(cx.CartesianDifferential1D, vector) assert newvec == difntl # The normal `represent_as` method should return the same object - newvec = represent_as(difntl, CartesianDifferential1D, vector) + newvec = cx.represent_as(difntl, cx.CartesianDifferential1D, 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(RadialDifferential, vector) + radial = difntl.represent_as(cx.RadialDifferential, vector) - assert isinstance(radial, RadialDifferential) - assert qnp.array_equal(radial.d_r, Quantity([1, 2, 3, 4], u.km / u.s)) + assert isinstance(radial, cx.RadialDifferential) + 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)``.""" cart2d = difntl.represent_as( - CartesianDifferential2D, vector, dy=Quantity([5, 6, 7, 8], u.km) + cx.CartesianDifferential2D, vector, d_y=Quantity([5, 6, 7, 8], "km") ) - assert isinstance(cart2d, CartesianDifferential2D) - assert qnp.array_equal(cart2d.d_x, Quantity([1, 2, 3, 4], u.km / u.s)) - assert qnp.array_equal(cart2d.d_y, Quantity([5, 6, 7, 8], u.km / u.s)) + assert isinstance(cart2d, cx.CartesianDifferential2D) + 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)``.""" polar = difntl.represent_as( - PolarDifferential, vector, dphi=Quantity([0, 1, 2, 3], u.rad) + cx.PolarDifferential, vector, d_phi=Quantity([0, 1, 2, 3], "rad") ) - assert isinstance(polar, PolarDifferential) - assert qnp.array_equal(polar.d_r, Quantity([1, 2, 3, 4], u.km / u.s)) - assert qnp.array_equal(polar.d_phi, Quantity([0, 1, 2, 3], u.rad / u.s)) + assert isinstance(polar, cx.PolarDifferential) + 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)``.""" cart3d = difntl.represent_as( - CartesianDifferential3D, + cx.CartesianDifferential3D, vector, - dy=Quantity([5, 6, 7, 8], u.km), - dz=Quantity([9, 10, 11, 12], u.m), + d_y=Quantity([5, 6, 7, 8], "km"), + d_z=Quantity([9, 10, 11, 12], "m"), ) - assert isinstance(cart3d, CartesianDifferential3D) - assert qnp.array_equal(cart3d.d_x, Quantity([1, 2, 3, 4], u.kpc)) - assert qnp.array_equal(cart3d.d_y, Quantity([5, 6, 7, 8], u.km)) - assert qnp.array_equal(cart3d.d_z, Quantity([9, 10, 11, 12], u.m)) + assert isinstance(cart3d, cx.CartesianDifferential3D) + 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")) @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)``.""" spherical = difntl.represent_as( - SphericalDifferential, + cx.SphericalDifferential, vector, - dphi=Quantity([0, 1, 2, 3], u.rad), - dtheta=Quantity([4, 5, 6, 7], u.rad), + d_phi=Quantity([0, 1, 2, 3], "rad"), + d_theta=Quantity([4, 5, 6, 7], "rad"), ) - assert isinstance(spherical, SphericalDifferential) - assert qnp.array_equal(spherical.d_r, Quantity([1, 2, 3, 4], u.kpc)) - assert qnp.array_equal(spherical.d_phi, Quantity([0, 1, 2, 3], u.rad)) - assert spherical.dtheta == Quantity([4, 5, 6, 7], u.rad) + assert isinstance(spherical, cx.SphericalDifferential) + assert qnp.array_equal(spherical.d_r, Quantity([1, 2, 3, 4], "kpc")) + assert qnp.array_equal(spherical.d_phi, Quantity([0, 1, 2, 3], "rad")) + assert spherical.dtheta == Quantity([4, 5, 6, 7], "rad") @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)``.""" cylindrical = difntl.represent_as( - CylindricalDifferential, + cx.CylindricalDifferential, vector, - dphi=Quantity([0, 1, 2, 3], u.rad), - dz=Quantity([4, 5, 6, 7], u.m), + d_phi=Quantity([0, 1, 2, 3], "rad"), + d_z=Quantity([4, 5, 6, 7], "m"), ) - assert isinstance(cylindrical, CylindricalDifferential) - assert qnp.array_equal(cylindrical.d_rho, Quantity([1, 2, 3, 4], u.kpc)) - assert qnp.array_equal(cylindrical.d_phi, Quantity([0, 1, 2, 3], u.rad)) - assert qnp.array_equal(cylindrical.d_z, Quantity([4, 5, 6, 7], u.m)) + assert isinstance(cylindrical, cx.CylindricalDifferential) + 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`.""" @pytest.fixture(scope="class") - def difntl(self) -> RadialDifferential: + def difntl(self) -> cx.RadialDifferential: """Return a vector.""" - return RadialDifferential(d_r=Quantity([1, 2, 3, 4], u.km / u.s)) + return cx.RadialDifferential(d_r=Quantity([1, 2, 3, 4], "km/s")) @pytest.fixture(scope="class") - def vector(self) -> RadialVector: + def vector(self) -> cx.RadialVector: """Return a vector.""" - return RadialVector(r=Quantity([1, 2, 3, 4], u.kpc)) + return cx.RadialVector(r=Quantity([1, 2, 3, 4], "kpc")) # ========================================================================== # represent_as @@ -356,20 +342,20 @@ def vector(self) -> RadialVector: @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_radial_to_cartesian1d(self, difntl, vector): """Test ``difntl.represent_as(CartesianDifferential1D)``.""" - cart1d = difntl.represent_as(CartesianDifferential1D, vector) + cart1d = difntl.represent_as(cx.CartesianDifferential1D, vector) - assert isinstance(cart1d, CartesianDifferential1D) - assert qnp.array_equal(cart1d.d_x, Quantity([1, 2, 3, 4], u.km / u.s)) + assert isinstance(cart1d, cx.CartesianDifferential1D) + 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)``.""" # Jit can copy - newvec = difntl.represent_as(RadialDifferential, vector) + newvec = difntl.represent_as(cx.RadialDifferential, vector) assert newvec == difntl # The normal `represent_as` method should return the same object - newvec = represent_as(difntl, RadialDifferential, vector) + newvec = cx.represent_as(difntl, cx.RadialDifferential, vector) assert newvec is difntl @pytest.mark.xfail(reason="Not implemented") @@ -377,69 +363,69 @@ def test_radial_to_radial(self, difntl, vector): def test_radial_to_cartesian2d(self, difntl, vector): """Test ``difntl.represent_as(CartesianDifferential2D)``.""" cart2d = difntl.represent_as( - CartesianDifferential2D, vector, dy=Quantity([5, 6, 7, 8], u.km) + cx.CartesianDifferential2D, vector, d_y=Quantity([5, 6, 7, 8], "km") ) - assert isinstance(cart2d, CartesianDifferential2D) - assert qnp.array_equal(cart2d.d_x, Quantity([1, 2, 3, 4], u.kpc)) - assert qnp.array_equal(cart2d.d_y, Quantity([5, 6, 7, 8], u.km)) + assert isinstance(cart2d, cx.CartesianDifferential2D) + 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)``.""" polar = difntl.represent_as( - PolarDifferential, vector, dphi=Quantity([0, 1, 2, 3], u.rad) + cx.PolarDifferential, vector, d_phi=Quantity([0, 1, 2, 3], "rad") ) - assert isinstance(polar, PolarDifferential) - assert qnp.array_equal(polar.d_r, Quantity([1, 2, 3, 4], u.kpc)) - assert qnp.array_equal(polar.d_phi, Quantity([0, 1, 2, 3], u.rad)) + assert isinstance(polar, cx.PolarDifferential) + 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)``.""" cart3d = difntl.represent_as( - CartesianDifferential3D, + cx.CartesianDifferential3D, vector, - dy=Quantity([5, 6, 7, 8], u.km), - dz=Quantity([9, 10, 11, 12], u.m), + d_y=Quantity([5, 6, 7, 8], "km"), + d_z=Quantity([9, 10, 11, 12], "m"), ) - assert isinstance(cart3d, CartesianDifferential3D) - assert qnp.array_equal(cart3d.d_x, Quantity([1, 2, 3, 4], u.kpc)) - assert qnp.array_equal(cart3d.d_y, Quantity([5, 6, 7, 8], u.km)) - assert qnp.array_equal(cart3d.d_z, Quantity([9, 10, 11, 12], u.m)) + assert isinstance(cart3d, cx.CartesianDifferential3D) + 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")) @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)``.""" spherical = difntl.represent_as( - SphericalDifferential, + cx.SphericalDifferential, vector, - dphi=Quantity([0, 1, 2, 3], u.rad), - dtheta=Quantity([4, 5, 6, 7], u.rad), + d_phi=Quantity([0, 1, 2, 3], "rad"), + dtheta=Quantity([4, 5, 6, 7], "rad"), ) - assert isinstance(spherical, SphericalDifferential) - assert qnp.array_equal(spherical.d_r, Quantity([1, 2, 3, 4], u.kpc)) - assert qnp.array_equal(spherical.d_phi, Quantity([0, 1, 2, 3], u.rad)) - assert spherical.dtheta == Quantity([4, 5, 6, 7], u.rad) + assert isinstance(spherical, cx.SphericalDifferential) + assert qnp.array_equal(spherical.d_r, Quantity([1, 2, 3, 4], "kpc")) + assert qnp.array_equal(spherical.d_phi, Quantity([0, 1, 2, 3], "rad")) + assert spherical.dtheta == Quantity([4, 5, 6, 7], "rad") @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)``.""" cylindrical = difntl.represent_as( - CylindricalDifferential, + cx.CylindricalDifferential, vector, - dphi=Quantity([0, 1, 2, 3], u.rad), - dz=Quantity([4, 5, 6, 7], u.m), + d_phi=Quantity([0, 1, 2, 3], "rad"), + d_z=Quantity([4, 5, 6, 7], "m"), ) - assert isinstance(cylindrical, CylindricalDifferential) - assert qnp.array_equal(cylindrical.d_rho, Quantity([1, 2, 3, 4], u.kpc)) - assert qnp.array_equal(cylindrical.d_phi, Quantity([0, 1, 2, 3], u.rad)) - assert qnp.array_equal(cylindrical.d_z, Quantity([4, 5, 6, 7], u.m)) + assert isinstance(cylindrical, cx.CylindricalDifferential) + 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_d3.py b/tests/test_d3.py index 8ac3e2ab..31479070 100644 --- a/tests/test_d3.py +++ b/tests/test_d3.py @@ -1,36 +1,19 @@ """Test :mod:`coordinax._builtin`.""" import astropy.coordinates as apyc -import astropy.units as u import jax.numpy as jnp import numpy as np import pytest from astropy.coordinates.tests.test_representation import representation_equal +from astropy.units import Quantity as APYQuantity from plum import convert import quaxed.array_api as xp import quaxed.numpy as qnp from unxt import Quantity +import coordinax as cx from .test_base import AbstractVectorDifferentialTest, AbstractVectorTest -from coordinax import ( - AbstractVector, - Cartesian1DVector, - Cartesian2DVector, - Cartesian3DVector, - CylindricalVector, - PolarVector, - RadialVector, - SphericalVector, - represent_as, -) -from coordinax._d1.builtin import CartesianDifferential1D -from coordinax._d2.builtin import CartesianDifferential2D -from coordinax._d3.builtin import ( - CartesianDifferential3D, - CylindricalDifferential, - SphericalDifferential, -) class Abstract3DVectorTest(AbstractVectorTest): @@ -40,7 +23,7 @@ class Abstract3DVectorTest(AbstractVectorTest): # Unary operations def test_neg_compare_apy( - self, vector: AbstractVector, apyvector: apyc.BaseRepresentation + self, vector: cx.AbstractVector, apyvector: apyc.BaseRepresentation ): """Test negation.""" # To take the negative, Vector converts to Cartesian coordinates, takes @@ -77,18 +60,16 @@ class TestCartesian3DVector(Abstract3DVectorTest): """Test :class:`coordinax.Cartesian3DVector`.""" @pytest.fixture(scope="class") - def vector(self) -> AbstractVector: + def vector(self) -> cx.AbstractVector: """Return a vector.""" - from coordinax import Cartesian3DVector - - return Cartesian3DVector( - x=Quantity([1, 2, 3, 4], u.kpc), - y=Quantity([5, 6, 7, 8], u.kpc), - z=Quantity([9, 10, 11, 12], u.kpc), + return cx.Cartesian3DVector( + 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 apyvector(self, vector: AbstractVector) -> apyc.CartesianRepresentation: + def apyvector(self, vector: cx.AbstractVector) -> apyc.CartesianRepresentation: """Return an Astropy vector.""" return convert(vector, apyc.CartesianRepresentation) @@ -98,39 +79,41 @@ def apyvector(self, vector: AbstractVector) -> 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(Cartesian1DVector) + cart1d = vector.represent_as(cx.Cartesian1DVector) - assert isinstance(cart1d, Cartesian1DVector) - assert qnp.array_equal(cart1d.x, Quantity([1, 2, 3, 4], u.kpc)) + assert isinstance(cart1d, cx.Cartesian1DVector) + 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(RadialVector) + radial = vector.represent_as(cx.RadialVector) - assert isinstance(radial, RadialVector) + assert isinstance(radial, cx.RadialVector) assert qnp.array_equal( - radial.r, Quantity([10.34408, 11.83216, 13.379088, 14.96663], u.kpc) + 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)``.""" - cart2d = vector.represent_as(Cartesian2DVector, y=Quantity([5, 6, 7, 8], u.km)) + cart2d = vector.represent_as( + cx.Cartesian2DVector, y=Quantity([5, 6, 7, 8], "km") + ) - assert isinstance(cart2d, Cartesian2DVector) - assert qnp.array_equal(cart2d.x, Quantity([1, 2, 3, 4], u.kpc)) - assert qnp.array_equal(cart2d.y, Quantity([5, 6, 7, 8], u.kpc)) + assert isinstance(cart2d, cx.Cartesian2DVector) + 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(PolarVector, phi=Quantity([0, 1, 2, 3], u.rad)) + polar = vector.represent_as(cx.PolarVector, phi=Quantity([0, 1, 2, 3], "rad")) - assert isinstance(polar, PolarVector) + assert isinstance(polar, cx.PolarVector) 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], u.rad) + polar.phi, Quantity([1.3734008, 1.2490457, 1.1659045, 1.1071488], "rad") ) # @pytest.mark.filterwarnings("ignore:Irreversible dimension change") @@ -146,82 +129,82 @@ def test_cartesian3d_to_polar(self, vector): def test_cartesian3d_to_cartesian3d(self, vector): """Test ``coordinax.represent_as(Cartesian3DVector)``.""" # Jit can copy - newvec = vector.represent_as(Cartesian3DVector) + newvec = vector.represent_as(cx.Cartesian3DVector) assert newvec == vector # The normal `represent_as` method should return the same object - newvec = represent_as(vector, Cartesian3DVector) + newvec = cx.represent_as(vector, cx.Cartesian3DVector) assert newvec is vector def test_cartesian3d_to_cartesian3d_astropy(self, vector, apyvector): """Test Astropy equivalence.""" - newvec = vector.represent_as(Cartesian3DVector) + newvec = vector.represent_as(cx.Cartesian3DVector) - assert np.allclose(convert(newvec.x, u.Quantity), apyvector.x) - assert np.allclose(convert(newvec.y, u.Quantity), apyvector.y) - assert np.allclose(convert(newvec.z, u.Quantity), apyvector.z) + 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(SphericalVector) + spherical = vector.represent_as(cx.SphericalVector) - assert isinstance(spherical, SphericalVector) + assert isinstance(spherical, cx.SphericalVector) assert qnp.array_equal( - spherical.r, Quantity([10.34408, 11.83216, 13.379088, 14.96663], u.kpc) + spherical.r, Quantity([10.34408, 11.83216, 13.379088, 14.96663], "kpc") ) assert qnp.array_equal( - spherical.phi, Quantity([1.3734008, 1.2490457, 1.1659045, 1.1071488], u.rad) + spherical.phi, Quantity([1.3734008, 1.2490457, 1.1659045, 1.1071488], "rad") ) assert jnp.allclose( - spherical.theta.to_value(u.rad), + spherical.theta.to_value("rad"), xp.asarray([0.51546645, 0.5639427, 0.6055685, 0.64052236]), ) def test_cartesian3d_to_spherical_astropy(self, vector, apyvector): """Test Astropy equivalence.""" - sph = vector.represent_as(SphericalVector) + sph = vector.represent_as(cx.SphericalVector) apysph = apyvector.represent_as(apyc.PhysicsSphericalRepresentation) - assert np.allclose(convert(sph.r, u.Quantity), apysph.r) - assert np.allclose(convert(sph.theta, u.Quantity), apysph.theta) - assert np.allclose(convert(sph.phi, u.Quantity), apysph.phi) + 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_cartesian3d_to_cylindrical(self, vector): """Test ``coordinax.represent_as(CylindricalVector)``.""" - cylindrical = vector.represent_as(CylindricalVector) + cylindrical = vector.represent_as(cx.CylindricalVector) - assert isinstance(cylindrical, CylindricalVector) + assert isinstance(cylindrical, cx.CylindricalVector) assert qnp.array_equal(cylindrical.rho, qnp.hypot(vector.x, vector.y)) assert qnp.array_equal( cylindrical.phi, - Quantity([1.3734008, 1.2490457, 1.1659045, 1.1071488], u.rad), + Quantity([1.3734008, 1.2490457, 1.1659045, 1.1071488], "rad"), ) - assert qnp.array_equal(cylindrical.z, Quantity([9.0, 10, 11, 12], u.kpc)) + assert qnp.array_equal(cylindrical.z, Quantity([9.0, 10, 11, 12], "kpc")) def test_cartesian3d_to_cylindrical_astropy(self, vector, apyvector): """Test Astropy equivalence.""" - cyl = vector.represent_as(CylindricalVector) + cyl = vector.represent_as(cx.CylindricalVector) apycyl = apyvector.represent_as(apyc.CylindricalRepresentation) - assert np.allclose(convert(cyl.rho, u.Quantity), apycyl.rho) - assert np.allclose(convert(cyl.z, u.Quantity), apycyl.z) - assert np.allclose(convert(cyl.phi, u.Quantity), apycyl.phi) + assert np.allclose(convert(cyl.rho, APYQuantity), apycyl.rho) + assert np.allclose(convert(cyl.z, APYQuantity), apycyl.z) + assert np.allclose(convert(cyl.phi, APYQuantity), apycyl.phi) class TestSphericalVector(Abstract3DVectorTest): """Test :class:`coordinax.SphericalVector`.""" @pytest.fixture(scope="class") - def vector(self) -> SphericalVector: + def vector(self) -> cx.SphericalVector: """Return a vector.""" - return SphericalVector( - r=Quantity([1, 2, 3, 4], u.kpc), - phi=Quantity([0, 65, 135, 270], u.deg), - theta=Quantity([0, 36, 142, 180], u.deg), + return cx.SphericalVector( + r=Quantity([1, 2, 3, 4], "kpc"), + phi=Quantity([0, 65, 135, 270], "deg"), + theta=Quantity([0, 36, 142, 180], "deg"), ) @pytest.fixture(scope="class") - def apyvector(self, vector: AbstractVector): + def apyvector(self, vector: cx.AbstractVector): """Return an Astropy vector.""" return convert(vector, apyc.PhysicsSphericalRepresentation) @@ -231,47 +214,49 @@ def apyvector(self, vector: AbstractVector): @pytest.mark.filterwarnings("ignore:Irreversible dimension change") def test_spherical_to_cartesian1d(self, vector): """Test ``coordinax.represent_as(Cartesian1DVector)``.""" - cart1d = vector.represent_as(Cartesian1DVector) + cart1d = vector.represent_as(cx.Cartesian1DVector) - assert isinstance(cart1d, Cartesian1DVector) + assert isinstance(cart1d, cx.Cartesian1DVector) assert jnp.allclose( - cart1d.x.to_value(u.kpc), + cart1d.x.to_value("kpc"), xp.asarray([0, 0.49681753, -1.3060151, -4.1700245e-15]), ) @pytest.mark.filterwarnings("ignore:Irreversible dimension change") def test_spherical_to_radial(self, vector): """Test ``coordinax.represent_as(RadialVector)``.""" - radial = vector.represent_as(RadialVector) + radial = vector.represent_as(cx.RadialVector) - assert isinstance(radial, RadialVector) - assert qnp.array_equal(radial.r, Quantity([1, 2, 3, 4], u.kpc)) + assert isinstance(radial, cx.RadialVector) + 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)``.""" - cart2d = vector.represent_as(Cartesian2DVector, y=Quantity([5, 6, 7, 8], u.km)) + cart2d = vector.represent_as( + cx.Cartesian2DVector, y=Quantity([5, 6, 7, 8], "km") + ) - assert isinstance(cart2d, Cartesian2DVector) + assert isinstance(cart2d, cx.Cartesian2DVector) assert qnp.array_equal( cart2d.x, - Quantity([0, 0.49681753, -1.3060151, -4.1700245e-15], u.kpc), + Quantity([0, 0.49681753, -1.3060151, -4.1700245e-15], "kpc"), ) assert qnp.array_equal( - cart2d.y, Quantity([0.0, 1.0654287, 1.3060151, 3.4969111e-07], u.kpc) + cart2d.y, Quantity([0.0, 1.0654287, 1.3060151, 3.4969111e-07], "kpc") ) @pytest.mark.filterwarnings("ignore:Irreversible dimension change") def test_spherical_to_polar(self, vector): """Test ``coordinax.represent_as(PolarVector)``.""" - polar = vector.represent_as(PolarVector, phi=Quantity([0, 1, 2, 3], u.rad)) + polar = vector.represent_as(cx.PolarVector, phi=Quantity([0, 1, 2, 3], "rad")) - assert isinstance(polar, PolarVector) + assert isinstance(polar, cx.PolarVector) assert qnp.array_equal( polar.r, - Quantity([0.0, 1.1755705, 1.8469844, -3.4969111e-07], u.kpc), + Quantity([0.0, 1.1755705, 1.8469844, -3.4969111e-07], "kpc"), ) - assert qnp.array_equal(polar.phi, Quantity([0.0, 65.0, 135.0, 270.0], u.deg)) + assert qnp.array_equal(polar.phi, Quantity([0.0, 65.0, 135.0, 270.0], "deg")) # @pytest.mark.filterwarnings("ignore:Irreversible dimension change") # def test_spherical_to_lnpolar(self, vector): @@ -285,93 +270,93 @@ def test_spherical_to_polar(self, vector): def test_spherical_to_cartesian3d(self, vector): """Test ``coordinax.represent_as(Cartesian3DVector)``.""" - cart3d = vector.represent_as(Cartesian3DVector) + cart3d = vector.represent_as(cx.Cartesian3DVector) - assert isinstance(cart3d, Cartesian3DVector) + assert isinstance(cart3d, cx.Cartesian3DVector) assert qnp.array_equal( - cart3d.x, Quantity([0, 0.49681753, -1.3060151, -4.1700245e-15], u.kpc) + cart3d.x, Quantity([0, 0.49681753, -1.3060151, -4.1700245e-15], "kpc") ) assert qnp.array_equal( - cart3d.y, Quantity([0.0, 1.0654287, 1.3060151, 3.4969111e-07], u.kpc) + cart3d.y, Quantity([0.0, 1.0654287, 1.3060151, 3.4969111e-07], "kpc") ) assert qnp.array_equal( - cart3d.z, Quantity([1.0, 1.618034, -2.3640323, -4.0], u.kpc) + cart3d.z, Quantity([1.0, 1.618034, -2.3640323, -4.0], "kpc") ) def test_spherical_to_cartesian3d_astropy(self, vector, apyvector): """Test Astropy equivalence.""" - cart3d = vector.represent_as(Cartesian3DVector) + cart3d = vector.represent_as(cx.Cartesian3DVector) apycart3 = apyvector.represent_as(apyc.CartesianRepresentation) - assert np.allclose(convert(cart3d.x, u.Quantity), apycart3.x) - assert np.allclose(convert(cart3d.y, u.Quantity), apycart3.y) - assert np.allclose(convert(cart3d.z, u.Quantity), apycart3.z) + assert np.allclose(convert(cart3d.x, APYQuantity), apycart3.x) + assert np.allclose(convert(cart3d.y, APYQuantity), apycart3.y) + assert np.allclose(convert(cart3d.z, APYQuantity), apycart3.z) def test_spherical_to_spherical(self, vector): """Test ``coordinax.represent_as(SphericalVector)``.""" # Jit can copy - newvec = vector.represent_as(SphericalVector) + newvec = vector.represent_as(cx.SphericalVector) assert newvec == vector # The normal `represent_as` method should return the same object - newvec = represent_as(vector, SphericalVector) + newvec = cx.represent_as(vector, cx.SphericalVector) assert newvec is vector def test_spherical_to_spherical_astropy(self, vector, apyvector): """Test Astropy equivalence.""" - sph = vector.represent_as(SphericalVector) + sph = vector.represent_as(cx.SphericalVector) apysph = apyvector.represent_as(apyc.PhysicsSphericalRepresentation) - assert np.allclose(convert(sph.r, u.Quantity), apysph.r) - assert np.allclose(convert(sph.theta, u.Quantity), apysph.theta) - assert np.allclose(convert(sph.phi, u.Quantity), apysph.phi) + 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_spherical_to_cylindrical(self, vector): """Test ``coordinax.represent_as(CylindricalVector)``.""" cylindrical = vector.represent_as( - CylindricalVector, z=Quantity([9, 10, 11, 12], u.m) + cx.CylindricalVector, z=Quantity([9, 10, 11, 12], "m") ) - assert isinstance(cylindrical, CylindricalVector) + assert isinstance(cylindrical, cx.CylindricalVector) assert qnp.array_equal( cylindrical.rho, - Quantity([0.0, 1.1755705, 1.8469844, 3.4969111e-07], u.kpc), + Quantity([0.0, 1.1755705, 1.8469844, 3.4969111e-07], "kpc"), ) assert qnp.array_equal( - cylindrical.phi, Quantity([0.0, 65.0, 135.0, 270.0], u.deg) + cylindrical.phi, Quantity([0.0, 65.0, 135.0, 270.0], "deg") ) assert qnp.array_equal( - cylindrical.z, Quantity([1.0, 1.618034, -2.3640323, -4.0], u.kpc) + cylindrical.z, Quantity([1.0, 1.618034, -2.3640323, -4.0], "kpc") ) def test_spherical_to_cylindrical_astropy(self, vector, apyvector): """Test ``coordinax.represent_as(CylindricalVector)``.""" - cyl = vector.represent_as(CylindricalVector, z=Quantity([9, 10, 11, 12], u.m)) + cyl = vector.represent_as( + cx.CylindricalVector, z=Quantity([9, 10, 11, 12], "m") + ) apycyl = apyvector.represent_as(apyc.CylindricalRepresentation) - assert np.allclose(convert(cyl.rho, u.Quantity), apycyl.rho) - assert np.allclose(convert(cyl.z, u.Quantity), apycyl.z) + assert np.allclose(convert(cyl.rho, APYQuantity), apycyl.rho) + assert np.allclose(convert(cyl.z, APYQuantity), apycyl.z) with pytest.raises(AssertionError): # TODO: Fix this - assert np.allclose(convert(cyl.phi, u.Quantity), apycyl.phi) + assert np.allclose(convert(cyl.phi, APYQuantity), apycyl.phi) class TestCylindricalVector(Abstract3DVectorTest): """Test :class:`coordinax.CylindricalVector`.""" @pytest.fixture(scope="class") - def vector(self) -> AbstractVector: + def vector(self) -> cx.AbstractVector: """Return a vector.""" - from coordinax import CylindricalVector - - return CylindricalVector( - rho=Quantity([1, 2, 3, 4], u.kpc), - phi=Quantity([0, 1, 2, 3], u.rad), - z=Quantity([9, 10, 11, 12], u.m), + return cx.CylindricalVector( + rho=Quantity([1, 2, 3, 4], "kpc"), + phi=Quantity([0, 1, 2, 3], "rad"), + z=Quantity([9, 10, 11, 12], "m"), ) @pytest.fixture(scope="class") - def apyvector(self, vector: AbstractVector): + def apyvector(self, vector: cx.AbstractVector): """Return an Astropy vector.""" return convert(vector, apyc.CylindricalRepresentation) @@ -381,42 +366,42 @@ def apyvector(self, vector: AbstractVector): @pytest.mark.filterwarnings("ignore:Irreversible dimension change") def test_cylindrical_to_cartesian1d(self, vector): """Test ``coordinax.represent_as(Cartesian1DVector)``.""" - cart1d = vector.represent_as(Cartesian1DVector) + cart1d = vector.represent_as(cx.Cartesian1DVector) - assert isinstance(cart1d, Cartesian1DVector) + assert isinstance(cart1d, cx.Cartesian1DVector) assert jnp.allclose( - cart1d.x.to_value(u.kpc), xp.asarray([1.0, 1.0806047, -1.2484405, -3.95997]) + cart1d.x.to_value("kpc"), xp.asarray([1.0, 1.0806047, -1.2484405, -3.95997]) ) @pytest.mark.filterwarnings("ignore:Irreversible dimension change") def test_cylindrical_to_radial(self, vector): """Test ``coordinax.represent_as(RadialVector)``.""" - radial = vector.represent_as(RadialVector) + radial = vector.represent_as(cx.RadialVector) - assert isinstance(radial, RadialVector) - assert qnp.array_equal(radial.r, Quantity([1, 2, 3, 4], u.kpc)) + assert isinstance(radial, cx.RadialVector) + 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(Cartesian2DVector) + cart2d = vector.represent_as(cx.Cartesian2DVector) - assert isinstance(cart2d, Cartesian2DVector) + assert isinstance(cart2d, cx.Cartesian2DVector) assert qnp.array_equal( - cart2d.x, Quantity([1.0, 1.0806046, -1.2484405, -3.95997], u.kpc) + cart2d.x, Quantity([1.0, 1.0806046, -1.2484405, -3.95997], "kpc") ) assert qnp.array_equal( - cart2d.y, Quantity([0.0, 1.6829419, 2.7278922, 0.56448], u.kpc) + cart2d.y, Quantity([0.0, 1.6829419, 2.7278922, 0.56448], "kpc") ) @pytest.mark.filterwarnings("ignore:Irreversible dimension change") def test_cylindrical_to_polar(self, vector): """Test ``coordinax.represent_as(PolarVector)``.""" - polar = vector.represent_as(PolarVector) + polar = vector.represent_as(cx.PolarVector) - assert isinstance(polar, PolarVector) - assert qnp.array_equal(polar.r, Quantity([1, 2, 3, 4], u.kpc)) - assert qnp.array_equal(polar.phi, Quantity([0, 1, 2, 3], u.rad)) + assert isinstance(polar, cx.PolarVector) + assert qnp.array_equal(polar.r, Quantity([1, 2, 3, 4], "kpc")) + assert qnp.array_equal(polar.phi, Quantity([0, 1, 2, 3], "rad")) # @pytest.mark.filterwarnings("ignore:Irreversible dimension change") # def test_cylindrical_to_lnpolar(self, vector): @@ -430,61 +415,61 @@ def test_cylindrical_to_polar(self, vector): def test_cylindrical_to_cartesian3d(self, vector): """Test ``coordinax.represent_as(Cartesian3DVector)``.""" - cart3d = vector.represent_as(Cartesian3DVector) + cart3d = vector.represent_as(cx.Cartesian3DVector) - assert isinstance(cart3d, Cartesian3DVector) + assert isinstance(cart3d, cx.Cartesian3DVector) assert qnp.array_equal( - cart3d.x, Quantity([1.0, 1.0806046, -1.2484405, -3.95997], u.kpc) + cart3d.x, Quantity([1.0, 1.0806046, -1.2484405, -3.95997], "kpc") ) assert qnp.array_equal( - cart3d.y, Quantity([0.0, 1.6829419, 2.7278922, 0.56448], u.kpc) + cart3d.y, Quantity([0.0, 1.6829419, 2.7278922, 0.56448], "kpc") ) assert qnp.array_equal(cart3d.z, vector.z) def test_cylindrical_to_cartesian3d_astropy(self, vector, apyvector): """Test Astropy equivalence.""" - cart3d = vector.represent_as(Cartesian3DVector) + cart3d = vector.represent_as(cx.Cartesian3DVector) apycart3 = apyvector.represent_as(apyc.CartesianRepresentation) - assert np.allclose(convert(cart3d.x, u.Quantity), apycart3.x) - assert np.allclose(convert(cart3d.y, u.Quantity), apycart3.y) - assert np.allclose(convert(cart3d.z, u.Quantity), apycart3.z) + assert np.allclose(convert(cart3d.x, APYQuantity), apycart3.x) + assert np.allclose(convert(cart3d.y, APYQuantity), apycart3.y) + 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(SphericalVector) + spherical = vector.represent_as(cx.SphericalVector) - assert isinstance(spherical, SphericalVector) - assert qnp.array_equal(spherical.r, Quantity([1, 2, 3, 4], u.kpc)) - assert qnp.array_equal(spherical.phi, Quantity([0, 1, 2, 3], u.rad)) - assert qnp.array_equal(spherical.theta, Quantity(xp.full(4, xp.pi / 2), u.rad)) + assert isinstance(spherical, cx.SphericalVector) + assert qnp.array_equal(spherical.r, Quantity([1, 2, 3, 4], "kpc")) + assert qnp.array_equal(spherical.phi, Quantity([0, 1, 2, 3], "rad")) + assert qnp.array_equal(spherical.theta, Quantity(xp.full(4, xp.pi / 2), "rad")) def test_cylindrical_to_spherical_astropy(self, vector, apyvector): """Test Astropy equivalence.""" - sph = vector.represent_as(SphericalVector) + sph = vector.represent_as(cx.SphericalVector) apysph = apyvector.represent_as(apyc.PhysicsSphericalRepresentation) - assert np.allclose(convert(sph.r, u.Quantity), apysph.r) - assert np.allclose(convert(sph.theta, u.Quantity), apysph.theta) - assert np.allclose(convert(sph.phi, u.Quantity), apysph.phi) + 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)``.""" # Jit can copy - newvec = vector.represent_as(CylindricalVector) + newvec = vector.represent_as(cx.CylindricalVector) assert newvec == vector # The normal `represent_as` method should return the same object - newvec = represent_as(vector, CylindricalVector) + newvec = cx.represent_as(vector, cx.CylindricalVector) assert newvec is vector def test_cylindrical_to_cylindrical_astropy(self, vector, apyvector): """Test Astropy equivalence.""" - cyl = vector.represent_as(CylindricalVector) + cyl = vector.represent_as(cx.CylindricalVector) apycyl = apyvector.represent_as(apyc.CylindricalRepresentation) - assert np.allclose(convert(cyl.rho, u.Quantity), apycyl.rho) - assert np.allclose(convert(cyl.z, u.Quantity), apycyl.z) - assert np.allclose(convert(cyl.phi, u.Quantity), apycyl.phi) + assert np.allclose(convert(cyl.rho, APYQuantity), apycyl.rho) + assert np.allclose(convert(cyl.z, APYQuantity), apycyl.z) + assert np.allclose(convert(cyl.phi, APYQuantity), apycyl.phi) class Abstract3DVectorDifferentialTest(AbstractVectorDifferentialTest): @@ -494,7 +479,7 @@ class Abstract3DVectorDifferentialTest(AbstractVectorDifferentialTest): # Unary operations def test_neg_compare_apy( - self, difntl: AbstractVector, apydifntl: apyc.BaseRepresentation + self, difntl: cx.AbstractVector, apydifntl: apyc.BaseRepresentation ): """Test negation.""" assert all(representation_equal(convert(-difntl, type(apydifntl)), -apydifntl)) @@ -504,30 +489,30 @@ class TestCartesianDifferential3D(Abstract3DVectorDifferentialTest): """Test :class:`coordinax.CartesianDifferential3D`.""" @pytest.fixture(scope="class") - def difntl(self) -> CartesianDifferential3D: + def difntl(self) -> cx.CartesianDifferential3D: """Return a differential.""" - return CartesianDifferential3D( - d_x=Quantity([1, 2, 3, 4], u.km / u.s), - d_y=Quantity([5, 6, 7, 8], u.km / u.s), - d_z=Quantity([9, 10, 11, 12], u.km / u.s), + return cx.CartesianDifferential3D( + d_x=Quantity([1, 2, 3, 4], "km/s"), + d_y=Quantity([5, 6, 7, 8], "km/s"), + d_z=Quantity([9, 10, 11, 12], "km/s"), ) @pytest.fixture(scope="class") - def vector(self) -> Cartesian3DVector: + def vector(self) -> cx.Cartesian3DVector: """Return a vector.""" - return Cartesian3DVector( - x=Quantity([1, 2, 3, 4], u.kpc), - y=Quantity([5, 6, 7, 8], u.kpc), - z=Quantity([9, 10, 11, 12], u.kpc), + return cx.Cartesian3DVector( + 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: CartesianDifferential3D): + def apydifntl(self, difntl: cx.CartesianDifferential3D): """Return an Astropy differential.""" return convert(difntl, apyc.CartesianDifferential) @pytest.fixture(scope="class") - def apyvector(self, vector: Cartesian3DVector): + def apyvector(self, vector: cx.Cartesian3DVector): """Return an Astropy vector.""" return convert(vector, apyc.CartesianRepresentation) @@ -537,75 +522,75 @@ def apyvector(self, vector: Cartesian3DVector): @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_cartesian3d_to_cartesian1d(self, difntl, vector): """Test ``coordinax.represent_as(Cartesian1DVector)``.""" - cart1d = difntl.represent_as(CartesianDifferential1D, vector) + cart1d = difntl.represent_as(cx.CartesianDifferential1D, vector) - assert isinstance(cart1d, CartesianDifferential1D) - assert qnp.array_equal(cart1d.d_x, Quantity([1, 2, 3, 4], u.km / u.s)) + assert isinstance(cart1d, cx.CartesianDifferential1D) + 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(RadialVector, vector) + radial = difntl.represent_as(cx.RadialVector, vector) - assert isinstance(radial, RadialVector) - assert qnp.array_equal(radial.d_r, Quantity([1, 2, 3, 4], u.km / u.s)) + assert isinstance(radial, cx.RadialVector) + 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(CartesianDifferential2D, vector) + cart2d = difntl.represent_as(cx.CartesianDifferential2D, vector) - assert isinstance(cart2d, CartesianDifferential2D) - assert qnp.array_equal(cart2d.d_x, Quantity([1, 2, 3, 4], u.km / u.s)) - assert qnp.array_equal(cart2d.d_y, Quantity([5, 6, 7, 8], u.km / u.s)) + assert isinstance(cart2d, cx.CartesianDifferential2D) + 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(PolarVector, vector) + polar = difntl.represent_as(cx.PolarVector, vector) - assert isinstance(polar, PolarVector) - assert qnp.array_equal(polar.d_r, Quantity([1, 2, 3, 4], u.km / u.s)) - assert qnp.array_equal(polar.d_phi, Quantity([5, 6, 7, 8], u.mas / u.yr)) + assert isinstance(polar, cx.PolarVector) + 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)``.""" # Jit can copy - newvec = difntl.represent_as(CartesianDifferential3D, vector) + newvec = difntl.represent_as(cx.CartesianDifferential3D, vector) assert newvec == difntl # The normal `represent_as` method should return the same object - newvec = represent_as(difntl, CartesianDifferential3D, vector) + newvec = cx.represent_as(difntl, cx.CartesianDifferential3D, vector) assert newvec is difntl def test_cartesian3d_to_cartesian3d_astropy( self, difntl, vector, apydifntl, apyvector ): """Test Astropy equivalence.""" - cart3 = difntl.represent_as(CartesianDifferential3D, vector) + cart3 = difntl.represent_as(cx.CartesianDifferential3D, vector) apycart3 = apydifntl.represent_as(apyc.CartesianDifferential, apyvector) - assert np.allclose(convert(cart3.d_x, u.Quantity), apycart3.d_x) - assert np.allclose(convert(cart3.d_y, u.Quantity), apycart3.d_y) - assert np.allclose(convert(cart3.d_z, u.Quantity), apycart3.d_z) + assert np.allclose(convert(cart3.d_x, APYQuantity), apycart3.d_x) + assert np.allclose(convert(cart3.d_y, APYQuantity), apycart3.d_y) + 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(SphericalDifferential, vector) + spherical = difntl.represent_as(cx.SphericalDifferential, vector) - assert isinstance(spherical, SphericalDifferential) + assert isinstance(spherical, cx.SphericalDifferential) assert jnp.allclose( - spherical.d_r.to_value(u.km / u.s), + spherical.d_r.to_value("km/s"), xp.asarray([10.344081, 11.832159, 13.379088, 14.966629]), ) assert jnp.allclose( - spherical.d_phi.to_value(u.mas / u.Myr), xp.asarray([0, 0, 0.00471509, 0]) + spherical.d_phi.to_value("mas/Myr"), xp.asarray([0, 0, 0.00471509, 0]) ) assert jnp.allclose( - spherical.d_theta.to_value(u.mas / u.Myr), + spherical.d_theta.to_value("mas/Myr"), xp.asarray([0.03221978, -0.05186598, -0.01964621, -0.01886036]), ) @@ -613,79 +598,81 @@ def test_cartesian3d_to_spherical_astropy( self, difntl, vector, apydifntl, apyvector ): """Test Astropy equivalence.""" - sph = difntl.represent_as(SphericalDifferential, vector) + sph = difntl.represent_as(cx.SphericalDifferential, vector) apysph = apydifntl.represent_as(apyc.PhysicsSphericalDifferential, apyvector) - assert np.allclose(convert(sph.d_r, u.Quantity), apysph.d_r) + assert np.allclose(convert(sph.d_r, APYQuantity), apysph.d_r) with pytest.raises(AssertionError): # TODO: fixme assert np.allclose( - convert(sph.d_theta, u.Quantity).to(u.mas / u.Myr), - apysph.d_theta.to(u.mas / u.Myr), + convert(sph.d_theta, APYQuantity).to("mas/Myr"), + apysph.d_theta.to("mas/Myr"), atol=1e-9, ) with pytest.raises(AssertionError): # TODO: fixme assert np.allclose( - convert(sph.d_phi, u.Quantity).to(u.mas / u.Myr), - apysph.d_phi.to(u.mas / u.Myr), + convert(sph.d_phi, APYQuantity).to("mas/Myr"), + apysph.d_phi.to("mas/Myr"), atol=1e-7, ) def test_cartesian3d_to_cylindrical(self, difntl, vector): """Test ``coordinax.represent_as(CylindricalDifferential)``.""" - cylindrical = difntl.represent_as(CylindricalDifferential, vector) + cylindrical = difntl.represent_as(cx.CylindricalDifferential, vector) - assert isinstance(cylindrical, CylindricalDifferential) + assert isinstance(cylindrical, cx.CylindricalDifferential) assert qnp.array_equal( cylindrical.d_rho, - Quantity([5.0990195, 6.324555, 7.6157727, 8.944272], u.km / u.s), + Quantity([5.0990195, 6.324555, 7.6157727, 8.944272], "km/s"), ) assert jnp.allclose( - cylindrical.d_phi.to_value(u.mas / u.Myr), xp.asarray([0, 0, 0.00471509, 0]) + cylindrical.d_phi.to_value("mas/Myr"), xp.asarray([0, 0, 0.00471509, 0]) ) - assert qnp.array_equal(cylindrical.d_z, Quantity([9, 10, 11, 12], u.km / u.s)) + assert qnp.array_equal(cylindrical.d_z, Quantity([9, 10, 11, 12], "km/s")) def test_cartesian3d_to_cylindrical_astropy( self, difntl, vector, apydifntl, apyvector ): """Test Astropy equivalence.""" - cyl = difntl.represent_as(CylindricalDifferential, vector) + cyl = difntl.represent_as(cx.CylindricalDifferential, vector) apycyl = apydifntl.represent_as(apyc.CylindricalDifferential, apyvector) - assert np.allclose(convert(cyl.d_rho, u.Quantity), apycyl.d_rho) - assert np.allclose(convert(cyl.d_z, u.Quantity), apycyl.d_z) + assert np.allclose(convert(cyl.d_rho, APYQuantity), apycyl.d_rho) + assert np.allclose(convert(cyl.d_z, APYQuantity), apycyl.d_z) with pytest.raises(AssertionError): # TODO: fixme - assert np.allclose(convert(cyl.d_phi, u.Quantity), apycyl.d_phi) + assert np.allclose(convert(cyl.d_phi, APYQuantity), apycyl.d_phi) class TestSphericalDifferential(Abstract3DVectorDifferentialTest): """Test :class:`coordinax.SphericalDifferential`.""" @pytest.fixture(scope="class") - def difntl(self) -> SphericalDifferential: + def difntl(self) -> cx.SphericalDifferential: """Return a differential.""" - return SphericalDifferential( - d_r=Quantity([1, 2, 3, 4], u.km / u.s), - d_phi=Quantity([5, 6, 7, 8], u.mas / u.yr), - d_theta=Quantity([9, 10, 11, 12], u.mas / u.yr), + return cx.SphericalDifferential( + d_r=Quantity([1, 2, 3, 4], "km/s"), + d_phi=Quantity([5, 6, 7, 8], "mas/yr"), + d_theta=Quantity([9, 10, 11, 12], "mas/yr"), ) @pytest.fixture(scope="class") - def vector(self) -> SphericalVector: + def vector(self) -> cx.SphericalVector: """Return a vector.""" - return SphericalVector( - r=Quantity([1, 2, 3, 4], u.kpc), - phi=Quantity([0, 42, 160, 270], u.deg), - theta=Quantity([3, 63, 90, 179.5], u.deg), + return cx.SphericalVector( + r=Quantity([1, 2, 3, 4], "kpc"), + phi=Quantity([0, 42, 160, 270], "deg"), + theta=Quantity([3, 63, 90, 179.5], "deg"), ) @pytest.fixture(scope="class") def apydifntl( - self, difntl: SphericalDifferential + self, difntl: cx.SphericalDifferential ) -> apyc.PhysicsSphericalDifferential: """Return an Astropy differential.""" return convert(difntl, apyc.PhysicsSphericalDifferential) @pytest.fixture(scope="class") - def apyvector(self, vector: SphericalVector) -> apyc.PhysicsSphericalRepresentation: + def apyvector( + self, vector: cx.SphericalVector + ) -> apyc.PhysicsSphericalRepresentation: """Return an Astropy vector.""" return convert(vector, apyc.PhysicsSphericalRepresentation) @@ -695,141 +682,141 @@ def apyvector(self, vector: SphericalVector) -> apyc.PhysicsSphericalRepresentat @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_spherical_to_cartesian1d(self, difntl, vector): """Test ``coordinax.represent_as(Cartesian1DVector)``.""" - cart1d = difntl.represent_as(CartesianDifferential1D, vector) + cart1d = difntl.represent_as(cx.CartesianDifferential1D, vector) - assert isinstance(cart1d, CartesianDifferential1D) - assert qnp.array_equal(cart1d.d_x, Quantity([1, 2, 3, 4], u.km / u.s)) + assert isinstance(cart1d, cx.CartesianDifferential1D) + 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(RadialVector, vector) + radial = difntl.represent_as(cx.RadialVector, vector) - assert isinstance(radial, RadialVector) - assert qnp.array_equal(radial.d_r, Quantity([1, 2, 3, 4], u.km / u.s)) + assert isinstance(radial, cx.RadialVector) + 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(CartesianDifferential2D, vector) + cart2d = difntl.represent_as(cx.CartesianDifferential2D, vector) - assert isinstance(cart2d, CartesianDifferential2D) - assert qnp.array_equal(cart2d.d_x, Quantity([1, 2, 3, 4], u.km / u.s)) - assert qnp.array_equal(cart2d.d_y, Quantity([5, 6, 7, 8], u.km / u.s)) + assert isinstance(cart2d, cx.CartesianDifferential2D) + 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(PolarVector, vector) + polar = difntl.represent_as(cx.PolarVector, vector) - assert isinstance(polar, PolarVector) - assert qnp.array_equal(polar.d_r, Quantity([1, 2, 3, 4], u.km / u.s)) - assert qnp.array_equal(polar.d_phi, Quantity([5, 6, 7, 8], u.mas / u.yr)) + assert isinstance(polar, cx.PolarVector) + 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(CartesianDifferential3D, vector) + cart3d = difntl.represent_as(cx.CartesianDifferential3D, vector) - assert isinstance(cart3d, CartesianDifferential3D) + assert isinstance(cart3d, cx.CartesianDifferential3D) assert qnp.array_equal( cart3d.d_x, - Quantity([42.658096, -0.6040496, -36.867138, 1.323785], u.km / u.s), + Quantity([42.658096, -0.6040496, -36.867138, 1.323785], "km/s"), ) assert qnp.array_equal( cart3d.d_y, - Quantity([1.2404853, 67.66016, -92.52022, 227.499], u.km / u.s), + Quantity([1.2404853, 67.66016, -92.52022, 227.499], "km/s"), ) assert qnp.array_equal( cart3d.d_z, - Quantity([-1.2342439, -83.56782, -156.43553, -5.985529], u.km / u.s), + Quantity([-1.2342439, -83.56782, -156.43553, -5.985529], "km/s"), ) def test_spherical_to_cartesian3d_astropy( self, difntl, vector, apydifntl, apyvector ): """Test Astropy equivalence.""" - cart3d = difntl.represent_as(CartesianDifferential3D, vector) + cart3d = difntl.represent_as(cx.CartesianDifferential3D, vector) apycart3 = apydifntl.represent_as(apyc.CartesianDifferential, apyvector) - assert np.allclose(convert(cart3d.d_x, u.Quantity), apycart3.d_x) - assert np.allclose(convert(cart3d.d_y, u.Quantity), apycart3.d_y) - assert np.allclose(convert(cart3d.d_z, u.Quantity), apycart3.d_z) + assert np.allclose(convert(cart3d.d_x, APYQuantity), apycart3.d_x) + assert np.allclose(convert(cart3d.d_y, APYQuantity), apycart3.d_y) + assert np.allclose(convert(cart3d.d_z, APYQuantity), apycart3.d_z) def test_spherical_to_spherical(self, difntl, vector): """Test ``coordinax.represent_as(SphericalDifferential)``.""" # Jit can copy - newvec = difntl.represent_as(SphericalDifferential, vector) + newvec = difntl.represent_as(cx.SphericalDifferential, vector) assert newvec == difntl # The normal `represent_as` method should return the same object - newvec = represent_as(difntl, SphericalDifferential, vector) + newvec = cx.represent_as(difntl, cx.SphericalDifferential, vector) assert newvec is difntl def test_spherical_to_spherical_astropy(self, difntl, vector, apydifntl, apyvector): """Test Astropy equivalence.""" - sph = difntl.represent_as(SphericalDifferential, vector) + sph = difntl.represent_as(cx.SphericalDifferential, vector) apysph = apydifntl.represent_as(apyc.PhysicsSphericalDifferential, apyvector) - assert np.allclose(convert(sph.d_r, u.Quantity), apysph.d_r) - assert np.allclose(convert(sph.d_theta, u.Quantity), apysph.d_theta) - assert np.allclose(convert(sph.d_phi, u.Quantity), apysph.d_phi) + 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_cylindrical(self, difntl, vector): """Test ``coordinax.represent_as(CylindricalDifferential)``.""" - cylindrical = difntl.represent_as(CylindricalDifferential, vector) + cylindrical = difntl.represent_as(cx.CylindricalDifferential, vector) - assert isinstance(cylindrical, CylindricalDifferential) + assert isinstance(cylindrical, cx.CylindricalDifferential) assert qnp.array_equal( cylindrical.d_rho, - Quantity([42.658096, 44.824585, 2.999993, -227.499], u.km / u.s), + Quantity([42.658096, 44.824585, 2.999993, -227.499], "km/s"), ) - assert qnp.array_equal(cylindrical.d_phi, Quantity([5, 6, 7, 8], u.mas / u.yr)) + assert qnp.array_equal(cylindrical.d_phi, Quantity([5, 6, 7, 8], "mas/yr")) assert qnp.array_equal( cylindrical.d_z, - Quantity([-1.2342439, -83.56782, -156.43553, -5.985529], u.km / u.s), + Quantity([-1.2342439, -83.56782, -156.43553, -5.985529], "km/s"), ) def test_spherical_to_cylindrical_astropy( self, difntl, vector, apydifntl, apyvector ): """Test Astropy equivalence.""" - cyl = difntl.represent_as(CylindricalDifferential, vector) + cyl = difntl.represent_as(cx.CylindricalDifferential, vector) apycyl = apydifntl.represent_as(apyc.CylindricalDifferential, apyvector) - assert np.allclose(convert(cyl.d_rho, u.Quantity), apycyl.d_rho) - assert np.allclose(convert(cyl.d_z, u.Quantity), apycyl.d_z) - assert np.allclose(convert(cyl.d_phi, u.Quantity), apycyl.d_phi) + assert np.allclose(convert(cyl.d_rho, APYQuantity), apycyl.d_rho) + assert np.allclose(convert(cyl.d_z, APYQuantity), apycyl.d_z) + assert np.allclose(convert(cyl.d_phi, APYQuantity), apycyl.d_phi) class TestCylindricalDifferential(Abstract3DVectorDifferentialTest): """Test :class:`coordinax.CylindricalDifferential`.""" @pytest.fixture(scope="class") - def difntl(self) -> CylindricalDifferential: + def difntl(self) -> cx.CylindricalDifferential: """Return a differential.""" - return CylindricalDifferential( - d_rho=Quantity([1, 2, 3, 4], u.km / u.s), - d_phi=Quantity([5, 6, 7, 8], u.mas / u.yr), - d_z=Quantity([9, 10, 11, 12], u.km / u.s), + return cx.CylindricalDifferential( + d_rho=Quantity([1, 2, 3, 4], "km/s"), + d_phi=Quantity([5, 6, 7, 8], "mas/yr"), + d_z=Quantity([9, 10, 11, 12], "km/s"), ) @pytest.fixture(scope="class") - def vector(self) -> CylindricalVector: + def vector(self) -> cx.CylindricalVector: """Return a vector.""" - return CylindricalVector( - rho=Quantity([1, 2, 3, 4], u.kpc), - phi=Quantity([0, 1, 2, 3], u.rad), - z=Quantity([9, 10, 11, 12], u.kpc), + return cx.CylindricalVector( + 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: CylindricalDifferential): + def apydifntl(self, difntl: cx.CylindricalDifferential): """Return an Astropy differential.""" return convert(difntl, apyc.CylindricalDifferential) @pytest.fixture(scope="class") - def apyvector(self, vector: CylindricalVector) -> apyc.CylindricalRepresentation: + def apyvector(self, vector: cx.CylindricalVector) -> apyc.CylindricalRepresentation: """Return an Astropy vector.""" return convert(vector, apyc.CylindricalRepresentation) @@ -839,71 +826,71 @@ def apyvector(self, vector: CylindricalVector) -> apyc.CylindricalRepresentation @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_cylindrical_to_cartesian1d(self, difntl, vector): """Test ``coordinax.represent_as(Cartesian1DVector)``.""" - cart1d = difntl.represent_as(CartesianDifferential1D, vector) + cart1d = difntl.represent_as(cx.CartesianDifferential1D, vector) - assert isinstance(cart1d, CartesianDifferential1D) - assert qnp.array_equal(cart1d.d_x, Quantity([1, 2, 3, 4], u.km / u.s)) + assert isinstance(cart1d, cx.CartesianDifferential1D) + 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(RadialVector, vector) + radial = difntl.represent_as(cx.RadialVector, vector) - assert isinstance(radial, RadialVector) - assert qnp.array_equal(radial.d_r, Quantity([1, 2, 3, 4], u.km / u.s)) + assert isinstance(radial, cx.RadialVector) + 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(CartesianDifferential2D, vector) + cart2d = difntl.represent_as(cx.CartesianDifferential2D, vector) - assert isinstance(cart2d, CartesianDifferential2D) - assert qnp.array_equal(cart2d.d_x, Quantity([1, 2, 3, 4], u.km / u.s)) - assert qnp.array_equal(cart2d.d_y, Quantity([5, 6, 7, 8], u.km / u.s)) + assert isinstance(cart2d, cx.CartesianDifferential2D) + 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(PolarVector, vector) + polar = difntl.represent_as(cx.PolarVector, vector) - assert isinstance(polar, PolarVector) - assert qnp.array_equal(polar.d_r, Quantity([1, 2, 3, 4], u.km / u.s)) - assert qnp.array_equal(polar.d_phi, Quantity([5, 6, 7, 8], u.mas / u.yr)) + assert isinstance(polar, cx.PolarVector) + 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(CartesianDifferential3D, vector) + cart3d = difntl.represent_as(cx.CartesianDifferential3D, vector) - assert isinstance(cart3d, CartesianDifferential3D) + assert isinstance(cart3d, cx.CartesianDifferential3D) assert qnp.array_equal( - cart3d.d_x, Quantity([1.0, -46.787014, -91.76889, -25.367176], u.km / u.s) + cart3d.d_x, Quantity([1.0, -46.787014, -91.76889, -25.367176], "km/s") ) assert qnp.array_equal( cart3d.d_y, - Quantity([23.702353, 32.418385, -38.69947, -149.61249], u.km / u.s), + Quantity([23.702353, 32.418385, -38.69947, -149.61249], "km/s"), ) - assert qnp.array_equal(cart3d.d_z, Quantity([9, 10, 11, 12], u.km / u.s)) + assert qnp.array_equal(cart3d.d_z, Quantity([9, 10, 11, 12], "km/s")) apycart3 = apydifntl.represent_as(apyc.CartesianDifferential, apyvector) - assert np.allclose(convert(cart3d.d_x, u.Quantity), apycart3.d_x) - assert np.allclose(convert(cart3d.d_y, u.Quantity), apycart3.d_y) - assert np.allclose(convert(cart3d.d_z, u.Quantity), apycart3.d_z) + assert np.allclose(convert(cart3d.d_x, APYQuantity), apycart3.d_x) + assert np.allclose(convert(cart3d.d_y, APYQuantity), apycart3.d_y) + assert np.allclose(convert(cart3d.d_z, APYQuantity), apycart3.d_z) def test_cylindrical_to_spherical(self, difntl, vector): """Test ``coordinax.represent_as(SphericalDifferential)``.""" - spherical = difntl.represent_as(SphericalDifferential, vector) + spherical = difntl.represent_as(cx.SphericalDifferential, vector) - assert isinstance(spherical, SphericalDifferential) + assert isinstance(spherical, cx.SphericalDifferential) assert qnp.array_equal( spherical.d_r, - Quantity([9.055385, 10.198039, 11.401753, 12.64911], u.km / u.s), + Quantity([9.055385, 10.198039, 11.401753, 12.64911], "km/s"), ) - assert qnp.array_equal(spherical.d_phi, Quantity([5, 6, 7, 8], u.mas / u.yr)) + assert qnp.array_equal(spherical.d_phi, Quantity([5, 6, 7, 8], "mas/yr")) assert jnp.allclose( - spherical.d_theta.to_value(u.mas / u.Myr), + spherical.d_theta.to_value("mas/Myr"), xp.asarray([-0.08428223, 0.07544143, -0.0326127, -0.01571696]), ) @@ -911,27 +898,27 @@ def test_cylindrical_to_spherical_astropy( self, difntl, vector, apydifntl, apyvector ): """Test Astropy equivalence.""" - sph = difntl.represent_as(SphericalDifferential, vector) + sph = difntl.represent_as(cx.SphericalDifferential, vector) apysph = apydifntl.represent_as(apyc.PhysicsSphericalDifferential, apyvector) - assert np.allclose(convert(sph.d_r, u.Quantity), apysph.d_r) + assert np.allclose(convert(sph.d_r, APYQuantity), apysph.d_r) with pytest.raises(AssertionError): - assert np.allclose(convert(sph.d_theta, u.Quantity), apysph.d_theta) - assert np.allclose(convert(sph.d_phi, u.Quantity), apysph.d_phi) + 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)``.""" # Jit can copy - newvec = difntl.represent_as(CylindricalDifferential, vector) + newvec = difntl.represent_as(cx.CylindricalDifferential, vector) assert newvec == difntl # The normal `represent_as` method should return the same object - newvec = represent_as(difntl, CylindricalDifferential, vector) + newvec = cx.represent_as(difntl, cx.CylindricalDifferential, vector) assert newvec is difntl def test_cylindrical_to_cylindrical(self, difntl, vector, apydifntl, apyvector): """Test Astropy equivalence.""" - cyl = difntl.represent_as(CylindricalDifferential, vector) + cyl = difntl.represent_as(cx.CylindricalDifferential, vector) apycyl = apydifntl.represent_as(apyc.CylindricalDifferential, apyvector) - assert np.allclose(convert(cyl.d_rho, u.Quantity), apycyl.d_rho) - assert np.allclose(convert(cyl.d_z, u.Quantity), apycyl.d_z) - assert np.allclose(convert(cyl.d_phi, u.Quantity), apycyl.d_phi) + assert np.allclose(convert(cyl.d_rho, APYQuantity), apycyl.d_rho) + assert np.allclose(convert(cyl.d_z, APYQuantity), apycyl.d_z) + assert np.allclose(convert(cyl.d_phi, APYQuantity), apycyl.d_phi) From 8b191e5fbe72efd46bb40408909e9c75ae4163a7 Mon Sep 17 00:00:00 2001 From: nstarman Date: Tue, 19 Mar 2024 12:44:44 -0400 Subject: [PATCH 2/4] feat: improve str Signed-off-by: nstarman --- src/coordinax/_base.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/coordinax/_base.py b/src/coordinax/_base.py index 16e5471e..7420e8e7 100644 --- a/src/coordinax/_base.py +++ b/src/coordinax/_base.py @@ -695,12 +695,12 @@ def __str__(self) -> str: >>> vec = cx.Cartesian3DVector.constructor(Quantity([1, 2, 3], "m")) >>> str(vec) - '' + '' """ cls_name = type(self).__name__ - comps = ", ".join(self.components) - units = ", ".join(map(str, self.units.values())) + units = self.units + comps = ", ".join(f"{c}[{units[c]}]" for c in self.components) vs = np.array2string( xp.stack( tuple(v.value for v in xp.broadcast_arrays(*dataclass_values(self))), @@ -709,7 +709,7 @@ def __str__(self) -> str: precision=3, prefix=" ", ) - return f"<{cls_name} ({comps}) in ({units})\n {vs}>" + return f"<{cls_name} ({comps})\n {vs}>" # ----------------------------------------------- From df37637c7fee8d02b5190e5102805cbc092213f8 Mon Sep 17 00:00:00 2001 From: nstarman Date: Tue, 19 Mar 2024 12:46:21 -0400 Subject: [PATCH 3/4] doc: operate Signed-off-by: nstarman --- src/coordinax/_d3/operate.py | 48 ++++++++++++++++++++++++++++++++---- 1 file changed, 43 insertions(+), 5 deletions(-) diff --git a/src/coordinax/_d3/operate.py b/src/coordinax/_d3/operate.py index 3250461a..31df95e5 100644 --- a/src/coordinax/_d3/operate.py +++ b/src/coordinax/_d3/operate.py @@ -18,9 +18,40 @@ @op_call_dispatch -def call(self: AbstractOperator, x: Q3, /) -> Q3: - """Dispatch to the operator's `__call__` method.""" - return self(Cartesian3DVector.constructor(x)) +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. + + Returns + ------- + x' : Quantity['length', '*#batch 3'] + The operated-upon position vector. + + Examples + -------- + >>> from unxt import Quantity + >>> import coordinax as cx + >>> import coordinax.operators as cxo + + >>> shift = Quantity([1.0, 2.0, 3.0], "kpc") + >>> op = cxo.GalileanSpatialTranslationOperator(shift) + + >>> q = Quantity([0.0, 0, 0], "kpc") + >>> op(q) + Quantity['length'](Array([1., 2., 3.], dtype=float32), unit='kpc') + + Since :meth:`AbstractOperator.__call__` uses multiple dispatch, we + explicitly call this registered method. + + >>> op.__call__._f.resolve_method((op, q))[0](op, q) + Quantity['length'](Array([1., 2., 3.], dtype=float32), unit='kpc') + + """ + return convert( + self(Cartesian3DVector.constructor(q)).represent_as(Cartesian3DVector), Quantity + ) @op_call_dispatch @@ -42,10 +73,17 @@ def call( We can then apply the operator to a position: - >>> pos = Quantity([1.0, 2.0, 3.0], "kpc") + >>> q = Quantity([1.0, 2.0, 3.0], "kpc") >>> t = Quantity(0.0, "Gyr") - >>> op(pos, t) + >>> op(q, t) + (Quantity['length'](Array([2., 4., 6.], dtype=float32), unit='kpc'), + Quantity['time'](Array(0., dtype=float32, ...), unit='Gyr')) + + Since :meth:`AbstractOperator.__call__` uses multiple dispatch, we + explicitly call this registered method. + + >>> op.__call__._f.resolve_method((op, q, t))[0](op, q, t) (Quantity['length'](Array([2., 4., 6.], dtype=float32), unit='kpc'), Quantity['time'](Array(0., dtype=float32, ...), unit='Gyr')) From 1721147d8772f4d2352a58550e72bbd34b198db5 Mon Sep 17 00:00:00 2001 From: nstarman Date: Tue, 19 Mar 2024 13:06:53 -0400 Subject: [PATCH 4/4] docs: self transform Signed-off-by: nstarman --- src/coordinax/_d3/transform.py | 61 ++++++++++++++++++++++++++++++++-- 1 file changed, 59 insertions(+), 2 deletions(-) diff --git a/src/coordinax/_d3/transform.py b/src/coordinax/_d3/transform.py index 34856e08..042ded77 100644 --- a/src/coordinax/_d3/transform.py +++ b/src/coordinax/_d3/transform.py @@ -39,7 +39,34 @@ def represent_as( def represent_as( current: Abstract3DVector, target: type[Abstract3DVector], /, **kwargs: Any ) -> Abstract3DVector: - """Self transform.""" + """Self transforms for 3D vectors. + + Examples + -------- + >>> from unxt import Quantity + >>> import coordinax as cx + + Cartesian to Cartesian: + + >>> vec = cx.Cartesian3DVector.constructor(Quantity([1, 2, 3], "kpc")) + >>> cx.represent_as(vec, cx.Cartesian3DVector) is vec + True + + Spherical to Spherical: + + >>> vec = cx.SphericalVector(r=Quantity(1, "kpc"), theta=Quantity(2, "deg"), + ... phi=Quantity(3, "deg")) + >>> cx.represent_as(vec, cx.SphericalVector) is vec + True + + Cylindrical to Cylindrical: + + >>> vec = cx.CylindricalVector(rho=Quantity(1, "kpc"), phi=Quantity(2, "deg"), + ... z=Quantity(3, "kpc")) + >>> cx.represent_as(vec, cx.CylindricalVector) is vec + True + + """ return current @@ -55,7 +82,37 @@ def represent_as( /, **kwargs: Any, ) -> Abstract3DVectorDifferential: - """Self transform of 3D Differentials.""" + """Self transforms for 3D differentials. + + Examples + -------- + >>> from unxt import Quantity + >>> import coordinax as cx + + 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")) + + Cartesian to Cartesian Differential: + + >>> dif = cx.CartesianDifferential3D.constructor(Quantity([1, 2, 3], "km/s")) + >>> cx.represent_as(dif, cx.CartesianDifferential3D, vec) is dif + True + + >>> dif = cx.SphericalDifferential(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 + True + + >>> dif = cx.CylindricalDifferential(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 + True + + """ return current