ucon 0.4.1__tar.gz → 0.4.2__tar.gz

{ucon-0.4.1 → ucon-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ucon
-Version: 0.4.1
+Version: 0.4.2
 Summary: a tool for dimensional analysis: a "Unit CONverter"
 Home-page: https://github.com/withtwoemms/ucon
 Author: Emmanuel I. Obi

{ucon-0.4.1 → ucon-0.4.2}/tests/ucon/test_quantity.py

@@ -364,6 +364,66 @@ class TestRatioEdgeCases(unittest.TestCase):
         self.assertIn("/", rep)
 
 
+class TestRatioExponentScaling(unittest.TestCase):
+    """Tests for Ratio.evaluate() using Exponent-based scaling.
+
+    Ensures Ratio.evaluate() behaves consistently with Number.__truediv__
+    when units cancel to dimensionless results.
+    """
+
+    def test_evaluate_dimensionless_with_different_scales(self):
+        """Ratio of same unit with different scales should fold scales."""
+        kg = Scale.kilo * units.gram
+        # 500 g / 1 kg = 0.5 (dimensionless)
+        ratio = Ratio(units.gram(500), kg(1))
+        result = ratio.evaluate()
+        self.assertAlmostEqual(result.quantity, 0.5, places=10)
+        self.assertEqual(result.unit.dimension, Dimension.none)
+
+    def test_evaluate_matches_number_truediv(self):
+        """Ratio.evaluate() should match Number.__truediv__ for dimensionless."""
+        kg = Scale.kilo * units.gram
+        num = units.gram(500)
+        den = kg(1)
+
+        ratio_result = Ratio(num, den).evaluate()
+        truediv_result = num / den
+
+        self.assertAlmostEqual(ratio_result.quantity, truediv_result.quantity, places=10)
+        self.assertEqual(ratio_result.unit.dimension, truediv_result.unit.dimension)
+
+    def test_evaluate_cross_base_scaling(self):
+        """Binary and decimal prefixes should combine correctly."""
+        kibigram = Scale.kibi * units.gram  # 1024 g
+        kg = Scale.kilo * units.gram         # 1000 g
+        # 1 kibigram / 1 kg = 1024/1000 = 1.024
+        ratio = Ratio(kibigram(1), kg(1))
+        result = ratio.evaluate()
+        self.assertAlmostEqual(result.quantity, 1.024, places=10)
+        self.assertEqual(result.unit.dimension, Dimension.none)
+
+    def test_evaluate_dimensionful_preserves_scales(self):
+        """Non-cancelling units should preserve symbolic scales."""
+        km = Scale.kilo * units.meter
+        # 100 km / 2 h = 50 km/h (scales preserved, not folded)
+        ratio = Ratio(km(100), units.hour(2))
+        result = ratio.evaluate()
+        self.assertAlmostEqual(result.quantity, 50.0, places=10)
+        self.assertEqual(result.unit.dimension, Dimension.velocity)
+        self.assertIn("km", result.unit.shorthand)
+
+    def test_evaluate_complex_composition(self):
+        """Composed ratios should maintain scale semantics."""
+        mL = Scale.milli * units.liter
+        # Density: 3.119 g/mL
+        density = Ratio(units.gram(3.119), mL(1))
+        # Volume: 2 mL
+        volume = Ratio(mL(2), Number())
+        # Mass = density * volume
+        result = (density * volume).evaluate()
+        self.assertAlmostEqual(result.quantity, 6.238, places=3)
+
+
 class TestCallableUnits(unittest.TestCase):
     """Tests for the callable unit syntax: unit(quantity) -> Number."""
 

{ucon-0.4.1 → ucon-0.4.2}/ucon/core.py

@@ -1091,13 +1091,27 @@ class Ratio:
         return Ratio(numerator=self.denominator, denominator=self.numerator)
 
     def evaluate(self) -> "Number":
-        # Pure arithmetic, no scale normalization.
-        numeric = self.numerator.quantity / self.denominator.quantity
+        """Evaluate the ratio to a Number.
+
+        Uses Exponent-derived arithmetic for scale handling:
+        - If the result is dimensionless (units cancel), scales are folded
+          into the magnitude using _canonical_magnitude.
+        - If the result is dimensionful, raw quantities are divided and
+          unit scales are preserved symbolically.
 
-        # Pure unit division, with UnitFactor preservation.
+        This matches the behavior of Number.__truediv__ for consistency.
+        """
+        # Symbolic quotient in the unit algebra
         unit = self.numerator.unit / self.denominator.unit
 
-        # DO NOT normalize, DO NOT fold scale.
+        # Dimensionless result: fold all scale factors into magnitude
+        if not unit.dimension:
+            num = self.numerator._canonical_magnitude
+            den = self.denominator._canonical_magnitude
+            return Number(quantity=num / den, unit=_none)
+
+        # Dimensionful result: preserve user's chosen scales symbolically
+        numeric = self.numerator.quantity / self.denominator.quantity
         return Number(quantity=numeric, unit=unit)
 
     def __mul__(self, another_ratio: 'Ratio') -> 'Ratio':

{ucon-0.4.1 → ucon-0.4.2}/ucon.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ucon
-Version: 0.4.1
+Version: 0.4.2
 Summary: a tool for dimensional analysis: a "Unit CONverter"
 Home-page: https://github.com/withtwoemms/ucon
 Author: Emmanuel I. Obi