coordinax.distance

argmin(*args: Any, **kwargs: Any)#

Return the indices of the minimum value.

Examples

>>> import unxt as u
>>> q = u.Quantity([1, 2, 3], "m")
>>> q.argmin()
Array(0, dtype=int32)

Parameters:

args (Any)
kwargs (Any)

Return type:

astype(*args: Any, **kwargs: Any)#

Copy the array and cast to a specified dtype.

Examples

>>> import unxt as u
>>> q = u.Quantity([1, 2, 3], "m")
>>> q.dtype
dtype('int32')

>>> q.astype(float)
Quantity(Array([1., 2., 3.], dtype=float32), unit='m')

Parameters:

args (Any)
kwargs (Any)

Return type:

property at: _QuantityIndexUpdateHelper#

Helper property for index update functionality.

The at property provides a functionally pure equivalent of in-place array modifications.

In particular:

Alternate syntax	Equivalent In-place expression
`x = x.at[idx].set(y)`	`x[idx] = y`
`x = x.at[idx].add(y)`	`x[idx] += y`
`x = x.at[idx].subtract(y)`	`x[idx] -= y`
`x = x.at[idx].multiply(y)`	`x[idx] *= y`
`x = x.at[idx].divide(y)`	`x[idx] /= y`
`x = x.at[idx].power(y)`	`x[idx] **= y`
`x = x.at[idx].min(y)`	`x[idx] = minimum(x[idx], y)`
`x = x.at[idx].max(y)`	`x[idx] = maximum(x[idx], y)`
`x = x.at[idx].apply(ufunc)`	`ufunc.at(x, idx)`
`x = x.at[idx].get()`	`x = x[idx]`

None of the x.at expressions modify the original x; instead they return a modified copy of x. However, inside a jit() compiled function, expressions like x = x.at[idx].set(y) are guaranteed to be applied in-place.

Unlike NumPy in-place operations such as x[idx] += y, if multiple indices refer to the same location, all updates will be applied (NumPy would only apply the last update, rather than applying all updates.) The order in which conflicting updates are applied is implementation-defined and may be nondeterministic (e.g., due to concurrency on some hardware platforms).

By default, JAX assumes that all indices are in-bounds. Alternative out-of-bound index semantics can be specified via the mode parameter (see below).

Parameters:

mode (str) –
Specify out-of-bound indexing mode. Options are:
- "promise_in_bounds": (default) The user promises that indices are in bounds. No additional checking will be performed. In practice, this means that out-of-bounds indices in get() will be clipped, and out-of-bounds indices in set(), add(), etc. will be dropped.
- "clip": clamp out of bounds indices into valid range.
- "drop": ignore out-of-bound indices.
- "fill": alias for "drop". For get(), the optional fill_value argument specifies the value that will be returned.
  
  See jax.lax.GatherScatterMode for more details.
indices_are_sorted (bool) – If True, the implementation will assume that the indices passed to at[] are sorted in ascending order, which can lead to more efficient execution on some backends.
unique_indices (bool) – If True, the implementation will assume that the indices passed to at[] are unique, which can result in more efficient execution on some backends.
fill_value (Any) – Only applies to the get() method: the fill value to return for out-of-bounds slices when mode is 'fill'. Ignored otherwise. Defaults to NaN for inexact types, the largest negative value for signed types, the largest positive value for unsigned types, and True for booleans.

Examples

>>> x = jnp.arange(5.0)
>>> x
Array([0., 1., 2., 3., 4.], dtype=float32)
>>> x.at[2].add(10)
Array([ 0.,  1., 12.,  3.,  4.], dtype=float32)
>>> x.at[10].add(10)  # out-of-bounds indices are ignored
Array([0., 1., 2., 3., 4.], dtype=float32)
>>> x.at[20].add(10, mode='clip')
Array([ 0.,  1.,  2.,  3., 14.], dtype=float32)
>>> x.at[2].get()
Array(2., dtype=float32)
>>> x.at[20].get()  # out-of-bounds indices clipped
Array(4., dtype=float32)
>>> x.at[20].get(mode='fill')  # out-of-bounds indices filled with NaN
Array(nan, dtype=float32)
>>> x.at[20].get(mode='fill', fill_value=-1)  # custom fill value
Array(-1., dtype=float32)

block_until_ready()#

Block until the array is ready.

Return type:: AbstractQuantity

Examples

>>> import unxt as u
>>> q = u.Quantity(1, "m")
>>> q.block_until_ready() is q
True

decompose(bases: Sequence[Unit | UnitBase | CompositeUnit | str], /)#

Decompose the quantity into the given bases.

Examples

>>> from unxt import Quantity

>>> q = Quantity(1, "m")
>>> q.decompose(["cm", "s"])
Quantity(Array(100., dtype=float32, ...), unit='cm')

Parameters:: bases (Sequence[Unit | UnitBase | CompositeUnit | str])
Return type:: AbstractQuantity

property device: Device#

Device where the array is located.

Examples

>>> import unxt as u
>>> u.Quantity(1, "m").device
CpuDevice(id=0)

devices()#

Return the devices where the array is located.

Return type:: set[Device]

Examples

>>> import unxt as u
>>> q = u.Quantity(1, "m")
>>> q.devices()
{CpuDevice(id=0)}

property distance: AbstractDistance#

The distance.

Examples

>>> from coordinax.distance import Distance
>>> d = Distance(10, "km")
>>> d.distance is d
True

>>> from coordinax.distance import DistanceModulus
>>> DistanceModulus(10, "mag").distance
Distance(Array(1000., dtype=float32, ...), unit='pc')

>>> from coordinax.distance import Parallax
>>> p = Parallax(1, "mas")
>>> p.distance.to("kpc")
Distance(Array(1., dtype=float32, ...), unit='kpc')

property distance_modulus: AbstractDistance#

The distance modulus.

Examples

>>> from coordinax.distance import Distance
>>> d = Distance(1, "pc")
>>> d.distance_modulus
DistanceModulus(Array(-5., dtype=float32), unit='mag')

>>> from coordinax.distance import DistanceModulus
>>> DistanceModulus(10, "mag").distance_modulus
DistanceModulus(Array(10, dtype=int32, ...), unit='mag')

>>> from coordinax.distance import Parallax
>>> Parallax(1, "mas").distance_modulus
DistanceModulus(Array(10., dtype=float32), unit='mag')

property dtype: dtype#

Data type of the array.

Examples

>>> import unxt as u
>>> u.Quantity(1, "m").dtype
dtype('int32')

flatten()#

Return a flattened version of the array.

Return type:: AbstractQuantity

Examples

>>> import unxt as u
>>> q = u.Quantity([[1, 2], [3, 4]], "m")
>>> q.flatten()
Quantity(Array([1, 2, 3, 4], dtype=int32), unit='m')

classmethod from_(cls: type[AbstractQuantity], *args: Any, **kwargs: Any)#

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a unxt.Quantity from an array-like value and a unit.

Parameters:

value – The array-like value.
unit – The unit of the value.
dtype – The data type of the array (keyword-only).
args (Any)
kwargs (Any)

Return type:

Examples

For this example we’ll use the Quantity class. The same applies to any subclass of AbstractQuantity.

>>> import jax.numpy as jnp
>>> import unxt as u

>>> x = jnp.array([1.0, 2, 3])
>>> u.Quantity.from_(x, "m")
Quantity(Array([1., 2., 3.], dtype=float32), unit='m')

>>> u.Quantity.from_([1.0, 2, 3], "m")
Quantity(Array([1., 2., 3.], dtype=float32), unit='m')

>>> u.Quantity.from_((1.0, 2, 3), "m")
Quantity(Array([1., 2., 3.], dtype=float32), unit='m')

Parameters:

args (Any)
kwargs (Any)

Return type:

Make a unxt.AbstractQuantity from an array-like value and a unit kwarg.

Examples

For this example we’ll use the unxt.Quantity class. The same applies to any subclass of unxt.AbstractQuantity.

>>> import unxt as u
>>> u.Quantity.from_([1.0, 2, 3], unit="m")
Quantity(Array([1., 2., 3.], dtype=float32), unit='m')

from_(cls: type[AbstractQuantity], *, value: Any, unit: Any, dtype: Any = None) → AbstractQuantity

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a AbstractQuantity from value and unit kwargs.

Examples

For this example we’ll use the Quantity class. The same applies to any subclass of AbstractQuantity.

>>> import unxt as u
>>> u.Quantity.from_(value=[1.0, 2, 3], unit="m")
Quantity(Array([1., 2., 3.], dtype=float32), unit='m')

from_(cls: type[AbstractQuantity], mapping: Mapping[str, Any]) → AbstractQuantity

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a Quantity from a Mapping.

Examples

For this example we’ll use the Quantity class. The same applies to any subclass of AbstractQuantity.

>>> import jax.numpy as jnp
>>> import unxt as u

>>> x = jnp.array([1.0, 2, 3])
>>> q = u.Quantity.from_({"value": x, "unit": "m"})
>>> q
Quantity(Array([1., 2., 3.], dtype=float32), unit='m')

>>> u.Quantity.from_({"value": q, "unit": "km"})
Quantity(Array([0.001, 0.002, 0.003], dtype=float32), unit='km')

from_(cls: type[AbstractQuantity], value: AbstractQuantity, unit: Any, /, *, dtype: Any = None) → AbstractQuantity

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a Quantity from another Quantity.

The value is converted to the new unit.

Examples

>>> import unxt as u

>>> q = u.Quantity(1, "m")
>>> u.Quantity.from_(q, "cm")
Quantity(Array(100., dtype=float32, ...), unit='cm')

from_(cls: type[AbstractQuantity], value: AbstractQuantity, unit: NoneType, /, *, dtype: Any = None) → AbstractQuantity

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a Quantity from another Quantity.

The value is converted to the new unit.

Examples

>>> import unxt as u

>>> q = u.Quantity(1, "m")
>>> u.Quantity.from_(q, None)
Quantity(Array(1, dtype=int32, ...), unit='m')

from_(cls: type[AbstractQuantity], value: AbstractQuantity, /, *, unit: Any | None = None, dtype: Any = None) → AbstractQuantity

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a Quantity from another Quantity, with no unit change.

from_(cls: type[AbstractQuantity], value: Quantity, /, **kwargs: Any) → AbstractQuantity

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a Quantity from another Quantity.

The value is converted to the new unit.

Examples

>>> import unxt as u
>>> import astropy.units as apyu

>>> u.Quantity.from_(apyu.Quantity(1, "m"))
Quantity(Array(1., dtype=float32), unit='m')

from_(cls: type[AbstractQuantity], value: Quantity, u: Any, /, **kwargs: Any) → AbstractQuantity

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a Quantity from another Quantity.

The value is converted to the new unit.

Examples

>>> import unxt as u
>>> import astropy.units as apyu

>>> u.Quantity.from_(apyu.Quantity(1, "m"), "cm")
Quantity(Array(100., dtype=float32), unit='cm')

from_(cls: type[Distance], obj: AbstractDistance | Quantity[PhysicalType('length')] | Quantity[PhysicalType('angle')] | Quantity[PhysicalType('unknown')], /, **kw: Any) → Distance

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a Distance from the inputs.

from_(cls: type[DistanceModulus], dm: AbstractDistance | Quantity[PhysicalType('unknown')] | Quantity[PhysicalType('length')] | Quantity[PhysicalType('angle')], /, **kwargs: Any) → DistanceModulus

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a DistanceModulus from the input.

from_(cls: type[Parallax], obj: AbstractDistance | Quantity[PhysicalType('angle')] | Quantity[PhysicalType('length')] | Quantity[PhysicalType('unknown')], /, **kwargs: Any) → Parallax

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a Parallax the input.

Parameters:

cls (type[AbstractQuantity])
args (Any)
kwargs (Any)

Return type:

property mT: AbstractQuantity#

Matrix transpose of the array.

Examples

>>> import unxt as u
>>> q = u.Quantity([[0, 1], [1, 2]], "m")
>>> q.mT
Quantity(Array([[0, 1],
                          [1, 2]], dtype=int32), unit='m')

max(*args: Any, **kwargs: Any)#

Return the maximum value.

Examples

>>> import unxt as u
>>> q = u.Quantity([1, 2, 3], "m")
>>> q.max()
Quantity(Array(3, dtype=int32), unit='m')

Parameters:

args (Any)
kwargs (Any)

Return type:

mean(*args: Any, **kwargs: Any)#

Return the mean value.

Examples

>>> import unxt as u
>>> q = u.Quantity([1, 2, 3], "m")
>>> q.mean()
Quantity(Array(2., dtype=float32), unit='m')

Parameters:

args (Any)
kwargs (Any)

Return type:

min(*args: Any, **kwargs: Any)#

Return the minimum value.

Examples

>>> import unxt as u
>>> q = u.Quantity([1, 2, 3], "m")
>>> q.min()
Quantity(Array(1, dtype=int32), unit='m')

Parameters:

args (Any)
kwargs (Any)

Return type:

property ndim: int#

Number of dimensions.

Examples

>>> import unxt as u
>>> q = u.Quantity([[1]], "m")
>>> q.ndim
2

property parallax: AbstractDistance#

The parallax from a distance.

The parallax is calculated as \(\arctan(1 AU / d)\).

Examples

>>> import quaxed.numpy as jnp
>>> from coordinax.distance import Distance

>>> d = Distance(1, "pc")
>>> jnp.round(d.parallax.to("arcsec"), 2)
Parallax(Array(1., dtype=float32, ...), unit='arcsec')

>>> from coordinax.distance import DistanceModulus
>>> DistanceModulus(10, "mag").parallax.to("mas")
Parallax(Array(0.99999994, dtype=float32, ...), unit='mas')

>>> from coordinax.distance import Parallax
>>> p = Parallax(1, "mas")
>>> p.parallax is p
True

ravel()#

Return a flattened version of the array.

Return type:: AbstractQuantity

Examples

>>> import unxt as u
>>> q = u.Quantity([[1, 2], [3, 4]], "m")
>>> q.ravel()
Quantity(Array([1, 2, 3, 4], dtype=int32), unit='m')

reshape(*args: Any, order: str = 'C')#

Return a reshaped version of the array.

Examples

>>> import unxt as u
>>> q = u.Quantity([1, 2, 3, 4], "m")
>>> q.reshape(2, 2)
Quantity(Array([[1, 2],
                          [3, 4]], dtype=int32), unit='m')

Parameters:

args (Any)
order (str)

Return type:

round(*args: Any, **kwargs: Any)#

Round the array to the given number of decimals.

Examples

>>> import unxt as u
>>> q = u.Quantity([1.1, 2.2, 3.3], "m")
>>> q.round(0)
Quantity(Array([1., 2., 3.], dtype=float32), unit='m')

Parameters:

args (Any)
kwargs (Any)

Return type:

property shape: tuple[int, ...]#: Shape of the array.

property sharding: Any#

Return the sharding configuration of the array.

Examples

>>> import unxt as u
>>> q = u.Quantity([1, 2, 3], "m")
>>> q.sharding
SingleDeviceSharding(device=..., memory_kind=...)

property size: int#

Total number of elements.

Examples

>>> import unxt as u
>>> q = u.Quantity([1, 2, 3], "m")
>>> q.size
3

squeeze(*args: Any, **kwargs: Any)#

Return the array with all single-dimensional entries removed.

Examples

>>> import unxt as u
>>> q = u.Quantity([[[1], [2], [3]]], "m")
>>> q.squeeze()
Quantity(Array([1, 2, 3], dtype=int32), unit='m')

Parameters:

args (Any)
kwargs (Any)

Return type:

to(u: Any, /)#

Convert the quantity to the given units.

See unxt.quantity.AbstractQuantity.uconvert.

Examples

>>> from unxt import Quantity

>>> q = Quantity(1, "m")
>>> q.to("cm")
Quantity(Array(100., dtype=float32, ...), unit='cm')

Parameters:: u (Any)
Return type:: AbstractQuantity

to_device(device: None | Device = None)#

Move the array to a new device.

Examples

>>> import unxt as u
>>> q = u.Quantity(1, "m")
>>> q.to_device(None)
Quantity(Array(1, dtype=int32, weak_type=True), unit='m')

Parameters:: device (None | Device)
Return type:: AbstractQuantity

to_value(u: Any, /)#

Return the value in the given units.

See unxt.AbstractQuantity.ustrip.

Examples

>>> from unxt import Quantity

>>> q = Quantity(1, "m")
>>> q.to_value("cm")
Array(100., dtype=float32, weak_type=True)

Parameters:: u (Any)
Return type:: Union[Array, ndarray, bool, number, bool, int, float, complex]

uconvert(u: Any, /)#

Convert the quantity to the given units.

See also

None: convert a quantity to a new unit.

Examples

>>> import unxt as u

>>> q = u.Quantity(1, "m")
>>> q.uconvert("cm")
Quantity(Array(100., dtype=float32, ...), unit='cm')

Parameters:: u (Any)
Return type:: AbstractQuantity

ustrip(u: Any, /)#

Return the value in the given units.

See also

None: strip the units from a quantity.

Examples

>>> import unxt as u

>>> q = u.Quantity(1, "m")
>>> q.ustrip("cm")
Array(100., dtype=float32, weak_type=True)

Parameters:: u (Any)
Return type:: Array

value: eqx.AbstractVar[Shaped[Array | StaticValue, '*shape']]#: The value of the AbstractQuantity.

unit: eqx.AbstractVar[AbstractUnit]#: The unit associated with this value.

class coordinax.distance.Distance(value: Any, unit: Any, *, check_negative: bool = True)#

Bases: AbstractDistance

Distance quantities.

The distance is a quantity with dimensions of length.

Examples

>>> from coordinax.distance import Distance
>>> Distance(10, "km")
Distance(Array(10, dtype=int32, ...), unit='km')

The units are checked to have length dimensions.

>>> try: Distance(10, "s")
... except ValueError as e: print(e)
Distance must have dimensions length.

Parameters:

value (Any)
unit (Any)
check_negative (bool)

property T: AbstractQuantity#

Transpose of the array.

Examples

>>> import unxt as u
>>> q = u.Quantity([[0, 1], [1, 2]], "m")
>>> q.T
Quantity(Array([[0, 1],
                          [1, 2]], dtype=int32), unit='m')

argmax(*args: Any, **kwargs: Any)#

Return the indices of the maximum value.

Examples

>>> import unxt as u
>>> q = u.Quantity([1, 2, 3], "m")
>>> q.argmax()
Array(2, dtype=int32)

Parameters:

args (Any)
kwargs (Any)

Return type:

argmin(*args: Any, **kwargs: Any)#

Return the indices of the minimum value.

Examples

>>> import unxt as u
>>> q = u.Quantity([1, 2, 3], "m")
>>> q.argmin()
Array(0, dtype=int32)

Parameters:

args (Any)
kwargs (Any)

Return type:

astype(*args: Any, **kwargs: Any)#

Copy the array and cast to a specified dtype.

Examples

>>> import unxt as u
>>> q = u.Quantity([1, 2, 3], "m")
>>> q.dtype
dtype('int32')

>>> q.astype(float)
Quantity(Array([1., 2., 3.], dtype=float32), unit='m')

Parameters:

args (Any)
kwargs (Any)

Return type:

property at: _QuantityIndexUpdateHelper#

Helper property for index update functionality.

The at property provides a functionally pure equivalent of in-place array modifications.

In particular:

Alternate syntax	Equivalent In-place expression
`x = x.at[idx].set(y)`	`x[idx] = y`
`x = x.at[idx].add(y)`	`x[idx] += y`
`x = x.at[idx].subtract(y)`	`x[idx] -= y`
`x = x.at[idx].multiply(y)`	`x[idx] *= y`
`x = x.at[idx].divide(y)`	`x[idx] /= y`
`x = x.at[idx].power(y)`	`x[idx] **= y`
`x = x.at[idx].min(y)`	`x[idx] = minimum(x[idx], y)`
`x = x.at[idx].max(y)`	`x[idx] = maximum(x[idx], y)`
`x = x.at[idx].apply(ufunc)`	`ufunc.at(x, idx)`
`x = x.at[idx].get()`	`x = x[idx]`

None of the x.at expressions modify the original x; instead they return a modified copy of x. However, inside a jit() compiled function, expressions like x = x.at[idx].set(y) are guaranteed to be applied in-place.

Unlike NumPy in-place operations such as x[idx] += y, if multiple indices refer to the same location, all updates will be applied (NumPy would only apply the last update, rather than applying all updates.) The order in which conflicting updates are applied is implementation-defined and may be nondeterministic (e.g., due to concurrency on some hardware platforms).

By default, JAX assumes that all indices are in-bounds. Alternative out-of-bound index semantics can be specified via the mode parameter (see below).

Parameters:

mode (str) –
Specify out-of-bound indexing mode. Options are:
- "promise_in_bounds": (default) The user promises that indices are in bounds. No additional checking will be performed. In practice, this means that out-of-bounds indices in get() will be clipped, and out-of-bounds indices in set(), add(), etc. will be dropped.
- "clip": clamp out of bounds indices into valid range.
- "drop": ignore out-of-bound indices.
- "fill": alias for "drop". For get(), the optional fill_value argument specifies the value that will be returned.
  
  See jax.lax.GatherScatterMode for more details.
indices_are_sorted (bool) – If True, the implementation will assume that the indices passed to at[] are sorted in ascending order, which can lead to more efficient execution on some backends.
unique_indices (bool) – If True, the implementation will assume that the indices passed to at[] are unique, which can result in more efficient execution on some backends.
fill_value (Any) – Only applies to the get() method: the fill value to return for out-of-bounds slices when mode is 'fill'. Ignored otherwise. Defaults to NaN for inexact types, the largest negative value for signed types, the largest positive value for unsigned types, and True for booleans.

Examples

>>> x = jnp.arange(5.0)
>>> x
Array([0., 1., 2., 3., 4.], dtype=float32)
>>> x.at[2].add(10)
Array([ 0.,  1., 12.,  3.,  4.], dtype=float32)
>>> x.at[10].add(10)  # out-of-bounds indices are ignored
Array([0., 1., 2., 3., 4.], dtype=float32)
>>> x.at[20].add(10, mode='clip')
Array([ 0.,  1.,  2.,  3., 14.], dtype=float32)
>>> x.at[2].get()
Array(2., dtype=float32)
>>> x.at[20].get()  # out-of-bounds indices clipped
Array(4., dtype=float32)
>>> x.at[20].get(mode='fill')  # out-of-bounds indices filled with NaN
Array(nan, dtype=float32)
>>> x.at[20].get(mode='fill', fill_value=-1)  # custom fill value
Array(-1., dtype=float32)

block_until_ready()#

Block until the array is ready.

Return type:: AbstractQuantity

Examples

>>> import unxt as u
>>> q = u.Quantity(1, "m")
>>> q.block_until_ready() is q
True

check_negative: bool = True#: Whether to check that the distance is strictly non-negative.

decompose(bases: Sequence[Unit | UnitBase | CompositeUnit | str], /)#

Decompose the quantity into the given bases.

Examples

>>> from unxt import Quantity

>>> q = Quantity(1, "m")
>>> q.decompose(["cm", "s"])
Quantity(Array(100., dtype=float32, ...), unit='cm')

Parameters:: bases (Sequence[Unit | UnitBase | CompositeUnit | str])
Return type:: AbstractQuantity

property device: Device#

Device where the array is located.

Examples

>>> import unxt as u
>>> u.Quantity(1, "m").device
CpuDevice(id=0)

devices()#

Return the devices where the array is located.

Return type:: set[Device]

Examples

>>> import unxt as u
>>> q = u.Quantity(1, "m")
>>> q.devices()
{CpuDevice(id=0)}

property distance: AbstractDistance#

The distance.

Examples

>>> from coordinax.distance import Distance
>>> d = Distance(10, "km")
>>> d.distance is d
True

>>> from coordinax.distance import DistanceModulus
>>> DistanceModulus(10, "mag").distance
Distance(Array(1000., dtype=float32, ...), unit='pc')

>>> from coordinax.distance import Parallax
>>> p = Parallax(1, "mas")
>>> p.distance.to("kpc")
Distance(Array(1., dtype=float32, ...), unit='kpc')

property distance_modulus: AbstractDistance#

The distance modulus.

Examples

>>> from coordinax.distance import Distance
>>> d = Distance(1, "pc")
>>> d.distance_modulus
DistanceModulus(Array(-5., dtype=float32), unit='mag')

>>> from coordinax.distance import DistanceModulus
>>> DistanceModulus(10, "mag").distance_modulus
DistanceModulus(Array(10, dtype=int32, ...), unit='mag')

>>> from coordinax.distance import Parallax
>>> Parallax(1, "mas").distance_modulus
DistanceModulus(Array(10., dtype=float32), unit='mag')

property dtype: dtype#

Data type of the array.

Examples

>>> import unxt as u
>>> u.Quantity(1, "m").dtype
dtype('int32')

flatten()#

Return a flattened version of the array.

Return type:: AbstractQuantity

Examples

>>> import unxt as u
>>> q = u.Quantity([[1, 2], [3, 4]], "m")
>>> q.flatten()
Quantity(Array([1, 2, 3, 4], dtype=int32), unit='m')

classmethod from_(cls: type[AbstractQuantity], *args: Any, **kwargs: Any)#

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a unxt.Quantity from an array-like value and a unit.

Parameters:

value – The array-like value.
unit – The unit of the value.
dtype – The data type of the array (keyword-only).
args (Any)
kwargs (Any)

Return type:

Examples

For this example we’ll use the Quantity class. The same applies to any subclass of AbstractQuantity.

>>> import jax.numpy as jnp
>>> import unxt as u

>>> x = jnp.array([1.0, 2, 3])
>>> u.Quantity.from_(x, "m")
Quantity(Array([1., 2., 3.], dtype=float32), unit='m')

>>> u.Quantity.from_([1.0, 2, 3], "m")
Quantity(Array([1., 2., 3.], dtype=float32), unit='m')

>>> u.Quantity.from_((1.0, 2, 3), "m")
Quantity(Array([1., 2., 3.], dtype=float32), unit='m')

Parameters:

args (Any)
kwargs (Any)

Return type:

Make a unxt.AbstractQuantity from an array-like value and a unit kwarg.

Examples

For this example we’ll use the unxt.Quantity class. The same applies to any subclass of unxt.AbstractQuantity.

>>> import unxt as u
>>> u.Quantity.from_([1.0, 2, 3], unit="m")
Quantity(Array([1., 2., 3.], dtype=float32), unit='m')

from_(cls: type[AbstractQuantity], *, value: Any, unit: Any, dtype: Any = None) → AbstractQuantity

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a AbstractQuantity from value and unit kwargs.

Examples

For this example we’ll use the Quantity class. The same applies to any subclass of AbstractQuantity.

>>> import unxt as u
>>> u.Quantity.from_(value=[1.0, 2, 3], unit="m")
Quantity(Array([1., 2., 3.], dtype=float32), unit='m')

from_(cls: type[AbstractQuantity], mapping: Mapping[str, Any]) → AbstractQuantity

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a Quantity from a Mapping.

Examples

For this example we’ll use the Quantity class. The same applies to any subclass of AbstractQuantity.

>>> import jax.numpy as jnp
>>> import unxt as u

>>> x = jnp.array([1.0, 2, 3])
>>> q = u.Quantity.from_({"value": x, "unit": "m"})
>>> q
Quantity(Array([1., 2., 3.], dtype=float32), unit='m')

>>> u.Quantity.from_({"value": q, "unit": "km"})
Quantity(Array([0.001, 0.002, 0.003], dtype=float32), unit='km')

from_(cls: type[AbstractQuantity], value: AbstractQuantity, unit: Any, /, *, dtype: Any = None) → AbstractQuantity

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a Quantity from another Quantity.

The value is converted to the new unit.

Examples

>>> import unxt as u

>>> q = u.Quantity(1, "m")
>>> u.Quantity.from_(q, "cm")
Quantity(Array(100., dtype=float32, ...), unit='cm')

from_(cls: type[AbstractQuantity], value: AbstractQuantity, unit: NoneType, /, *, dtype: Any = None) → AbstractQuantity

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a Quantity from another Quantity.

The value is converted to the new unit.

Examples

>>> import unxt as u

>>> q = u.Quantity(1, "m")
>>> u.Quantity.from_(q, None)
Quantity(Array(1, dtype=int32, ...), unit='m')

from_(cls: type[AbstractQuantity], value: AbstractQuantity, /, *, unit: Any | None = None, dtype: Any = None) → AbstractQuantity

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a Quantity from another Quantity, with no unit change.

from_(cls: type[AbstractQuantity], value: Quantity, /, **kwargs: Any) → AbstractQuantity

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a Quantity from another Quantity.

The value is converted to the new unit.

Examples

>>> import unxt as u
>>> import astropy.units as apyu

>>> u.Quantity.from_(apyu.Quantity(1, "m"))
Quantity(Array(1., dtype=float32), unit='m')

from_(cls: type[AbstractQuantity], value: Quantity, u: Any, /, **kwargs: Any) → AbstractQuantity

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a Quantity from another Quantity.

The value is converted to the new unit.

Examples

>>> import unxt as u
>>> import astropy.units as apyu

>>> u.Quantity.from_(apyu.Quantity(1, "m"), "cm")
Quantity(Array(100., dtype=float32), unit='cm')

from_(cls: type[Distance], obj: AbstractDistance | Quantity[PhysicalType('length')] | Quantity[PhysicalType('angle')] | Quantity[PhysicalType('unknown')], /, **kw: Any) → Distance

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a Distance from the inputs.

from_(cls: type[DistanceModulus], dm: AbstractDistance | Quantity[PhysicalType('unknown')] | Quantity[PhysicalType('length')] | Quantity[PhysicalType('angle')], /, **kwargs: Any) → DistanceModulus

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a DistanceModulus from the input.

from_(cls: type[Parallax], obj: AbstractDistance | Quantity[PhysicalType('angle')] | Quantity[PhysicalType('length')] | Quantity[PhysicalType('unknown')], /, **kwargs: Any) → Parallax

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a Parallax the input.

Parameters:

cls (type[AbstractQuantity])
args (Any)
kwargs (Any)

Return type:

property mT: AbstractQuantity#

Matrix transpose of the array.

Examples

>>> import unxt as u
>>> q = u.Quantity([[0, 1], [1, 2]], "m")
>>> q.mT
Quantity(Array([[0, 1],
                          [1, 2]], dtype=int32), unit='m')

max(*args: Any, **kwargs: Any)#

Return the maximum value.

Examples

>>> import unxt as u
>>> q = u.Quantity([1, 2, 3], "m")
>>> q.max()
Quantity(Array(3, dtype=int32), unit='m')

Parameters:

args (Any)
kwargs (Any)

Return type:

mean(*args: Any, **kwargs: Any)#

Return the mean value.

Examples

>>> import unxt as u
>>> q = u.Quantity([1, 2, 3], "m")
>>> q.mean()
Quantity(Array(2., dtype=float32), unit='m')

Parameters:

args (Any)
kwargs (Any)

Return type:

min(*args: Any, **kwargs: Any)#

Return the minimum value.

Examples

>>> import unxt as u
>>> q = u.Quantity([1, 2, 3], "m")
>>> q.min()
Quantity(Array(1, dtype=int32), unit='m')

Parameters:

args (Any)
kwargs (Any)

Return type:

property ndim: int#

Number of dimensions.

Examples

>>> import unxt as u
>>> q = u.Quantity([[1]], "m")
>>> q.ndim
2

property parallax: AbstractDistance#

The parallax from a distance.

The parallax is calculated as \(\arctan(1 AU / d)\).

Examples

>>> import quaxed.numpy as jnp
>>> from coordinax.distance import Distance

>>> d = Distance(1, "pc")
>>> jnp.round(d.parallax.to("arcsec"), 2)
Parallax(Array(1., dtype=float32, ...), unit='arcsec')

>>> from coordinax.distance import DistanceModulus
>>> DistanceModulus(10, "mag").parallax.to("mas")
Parallax(Array(0.99999994, dtype=float32, ...), unit='mas')

>>> from coordinax.distance import Parallax
>>> p = Parallax(1, "mas")
>>> p.parallax is p
True

ravel()#

Return a flattened version of the array.

Return type:: AbstractQuantity

Examples

>>> import unxt as u
>>> q = u.Quantity([[1, 2], [3, 4]], "m")
>>> q.ravel()
Quantity(Array([1, 2, 3, 4], dtype=int32), unit='m')

reshape(*args: Any, order: str = 'C')#

Return a reshaped version of the array.

Examples

>>> import unxt as u
>>> q = u.Quantity([1, 2, 3, 4], "m")
>>> q.reshape(2, 2)
Quantity(Array([[1, 2],
                          [3, 4]], dtype=int32), unit='m')

Parameters:

args (Any)
order (str)

Return type:

round(*args: Any, **kwargs: Any)#

Round the array to the given number of decimals.

Examples

>>> import unxt as u
>>> q = u.Quantity([1.1, 2.2, 3.3], "m")
>>> q.round(0)
Quantity(Array([1., 2., 3.], dtype=float32), unit='m')

Parameters:

args (Any)
kwargs (Any)

Return type:

property shape: tuple[int, ...]#: Shape of the array.

property sharding: Any#

Return the sharding configuration of the array.

Examples

>>> import unxt as u
>>> q = u.Quantity([1, 2, 3], "m")
>>> q.sharding
SingleDeviceSharding(device=..., memory_kind=...)

property size: int#

Total number of elements.

Examples

>>> import unxt as u
>>> q = u.Quantity([1, 2, 3], "m")
>>> q.size
3

squeeze(*args: Any, **kwargs: Any)#

Return the array with all single-dimensional entries removed.

Examples

>>> import unxt as u
>>> q = u.Quantity([[[1], [2], [3]]], "m")
>>> q.squeeze()
Quantity(Array([1, 2, 3], dtype=int32), unit='m')

Parameters:

args (Any)
kwargs (Any)

Return type:

to(u: Any, /)#

Convert the quantity to the given units.

See unxt.quantity.AbstractQuantity.uconvert.

Examples

>>> from unxt import Quantity

>>> q = Quantity(1, "m")
>>> q.to("cm")
Quantity(Array(100., dtype=float32, ...), unit='cm')

Parameters:: u (Any)
Return type:: AbstractQuantity

to_device(device: None | Device = None)#

Move the array to a new device.

Examples

>>> import unxt as u
>>> q = u.Quantity(1, "m")
>>> q.to_device(None)
Quantity(Array(1, dtype=int32, weak_type=True), unit='m')

Parameters:: device (None | Device)
Return type:: AbstractQuantity

to_value(u: Any, /)#

Return the value in the given units.

See unxt.AbstractQuantity.ustrip.

Examples

>>> from unxt import Quantity

>>> q = Quantity(1, "m")
>>> q.to_value("cm")
Array(100., dtype=float32, weak_type=True)

Parameters:: u (Any)
Return type:: Union[Array, ndarray, bool, number, bool, int, float, complex]

uconvert(u: Any, /)#

Convert the quantity to the given units.

See also

None: convert a quantity to a new unit.

Examples

>>> import unxt as u

>>> q = u.Quantity(1, "m")
>>> q.uconvert("cm")
Quantity(Array(100., dtype=float32, ...), unit='cm')

Parameters:: u (Any)
Return type:: AbstractQuantity

ustrip(u: Any, /)#

Return the value in the given units.

See also

None: strip the units from a quantity.

Examples

>>> import unxt as u

>>> q = u.Quantity(1, "m")
>>> q.ustrip("cm")
Array(100., dtype=float32, weak_type=True)

Parameters:: u (Any)
Return type:: Array

value: Shaped[Array, '*shape']#: The value of the unxt.AbstractQuantity.

unit: Unit | UnitBase | CompositeUnit#: The unit associated with this value.

class coordinax.distance.DistanceModulus(value: Any, unit: Any)#

Bases: AbstractDistance

Distance modulus quantity.

Examples

>>> from coordinax.distance import DistanceModulus
>>> DistanceModulus(10, "mag")
DistanceModulus(Array(10, dtype=int32, ...), unit='mag')

The units are checked to have magnitude dimensions.

>>> try: DistanceModulus(10, "pc")
... except ValueError as e: print(e)
Distance modulus must have units of magnitude.

Parameters:

value (Any)
unit (Any)

property T: AbstractQuantity#

Transpose of the array.

Examples

>>> import unxt as u
>>> q = u.Quantity([[0, 1], [1, 2]], "m")
>>> q.T
Quantity(Array([[0, 1],
                          [1, 2]], dtype=int32), unit='m')

argmax(*args: Any, **kwargs: Any)#

Return the indices of the maximum value.

Examples

>>> import unxt as u
>>> q = u.Quantity([1, 2, 3], "m")
>>> q.argmax()
Array(2, dtype=int32)

Parameters:

args (Any)
kwargs (Any)

Return type:

argmin(*args: Any, **kwargs: Any)#

Return the indices of the minimum value.

Examples

>>> import unxt as u
>>> q = u.Quantity([1, 2, 3], "m")
>>> q.argmin()
Array(0, dtype=int32)

Parameters:

args (Any)
kwargs (Any)

Return type:

astype(*args: Any, **kwargs: Any)#

Copy the array and cast to a specified dtype.

Examples

>>> import unxt as u
>>> q = u.Quantity([1, 2, 3], "m")
>>> q.dtype
dtype('int32')

>>> q.astype(float)
Quantity(Array([1., 2., 3.], dtype=float32), unit='m')

Parameters:

args (Any)
kwargs (Any)

Return type:

property at: _QuantityIndexUpdateHelper#

Helper property for index update functionality.

The at property provides a functionally pure equivalent of in-place array modifications.

In particular:

Alternate syntax	Equivalent In-place expression
`x = x.at[idx].set(y)`	`x[idx] = y`
`x = x.at[idx].add(y)`	`x[idx] += y`
`x = x.at[idx].subtract(y)`	`x[idx] -= y`
`x = x.at[idx].multiply(y)`	`x[idx] *= y`
`x = x.at[idx].divide(y)`	`x[idx] /= y`
`x = x.at[idx].power(y)`	`x[idx] **= y`
`x = x.at[idx].min(y)`	`x[idx] = minimum(x[idx], y)`
`x = x.at[idx].max(y)`	`x[idx] = maximum(x[idx], y)`
`x = x.at[idx].apply(ufunc)`	`ufunc.at(x, idx)`
`x = x.at[idx].get()`	`x = x[idx]`

None of the x.at expressions modify the original x; instead they return a modified copy of x. However, inside a jit() compiled function, expressions like x = x.at[idx].set(y) are guaranteed to be applied in-place.

Unlike NumPy in-place operations such as x[idx] += y, if multiple indices refer to the same location, all updates will be applied (NumPy would only apply the last update, rather than applying all updates.) The order in which conflicting updates are applied is implementation-defined and may be nondeterministic (e.g., due to concurrency on some hardware platforms).

By default, JAX assumes that all indices are in-bounds. Alternative out-of-bound index semantics can be specified via the mode parameter (see below).

Parameters:

mode (str) –
Specify out-of-bound indexing mode. Options are:
- "promise_in_bounds": (default) The user promises that indices are in bounds. No additional checking will be performed. In practice, this means that out-of-bounds indices in get() will be clipped, and out-of-bounds indices in set(), add(), etc. will be dropped.
- "clip": clamp out of bounds indices into valid range.
- "drop": ignore out-of-bound indices.
- "fill": alias for "drop". For get(), the optional fill_value argument specifies the value that will be returned.
  
  See jax.lax.GatherScatterMode for more details.
indices_are_sorted (bool) – If True, the implementation will assume that the indices passed to at[] are sorted in ascending order, which can lead to more efficient execution on some backends.
unique_indices (bool) – If True, the implementation will assume that the indices passed to at[] are unique, which can result in more efficient execution on some backends.
fill_value (Any) – Only applies to the get() method: the fill value to return for out-of-bounds slices when mode is 'fill'. Ignored otherwise. Defaults to NaN for inexact types, the largest negative value for signed types, the largest positive value for unsigned types, and True for booleans.

Examples

>>> x = jnp.arange(5.0)
>>> x
Array([0., 1., 2., 3., 4.], dtype=float32)
>>> x.at[2].add(10)
Array([ 0.,  1., 12.,  3.,  4.], dtype=float32)
>>> x.at[10].add(10)  # out-of-bounds indices are ignored
Array([0., 1., 2., 3., 4.], dtype=float32)
>>> x.at[20].add(10, mode='clip')
Array([ 0.,  1.,  2.,  3., 14.], dtype=float32)
>>> x.at[2].get()
Array(2., dtype=float32)
>>> x.at[20].get()  # out-of-bounds indices clipped
Array(4., dtype=float32)
>>> x.at[20].get(mode='fill')  # out-of-bounds indices filled with NaN
Array(nan, dtype=float32)
>>> x.at[20].get(mode='fill', fill_value=-1)  # custom fill value
Array(-1., dtype=float32)

block_until_ready()#

Block until the array is ready.

Return type:: AbstractQuantity

Examples

>>> import unxt as u
>>> q = u.Quantity(1, "m")
>>> q.block_until_ready() is q
True

decompose(bases: Sequence[Unit | UnitBase | CompositeUnit | str], /)#

Decompose the quantity into the given bases.

Examples

>>> from unxt import Quantity

>>> q = Quantity(1, "m")
>>> q.decompose(["cm", "s"])
Quantity(Array(100., dtype=float32, ...), unit='cm')

Parameters:: bases (Sequence[Unit | UnitBase | CompositeUnit | str])
Return type:: AbstractQuantity

property device: Device#

Device where the array is located.

Examples

>>> import unxt as u
>>> u.Quantity(1, "m").device
CpuDevice(id=0)

devices()#

Return the devices where the array is located.

Return type:: set[Device]

Examples

>>> import unxt as u
>>> q = u.Quantity(1, "m")
>>> q.devices()
{CpuDevice(id=0)}

property distance: AbstractDistance#

The distance.

Examples

>>> from coordinax.distance import Distance
>>> d = Distance(10, "km")
>>> d.distance is d
True

>>> from coordinax.distance import DistanceModulus
>>> DistanceModulus(10, "mag").distance
Distance(Array(1000., dtype=float32, ...), unit='pc')

>>> from coordinax.distance import Parallax
>>> p = Parallax(1, "mas")
>>> p.distance.to("kpc")
Distance(Array(1., dtype=float32, ...), unit='kpc')

property distance_modulus: AbstractDistance#

The distance modulus.

Examples

>>> from coordinax.distance import Distance
>>> d = Distance(1, "pc")
>>> d.distance_modulus
DistanceModulus(Array(-5., dtype=float32), unit='mag')

>>> from coordinax.distance import DistanceModulus
>>> DistanceModulus(10, "mag").distance_modulus
DistanceModulus(Array(10, dtype=int32, ...), unit='mag')

>>> from coordinax.distance import Parallax
>>> Parallax(1, "mas").distance_modulus
DistanceModulus(Array(10., dtype=float32), unit='mag')

property dtype: dtype#

Data type of the array.

Examples

>>> import unxt as u
>>> u.Quantity(1, "m").dtype
dtype('int32')

flatten()#

Return a flattened version of the array.

Return type:: AbstractQuantity

Examples

>>> import unxt as u
>>> q = u.Quantity([[1, 2], [3, 4]], "m")
>>> q.flatten()
Quantity(Array([1, 2, 3, 4], dtype=int32), unit='m')

classmethod from_(cls: type[AbstractQuantity], *args: Any, **kwargs: Any)#

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a unxt.Quantity from an array-like value and a unit.

Parameters:

value – The array-like value.
unit – The unit of the value.
dtype – The data type of the array (keyword-only).
args (Any)
kwargs (Any)

Return type:

Examples

For this example we’ll use the Quantity class. The same applies to any subclass of AbstractQuantity.

>>> import jax.numpy as jnp
>>> import unxt as u

>>> x = jnp.array([1.0, 2, 3])
>>> u.Quantity.from_(x, "m")
Quantity(Array([1., 2., 3.], dtype=float32), unit='m')

>>> u.Quantity.from_([1.0, 2, 3], "m")
Quantity(Array([1., 2., 3.], dtype=float32), unit='m')

>>> u.Quantity.from_((1.0, 2, 3), "m")
Quantity(Array([1., 2., 3.], dtype=float32), unit='m')

Parameters:

args (Any)
kwargs (Any)

Return type:

Make a unxt.AbstractQuantity from an array-like value and a unit kwarg.

Examples

For this example we’ll use the unxt.Quantity class. The same applies to any subclass of unxt.AbstractQuantity.

>>> import unxt as u
>>> u.Quantity.from_([1.0, 2, 3], unit="m")
Quantity(Array([1., 2., 3.], dtype=float32), unit='m')

from_(cls: type[AbstractQuantity], *, value: Any, unit: Any, dtype: Any = None) → AbstractQuantity

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a AbstractQuantity from value and unit kwargs.

Examples

For this example we’ll use the Quantity class. The same applies to any subclass of AbstractQuantity.

>>> import unxt as u
>>> u.Quantity.from_(value=[1.0, 2, 3], unit="m")
Quantity(Array([1., 2., 3.], dtype=float32), unit='m')

from_(cls: type[AbstractQuantity], mapping: Mapping[str, Any]) → AbstractQuantity

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a Quantity from a Mapping.

Examples

For this example we’ll use the Quantity class. The same applies to any subclass of AbstractQuantity.

>>> import jax.numpy as jnp
>>> import unxt as u

>>> x = jnp.array([1.0, 2, 3])
>>> q = u.Quantity.from_({"value": x, "unit": "m"})
>>> q
Quantity(Array([1., 2., 3.], dtype=float32), unit='m')

>>> u.Quantity.from_({"value": q, "unit": "km"})
Quantity(Array([0.001, 0.002, 0.003], dtype=float32), unit='km')

from_(cls: type[AbstractQuantity], value: AbstractQuantity, unit: Any, /, *, dtype: Any = None) → AbstractQuantity

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a Quantity from another Quantity.

The value is converted to the new unit.

Examples

>>> import unxt as u

>>> q = u.Quantity(1, "m")
>>> u.Quantity.from_(q, "cm")
Quantity(Array(100., dtype=float32, ...), unit='cm')

from_(cls: type[AbstractQuantity], value: AbstractQuantity, unit: NoneType, /, *, dtype: Any = None) → AbstractQuantity

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a Quantity from another Quantity.

The value is converted to the new unit.

Examples

>>> import unxt as u

>>> q = u.Quantity(1, "m")
>>> u.Quantity.from_(q, None)
Quantity(Array(1, dtype=int32, ...), unit='m')

from_(cls: type[AbstractQuantity], value: AbstractQuantity, /, *, unit: Any | None = None, dtype: Any = None) → AbstractQuantity

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a Quantity from another Quantity, with no unit change.

from_(cls: type[AbstractQuantity], value: Quantity, /, **kwargs: Any) → AbstractQuantity

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a Quantity from another Quantity.

The value is converted to the new unit.

Examples

>>> import unxt as u
>>> import astropy.units as apyu

>>> u.Quantity.from_(apyu.Quantity(1, "m"))
Quantity(Array(1., dtype=float32), unit='m')

from_(cls: type[AbstractQuantity], value: Quantity, u: Any, /, **kwargs: Any) → AbstractQuantity

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a Quantity from another Quantity.

The value is converted to the new unit.

Examples

>>> import unxt as u
>>> import astropy.units as apyu

>>> u.Quantity.from_(apyu.Quantity(1, "m"), "cm")
Quantity(Array(100., dtype=float32), unit='cm')

from_(cls: type[Distance], obj: AbstractDistance | Quantity[PhysicalType('length')] | Quantity[PhysicalType('angle')] | Quantity[PhysicalType('unknown')], /, **kw: Any) → Distance

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a Distance from the inputs.

from_(cls: type[DistanceModulus], dm: AbstractDistance | Quantity[PhysicalType('unknown')] | Quantity[PhysicalType('length')] | Quantity[PhysicalType('angle')], /, **kwargs: Any) → DistanceModulus

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a DistanceModulus from the input.

from_(cls: type[Parallax], obj: AbstractDistance | Quantity[PhysicalType('angle')] | Quantity[PhysicalType('length')] | Quantity[PhysicalType('unknown')], /, **kwargs: Any) → Parallax

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a Parallax the input.

Parameters:

cls (type[AbstractQuantity])
args (Any)
kwargs (Any)

Return type:

property mT: AbstractQuantity#

Matrix transpose of the array.

Examples

>>> import unxt as u
>>> q = u.Quantity([[0, 1], [1, 2]], "m")
>>> q.mT
Quantity(Array([[0, 1],
                          [1, 2]], dtype=int32), unit='m')

max(*args: Any, **kwargs: Any)#

Return the maximum value.

Examples

>>> import unxt as u
>>> q = u.Quantity([1, 2, 3], "m")
>>> q.max()
Quantity(Array(3, dtype=int32), unit='m')

Parameters:

args (Any)
kwargs (Any)

Return type:

mean(*args: Any, **kwargs: Any)#

Return the mean value.

Examples

>>> import unxt as u
>>> q = u.Quantity([1, 2, 3], "m")
>>> q.mean()
Quantity(Array(2., dtype=float32), unit='m')

Parameters:

args (Any)
kwargs (Any)

Return type:

min(*args: Any, **kwargs: Any)#

Return the minimum value.

Examples

>>> import unxt as u
>>> q = u.Quantity([1, 2, 3], "m")
>>> q.min()
Quantity(Array(1, dtype=int32), unit='m')

Parameters:

args (Any)
kwargs (Any)

Return type:

property ndim: int#

Number of dimensions.

Examples

>>> import unxt as u
>>> q = u.Quantity([[1]], "m")
>>> q.ndim
2

property parallax: AbstractDistance#

The parallax from a distance.

The parallax is calculated as \(\arctan(1 AU / d)\).

Examples

>>> import quaxed.numpy as jnp
>>> from coordinax.distance import Distance

>>> d = Distance(1, "pc")
>>> jnp.round(d.parallax.to("arcsec"), 2)
Parallax(Array(1., dtype=float32, ...), unit='arcsec')

>>> from coordinax.distance import DistanceModulus
>>> DistanceModulus(10, "mag").parallax.to("mas")
Parallax(Array(0.99999994, dtype=float32, ...), unit='mas')

>>> from coordinax.distance import Parallax
>>> p = Parallax(1, "mas")
>>> p.parallax is p
True

ravel()#

Return a flattened version of the array.

Return type:: AbstractQuantity

Examples

>>> import unxt as u
>>> q = u.Quantity([[1, 2], [3, 4]], "m")
>>> q.ravel()
Quantity(Array([1, 2, 3, 4], dtype=int32), unit='m')

reshape(*args: Any, order: str = 'C')#

Return a reshaped version of the array.

Examples

>>> import unxt as u
>>> q = u.Quantity([1, 2, 3, 4], "m")
>>> q.reshape(2, 2)
Quantity(Array([[1, 2],
                          [3, 4]], dtype=int32), unit='m')

Parameters:

args (Any)
order (str)

Return type:

round(*args: Any, **kwargs: Any)#

Round the array to the given number of decimals.

Examples

>>> import unxt as u
>>> q = u.Quantity([1.1, 2.2, 3.3], "m")
>>> q.round(0)
Quantity(Array([1., 2., 3.], dtype=float32), unit='m')

Parameters:

args (Any)
kwargs (Any)

Return type:

property shape: tuple[int, ...]#: Shape of the array.

property sharding: Any#

Return the sharding configuration of the array.

Examples

>>> import unxt as u
>>> q = u.Quantity([1, 2, 3], "m")
>>> q.sharding
SingleDeviceSharding(device=..., memory_kind=...)

property size: int#

Total number of elements.

Examples

>>> import unxt as u
>>> q = u.Quantity([1, 2, 3], "m")
>>> q.size
3

squeeze(*args: Any, **kwargs: Any)#

Return the array with all single-dimensional entries removed.

Examples

>>> import unxt as u
>>> q = u.Quantity([[[1], [2], [3]]], "m")
>>> q.squeeze()
Quantity(Array([1, 2, 3], dtype=int32), unit='m')

Parameters:

args (Any)
kwargs (Any)

Return type:

to(u: Any, /)#

Convert the quantity to the given units.

See unxt.quantity.AbstractQuantity.uconvert.

Examples

>>> from unxt import Quantity

>>> q = Quantity(1, "m")
>>> q.to("cm")
Quantity(Array(100., dtype=float32, ...), unit='cm')

Parameters:: u (Any)
Return type:: AbstractQuantity

to_device(device: None | Device = None)#

Move the array to a new device.

Examples

>>> import unxt as u
>>> q = u.Quantity(1, "m")
>>> q.to_device(None)
Quantity(Array(1, dtype=int32, weak_type=True), unit='m')

Parameters:: device (None | Device)
Return type:: AbstractQuantity

to_value(u: Any, /)#

Return the value in the given units.

See unxt.AbstractQuantity.ustrip.

Examples

>>> from unxt import Quantity

>>> q = Quantity(1, "m")
>>> q.to_value("cm")
Array(100., dtype=float32, weak_type=True)

Parameters:: u (Any)
Return type:: Union[Array, ndarray, bool, number, bool, int, float, complex]

uconvert(u: Any, /)#

Convert the quantity to the given units.

See also

None: convert a quantity to a new unit.

Examples

>>> import unxt as u

>>> q = u.Quantity(1, "m")
>>> q.uconvert("cm")
Quantity(Array(100., dtype=float32, ...), unit='cm')

Parameters:: u (Any)
Return type:: AbstractQuantity

ustrip(u: Any, /)#

Return the value in the given units.

See also

None: strip the units from a quantity.

Examples

>>> import unxt as u

>>> q = u.Quantity(1, "m")
>>> q.ustrip("cm")
Array(100., dtype=float32, weak_type=True)

Parameters:: u (Any)
Return type:: Array

value: Shaped[Array, '*shape']#: The value of the unxt.AbstractQuantity.

unit: Unit | UnitBase | CompositeUnit#: The unit associated with this value.

class coordinax.distance.Parallax(value: Any, unit: Any, *, check_negative: bool = True)#

Bases: AbstractDistance

Parallax distance quantity.

Examples

>>> from coordinax.distance import Parallax
>>> Parallax(1, "mas")
Parallax(Array(1, dtype=int32, ...), unit='mas')

The units are checked to have angle dimensions.

>>> try: Parallax(1, "pc")
... except ValueError as e: print(e)
Parallax must have angular dimensions.

The parallax is checked to be non-negative by default.

>>> try: Parallax(-1, "mas")
... except Exception: print("negative")
negative

To disable this check, set check_negative=False.

>>> Parallax(-1, "mas", check_negative=False)
Parallax(Array(-1, dtype=int32, weak_type=True), unit='mas', check_negative=False)

Parameters:

value (Any)
unit (Any)
check_negative (bool)

property T: AbstractQuantity#

Transpose of the array.

Examples

>>> import unxt as u
>>> q = u.Quantity([[0, 1], [1, 2]], "m")
>>> q.T
Quantity(Array([[0, 1],
                          [1, 2]], dtype=int32), unit='m')

argmax(*args: Any, **kwargs: Any)#

Return the indices of the maximum value.

Examples

>>> import unxt as u
>>> q = u.Quantity([1, 2, 3], "m")
>>> q.argmax()
Array(2, dtype=int32)

Parameters:

args (Any)
kwargs (Any)

Return type:

argmin(*args: Any, **kwargs: Any)#

Return the indices of the minimum value.

Examples

>>> import unxt as u
>>> q = u.Quantity([1, 2, 3], "m")
>>> q.argmin()
Array(0, dtype=int32)

Parameters:

args (Any)
kwargs (Any)

Return type:

astype(*args: Any, **kwargs: Any)#

Copy the array and cast to a specified dtype.

Examples

>>> import unxt as u
>>> q = u.Quantity([1, 2, 3], "m")
>>> q.dtype
dtype('int32')

>>> q.astype(float)
Quantity(Array([1., 2., 3.], dtype=float32), unit='m')

Parameters:

args (Any)
kwargs (Any)

Return type:

property at: _QuantityIndexUpdateHelper#

Helper property for index update functionality.

The at property provides a functionally pure equivalent of in-place array modifications.

In particular:

Alternate syntax	Equivalent In-place expression
`x = x.at[idx].set(y)`	`x[idx] = y`
`x = x.at[idx].add(y)`	`x[idx] += y`
`x = x.at[idx].subtract(y)`	`x[idx] -= y`
`x = x.at[idx].multiply(y)`	`x[idx] *= y`
`x = x.at[idx].divide(y)`	`x[idx] /= y`
`x = x.at[idx].power(y)`	`x[idx] **= y`
`x = x.at[idx].min(y)`	`x[idx] = minimum(x[idx], y)`
`x = x.at[idx].max(y)`	`x[idx] = maximum(x[idx], y)`
`x = x.at[idx].apply(ufunc)`	`ufunc.at(x, idx)`
`x = x.at[idx].get()`	`x = x[idx]`

None of the x.at expressions modify the original x; instead they return a modified copy of x. However, inside a jit() compiled function, expressions like x = x.at[idx].set(y) are guaranteed to be applied in-place.

Unlike NumPy in-place operations such as x[idx] += y, if multiple indices refer to the same location, all updates will be applied (NumPy would only apply the last update, rather than applying all updates.) The order in which conflicting updates are applied is implementation-defined and may be nondeterministic (e.g., due to concurrency on some hardware platforms).

By default, JAX assumes that all indices are in-bounds. Alternative out-of-bound index semantics can be specified via the mode parameter (see below).

Parameters:

mode (str) –
Specify out-of-bound indexing mode. Options are:
- "promise_in_bounds": (default) The user promises that indices are in bounds. No additional checking will be performed. In practice, this means that out-of-bounds indices in get() will be clipped, and out-of-bounds indices in set(), add(), etc. will be dropped.
- "clip": clamp out of bounds indices into valid range.
- "drop": ignore out-of-bound indices.
- "fill": alias for "drop". For get(), the optional fill_value argument specifies the value that will be returned.
  
  See jax.lax.GatherScatterMode for more details.
indices_are_sorted (bool) – If True, the implementation will assume that the indices passed to at[] are sorted in ascending order, which can lead to more efficient execution on some backends.
unique_indices (bool) – If True, the implementation will assume that the indices passed to at[] are unique, which can result in more efficient execution on some backends.
fill_value (Any) – Only applies to the get() method: the fill value to return for out-of-bounds slices when mode is 'fill'. Ignored otherwise. Defaults to NaN for inexact types, the largest negative value for signed types, the largest positive value for unsigned types, and True for booleans.

Examples

>>> x = jnp.arange(5.0)
>>> x
Array([0., 1., 2., 3., 4.], dtype=float32)
>>> x.at[2].add(10)
Array([ 0.,  1., 12.,  3.,  4.], dtype=float32)
>>> x.at[10].add(10)  # out-of-bounds indices are ignored
Array([0., 1., 2., 3., 4.], dtype=float32)
>>> x.at[20].add(10, mode='clip')
Array([ 0.,  1.,  2.,  3., 14.], dtype=float32)
>>> x.at[2].get()
Array(2., dtype=float32)
>>> x.at[20].get()  # out-of-bounds indices clipped
Array(4., dtype=float32)
>>> x.at[20].get(mode='fill')  # out-of-bounds indices filled with NaN
Array(nan, dtype=float32)
>>> x.at[20].get(mode='fill', fill_value=-1)  # custom fill value
Array(-1., dtype=float32)

block_until_ready()#

Block until the array is ready.

Return type:: AbstractQuantity

Examples

>>> import unxt as u
>>> q = u.Quantity(1, "m")
>>> q.block_until_ready() is q
True

check_negative: bool = True#

Whether to check that the parallax is strictly non-negative.

Theoretically the parallax must be strictly non-negative (:math:` an(p) = 1 AU / d`), however noisy direct measurements of the parallax can be negative.

decompose(bases: Sequence[Unit | UnitBase | CompositeUnit | str], /)#

Decompose the quantity into the given bases.

Examples

>>> from unxt import Quantity

>>> q = Quantity(1, "m")
>>> q.decompose(["cm", "s"])
Quantity(Array(100., dtype=float32, ...), unit='cm')

Parameters:: bases (Sequence[Unit | UnitBase | CompositeUnit | str])
Return type:: AbstractQuantity

property device: Device#

Device where the array is located.

Examples

>>> import unxt as u
>>> u.Quantity(1, "m").device
CpuDevice(id=0)

devices()#

Return the devices where the array is located.

Return type:: set[Device]

Examples

>>> import unxt as u
>>> q = u.Quantity(1, "m")
>>> q.devices()
{CpuDevice(id=0)}

property distance: AbstractDistance#

The distance.

Examples

>>> from coordinax.distance import Distance
>>> d = Distance(10, "km")
>>> d.distance is d
True

>>> from coordinax.distance import DistanceModulus
>>> DistanceModulus(10, "mag").distance
Distance(Array(1000., dtype=float32, ...), unit='pc')

>>> from coordinax.distance import Parallax
>>> p = Parallax(1, "mas")
>>> p.distance.to("kpc")
Distance(Array(1., dtype=float32, ...), unit='kpc')

property distance_modulus: AbstractDistance#

The distance modulus.

Examples

>>> from coordinax.distance import Distance
>>> d = Distance(1, "pc")
>>> d.distance_modulus
DistanceModulus(Array(-5., dtype=float32), unit='mag')

>>> from coordinax.distance import DistanceModulus
>>> DistanceModulus(10, "mag").distance_modulus
DistanceModulus(Array(10, dtype=int32, ...), unit='mag')

>>> from coordinax.distance import Parallax
>>> Parallax(1, "mas").distance_modulus
DistanceModulus(Array(10., dtype=float32), unit='mag')

property dtype: dtype#

Data type of the array.

Examples

>>> import unxt as u
>>> u.Quantity(1, "m").dtype
dtype('int32')

flatten()#

Return a flattened version of the array.

Return type:: AbstractQuantity

Examples

>>> import unxt as u
>>> q = u.Quantity([[1, 2], [3, 4]], "m")
>>> q.flatten()
Quantity(Array([1, 2, 3, 4], dtype=int32), unit='m')

classmethod from_(cls: type[AbstractQuantity], *args: Any, **kwargs: Any)#

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a unxt.Quantity from an array-like value and a unit.

Parameters:

value – The array-like value.
unit – The unit of the value.
dtype – The data type of the array (keyword-only).
args (Any)
kwargs (Any)

Return type:

Examples

For this example we’ll use the Quantity class. The same applies to any subclass of AbstractQuantity.

>>> import jax.numpy as jnp
>>> import unxt as u

>>> x = jnp.array([1.0, 2, 3])
>>> u.Quantity.from_(x, "m")
Quantity(Array([1., 2., 3.], dtype=float32), unit='m')

>>> u.Quantity.from_([1.0, 2, 3], "m")
Quantity(Array([1., 2., 3.], dtype=float32), unit='m')

>>> u.Quantity.from_((1.0, 2, 3), "m")
Quantity(Array([1., 2., 3.], dtype=float32), unit='m')

Parameters:

args (Any)
kwargs (Any)

Return type:

Make a unxt.AbstractQuantity from an array-like value and a unit kwarg.

Examples

For this example we’ll use the unxt.Quantity class. The same applies to any subclass of unxt.AbstractQuantity.

>>> import unxt as u
>>> u.Quantity.from_([1.0, 2, 3], unit="m")
Quantity(Array([1., 2., 3.], dtype=float32), unit='m')

from_(cls: type[AbstractQuantity], *, value: Any, unit: Any, dtype: Any = None) → AbstractQuantity

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a AbstractQuantity from value and unit kwargs.

Examples

For this example we’ll use the Quantity class. The same applies to any subclass of AbstractQuantity.

>>> import unxt as u
>>> u.Quantity.from_(value=[1.0, 2, 3], unit="m")
Quantity(Array([1., 2., 3.], dtype=float32), unit='m')

from_(cls: type[AbstractQuantity], mapping: Mapping[str, Any]) → AbstractQuantity

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a Quantity from a Mapping.

Examples

For this example we’ll use the Quantity class. The same applies to any subclass of AbstractQuantity.

>>> import jax.numpy as jnp
>>> import unxt as u

>>> x = jnp.array([1.0, 2, 3])
>>> q = u.Quantity.from_({"value": x, "unit": "m"})
>>> q
Quantity(Array([1., 2., 3.], dtype=float32), unit='m')

>>> u.Quantity.from_({"value": q, "unit": "km"})
Quantity(Array([0.001, 0.002, 0.003], dtype=float32), unit='km')

from_(cls: type[AbstractQuantity], value: AbstractQuantity, unit: Any, /, *, dtype: Any = None) → AbstractQuantity

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a Quantity from another Quantity.

The value is converted to the new unit.

Examples

>>> import unxt as u

>>> q = u.Quantity(1, "m")
>>> u.Quantity.from_(q, "cm")
Quantity(Array(100., dtype=float32, ...), unit='cm')

from_(cls: type[AbstractQuantity], value: AbstractQuantity, unit: NoneType, /, *, dtype: Any = None) → AbstractQuantity

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a Quantity from another Quantity.

The value is converted to the new unit.

Examples

>>> import unxt as u

>>> q = u.Quantity(1, "m")
>>> u.Quantity.from_(q, None)
Quantity(Array(1, dtype=int32, ...), unit='m')

from_(cls: type[AbstractQuantity], value: AbstractQuantity, /, *, unit: Any | None = None, dtype: Any = None) → AbstractQuantity

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a Quantity from another Quantity, with no unit change.

from_(cls: type[AbstractQuantity], value: Quantity, /, **kwargs: Any) → AbstractQuantity

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a Quantity from another Quantity.

The value is converted to the new unit.

Examples

>>> import unxt as u
>>> import astropy.units as apyu

>>> u.Quantity.from_(apyu.Quantity(1, "m"))
Quantity(Array(1., dtype=float32), unit='m')

from_(cls: type[AbstractQuantity], value: Quantity, u: Any, /, **kwargs: Any) → AbstractQuantity

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a Quantity from another Quantity.

The value is converted to the new unit.

Examples

>>> import unxt as u
>>> import astropy.units as apyu

>>> u.Quantity.from_(apyu.Quantity(1, "m"), "cm")
Quantity(Array(100., dtype=float32), unit='cm')

from_(cls: type[Distance], obj: AbstractDistance | Quantity[PhysicalType('length')] | Quantity[PhysicalType('angle')] | Quantity[PhysicalType('unknown')], /, **kw: Any) → Distance

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a Distance from the inputs.

from_(cls: type[DistanceModulus], dm: AbstractDistance | Quantity[PhysicalType('unknown')] | Quantity[PhysicalType('length')] | Quantity[PhysicalType('angle')], /, **kwargs: Any) → DistanceModulus

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a DistanceModulus from the input.

from_(cls: type[Parallax], obj: AbstractDistance | Quantity[PhysicalType('angle')] | Quantity[PhysicalType('length')] | Quantity[PhysicalType('unknown')], /, **kwargs: Any) → Parallax

Parameters:

args (Any)
kwargs (Any)

Return type:

Construct a Parallax the input.

Parameters:

cls (type[AbstractQuantity])
args (Any)
kwargs (Any)

Return type:

property mT: AbstractQuantity#

Matrix transpose of the array.

Examples

>>> import unxt as u
>>> q = u.Quantity([[0, 1], [1, 2]], "m")
>>> q.mT
Quantity(Array([[0, 1],
                          [1, 2]], dtype=int32), unit='m')

max(*args: Any, **kwargs: Any)#

Return the maximum value.

Examples

>>> import unxt as u
>>> q = u.Quantity([1, 2, 3], "m")
>>> q.max()
Quantity(Array(3, dtype=int32), unit='m')

Parameters:

args (Any)
kwargs (Any)

Return type:

mean(*args: Any, **kwargs: Any)#

Return the mean value.

Examples

>>> import unxt as u
>>> q = u.Quantity([1, 2, 3], "m")
>>> q.mean()
Quantity(Array(2., dtype=float32), unit='m')

Parameters:

args (Any)
kwargs (Any)

Return type:

min(*args: Any, **kwargs: Any)#

Return the minimum value.

Examples

>>> import unxt as u
>>> q = u.Quantity([1, 2, 3], "m")
>>> q.min()
Quantity(Array(1, dtype=int32), unit='m')

Parameters:

args (Any)
kwargs (Any)

Return type:

property ndim: int#

Number of dimensions.

Examples

>>> import unxt as u
>>> q = u.Quantity([[1]], "m")
>>> q.ndim
2

property parallax: AbstractDistance#

The parallax from a distance.

The parallax is calculated as \(\arctan(1 AU / d)\).

Examples

>>> import quaxed.numpy as jnp
>>> from coordinax.distance import Distance

>>> d = Distance(1, "pc")
>>> jnp.round(d.parallax.to("arcsec"), 2)
Parallax(Array(1., dtype=float32, ...), unit='arcsec')

>>> from coordinax.distance import DistanceModulus
>>> DistanceModulus(10, "mag").parallax.to("mas")
Parallax(Array(0.99999994, dtype=float32, ...), unit='mas')

>>> from coordinax.distance import Parallax
>>> p = Parallax(1, "mas")
>>> p.parallax is p
True

ravel()#

Return a flattened version of the array.

Return type:: AbstractQuantity

Examples

>>> import unxt as u
>>> q = u.Quantity([[1, 2], [3, 4]], "m")
>>> q.ravel()
Quantity(Array([1, 2, 3, 4], dtype=int32), unit='m')

reshape(*args: Any, order: str = 'C')#

Return a reshaped version of the array.

Examples

>>> import unxt as u
>>> q = u.Quantity([1, 2, 3, 4], "m")
>>> q.reshape(2, 2)
Quantity(Array([[1, 2],
                          [3, 4]], dtype=int32), unit='m')

Parameters:

args (Any)
order (str)

Return type:

round(*args: Any, **kwargs: Any)#

Round the array to the given number of decimals.

Examples

>>> import unxt as u
>>> q = u.Quantity([1.1, 2.2, 3.3], "m")
>>> q.round(0)
Quantity(Array([1., 2., 3.], dtype=float32), unit='m')

Parameters:

args (Any)
kwargs (Any)

Return type:

property shape: tuple[int, ...]#: Shape of the array.

property sharding: Any#

Return the sharding configuration of the array.

Examples

>>> import unxt as u
>>> q = u.Quantity([1, 2, 3], "m")
>>> q.sharding
SingleDeviceSharding(device=..., memory_kind=...)

property size: int#

Total number of elements.

Examples

>>> import unxt as u
>>> q = u.Quantity([1, 2, 3], "m")
>>> q.size
3

squeeze(*args: Any, **kwargs: Any)#

Return the array with all single-dimensional entries removed.

Examples

>>> import unxt as u
>>> q = u.Quantity([[[1], [2], [3]]], "m")
>>> q.squeeze()
Quantity(Array([1, 2, 3], dtype=int32), unit='m')

Parameters:

args (Any)
kwargs (Any)

Return type:

to(u: Any, /)#

Convert the quantity to the given units.

See unxt.quantity.AbstractQuantity.uconvert.

Examples

>>> from unxt import Quantity

>>> q = Quantity(1, "m")
>>> q.to("cm")
Quantity(Array(100., dtype=float32, ...), unit='cm')

Parameters:: u (Any)
Return type:: AbstractQuantity

to_device(device: None | Device = None)#

Move the array to a new device.

Examples

>>> import unxt as u
>>> q = u.Quantity(1, "m")
>>> q.to_device(None)
Quantity(Array(1, dtype=int32, weak_type=True), unit='m')

Parameters:: device (None | Device)
Return type:: AbstractQuantity

to_value(u: Any, /)#

Return the value in the given units.

See unxt.AbstractQuantity.ustrip.

Examples

>>> from unxt import Quantity

>>> q = Quantity(1, "m")
>>> q.to_value("cm")
Array(100., dtype=float32, weak_type=True)

Parameters:: u (Any)
Return type:: Union[Array, ndarray, bool, number, bool, int, float, complex]

uconvert(u: Any, /)#

Convert the quantity to the given units.

See also

None: convert a quantity to a new unit.

Examples

>>> import unxt as u

>>> q = u.Quantity(1, "m")
>>> q.uconvert("cm")
Quantity(Array(100., dtype=float32, ...), unit='cm')

Parameters:: u (Any)
Return type:: AbstractQuantity

ustrip(u: Any, /)#

Return the value in the given units.

See also

None: strip the units from a quantity.

Examples

>>> import unxt as u

>>> q = u.Quantity(1, "m")
>>> q.ustrip("cm")
Array(100., dtype=float32, weak_type=True)

Parameters:: u (Any)
Return type:: Array

value: Shaped[Array, '*shape']#: The value of the unxt.AbstractQuantity.

unit: Unit | UnitBase | CompositeUnit#: The unit associated with this value.

Construct a distance.

Examples

>>> import unxt as u
>>> import coordinax.distance as cxd

>>> cxd.distance(1, "kpc")
Distance(Array(1, dtype=int32, ...), unit='kpc')

coordinax.distance.distance(d: Distance, /, **kw: Any) → Distance

Parameters:

value (Array | ndarray | bool | number | bool | int | float | complex)
unit (Any)
kw (Any)

Return type:

Compute distance from distance.

Examples

>>> import unxt as u
>>> import coordinax.distance as cxd

>>> d = cxd.Distance(1, "kpc")
>>> cxd.distance(d) is d
True

>>> cxd.distance(d, dtype=float)
Distance(Array(1., dtype=float32), unit='kpc')

coordinax.distance.distance(d: Quantity[PhysicalType('length')], /, **kw: Any) → Distance

Parameters:

value (Array | ndarray | bool | number | bool | int | float | complex)
unit (Any)
kw (Any)

Return type:

Compute distance from distance.

Examples

>>> import unxt as u
>>> import coordinax.distance as cxd

>>> q = u.Quantity(1, "kpc")
>>> cxd.distance(q, dtype=float)
Distance(Array(1., dtype=float32), unit='kpc')

coordinax.distance.distance(p: Parallax | Quantity[PhysicalType('angle')], /, **kw: Any) → Distance

Parameters:

value (Array | ndarray | bool | number | bool | int | float | complex)
unit (Any)
kw (Any)

Return type:

Compute distance from parallax.

Examples

>>> import unxt as u
>>> import coordinax.distance as cxd

>>> p = cxd.Parallax(1, "mas")
>>> cxd.distance(p).uconvert("pc").round(2)
Distance(Array(1000., dtype=float32, ...), unit='pc')

>>> q = u.Quantity(1, "mas")
>>> cxd.distance(q).uconvert("pc").round(2)
Distance(Array(1000., dtype=float32, ...), unit='pc')

coordinax.distance.distance(dm: DistanceModulus | Quantity[PhysicalType('unknown')], /, **kw: Any) → Distance

Parameters:

value (Array | ndarray | bool | number | bool | int | float | complex)
unit (Any)
kw (Any)

Return type:

Compute distance from distance modulus.

Examples

>>> import unxt as u
>>> import coordinax.distance as cxd

>>> dm = cxd.DistanceModulus(10, "mag")
>>> cxd.distance(dm).uconvert("pc").round(2)
Distance(Array(1000., dtype=float32, ...), unit='pc')

>>> q = u.Quantity(10, "mag")
>>> cxd.distance(q).uconvert("pc").round(2)
Distance(Array(1000., dtype=float32, ...), unit='pc')

Parameters:

value (Union[Array, ndarray, bool, number, bool, int, float, complex])
unit (Any)
kw (Any)

Return type:

Distance

Construct a distance.

Examples

>>> import unxt as u
>>> import coordinax.distance as cxd

>>> cxd.parallax(1, "mas")
Parallax(Array(1, dtype=int32, ...), unit='mas')

coordinax.distance.parallax(p: Parallax, /, **kw: Any) → Parallax

Parameters:

value (Array | ndarray | bool | number | bool | int | float | complex)
unit (Any)
kw (Any)

Return type:

Compute parallax from parallax.

Examples

>>> import unxt as u
>>> import coordinax.distance as cxd

>>> p = cxd.Parallax(1, "mas")
>>> cxd.parallax(p) is p
True

>>> cxd.parallax(p, dtype=float)
Parallax(Array(1., dtype=float32), unit='mas')

coordinax.distance.parallax(p: Quantity[PhysicalType('angle')], /, **kw: Any) → Parallax

Parameters:

value (Array | ndarray | bool | number | bool | int | float | complex)
unit (Any)
kw (Any)

Return type:

Compute parallax from parallax.

Examples

>>> import unxt as u
>>> import coordinax.distance as cxd

>>> q = u.Quantity(1, "mas")
>>> cxd.parallax(q, dtype=float)
Parallax(Array(1., dtype=float32), unit='mas')

coordinax.distance.parallax(d: Distance | Quantity[PhysicalType('length')], /, **kw: Any) → Parallax

Parameters:

value (Array | ndarray | bool | number | bool | int | float | complex)
unit (Any)
kw (Any)

Return type:

Compute parallax from distance.

Examples

>>> import unxt as u
>>> import coordinax.distance as cxd

>>> d = cxd.Distance(10, "pc")
>>> cxd.parallax(d).uconvert("mas").round(2)
Parallax(Array(100., dtype=float32, ...), unit='mas')

>>> q = u.Quantity(10, "pc")
>>> cxd.parallax(q).uconvert("mas").round(2)
Parallax(Array(100., dtype=float32, ...), unit='mas')

coordinax.distance.parallax(dm: DistanceModulus | Quantity[PhysicalType('unknown')], /, **kw: Any) → Parallax

Parameters:

value (Array | ndarray | bool | number | bool | int | float | complex)
unit (Any)
kw (Any)

Return type:

Convert distance modulus to parallax.

Examples

>>> import unxt as u
>>> import coordinax.distance as cxd

>>> dm = cxd.DistanceModulus(10, "mag")
>>> cxd.parallax(dm).uconvert("mas").round(2)
Parallax(Array(1., dtype=float32, ...), unit='mas')

Parameters:

value (Union[Array, ndarray, bool, number, bool, int, float, complex])
unit (Any)
kw (Any)

Return type:

Parallax

Construct a distance.

Examples

>>> import unxt as u
>>> import coordinax.distance as cxd

>>> cxd.distance_modulus(1, "mag")
DistanceModulus(Array(1, dtype=int32, ...), unit='mag')

coordinax.distance.distance_modulus(dm: DistanceModulus, /, **kw: Any) → DistanceModulus

Parameters:

value (Array | ndarray | bool | number | bool | int | float | complex)
unit (Any)
kw (Any)

Return type:

Compute distance modulus from distance modulus.

Examples

>>> import unxt as u
>>> import coordinax.distance as cxd

>>> dm = cxd.DistanceModulus(1, "mag")
>>> cxd.distance_modulus(dm) is dm
True

>>> cxd.distance_modulus(dm, dtype=float)
DistanceModulus(Array(1., dtype=float32), unit='mag')

coordinax.distance.distance_modulus(dm: Quantity[PhysicalType('unknown')], /, **kw: Any) → DistanceModulus

Parameters:

value (Array | ndarray | bool | number | bool | int | float | complex)
unit (Any)
kw (Any)

Return type:

Compute parallax from parallax.

Examples

>>> import unxt as u
>>> import coordinax.distance as cxd

>>> q = u.Quantity(1, "mag")
>>> cxd.distance_modulus(q)
DistanceModulus(Array(1, dtype=int32, ...), unit='mag')

coordinax.distance.distance_modulus(d: Distance | Quantity[PhysicalType('length')], /, **kw: Any) → DistanceModulus

Parameters:

value (Array | ndarray | bool | number | bool | int | float | complex)
unit (Any)
kw (Any)

Return type:

Compute distance modulus from distance.

Examples

>>> import unxt as u
>>> import coordinax.distance as cxd

>>> d = cxd.Distance(1, "pc")
>>> cxd.distance_modulus(d)
DistanceModulus(Array(-5., dtype=float32), unit='mag')

>>> q = u.Quantity(1, "pc")
>>> cxd.distance_modulus(q)
DistanceModulus(Array(-5., dtype=float32), unit='mag')

coordinax.distance.distance_modulus(p: Parallax | Quantity[PhysicalType('angle')], /, **kw: Any) → DistanceModulus

Parameters:

value (Array | ndarray | bool | number | bool | int | float | complex)
unit (Any)
kw (Any)

Return type: