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

tests/ucon/test_quantity.py

@@ -19,18 +19,15 @@ 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())
+        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")
 
     @unittest.skip("Requires ConversionGraph implementation")
     def test_to(self):
@@ -232,7 +229,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 +266,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 +286,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 +365,197 @@ 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")
+
+    @unittest.skip("Requires Dimension.information and units.byte (see user story)")
+    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)
+
+    @unittest.skip("Requires Number.simplify() from ucon#93-numbers-can-be-simplified")
+    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")
+
+    @unittest.skip("Requires Number.simplify() from ucon#93-numbers-can-be-simplified")
+    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))