1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
from __future__ import annotations
from decimal import Decimal
from fractions import Fraction
import pytest
from pint import UnitRegistry
from pint.testsuite import helpers
from pint.util import infer_base_unit
def test_infer_base_unit(sess_registry):
test_units = sess_registry.Quantity(1, "meter**2").units
registry = sess_registry
assert (
infer_base_unit(sess_registry.Quantity(1, "millimeter * nanometer"))
== test_units
)
assert infer_base_unit("millimeter * nanometer", registry) == test_units
assert (
infer_base_unit(
sess_registry.Quantity(1, "millimeter * nanometer").units, registry
)
== test_units
)
with pytest.raises(ValueError, match=r"No registry provided."):
infer_base_unit("millimeter")
def test_infer_base_unit_decimal(sess_registry):
ureg = UnitRegistry(non_int_type=Decimal)
QD = ureg.Quantity
ibu_d = infer_base_unit(QD(Decimal(1), "millimeter * nanometer"))
assert ibu_d == QD(Decimal(1), "meter**2").units
assert all(isinstance(v, Decimal) for v in ibu_d.values())
def test_infer_base_unit_fraction(sess_registry):
ureg = UnitRegistry(non_int_type=Fraction)
QD = ureg.Quantity
ibu_d = infer_base_unit(QD(Fraction("1"), "millimeter * nanometer"))
assert ibu_d == QD(Fraction("1"), "meter**2").units
assert all(isinstance(v, Fraction) for v in ibu_d.values())
def test_units_adding_to_zero(sess_registry):
assert (
infer_base_unit(sess_registry.Quantity(1, "m * mm / m / um * s"))
== sess_registry.Quantity(1, "s").units
)
def test_to_compact(sess_registry):
r = (
sess_registry.Quantity(1000000000, "m")
* sess_registry.Quantity(1, "mm")
/ sess_registry.Quantity(1, "s")
/ sess_registry.Quantity(1, "ms")
)
compact_r = r.to_compact()
expected = sess_registry.Quantity(1000.0, "kilometer**2 / second**2")
helpers.assert_quantity_almost_equal(compact_r, expected)
r = (
sess_registry.Quantity(1, "m")
* sess_registry.Quantity(1, "mm")
/ sess_registry.Quantity(1, "m")
/ sess_registry.Quantity(2, "um")
* sess_registry.Quantity(2, "s")
).to_compact()
helpers.assert_quantity_almost_equal(r, sess_registry.Quantity(1000, "s"))
def test_to_compact_decimal(sess_registry):
ureg = UnitRegistry(non_int_type=Decimal)
Q = ureg.Quantity
r = (
Q(Decimal("1000000000.0"), "m")
* Q(Decimal(1), "mm")
/ Q(Decimal(1), "s")
/ Q(Decimal(1), "ms")
)
compact_r = r.to_compact()
expected = Q(Decimal("1000.0"), "kilometer**2 / second**2")
assert compact_r == expected
r = (
Q(Decimal(1), "m") * Q(1, "mm") / Q(1, "m**2") / Q(2, "um") * Q(2, "s")
).to_compact()
assert r == Q(1000, "s/m")
def test_to_compact_fraction(sess_registry):
ureg = UnitRegistry(non_int_type=Fraction)
Q = ureg.Quantity
r = (
Q(Fraction("10000000000/10"), "m")
* Q(Fraction("1"), "mm")
/ Q(Fraction("1"), "s")
/ Q(Fraction("1"), "ms")
)
compact_r = r.to_compact()
expected = Q(Fraction("1000.0"), "kilometer**2 / second**2")
assert compact_r == expected
r = (
sess_registry.Quantity(Fraction(1), "m")
* sess_registry.Quantity(1, "mm")
/ sess_registry.Quantity(1, "m**2")
/ sess_registry.Quantity(2, "um")
* sess_registry.Quantity(2, "s")
).to_compact()
assert r == Q(1000, "s/m")
def test_volts(sess_registry):
r = (
sess_registry.Quantity(1, "V")
* sess_registry.Quantity(1, "mV")
/ sess_registry.Quantity(1, "kV")
)
b = infer_base_unit(r)
assert b == sess_registry.Quantity(1, "V").units
helpers.assert_quantity_almost_equal(r, sess_registry.Quantity(1, "uV"))
|
