1253 lines
57 KiB
Python
1253 lines
57 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
from __future__ import division, unicode_literals, print_function, absolute_import
|
|
|
|
import copy
|
|
import datetime
|
|
import math
|
|
import operator as op
|
|
import warnings
|
|
|
|
from pint import DimensionalityError, OffsetUnitCalculusError, UnitRegistry
|
|
from pint.unit import UnitsContainer
|
|
from pint.compat import string_types, PYTHON3, np
|
|
from pint.testsuite import QuantityTestCase, helpers
|
|
from pint.testsuite.parameterized import ParameterizedTestCase
|
|
|
|
|
|
class TestQuantity(QuantityTestCase):
|
|
|
|
FORCE_NDARRAY = False
|
|
|
|
def test_quantity_creation(self):
|
|
for args in ((4.2, 'meter'),
|
|
(4.2, UnitsContainer(meter=1)),
|
|
(4.2, self.ureg.meter),
|
|
('4.2*meter', ),
|
|
('4.2/meter**(-1)', ),
|
|
(self.Q_(4.2, 'meter'),)):
|
|
x = self.Q_(*args)
|
|
self.assertEqual(x.magnitude, 4.2)
|
|
self.assertEqual(x.units, UnitsContainer(meter=1))
|
|
|
|
x = self.Q_(4.2, UnitsContainer(length=1))
|
|
y = self.Q_(x)
|
|
self.assertEqual(x.magnitude, y.magnitude)
|
|
self.assertEqual(x.units, y.units)
|
|
self.assertIsNot(x, y)
|
|
|
|
x = self.Q_(4.2, None)
|
|
self.assertEqual(x.magnitude, 4.2)
|
|
self.assertEqual(x.units, UnitsContainer())
|
|
|
|
with self.capture_log() as buffer:
|
|
self.assertEqual(4.2 * self.ureg.meter, self.Q_(4.2, 2 * self.ureg.meter))
|
|
self.assertEqual(len(buffer), 1)
|
|
|
|
def test_quantity_bool(self):
|
|
self.assertTrue(self.Q_(1, None))
|
|
self.assertTrue(self.Q_(1, 'meter'))
|
|
self.assertFalse(self.Q_(0, None))
|
|
self.assertFalse(self.Q_(0, 'meter'))
|
|
|
|
def test_quantity_comparison(self):
|
|
x = self.Q_(4.2, 'meter')
|
|
y = self.Q_(4.2, 'meter')
|
|
z = self.Q_(5, 'meter')
|
|
j = self.Q_(5, 'meter*meter')
|
|
|
|
# identity for single object
|
|
self.assertTrue(x == x)
|
|
self.assertFalse(x != x)
|
|
|
|
# identity for multiple objects with same value
|
|
self.assertTrue(x == y)
|
|
self.assertFalse(x != y)
|
|
|
|
self.assertTrue(x <= y)
|
|
self.assertTrue(x >= y)
|
|
self.assertFalse(x < y)
|
|
self.assertFalse(x > y)
|
|
|
|
self.assertFalse(x == z)
|
|
self.assertTrue(x != z)
|
|
self.assertTrue(x < z)
|
|
|
|
self.assertTrue(z != j)
|
|
|
|
self.assertNotEqual(z, j)
|
|
self.assertEqual(self.Q_(0, 'meter'), self.Q_(0, 'centimeter'))
|
|
self.assertNotEqual(self.Q_(0, 'meter'), self.Q_(0, 'second'))
|
|
|
|
self.assertLess(self.Q_(10, 'meter'), self.Q_(5, 'kilometer'))
|
|
|
|
def test_quantity_comparison_convert(self):
|
|
self.assertEqual(self.Q_(1000, 'millimeter'), self.Q_(1, 'meter'))
|
|
self.assertEqual(self.Q_(1000, 'millimeter/min'), self.Q_(1000/60, 'millimeter/s'))
|
|
|
|
def test_quantity_repr(self):
|
|
x = self.Q_(4.2, UnitsContainer(meter=1))
|
|
self.assertEqual(str(x), '4.2 meter')
|
|
self.assertEqual(repr(x), "<Quantity(4.2, 'meter')>")
|
|
|
|
def test_quantity_hash(self):
|
|
x = self.Q_(4.2, 'meter')
|
|
x2 = self.Q_(4200, 'millimeter')
|
|
y = self.Q_(2, 'second')
|
|
z = self.Q_(0.5, 'hertz')
|
|
self.assertEqual(hash(x), hash(x2))
|
|
|
|
# Dimensionless equality
|
|
self.assertEqual(hash(y * z), hash(1.0))
|
|
|
|
# Dimensionless equality from a different unit registry
|
|
ureg2 = UnitRegistry(force_ndarray=self.FORCE_NDARRAY)
|
|
y2 = ureg2.Quantity(2, 'second')
|
|
z2 = ureg2.Quantity(0.5, 'hertz')
|
|
self.assertEqual(hash(y * z), hash(y2 * z2))
|
|
|
|
def test_quantity_format(self):
|
|
x = self.Q_(4.12345678, UnitsContainer(meter=2, kilogram=1, second=-1))
|
|
for spec, result in (('{0}', str(x)), ('{0!s}', str(x)), ('{0!r}', repr(x)),
|
|
('{0.magnitude}', str(x.magnitude)), ('{0.units}', str(x.units)),
|
|
('{0.magnitude!s}', str(x.magnitude)), ('{0.units!s}', str(x.units)),
|
|
('{0.magnitude!r}', repr(x.magnitude)), ('{0.units!r}', repr(x.units)),
|
|
('{0:.4f}', '{0:.4f} {1!s}'.format(x.magnitude, x.units)),
|
|
('{0:L}', r'4.12345678\ \frac{\mathrm{kilogram} \cdot \mathrm{meter}^{2}}{\mathrm{second}}'),
|
|
('{0:P}', '4.12345678 kilogram·meter²/second'),
|
|
('{0:H}', '4.12345678 kilogram meter<sup>2</sup>/second'),
|
|
('{0:C}', '4.12345678 kilogram*meter**2/second'),
|
|
('{0:~}', '4.12345678 kg * m ** 2 / s'),
|
|
('{0:L~}', r'4.12345678\ \frac{\mathrm{kg} \cdot \mathrm{m}^{2}}{\mathrm{s}}'),
|
|
('{0:P~}', '4.12345678 kg·m²/s'),
|
|
('{0:H~}', '4.12345678 kg m<sup>2</sup>/s'),
|
|
('{0:C~}', '4.12345678 kg*m**2/s'),
|
|
('{0:Lx}', r'\SI[]{4.12345678}{\kilo\gram\meter\squared\per\second}'),
|
|
):
|
|
self.assertEqual(spec.format(x), result)
|
|
# Check the special case that prevents e.g. '3 1 / second'
|
|
x = self.Q_(3, UnitsContainer(second=-1))
|
|
self.assertEqual('{0}'.format(x), '3 / second')
|
|
|
|
def test_format_compact(self):
|
|
q1 = (200e-9 * self.ureg.s).to_compact()
|
|
q1b = self.Q_(200., 'nanosecond')
|
|
self.assertAlmostEqual(q1.magnitude, q1b.magnitude)
|
|
self.assertEqual(q1.units, q1b.units)
|
|
|
|
q2 = (1e-2 * self.ureg('kg m/s^2')).to_compact('N')
|
|
q2b = self.Q_(10., 'millinewton')
|
|
self.assertEqual(q2.magnitude, q2b.magnitude)
|
|
self.assertEqual(q2.units, q2b.units)
|
|
|
|
q3 = (-1000.0 * self.ureg('meters')).to_compact()
|
|
q3b = self.Q_(-1., 'kilometer')
|
|
self.assertEqual(q3.magnitude, q3b.magnitude)
|
|
self.assertEqual(q3.units, q3b.units)
|
|
|
|
self.assertEqual('{0:#.1f}'.format(q1), '{0}'.format(q1b))
|
|
self.assertEqual('{0:#.1f}'.format(q2), '{0}'.format(q2b))
|
|
self.assertEqual('{0:#.1f}'.format(q3), '{0}'.format(q3b))
|
|
|
|
|
|
def test_default_formatting(self):
|
|
ureg = UnitRegistry()
|
|
x = ureg.Quantity(4.12345678, UnitsContainer(meter=2, kilogram=1, second=-1))
|
|
for spec, result in (('L', r'4.12345678\ \frac{\mathrm{kilogram} \cdot \mathrm{meter}^{2}}{\mathrm{second}}'),
|
|
('P', '4.12345678 kilogram·meter²/second'),
|
|
('H', '4.12345678 kilogram meter<sup>2</sup>/second'),
|
|
('C', '4.12345678 kilogram*meter**2/second'),
|
|
('~', '4.12345678 kg * m ** 2 / s'),
|
|
('L~', r'4.12345678\ \frac{\mathrm{kg} \cdot \mathrm{m}^{2}}{\mathrm{s}}'),
|
|
('P~', '4.12345678 kg·m²/s'),
|
|
('H~', '4.12345678 kg m<sup>2</sup>/s'),
|
|
('C~', '4.12345678 kg*m**2/s'),
|
|
):
|
|
ureg.default_format = spec
|
|
self.assertEqual('{0}'.format(x), result)
|
|
|
|
def test_to_base_units(self):
|
|
x = self.Q_('1*inch')
|
|
self.assertQuantityAlmostEqual(x.to_base_units(), self.Q_(0.0254, 'meter'))
|
|
x = self.Q_('1*inch*inch')
|
|
self.assertQuantityAlmostEqual(x.to_base_units(), self.Q_(0.0254 ** 2.0, 'meter*meter'))
|
|
x = self.Q_('1*inch/minute')
|
|
self.assertQuantityAlmostEqual(x.to_base_units(), self.Q_(0.0254 / 60., 'meter/second'))
|
|
|
|
def test_convert(self):
|
|
x = self.Q_('2*inch')
|
|
self.assertQuantityAlmostEqual(x.to('meter'), self.Q_(2. * 0.0254, 'meter'))
|
|
x = self.Q_('2*meter')
|
|
self.assertQuantityAlmostEqual(x.to('inch'), self.Q_(2. / 0.0254, 'inch'))
|
|
x = self.Q_('2*sidereal_second')
|
|
self.assertQuantityAlmostEqual(x.to('second'), self.Q_(1.994539133 , 'second'))
|
|
x = self.Q_('2.54*centimeter/second')
|
|
self.assertQuantityAlmostEqual(x.to('inch/second'), self.Q_(1, 'inch/second'))
|
|
x = self.Q_('2.54*centimeter')
|
|
self.assertQuantityAlmostEqual(x.to('inch').magnitude, 1)
|
|
self.assertQuantityAlmostEqual(self.Q_(2, 'second').to('millisecond').magnitude, 2000)
|
|
|
|
@helpers.requires_numpy()
|
|
def test_convert(self):
|
|
|
|
# Conversions with single units take a different codepath than
|
|
# Conversions with more than one unit.
|
|
src_dst1 = UnitsContainer(meter=1), UnitsContainer(inch=1)
|
|
src_dst2 = UnitsContainer(meter=1, second=-1), UnitsContainer(inch=1, minute=-1)
|
|
for src, dst in (src_dst1, src_dst2):
|
|
a = np.ones((3, 1))
|
|
ac = np.ones((3, 1))
|
|
|
|
q = self.Q_(a, src)
|
|
qac = self.Q_(ac, src).to(dst)
|
|
r = q.to(dst)
|
|
self.assertQuantityAlmostEqual(qac, r)
|
|
self.assertIsNot(r, q)
|
|
self.assertIsNot(r._magnitude, a)
|
|
|
|
@helpers.requires_numpy()
|
|
def test_retain_unit(self):
|
|
# Test that methods correctly retain units and do not degrade into
|
|
# ordinary ndarrays. List contained in __copy_units.
|
|
a = np.ones((3, 2))
|
|
q = self.Q_(a, "km")
|
|
self.assertEqual(q.u, q.reshape(2, 3).u)
|
|
self.assertEqual(q.u, q.swapaxes(0, 1).u)
|
|
self.assertEqual(q.u, q.mean().u)
|
|
self.assertEqual(q.u, np.compress((q==q[0,0]).any(0), q).u)
|
|
|
|
def test_context_attr(self):
|
|
self.assertEqual(self.ureg.meter, self.Q_(1, 'meter'))
|
|
|
|
def test_both_symbol(self):
|
|
self.assertEqual(self.Q_(2, 'ms'), self.Q_(2, 'millisecond'))
|
|
self.assertEqual(self.Q_(2, 'cm'), self.Q_(2, 'centimeter'))
|
|
|
|
def test_dimensionless_units(self):
|
|
self.assertAlmostEqual(self.Q_(360, 'degree').to('radian').magnitude, 2 * math.pi)
|
|
self.assertAlmostEqual(self.Q_(2 * math.pi, 'radian'), self.Q_(360, 'degree'))
|
|
self.assertEqual(self.Q_(1, 'radian').dimensionality, UnitsContainer())
|
|
self.assertTrue(self.Q_(1, 'radian').dimensionless)
|
|
self.assertFalse(self.Q_(1, 'radian').unitless)
|
|
|
|
self.assertEqual(self.Q_(1, 'meter')/self.Q_(1, 'meter'), 1)
|
|
self.assertEqual((self.Q_(1, 'meter')/self.Q_(1, 'mm')).to(''), 1000)
|
|
|
|
self.assertEqual(self.Q_(10) // self.Q_(360, 'degree'), 1)
|
|
self.assertEqual(self.Q_(400, 'degree') // self.Q_(2 * math.pi), 1)
|
|
self.assertEqual(self.Q_(400, 'degree') // (2 * math.pi), 1)
|
|
self.assertEqual(7 // self.Q_(360, 'degree'), 1)
|
|
|
|
def test_offset(self):
|
|
self.assertQuantityAlmostEqual(self.Q_(0, 'kelvin').to('kelvin'), self.Q_(0, 'kelvin'))
|
|
self.assertQuantityAlmostEqual(self.Q_(0, 'degC').to('kelvin'), self.Q_(273.15, 'kelvin'))
|
|
self.assertQuantityAlmostEqual(self.Q_(0, 'degF').to('kelvin'), self.Q_(255.372222, 'kelvin'), rtol=0.01)
|
|
|
|
self.assertQuantityAlmostEqual(self.Q_(100, 'kelvin').to('kelvin'), self.Q_(100, 'kelvin'))
|
|
self.assertQuantityAlmostEqual(self.Q_(100, 'degC').to('kelvin'), self.Q_(373.15, 'kelvin'))
|
|
self.assertQuantityAlmostEqual(self.Q_(100, 'degF').to('kelvin'), self.Q_(310.92777777, 'kelvin'), rtol=0.01)
|
|
|
|
self.assertQuantityAlmostEqual(self.Q_(0, 'kelvin').to('degC'), self.Q_(-273.15, 'degC'))
|
|
self.assertQuantityAlmostEqual(self.Q_(100, 'kelvin').to('degC'), self.Q_(-173.15, 'degC'))
|
|
self.assertQuantityAlmostEqual(self.Q_(0, 'kelvin').to('degF'), self.Q_(-459.67, 'degF'), rtol=0.01)
|
|
self.assertQuantityAlmostEqual(self.Q_(100, 'kelvin').to('degF'), self.Q_(-279.67, 'degF'), rtol=0.01)
|
|
|
|
self.assertQuantityAlmostEqual(self.Q_(32, 'degF').to('degC'), self.Q_(0, 'degC'), atol=0.01)
|
|
self.assertQuantityAlmostEqual(self.Q_(100, 'degC').to('degF'), self.Q_(212, 'degF'), atol=0.01)
|
|
|
|
self.assertQuantityAlmostEqual(self.Q_(54, 'degF').to('degC'), self.Q_(12.2222, 'degC'), atol=0.01)
|
|
self.assertQuantityAlmostEqual(self.Q_(12, 'degC').to('degF'), self.Q_(53.6, 'degF'), atol=0.01)
|
|
|
|
self.assertQuantityAlmostEqual(self.Q_(12, 'kelvin').to('degC'), self.Q_(-261.15, 'degC'), atol=0.01)
|
|
self.assertQuantityAlmostEqual(self.Q_(12, 'degC').to('kelvin'), self.Q_(285.15, 'kelvin'), atol=0.01)
|
|
|
|
self.assertQuantityAlmostEqual(self.Q_(12, 'kelvin').to('degR'), self.Q_(21.6, 'degR'), atol=0.01)
|
|
self.assertQuantityAlmostEqual(self.Q_(12, 'degR').to('kelvin'), self.Q_(6.66666667, 'kelvin'), atol=0.01)
|
|
|
|
self.assertQuantityAlmostEqual(self.Q_(12, 'degC').to('degR'), self.Q_(513.27, 'degR'), atol=0.01)
|
|
self.assertQuantityAlmostEqual(self.Q_(12, 'degR').to('degC'), self.Q_(-266.483333, 'degC'), atol=0.01)
|
|
|
|
|
|
def test_offset_delta(self):
|
|
self.assertQuantityAlmostEqual(self.Q_(0, 'delta_degC').to('kelvin'), self.Q_(0, 'kelvin'))
|
|
self.assertQuantityAlmostEqual(self.Q_(0, 'delta_degF').to('kelvin'), self.Q_(0, 'kelvin'), rtol=0.01)
|
|
|
|
self.assertQuantityAlmostEqual(self.Q_(100, 'kelvin').to('delta_degC'), self.Q_(100, 'delta_degC'))
|
|
self.assertQuantityAlmostEqual(self.Q_(100, 'kelvin').to('delta_degF'), self.Q_(180, 'delta_degF'), rtol=0.01)
|
|
self.assertQuantityAlmostEqual(self.Q_(100, 'delta_degF').to('kelvin'), self.Q_(55.55555556, 'kelvin'), rtol=0.01)
|
|
self.assertQuantityAlmostEqual(self.Q_(100, 'delta_degC').to('delta_degF'), self.Q_(180, 'delta_degF'), rtol=0.01)
|
|
self.assertQuantityAlmostEqual(self.Q_(100, 'delta_degF').to('delta_degC'), self.Q_(55.55555556, 'delta_degC'), rtol=0.01)
|
|
|
|
self.assertQuantityAlmostEqual(self.Q_(12.3, 'delta_degC').to('delta_degF'), self.Q_(22.14, 'delta_degF'), rtol=0.01)
|
|
|
|
|
|
def test_pickle(self):
|
|
import pickle
|
|
|
|
def pickle_test(q):
|
|
self.assertEqual(q, pickle.loads(pickle.dumps(q)))
|
|
|
|
pickle_test(self.Q_(32, ''))
|
|
pickle_test(self.Q_(2.4, ''))
|
|
pickle_test(self.Q_(32, 'm/s'))
|
|
pickle_test(self.Q_(2.4, 'm/s'))
|
|
|
|
|
|
class TestQuantityToCompact(QuantityTestCase):
|
|
|
|
def assertQuantityAlmostIdentical(self, q1, q2):
|
|
self.assertEqual(q1.units, q2.units)
|
|
self.assertAlmostEqual(q1.magnitude, q2.magnitude)
|
|
|
|
def compareQuantity_compact(self, q, expected_compact, unit=None):
|
|
self.assertQuantityAlmostIdentical(q.to_compact(unit=unit),
|
|
expected_compact)
|
|
|
|
def test_dimensionally_simple_units(self):
|
|
ureg = self.ureg
|
|
self.compareQuantity_compact(1*ureg.m, 1*ureg.m)
|
|
self.compareQuantity_compact(1e-9*ureg.m, 1*ureg.nm)
|
|
|
|
def test_power_units(self):
|
|
ureg = self.ureg
|
|
self.compareQuantity_compact(900*ureg.m**2, 900*ureg.m**2)
|
|
self.compareQuantity_compact(1e7*ureg.m**2, 10*ureg.km**2)
|
|
|
|
def test_inverse_units(self):
|
|
ureg = self.ureg
|
|
self.compareQuantity_compact(1/ureg.m, 1/ureg.m)
|
|
self.compareQuantity_compact(100e9/ureg.m, 100/ureg.nm)
|
|
|
|
def test_inverse_square_units(self):
|
|
ureg = self.ureg
|
|
self.compareQuantity_compact(1/ureg.m**2, 1/ureg.m**2)
|
|
self.compareQuantity_compact(1e11/ureg.m**2, 1e5/ureg.mm**2)
|
|
|
|
def test_fractional_exponent_units(self):
|
|
ureg = self.ureg
|
|
self.compareQuantity_compact(1*ureg.m**0.5, 1*ureg.m**0.5)
|
|
self.compareQuantity_compact(1e-2*ureg.m**0.5, 10*ureg.um**0.5)
|
|
|
|
def test_derived_units(self):
|
|
ureg = self.ureg
|
|
self.compareQuantity_compact(0.5*ureg.megabyte, 500*ureg.kilobyte)
|
|
self.compareQuantity_compact(1e-11*ureg.N, 10*ureg.pN)
|
|
|
|
def test_unit_parameter(self):
|
|
ureg = self.ureg
|
|
self.compareQuantity_compact(self.Q_(100e-9, 'kg m / s^2'),
|
|
100*ureg.nN, ureg.N)
|
|
self.compareQuantity_compact(self.Q_(101.3e3, 'kg/m/s^2'),
|
|
101.3*ureg.kPa, ureg.Pa)
|
|
|
|
def test_limits_magnitudes(self):
|
|
ureg = self.ureg
|
|
self.compareQuantity_compact(0*ureg.m, 0*ureg.m)
|
|
self.compareQuantity_compact(float('inf')*ureg.m, float('inf')*ureg.m)
|
|
|
|
def test_nonnumeric_magnitudes(self):
|
|
ureg = self.ureg
|
|
x = "some string"*ureg.m
|
|
self.assertRaises(RuntimeError, self.compareQuantity_compact(x,x))
|
|
|
|
class TestQuantityBasicMath(QuantityTestCase):
|
|
|
|
FORCE_NDARRAY = False
|
|
|
|
def _test_inplace(self, operator, value1, value2, expected_result, unit=None):
|
|
if isinstance(value1, string_types):
|
|
value1 = self.Q_(value1)
|
|
if isinstance(value2, string_types):
|
|
value2 = self.Q_(value2)
|
|
if isinstance(expected_result, string_types):
|
|
expected_result = self.Q_(expected_result)
|
|
|
|
if not unit is None:
|
|
value1 = value1 * unit
|
|
value2 = value2 * unit
|
|
expected_result = expected_result * unit
|
|
|
|
value1 = copy.copy(value1)
|
|
value2 = copy.copy(value2)
|
|
id1 = id(value1)
|
|
id2 = id(value2)
|
|
value1 = operator(value1, value2)
|
|
value2_cpy = copy.copy(value2)
|
|
self.assertQuantityAlmostEqual(value1, expected_result)
|
|
self.assertEqual(id1, id(value1))
|
|
self.assertQuantityAlmostEqual(value2, value2_cpy)
|
|
self.assertEqual(id2, id(value2))
|
|
|
|
def _test_not_inplace(self, operator, value1, value2, expected_result, unit=None):
|
|
if isinstance(value1, string_types):
|
|
value1 = self.Q_(value1)
|
|
if isinstance(value2, string_types):
|
|
value2 = self.Q_(value2)
|
|
if isinstance(expected_result, string_types):
|
|
expected_result = self.Q_(expected_result)
|
|
|
|
if not unit is None:
|
|
value1 = value1 * unit
|
|
value2 = value2 * unit
|
|
expected_result = expected_result * unit
|
|
|
|
id1 = id(value1)
|
|
id2 = id(value2)
|
|
|
|
value1_cpy = copy.copy(value1)
|
|
value2_cpy = copy.copy(value2)
|
|
|
|
result = operator(value1, value2)
|
|
|
|
self.assertQuantityAlmostEqual(expected_result, result)
|
|
self.assertQuantityAlmostEqual(value1, value1_cpy)
|
|
self.assertQuantityAlmostEqual(value2, value2_cpy)
|
|
self.assertNotEqual(id(result), id1)
|
|
self.assertNotEqual(id(result), id2)
|
|
|
|
def _test_quantity_add_sub(self, unit, func):
|
|
x = self.Q_(unit, 'centimeter')
|
|
y = self.Q_(unit, 'inch')
|
|
z = self.Q_(unit, 'second')
|
|
a = self.Q_(unit, None)
|
|
|
|
func(op.add, x, x, self.Q_(unit + unit, 'centimeter'))
|
|
func(op.add, x, y, self.Q_(unit + 2.54 * unit, 'centimeter'))
|
|
func(op.add, y, x, self.Q_(unit + unit / (2.54 * unit), 'inch'))
|
|
func(op.add, a, unit, self.Q_(unit + unit, None))
|
|
self.assertRaises(DimensionalityError, op.add, 10, x)
|
|
self.assertRaises(DimensionalityError, op.add, x, 10)
|
|
self.assertRaises(DimensionalityError, op.add, x, z)
|
|
|
|
func(op.sub, x, x, self.Q_(unit - unit, 'centimeter'))
|
|
func(op.sub, x, y, self.Q_(unit - 2.54 * unit, 'centimeter'))
|
|
func(op.sub, y, x, self.Q_(unit - unit / (2.54 * unit), 'inch'))
|
|
func(op.sub, a, unit, self.Q_(unit - unit, None))
|
|
self.assertRaises(DimensionalityError, op.sub, 10, x)
|
|
self.assertRaises(DimensionalityError, op.sub, x, 10)
|
|
self.assertRaises(DimensionalityError, op.sub, x, z)
|
|
|
|
def _test_quantity_iadd_isub(self, unit, func):
|
|
x = self.Q_(unit, 'centimeter')
|
|
y = self.Q_(unit, 'inch')
|
|
z = self.Q_(unit, 'second')
|
|
a = self.Q_(unit, None)
|
|
|
|
func(op.iadd, x, x, self.Q_(unit + unit, 'centimeter'))
|
|
func(op.iadd, x, y, self.Q_(unit + 2.54 * unit, 'centimeter'))
|
|
func(op.iadd, y, x, self.Q_(unit + unit / 2.54, 'inch'))
|
|
func(op.iadd, a, unit, self.Q_(unit + unit, None))
|
|
self.assertRaises(DimensionalityError, op.iadd, 10, x)
|
|
self.assertRaises(DimensionalityError, op.iadd, x, 10)
|
|
self.assertRaises(DimensionalityError, op.iadd, x, z)
|
|
|
|
func(op.isub, x, x, self.Q_(unit - unit, 'centimeter'))
|
|
func(op.isub, x, y, self.Q_(unit - 2.54, 'centimeter'))
|
|
func(op.isub, y, x, self.Q_(unit - unit / 2.54, 'inch'))
|
|
func(op.isub, a, unit, self.Q_(unit - unit, None))
|
|
self.assertRaises(DimensionalityError, op.sub, 10, x)
|
|
self.assertRaises(DimensionalityError, op.sub, x, 10)
|
|
self.assertRaises(DimensionalityError, op.sub, x, z)
|
|
|
|
def _test_quantity_mul_div(self, unit, func):
|
|
func(op.mul, unit * 10.0, '4.2*meter', '42*meter', unit)
|
|
func(op.mul, '4.2*meter', unit * 10.0, '42*meter', unit)
|
|
func(op.mul, '4.2*meter', '10*inch', '42*meter*inch', unit)
|
|
func(op.truediv, unit * 42, '4.2*meter', '10/meter', unit)
|
|
func(op.truediv, '4.2*meter', unit * 10.0, '0.42*meter', unit)
|
|
func(op.truediv, '4.2*meter', '10*inch', '0.42*meter/inch', unit)
|
|
|
|
def _test_quantity_imul_idiv(self, unit, func):
|
|
#func(op.imul, 10.0, '4.2*meter', '42*meter')
|
|
func(op.imul, '4.2*meter', 10.0, '42*meter', unit)
|
|
func(op.imul, '4.2*meter', '10*inch', '42*meter*inch', unit)
|
|
#func(op.truediv, 42, '4.2*meter', '10/meter')
|
|
func(op.itruediv, '4.2*meter', unit * 10.0, '0.42*meter', unit)
|
|
func(op.itruediv, '4.2*meter', '10*inch', '0.42*meter/inch', unit)
|
|
|
|
def _test_quantity_floordiv(self, unit, func):
|
|
a = self.Q_('10*meter')
|
|
b = self.Q_('3*second')
|
|
self.assertRaises(DimensionalityError, op.floordiv, a, b)
|
|
self.assertRaises(DimensionalityError, op.floordiv, 3, b)
|
|
self.assertRaises(DimensionalityError, op.floordiv, a, 3)
|
|
self.assertRaises(DimensionalityError, op.ifloordiv, a, b)
|
|
self.assertRaises(DimensionalityError, op.ifloordiv, 3, b)
|
|
self.assertRaises(DimensionalityError, op.ifloordiv, a, 3)
|
|
func(op.floordiv, unit * 10.0, '4.2*meter/meter', 2, unit)
|
|
func(op.floordiv, '10*meter', '4.2*inch', 93, unit)
|
|
|
|
def _test_quantity_mod(self, unit, func):
|
|
a = self.Q_('10*meter')
|
|
b = self.Q_('3*second')
|
|
self.assertRaises(DimensionalityError, op.mod, a, b)
|
|
self.assertRaises(DimensionalityError, op.mod, 3, b)
|
|
self.assertRaises(DimensionalityError, op.mod, a, 3)
|
|
self.assertRaises(DimensionalityError, op.imod, a, b)
|
|
self.assertRaises(DimensionalityError, op.imod, 3, b)
|
|
self.assertRaises(DimensionalityError, op.imod, a, 3)
|
|
func(op.mod, unit * 10.0, '4.2*meter/meter', 1.6, unit)
|
|
|
|
def _test_quantity_ifloordiv(self, unit, func):
|
|
func(op.ifloordiv, 10.0, '4.2*meter/meter', 2, unit)
|
|
func(op.ifloordiv, '10*meter', '4.2*inch', 93, unit)
|
|
|
|
def _test_quantity_divmod_one(self, a, b):
|
|
if isinstance(a, string_types):
|
|
a = self.Q_(a)
|
|
if isinstance(b, string_types):
|
|
b = self.Q_(b)
|
|
|
|
q, r = divmod(a, b)
|
|
self.assertEqual(q, a // b)
|
|
self.assertEqual(r, a % b)
|
|
self.assertEqual(a, (q * b) + r)
|
|
self.assertEqual(q, math.floor(q))
|
|
if b > (0 * b):
|
|
self.assertTrue((0 * b) <= r < b)
|
|
else:
|
|
self.assertTrue((0 * b) >= r > b)
|
|
if isinstance(a, self.Q_):
|
|
self.assertEqual(r.units, a.units)
|
|
else:
|
|
self.assertTrue(r.unitless)
|
|
self.assertTrue(q.unitless)
|
|
|
|
copy_a = copy.copy(a)
|
|
a %= b
|
|
self.assertEqual(a, r)
|
|
copy_a //= b
|
|
self.assertEqual(copy_a, q)
|
|
|
|
def _test_quantity_divmod(self):
|
|
self._test_quantity_divmod_one('10*meter', '4.2*inch')
|
|
self._test_quantity_divmod_one('-10*meter', '4.2*inch')
|
|
self._test_quantity_divmod_one('-10*meter', '-4.2*inch')
|
|
self._test_quantity_divmod_one('10*meter', '-4.2*inch')
|
|
|
|
self._test_quantity_divmod_one('400*degree', '3')
|
|
self._test_quantity_divmod_one('4', '180 degree')
|
|
self._test_quantity_divmod_one(4, '180 degree')
|
|
self._test_quantity_divmod_one('20', 4)
|
|
self._test_quantity_divmod_one('300*degree', '100 degree')
|
|
|
|
a = self.Q_('10*meter')
|
|
b = self.Q_('3*second')
|
|
self.assertRaises(DimensionalityError, divmod, a, b)
|
|
self.assertRaises(DimensionalityError, divmod, 3, b)
|
|
self.assertRaises(DimensionalityError, divmod, a, 3)
|
|
|
|
def _test_numeric(self, unit, ifunc):
|
|
self._test_quantity_add_sub(unit, self._test_not_inplace)
|
|
self._test_quantity_iadd_isub(unit, ifunc)
|
|
self._test_quantity_mul_div(unit, self._test_not_inplace)
|
|
self._test_quantity_imul_idiv(unit, ifunc)
|
|
self._test_quantity_floordiv(unit, self._test_not_inplace)
|
|
self._test_quantity_mod(unit, self._test_not_inplace)
|
|
self._test_quantity_divmod()
|
|
#self._test_quantity_ifloordiv(unit, ifunc)
|
|
|
|
def test_float(self):
|
|
self._test_numeric(1., self._test_not_inplace)
|
|
|
|
def test_fraction(self):
|
|
import fractions
|
|
self._test_numeric(fractions.Fraction(1, 1), self._test_not_inplace)
|
|
|
|
@helpers.requires_numpy()
|
|
def test_nparray(self):
|
|
self._test_numeric(np.ones((1, 3)), self._test_inplace)
|
|
|
|
def test_quantity_abs_round(self):
|
|
|
|
x = self.Q_(-4.2, 'meter')
|
|
y = self.Q_(4.2, 'meter')
|
|
# In Python 3+ round of x is delegated to x.__round__, instead of round(x.__float__)
|
|
# and therefore it can be properly implemented by Pint
|
|
for fun in (abs, op.pos, op.neg) + (round, ) if PYTHON3 else ():
|
|
zx = self.Q_(fun(x.magnitude), 'meter')
|
|
zy = self.Q_(fun(y.magnitude), 'meter')
|
|
rx = fun(x)
|
|
ry = fun(y)
|
|
self.assertEqual(rx, zx, 'while testing {0}'.format(fun))
|
|
self.assertEqual(ry, zy, 'while testing {0}'.format(fun))
|
|
self.assertIsNot(rx, zx, 'while testing {0}'.format(fun))
|
|
self.assertIsNot(ry, zy, 'while testing {0}'.format(fun))
|
|
|
|
def test_quantity_float_complex(self):
|
|
x = self.Q_(-4.2, None)
|
|
y = self.Q_(4.2, None)
|
|
z = self.Q_(1, 'meter')
|
|
for fun in (float, complex):
|
|
self.assertEqual(fun(x), fun(x.magnitude))
|
|
self.assertEqual(fun(y), fun(y.magnitude))
|
|
self.assertRaises(DimensionalityError, fun, z)
|
|
|
|
|
|
class TestDimensions(QuantityTestCase):
|
|
|
|
FORCE_NDARRAY = False
|
|
|
|
def test_get_dimensionality(self):
|
|
get = self.ureg.get_dimensionality
|
|
self.assertEqual(get('[time]'), UnitsContainer({'[time]': 1}))
|
|
self.assertEqual(get(UnitsContainer({'[time]': 1})), UnitsContainer({'[time]': 1}))
|
|
self.assertEqual(get('seconds'), UnitsContainer({'[time]': 1}))
|
|
self.assertEqual(get(UnitsContainer({'seconds': 1})), UnitsContainer({'[time]': 1}))
|
|
self.assertEqual(get('[speed]'), UnitsContainer({'[length]': 1, '[time]': -1}))
|
|
self.assertEqual(get('[acceleration]'), UnitsContainer({'[length]': 1, '[time]': -2}))
|
|
|
|
def test_dimensionality(self):
|
|
x = self.Q_(42, 'centimeter')
|
|
x.to_base_units()
|
|
x = self.Q_(42, 'meter*second')
|
|
self.assertEqual(x.dimensionality, UnitsContainer({'[length]': 1., '[time]': 1.}))
|
|
x = self.Q_(42, 'meter*second*second')
|
|
self.assertEqual(x.dimensionality, UnitsContainer({'[length]': 1., '[time]': 2.}))
|
|
x = self.Q_(42, 'inch*second*second')
|
|
self.assertEqual(x.dimensionality, UnitsContainer({'[length]': 1., '[time]': 2.}))
|
|
self.assertTrue(self.Q_(42, None).dimensionless)
|
|
self.assertFalse(self.Q_(42, 'meter').dimensionless)
|
|
self.assertTrue((self.Q_(42, 'meter') / self.Q_(1, 'meter')).dimensionless)
|
|
self.assertFalse((self.Q_(42, 'meter') / self.Q_(1, 'second')).dimensionless)
|
|
self.assertTrue((self.Q_(42, 'meter') / self.Q_(1, 'inch')).dimensionless)
|
|
|
|
def test_inclusion(self):
|
|
dim = self.Q_(42, 'meter').dimensionality
|
|
self.assertTrue('[length]' in dim)
|
|
self.assertFalse('[time]' in dim)
|
|
dim = (self.Q_(42, 'meter') / self.Q_(11, 'second')).dimensionality
|
|
self.assertTrue('[length]' in dim)
|
|
self.assertTrue('[time]' in dim)
|
|
dim = self.Q_(20.785, 'J/(mol)').dimensionality
|
|
for dimension in ('[length]', '[mass]', '[substance]', '[time]'):
|
|
self.assertTrue(dimension in dim)
|
|
self.assertFalse('[angle]' in dim)
|
|
|
|
|
|
class TestQuantityWithDefaultRegistry(TestDimensions):
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
from pint import _DEFAULT_REGISTRY
|
|
cls.ureg = _DEFAULT_REGISTRY
|
|
cls.Q_ = cls.ureg.Quantity
|
|
|
|
|
|
class TestDimensionsWithDefaultRegistry(TestDimensions):
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
from pint import _DEFAULT_REGISTRY
|
|
cls.ureg = _DEFAULT_REGISTRY
|
|
cls.Q_ = cls.ureg.Quantity
|
|
|
|
|
|
class TestOffsetUnitMath(QuantityTestCase, ParameterizedTestCase):
|
|
|
|
def setup(self):
|
|
self.ureg.autoconvert_offset_to_baseunit = False
|
|
self.ureg.default_as_delta = True
|
|
|
|
additions = [
|
|
# --- input tuple -------------------- | -- expected result --
|
|
(((100, 'kelvin'), (10, 'kelvin')), (110, 'kelvin')),
|
|
(((100, 'kelvin'), (10, 'degC')), 'error'),
|
|
(((100, 'kelvin'), (10, 'degF')), 'error'),
|
|
(((100, 'kelvin'), (10, 'degR')), (105.56, 'kelvin')),
|
|
(((100, 'kelvin'), (10, 'delta_degC')), (110, 'kelvin')),
|
|
(((100, 'kelvin'), (10, 'delta_degF')), (105.56, 'kelvin')),
|
|
|
|
(((100, 'degC'), (10, 'kelvin')), 'error'),
|
|
(((100, 'degC'), (10, 'degC')), 'error'),
|
|
(((100, 'degC'), (10, 'degF')), 'error'),
|
|
(((100, 'degC'), (10, 'degR')), 'error'),
|
|
(((100, 'degC'), (10, 'delta_degC')), (110, 'degC')),
|
|
(((100, 'degC'), (10, 'delta_degF')), (105.56, 'degC')),
|
|
|
|
(((100, 'degF'), (10, 'kelvin')), 'error'),
|
|
(((100, 'degF'), (10, 'degC')), 'error'),
|
|
(((100, 'degF'), (10, 'degF')), 'error'),
|
|
(((100, 'degF'), (10, 'degR')), 'error'),
|
|
(((100, 'degF'), (10, 'delta_degC')), (118, 'degF')),
|
|
(((100, 'degF'), (10, 'delta_degF')), (110, 'degF')),
|
|
|
|
(((100, 'degR'), (10, 'kelvin')), (118, 'degR')),
|
|
(((100, 'degR'), (10, 'degC')), 'error'),
|
|
(((100, 'degR'), (10, 'degF')), 'error'),
|
|
(((100, 'degR'), (10, 'degR')), (110, 'degR')),
|
|
(((100, 'degR'), (10, 'delta_degC')), (118, 'degR')),
|
|
(((100, 'degR'), (10, 'delta_degF')), (110, 'degR')),
|
|
|
|
(((100, 'delta_degC'), (10, 'kelvin')), (110, 'kelvin')),
|
|
(((100, 'delta_degC'), (10, 'degC')), (110, 'degC')),
|
|
(((100, 'delta_degC'), (10, 'degF')), (190, 'degF')),
|
|
(((100, 'delta_degC'), (10, 'degR')), (190, 'degR')),
|
|
(((100, 'delta_degC'), (10, 'delta_degC')), (110, 'delta_degC')),
|
|
(((100, 'delta_degC'), (10, 'delta_degF')), (105.56, 'delta_degC')),
|
|
|
|
(((100, 'delta_degF'), (10, 'kelvin')), (65.56, 'kelvin')),
|
|
(((100, 'delta_degF'), (10, 'degC')), (65.56, 'degC')),
|
|
(((100, 'delta_degF'), (10, 'degF')), (110, 'degF')),
|
|
(((100, 'delta_degF'), (10, 'degR')), (110, 'degR')),
|
|
(((100, 'delta_degF'), (10, 'delta_degC')), (118, 'delta_degF')),
|
|
(((100, 'delta_degF'), (10, 'delta_degF')), (110, 'delta_degF')),
|
|
]
|
|
|
|
@ParameterizedTestCase.parameterize(("input", "expected_output"),
|
|
additions)
|
|
def test_addition(self, input_tuple, expected):
|
|
self.ureg.autoconvert_offset_to_baseunit = False
|
|
qin1, qin2 = input_tuple
|
|
q1, q2 = self.Q_(*qin1), self.Q_(*qin2)
|
|
# update input tuple with new values to have correct values on failure
|
|
input_tuple = q1, q2
|
|
if expected == 'error':
|
|
self.assertRaises(OffsetUnitCalculusError, op.add, q1, q2)
|
|
else:
|
|
expected = self.Q_(*expected)
|
|
self.assertEqual(op.add(q1, q2).units, expected.units)
|
|
self.assertQuantityAlmostEqual(op.add(q1, q2), expected,
|
|
atol=0.01)
|
|
|
|
@helpers.requires_numpy()
|
|
@ParameterizedTestCase.parameterize(("input", "expected_output"),
|
|
additions)
|
|
def test_inplace_addition(self, input_tuple, expected):
|
|
self.ureg.autoconvert_offset_to_baseunit = False
|
|
(q1v, q1u), (q2v, q2u) = input_tuple
|
|
# update input tuple with new values to have correct values on failure
|
|
input_tuple = ((np.array([q1v]*2, dtype=np.float), q1u),
|
|
(np.array([q2v]*2, dtype=np.float), q2u))
|
|
Q_ = self.Q_
|
|
qin1, qin2 = input_tuple
|
|
q1, q2 = Q_(*qin1), Q_(*qin2)
|
|
q1_cp = copy.copy(q1)
|
|
if expected == 'error':
|
|
self.assertRaises(OffsetUnitCalculusError, op.iadd, q1_cp, q2)
|
|
else:
|
|
expected = np.array([expected[0]]*2, dtype=np.float), expected[1]
|
|
self.assertEqual(op.iadd(q1_cp, q2).units, Q_(*expected).units)
|
|
q1_cp = copy.copy(q1)
|
|
self.assertQuantityAlmostEqual(op.iadd(q1_cp, q2), Q_(*expected),
|
|
atol=0.01)
|
|
|
|
subtractions = [
|
|
(((100, 'kelvin'), (10, 'kelvin')), (90, 'kelvin')),
|
|
(((100, 'kelvin'), (10, 'degC')), (-183.15, 'kelvin')),
|
|
(((100, 'kelvin'), (10, 'degF')), (-160.93, 'kelvin')),
|
|
(((100, 'kelvin'), (10, 'degR')), (94.44, 'kelvin')),
|
|
(((100, 'kelvin'), (10, 'delta_degC')), (90, 'kelvin')),
|
|
(((100, 'kelvin'), (10, 'delta_degF')), (94.44, 'kelvin')),
|
|
|
|
(((100, 'degC'), (10, 'kelvin')), (363.15, 'delta_degC')),
|
|
(((100, 'degC'), (10, 'degC')), (90, 'delta_degC')),
|
|
(((100, 'degC'), (10, 'degF')), (112.22, 'delta_degC')),
|
|
(((100, 'degC'), (10, 'degR')), (367.59, 'delta_degC')),
|
|
(((100, 'degC'), (10, 'delta_degC')), (90, 'degC')),
|
|
(((100, 'degC'), (10, 'delta_degF')), (94.44, 'degC')),
|
|
|
|
(((100, 'degF'), (10, 'kelvin')), (541.67, 'delta_degF')),
|
|
(((100, 'degF'), (10, 'degC')), (50, 'delta_degF')),
|
|
(((100, 'degF'), (10, 'degF')), (90, 'delta_degF')),
|
|
(((100, 'degF'), (10, 'degR')), (549.67, 'delta_degF')),
|
|
(((100, 'degF'), (10, 'delta_degC')), (82, 'degF')),
|
|
(((100, 'degF'), (10, 'delta_degF')), (90, 'degF')),
|
|
|
|
(((100, 'degR'), (10, 'kelvin')), (82, 'degR')),
|
|
(((100, 'degR'), (10, 'degC')), (-409.67, 'degR')),
|
|
(((100, 'degR'), (10, 'degF')), (-369.67, 'degR')),
|
|
(((100, 'degR'), (10, 'degR')), (90, 'degR')),
|
|
(((100, 'degR'), (10, 'delta_degC')), (82, 'degR')),
|
|
(((100, 'degR'), (10, 'delta_degF')), (90, 'degR')),
|
|
|
|
(((100, 'delta_degC'), (10, 'kelvin')), (90, 'kelvin')),
|
|
(((100, 'delta_degC'), (10, 'degC')), (90, 'degC')),
|
|
(((100, 'delta_degC'), (10, 'degF')), (170, 'degF')),
|
|
(((100, 'delta_degC'), (10, 'degR')), (170, 'degR')),
|
|
(((100, 'delta_degC'), (10, 'delta_degC')), (90, 'delta_degC')),
|
|
(((100, 'delta_degC'), (10, 'delta_degF')), (94.44, 'delta_degC')),
|
|
|
|
(((100, 'delta_degF'), (10, 'kelvin')), (45.56, 'kelvin')),
|
|
(((100, 'delta_degF'), (10, 'degC')), (45.56, 'degC')),
|
|
(((100, 'delta_degF'), (10, 'degF')), (90, 'degF')),
|
|
(((100, 'delta_degF'), (10, 'degR')), (90, 'degR')),
|
|
(((100, 'delta_degF'), (10, 'delta_degC')), (82, 'delta_degF')),
|
|
(((100, 'delta_degF'), (10, 'delta_degF')), (90, 'delta_degF')),
|
|
]
|
|
|
|
@ParameterizedTestCase.parameterize(("input", "expected_output"),
|
|
subtractions)
|
|
def test_subtraction(self, input_tuple, expected):
|
|
self.ureg.autoconvert_offset_to_baseunit = False
|
|
qin1, qin2 = input_tuple
|
|
q1, q2 = self.Q_(*qin1), self.Q_(*qin2)
|
|
input_tuple = q1, q2
|
|
if expected == 'error':
|
|
self.assertRaises(OffsetUnitCalculusError, op.sub, q1, q2)
|
|
else:
|
|
expected = self.Q_(*expected)
|
|
self.assertEqual(op.sub(q1, q2).units, expected.units)
|
|
self.assertQuantityAlmostEqual(op.sub(q1, q2), expected,
|
|
atol=0.01)
|
|
|
|
# @unittest.expectedFailure
|
|
@helpers.requires_numpy()
|
|
@ParameterizedTestCase.parameterize(("input", "expected_output"),
|
|
subtractions)
|
|
def test_inplace_subtraction(self, input_tuple, expected):
|
|
self.ureg.autoconvert_offset_to_baseunit = False
|
|
(q1v, q1u), (q2v, q2u) = input_tuple
|
|
# update input tuple with new values to have correct values on failure
|
|
input_tuple = ((np.array([q1v]*2, dtype=np.float), q1u),
|
|
(np.array([q2v]*2, dtype=np.float), q2u))
|
|
Q_ = self.Q_
|
|
qin1, qin2 = input_tuple
|
|
q1, q2 = Q_(*qin1), Q_(*qin2)
|
|
q1_cp = copy.copy(q1)
|
|
if expected == 'error':
|
|
self.assertRaises(OffsetUnitCalculusError, op.isub, q1_cp, q2)
|
|
else:
|
|
expected = np.array([expected[0]]*2, dtype=np.float), expected[1]
|
|
self.assertEqual(op.isub(q1_cp, q2).units, Q_(*expected).units)
|
|
q1_cp = copy.copy(q1)
|
|
self.assertQuantityAlmostEqual(op.isub(q1_cp, q2), Q_(*expected),
|
|
atol=0.01)
|
|
|
|
multiplications = [
|
|
(((100, 'kelvin'), (10, 'kelvin')), (1000, 'kelvin**2')),
|
|
(((100, 'kelvin'), (10, 'degC')), 'error'),
|
|
(((100, 'kelvin'), (10, 'degF')), 'error'),
|
|
(((100, 'kelvin'), (10, 'degR')), (1000, 'kelvin*degR')),
|
|
(((100, 'kelvin'), (10, 'delta_degC')), (1000, 'kelvin*delta_degC')),
|
|
(((100, 'kelvin'), (10, 'delta_degF')), (1000, 'kelvin*delta_degF')),
|
|
|
|
(((100, 'degC'), (10, 'kelvin')), 'error'),
|
|
(((100, 'degC'), (10, 'degC')), 'error'),
|
|
(((100, 'degC'), (10, 'degF')), 'error'),
|
|
(((100, 'degC'), (10, 'degR')), 'error'),
|
|
(((100, 'degC'), (10, 'delta_degC')), 'error'),
|
|
(((100, 'degC'), (10, 'delta_degF')), 'error'),
|
|
|
|
(((100, 'degF'), (10, 'kelvin')), 'error'),
|
|
(((100, 'degF'), (10, 'degC')), 'error'),
|
|
(((100, 'degF'), (10, 'degF')), 'error'),
|
|
(((100, 'degF'), (10, 'degR')), 'error'),
|
|
(((100, 'degF'), (10, 'delta_degC')), 'error'),
|
|
(((100, 'degF'), (10, 'delta_degF')), 'error'),
|
|
|
|
(((100, 'degR'), (10, 'kelvin')), (1000, 'degR*kelvin')),
|
|
(((100, 'degR'), (10, 'degC')), 'error'),
|
|
(((100, 'degR'), (10, 'degF')), 'error'),
|
|
(((100, 'degR'), (10, 'degR')), (1000, 'degR**2')),
|
|
(((100, 'degR'), (10, 'delta_degC')), (1000, 'degR*delta_degC')),
|
|
(((100, 'degR'), (10, 'delta_degF')), (1000, 'degR*delta_degF')),
|
|
|
|
(((100, 'delta_degC'), (10, 'kelvin')), (1000, 'delta_degC*kelvin')),
|
|
(((100, 'delta_degC'), (10, 'degC')), 'error'),
|
|
(((100, 'delta_degC'), (10, 'degF')), 'error'),
|
|
(((100, 'delta_degC'), (10, 'degR')), (1000, 'delta_degC*degR')),
|
|
(((100, 'delta_degC'), (10, 'delta_degC')), (1000, 'delta_degC**2')),
|
|
(((100, 'delta_degC'), (10, 'delta_degF')), (1000, 'delta_degC*delta_degF')),
|
|
|
|
(((100, 'delta_degF'), (10, 'kelvin')), (1000, 'delta_degF*kelvin')),
|
|
(((100, 'delta_degF'), (10, 'degC')), 'error'),
|
|
(((100, 'delta_degF'), (10, 'degF')), 'error'),
|
|
(((100, 'delta_degF'), (10, 'degR')), (1000, 'delta_degF*degR')),
|
|
(((100, 'delta_degF'), (10, 'delta_degC')), (1000, 'delta_degF*delta_degC')),
|
|
(((100, 'delta_degF'), (10, 'delta_degF')), (1000, 'delta_degF**2')),
|
|
]
|
|
|
|
@ParameterizedTestCase.parameterize(("input", "expected_output"),
|
|
multiplications)
|
|
def test_multiplication(self, input_tuple, expected):
|
|
self.ureg.autoconvert_offset_to_baseunit = False
|
|
qin1, qin2 = input_tuple
|
|
q1, q2 = self.Q_(*qin1), self.Q_(*qin2)
|
|
input_tuple = q1, q2
|
|
if expected == 'error':
|
|
self.assertRaises(OffsetUnitCalculusError, op.mul, q1, q2)
|
|
else:
|
|
expected = self.Q_(*expected)
|
|
self.assertEqual(op.mul(q1, q2).units, expected.units)
|
|
self.assertQuantityAlmostEqual(op.mul(q1, q2), expected,
|
|
atol=0.01)
|
|
|
|
@helpers.requires_numpy()
|
|
@ParameterizedTestCase.parameterize(("input", "expected_output"),
|
|
multiplications)
|
|
def test_inplace_multiplication(self, input_tuple, expected):
|
|
self.ureg.autoconvert_offset_to_baseunit = False
|
|
(q1v, q1u), (q2v, q2u) = input_tuple
|
|
# update input tuple with new values to have correct values on failure
|
|
input_tuple = ((np.array([q1v]*2, dtype=np.float), q1u),
|
|
(np.array([q2v]*2, dtype=np.float), q2u))
|
|
Q_ = self.Q_
|
|
qin1, qin2 = input_tuple
|
|
q1, q2 = Q_(*qin1), Q_(*qin2)
|
|
q1_cp = copy.copy(q1)
|
|
if expected == 'error':
|
|
self.assertRaises(OffsetUnitCalculusError, op.imul, q1_cp, q2)
|
|
else:
|
|
expected = np.array([expected[0]]*2, dtype=np.float), expected[1]
|
|
self.assertEqual(op.imul(q1_cp, q2).units, Q_(*expected).units)
|
|
q1_cp = copy.copy(q1)
|
|
self.assertQuantityAlmostEqual(op.imul(q1_cp, q2), Q_(*expected),
|
|
atol=0.01)
|
|
|
|
divisions = [
|
|
(((100, 'kelvin'), (10, 'kelvin')), (10, '')),
|
|
(((100, 'kelvin'), (10, 'degC')), 'error'),
|
|
(((100, 'kelvin'), (10, 'degF')), 'error'),
|
|
(((100, 'kelvin'), (10, 'degR')), (10, 'kelvin/degR')),
|
|
(((100, 'kelvin'), (10, 'delta_degC')), (10, 'kelvin/delta_degC')),
|
|
(((100, 'kelvin'), (10, 'delta_degF')), (10, 'kelvin/delta_degF')),
|
|
|
|
(((100, 'degC'), (10, 'kelvin')), 'error'),
|
|
(((100, 'degC'), (10, 'degC')), 'error'),
|
|
(((100, 'degC'), (10, 'degF')), 'error'),
|
|
(((100, 'degC'), (10, 'degR')), 'error'),
|
|
(((100, 'degC'), (10, 'delta_degC')), 'error'),
|
|
(((100, 'degC'), (10, 'delta_degF')), 'error'),
|
|
|
|
(((100, 'degF'), (10, 'kelvin')), 'error'),
|
|
(((100, 'degF'), (10, 'degC')), 'error'),
|
|
(((100, 'degF'), (10, 'degF')), 'error'),
|
|
(((100, 'degF'), (10, 'degR')), 'error'),
|
|
(((100, 'degF'), (10, 'delta_degC')), 'error'),
|
|
(((100, 'degF'), (10, 'delta_degF')), 'error'),
|
|
|
|
(((100, 'degR'), (10, 'kelvin')), (10, 'degR/kelvin')),
|
|
(((100, 'degR'), (10, 'degC')), 'error'),
|
|
(((100, 'degR'), (10, 'degF')), 'error'),
|
|
(((100, 'degR'), (10, 'degR')), (10, '')),
|
|
(((100, 'degR'), (10, 'delta_degC')), (10, 'degR/delta_degC')),
|
|
(((100, 'degR'), (10, 'delta_degF')), (10, 'degR/delta_degF')),
|
|
|
|
(((100, 'delta_degC'), (10, 'kelvin')), (10, 'delta_degC/kelvin')),
|
|
(((100, 'delta_degC'), (10, 'degC')), 'error'),
|
|
(((100, 'delta_degC'), (10, 'degF')), 'error'),
|
|
(((100, 'delta_degC'), (10, 'degR')), (10, 'delta_degC/degR')),
|
|
(((100, 'delta_degC'), (10, 'delta_degC')), (10, '')),
|
|
(((100, 'delta_degC'), (10, 'delta_degF')), (10, 'delta_degC/delta_degF')),
|
|
|
|
(((100, 'delta_degF'), (10, 'kelvin')), (10, 'delta_degF/kelvin')),
|
|
(((100, 'delta_degF'), (10, 'degC')), 'error'),
|
|
(((100, 'delta_degF'), (10, 'degF')), 'error'),
|
|
(((100, 'delta_degF'), (10, 'degR')), (10, 'delta_degF/degR')),
|
|
(((100, 'delta_degF'), (10, 'delta_degC')), (10, 'delta_degF/delta_degC')),
|
|
(((100, 'delta_degF'), (10, 'delta_degF')), (10, '')),
|
|
]
|
|
|
|
@ParameterizedTestCase.parameterize(("input", "expected_output"),
|
|
divisions)
|
|
def test_truedivision(self, input_tuple, expected):
|
|
self.ureg.autoconvert_offset_to_baseunit = False
|
|
qin1, qin2 = input_tuple
|
|
q1, q2 = self.Q_(*qin1), self.Q_(*qin2)
|
|
input_tuple = q1, q2
|
|
if expected == 'error':
|
|
self.assertRaises(OffsetUnitCalculusError, op.truediv, q1, q2)
|
|
else:
|
|
expected = self.Q_(*expected)
|
|
self.assertEqual(op.truediv(q1, q2).units, expected.units)
|
|
self.assertQuantityAlmostEqual(op.truediv(q1, q2), expected,
|
|
atol=0.01)
|
|
|
|
@helpers.requires_numpy()
|
|
@ParameterizedTestCase.parameterize(("input", "expected_output"),
|
|
divisions)
|
|
def test_inplace_truedivision(self, input_tuple, expected):
|
|
self.ureg.autoconvert_offset_to_baseunit = False
|
|
(q1v, q1u), (q2v, q2u) = input_tuple
|
|
# update input tuple with new values to have correct values on failure
|
|
input_tuple = ((np.array([q1v]*2, dtype=np.float), q1u),
|
|
(np.array([q2v]*2, dtype=np.float), q2u))
|
|
Q_ = self.Q_
|
|
qin1, qin2 = input_tuple
|
|
q1, q2 = Q_(*qin1), Q_(*qin2)
|
|
q1_cp = copy.copy(q1)
|
|
if expected == 'error':
|
|
self.assertRaises(OffsetUnitCalculusError, op.itruediv, q1_cp, q2)
|
|
else:
|
|
expected = np.array([expected[0]]*2, dtype=np.float), expected[1]
|
|
self.assertEqual(op.itruediv(q1_cp, q2).units, Q_(*expected).units)
|
|
q1_cp = copy.copy(q1)
|
|
self.assertQuantityAlmostEqual(op.itruediv(q1_cp, q2),
|
|
Q_(*expected), atol=0.01)
|
|
|
|
multiplications_with_autoconvert_to_baseunit = [
|
|
(((100, 'kelvin'), (10, 'degC')), (28315., 'kelvin**2')),
|
|
(((100, 'kelvin'), (10, 'degF')), (26092.78, 'kelvin**2')),
|
|
|
|
(((100, 'degC'), (10, 'kelvin')), (3731.5, 'kelvin**2')),
|
|
(((100, 'degC'), (10, 'degC')), (105657.42, 'kelvin**2')),
|
|
(((100, 'degC'), (10, 'degF')), (97365.20, 'kelvin**2')),
|
|
(((100, 'degC'), (10, 'degR')), (3731.5, 'kelvin*degR')),
|
|
(((100, 'degC'), (10, 'delta_degC')), (3731.5, 'kelvin*delta_degC')),
|
|
(((100, 'degC'), (10, 'delta_degF')), (3731.5, 'kelvin*delta_degF')),
|
|
|
|
(((100, 'degF'), (10, 'kelvin')), (3109.28, 'kelvin**2')),
|
|
(((100, 'degF'), (10, 'degC')), (88039.20, 'kelvin**2')),
|
|
(((100, 'degF'), (10, 'degF')), (81129.69, 'kelvin**2')),
|
|
(((100, 'degF'), (10, 'degR')), (3109.28, 'kelvin*degR')),
|
|
(((100, 'degF'), (10, 'delta_degC')), (3109.28, 'kelvin*delta_degC')),
|
|
(((100, 'degF'), (10, 'delta_degF')), (3109.28, 'kelvin*delta_degF')),
|
|
|
|
(((100, 'degR'), (10, 'degC')), (28315., 'degR*kelvin')),
|
|
(((100, 'degR'), (10, 'degF')), (26092.78, 'degR*kelvin')),
|
|
|
|
(((100, 'delta_degC'), (10, 'degC')), (28315., 'delta_degC*kelvin')),
|
|
(((100, 'delta_degC'), (10, 'degF')), (26092.78, 'delta_degC*kelvin')),
|
|
|
|
(((100, 'delta_degF'), (10, 'degC')), (28315., 'delta_degF*kelvin')),
|
|
(((100, 'delta_degF'), (10, 'degF')), (26092.78, 'delta_degF*kelvin')),
|
|
]
|
|
|
|
@ParameterizedTestCase.parameterize(
|
|
("input", "expected_output"),
|
|
multiplications_with_autoconvert_to_baseunit)
|
|
def test_multiplication_with_autoconvert(self, input_tuple, expected):
|
|
self.ureg.autoconvert_offset_to_baseunit = True
|
|
qin1, qin2 = input_tuple
|
|
q1, q2 = self.Q_(*qin1), self.Q_(*qin2)
|
|
input_tuple = q1, q2
|
|
if expected == 'error':
|
|
self.assertRaises(OffsetUnitCalculusError, op.mul, q1, q2)
|
|
else:
|
|
expected = self.Q_(*expected)
|
|
self.assertEqual(op.mul(q1, q2).units, expected.units)
|
|
self.assertQuantityAlmostEqual(op.mul(q1, q2), expected,
|
|
atol=0.01)
|
|
|
|
@helpers.requires_numpy()
|
|
@ParameterizedTestCase.parameterize(
|
|
("input", "expected_output"),
|
|
multiplications_with_autoconvert_to_baseunit)
|
|
def test_inplace_multiplication_with_autoconvert(self, input_tuple, expected):
|
|
self.ureg.autoconvert_offset_to_baseunit = True
|
|
(q1v, q1u), (q2v, q2u) = input_tuple
|
|
# update input tuple with new values to have correct values on failure
|
|
input_tuple = ((np.array([q1v]*2, dtype=np.float), q1u),
|
|
(np.array([q2v]*2, dtype=np.float), q2u))
|
|
Q_ = self.Q_
|
|
qin1, qin2 = input_tuple
|
|
q1, q2 = Q_(*qin1), Q_(*qin2)
|
|
q1_cp = copy.copy(q1)
|
|
if expected == 'error':
|
|
self.assertRaises(OffsetUnitCalculusError, op.imul, q1_cp, q2)
|
|
else:
|
|
expected = np.array([expected[0]]*2, dtype=np.float), expected[1]
|
|
self.assertEqual(op.imul(q1_cp, q2).units, Q_(*expected).units)
|
|
q1_cp = copy.copy(q1)
|
|
self.assertQuantityAlmostEqual(op.imul(q1_cp, q2), Q_(*expected),
|
|
atol=0.01)
|
|
|
|
multiplications_with_scalar = [
|
|
(((10, 'kelvin'), 2), (20., 'kelvin')),
|
|
(((10, 'kelvin**2'), 2), (20., 'kelvin**2')),
|
|
(((10, 'degC'), 2), (20., 'degC')),
|
|
(((10, '1/degC'), 2), 'error'),
|
|
(((10, 'degC**0.5'), 2), 'error'),
|
|
(((10, 'degC**2'), 2), 'error'),
|
|
(((10, 'degC**-2'), 2), 'error'),
|
|
]
|
|
|
|
@ParameterizedTestCase.parameterize(
|
|
("input", "expected_output"), multiplications_with_scalar)
|
|
def test_multiplication_with_scalar(self, input_tuple, expected):
|
|
self.ureg.default_as_delta = False
|
|
in1, in2 = input_tuple
|
|
if type(in1) is tuple:
|
|
in1, in2 = self.Q_(*in1), in2
|
|
else:
|
|
in1, in2 = in1, self.Q_(*in2)
|
|
input_tuple = in1, in2 # update input_tuple for better tracebacks
|
|
if expected == 'error':
|
|
self.assertRaises(OffsetUnitCalculusError, op.mul, in1, in2)
|
|
else:
|
|
expected = self.Q_(*expected)
|
|
self.assertEqual(op.mul(in1, in2).units, expected.units)
|
|
self.assertQuantityAlmostEqual(op.mul(in1, in2), expected,
|
|
atol=0.01)
|
|
|
|
divisions_with_scalar = [ # without / with autoconvert to base unit
|
|
(((10, 'kelvin'), 2), [(5., 'kelvin'), (5., 'kelvin')]),
|
|
(((10, 'kelvin**2'), 2), [(5., 'kelvin**2'), (5., 'kelvin**2')]),
|
|
(((10, 'degC'), 2), ['error', 'error']),
|
|
(((10, 'degC**2'), 2), ['error', 'error']),
|
|
(((10, 'degC**-2'), 2), ['error', 'error']),
|
|
|
|
((2, (10, 'kelvin')), [(0.2, '1/kelvin'), (0.2, '1/kelvin')]),
|
|
((2, (10, 'degC')), ['error', (2/283.15, '1/kelvin')]),
|
|
((2, (10, 'degC**2')), ['error', 'error']),
|
|
((2, (10, 'degC**-2')), ['error', 'error']),
|
|
]
|
|
|
|
@ParameterizedTestCase.parameterize(
|
|
("input", "expected_output"), divisions_with_scalar)
|
|
def test_division_with_scalar(self, input_tuple, expected):
|
|
self.ureg.default_as_delta = False
|
|
in1, in2 = input_tuple
|
|
if type(in1) is tuple:
|
|
in1, in2 = self.Q_(*in1), in2
|
|
else:
|
|
in1, in2 = in1, self.Q_(*in2)
|
|
input_tuple = in1, in2 # update input_tuple for better tracebacks
|
|
expected_copy = expected[:]
|
|
for i, mode in enumerate([False, True]):
|
|
self.ureg.autoconvert_offset_to_baseunit = mode
|
|
if expected_copy[i] == 'error':
|
|
self.assertRaises(OffsetUnitCalculusError, op.truediv, in1, in2)
|
|
else:
|
|
expected = self.Q_(*expected_copy[i])
|
|
self.assertEqual(op.truediv(in1, in2).units, expected.units)
|
|
self.assertQuantityAlmostEqual(op.truediv(in1, in2), expected)
|
|
|
|
exponentiation = [ # resuls without / with autoconvert
|
|
(((10, 'degC'), 1), [(10, 'degC'), (10, 'degC')]),
|
|
(((10, 'degC'), 0.5), ['error', (283.15**0.5, 'kelvin**0.5')]),
|
|
(((10, 'degC'), 0), [(1., ''), (1., '')]),
|
|
(((10, 'degC'), -1), ['error', (1/(10+273.15), 'kelvin**-1')]),
|
|
(((10, 'degC'), -2), ['error', (1/(10+273.15)**2., 'kelvin**-2')]),
|
|
((( 0, 'degC'), -2), ['error', (1/(273.15)**2, 'kelvin**-2')]),
|
|
(((10, 'degC'), (2, '')), ['error', ((283.15)**2, 'kelvin**2')]),
|
|
(((10, 'degC'), (10, 'degK')), ['error', 'error']),
|
|
|
|
(((10, 'kelvin'), (2, '')), [(100., 'kelvin**2'), (100., 'kelvin**2')]),
|
|
|
|
(( 2, (2, 'kelvin')), ['error', 'error']),
|
|
(( 2, (500., 'millikelvin/kelvin')), [2**0.5, 2**0.5]),
|
|
(( 2, (0.5, 'kelvin/kelvin')), [2**0.5, 2**0.5]),
|
|
(((10, 'degC'), (500., 'millikelvin/kelvin')),
|
|
['error', (283.15**0.5, 'kelvin**0.5')]),
|
|
]
|
|
|
|
@ParameterizedTestCase.parameterize(
|
|
("input", "expected_output"), exponentiation)
|
|
def test_exponentiation(self, input_tuple, expected):
|
|
self.ureg.default_as_delta = False
|
|
in1, in2 = input_tuple
|
|
if type(in1) is tuple and type(in2) is tuple:
|
|
in1, in2 = self.Q_(*in1), self.Q_(*in2)
|
|
elif not type(in1) is tuple and type(in2) is tuple:
|
|
in2 = self.Q_(*in2)
|
|
else:
|
|
in1 = self.Q_(*in1)
|
|
input_tuple = in1, in2
|
|
expected_copy = expected[:]
|
|
for i, mode in enumerate([False, True]):
|
|
self.ureg.autoconvert_offset_to_baseunit = mode
|
|
if expected_copy[i] == 'error':
|
|
self.assertRaises((OffsetUnitCalculusError,
|
|
DimensionalityError), op.pow, in1, in2)
|
|
else:
|
|
if type(expected_copy[i]) is tuple:
|
|
expected = self.Q_(*expected_copy[i])
|
|
self.assertEqual(op.pow(in1, in2).units, expected.units)
|
|
else:
|
|
expected = expected_copy[i]
|
|
self.assertQuantityAlmostEqual(op.pow(in1, in2), expected)
|
|
|
|
@helpers.requires_numpy()
|
|
@ParameterizedTestCase.parameterize(
|
|
("input", "expected_output"), exponentiation)
|
|
def test_inplace_exponentiation(self, input_tuple, expected):
|
|
self.ureg.default_as_delta = False
|
|
in1, in2 = input_tuple
|
|
if type(in1) is tuple and type(in2) is tuple:
|
|
(q1v, q1u), (q2v, q2u) = in1, in2
|
|
in1 = self.Q_(*(np.array([q1v]*2, dtype=np.float), q1u))
|
|
in2 = self.Q_(q2v, q2u)
|
|
elif not type(in1) is tuple and type(in2) is tuple:
|
|
in2 = self.Q_(*in2)
|
|
else:
|
|
in1 = self.Q_(*in1)
|
|
|
|
input_tuple = in1, in2
|
|
|
|
expected_copy = expected[:]
|
|
for i, mode in enumerate([False, True]):
|
|
self.ureg.autoconvert_offset_to_baseunit = mode
|
|
in1_cp = copy.copy(in1)
|
|
if expected_copy[i] == 'error':
|
|
self.assertRaises((OffsetUnitCalculusError,
|
|
DimensionalityError), op.ipow, in1_cp, in2)
|
|
else:
|
|
if type(expected_copy[i]) is tuple:
|
|
expected = self.Q_(np.array([expected_copy[i][0]]*2,
|
|
dtype=np.float),
|
|
expected_copy[i][1])
|
|
self.assertEqual(op.ipow(in1_cp, in2).units, expected.units)
|
|
else:
|
|
expected = np.array([expected_copy[i]]*2, dtype=np.float)
|
|
|
|
|
|
in1_cp = copy.copy(in1)
|
|
self.assertQuantityAlmostEqual(op.ipow(in1_cp, in2), expected)
|
|
|
|
|
|
class TestDimensionReduction(QuantityTestCase):
|
|
def _calc_mass(self, ureg):
|
|
density = 3 * ureg.g / ureg.L
|
|
volume = 32 * ureg.milliliter
|
|
return density * volume
|
|
|
|
def _icalc_mass(self, ureg):
|
|
res = ureg.Quantity(3.0, 'gram/liter')
|
|
res *= ureg.Quantity(32.0, 'milliliter')
|
|
return res
|
|
|
|
def test_mul_and_div_reduction(self):
|
|
ureg = UnitRegistry(auto_reduce_dimensions=True)
|
|
mass = self._calc_mass(ureg)
|
|
self.assertEqual(mass.units, ureg.g)
|
|
ureg = UnitRegistry(auto_reduce_dimensions=False)
|
|
mass = self._calc_mass(ureg)
|
|
self.assertEqual(mass.units, ureg.g / ureg.L * ureg.milliliter)
|
|
|
|
@helpers.requires_numpy()
|
|
def test_imul_and_div_reduction(self):
|
|
ureg = UnitRegistry(auto_reduce_dimensions=True, force_ndarray=True)
|
|
mass = self._icalc_mass(ureg)
|
|
self.assertEqual(mass.units, ureg.g)
|
|
ureg = UnitRegistry(auto_reduce_dimensions=False, force_ndarray=True)
|
|
mass = self._icalc_mass(ureg)
|
|
self.assertEqual(mass.units, ureg.g / ureg.L * ureg.milliliter)
|
|
|
|
def test_reduction_to_dimensionless(self):
|
|
ureg = UnitRegistry(auto_reduce_dimensions=True)
|
|
x = (10 * ureg.feet) / (3 * ureg.inches)
|
|
self.assertEqual(x.units, UnitsContainer({}))
|
|
ureg = UnitRegistry(auto_reduce_dimensions=False)
|
|
x = (10 * ureg.feet) / (3 * ureg.inches)
|
|
self.assertEqual(x.units, ureg.feet / ureg.inches)
|
|
|
|
|
|
class TestTimedelta(QuantityTestCase):
|
|
def test_add_sub(self):
|
|
d = datetime.datetime(year=1968, month=1, day=10, hour=3, minute=42, second=24)
|
|
after = d + 3 * self.ureg.second
|
|
self.assertEqual(d + datetime.timedelta(seconds=3), after)
|
|
after = 3 * self.ureg.second + d
|
|
self.assertEqual(d + datetime.timedelta(seconds=3), after)
|
|
after = d - 3 * self.ureg.second
|
|
self.assertEqual(d - datetime.timedelta(seconds=3), after)
|
|
with self.assertRaises(DimensionalityError):
|
|
3 * self.ureg.second - d
|
|
|
|
def test_iadd_isub(self):
|
|
d = datetime.datetime(year=1968, month=1, day=10, hour=3, minute=42, second=24)
|
|
after = copy.copy(d)
|
|
after += 3 * self.ureg.second
|
|
self.assertEqual(d + datetime.timedelta(seconds=3), after)
|
|
after = 3 * self.ureg.second
|
|
after += d
|
|
self.assertEqual(d + datetime.timedelta(seconds=3), after)
|
|
after = copy.copy(d)
|
|
after -= 3 * self.ureg.second
|
|
self.assertEqual(d - datetime.timedelta(seconds=3), after)
|
|
after = 3 * self.ureg.second
|
|
with self.assertRaises(DimensionalityError):
|
|
after -= d
|