import copy
import math
import pprint
import unittest
import pytest
from pint import Context, DimensionalityError, UnitRegistry
from pint.compat import np
from pint.testsuite import QuantityTestCase, helpers
from pint.unit import UnitsContainer
from pint.util import ParserHelper
ureg = UnitRegistry()
[docs]class TestIssues(QuantityTestCase):
FORCE_NDARRAY = False
def setup(self):
self.ureg.autoconvert_offset_to_baseunit = False
@unittest.expectedFailure
def test_issue25(self):
x = ParserHelper.from_string("10 %")
self.assertEqual(x, ParserHelper(10, {"%": 1}))
x = ParserHelper.from_string("10 ‰")
self.assertEqual(x, ParserHelper(10, {"‰": 1}))
ureg.define("percent = [fraction]; offset: 0 = %")
ureg.define("permille = percent / 10 = ‰")
x = ureg.parse_expression("10 %")
self.assertEqual(x, ureg.Quantity(10, {"%": 1}))
y = ureg.parse_expression("10 ‰")
self.assertEqual(y, ureg.Quantity(10, {"‰": 1}))
self.assertEqual(x.to("‰"), ureg.Quantity(1, {"‰": 1}))
def test_issue29(self):
t = 4 * ureg("mW")
self.assertEqual(t.magnitude, 4)
self.assertEqual(t._units, UnitsContainer(milliwatt=1))
self.assertEqual(t.to("joule / second"), 4e-3 * ureg("W"))
@unittest.expectedFailure
@helpers.requires_numpy()
def test_issue37(self):
x = np.ma.masked_array([1, 2, 3], mask=[True, True, False])
q = ureg.meter * x
self.assertIsInstance(q, ureg.Quantity)
np.testing.assert_array_equal(q.magnitude, x)
self.assertEqual(q.units, ureg.meter.units)
q = x * ureg.meter
self.assertIsInstance(q, ureg.Quantity)
np.testing.assert_array_equal(q.magnitude, x)
self.assertEqual(q.units, ureg.meter.units)
m = np.ma.masked_array(2 * np.ones(3, 3))
qq = q * m
self.assertIsInstance(qq, ureg.Quantity)
np.testing.assert_array_equal(qq.magnitude, x * m)
self.assertEqual(qq.units, ureg.meter.units)
qq = m * q
self.assertIsInstance(qq, ureg.Quantity)
np.testing.assert_array_equal(qq.magnitude, x * m)
self.assertEqual(qq.units, ureg.meter.units)
@unittest.expectedFailure
@helpers.requires_numpy()
def test_issue39(self):
x = np.matrix([[1, 2, 3], [1, 2, 3], [1, 2, 3]])
q = ureg.meter * x
self.assertIsInstance(q, ureg.Quantity)
np.testing.assert_array_equal(q.magnitude, x)
self.assertEqual(q.units, ureg.meter.units)
q = x * ureg.meter
self.assertIsInstance(q, ureg.Quantity)
np.testing.assert_array_equal(q.magnitude, x)
self.assertEqual(q.units, ureg.meter.units)
m = np.matrix(2 * np.ones(3, 3))
qq = q * m
self.assertIsInstance(qq, ureg.Quantity)
np.testing.assert_array_equal(qq.magnitude, x * m)
self.assertEqual(qq.units, ureg.meter.units)
qq = m * q
self.assertIsInstance(qq, ureg.Quantity)
np.testing.assert_array_equal(qq.magnitude, x * m)
self.assertEqual(qq.units, ureg.meter.units)
@helpers.requires_numpy()
def test_issue44(self):
x = 4.0 * ureg.dimensionless
np.sqrt(x)
self.assertQuantityAlmostEqual(
np.sqrt([4.0] * ureg.dimensionless), [2.0] * ureg.dimensionless
)
self.assertQuantityAlmostEqual(
np.sqrt(4.0 * ureg.dimensionless), 2.0 * ureg.dimensionless
)
def test_issue45(self):
import math
self.assertAlmostEqual(math.sqrt(4 * ureg.m / ureg.cm), math.sqrt(4 * 100))
self.assertAlmostEqual(float(ureg.V / ureg.mV), 1000.0)
@helpers.requires_numpy()
def test_issue45b(self):
self.assertAlmostEqual(
np.sin([np.pi / 2] * ureg.m / ureg.m),
np.sin([np.pi / 2] * ureg.dimensionless),
)
self.assertAlmostEqual(
np.sin([np.pi / 2] * ureg.cm / ureg.m),
np.sin([np.pi / 2] * ureg.dimensionless * 0.01),
)
def test_issue50(self):
Q_ = ureg.Quantity
self.assertEqual(Q_(100), 100 * ureg.dimensionless)
self.assertEqual(Q_("100"), 100 * ureg.dimensionless)
def test_issue52(self):
u1 = UnitRegistry()
u2 = UnitRegistry()
q1 = 1 * u1.meter
q2 = 1 * u2.meter
import operator as op
for fun in (
op.add,
op.iadd,
op.sub,
op.isub,
op.mul,
op.imul,
op.floordiv,
op.ifloordiv,
op.truediv,
op.itruediv,
):
self.assertRaises(ValueError, fun, q1, q2)
def test_issue54(self):
self.assertEqual((1 * ureg.km / ureg.m + 1).magnitude, 1001)
def test_issue54_related(self):
self.assertEqual(ureg.km / ureg.m, 1000)
self.assertEqual(1000, ureg.km / ureg.m)
self.assertLess(900, ureg.km / ureg.m)
self.assertGreater(1100, ureg.km / ureg.m)
def test_issue61(self):
Q_ = ureg.Quantity
for value in ({}, {"a": 3}, None):
self.assertRaises(TypeError, Q_, value)
self.assertRaises(TypeError, Q_, value, "meter")
self.assertRaises(ValueError, Q_, "", "meter")
self.assertRaises(ValueError, Q_, "")
@helpers.requires_not_numpy()
def test_issue61_notNP(self):
Q_ = ureg.Quantity
for value in ([1, 2, 3], (1, 2, 3)):
self.assertRaises(TypeError, Q_, value)
self.assertRaises(TypeError, Q_, value, "meter")
def test_issue62(self):
m = ureg("m**0.5")
self.assertEqual(str(m.units), "meter ** 0.5")
def test_issue66(self):
self.assertEqual(
ureg.get_dimensionality(UnitsContainer({"[temperature]": 1})),
UnitsContainer({"[temperature]": 1}),
)
self.assertEqual(
ureg.get_dimensionality(ureg.kelvin), UnitsContainer({"[temperature]": 1})
)
self.assertEqual(
ureg.get_dimensionality(ureg.degC), UnitsContainer({"[temperature]": 1})
)
def test_issue66b(self):
self.assertEqual(
ureg.get_base_units(ureg.kelvin),
(1.0, ureg.Unit(UnitsContainer({"kelvin": 1}))),
)
self.assertEqual(
ureg.get_base_units(ureg.degC),
(1.0, ureg.Unit(UnitsContainer({"kelvin": 1}))),
)
def test_issue69(self):
q = ureg("m").to(ureg("in"))
self.assertEqual(q, ureg("m").to("in"))
@helpers.requires_numpy()
def test_issue74(self):
v1 = np.asarray([1.0, 2.0, 3.0])
v2 = np.asarray([3.0, 2.0, 1.0])
q1 = v1 * ureg.ms
q2 = v2 * ureg.ms
np.testing.assert_array_equal(q1 < q2, v1 < v2)
np.testing.assert_array_equal(q1 > q2, v1 > v2)
np.testing.assert_array_equal(q1 <= q2, v1 <= v2)
np.testing.assert_array_equal(q1 >= q2, v1 >= v2)
q2s = np.asarray([0.003, 0.002, 0.001]) * ureg.s
v2s = q2s.to("ms").magnitude
np.testing.assert_array_equal(q1 < q2s, v1 < v2s)
np.testing.assert_array_equal(q1 > q2s, v1 > v2s)
np.testing.assert_array_equal(q1 <= q2s, v1 <= v2s)
np.testing.assert_array_equal(q1 >= q2s, v1 >= v2s)
@helpers.requires_numpy()
def test_issue75(self):
v1 = np.asarray([1.0, 2.0, 3.0])
v2 = np.asarray([3.0, 2.0, 1.0])
q1 = v1 * ureg.ms
q2 = v2 * ureg.ms
np.testing.assert_array_equal(q1 == q2, v1 == v2)
np.testing.assert_array_equal(q1 != q2, v1 != v2)
q2s = np.asarray([0.003, 0.002, 0.001]) * ureg.s
v2s = q2s.to("ms").magnitude
np.testing.assert_array_equal(q1 == q2s, v1 == v2s)
np.testing.assert_array_equal(q1 != q2s, v1 != v2s)
@helpers.requires_uncertainties()
def test_issue77(self):
acc = (5.0 * ureg("m/s/s")).plus_minus(0.25)
tim = (37.0 * ureg("s")).plus_minus(0.16)
dis = acc * tim ** 2 / 2
self.assertEqual(dis.value, acc.value * tim.value ** 2 / 2)
def test_issue85(self):
T = 4.0 * ureg.kelvin
m = 1.0 * ureg.amu
va = 2.0 * ureg.k * T / m
va.to_base_units()
boltmk = 1.380649e-23 * ureg.J / ureg.K
vb = 2.0 * boltmk * T / m
self.assertQuantityAlmostEqual(va.to_base_units(), vb.to_base_units())
def test_issue86(self):
ureg = self.ureg
ureg.autoconvert_offset_to_baseunit = True
def parts(q):
return q.magnitude, q.units
q1 = 10.0 * ureg.degC
q2 = 10.0 * ureg.kelvin
k1 = q1.to_base_units()
q3 = 3.0 * ureg.meter
q1m, q1u = parts(q1)
q2m, q2u = parts(q2)
q3m, q3u = parts(q3)
k1m, k1u = parts(k1)
self.assertEqual(parts(q2 * q3), (q2m * q3m, q2u * q3u))
self.assertEqual(parts(q2 / q3), (q2m / q3m, q2u / q3u))
self.assertEqual(parts(q3 * q2), (q3m * q2m, q3u * q2u))
self.assertEqual(parts(q3 / q2), (q3m / q2m, q3u / q2u))
self.assertEqual(parts(q2 ** 1), (q2m ** 1, q2u ** 1))
self.assertEqual(parts(q2 ** -1), (q2m ** -1, q2u ** -1))
self.assertEqual(parts(q2 ** 2), (q2m ** 2, q2u ** 2))
self.assertEqual(parts(q2 ** -2), (q2m ** -2, q2u ** -2))
self.assertEqual(parts(q1 * q3), (k1m * q3m, k1u * q3u))
self.assertEqual(parts(q1 / q3), (k1m / q3m, k1u / q3u))
self.assertEqual(parts(q3 * q1), (q3m * k1m, q3u * k1u))
self.assertEqual(parts(q3 / q1), (q3m / k1m, q3u / k1u))
self.assertEqual(parts(q1 ** -1), (k1m ** -1, k1u ** -1))
self.assertEqual(parts(q1 ** 2), (k1m ** 2, k1u ** 2))
self.assertEqual(parts(q1 ** -2), (k1m ** -2, k1u ** -2))
def test_issues86b(self):
ureg = self.ureg
T1 = 200.0 * ureg.degC
T2 = T1.to(ureg.kelvin)
m = 132.9054519 * ureg.amu
v1 = 2 * ureg.k * T1 / m
v2 = 2 * ureg.k * T2 / m
self.assertQuantityAlmostEqual(v1, v2)
self.assertQuantityAlmostEqual(v1, v2.to_base_units())
self.assertQuantityAlmostEqual(v1.to_base_units(), v2)
self.assertQuantityAlmostEqual(v1.to_base_units(), v2.to_base_units())
@unittest.expectedFailure
def test_issue86c(self):
ureg = self.ureg
ureg.autoconvert_offset_to_baseunit = True
T = ureg.degC
T = 100.0 * T
self.assertQuantityAlmostEqual(ureg.k * 2 * T, ureg.k * (2 * T))
def test_issue93(self):
x = 5 * ureg.meter
self.assertIsInstance(x.magnitude, int)
y = 0.1 * ureg.meter
self.assertIsInstance(y.magnitude, float)
z = 5 * ureg.meter
self.assertIsInstance(z.magnitude, int)
z += y
self.assertIsInstance(z.magnitude, float)
self.assertQuantityAlmostEqual(x + y, 5.1 * ureg.meter)
self.assertQuantityAlmostEqual(z, 5.1 * ureg.meter)
@helpers.requires_numpy_previous_than("1.10")
def test_issue94(self):
v1 = np.array([5, 5]) * ureg.meter
v2 = 0.1 * ureg.meter
v3 = np.array([5, 5]) * ureg.meter
v3 += v2
np.testing.assert_array_equal((v1 + v2).magnitude, np.array([5.1, 5.1]))
np.testing.assert_array_equal(v3.magnitude, np.array([5, 5]))
def test_issue104(self):
x = [ureg("1 meter"), ureg("1 meter"), ureg("1 meter")]
y = [ureg("1 meter")] * 3
def summer(values):
if not values:
return 0
total = values[0]
for v in values[1:]:
total += v
return total
self.assertQuantityAlmostEqual(summer(x), ureg.Quantity(3, "meter"))
self.assertQuantityAlmostEqual(x[0], ureg.Quantity(1, "meter"))
self.assertQuantityAlmostEqual(summer(y), ureg.Quantity(3, "meter"))
self.assertQuantityAlmostEqual(y[0], ureg.Quantity(1, "meter"))
def test_issue105(self):
func = ureg.parse_unit_name
val = list(func("meter"))
self.assertEqual(list(func("METER")), [])
self.assertEqual(val, list(func("METER", False)))
for func in (ureg.get_name, ureg.parse_expression):
val = func("meter")
with self.assertRaises(AttributeError):
func("METER")
self.assertEqual(val, func("METER", False))
def test_issue121(self):
z, v = 0, 2.0
self.assertEqual(z + v * ureg.meter, v * ureg.meter)
self.assertEqual(z - v * ureg.meter, -v * ureg.meter)
self.assertEqual(v * ureg.meter + z, v * ureg.meter)
self.assertEqual(v * ureg.meter - z, v * ureg.meter)
self.assertEqual(sum([v * ureg.meter, v * ureg.meter]), 2 * v * ureg.meter)
@helpers.requires_numpy18()
def test_issue121b(self):
sh = (2, 1)
z, v = 0, 2.0
self.assertEqual(z + v * ureg.meter, v * ureg.meter)
self.assertEqual(z - v * ureg.meter, -v * ureg.meter)
self.assertEqual(v * ureg.meter + z, v * ureg.meter)
self.assertEqual(v * ureg.meter - z, v * ureg.meter)
self.assertEqual(sum([v * ureg.meter, v * ureg.meter]), 2 * v * ureg.meter)
z, v = np.zeros(sh), 2.0 * np.ones(sh)
self.assertQuantityEqual(z + v * ureg.meter, v * ureg.meter)
self.assertQuantityEqual(z - v * ureg.meter, -v * ureg.meter)
self.assertQuantityEqual(v * ureg.meter + z, v * ureg.meter)
self.assertQuantityEqual(v * ureg.meter - z, v * ureg.meter)
z, v = np.zeros((3, 1)), 2.0 * np.ones(sh)
for x, y in ((z, v), (z, v * ureg.meter), (v * ureg.meter, z)):
with self.assertRaises(ValueError):
x + y
with self.assertRaises(ValueError):
x - y
@helpers.requires_numpy()
def test_issue127(self):
q = [1.0, 2.0, 3.0, 4.0] * self.ureg.meter
q[0] = np.nan
self.assertNotEqual(q[0], 1.0)
self.assertTrue(math.isnan(q[0].magnitude))
q[1] = float("NaN")
self.assertNotEqual(q[1], 2.0)
self.assertTrue(math.isnan(q[1].magnitude))
def test_issue170(self):
Q_ = UnitRegistry().Quantity
q = Q_("1 kHz") / Q_("100 Hz")
iq = int(q)
self.assertEqual(iq, 10)
self.assertIsInstance(iq, int)
def test_angstrom_creation(self):
ureg.Quantity(2, "Å")
def test_alternative_angstrom_definition(self):
ureg.Quantity(2, "\u212B")
def test_micro_creation(self):
ureg.Quantity(2, "µm")
@helpers.requires_numpy()
def test_issue171_real_imag(self):
qr = [1.0, 2.0, 3.0, 4.0] * self.ureg.meter
qi = [4.0, 3.0, 2.0, 1.0] * self.ureg.meter
q = qr + 1j * qi
self.assertQuantityEqual(q.real, qr)
self.assertQuantityEqual(q.imag, qi)
@helpers.requires_numpy()
def test_issue171_T(self):
a = np.asarray([[1.0, 2.0, 3.0, 4.0], [4.0, 3.0, 2.0, 1.0]])
q1 = a * self.ureg.meter
q2 = a.T * self.ureg.meter
self.assertQuantityEqual(q1.T, q2)
@helpers.requires_numpy()
def test_issue250(self):
a = self.ureg.V
b = self.ureg.mV
self.assertEqual(np.float16(a / b), 1000.0)
self.assertEqual(np.float32(a / b), 1000.0)
self.assertEqual(np.float64(a / b), 1000.0)
if "float128" in dir(np):
self.assertEqual(np.float128(a / b), 1000.0)
def test_issue252(self):
ur = UnitRegistry()
q = ur("3 F")
t = copy.deepcopy(q)
u = t.to(ur.mF)
self.assertQuantityEqual(q.to(ur.mF), u)
def test_issue323(self):
from fractions import Fraction as F
self.assertEqual((self.Q_(F(2, 3), "s")).to("ms"), self.Q_(F(2000, 3), "ms"))
self.assertEqual((self.Q_(F(2, 3), "m")).to("km"), self.Q_(F(1, 1500), "km"))
def test_issue339(self):
q1 = self.ureg("")
self.assertEqual(q1.magnitude, 1)
self.assertEqual(q1.units, self.ureg.dimensionless)
q2 = self.ureg("1 dimensionless")
self.assertEqual(q1, q2)
def test_issue354_356_370(self):
self.assertEqual(
"{:~}".format(1 * self.ureg.second / self.ureg.millisecond), "1.0 s / ms"
)
self.assertEqual("{:~}".format(1 * self.ureg.count), "1 count")
self.assertEqual("{:~}".format(1 * self.ureg("MiB")), "1 MiB")
def test_issue468(self):
@ureg.wraps(("kg"), "meter")
def f(x):
return x
x = ureg.Quantity(1.0, "meter")
y = f(x)
z = x * y
self.assertEqual(z, ureg.Quantity(1.0, "meter * kilogram"))
@helpers.requires_numpy()
def test_issue482(self):
q = self.ureg.Quantity(1, self.ureg.dimensionless)
qe = np.exp(q)
self.assertIsInstance(qe, self.ureg.Quantity)
@helpers.requires_numpy()
def test_issue483(self):
ureg = self.ureg
a = np.asarray([1, 2, 3])
q = [1, 2, 3] * ureg.dimensionless
p = (q ** q).m
np.testing.assert_array_equal(p, a ** a)
def test_issue523(self):
src, dst = UnitsContainer({"meter": 1}), UnitsContainer({"degF": 1})
value = 10.0
convert = self.ureg.convert
self.assertRaises(DimensionalityError, convert, value, src, dst)
self.assertRaises(DimensionalityError, convert, value, dst, src)
def test_issue532(self):
ureg = self.ureg
@ureg.check(ureg(""))
def f(x):
return 2 * x
self.assertEqual(f(ureg.Quantity(1, "")), 2)
self.assertRaises(DimensionalityError, f, ureg.Quantity(1, "m"))
def test_issue625a(self):
Q_ = ureg.Quantity
from math import sqrt
@ureg.wraps(ureg.second, (ureg.meters, ureg.meters / ureg.second ** 2))
def calculate_time_to_fall(height, gravity=Q_(9.8, "m/s^2")):
"""Calculate time to fall from a height h with a default gravity.
By default, the gravity is assumed to be earth gravity,
but it can be modified.
d = .5 * g * t**2
t = sqrt(2 * d / g)
Parameters
----------
height :
gravity :
(Default value = Q_(9.8)
"m/s^2") :
Returns
-------
"""
return sqrt(2 * height / gravity)
lunar_module_height = Q_(10, "m")
t1 = calculate_time_to_fall(lunar_module_height)
print(t1)
self.assertAlmostEqual(t1, Q_(1.4285714285714286, "s"))
moon_gravity = Q_(1.625, "m/s^2")
t2 = calculate_time_to_fall(lunar_module_height, moon_gravity)
self.assertAlmostEqual(t2, Q_(3.508232077228117, "s"))
def test_issue625b(self):
Q_ = ureg.Quantity
@ureg.wraps("=A*B", ("=A", "=B"))
def get_displacement(time, rate=Q_(1, "m/s")):
"""Calculates displacement from a duration and default rate.
Parameters
----------
time :
rate :
(Default value = Q_(1)
"m/s") :
Returns
-------
"""
return time * rate
d1 = get_displacement(Q_(2, "s"))
self.assertAlmostEqual(d1, Q_(2, "m"))
d2 = get_displacement(Q_(2, "s"), Q_(1, "deg/s"))
self.assertAlmostEqual(d2, Q_(2, " deg"))
def test_issue625c(self):
u = UnitRegistry()
@u.wraps("=A*B*C", ("=A", "=B", "=C"))
def get_product(a=2 * u.m, b=3 * u.m, c=5 * u.m):
return a * b * c
self.assertEqual(get_product(a=3 * u.m), 45 * u.m ** 3)
self.assertEqual(get_product(b=2 * u.m), 20 * u.m ** 3)
self.assertEqual(get_product(c=1 * u.dimensionless), 6 * u.m ** 2)
def test_issue655a(self):
distance = 1 * ureg.m
time = 1 * ureg.s
velocity = distance / time
self.assertEqual(distance.check("[length]"), True)
self.assertEqual(distance.check("[time]"), False)
self.assertEqual(velocity.check("[length] / [time]"), True)
self.assertEqual(velocity.check("1 / [time] * [length]"), True)
def test_issue655b(self):
Q_ = ureg.Quantity
@ureg.check("[length]", "[length]/[time]^2")
def pendulum_period(length, G=Q_(1, "standard_gravity")):
print(length)
return (2 * math.pi * (length / G) ** 0.5).to("s")
length = Q_(1, ureg.m)
# Assume earth gravity
t = pendulum_period(length)
self.assertAlmostEqual(t, Q_("2.0064092925890407 second"))
# Use moon gravity
moon_gravity = Q_(1.625, "m/s^2")
t = pendulum_period(length, moon_gravity)
self.assertAlmostEqual(t, Q_("4.928936075204336 second"))
def test_issue783(self):
assert not ureg("g") == []
def test_issue856(self):
ph1 = ParserHelper(scale=123)
ph2 = copy.deepcopy(ph1)
assert ph2.scale == ph1.scale
ureg1 = UnitRegistry()
ureg2 = copy.deepcopy(ureg1)
# Very basic functionality test
assert ureg2("1 t").to("kg").magnitude == 1000
def test_issue856b(self):
# Test that, after a deepcopy(), the two UnitRegistries are
# independent from each other
ureg1 = UnitRegistry()
ureg2 = copy.deepcopy(ureg1)
ureg1.define("test123 = 123 kg")
ureg2.define("test123 = 456 kg")
assert ureg1("1 test123").to("kg").magnitude == 123
assert ureg2("1 test123").to("kg").magnitude == 456
def test_issue876(self):
# Same hash must not imply equality.
# As an implementation detail of CPython, hash(-1) == hash(-2).
# This test is useless in potential alternative Python implementations where
# hash(-1) != hash(-2); one would need to find hash collisions specific for each
# implementation
a = UnitsContainer({"[mass]": -1})
b = UnitsContainer({"[mass]": -2})
c = UnitsContainer({"[mass]": -3})
# Guarantee working on alternative Python implementations
assert (hash(-1) == hash(-2)) == (hash(a) == hash(b))
assert (hash(-1) == hash(-3)) == (hash(a) == hash(c))
assert a != b
assert a != c
def test_issue902(self):
ureg = UnitRegistry(auto_reduce_dimensions=True)
velocity = 1 * ureg.m / ureg.s
cross_section = 1 * ureg.um ** 2
result = cross_section / velocity
assert result == 1e-12 * ureg.m * ureg.s
[docs] def test_issue912(self):
"""pprint.pformat() invokes sorted() on large sets and frozensets and graciously
handles TypeError, but not generic Exceptions. This test will fail if
pint.DimensionalityError stops being a subclass of TypeError.
Parameters
----------
Returns
-------
"""
meter_units = ureg.get_compatible_units(ureg.meter)
hertz_units = ureg.get_compatible_units(ureg.hertz)
pprint.pformat(meter_units | hertz_units)
def test_issue932(self):
q = ureg.Quantity("1 kg")
with self.assertRaises(DimensionalityError):
q.to("joule")
ureg.enable_contexts("energy", *(Context() for _ in range(20)))
q.to("joule")
ureg.disable_contexts()
with self.assertRaises(DimensionalityError):
q.to("joule")
try:
@pytest.mark.skipif(np is None, reason="NumPy is not available")
@pytest.mark.parametrize(
"callable",
[
lambda x: np.sin(x / x.units), # Issue 399
lambda x: np.cos(x / x.units), # Issue 399
np.isfinite, # Issue 481
np.shape, # Issue 509
np.size, # Issue 509
np.sqrt, # Issue 622
lambda x: x.mean(), # Issue 678
lambda x: x.copy(), # Issue 678
np.array,
lambda x: x.conjugate,
],
)
@pytest.mark.parametrize(
"q",
[
pytest.param(ureg.Quantity(1, "m"), id="python scalar int"),
pytest.param(ureg.Quantity([1, 2, 3, 4], "m"), id="array int"),
pytest.param(ureg.Quantity([1], "m")[0], id="numpy scalar int"),
pytest.param(ureg.Quantity(1.0, "m"), id="python scalar float"),
pytest.param(ureg.Quantity([1.0, 2.0, 3.0, 4.0], "m"), id="array float"),
pytest.param(ureg.Quantity([1.0], "m")[0], id="numpy scalar float"),
],
)
def test_issue925(callable, q):
# Test for immutability of type
type_before = type(q._magnitude)
callable(q)
assert isinstance(q._magnitude, type_before)
[docs] @pytest.mark.skipif(np is None, reason="NumPy is not available")
def test_issue973():
"""Verify that an empty array Quantity can be created through multiplication."""
q0 = np.array([]) * ureg.m # by Unit
q1 = np.array([]) * ureg("m") # by Quantity
assert isinstance(q0, ureg.Quantity)
assert isinstance(q1, ureg.Quantity)
assert len(q0) == len(q1) == 0
except AttributeError:
# Calling attributes on np will fail if NumPy is not available
pass
