def test_parsing(self):
su = Unit('AU, AU/d')
assert isinstance(su, StructuredUnit)
assert isinstance(su['f0'], UnitBase)
assert isinstance(su['f1'], UnitBase)
assert su['f0'] == u.AU
assert su['f1'] == u.AU/u.day
su2 = Unit('AU, AU/d, yr')
assert isinstance(su2, StructuredUnit)
assert su2 == StructuredUnit(('AU', 'AU/d', 'yr'))
su2a = Unit('(AU, AU/d, yr)')
assert isinstance(su2a, StructuredUnit)
assert su2a == su2
su3 = Unit('(km, km/s), yr')
assert isinstance(su3, StructuredUnit)
assert su3 == StructuredUnit((('km', 'km/s'), 'yr'))
su4 = Unit('km,')
assert isinstance(su4, StructuredUnit)
assert su4 == StructuredUnit((u.km,))
su5 = Unit('(m,s),')
assert isinstance(su5, StructuredUnit)
assert su5 == StructuredUnit(((u.m, u.s),))
ldbody_unit = Unit('Msun, 0.5rad^2, (au, au/day)')
assert ldbody_unit == StructuredUnit(
(u.Msun, Unit(u.rad**2 / 2), (u.AU, u.AU / u.day)))
def test_conversion(self):
pv1 = self.pv_unit.to(('AU', 'AU/day'), self.pv)
assert isinstance(pv1, np.ndarray)
assert pv1.dtype == self.pv.dtype
assert np.all(pv1['p'] * u.AU == self.pv['p'] * self.p_unit)
assert np.all(pv1['v'] * u.AU / u.day == self.pv['v'] * self.v_unit)
# Names should be from value.
su2 = StructuredUnit((self.p_unit, self.v_unit),
('position', 'velocity'))
pv2 = su2.to(('Mm', 'mm/s'), self.pv)
assert pv2.dtype.names == ('p', 'v')
assert pv2.dtype == self.pv.dtype
# Check recursion.
pv_t1 = self.pv_t_unit.to((('AU', 'AU/day'), 'Myr'), self.pv_t)
assert isinstance(pv_t1, np.ndarray)
assert pv_t1.dtype == self.pv_t.dtype
assert np.all(pv_t1['pv']['p'] * u.AU ==
self.pv_t['pv']['p'] * self.p_unit)
assert np.all(pv_t1['pv']['v'] * u.AU / u.day ==
self.pv_t['pv']['v'] * self.v_unit)
assert np.all(pv_t1['t'] * u.Myr == self.pv_t['t'] * self.t_unit)
# Passing in tuples should work.
pv_t2 = self.pv_t_unit.to((('AU', 'AU/day'), 'Myr'),
((1., 0.1), 10.))
assert pv_t2['pv']['p'] == self.p_unit.to('AU', 1.)
assert pv_t2['pv']['v'] == self.v_unit.to('AU/day', 0.1)
assert pv_t2['t'] == self.t_unit.to('Myr', 10.)
pv_t3 = self.pv_t_unit.to((('AU', 'AU/day'), 'Myr'),
[((1., 0.1), 10.),
((2., 0.2), 20.)])
assert np.all(pv_t3['pv']['p'] == self.p_unit.to('AU', [1., 2.]))
assert np.all(pv_t3['pv']['v'] == self.v_unit.to('AU/day', [0.1, 0.2]))
assert np.all(pv_t3['t'] == self.t_unit.to('Myr', [10., 20.]))
def test_initialize_single_field(self):
su = StructuredUnit('AU', 'p')
assert isinstance(su, StructuredUnit)
assert isinstance(su['p'], UnitBase)
assert su['p'] == u.AU
su = StructuredUnit('AU')
assert isinstance(su, StructuredUnit)
assert isinstance(su['f0'], UnitBase)
assert su['f0'] == u.AU
def test_initialize_with_float_dtype(self):
su = StructuredUnit(('AU', 'AU/d'), self.pv_dtype)
assert isinstance(su['p'], UnitBase)
assert isinstance(su['v'], UnitBase)
assert su['p'] == u.AU
assert su['v'] == u.AU / u.day
su = StructuredUnit((('km', 'km/s'), 'yr'), self.pv_t_dtype)
assert isinstance(su['pv'], StructuredUnit)
assert isinstance(su['pv']['p'], UnitBase)
assert isinstance(su['t'], UnitBase)
assert su['pv']['v'] == u.km / u.s
su = StructuredUnit('(km, km/s), yr', self.pv_t_dtype)
assert isinstance(su['pv'], StructuredUnit)
assert isinstance(su['pv']['p'], UnitBase)
assert isinstance(su['t'], UnitBase)
assert su['pv']['v'] == u.km / u.s
def test_unit_initialization(self):
mag_time_unit = StructuredUnit((u.STmag, u.s), self.mag_time_dtype)
assert mag_time_unit['mag'] == u.STmag
assert mag_time_unit['t'] == u.s
mag_time_unit2 = u.Unit('mag(ST),s')
assert mag_time_unit2 == mag_time_unit
def test_extreme_recursive_initialization(self):
su = StructuredUnit('(yr,(AU,AU/day,(km,(day,day))),m)',
('t', ('p', 'v', ('h', ('d1', 'd2'))), 'l'))
assert su.field_names == ('t', ['pvhd1d2',
('p', 'v',
['hd1d2',
('h',
['d1d2',
('d1', 'd2')])])], 'l')
def test_is_equivalent(self):
assert self.pv_unit.is_equivalent(('AU', 'AU/day'))
assert not self.pv_unit.is_equivalent('m')
assert not self.pv_unit.is_equivalent(('AU', 'AU'))
# Names should be ignored.
pv_alt = StructuredUnit('m,m/s', names=('q', 'w'))
assert pv_alt.field_names != self.pv_unit.field_names
assert self.pv_unit.is_equivalent(pv_alt)
# Regular units should work too.
assert not u.m.is_equivalent(self.pv_unit)
def test_initialization_and_keying(self):
su = StructuredUnit((self.p_unit, self.v_unit), ('p', 'v'))
assert su['p'] is self.p_unit
assert su['v'] is self.v_unit
su2 = StructuredUnit((su, self.t_unit), ('pv', 't'))
assert isinstance(su2['pv'], StructuredUnit)
assert su2['pv']['p'] is self.p_unit
assert su2['pv']['v'] is self.v_unit
assert su2['t'] is self.t_unit
assert su2['pv'] == su
su3 = StructuredUnit(('AU', 'AU/day'), ('p', 'v'))
assert isinstance(su3['p'], UnitBase)
assert isinstance(su3['v'], UnitBase)
su4 = StructuredUnit('AU, AU/day', ('p', 'v'))
assert su4['p'] == u.AU
assert su4['v'] == u.AU / u.day
su5 = StructuredUnit(('AU', 'AU/day'))
assert su5.field_names == ('f0', 'f1')
assert su5['f0'] == u.AU
assert su5['f1'] == u.AU / u.day
def test_equality(self):
su = StructuredUnit(('AU', 'AU/d'), self.pv_dtype)
assert su == StructuredUnit(('AU', 'AU/d'), self.pv_dtype)
assert su != StructuredUnit(('m', 'AU/d'), self.pv_dtype)
# Names should be ignored.
assert su == StructuredUnit(('AU', 'AU/d'))
assert su == StructuredUnit(('AU', 'AU/d'), names=('q', 'w'))
assert su != StructuredUnit(('m', 'm/s'))
def test_recursive_initialization(self):
su = StructuredUnit(((self.p_unit, self.v_unit), self.t_unit),
(('p', 'v'), 't'))
assert isinstance(su['pv'], StructuredUnit)
assert su['pv']['p'] is self.p_unit
assert su['pv']['v'] is self.v_unit
assert su['t'] is self.t_unit
su2 = StructuredUnit(((self.p_unit, self.v_unit), self.t_unit),
(['p_v', ('p', 'v')], 't'))
assert isinstance(su2['p_v'], StructuredUnit)
assert su2['p_v']['p'] is self.p_unit
assert su2['p_v']['v'] is self.v_unit
assert su2['t'] is self.t_unit
su3 = StructuredUnit((('AU', 'AU/day'), 'yr'),
(['p_v', ('p', 'v')], 't'))
assert isinstance(su3['p_v'], StructuredUnit)
assert su3['p_v']['p'] == u.AU
assert su3['p_v']['v'] == u.AU / u.day
assert su3['t'] == u.yr
su4 = StructuredUnit('(AU, AU/day), yr', (('p', 'v'), 't'))
assert isinstance(su4['pv'], StructuredUnit)
assert su4['pv']['p'] == u.AU
assert su4['pv']['v'] == u.AU / u.day
assert su4['t'] == u.yr
def test_inplace_conversion(self):
q_pv = Quantity(self.pv, self.pv_unit)
q1 = q_pv.copy()
q_link = q1
q1 <<= StructuredUnit(('AU', 'AU/day'))
assert q1 is q_link
assert q1['p'].unit == u.AU
assert q1['v'].unit == u.AU / u.day
assert np.all(q1['p'] == q_pv['p'].to(u.AU))
assert np.all(q1['v'] == q_pv['v'].to(u.AU/u.day))
q_pv_t = Quantity(self.pv_t, self.pv_t_unit)
q2 = q_pv_t.copy()
q_link = q2
q2 <<= '(kpc,kpc/Myr),Myr'
assert q2 is q_link
assert q2['pv']['p'].unit == u.kpc
assert q2['pv']['v'].unit == u.kpc / u.Myr
assert q2['t'].unit == u.Myr
assert np.all(q2['pv']['p'] == q_pv_t['pv']['p'].to(u.kpc))
assert np.all(q2['pv']['v'] == q_pv_t['pv']['v'].to(u.kpc/u.Myr))
assert np.all(q2['t'] == q_pv_t['t'].to(u.Myr))
def test_conversion_via_lshift(self):
q_pv = Quantity(self.pv, self.pv_unit)
q1 = q_pv << StructuredUnit(('AU', 'AU/day'))
assert isinstance(q1, Quantity)
assert q1['p'].unit == u.AU
assert q1['v'].unit == u.AU / u.day
assert np.all(q1['p'] == q_pv['p'].to(u.AU))
assert np.all(q1['v'] == q_pv['v'].to(u.AU/u.day))
q2 = q_pv << self.pv_unit
assert q2['p'].unit == self.p_unit
assert q2['v'].unit == self.v_unit
assert np.all(q2['p'].value == self.pv['p'])
assert np.all(q2['v'].value == self.pv['v'])
assert np.may_share_memory(q2, q_pv)
q_pv_t = Quantity(self.pv_t, self.pv_t_unit)
q2 = q_pv_t << '(kpc,kpc/Myr),Myr'
assert q2['pv']['p'].unit == u.kpc
assert q2['pv']['v'].unit == u.kpc / u.Myr
assert q2['t'].unit == u.Myr
assert np.all(q2['pv']['p'] == q_pv_t['pv']['p'].to(u.kpc))
assert np.all(q2['pv']['v'] == q_pv_t['pv']['v'].to(u.kpc/u.Myr))
assert np.all(q2['t'] == q_pv_t['t'].to(u.Myr))
def test_str(self):
su = StructuredUnit(((u.km, u.km/u.s), u.yr))
assert str(su) == '((km, km / s), yr)'
assert Unit(str(su)) == su
def setup_class(self):
super().setup_class()
self.pv_unit = StructuredUnit((self.p_unit, self.v_unit),
('p', 'v'))
self.pv_t_unit = StructuredUnit((self.pv_unit, self.t_unit),
('pv', 't'))
def test_initialization_names_invalid_list_errors(self, names, invalid):
with pytest.raises(ValueError) as exc:
StructuredUnit('(yr,(AU,AU/day)', names)
assert f'invalid entry {invalid}' in str(exc)
def test_to_string(self):
su = StructuredUnit((u.km, u.km / u.s))
latex_str = r'$(\mathrm{km}, \mathrm{\frac{km}{s}})$'
assert su.to_string(format='latex') == latex_str
latex_str = r'$(\mathrm{km}, \mathrm{km\,s^{-1}})$'
assert su.to_string(format='latex_inline') == latex_str
def test_looks_like_unit(self):
su = StructuredUnit((self.p_unit, self.v_unit), ('p', 'v'))
assert Unit(su) is su
def test_initialize_with_structured_unit_for_names(self):
su = StructuredUnit(('AU', 'AU/d'), names=('p', 'v'))
su2 = StructuredUnit(('km', 'km/s'), names=su)
assert su2.field_names == ('p', 'v')
assert su2['p'] == u.km
assert su2['v'] == u.km / u.s
def test_repr(self):
su = StructuredUnit(((u.km, u.km/u.s), u.yr))
assert repr(su) == 'Unit("((km, km / s), yr)")'
assert eval(repr(su)) == su
def unstructured_to_structured(arr, dtype, *args, **kwargs):
from astropy.units import StructuredUnit
target_unit = StructuredUnit(_build_structured_unit(dtype, arr.unit))
return (arr.to_value(arr.unit), dtype) + args, kwargs, target_unit, None
