ucon 0.3.5rc2__py3-none-any.whl → 0.4.1__py3-none-any.whl

tests/ucon/test_quantity.py

@@ -19,38 +19,38 @@ class TestNumber(unittest.TestCase):
         self.assertEqual(ratio.numerator, self.number)
         self.assertEqual(ratio.denominator, Number())
 
-    @unittest.skip("Requires ConversionGraph implementation")
-    def test_simplify(self):
-        decagram = UnitFactor(dimension=Dimension.mass, name='gram', scale=Scale.deca)
-        kibigram = UnitFactor(dimension=Dimension.mass, name='gram', scale=Scale.kibi)
-
+    def test_simplify_scaled_unit(self):
+        """Test simplify() removes scale prefix and adjusts quantity."""
+        decagram = Scale.deca * units.gram
         ten_decagrams = Number(unit=decagram, quantity=10)
-        point_one_decagrams = Number(unit=decagram, quantity=0.1)
-        two_kibigrams = Number(unit=kibigram, quantity=2)
-
-        self.assertEqual(Number(unit=units.gram, quantity=100), ten_decagrams.simplify())
-        self.assertEqual(Number(unit=units.gram, quantity=1), point_one_decagrams.simplify())
-        self.assertEqual(Number(unit=units.gram, quantity=2048), two_kibigrams.simplify())
-
-    @unittest.skip("Requires ConversionGraph implementation")
-    def test_to(self):
-        kg = UnitFactor(dimension=Dimension.mass, name='gram', scale=Scale.kilo)
-        mg = UnitFactor(dimension=Dimension.mass, name='gram', scale=Scale.milli)
-        kibigram = UnitFactor(dimension=Dimension.mass, name='gram', scale=Scale.kibi)
-
-        thousandth_of_a_kilogram = Number(unit=kg, quantity=0.001)
-        thousand_milligrams = Number(unit=mg, quantity=1000)
-        kibigram_fraction = Number(unit=kibigram, quantity=0.0009765625)
+        result = ten_decagrams.simplify()
+        # 10 decagrams = 100 grams
+        self.assertAlmostEqual(result.quantity, 100.0, places=10)
+        # Unit should be base gram (Scale.one)
+        self.assertEqual(result.unit.shorthand, "g")
+
+    def test_to_converts_between_units(self):
+        """Test Number.to() converts between compatible units."""
+        # 1 gram to kilogram
+        kg = Scale.kilo * units.gram
+        result = self.number.to(kg)
+        self.assertAlmostEqual(result.quantity, 0.001, places=10)
+
+        # 1 gram to milligram
+        mg = Scale.milli * units.gram
+        result = self.number.to(mg)
+        self.assertAlmostEqual(result.quantity, 1000.0, places=10)
 
-        self.assertEqual(thousandth_of_a_kilogram, self.number.to(Scale.kilo))
-        self.assertEqual(thousand_milligrams, self.number.to(Scale.milli))
-        self.assertEqual(kibigram_fraction, self.number.to(Scale.kibi))
+        # 1 kilogram to gram
+        one_kg = Number(unit=kg, quantity=1)
+        result = one_kg.to(units.gram)
+        self.assertAlmostEqual(result.quantity, 1000.0, places=10)
 
-    @unittest.skip("TODO: revamp: Unit.scale is deprecated.")
     def test___repr__(self):
-        self.assertIn(str(self.number.quantity), str(self.number))
-        self.assertIn(str(self.number.unit.scale.value.evaluated), str(self.number))
-        self.assertIn(self.number.unit.shorthand, str(self.number))
+        """Test Number repr contains quantity and unit shorthand."""
+        repr_str = repr(self.number)
+        self.assertIn(str(self.number.quantity), repr_str)
+        self.assertIn(self.number.unit.shorthand, repr_str)
 
     def test___truediv__(self):
         dal = Scale.deca * units.gram
@@ -154,32 +154,32 @@ class TestNumberEdgeCases(unittest.TestCase):
         assert evaluated.unit == units.gram
         assert abs(evaluated.quantity - 6.238) < 1e-12
 
-    @unittest.skip("TODO: revamp: Unit.scale is deprecated.")
     def test_default_number_is_dimensionless_one(self):
+        """Default Number() is dimensionless with quantity=1."""
         n = Number()
         self.assertEqual(n.unit, units.none)
-        self.assertEqual(n.unit.scale, Scale.one)
         self.assertEqual(n.quantity, 1)
         self.assertAlmostEqual(n.value, 1.0)
         self.assertIn("1", repr(n))
 
-    @unittest.skip("Requires ConversionGraph implementation")
-    def test_to_new_scale_changes_value(self):
-        thousand = UnitFactor(dimension=Dimension.none, name='', scale=Scale.kilo)
-        n = Number(quantity=1000, unit=thousand)
-        converted = n.to(Scale.one)
-        self.assertNotEqual(n.value, converted.value)
-        self.assertAlmostEqual(converted.value, 1000)
+    def test_to_different_scale_changes_quantity(self):
+        """Converting to a different scale changes the quantity."""
+        km = Scale.kilo * units.meter
+        n = Number(quantity=5, unit=km)  # 5 km
+        converted = n.to(units.meter)    # convert to meters
+        # quantity changes: 5 km = 5000 m
+        self.assertNotEqual(n.quantity, converted.quantity)
+        self.assertAlmostEqual(converted.quantity, 5000.0, places=10)
 
-    @unittest.skip("TODO: revamp: Unit.scale is deprecated.")
-    @unittest.skip("Requires ConversionGraph implementation")
     def test_simplify_uses_value_as_quantity(self):
-        thousand = UnitFactor(dimension=Dimension.none, name='', scale=Scale.kilo)
-        n = Number(quantity=2, unit=thousand)
+        """Simplify converts scaled quantity to base scale quantity."""
+        km = Scale.kilo * units.meter
+        n = Number(quantity=2, unit=km)  # 2 km
         simplified = n.simplify()
-        self.assertEqual(simplified.quantity, n.value)
-        self.assertNotEqual(simplified.unit.scale, n.unit.scale)
-        self.assertEqual(simplified.value, n.value)
+        # simplified.quantity should be the canonical magnitude (2 * 1000 = 2000)
+        self.assertAlmostEqual(simplified.quantity, 2000.0, places=10)
+        # canonical magnitude (physical quantity) is preserved
+        self.assertAlmostEqual(simplified._canonical_magnitude, n._canonical_magnitude, places=10)
 
     def test_multiplication_combines_units_and_quantities(self):
         n1 = Number(unit=units.joule, quantity=2)
@@ -188,14 +188,13 @@ class TestNumberEdgeCases(unittest.TestCase):
         self.assertEqual(result.quantity, 6)
         self.assertEqual(result.unit.dimension, Dimension.energy * Dimension.time)
 
-    @unittest.skip("TODO: revamp: Unit.scale is deprecated.")
-    @unittest.skip("Requires ConversionGraph implementation")
     def test_division_combines_units_scales_and_quantities(self):
-        km = UnitFactor('m', name='meter', dimension=Dimension.length, scale=Scale.kilo)
-        n1 = Number(unit=km, quantity=1000)
+        """Division creates composite unit with preserved scales."""
+        km = Scale.kilo * units.meter
+        n1 = Number(unit=km, quantity=1000)  # 1000 km
         n2 = Number(unit=units.second, quantity=2)
 
-        result = n1 / n2     # should yield <500 km/s>
+        result = n1 / n2  # should yield <500 km/s>
 
         cu = result.unit
         self.assertIsInstance(cu, UnitProduct)
@@ -206,18 +205,13 @@ class TestNumberEdgeCases(unittest.TestCase):
         # --- dimension check ---
         self.assertEqual(cu.dimension, Dimension.velocity)
 
-        # --- scale check: km/s should have a kilo-scaled meter in the numerator ---
-        # find the meter-like unit in the components
-        meter_like = next(u for u, exp in cu.components.items() if u.dimension == Dimension.length)
-        self.assertEqual(meter_like.scale, Scale.kilo)
-        self.assertEqual(cu.components[meter_like], 1)  # exponent = 1 in numerator
-
         # --- symbolic shorthand ---
         self.assertEqual(cu.shorthand, "km/s")
 
-        # --- optional canonicalization ---
-        canonical = result.to(Scale.one)
-        self.assertAlmostEqual(canonical.quantity, 500000)
+        # --- convert to base units (m/s) ---
+        m_per_s = units.meter / units.second
+        canonical = result.to(m_per_s)
+        self.assertAlmostEqual(canonical.quantity, 500000, places=5)
         self.assertEqual(canonical.unit.shorthand, "m/s")
 
     def test_equality_with_non_number_raises_value_error(self):
@@ -232,7 +226,7 @@ class TestNumberEdgeCases(unittest.TestCase):
         self.assertTrue(r == Number())
 
     def test_repr_includes_scale_and_unit(self):
-        kV = Scale.kilo * Unit('V', name='volt', dimension=Dimension.voltage)
+        kV = Scale.kilo * Unit(name='volt', dimension=Dimension.voltage, aliases=('V',))
         n = Number(unit=kV, quantity=5)
         rep = repr(n)
         self.assertIn("kV", rep)
@@ -269,7 +263,7 @@ class TestRatio(unittest.TestCase):
         self.assertEqual(self.one_half * self.three_halves, self.three_fourths)
 
     def test___mul__(self):
-        mL = Scale.milli * Unit('L', name='liter', dimension=Dimension.volume)
+        mL = Scale.milli * Unit(name='liter', dimension=Dimension.volume, aliases=('L',))
         n1 = Number(unit=units.gram, quantity=3.119)
         n2 = Number(unit=mL)
         bromine_density = Ratio(n1, n2)
@@ -289,7 +283,7 @@ class TestRatio(unittest.TestCase):
 
         # How many Wh from 20 kJ?
         twenty_kilojoules = Number(
-            unit=Scale.kilo * Unit('J', name='joule', dimension=Dimension.energy),
+            unit=Scale.kilo * Unit(name='joule', dimension=Dimension.energy, aliases=('J',)),
             quantity=20
         )
         ratio = twenty_kilojoules.as_ratio() / seconds_per_hour
@@ -368,3 +362,194 @@ class TestRatioEdgeCases(unittest.TestCase):
         r = Ratio(n1, n2)
         rep = repr(r)
         self.assertIn("/", rep)
+
+
+class TestCallableUnits(unittest.TestCase):
+    """Tests for the callable unit syntax: unit(quantity) -> Number."""
+
+    def test_unit_callable_returns_number(self):
+        result = units.meter(5)
+        self.assertIsInstance(result, Number)
+        self.assertEqual(result.quantity, 5)
+
+    def test_unit_callable_shorthand(self):
+        result = units.meter(5)
+        self.assertIn("m", result.unit.shorthand)
+
+    def test_unit_product_callable_returns_number(self):
+        velocity = units.meter / units.second
+        result = velocity(10)
+        self.assertIsInstance(result, Number)
+        self.assertEqual(result.quantity, 10)
+        self.assertEqual(result.unit.dimension, Dimension.velocity)
+
+    def test_scaled_unit_callable_returns_number(self):
+        km = Scale.kilo * units.meter
+        result = km(5)
+        self.assertIsInstance(result, Number)
+        self.assertEqual(result.quantity, 5)
+        self.assertIn("km", result.unit.shorthand)
+
+    def test_composite_scaled_unit_callable(self):
+        mph = units.mile / units.hour
+        result = mph(60)
+        self.assertIsInstance(result, Number)
+        self.assertEqual(result.quantity, 60)
+
+
+class TestScaledUnitConversion(unittest.TestCase):
+    """Tests for conversions involving scaled units.
+
+    Regression tests for bug where scale was applied twice during conversion.
+    """
+
+    def test_km_to_mile_conversion(self):
+        """5 km should be approximately 3.10686 miles."""
+        km = Scale.kilo * units.meter
+        result = km(5).to(units.mile)
+        # 5 km = 5000 m = 5000 / 1609.34 miles ≈ 3.10686
+        self.assertAlmostEqual(result.quantity, 3.10686, places=4)
+
+    def test_km_to_meter_conversion(self):
+        """1 km should be 1000 meters."""
+        km = Scale.kilo * units.meter
+        result = km(1).to(units.meter)
+        self.assertAlmostEqual(result.quantity, 1000.0, places=6)
+
+    def test_meter_to_mm_conversion(self):
+        """1 meter should be 1000 millimeters."""
+        mm = Scale.milli * units.meter
+        result = units.meter(1).to(mm)
+        self.assertAlmostEqual(result.quantity, 1000.0, places=6)
+
+    def test_mm_to_inch_conversion(self):
+        """25.4 mm should be approximately 1 inch."""
+        mm = Scale.milli * units.meter
+        result = mm(25.4).to(units.inch)
+        self.assertAlmostEqual(result.quantity, 1.0, places=4)
+
+    def test_scaled_velocity_conversion(self):
+        """1 km/h should be approximately 0.27778 m/s."""
+        km_per_h = (Scale.kilo * units.meter) / units.hour
+        m_per_s = units.meter / units.second
+        result = km_per_h(1).to(m_per_s)
+        # 1 km/h = 1000m / 3600s = 0.27778 m/s
+        self.assertAlmostEqual(result.quantity, 0.27778, places=4)
+
+    def test_mph_to_m_per_s_conversion(self):
+        """60 mph should be approximately 26.8224 m/s."""
+        mph = units.mile / units.hour
+        m_per_s = units.meter / units.second
+        result = mph(60).to(m_per_s)
+        # 60 mph = 60 * 1609.34 / 3600 m/s ≈ 26.8224
+        self.assertAlmostEqual(result.quantity, 26.8224, places=2)
+
+
+class TestNumberSimplify(unittest.TestCase):
+    """Tests for Number.simplify() method."""
+
+    def test_simplify_kilo_prefix(self):
+        """5 km simplifies to 5000 m."""
+        km = Scale.kilo * units.meter
+        result = km(5).simplify()
+        self.assertAlmostEqual(result.quantity, 5000.0, places=10)
+        self.assertEqual(result.unit.shorthand, "m")
+
+    def test_simplify_milli_prefix(self):
+        """500 mg simplifies to 0.5 g."""
+        mg = Scale.milli * units.gram
+        result = mg(500).simplify()
+        self.assertAlmostEqual(result.quantity, 0.5, places=10)
+        self.assertEqual(result.unit.shorthand, "g")
+
+    def test_simplify_binary_prefix(self):
+        """2 kibibytes simplifies to 2048 bytes."""
+        kibibyte = Scale.kibi * units.byte
+        result = kibibyte(2).simplify()
+        self.assertAlmostEqual(result.quantity, 2048.0, places=10)
+        self.assertEqual(result.unit.shorthand, "B")
+
+    def test_simplify_composite_unit(self):
+        """1 km/h simplifies to base scales."""
+        km_per_h = (Scale.kilo * units.meter) / units.hour
+        result = km_per_h(1).simplify()
+        # 1 km/h = 1000 m / 1 h (hour stays hour since it's base unit)
+        self.assertAlmostEqual(result.quantity, 1000.0, places=10)
+        self.assertEqual(result.unit.shorthand, "m/h")
+
+    def test_simplify_plain_unit_unchanged(self):
+        """Plain unit without scale returns equivalent Number."""
+        result = units.meter(5).simplify()
+        self.assertAlmostEqual(result.quantity, 5.0, places=10)
+        self.assertEqual(result.unit.shorthand, "m")
+
+    def test_simplify_preserves_dimension(self):
+        """Simplified Number has same dimension."""
+        km = Scale.kilo * units.meter
+        original = km(5)
+        simplified = original.simplify()
+        self.assertEqual(original.unit.dimension, simplified.unit.dimension)
+
+    def test_simplify_idempotent(self):
+        """Simplifying twice gives same result."""
+        km = Scale.kilo * units.meter
+        result1 = km(5).simplify()
+        result2 = result1.simplify()
+        self.assertAlmostEqual(result1.quantity, result2.quantity, places=10)
+        self.assertEqual(result1.unit.shorthand, result2.unit.shorthand)
+
+
+class TestInformationDimension(unittest.TestCase):
+    """Tests for Dimension.information and information units (bit, byte)."""
+
+    def test_dimension_information_exists(self):
+        """Dimension.information should be a valid dimension."""
+        self.assertEqual(Dimension.information.name, 'information')
+        self.assertNotEqual(Dimension.information, Dimension.none)
+
+    def test_bit_unit_exists(self):
+        """units.bit should have Dimension.information."""
+        self.assertEqual(units.bit.dimension, Dimension.information)
+        self.assertIn('b', units.bit.aliases)
+
+    def test_byte_unit_exists(self):
+        """units.byte should have Dimension.information."""
+        self.assertEqual(units.byte.dimension, Dimension.information)
+        self.assertIn('B', units.byte.aliases)
+
+    def test_byte_to_bit_conversion(self):
+        """1 byte should be 8 bits."""
+        result = units.byte(1).to(units.bit)
+        self.assertAlmostEqual(result.quantity, 8.0, places=10)
+
+    def test_bit_to_byte_conversion(self):
+        """8 bits should be 1 byte."""
+        result = units.bit(8).to(units.byte)
+        self.assertAlmostEqual(result.quantity, 1.0, places=10)
+
+    def test_kibibyte_simplify(self):
+        """1 kibibyte simplifies to 1024 bytes."""
+        kibibyte = Scale.kibi * units.byte
+        result = kibibyte(1).simplify()
+        self.assertAlmostEqual(result.quantity, 1024.0, places=10)
+        self.assertEqual(result.unit.shorthand, "B")
+
+    def test_kilobyte_simplify(self):
+        """1 kilobyte simplifies to 1000 bytes."""
+        kilobyte = Scale.kilo * units.byte
+        result = kilobyte(1).simplify()
+        self.assertAlmostEqual(result.quantity, 1000.0, places=10)
+        self.assertEqual(result.unit.shorthand, "B")
+
+    def test_data_rate_dimension(self):
+        """bytes/second should have information/time dimension."""
+        data_rate = units.byte / units.second
+        expected_dim = Dimension.information / Dimension.time
+        self.assertEqual(data_rate.dimension, expected_dim)
+
+    def test_information_orthogonal_to_physical(self):
+        """Information dimension should be orthogonal to physical dimensions."""
+        # byte * meter should have both information and length
+        composite = units.byte * units.meter
+        self.assertNotEqual(composite.dimension, Dimension.information)
+        self.assertNotEqual(composite.dimension, Dimension.length)

ucon/__init__.py

@@ -38,8 +38,8 @@ Design Philosophy
 """
 from ucon import units
 from ucon.algebra import Exponent
-from ucon.core import Dimension, Scale, Unit
-from ucon.quantity import Number, Ratio
+from ucon.core import Dimension, Scale, Unit, UnitFactor, UnitProduct, Number, Ratio
+from ucon.graph import get_default_graph, using_graph
 
 
 __all__ = [
@@ -49,5 +49,9 @@ __all__ = [
     'Ratio',
     'Scale',
     'Unit',
+    'UnitFactor',
+    'UnitProduct',
+    'get_default_graph',
+    'using_graph',
     'units',
 ]

ucon/algebra.py

@@ -34,18 +34,20 @@ class Vector:
     """
     Represents the **exponent vector** of a physical quantity.
 
-    Each component corresponds to the power of a base dimension in the SI system:
+    Each component corresponds to the power of a base dimension in the SI system
+    plus information (B) as an orthogonal non-SI dimension:
     time (T), length (L), mass (M), current (I), temperature (Θ),
-    luminous intensity (J), and amount of substance (N).
+    luminous intensity (J), amount of substance (N), and information (B).
 
     Arithmetic operations correspond to dimensional composition:
     - Addition (`+`) → multiplication of quantities
     - Subtraction (`-`) → division of quantities
 
     e.g.
-    Vector(T=1, L=0, M=0, I=0, Θ=0, J=0, N=0)   => "time"
-    Vector(T=0, L=2, M=0, I=0, Θ=0, J=0, N=0)   => "area"
-    Vector(T=-2, L=1, M=1, I=0, Θ=0, J=0, N=0)  => "force"
+    Vector(T=1, L=0, M=0, I=0, Θ=0, J=0, N=0, B=0)   => "time"
+    Vector(T=0, L=2, M=0, I=0, Θ=0, J=0, N=0, B=0)   => "area"
+    Vector(T=-2, L=1, M=1, I=0, Θ=0, J=0, N=0, B=0)  => "force"
+    Vector(T=0, L=0, M=0, I=0, Θ=0, J=0, N=0, B=1)   => "information"
     """
     T: int = 0  # time
     L: int = 0  # length
@@ -54,6 +56,7 @@ class Vector:
     Θ: int = 0  # temperature
     J: int = 0  # luminous intensity
     N: int = 0  # amount of substance
+    B: int = 0  # information (bits)
 
     def __iter__(self) -> Iterator[int]:
         yield self.T
@@ -63,6 +66,7 @@ class Vector:
         yield self.Θ
         yield self.J
         yield self.N
+        yield self.B
 
     def __len__(self) -> int:
         return sum(tuple(1 for x in self))