ucon 0.6.0__tar.gz → 0.6.2__tar.gz

{ucon-0.6.0 → ucon-0.6.2}/.github/workflows/publish.yaml

@@ -33,8 +33,8 @@ jobs:
         with:
           user: __token__
           password: ${{ secrets.test_pypi_password }}
-          skip_existing: true
-          repository_url: https://test.pypi.org/legacy/
+          skip-existing: true
+          repository-url: https://test.pypi.org/legacy/
 
       - name: Verify tag is on mainline
         if: startsWith(github.ref, 'refs/tags/')
@@ -53,8 +53,8 @@ jobs:
         with:
           user: __token__
           password: ${{ secrets.test_pypi_password }}
-          skip_existing: true
-          repository_url: https://test.pypi.org/legacy/
+          skip-existing: true
+          repository-url: https://test.pypi.org/legacy/
 
       - name: 🚀 Publish to Prod PyPI
         if: startsWith(github.ref, 'refs/tags/')
@@ -62,4 +62,4 @@ jobs:
         with:
           user: __token__
           password: ${{ secrets.pypi_password }}
-          skip_existing: true
+          skip-existing: true

{ucon-0.6.0 → ucon-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ucon
-Version: 0.6.0
+Version: 0.6.2
 Summary: A tool for dimensional analysis: a 'Unit CONverter'
 Home-page: https://github.com/withtwoemms/ucon
 Author: Emmanuel I. Obi
@@ -94,7 +94,7 @@ To best answer this question, we turn to an age-old technique ([dimensional anal
 | **`UnitProduct`**             | `ucon.core`                             | A product/quotient of `UnitFactor`s with exponent tracking and simplification.                      | Representing composite units like m/s, kg·m/s², kJ·h.                                                                 |
 | **`Number`**                  | `ucon.core`                             | Combines a numeric quantity with a unit; the primary measurable type.                               | Performing arithmetic with units; representing physical quantities like 5 m/s.                                         |
 | **`Ratio`**                   | `ucon.core`                             | Represents the division of two `Number` objects; captures relationships between quantities.         | Expressing rates, densities, efficiencies (e.g., energy / time = power, length / time = velocity).                     |
-| **`Map`** hierarchy           | `ucon.maps`                             | Composable conversion morphisms: `LinearMap`, `AffineMap`, `ComposedMap`.                           | Defining conversion functions between units (e.g., meter→foot, celsius→kelvin).                                        |
+| **`Map`** hierarchy           | `ucon.maps`                             | Composable conversion morphisms: `LinearMap`, `AffineMap`, `LogMap`, `ExpMap`, `ComposedMap`.       | Defining conversion functions between units (e.g., meter→foot, celsius→kelvin, availability→nines).                    |
 | **`ConversionGraph`**         | `ucon.graph`                            | Registry of unit conversion edges with BFS path composition.                                        | Converting between units via `Number.to(target)`; managing default and custom graphs.                                  |
 | **`UnitSystem`**              | `ucon.core`                             | Named mapping from dimensions to base units (e.g., SI, Imperial).                                   | Defining coherent unit systems; grouping base units by dimension.                                                      |
 | **`BasisTransform`**          | `ucon.core`                             | Matrix-based transformation between dimensional exponent spaces.                                    | Converting between incompatible dimensional structures; exact arithmetic with `Fraction`.                              |
@@ -227,6 +227,10 @@ print(ratio.to(units.ppm))  # <500000.0 ppm>
 
 # Cross-family conversions are prevented
 units.radian(1).to(units.percent)  # raises ConversionNotFound
+
+# SRE "nines" for availability (99.999% = 5 nines)
+uptime = units.percent(99.999)
+print(uptime.to(units.nines))  # <5.0 nines>
 ```
 
 ### Uncertainty Propagation
@@ -278,6 +282,47 @@ m4 = Measurement(value={"quantity": 9.8, "unit": "m/s²"})   # Unicode
 - **Serialization format**: Units serialize as human-readable shorthand strings (`"km"`, `"m/s^2"`) rather than structured dicts, aligning with how scientists express units.
 - **Parsing priority**: When parsing `"kg"`, ucon returns `Scale.kilo * gram` rather than looking up a `kilogram` Unit, ensuring consistent round-trip serialization and avoiding redundant unit definitions.
 
+### MCP Server
+
+ucon ships with an MCP server for AI agent integration (Claude Desktop, Claude Code, Cursor, etc.):
+
+```bash
+pip install ucon[mcp]
+```
+
+Configure in Claude Desktop (`claude_desktop_config.json`):
+
+**Via uvx (recommended, zero-install):**
+```json
+{
+  "mcpServers": {
+    "ucon": {
+      "command": "uvx",
+      "args": ["--from", "ucon[mcp]", "ucon-mcp"]
+    }
+  }
+}
+```
+
+**Local development:**
+```json
+{
+  "mcpServers": {
+    "ucon": {
+      "command": "uv",
+      "args": ["run", "--directory", "/path/to/ucon", "--extra", "mcp", "ucon-mcp"]
+    }
+  }
+}
+```
+
+Available tools:
+- `convert(value, from_unit, to_unit)` — Unit conversion with dimensional validation
+- `list_units(dimension?)` — Discover available units
+- `list_scales()` — List SI and binary prefixes
+- `check_dimensions(unit_a, unit_b)` — Check dimensional compatibility
+- `list_dimensions()` — List physical dimensions
+
 ### Custom Unit Systems
 
 `BasisTransform` enables conversions between incompatible dimensional structures (e.g., fantasy game physics, CGS units, domain-specific systems).
@@ -295,7 +340,7 @@ See full example: [docs/examples/basis-transform-fantasy-units.md](./docs/exampl
 | **0.5.0** | Dimensionless Units | Pseudo-dimensions for angle, solid angle, ratio | ✅ Complete |
 | **0.5.x** | Uncertainty | Propagation through arithmetic and conversions | ✅ Complete |
 | **0.5.x** | Unit Systems | `BasisTransform`, `UnitSystem`, cross-basis conversion | ✅ Complete |
-| **0.6.x** | Pydantic Integration | Type-safe quantity validation, JSON serialization | ✅ Complete |
+| **0.6.x** | Pydantic + MCP | API validation, AI agent integration | ✅ Complete |
 | **0.7.x** | NumPy Arrays | Vectorized conversion and arithmetic | ⏳ Planned |
 
 See full roadmap: [ROADMAP.md](./ROADMAP.md)

{ucon-0.6.0 → ucon-0.6.2}/README.md

@@ -54,7 +54,7 @@ To best answer this question, we turn to an age-old technique ([dimensional anal
 | **`UnitProduct`**             | `ucon.core`                             | A product/quotient of `UnitFactor`s with exponent tracking and simplification.                      | Representing composite units like m/s, kg·m/s², kJ·h.                                                                 |
 | **`Number`**                  | `ucon.core`                             | Combines a numeric quantity with a unit; the primary measurable type.                               | Performing arithmetic with units; representing physical quantities like 5 m/s.                                         |
 | **`Ratio`**                   | `ucon.core`                             | Represents the division of two `Number` objects; captures relationships between quantities.         | Expressing rates, densities, efficiencies (e.g., energy / time = power, length / time = velocity).                     |
-| **`Map`** hierarchy           | `ucon.maps`                             | Composable conversion morphisms: `LinearMap`, `AffineMap`, `ComposedMap`.                           | Defining conversion functions between units (e.g., meter→foot, celsius→kelvin).                                        |
+| **`Map`** hierarchy           | `ucon.maps`                             | Composable conversion morphisms: `LinearMap`, `AffineMap`, `LogMap`, `ExpMap`, `ComposedMap`.       | Defining conversion functions between units (e.g., meter→foot, celsius→kelvin, availability→nines).                    |
 | **`ConversionGraph`**         | `ucon.graph`                            | Registry of unit conversion edges with BFS path composition.                                        | Converting between units via `Number.to(target)`; managing default and custom graphs.                                  |
 | **`UnitSystem`**              | `ucon.core`                             | Named mapping from dimensions to base units (e.g., SI, Imperial).                                   | Defining coherent unit systems; grouping base units by dimension.                                                      |
 | **`BasisTransform`**          | `ucon.core`                             | Matrix-based transformation between dimensional exponent spaces.                                    | Converting between incompatible dimensional structures; exact arithmetic with `Fraction`.                              |
@@ -187,6 +187,10 @@ print(ratio.to(units.ppm))  # <500000.0 ppm>
 
 # Cross-family conversions are prevented
 units.radian(1).to(units.percent)  # raises ConversionNotFound
+
+# SRE "nines" for availability (99.999% = 5 nines)
+uptime = units.percent(99.999)
+print(uptime.to(units.nines))  # <5.0 nines>
 ```
 
 ### Uncertainty Propagation
@@ -238,6 +242,47 @@ m4 = Measurement(value={"quantity": 9.8, "unit": "m/s²"})   # Unicode
 - **Serialization format**: Units serialize as human-readable shorthand strings (`"km"`, `"m/s^2"`) rather than structured dicts, aligning with how scientists express units.
 - **Parsing priority**: When parsing `"kg"`, ucon returns `Scale.kilo * gram` rather than looking up a `kilogram` Unit, ensuring consistent round-trip serialization and avoiding redundant unit definitions.
 
+### MCP Server
+
+ucon ships with an MCP server for AI agent integration (Claude Desktop, Claude Code, Cursor, etc.):
+
+```bash
+pip install ucon[mcp]
+```
+
+Configure in Claude Desktop (`claude_desktop_config.json`):
+
+**Via uvx (recommended, zero-install):**
+```json
+{
+  "mcpServers": {
+    "ucon": {
+      "command": "uvx",
+      "args": ["--from", "ucon[mcp]", "ucon-mcp"]
+    }
+  }
+}
+```
+
+**Local development:**
+```json
+{
+  "mcpServers": {
+    "ucon": {
+      "command": "uv",
+      "args": ["run", "--directory", "/path/to/ucon", "--extra", "mcp", "ucon-mcp"]
+    }
+  }
+}
+```
+
+Available tools:
+- `convert(value, from_unit, to_unit)` — Unit conversion with dimensional validation
+- `list_units(dimension?)` — Discover available units
+- `list_scales()` — List SI and binary prefixes
+- `check_dimensions(unit_a, unit_b)` — Check dimensional compatibility
+- `list_dimensions()` — List physical dimensions
+
 ### Custom Unit Systems
 
 `BasisTransform` enables conversions between incompatible dimensional structures (e.g., fantasy game physics, CGS units, domain-specific systems).
@@ -255,7 +300,7 @@ See full example: [docs/examples/basis-transform-fantasy-units.md](./docs/exampl
 | **0.5.0** | Dimensionless Units | Pseudo-dimensions for angle, solid angle, ratio | ✅ Complete |
 | **0.5.x** | Uncertainty | Propagation through arithmetic and conversions | ✅ Complete |
 | **0.5.x** | Unit Systems | `BasisTransform`, `UnitSystem`, cross-basis conversion | ✅ Complete |
-| **0.6.x** | Pydantic Integration | Type-safe quantity validation, JSON serialization | ✅ Complete |
+| **0.6.x** | Pydantic + MCP | API validation, AI agent integration | ✅ Complete |
 | **0.7.x** | NumPy Arrays | Vectorized conversion and arithmetic | ⏳ Planned |
 
 See full roadmap: [ROADMAP.md](./ROADMAP.md)

{ucon-0.6.0 → ucon-0.6.2}/ROADMAP.md

@@ -26,6 +26,8 @@ ucon is a dimensional analysis library for engineers building systems where unit
 | v0.5.x | Uncertainty Propagation | Complete |
 | v0.5.x | BasisTransform + UnitSystem | Complete |
 | v0.6.0 | Pydantic + Serialization | Complete |
+| v0.6.x | MCP Server | Complete |
+| v0.6.x | LogMap + Nines | Complete |
 | v0.7.0 | NumPy Array Support | Planned |
 | v0.8.0 | String Parsing | Planned |
 | v0.9.0 | Constants + Logarithmic Units | Planned |
@@ -172,7 +174,6 @@ Building on v0.5.x baseline:
 - [x] JSON serialization/deserialization
 - [x] Pickle support
 - [x] Unit string parsing: `get_unit_by_name()` with Unicode and ASCII notation
-- [ ] Optional: MCP server for unit conversion tool (deferred)
 
 **Outcomes:**
 - Native validation and serialization for dimensioned quantities
@@ -182,6 +183,43 @@ Building on v0.5.x baseline:
 
 ---
 
+## v0.6.x — MCP Server (Complete)
+
+**Theme:** AI agent integration.
+
+- [x] MCP server exposing unit conversion tools
+- [x] `convert` tool with dimensional validation
+- [x] `list_units`, `list_scales`, `list_dimensions` discovery tools
+- [x] `check_dimensions` compatibility tool
+- [x] stdio transport for Claude Desktop, Claude Code, Cursor
+- [x] `ucon-mcp` CLI entry point
+
+**Outcomes:**
+- Zero-code adoption for AI tool users
+- Agents can perform unit-safe arithmetic without codebase integration
+- Dimensional errors become visible and correctable in conversation
+
+---
+
+## v0.6.x — LogMap + Nines (Complete)
+
+**Theme:** Logarithmic conversions.
+
+- [x] `LogMap` class: `y = scale · log_base(x) + offset`
+- [x] `ExpMap` class: `y = base^(scale · x + offset)`
+- [x] Composition with existing maps via `@` operator
+- [x] Derivative support for uncertainty propagation
+- [x] `nines` unit for SRE availability (99.999% = 5 nines)
+- [x] `fraction` unit (renamed from `ratio_one`)
+
+**Outcomes:**
+- Foundation for logarithmic unit conversions
+- SRE teams can express availability in nines notation
+- Uncertainty propagates correctly through nonlinear conversions
+- Paves the way for decibels, pH in v0.9.0
+
+---
+
 ## v0.7.0 — NumPy Array Support
 
 **Theme:** Scientific computing integration.
@@ -219,15 +257,15 @@ Building on v0.5.x baseline:
 **Theme:** Physical completeness.
 
 - [ ] Physical constants with uncertainties: `c`, `h`, `G`, `k_B`, `N_A`, etc.
-- [ ] `LogMap` for logarithmic conversions
-- [ ] Logarithmic units: `decibel`, `bel`, `neper`
+- [x] `LogMap`/`ExpMap` for logarithmic conversions (completed in v0.6.x)
+- [ ] Logarithmic units with reference levels: `decibel`, `bel`, `neper`
 - [ ] pH scale support
 - [ ] Currency dimension (with caveats about exchange rates)
 
 **Outcomes:**
-- Support for function-based (nonlinear) physical conversions
-- Enables acoustics (dB), chemistry (pH), and signal processing domains
 - Physical constants with CODATA uncertainties
+- Enables acoustics (dB), chemistry (pH), and signal processing domains
+- Reference-level infrastructure for dBm, dBV, dBSPL variants
 
 ---
 

{ucon-0.6.0 → ucon-0.6.2}/pyproject.toml

@@ -57,6 +57,8 @@ packages = ["ucon", "ucon.mcp"]
 
 [tool.setuptools_scm]
 # Version derived from git tags
+# no-local-version prevents +gXXXXXX suffixes that PyPI rejects
+local_scheme = "no-local-version"
 
 # -----------------------------------------------------------------------------
 # uv Configuration

{ucon-0.6.0 → ucon-0.6.2}/tests/ucon/test_dimensionless_units.py

@@ -185,17 +185,17 @@ class TestRatioConversions(unittest.TestCase):
     """Test ratio unit conversions."""
 
     def test_one_to_percent(self):
-        r = units.ratio_one(0.5)
+        r = units.fraction(0.5)
         result = r.to(units.percent)
         self.assertAlmostEqual(result.value, 50, places=9)
 
     def test_percent_to_one(self):
         r = units.percent(25)
-        result = r.to(units.ratio_one)
+        result = r.to(units.fraction)
         self.assertAlmostEqual(result.value, 0.25, places=9)
 
     def test_one_to_ppm(self):
-        r = units.ratio_one(0.001)
+        r = units.fraction(0.001)
         result = r.to(units.ppm)
         self.assertAlmostEqual(result.value, 1000, places=9)
 
@@ -205,7 +205,7 @@ class TestRatioConversions(unittest.TestCase):
         self.assertAlmostEqual(result.value, 1000, places=9)
 
     def test_one_to_permille(self):
-        r = units.ratio_one(0.005)
+        r = units.fraction(0.005)
         result = r.to(units.permille)
         self.assertAlmostEqual(result.value, 5, places=9)
 

ucon-0.6.2/tests/ucon/test_logmap.py

@@ -0,0 +1,289 @@
+# © 2026 The Radiativity Company
+# Licensed under the Apache License, Version 2.0
+# See the LICENSE file for details.
+
+"""
+Tests for LogMap and ExpMap classes.
+
+Tests logarithmic and exponential conversion morphisms including
+forward transforms, derivatives, inverses, and composition.
+"""
+
+import math
+import unittest
+
+from ucon.maps import LogMap, ExpMap, AffineMap, ComposedMap
+
+
+class TestLogMapBasic(unittest.TestCase):
+    """Test basic LogMap functionality."""
+
+    def test_default_log10(self):
+        m = LogMap()
+        self.assertAlmostEqual(m(10), 1.0)
+        self.assertAlmostEqual(m(100), 2.0)
+        self.assertAlmostEqual(m(1000), 3.0)
+
+    def test_scaled_log_decibel_power(self):
+        # 10 * log₁₀(x) — decibels for power ratios
+        m = LogMap(scale=10)
+        self.assertAlmostEqual(m(10), 10.0)
+        self.assertAlmostEqual(m(100), 20.0)
+        self.assertAlmostEqual(m(1000), 30.0)
+
+    def test_scaled_log_decibel_amplitude(self):
+        # 20 * log₁₀(x) — decibels for amplitude ratios
+        m = LogMap(scale=20)
+        self.assertAlmostEqual(m(10), 20.0)
+        self.assertAlmostEqual(m(100), 40.0)
+
+    def test_negative_scale_ph_style(self):
+        # -log₁₀(x) — pH-style
+        m = LogMap(scale=-1)
+        self.assertAlmostEqual(m(0.1), 1.0)
+        self.assertAlmostEqual(m(0.01), 2.0)
+        self.assertAlmostEqual(m(0.001), 3.0)
+        self.assertAlmostEqual(m(1e-7), 7.0)
+
+    def test_natural_log(self):
+        m = LogMap(base=math.e)
+        self.assertAlmostEqual(m(math.e), 1.0)
+        self.assertAlmostEqual(m(math.e ** 2), 2.0)
+        self.assertAlmostEqual(m(1), 0.0)
+
+    def test_with_offset(self):
+        m = LogMap(scale=1, base=10, offset=5)
+        # log₁₀(100) + 5 = 2 + 5 = 7
+        self.assertAlmostEqual(m(100), 7.0)
+
+    def test_log_of_one_is_zero(self):
+        m = LogMap()
+        self.assertAlmostEqual(m(1), 0.0)
+
+
+class TestLogMapErrors(unittest.TestCase):
+    """Test LogMap error handling."""
+
+    def test_zero_raises_error(self):
+        m = LogMap()
+        with self.assertRaises(ValueError) as ctx:
+            m(0)
+        self.assertIn("positive", str(ctx.exception))
+
+    def test_negative_raises_error(self):
+        m = LogMap()
+        with self.assertRaises(ValueError) as ctx:
+            m(-1)
+        self.assertIn("positive", str(ctx.exception))
+
+    def test_derivative_at_zero_raises(self):
+        m = LogMap()
+        with self.assertRaises(ValueError):
+            m.derivative(0)
+
+    def test_derivative_at_negative_raises(self):
+        m = LogMap()
+        with self.assertRaises(ValueError):
+            m.derivative(-1)
+
+
+class TestLogMapDerivative(unittest.TestCase):
+    """Test LogMap derivative for uncertainty propagation."""
+
+    def test_derivative_formula(self):
+        # d/dx[log₁₀(x)] = 1 / (x * ln(10))
+        m = LogMap()
+        x = 100
+        expected = 1 / (x * math.log(10))
+        self.assertAlmostEqual(m.derivative(x), expected)
+
+    def test_derivative_with_scale(self):
+        # d/dx[scale * log₁₀(x)] = scale / (x * ln(10))
+        m = LogMap(scale=10)
+        x = 100
+        expected = 10 / (x * math.log(10))
+        self.assertAlmostEqual(m.derivative(x), expected)
+
+    def test_derivative_natural_log(self):
+        # d/dx[ln(x)] = 1/x
+        m = LogMap(base=math.e)
+        x = 5
+        expected = 1 / x
+        self.assertAlmostEqual(m.derivative(x), expected)
+
+
+class TestLogMapInverse(unittest.TestCase):
+    """Test LogMap inverse returns ExpMap."""
+
+    def test_inverse_type(self):
+        m = LogMap()
+        inv = m.inverse()
+        self.assertIsInstance(inv, ExpMap)
+
+    def test_roundtrip(self):
+        m = LogMap(scale=2, base=10, offset=3)
+        x = 100
+        self.assertAlmostEqual(m.inverse()(m(x)), x)
+
+    def test_roundtrip_various_values(self):
+        m = LogMap(scale=-1)
+        for x in [0.001, 0.1, 1, 10, 100]:
+            self.assertAlmostEqual(m.inverse()(m(x)), x, places=9)
+
+    def test_non_invertible_raises(self):
+        m = LogMap(scale=0)
+        with self.assertRaises(ZeroDivisionError):
+            m.inverse()
+
+
+class TestLogMapProperties(unittest.TestCase):
+    """Test LogMap properties."""
+
+    def test_invertible_true(self):
+        m = LogMap(scale=1)
+        self.assertTrue(m.invertible)
+
+    def test_invertible_false(self):
+        m = LogMap(scale=0)
+        self.assertFalse(m.invertible)
+
+    def test_is_identity_false(self):
+        m = LogMap()
+        self.assertFalse(m.is_identity())
+
+    def test_pow_one(self):
+        m = LogMap(scale=2)
+        self.assertEqual(m ** 1, m)
+
+    def test_pow_minus_one(self):
+        m = LogMap(scale=2)
+        inv = m ** -1
+        self.assertIsInstance(inv, ExpMap)
+
+    def test_pow_other_raises(self):
+        m = LogMap()
+        with self.assertRaises(ValueError):
+            _ = m ** 2
+
+
+class TestExpMapBasic(unittest.TestCase):
+    """Test basic ExpMap functionality."""
+
+    def test_default_exp10(self):
+        m = ExpMap()
+        self.assertAlmostEqual(m(0), 1.0)
+        self.assertAlmostEqual(m(1), 10.0)
+        self.assertAlmostEqual(m(2), 100.0)
+        self.assertAlmostEqual(m(3), 1000.0)
+
+    def test_with_scale(self):
+        m = ExpMap(scale=0.5)
+        # 10^(0.5 * 2) = 10^1 = 10
+        self.assertAlmostEqual(m(2), 10.0)
+
+    def test_with_offset(self):
+        m = ExpMap(scale=1, offset=1)
+        # 10^(1*0 + 1) = 10^1 = 10
+        self.assertAlmostEqual(m(0), 10.0)
+
+    def test_natural_exp(self):
+        m = ExpMap(base=math.e)
+        self.assertAlmostEqual(m(0), 1.0)
+        self.assertAlmostEqual(m(1), math.e)
+        self.assertAlmostEqual(m(2), math.e ** 2)
+
+
+class TestExpMapDerivative(unittest.TestCase):
+    """Test ExpMap derivative."""
+
+    def test_derivative_formula(self):
+        # d/dx[10^x] = ln(10) * 10^x
+        m = ExpMap()
+        x = 2
+        expected = math.log(10) * (10 ** x)
+        self.assertAlmostEqual(m.derivative(x), expected)
+
+    def test_derivative_with_scale(self):
+        # d/dx[10^(scale*x)] = ln(10) * scale * 10^(scale*x)
+        m = ExpMap(scale=2)
+        x = 1
+        expected = math.log(10) * 2 * (10 ** 2)
+        self.assertAlmostEqual(m.derivative(x), expected)
+
+
+class TestExpMapInverse(unittest.TestCase):
+    """Test ExpMap inverse returns LogMap."""
+
+    def test_inverse_type(self):
+        m = ExpMap()
+        inv = m.inverse()
+        self.assertIsInstance(inv, LogMap)
+
+    def test_roundtrip(self):
+        m = ExpMap(scale=2, base=10, offset=1)
+        x = 3
+        self.assertAlmostEqual(m.inverse()(m(x)), x)
+
+    def test_non_invertible_raises(self):
+        m = ExpMap(scale=0)
+        with self.assertRaises(ZeroDivisionError):
+            m.inverse()
+
+
+class TestExpMapProperties(unittest.TestCase):
+    """Test ExpMap properties."""
+
+    def test_invertible_true(self):
+        m = ExpMap(scale=1)
+        self.assertTrue(m.invertible)
+
+    def test_invertible_false(self):
+        m = ExpMap(scale=0)
+        self.assertFalse(m.invertible)
+
+    def test_is_identity_false(self):
+        m = ExpMap()
+        self.assertFalse(m.is_identity())
+
+
+class TestLogMapComposition(unittest.TestCase):
+    """Test LogMap composition with other maps."""
+
+    def test_compose_with_affine(self):
+        # nines = -log₁₀(1 - x)
+        # = LogMap(scale=-1) @ AffineMap(a=-1, b=1)
+        nines = LogMap(scale=-1) @ AffineMap(a=-1, b=1)
+        self.assertIsInstance(nines, ComposedMap)
+
+    def test_nines_composition_values(self):
+        nines = LogMap(scale=-1) @ AffineMap(a=-1, b=1)
+        self.assertAlmostEqual(nines(0.9), 1.0)
+        self.assertAlmostEqual(nines(0.99), 2.0)
+        self.assertAlmostEqual(nines(0.999), 3.0)
+        self.assertAlmostEqual(nines(0.9999), 4.0)
+        self.assertAlmostEqual(nines(0.99999), 5.0)
+
+    def test_composed_derivative_chain_rule(self):
+        # nines'(x) = d/dx[-log₁₀(1-x)]
+        #           = 1 / ((1-x) * ln(10))
+        nines = LogMap(scale=-1) @ AffineMap(a=-1, b=1)
+        x = 0.99999
+        expected = 1 / ((1 - x) * math.log(10))
+        self.assertAlmostEqual(nines.derivative(x), expected, places=5)
+
+    def test_composed_inverse(self):
+        nines = LogMap(scale=-1) @ AffineMap(a=-1, b=1)
+        inv = nines.inverse()
+        x = 0.99999
+        self.assertAlmostEqual(inv(nines(x)), x, places=9)
+
+    def test_nines_inverse_values(self):
+        nines = LogMap(scale=-1) @ AffineMap(a=-1, b=1)
+        inv = nines.inverse()
+        self.assertAlmostEqual(inv(2), 0.99)
+        self.assertAlmostEqual(inv(3), 0.999)
+        self.assertAlmostEqual(inv(5), 0.99999)
+
+
+if __name__ == '__main__':
+    unittest.main()