ucon 0.4.0__py3-none-any.whl → 0.4.1__py3-none-any.whl

tests/ucon/conversion/test_graph.py

@@ -11,6 +11,10 @@ from ucon.graph import (
     DimensionMismatch,
     ConversionNotFound,
     CyclicInconsistency,
+    get_default_graph,
+    set_default_graph,
+    reset_default_graph,
+    using_graph,
 )
 from ucon.maps import LinearMap, AffineMap
 
@@ -173,3 +177,233 @@ class TestConversionGraphTemperature(unittest.TestCase):
         m = self.graph.convert(src=self.celsius, dst=self.fahrenheit)
         self.assertAlmostEqual(m(0), 32, places=0)
         self.assertAlmostEqual(m(100), 212, places=0)
+
+
+class TestConversionGraphProductEdgeManagement(unittest.TestCase):
+    """Tests for UnitProduct edge management."""
+
+    def setUp(self):
+        self.graph = ConversionGraph()
+        self.meter = units.meter
+        self.second = units.second
+        self.gram = units.gram
+
+    def test_add_product_edge(self):
+        """Test adding edge between two UnitProducts with different scales."""
+        # Create two energy-like products with different scales
+        energy_g = UnitProduct({
+            UnitFactor(self.gram, Scale.one): 1,
+            UnitFactor(self.meter, Scale.one): 2,
+            UnitFactor(self.second, Scale.one): -2,
+        })
+        energy_kg = UnitProduct({
+            UnitFactor(self.gram, Scale.kilo): 1,
+            UnitFactor(self.meter, Scale.one): 2,
+            UnitFactor(self.second, Scale.one): -2,
+        })
+        # Register direct edge: 1 g·m²/s² = 0.001 kg·m²/s²
+        self.graph.add_edge(src=energy_g, dst=energy_kg, map=LinearMap(0.001))
+        m = self.graph.convert(src=energy_g, dst=energy_kg)
+        self.assertAlmostEqual(m(1), 0.001, places=6)
+
+    def test_add_mixed_unit_and_product_edge(self):
+        """Test adding edge with Unit on one side, UnitProduct on other."""
+        m_prod = UnitProduct({UnitFactor(self.meter, Scale.one): 1})
+        self.graph.add_edge(src=self.meter, dst=m_prod, map=LinearMap(1.0))
+        m = self.graph.convert(src=self.meter, dst=m_prod)
+        self.assertTrue(m.is_identity())
+
+    def test_product_edge_dimension_mismatch(self):
+        """Test that dimension mismatch raises for UnitProduct edges."""
+        length_prod = UnitProduct({UnitFactor(self.meter, Scale.one): 1})
+        time_prod = UnitProduct({UnitFactor(self.second, Scale.one): 1})
+        with self.assertRaises(DimensionMismatch):
+            self.graph.add_edge(src=length_prod, dst=time_prod, map=LinearMap(1))
+
+    def test_product_edge_cyclic_consistency(self):
+        """Test cyclic consistency check for UnitProduct edges."""
+        energy1 = UnitProduct({
+            UnitFactor(self.gram, Scale.one): 1,
+            UnitFactor(self.meter, Scale.one): 2,
+            UnitFactor(self.second, Scale.one): -2,
+        })
+        energy2 = UnitProduct({
+            UnitFactor(self.gram, Scale.kilo): 1,
+            UnitFactor(self.meter, Scale.one): 2,
+            UnitFactor(self.second, Scale.one): -2,
+        })
+        self.graph.add_edge(src=energy1, dst=energy2, map=LinearMap(0.001))
+        # Adding inconsistent reverse should raise
+        with self.assertRaises(CyclicInconsistency):
+            self.graph.add_edge(src=energy2, dst=energy1, map=LinearMap(500))  # wrong!
+
+
+class TestConversionGraphFactorwiseEdgeCases(unittest.TestCase):
+    """Tests for factorwise conversion edge cases."""
+
+    def setUp(self):
+        self.graph = ConversionGraph()
+        self.meter = units.meter
+        self.second = units.second
+        self.foot = Unit(name='foot', dimension=Dimension.length, aliases=('ft',))
+
+    def test_factorwise_exponent_mismatch(self):
+        """Test that exponent mismatch raises ConversionNotFound."""
+        # m^2 vs m^1 - different exponents for same dimension
+        m_squared = UnitProduct({UnitFactor(self.meter, Scale.one): 2})
+        m_single = UnitProduct({UnitFactor(self.meter, Scale.one): 1})
+        # These have different dimensions, so dimension check fails first
+        with self.assertRaises(DimensionMismatch):
+            self.graph.convert(src=m_squared, dst=m_single)
+
+    def test_factorwise_misaligned_structures(self):
+        """Test that misaligned factor structures raise ConversionNotFound."""
+        # m/s vs m (missing time dimension in target)
+        m_per_s = UnitProduct({
+            UnitFactor(self.meter, Scale.one): 1,
+            UnitFactor(self.second, Scale.one): -1,
+        })
+        m_only = UnitProduct({UnitFactor(self.meter, Scale.one): 1})
+        with self.assertRaises(DimensionMismatch):
+            self.graph.convert(src=m_per_s, dst=m_only)
+
+    def test_convert_unit_to_product(self):
+        """Test conversion from plain Unit to UnitProduct."""
+        self.graph.add_edge(src=self.meter, dst=self.foot, map=LinearMap(3.28084))
+        m_prod = UnitProduct({UnitFactor(self.meter, Scale.one): 1})
+        ft_prod = UnitProduct({UnitFactor(self.foot, Scale.one): 1})
+        m = self.graph.convert(src=m_prod, dst=ft_prod)
+        self.assertAlmostEqual(m(1), 3.28084, places=4)
+
+    def test_convert_product_dimension_mismatch(self):
+        """Test dimension mismatch in _convert_products."""
+        length = UnitProduct({UnitFactor(self.meter, Scale.one): 1})
+        time = UnitProduct({UnitFactor(self.second, Scale.one): 1})
+        with self.assertRaises(DimensionMismatch):
+            self.graph.convert(src=length, dst=time)
+
+
+class TestConversionGraphBFSEdgeCases(unittest.TestCase):
+    """Tests for BFS path-finding edge cases."""
+
+    def setUp(self):
+        self.graph = ConversionGraph()
+
+    def test_no_edges_for_dimension(self):
+        """Test ConversionNotFound when dimension has no edges at all."""
+        custom_unit1 = Unit(name='custom1', dimension=Dimension.length)
+        custom_unit2 = Unit(name='custom2', dimension=Dimension.length)
+        with self.assertRaises(ConversionNotFound):
+            self.graph.convert(src=custom_unit1, dst=custom_unit2)
+
+    def test_source_has_no_outgoing_edges(self):
+        """Test when source exists in graph but has no path to target."""
+        a = Unit(name='a', dimension=Dimension.length)
+        b = Unit(name='b', dimension=Dimension.length)
+        c = Unit(name='c', dimension=Dimension.length)
+        # Only add a→b, no connection to c
+        self.graph.add_edge(src=a, dst=b, map=LinearMap(2.0))
+        with self.assertRaises(ConversionNotFound):
+            self.graph.convert(src=a, dst=c)
+
+    def test_disconnected_subgraphs(self):
+        """Test when units are in same dimension but disconnected subgraphs."""
+        a = Unit(name='a', dimension=Dimension.length)
+        b = Unit(name='b', dimension=Dimension.length)
+        c = Unit(name='c', dimension=Dimension.length)
+        d = Unit(name='d', dimension=Dimension.length)
+        # Subgraph 1: a ↔ b
+        self.graph.add_edge(src=a, dst=b, map=LinearMap(2.0))
+        # Subgraph 2: c ↔ d
+        self.graph.add_edge(src=c, dst=d, map=LinearMap(3.0))
+        # Cannot convert between subgraphs
+        with self.assertRaises(ConversionNotFound):
+            self.graph.convert(src=a, dst=c)
+
+
+class TestDefaultGraphManagement(unittest.TestCase):
+    """Tests for default graph management functions."""
+
+    def setUp(self):
+        reset_default_graph()
+
+    def tearDown(self):
+        reset_default_graph()
+
+    def test_get_default_graph_returns_graph(self):
+        """Test that get_default_graph returns a ConversionGraph."""
+        graph = get_default_graph()
+        self.assertIsInstance(graph, ConversionGraph)
+
+    def test_get_default_graph_is_cached(self):
+        """Test that get_default_graph returns same instance."""
+        graph1 = get_default_graph()
+        graph2 = get_default_graph()
+        self.assertIs(graph1, graph2)
+
+    def test_set_default_graph(self):
+        """Test that set_default_graph replaces the default."""
+        custom = ConversionGraph()
+        set_default_graph(custom)
+        self.assertIs(get_default_graph(), custom)
+
+    def test_reset_default_graph(self):
+        """Test that reset_default_graph clears the cached graph."""
+        graph1 = get_default_graph()
+        custom = ConversionGraph()
+        set_default_graph(custom)
+        reset_default_graph()
+        graph2 = get_default_graph()
+        self.assertIsNot(graph2, custom)
+        # Should be a fresh standard graph
+        self.assertIsInstance(graph2, ConversionGraph)
+
+    def test_using_graph_context_manager(self):
+        """Test using_graph provides scoped override."""
+        default = get_default_graph()
+        custom = ConversionGraph()
+
+        with using_graph(custom) as g:
+            self.assertIs(g, custom)
+            self.assertIs(get_default_graph(), custom)
+
+        # After context, back to default
+        self.assertIs(get_default_graph(), default)
+
+    def test_using_graph_nested(self):
+        """Test nested using_graph contexts."""
+        default = get_default_graph()
+        custom1 = ConversionGraph()
+        custom2 = ConversionGraph()
+
+        with using_graph(custom1):
+            self.assertIs(get_default_graph(), custom1)
+            with using_graph(custom2):
+                self.assertIs(get_default_graph(), custom2)
+            self.assertIs(get_default_graph(), custom1)
+
+        self.assertIs(get_default_graph(), default)
+
+    def test_using_graph_exception_safety(self):
+        """Test using_graph restores graph even on exception."""
+        default = get_default_graph()
+        custom = ConversionGraph()
+
+        try:
+            with using_graph(custom):
+                self.assertIs(get_default_graph(), custom)
+                raise ValueError("test error")
+        except ValueError:
+            pass
+
+        self.assertIs(get_default_graph(), default)
+
+    def test_default_graph_has_standard_conversions(self):
+        """Test that default graph includes expected conversions."""
+        graph = get_default_graph()
+        # Test a few known conversions
+        m = graph.convert(src=units.meter, dst=units.foot)
+        self.assertAlmostEqual(m(1), 3.28084, places=4)
+
+        m = graph.convert(src=units.kilogram, dst=units.pound)
+        self.assertAlmostEqual(m(1), 2.20462, places=4)

tests/ucon/conversion/test_map.py

@@ -67,6 +67,52 @@ class TestLinearMap(unittest.TestCase):
         result = m.__matmul__(42)
         self.assertIs(result, NotImplemented)
 
+    def test_matmul_with_affine(self):
+        lin = LinearMap(2.0)
+        aff = AffineMap(3.0, 5.0)
+        composed = lin @ aff
+        # lin(aff(x)) = 2 * (3x + 5) = 6x + 10
+        self.assertIsInstance(composed, AffineMap)
+        self.assertAlmostEqual(composed.a, 6.0)
+        self.assertAlmostEqual(composed.b, 10.0)
+        self.assertAlmostEqual(composed(1.0), 16.0)
+
+    def test_pow(self):
+        m = LinearMap(3.0)
+        squared = m ** 2
+        self.assertIsInstance(squared, LinearMap)
+        self.assertAlmostEqual(squared.a, 9.0)
+
+    def test_pow_negative(self):
+        m = LinearMap(4.0)
+        inv = m ** -1
+        self.assertIsInstance(inv, LinearMap)
+        self.assertAlmostEqual(inv.a, 0.25)
+
+    def test_pow_fractional(self):
+        m = LinearMap(4.0)
+        sqrt = m ** 0.5
+        self.assertIsInstance(sqrt, LinearMap)
+        self.assertAlmostEqual(sqrt.a, 2.0)
+
+    def test_is_identity_true(self):
+        m = LinearMap(1.0)
+        self.assertTrue(m.is_identity())
+
+    def test_is_identity_false(self):
+        m = LinearMap(2.0)
+        self.assertFalse(m.is_identity())
+
+    def test_is_identity_near_one(self):
+        m = LinearMap(1.0 + 1e-10)
+        self.assertTrue(m.is_identity())
+
+    def test_hash(self):
+        m1 = LinearMap(3.0)
+        m2 = LinearMap(3.0)
+        self.assertEqual(hash(m1), hash(m2))
+        self.assertEqual(len({m1, m2}), 1)
+
 
 class TestAffineMap(unittest.TestCase):
 
@@ -122,6 +168,57 @@ class TestAffineMap(unittest.TestCase):
         self.assertIn("1.8", r)
         self.assertIn("32.0", r)
 
+    def test_matmul_with_linear(self):
+        aff = AffineMap(2.0, 3.0)
+        lin = LinearMap(4.0)
+        composed = aff @ lin
+        # aff(lin(x)) = 2 * (4x) + 3 = 8x + 3
+        self.assertIsInstance(composed, AffineMap)
+        self.assertAlmostEqual(composed.a, 8.0)
+        self.assertAlmostEqual(composed.b, 3.0)
+        self.assertAlmostEqual(composed(1.0), 11.0)
+
+    def test_matmul_non_map_returns_not_implemented(self):
+        m = AffineMap(1.8, 32.0)
+        result = m.__matmul__("not a map")
+        self.assertIs(result, NotImplemented)
+
+    def test_pow_one(self):
+        m = AffineMap(1.8, 32.0)
+        result = m ** 1
+        self.assertIs(result, m)
+
+    def test_pow_negative_one(self):
+        m = AffineMap(1.8, 32.0)
+        result = m ** -1
+        inv = m.inverse()
+        self.assertEqual(result.a, inv.a)
+        self.assertEqual(result.b, inv.b)
+
+    def test_pow_invalid_raises(self):
+        m = AffineMap(1.8, 32.0)
+        with self.assertRaises(ValueError) as ctx:
+            m ** 2
+        self.assertIn("only supports exp=1 or exp=-1", str(ctx.exception))
+
+    def test_is_identity_true(self):
+        m = AffineMap(1.0, 0.0)
+        self.assertTrue(m.is_identity())
+
+    def test_is_identity_false_due_to_offset(self):
+        m = AffineMap(1.0, 5.0)
+        self.assertFalse(m.is_identity())
+
+    def test_is_identity_false_due_to_scale(self):
+        m = AffineMap(2.0, 0.0)
+        self.assertFalse(m.is_identity())
+
+    def test_hash(self):
+        m1 = AffineMap(1.8, 32.0)
+        m2 = AffineMap(1.8, 32.0)
+        self.assertEqual(hash(m1), hash(m2))
+        self.assertEqual(len({m1, m2}), 1)
+
 
 class TestComposedMap(unittest.TestCase):
 
@@ -155,9 +252,158 @@ class TestComposedMap(unittest.TestCase):
         self.assertIn("LinearMap", r)
         self.assertIn("AffineMap", r)
 
+    def test_matmul(self):
+        c1 = ComposedMap(LinearMap(2.0), AffineMap(3.0, 1.0))
+        c2 = LinearMap(5.0)
+        composed = c1 @ c2
+        self.assertIsInstance(composed, ComposedMap)
+        # c1(c2(x)) = c1(5x) = 2*(3*5x + 1) = 30x + 2
+        self.assertAlmostEqual(composed(1.0), 32.0)
+        self.assertAlmostEqual(composed(0.0), 2.0)
+
+    def test_matmul_non_map_returns_not_implemented(self):
+        composed = ComposedMap(LinearMap(2.0), AffineMap(3.0, 1.0))
+        result = composed.__matmul__(42)
+        self.assertIs(result, NotImplemented)
+
+    def test_pow_one(self):
+        composed = ComposedMap(LinearMap(2.0), AffineMap(3.0, 1.0))
+        result = composed ** 1
+        self.assertIs(result, composed)
+
+    def test_pow_negative_one(self):
+        composed = ComposedMap(LinearMap(2.0), AffineMap(3.0, 1.0))
+        result = composed ** -1
+        # Round-trip should be identity
+        for x in [0.0, 1.0, 5.0]:
+            self.assertAlmostEqual(result(composed(x)), x, places=10)
+
+    def test_pow_invalid_raises(self):
+        composed = ComposedMap(LinearMap(2.0), AffineMap(3.0, 1.0))
+        with self.assertRaises(ValueError) as ctx:
+            composed ** 2
+        self.assertIn("only supports exp=1 or exp=-1", str(ctx.exception))
+
+    def test_invertible_both_non_invertible(self):
+        composed = ComposedMap(LinearMap(0), LinearMap(0))
+        self.assertFalse(composed.invertible)
+
+    def test_invertible_inner_non_invertible(self):
+        composed = ComposedMap(LinearMap(2.0), LinearMap(0))
+        self.assertFalse(composed.invertible)
+
+    def test_is_identity(self):
+        composed = ComposedMap(LinearMap(1.0), LinearMap(1.0))
+        self.assertTrue(composed.is_identity())
+
+    def test_is_identity_false(self):
+        composed = ComposedMap(LinearMap(2.0), LinearMap(0.5))
+        self.assertTrue(composed.is_identity())  # 2 * 0.5 = 1
+
+    def test_is_identity_with_offset(self):
+        composed = ComposedMap(LinearMap(1.0), AffineMap(1.0, 5.0))
+        self.assertFalse(composed.is_identity())
+
 
 class TestMapABC(unittest.TestCase):
 
     def test_cannot_instantiate(self):
         with self.assertRaises(TypeError):
             Map()
+
+
+class TestCrossTypeComposition(unittest.TestCase):
+    """Tests for composition between different Map types."""
+
+    def test_linear_at_affine_at_linear(self):
+        """Chain: LinearMap @ AffineMap @ LinearMap"""
+        l1 = LinearMap(2.0)
+        a = AffineMap(3.0, 1.0)
+        l2 = LinearMap(4.0)
+        # l1 @ a = AffineMap(6, 2)
+        # (l1 @ a) @ l2 = AffineMap(24, 2)
+        composed = l1 @ a @ l2
+        self.assertIsInstance(composed, AffineMap)
+        self.assertAlmostEqual(composed(1.0), 26.0)
+
+    def test_affine_at_linear_at_affine(self):
+        """Chain: AffineMap @ LinearMap @ AffineMap"""
+        a1 = AffineMap(2.0, 1.0)
+        l = LinearMap(3.0)
+        a2 = AffineMap(4.0, 5.0)
+        # l @ a2 = AffineMap(12, 15)
+        # a1 @ (l @ a2) = AffineMap(24, 31)
+        composed = a1 @ l @ a2
+        self.assertIsInstance(composed, AffineMap)
+        self.assertAlmostEqual(composed(1.0), 55.0)
+
+    def test_composed_preserves_semantics(self):
+        """Verify f @ g computes f(g(x)) correctly for all type combinations."""
+        maps = [
+            LinearMap(2.0),
+            LinearMap(0.5),
+            AffineMap(3.0, 1.0),
+            AffineMap(1.0, -5.0),
+        ]
+        for f in maps:
+            for g in maps:
+                composed = f @ g
+                for x in [0.0, 1.0, -2.0, 10.0]:
+                    expected = f(g(x))
+                    actual = composed(x)
+                    self.assertAlmostEqual(actual, expected, places=10,
+                        msg=f"Failed for {type(f).__name__} @ {type(g).__name__} at x={x}")
+
+
+class TestMapEdgeCases(unittest.TestCase):
+    """Edge case tests for Map hierarchy."""
+
+    def test_linear_map_with_negative_scale(self):
+        m = LinearMap(-3.0)
+        self.assertAlmostEqual(m(5.0), -15.0)
+        self.assertAlmostEqual(m.inverse()(m(5.0)), 5.0)
+
+    def test_affine_map_with_negative_scale(self):
+        m = AffineMap(-2.0, 10.0)
+        self.assertAlmostEqual(m(5.0), 0.0)
+        self.assertAlmostEqual(m.inverse()(m(5.0)), 5.0)
+
+    def test_linear_map_very_small_scale(self):
+        m = LinearMap(1e-10)
+        self.assertAlmostEqual(m(1e10), 1.0)
+        self.assertTrue(m.invertible)
+
+    def test_linear_map_very_large_scale(self):
+        m = LinearMap(1e10)
+        self.assertAlmostEqual(m(1e-10), 1.0)
+        self.assertTrue(m.invertible)
+
+    def test_affine_identity(self):
+        """AffineMap(1, 0) should be identity."""
+        m = AffineMap(1.0, 0.0)
+        for x in [0.0, 1.0, -100.0, 1e6]:
+            self.assertAlmostEqual(m(x), x)
+
+    def test_linear_identity(self):
+        """LinearMap(1) should be identity."""
+        m = LinearMap(1.0)
+        for x in [0.0, 1.0, -100.0, 1e6]:
+            self.assertAlmostEqual(m(x), x)
+
+    def test_composed_map_deep_nesting(self):
+        """Test deeply nested ComposedMap."""
+        m = LinearMap(2.0)
+        for _ in range(5):
+            m = ComposedMap(m, LinearMap(1.5))
+        # 2 * 1.5^5 = 2 * 7.59375 = 15.1875
+        self.assertAlmostEqual(m(1.0), 2.0 * (1.5 ** 5))
+
+    def test_inverse_of_inverse(self):
+        """(m.inverse()).inverse() == m"""
+        m = LinearMap(7.0)
+        self.assertEqual(m.inverse().inverse(), m)
+
+        m2 = AffineMap(3.0, 5.0)
+        double_inv = m2.inverse().inverse()
+        self.assertAlmostEqual(double_inv.a, m2.a)
+        self.assertAlmostEqual(double_inv.b, m2.b)

tests/ucon/test_core.py

@@ -332,14 +332,13 @@ class TestScaleMultiplicationAdditional(unittest.TestCase):
         self.assertIsInstance(result, Scale)
         self.assertEqual(result.value.base, 10)
 
-    @unittest.skip("TODO: revamp: Unit.scale is deprecated.")
     def test_scale_multiplication_with_unit(self):
-        meter = UnitFactor('m', name='meter', dimension=Dimension.length)
-        kilometer = Scale.kilo * meter
-        self.assertIsInstance(kilometer, UnitFactor)
-        self.assertEqual(kilometer.scale, Scale.kilo)
+        """Scale * Unit returns a UnitProduct with the scaled unit."""
+        kilometer = Scale.kilo * units.meter
+        self.assertIsInstance(kilometer, UnitProduct)
         self.assertEqual(kilometer.dimension, Dimension.length)
-        self.assertIn('meter', kilometer.name)
+        self.assertEqual(kilometer.shorthand, "km")
+        self.assertAlmostEqual(kilometer.fold_scale(), 1000.0, places=10)
 
     def test_scale_multiplication_with_unit_returns_not_implemented_for_invalid_type(self):
         with self.assertRaises(TypeError):

tests/ucon/test_default_graph_conversions.py

@@ -0,0 +1,443 @@
+# © 2026 The Radiativity Company
+# Licensed under the Apache License, Version 2.0
+# See the LICENSE file for details.
+
+"""
+Tests for the default ConversionGraph with temperature, pressure, and base SI conversions.
+
+These tests verify that Number.to() works correctly with the default graph for:
+- Temperature conversions (Celsius, Kelvin, Fahrenheit) using AffineMap
+- Pressure conversions (Pascal, Bar, PSI, Atmosphere)
+- Base SI conversions (length, mass, time, volume, energy, power, information)
+"""
+
+import unittest
+
+from ucon import units
+from ucon.graph import get_default_graph, reset_default_graph
+
+
+class TestTemperatureConversions(unittest.TestCase):
+    """Tests for temperature conversions using AffineMap in the default graph."""
+
+    def setUp(self):
+        reset_default_graph()
+
+    def test_celsius_to_kelvin_freezing(self):
+        """0°C = 273.15 K"""
+        result = units.celsius(0).to(units.kelvin)
+        self.assertAlmostEqual(result.quantity, 273.15, places=2)
+
+    def test_celsius_to_kelvin_boiling(self):
+        """100°C = 373.15 K"""
+        result = units.celsius(100).to(units.kelvin)
+        self.assertAlmostEqual(result.quantity, 373.15, places=2)
+
+    def test_kelvin_to_celsius_absolute_zero(self):
+        """0 K = -273.15°C"""
+        result = units.kelvin(0).to(units.celsius)
+        self.assertAlmostEqual(result.quantity, -273.15, places=2)
+
+    def test_kelvin_to_celsius_room_temp(self):
+        """293.15 K = 20°C"""
+        result = units.kelvin(293.15).to(units.celsius)
+        self.assertAlmostEqual(result.quantity, 20, places=1)
+
+    def test_fahrenheit_to_celsius_freezing(self):
+        """32°F = 0°C"""
+        result = units.fahrenheit(32).to(units.celsius)
+        self.assertAlmostEqual(result.quantity, 0, places=1)
+
+    def test_fahrenheit_to_celsius_boiling(self):
+        """212°F = 100°C"""
+        result = units.fahrenheit(212).to(units.celsius)
+        self.assertAlmostEqual(result.quantity, 100, places=1)
+
+    def test_celsius_to_fahrenheit_freezing(self):
+        """0°C = 32°F"""
+        result = units.celsius(0).to(units.fahrenheit)
+        self.assertAlmostEqual(result.quantity, 32, places=1)
+
+    def test_celsius_to_fahrenheit_boiling(self):
+        """100°C = 212°F"""
+        result = units.celsius(100).to(units.fahrenheit)
+        self.assertAlmostEqual(result.quantity, 212, places=1)
+
+    def test_fahrenheit_to_kelvin_absolute_zero(self):
+        """-459.67°F = 0 K (approximately)"""
+        result = units.fahrenheit(-459.67).to(units.kelvin)
+        self.assertAlmostEqual(result.quantity, 0, places=0)
+
+    def test_kelvin_to_fahrenheit_boiling(self):
+        """373.15 K = 212°F"""
+        result = units.kelvin(373.15).to(units.fahrenheit)
+        self.assertAlmostEqual(result.quantity, 212, places=0)
+
+    def test_temperature_round_trip_celsius(self):
+        """Round-trip: C → K → C"""
+        original = 25.0
+        via_kelvin = units.celsius(original).to(units.kelvin)
+        back = via_kelvin.to(units.celsius)
+        self.assertAlmostEqual(back.quantity, original, places=10)
+
+    def test_temperature_round_trip_fahrenheit(self):
+        """Round-trip: F → C → F"""
+        original = 98.6  # body temperature
+        via_celsius = units.fahrenheit(original).to(units.celsius)
+        back = via_celsius.to(units.fahrenheit)
+        self.assertAlmostEqual(back.quantity, original, places=10)
+
+
+class TestPressureConversions(unittest.TestCase):
+    """Tests for pressure conversions in the default graph."""
+
+    def setUp(self):
+        reset_default_graph()
+
+    def test_pascal_to_bar(self):
+        """100000 Pa = 1 bar"""
+        result = units.pascal(100000).to(units.bar)
+        self.assertAlmostEqual(result.quantity, 1.0, places=5)
+
+    def test_bar_to_pascal(self):
+        """1 bar = 100000 Pa"""
+        result = units.bar(1).to(units.pascal)
+        self.assertAlmostEqual(result.quantity, 100000, places=0)
+
+    def test_pascal_to_psi(self):
+        """6894.76 Pa ≈ 1 psi"""
+        result = units.pascal(6894.76).to(units.psi)
+        self.assertAlmostEqual(result.quantity, 1.0, places=2)
+
+    def test_psi_to_pascal(self):
+        """1 psi ≈ 6894.76 Pa"""
+        result = units.psi(1).to(units.pascal)
+        self.assertAlmostEqual(result.quantity, 6894.76, places=0)
+
+    def test_atmosphere_to_pascal(self):
+        """1 atm = 101325 Pa"""
+        result = units.atmosphere(1).to(units.pascal)
+        self.assertAlmostEqual(result.quantity, 101325, places=0)
+
+    def test_pascal_to_atmosphere(self):
+        """101325 Pa = 1 atm"""
+        result = units.pascal(101325).to(units.atmosphere)
+        self.assertAlmostEqual(result.quantity, 1.0, places=5)
+
+    def test_atmosphere_to_bar(self):
+        """1 atm ≈ 1.01325 bar"""
+        result = units.atmosphere(1).to(units.bar)
+        self.assertAlmostEqual(result.quantity, 1.01325, places=4)
+
+    def test_bar_to_atmosphere(self):
+        """1 bar ≈ 0.986923 atm"""
+        result = units.bar(1).to(units.atmosphere)
+        self.assertAlmostEqual(result.quantity, 0.986923, places=4)
+
+    def test_atmosphere_to_psi(self):
+        """1 atm ≈ 14.696 psi"""
+        result = units.atmosphere(1).to(units.psi)
+        self.assertAlmostEqual(result.quantity, 14.696, places=2)
+
+    def test_psi_to_atmosphere(self):
+        """14.696 psi ≈ 1 atm"""
+        result = units.psi(14.696).to(units.atmosphere)
+        self.assertAlmostEqual(result.quantity, 1.0, places=2)
+
+    def test_pressure_round_trip(self):
+        """Round-trip: Pa → bar → Pa"""
+        original = 250000
+        via_bar = units.pascal(original).to(units.bar)
+        back = via_bar.to(units.pascal)
+        self.assertAlmostEqual(back.quantity, original, places=5)
+
+
+class TestBaseSILengthConversions(unittest.TestCase):
+    """Tests for length conversions in the default graph."""
+
+    def setUp(self):
+        reset_default_graph()
+
+    def test_meter_to_foot(self):
+        """1 m ≈ 3.28084 ft"""
+        result = units.meter(1).to(units.foot)
+        self.assertAlmostEqual(result.quantity, 3.28084, places=4)
+
+    def test_foot_to_meter(self):
+        """1 ft ≈ 0.3048 m"""
+        result = units.foot(1).to(units.meter)
+        self.assertAlmostEqual(result.quantity, 0.3048, places=4)
+
+    def test_foot_to_inch(self):
+        """1 ft = 12 in"""
+        result = units.foot(1).to(units.inch)
+        self.assertAlmostEqual(result.quantity, 12, places=10)
+
+    def test_inch_to_foot(self):
+        """12 in = 1 ft"""
+        result = units.inch(12).to(units.foot)
+        self.assertAlmostEqual(result.quantity, 1.0, places=10)
+
+    def test_meter_to_inch(self):
+        """1 m ≈ 39.37 in (via foot)"""
+        result = units.meter(1).to(units.inch)
+        self.assertAlmostEqual(result.quantity, 39.37, places=1)
+
+    def test_foot_to_yard(self):
+        """3 ft = 1 yd"""
+        result = units.foot(3).to(units.yard)
+        self.assertAlmostEqual(result.quantity, 1.0, places=10)
+
+    def test_yard_to_foot(self):
+        """1 yd = 3 ft"""
+        result = units.yard(1).to(units.foot)
+        self.assertAlmostEqual(result.quantity, 3.0, places=10)
+
+    def test_mile_to_foot(self):
+        """1 mi = 5280 ft"""
+        result = units.mile(1).to(units.foot)
+        self.assertAlmostEqual(result.quantity, 5280, places=0)
+
+    def test_foot_to_mile(self):
+        """5280 ft = 1 mi"""
+        result = units.foot(5280).to(units.mile)
+        self.assertAlmostEqual(result.quantity, 1.0, places=10)
+
+    def test_meter_to_mile(self):
+        """1609.34 m ≈ 1 mi (multi-hop: m → ft → mi)"""
+        result = units.meter(1609.34).to(units.mile)
+        self.assertAlmostEqual(result.quantity, 1.0, places=2)
+
+    def test_meter_to_yard(self):
+        """1 m ≈ 1.094 yd (multi-hop: m → ft → yd)"""
+        result = units.meter(1).to(units.yard)
+        self.assertAlmostEqual(result.quantity, 1.094, places=2)
+
+
+class TestBaseSIMassConversions(unittest.TestCase):
+    """Tests for mass conversions in the default graph."""
+
+    def setUp(self):
+        reset_default_graph()
+
+    def test_kilogram_to_gram(self):
+        """1 kg = 1000 g"""
+        result = units.kilogram(1).to(units.gram)
+        self.assertAlmostEqual(result.quantity, 1000, places=10)
+
+    def test_gram_to_kilogram(self):
+        """1000 g = 1 kg"""
+        result = units.gram(1000).to(units.kilogram)
+        self.assertAlmostEqual(result.quantity, 1.0, places=10)
+
+    def test_kilogram_to_pound(self):
+        """1 kg ≈ 2.20462 lb"""
+        result = units.kilogram(1).to(units.pound)
+        self.assertAlmostEqual(result.quantity, 2.20462, places=4)
+
+    def test_pound_to_kilogram(self):
+        """1 lb ≈ 0.453592 kg"""
+        result = units.pound(1).to(units.kilogram)
+        self.assertAlmostEqual(result.quantity, 0.453592, places=4)
+
+    def test_pound_to_ounce(self):
+        """1 lb = 16 oz"""
+        result = units.pound(1).to(units.ounce)
+        self.assertAlmostEqual(result.quantity, 16, places=10)
+
+    def test_ounce_to_pound(self):
+        """16 oz = 1 lb"""
+        result = units.ounce(16).to(units.pound)
+        self.assertAlmostEqual(result.quantity, 1.0, places=10)
+
+    def test_gram_to_pound(self):
+        """453.592 g ≈ 1 lb (via kg)"""
+        result = units.gram(453.592).to(units.pound)
+        self.assertAlmostEqual(result.quantity, 1.0, places=2)
+
+    def test_kilogram_to_ounce(self):
+        """1 kg ≈ 35.274 oz (multi-hop: kg → lb → oz)"""
+        result = units.kilogram(1).to(units.ounce)
+        self.assertAlmostEqual(result.quantity, 35.274, places=1)
+
+
+class TestBaseSITimeConversions(unittest.TestCase):
+    """Tests for time conversions in the default graph."""
+
+    def setUp(self):
+        reset_default_graph()
+
+    def test_second_to_minute(self):
+        """60 s = 1 min"""
+        result = units.second(60).to(units.minute)
+        self.assertAlmostEqual(result.quantity, 1.0, places=10)
+
+    def test_minute_to_second(self):
+        """1 min = 60 s"""
+        result = units.minute(1).to(units.second)
+        self.assertAlmostEqual(result.quantity, 60, places=10)
+
+    def test_minute_to_hour(self):
+        """60 min = 1 hr"""
+        result = units.minute(60).to(units.hour)
+        self.assertAlmostEqual(result.quantity, 1.0, places=10)
+
+    def test_hour_to_minute(self):
+        """1 hr = 60 min"""
+        result = units.hour(1).to(units.minute)
+        self.assertAlmostEqual(result.quantity, 60, places=10)
+
+    def test_hour_to_day(self):
+        """24 hr = 1 day"""
+        result = units.hour(24).to(units.day)
+        self.assertAlmostEqual(result.quantity, 1.0, places=10)
+
+    def test_day_to_hour(self):
+        """1 day = 24 hr"""
+        result = units.day(1).to(units.hour)
+        self.assertAlmostEqual(result.quantity, 24, places=10)
+
+    def test_second_to_hour(self):
+        """3600 s = 1 hr (multi-hop: s → min → hr)"""
+        result = units.second(3600).to(units.hour)
+        self.assertAlmostEqual(result.quantity, 1.0, places=10)
+
+    def test_second_to_day(self):
+        """86400 s = 1 day (multi-hop: s → min → hr → day)"""
+        result = units.second(86400).to(units.day)
+        self.assertAlmostEqual(result.quantity, 1.0, places=10)
+
+    def test_day_to_second(self):
+        """1 day = 86400 s"""
+        result = units.day(1).to(units.second)
+        self.assertAlmostEqual(result.quantity, 86400, places=0)
+
+
+class TestBaseSIVolumeConversions(unittest.TestCase):
+    """Tests for volume conversions in the default graph."""
+
+    def setUp(self):
+        reset_default_graph()
+
+    def test_liter_to_gallon(self):
+        """1 L ≈ 0.264172 gal"""
+        result = units.liter(1).to(units.gallon)
+        self.assertAlmostEqual(result.quantity, 0.264172, places=5)
+
+    def test_gallon_to_liter(self):
+        """1 gal ≈ 3.78541 L"""
+        result = units.gallon(1).to(units.liter)
+        self.assertAlmostEqual(result.quantity, 3.78541, places=3)
+
+
+class TestBaseSIEnergyConversions(unittest.TestCase):
+    """Tests for energy conversions in the default graph."""
+
+    def setUp(self):
+        reset_default_graph()
+
+    def test_joule_to_calorie(self):
+        """4.184 J = 1 cal"""
+        result = units.joule(4.184).to(units.calorie)
+        self.assertAlmostEqual(result.quantity, 1.0, places=3)
+
+    def test_calorie_to_joule(self):
+        """1 cal = 4.184 J"""
+        result = units.calorie(1).to(units.joule)
+        self.assertAlmostEqual(result.quantity, 4.184, places=3)
+
+    def test_joule_to_btu(self):
+        """1055.06 J ≈ 1 BTU"""
+        result = units.joule(1055.06).to(units.btu)
+        self.assertAlmostEqual(result.quantity, 1.0, places=2)
+
+    def test_btu_to_joule(self):
+        """1 BTU ≈ 1055.06 J"""
+        result = units.btu(1).to(units.joule)
+        self.assertAlmostEqual(result.quantity, 1055.06, places=0)
+
+    def test_calorie_to_btu(self):
+        """252 cal ≈ 1 BTU (multi-hop via joule)"""
+        result = units.calorie(252).to(units.btu)
+        self.assertAlmostEqual(result.quantity, 1.0, places=1)
+
+
+class TestBaseSIPowerConversions(unittest.TestCase):
+    """Tests for power conversions in the default graph."""
+
+    def setUp(self):
+        reset_default_graph()
+
+    def test_watt_to_horsepower(self):
+        """745.7 W ≈ 1 hp"""
+        result = units.watt(745.7).to(units.horsepower)
+        self.assertAlmostEqual(result.quantity, 1.0, places=2)
+
+    def test_horsepower_to_watt(self):
+        """1 hp ≈ 745.7 W"""
+        result = units.horsepower(1).to(units.watt)
+        self.assertAlmostEqual(result.quantity, 745.7, places=0)
+
+
+class TestInformationConversions(unittest.TestCase):
+    """Tests for information unit conversions in the default graph."""
+
+    def setUp(self):
+        reset_default_graph()
+
+    def test_byte_to_bit(self):
+        """1 B = 8 b"""
+        result = units.byte(1).to(units.bit)
+        self.assertAlmostEqual(result.quantity, 8, places=10)
+
+    def test_bit_to_byte(self):
+        """8 b = 1 B"""
+        result = units.bit(8).to(units.byte)
+        self.assertAlmostEqual(result.quantity, 1.0, places=10)
+
+    def test_kilobyte_to_bit(self):
+        """1 KB = 8000 b (using Scale.kilo)"""
+        from ucon.core import Scale
+        kilobyte = Scale.kilo * units.byte
+        result = kilobyte(1).to(units.bit)
+        self.assertAlmostEqual(result.quantity, 8000, places=0)
+
+
+class TestConversionRoundTrips(unittest.TestCase):
+    """Tests verifying round-trip conversion accuracy."""
+
+    def setUp(self):
+        reset_default_graph()
+
+    def test_length_round_trip(self):
+        """meter → foot → meter"""
+        original = 42.5
+        via_foot = units.meter(original).to(units.foot)
+        back = via_foot.to(units.meter)
+        self.assertAlmostEqual(back.quantity, original, places=8)
+
+    def test_mass_round_trip(self):
+        """kilogram → pound → kilogram"""
+        original = 75.0
+        via_pound = units.kilogram(original).to(units.pound)
+        back = via_pound.to(units.kilogram)
+        self.assertAlmostEqual(back.quantity, original, places=8)
+
+    def test_time_round_trip(self):
+        """second → day → second"""
+        original = 172800  # 2 days
+        via_day = units.second(original).to(units.day)
+        back = via_day.to(units.second)
+        self.assertAlmostEqual(back.quantity, original, places=5)
+
+    def test_pressure_multi_hop_round_trip(self):
+        """pascal → atmosphere → bar → pascal"""
+        original = 500000
+        via_atm = units.pascal(original).to(units.atmosphere)
+        via_bar = via_atm.to(units.bar)
+        back = via_bar.to(units.pascal)
+        self.assertAlmostEqual(back.quantity, original, places=2)
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/ucon/test_quantity.py

@@ -29,25 +29,28 @@ class TestNumber(unittest.TestCase):
         # Unit should be base gram (Scale.one)
         self.assertEqual(result.unit.shorthand, "g")
 
-    @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)
+    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
@@ -151,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)
@@ -185,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)
@@ -203,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):
@@ -465,7 +462,6 @@ class TestNumberSimplify(unittest.TestCase):
         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
@@ -531,7 +527,6 @@ class TestInformationDimension(unittest.TestCase):
         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
@@ -539,7 +534,6 @@ class TestInformationDimension(unittest.TestCase):
         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

ucon/graph.py

@@ -399,6 +399,14 @@ def _build_standard_graph() -> ConversionGraph:
     # F → C: C = (F - 32) * 5/9
     graph.add_edge(src=units.fahrenheit, dst=units.celsius, map=AffineMap(5/9, -32 * 5/9))
 
+    # --- Pressure ---
+    # 1 Pa = 0.00001 bar, so 1 bar = 100000 Pa
+    graph.add_edge(src=units.pascal, dst=units.bar, map=LinearMap(1/100000))
+    # 1 Pa = 0.000145038 psi
+    graph.add_edge(src=units.pascal, dst=units.psi, map=LinearMap(0.000145038))
+    # 1 atm = 101325 Pa
+    graph.add_edge(src=units.atmosphere, dst=units.pascal, map=LinearMap(101325))
+
     # --- Volume ---
     graph.add_edge(src=units.liter, dst=units.gallon, map=LinearMap(0.264172))
 

ucon/units.py

@@ -99,6 +99,11 @@ btu = Unit(name='btu', dimension=Dimension.energy, aliases=('BTU',))
 
 # Power
 horsepower = Unit(name='horsepower', dimension=Dimension.power, aliases=('hp',))
+
+# Pressure
+bar = Unit(name='bar', dimension=Dimension.pressure, aliases=('bar',))
+psi = Unit(name='psi', dimension=Dimension.pressure, aliases=('lbf/in²',))
+atmosphere = Unit(name='atmosphere', dimension=Dimension.pressure, aliases=('atm',))
 # ----------------------------------------------------------------------
 
 

{ucon-0.4.0.dist-info → ucon-0.4.1.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: ucon
-Version: 0.4.0
+Version: 0.4.1
 Summary: a tool for dimensional analysis: a "Unit CONverter"
 Home-page: https://github.com/withtwoemms/ucon
 Author: Emmanuel I. Obi
 Maintainer: Emmanuel I. Obi
 Maintainer-email: withtwoemms@gmail.com
 License: Apache-2.0
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Education
 Classifier: Intended Audience :: Science/Research

ucon-0.4.1.dist-info/RECORD

@@ -0,0 +1,22 @@
+tests/ucon/__init__.py,sha256=9BAHYTs27Ed3VgqiMUH4XtVttAmOPgK0Zvj-dUNo7D8,119
+tests/ucon/test_algebra.py,sha256=Esm38M1QBNsV7vdfoFgqRUluyvWX7yccB0RwZXk4DpA,8433
+tests/ucon/test_core.py,sha256=bmwSRWPlhwossy5NJ9rcPWujFmzBBPOeZzPAzN1acFg,32631
+tests/ucon/test_default_graph_conversions.py,sha256=rkcDcSV1_kZeuPf4ModHDpgfkOPZS32xcKq7KPDRN-0,15760
+tests/ucon/test_quantity.py,sha256=7rFg4cpdmGV7vyCwg72Bt4EFBgkyM3cPFoRbRn0bqEI,21943
+tests/ucon/test_units.py,sha256=SILymDtDNDyxEhkYQubrfkakKCMexwEwjyHfhrkDrMI,869
+tests/ucon/conversion/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/ucon/conversion/test_graph.py,sha256=fs0aP6qNf8eE1uI7SoGSCW2XAkHYb7T9aaI-kzmO02c,16955
+tests/ucon/conversion/test_map.py,sha256=DVFQ3xwp16Nuy9EtZRjKlWbkXfRUcM1mOzFrS4HhOaw,13886
+ucon/__init__.py,sha256=jaFcNFZC5gxHKzM8OkS1pLxltp6ToLRVpuuhJQY9FKQ,2000
+ucon/algebra.py,sha256=wGl4jJVMd8SXQ4sYDBOxV00ymAzRWfDhea1o4t2kVp4,7482
+ucon/core.py,sha256=o3Q4posUOYoIhQVHl6bANCIcGKgGOpNZsnqGZw9ujYk,41523
+ucon/graph.py,sha256=EH0Zi4yj8SI6o27V4uo4muucaqV5nCoL6S3syb-IfXc,14587
+ucon/maps.py,sha256=yyZ7RqnohO2joTUvvKh40in7E6SKMQIQ8jkECO0-_NA,4753
+ucon/quantity.py,sha256=GBxZ_96nocx-8F-usNWGbPvWHRhRgdZzqfH9Sx69iC4,465
+ucon/units.py,sha256=2hisCuB_kTDcNlG6tzze2ZNVpmsnEeEFGWhfbrbomzk,6096
+ucon-0.4.1.dist-info/licenses/LICENSE,sha256=LtimSYBSw1L_X6n1-VEdZRdwuROzPumrMUNX21asFuI,11356
+ucon-0.4.1.dist-info/licenses/NOTICE,sha256=bh4fBOItio3kM4hSNYhqfFpcaAvOoixjD7Du8im-sYA,1079
+ucon-0.4.1.dist-info/METADATA,sha256=bHAexnROmQ4BUaxkY83fLe6ptkCGwt7aVEckFrflg3U,12348
+ucon-0.4.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+ucon-0.4.1.dist-info/top_level.txt,sha256=zZYRJiQrVUtN32ziJD2YEq7ClSvDmVYHYy5ArRAZGxI,11
+ucon-0.4.1.dist-info/RECORD,,

ucon-0.4.0.dist-info/RECORD

@@ -1,21 +0,0 @@
-tests/ucon/__init__.py,sha256=9BAHYTs27Ed3VgqiMUH4XtVttAmOPgK0Zvj-dUNo7D8,119
-tests/ucon/test_algebra.py,sha256=Esm38M1QBNsV7vdfoFgqRUluyvWX7yccB0RwZXk4DpA,8433
-tests/ucon/test_core.py,sha256=NqmyKMkrF3T4ekucsFzVsxbkErdB6assbkhBAYH2fug,32664
-tests/ucon/test_quantity.py,sha256=qJ-dXOPgIp0SKelASu45IC6KquTjlcRwHVkSKicsrXw,22754
-tests/ucon/test_units.py,sha256=SILymDtDNDyxEhkYQubrfkakKCMexwEwjyHfhrkDrMI,869
-tests/ucon/conversion/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/ucon/conversion/test_graph.py,sha256=R3u-0FCpgffoUXvJmT7aBJCUDUpzmBYROh5I0WLHA_Y,7256
-tests/ucon/conversion/test_map.py,sha256=2_bxXCuga-lTGxU5rGferiziJmjzrltksA-6JJseEQ0,5359
-ucon/__init__.py,sha256=jaFcNFZC5gxHKzM8OkS1pLxltp6ToLRVpuuhJQY9FKQ,2000
-ucon/algebra.py,sha256=wGl4jJVMd8SXQ4sYDBOxV00ymAzRWfDhea1o4t2kVp4,7482
-ucon/core.py,sha256=o3Q4posUOYoIhQVHl6bANCIcGKgGOpNZsnqGZw9ujYk,41523
-ucon/graph.py,sha256=lgueyVdBI73pgqsydwRtOY9sxt02G-gy8-Lf7993RNw,14224
-ucon/maps.py,sha256=yyZ7RqnohO2joTUvvKh40in7E6SKMQIQ8jkECO0-_NA,4753
-ucon/quantity.py,sha256=GBxZ_96nocx-8F-usNWGbPvWHRhRgdZzqfH9Sx69iC4,465
-ucon/units.py,sha256=PJFAqUoEq_0--Zo7JDHezZBPHPbAlS_5eArIVCLemxA,5852
-ucon-0.4.0.dist-info/licenses/LICENSE,sha256=LtimSYBSw1L_X6n1-VEdZRdwuROzPumrMUNX21asFuI,11356
-ucon-0.4.0.dist-info/licenses/NOTICE,sha256=bh4fBOItio3kM4hSNYhqfFpcaAvOoixjD7Du8im-sYA,1079
-ucon-0.4.0.dist-info/METADATA,sha256=_hZdjrgY1lvorBac-JPQQVzNVuNet-QY2zPP0G8-hik,12349
-ucon-0.4.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-ucon-0.4.0.dist-info/top_level.txt,sha256=zZYRJiQrVUtN32ziJD2YEq7ClSvDmVYHYy5ArRAZGxI,11
-ucon-0.4.0.dist-info/RECORD,,