nomogram 0.2.0__tar.gz → 0.4.0__tar.gz

{nomogram-0.2.0 → nomogram-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nomogram
-Version: 0.2.0
+Version: 0.4.0
 Summary: Repository of scientific formulas: notations, units, validity domains
 Keywords: scientific computing,formulas,units,dimensional analysis,physics,thermodynamics,geoscience,atmospheric science,meteorology,hydrology,psychrometrics
 Author: miki4ia
@@ -32,7 +32,12 @@ Project-URL: Changelog, https://github.com/miki4iaml/nomogram/blob/main/CHANGELO
 Provides-Extra: viz
 Description-Content-Type: text/markdown
 
-# nomogram
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="docs/images/banner-dark.svg">
+    <img alt="nomogram" src="docs/images/banner-light.svg" width="480">
+  </picture>
+</p>
 
 **English** | [Français](README.fr.md)
 
@@ -47,9 +52,19 @@ Description-Content-Type: text/markdown
 [![Checked with mypy](https://www.mypy-lang.org/static/mypy_badge.svg)](https://mypy-lang.org/)
 [![Conventional Commits](https://img.shields.io/badge/Conventional%20Commits-1.0.0-fe5196)](https://www.conventionalcommits.org/en/v1.0.0/)
 
-A repository of scientific formulas: alternative notations across
-authors and conventions, parameter units (including empirical ones),
-validity domains, LaTeX rendering and symbolic computation.
+**Formulas as data, not as code.**
+
+nomogram does not hard-code functions: it catalogs formulas, each one
+
+- **meaningful**: QUDT quantity kinds and units, links to CF and
+  Wikidata, its source, its validity domain when stated;
+- **checked**: dimensions and units on loading, equivalences proved
+  symbolically, values cross-checked against references;
+- **ready to use**: compute, compose, invert, plot, and compare with its
+  alternatives.
+
+Built for trust, not for speed: to show that a calculation is right, and
+where it comes from.
 
 Pure Python, built on SymPy, numpy and pint; it works on an offline
 workstation (no online engine).
@@ -77,25 +92,28 @@ Python 3.12 or later. Plots need the `viz` extra (matplotlib):
 ## Example
 
 Every saturation vapour pressure formulation of the catalog against the
-IAPWS reference; curves stop where a formulation leaves its stated
-validity domain ([script](docs/examples/saturation_vapour_pressure.py)):
+IAPWS reference, from 0 to 60 °C and within 1 %; curves stop where a formulation leaves its
+stated validity domain, and the figure takes the option set of nomogram's
+documentation ([script](docs/examples/saturation_vapour_pressure.py)):
 
 ```python
 import numpy as np
-from nomogram.catalog import catalog
-from nomogram.comparison import compare
-from nomogram.plot import plot_deviations  # extra viz
+import nomogram as nomo
 from nomogram.units import Q_
 
-formulations = catalog().formulations_of("SaturationVapourPressureOverWater")
-reference = catalog().formulations["iapws_sr1_86"]
+catalog = nomo.catalog.catalog()
+formulations = catalog.formulations_of("SaturationVapourPressureOverWater")
+reference = catalog.formulations["iapws_sr1_86"]
 temperatures = Q_(np.linspace(-60, 110, 341), "degC")
 
-table = compare(formulations, reference, {"ThermodynamicTemperature": temperatures})
-plot_deviations(table)
+table = nomo.comparison.compare(
+    formulations, reference, {"ThermodynamicTemperature": temperatures}
+)
+with nomo.display.display_options(nomo.display.DisplayOptions.DOCUMENTATION):
+    nomo.plot.plot_deviations(table, xlim=(0, 60), ylim=(-1.0, 1.0))  # extra viz
 ```
 
-![Deviation of saturation vapour pressure formulations from IAPWS](https://raw.githubusercontent.com/miki4iaml/nomogram/v0.1.0/docs/images/saturation-vapour-pressure.png)
+![Deviation of saturation vapour pressure formulations from IAPWS](https://raw.githubusercontent.com/miki4iaml/nomogram/v0.4.0/docs/images/saturation-vapour-pressure.png)
 
 ## Usage
 
@@ -105,16 +123,28 @@ otherwise (`outside="ignore"`). Formulations also chain, for instance
 the absolute humidity from any saturation vapour pressure formulation:
 
 ```python
-from nomogram.comparison import compose
-
-ha = compose(catalog().formulations["mass_concentration_ideal_gas"], {"e_s": reference})
+ha = nomo.comparison.compose(
+    catalog.formulations["mass_concentration_ideal_gas"], {"e_s": reference}
+)
 ha.evaluate(RH=Q_(100, "percent"), T=Q_(20, "degC")).to("g/m^3")  # 17.29
 ```
 
+Formulations are found by words, wildcards and fields, whatever their
+notation ([Finding formulations](docs/search.md)):
+
+```python
+catalog.search(variable="rho*")                    # ρ in every notation
+catalog.search(kind="VapourPressure", source="buck*")
+```
+
 Each formulation keeps its units, validity domain, temperature scale and
 references. The vocabulary is mapped in [docs/rosetta.md](docs/rosetta.md);
 [How nomogram earns trust](docs/approach.md) explains what is checked and
-how.
+how, and [Displaying formulas](docs/display.md) shows formulas in notebooks,
+Markdown and plots. [Sea water](docs/sea-water.md) shows the salinity
+scales and the vapour pressure of sea water, and what its 2 % lowering
+changes at the sea surface. [The logo](docs/logo.md) is a working
+nomogram.
 
 ## Contributing
 
@@ -123,6 +153,26 @@ entries, new formulas and code are all welcome: see the
 [ways to contribute](.github/CONTRIBUTING.md#ways-to-contribute) and
 the [catalog guide](docs/catalog.md).
 
+## Data sources
+
+nomogram's units come from QUDT, and so do its quantity kinds, except
+those QUDT lacks, which nomogram defines as specializations of QUDT
+kinds. nomogram links some kinds to CF standard names, which come, with
+their canonical units, from the CF standard name table. The package
+bundles a subset of each source:
+
+- QUDT — Quantities, Units, Dimensions and Types, by QUDT.org
+  (<https://qudt.org>), release 3.5.2, licensed under
+  [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/);
+- the [CF standard name table](https://cfconventions.org/Data/cf-standard-names/95/build/cf-standard-name-table.html),
+  version 95, [CC0 1.0](https://creativecommons.org/publicdomain/zero/1.0/);
+- the UCUM codes of the units, as QUDT gives them: © Regenstrief
+  Institute, Inc., [UCUM License](https://ucum.org/license).
+
+What nomogram selects, changes and adds is listed in
+[NOTICE.md](src/nomogram/data/NOTICE.md).
+
 ## License
 
-[BSD-3-Clause](LICENSE).
+Code: [BSD-3-Clause](LICENSE). Bundled data: see
+[Data sources](#data-sources).

nomogram-0.4.0/README.md

@@ -0,0 +1,144 @@
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="docs/images/banner-dark.svg">
+    <img alt="nomogram" src="docs/images/banner-light.svg" width="480">
+  </picture>
+</p>
+
+**English** | [Français](README.fr.md)
+
+[![CI](https://github.com/miki4iaml/nomogram/actions/workflows/ci.yml/badge.svg?branch=develop)](https://github.com/miki4iaml/nomogram/actions/workflows/ci.yml)
+[![CodeQL](https://github.com/miki4iaml/nomogram/actions/workflows/github-code-scanning/codeql/badge.svg)](https://github.com/miki4iaml/nomogram/actions/workflows/github-code-scanning/codeql)
+[![codecov](https://codecov.io/gh/miki4iaml/nomogram/graph/badge.svg?branch=develop)](https://codecov.io/gh/miki4iaml/nomogram)
+[![Python](https://img.shields.io/python/required-version-toml?tomlFilePath=https%3A%2F%2Fraw.githubusercontent.com%2Fmiki4iaml%2Fnomogram%2Fdevelop%2Fpyproject.toml)](pyproject.toml)
+[![License](https://img.shields.io/github/license/miki4iaml/nomogram)](LICENSE)
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.23373134.svg)](https://doi.org/10.5281/zenodo.23373134)
+[![uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+[![Checked with mypy](https://www.mypy-lang.org/static/mypy_badge.svg)](https://mypy-lang.org/)
+[![Conventional Commits](https://img.shields.io/badge/Conventional%20Commits-1.0.0-fe5196)](https://www.conventionalcommits.org/en/v1.0.0/)
+
+**Formulas as data, not as code.**
+
+nomogram does not hard-code functions: it catalogs formulas, each one
+
+- **meaningful**: QUDT quantity kinds and units, links to CF and
+  Wikidata, its source, its validity domain when stated;
+- **checked**: dimensions and units on loading, equivalences proved
+  symbolically, values cross-checked against references;
+- **ready to use**: compute, compose, invert, plot, and compare with its
+  alternatives.
+
+Built for trust, not for speed: to show that a calculation is right, and
+where it comes from.
+
+Pure Python, built on SymPy, numpy and pint; it works on an offline
+workstation (no online engine).
+
+> Early stage project (alpha).
+
+## Installation
+
+```
+pip install nomogram          # core
+pip install "nomogram[viz]"   # with plots (matplotlib)
+```
+
+## Installation from source
+
+```
+git clone https://github.com/miki4iaml/nomogram.git
+cd nomogram
+uv sync
+```
+
+Python 3.12 or later. Plots need the `viz` extra (matplotlib):
+`uv sync --extra viz`.
+
+## Example
+
+Every saturation vapour pressure formulation of the catalog against the
+IAPWS reference, from 0 to 60 °C and within 1 %; curves stop where a formulation leaves its
+stated validity domain, and the figure takes the option set of nomogram's
+documentation ([script](docs/examples/saturation_vapour_pressure.py)):
+
+```python
+import numpy as np
+import nomogram as nomo
+from nomogram.units import Q_
+
+catalog = nomo.catalog.catalog()
+formulations = catalog.formulations_of("SaturationVapourPressureOverWater")
+reference = catalog.formulations["iapws_sr1_86"]
+temperatures = Q_(np.linspace(-60, 110, 341), "degC")
+
+table = nomo.comparison.compare(
+    formulations, reference, {"ThermodynamicTemperature": temperatures}
+)
+with nomo.display.display_options(nomo.display.DisplayOptions.DOCUMENTATION):
+    nomo.plot.plot_deviations(table, xlim=(0, 60), ylim=(-1.0, 1.0))  # extra viz
+```
+
+![Deviation of saturation vapour pressure formulations from IAPWS](https://raw.githubusercontent.com/miki4iaml/nomogram/v0.4.0/docs/images/saturation-vapour-pressure.png)
+
+## Usage
+
+The table holds the values and the relative deviations, by formulation;
+values outside a formulation's validity domain are NaN unless asked
+otherwise (`outside="ignore"`). Formulations also chain, for instance
+the absolute humidity from any saturation vapour pressure formulation:
+
+```python
+ha = nomo.comparison.compose(
+    catalog.formulations["mass_concentration_ideal_gas"], {"e_s": reference}
+)
+ha.evaluate(RH=Q_(100, "percent"), T=Q_(20, "degC")).to("g/m^3")  # 17.29
+```
+
+Formulations are found by words, wildcards and fields, whatever their
+notation ([Finding formulations](docs/search.md)):
+
+```python
+catalog.search(variable="rho*")                    # ρ in every notation
+catalog.search(kind="VapourPressure", source="buck*")
+```
+
+Each formulation keeps its units, validity domain, temperature scale and
+references. The vocabulary is mapped in [docs/rosetta.md](docs/rosetta.md);
+[How nomogram earns trust](docs/approach.md) explains what is checked and
+how, and [Displaying formulas](docs/display.md) shows formulas in notebooks,
+Markdown and plots. [Sea water](docs/sea-water.md) shows the salinity
+scales and the vapour pressure of sea water, and what its 2 % lowering
+changes at the sea surface. [The logo](docs/logo.md) is a working
+nomogram.
+
+## Contributing
+
+References to integrate, information or corrections about catalog
+entries, new formulas and code are all welcome: see the
+[ways to contribute](.github/CONTRIBUTING.md#ways-to-contribute) and
+the [catalog guide](docs/catalog.md).
+
+## Data sources
+
+nomogram's units come from QUDT, and so do its quantity kinds, except
+those QUDT lacks, which nomogram defines as specializations of QUDT
+kinds. nomogram links some kinds to CF standard names, which come, with
+their canonical units, from the CF standard name table. The package
+bundles a subset of each source:
+
+- QUDT — Quantities, Units, Dimensions and Types, by QUDT.org
+  (<https://qudt.org>), release 3.5.2, licensed under
+  [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/);
+- the [CF standard name table](https://cfconventions.org/Data/cf-standard-names/95/build/cf-standard-name-table.html),
+  version 95, [CC0 1.0](https://creativecommons.org/publicdomain/zero/1.0/);
+- the UCUM codes of the units, as QUDT gives them: © Regenstrief
+  Institute, Inc., [UCUM License](https://ucum.org/license).
+
+What nomogram selects, changes and adds is listed in
+[NOTICE.md](src/nomogram/data/NOTICE.md).
+
+## License
+
+Code: [BSD-3-Clause](LICENSE). Bundled data: see
+[Data sources](#data-sources).

{nomogram-0.2.0 → nomogram-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nomogram"
-version = "0.2.0"
+version = "0.4.0"
 description = "Repository of scientific formulas: notations, units, validity domains"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -120,6 +120,9 @@ fail_under = 80
 show_missing = true
 exclude_also = ['if __name__ == "__main__":']
 
+[tool.ruff.format]
+exclude = ["*.md"]
+
 [tool.ruff.lint]
 extend-select = [
     "ARG",
@@ -138,6 +141,7 @@ extend-select = [
 
 [tool.codespell]
 skip = "*.fr.md,uv.lock"
+ignore-words-list = "flate,alph,mesures"
 
 [tool.repo-review.ignore]
 PC110 = "ruff format runs as a local hook through uv run --frozen (single version source: uv.lock)"

{nomogram-0.2.0 → nomogram-0.4.0}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "nomogram"
-version = "0.2.0"
+version = "0.4.0"
 description = "Repository of scientific formulas: notations, units, validity domains"
 readme = "README.md"
 authors = [
@@ -102,6 +102,12 @@ fail_under = 80
 show_missing = true
 exclude_also = ['if __name__ == "__main__":']
 
+[tool.ruff.format]
+# ruff also formats the code blocks of Markdown files when run without
+# arguments; the documents keep their own layout (aligned comments), and
+# tests/test_examples.py reads the values their code comments state.
+exclude = ["*.md"]
+
 [tool.ruff.lint]
 # On top of ruff's default selection, which Dependabot bumps surface in CI.
 extend-select = ["ARG", "B", "C4", "PIE", "PT", "PTH", "RET", "T20"]
@@ -114,6 +120,9 @@ extend-select = ["ARG", "B", "C4", "PIE", "PT", "PTH", "RET", "T20"]
 
 [tool.codespell]
 skip = "*.fr.md,uv.lock"
+# Format terms: the Flate filter of PDF, the ALPH chunk of WebP; the
+# French name of the BIPM (Bureau International des Poids et Mesures).
+ignore-words-list = "flate,alph,mesures"
 
 [tool.repo-review.ignore]
 PC110 = "ruff format runs as a local hook through uv run --frozen (single version source: uv.lock)"

nomogram-0.4.0/src/nomogram/__init__.py

@@ -0,0 +1,72 @@
+# SPDX-FileCopyrightText: 2026 Miki
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""nomogram: a repository of scientific formulas.
+
+Submodules are imported on demand, so that ``import nomogram`` stays
+light: :mod:`nomogram.units` (pint), :mod:`nomogram.expression`
+(SymPy), :mod:`nomogram.semantics` (bundled QUDT and CF subsets),
+:mod:`nomogram.model` and :mod:`nomogram.catalog` (formulations),
+:mod:`nomogram.dimensions`, :mod:`nomogram.comparison`,
+:mod:`nomogram.inversion`, :mod:`nomogram.relations`,
+:mod:`nomogram.search`, :mod:`nomogram.display` and :mod:`nomogram.plot`.
+
+Each is also an attribute of the package, imported the first time it is
+used (PEP 562)::
+
+    import nomogram as nomo
+
+    formulations = nomo.catalog.catalog().formulations_of("VapourPressure")
+"""
+
+from importlib import import_module
+from importlib.metadata import version
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from nomogram import catalog as catalog
+    from nomogram import comparison as comparison
+    from nomogram import dimensions as dimensions
+    from nomogram import display as display
+    from nomogram import expression as expression
+    from nomogram import inversion as inversion
+    from nomogram import model as model
+    from nomogram import plot as plot
+    from nomogram import relations as relations
+    from nomogram import search as search
+    from nomogram import semantics as semantics
+    from nomogram import units as units
+
+__all__ = [
+    "__version__",
+    "catalog",
+    "comparison",
+    "dimensions",
+    "display",
+    "expression",
+    "inversion",
+    "model",
+    "plot",
+    "relations",
+    "search",
+    "semantics",
+    "units",
+]
+
+#: Submodules reachable as attributes of the package.
+_SUBMODULES = frozenset(__all__) - {"__version__"}
+
+__version__ = version("nomogram")
+
+
+def __getattr__(name: str) -> object:
+    """Import a submodule the first time it is used as an attribute."""
+    if name in _SUBMODULES:
+        return import_module(f"{__name__}.{name}")
+    msg = f"module {__name__!r} has no attribute {name!r}"
+    raise AttributeError(msg)
+
+
+def __dir__() -> list[str]:
+    """The names of the package, submodules included before their import."""
+    return sorted({*globals(), *_SUBMODULES})

nomogram-0.4.0/src/nomogram/_logo.py

@@ -0,0 +1,228 @@
+# SPDX-FileCopyrightText: 2026 Miki
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""Geometry of the logo, NOMO, shared by its SVG files and the plots.
+
+- N is a working alignment chart (an N or Z chart): two parallel scales,
+  u read downward on the left stroke and v upward on the right one, and a
+  diagonal scale for w = u / v, graduated at s = w / (1 + w) of its
+  length. A straight reading line through u and v crosses the diagonal at
+  u / v; :func:`n_chart` checks it.
+- The first O is a sphere of linked nodes (shared vocabularies), the
+  second a globe in orthographic projection (the Earth sciences).
+- M is plain, and the reading line runs on through O, M and O.
+
+Shapes are in SVG units, y downward, with a role that says how each is
+painted (:data:`THEMES`): ``ink`` and ``fine`` strokes (``fine`` at 55 %
+opacity), ``read`` for the reading line, filled ``sea``, ``dot`` and
+``node``. ``scripts/make_logo.py`` writes them as SVG,
+:func:`nomogram.plot.sign` as matplotlib artists. Standard library only.
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+
+#: Letter height and stroke widths, in SVG units.
+H = 100.0
+STROKE = 8.0
+THIN = 1.6
+TICK = 5.0
+
+#: Reading line: u on the left scale, v on the right one (0 to 5).
+U, V = 3.0, 2.2
+
+#: Colours: ink, sea of the globe, accent of the reading line.
+THEMES = {
+    "light": {"ink": "#1f2937", "sea": "#dbeafe", "accent": "#c2410c"},
+    "dark": {"ink": "#e5e7eb", "sea": "#1e3a5f", "accent": "#fb923c"},
+}
+
+#: Opacity of the ``fine`` strokes (graduations, graticule, links).
+FINE_OPACITY = 0.55
+
+Point = tuple[float, float]
+
+
+@dataclass(frozen=True)
+class Line:
+    start: Point
+    end: Point
+    role: str
+    width: float
+
+
+@dataclass(frozen=True)
+class Circle:
+    centre: Point
+    radius: float
+    role: str
+    #: Stroke width; 0 for a filled circle.
+    width: float = 0.0
+
+
+@dataclass(frozen=True)
+class Ellipse:
+    centre: Point
+    rx: float
+    ry: float
+    role: str
+    width: float
+
+
+@dataclass(frozen=True)
+class Polyline:
+    points: tuple[Point, ...]
+    role: str
+    width: float
+
+
+Shape = Line | Circle | Ellipse | Polyline
+
+
+def n_chart(
+    x: float, y: float, w: float, *, stroke: float = STROKE, ticks: bool = True
+) -> tuple[list[Shape], Point, Point]:
+    """The N as an alignment chart; returns its shapes and the reading points."""
+    scale = H / 5.0
+    out: list[Shape] = [
+        Line((x, y), (x, y + H), "ink", stroke),
+        Line((x + w, y), (x + w, y + H), "ink", stroke),
+        Line((x, y), (x + w, y + H), "ink", stroke),
+    ]
+    if ticks:
+        # u downward on the left stroke, v upward on the right one.
+        for k in range(11):
+            value = k / 2.0
+            length = TICK * (1.6 if k % 2 == 0 else 1.0)
+            left_y, right_y = y + scale * value, y + H - scale * value
+            out.append(
+                Line(
+                    (x - length - stroke / 2, left_y),
+                    (x - stroke / 2, left_y),
+                    "fine",
+                    THIN,
+                )
+            )
+            out.append(
+                Line(
+                    (x + w + stroke / 2, right_y),
+                    (x + w + stroke / 2 + length, right_y),
+                    "fine",
+                    THIN,
+                )
+            )
+        # w = u / v on the diagonal, at s = w / (1 + w) from its top end.
+        norm = math.hypot(w, H)
+        nx, ny = H / norm, -w / norm  # unit normal, up and right
+        for value in (0.25, 0.5, 1.0, 2.0, 4.0):
+            s = value / (1.0 + value)
+            cx, cy = x + s * w, y + s * H
+            near, far = stroke / 2, stroke / 2 + 1.6 * TICK
+            out.append(
+                Line(
+                    (cx + nx * near, cy + ny * near),
+                    (cx + nx * far, cy + ny * far),
+                    "fine",
+                    THIN,
+                )
+            )
+    left = (x, y + scale * U)
+    right = (x + w, y + H - scale * V)
+    # The reading line crosses the diagonal at w = U / V: check it.
+    s = (U / V) / (1.0 + U / V)
+    crossing = (left[1] - y) / ((left[1] - y) + (y + H - right[1]))
+    if abs(crossing - s) > 1e-12:  # pragma: no cover - a broken chart
+        msg = f"the reading line crosses the diagonal at {crossing}, not {s}"
+        raise AssertionError(msg)
+    out.append(Circle((x + s * w, y + s * H), stroke * 0.55, "dot"))
+    return out, left, right
+
+
+def reading_line(
+    left: Point, right: Point, start: float, end: float, width: float
+) -> Line:
+    """The straight line through both reading points, from x = start to end."""
+    slope = (right[1] - left[1]) / (right[0] - left[0])
+    return Line(
+        (start, left[1] + slope * (start - left[0])),
+        (end, left[1] + slope * (end - left[0])),
+        "read",
+        width,
+    )
+
+
+def globe(centre: Point, radius: float) -> list[Shape]:
+    """A sphere in orthographic projection, seen from the equator."""
+    cx, cy = centre
+    out: list[Shape] = [Circle(centre, radius, "sea")]
+    for longitude in (30.0, 60.0):
+        rx = radius * math.sin(math.radians(longitude))
+        out.append(Ellipse(centre, rx, radius, "fine", THIN))
+    out.append(Line((cx, cy - radius), (cx, cy + radius), "fine", THIN))
+    for latitude in (-60.0, -30.0, 0.0, 30.0, 60.0):
+        yy = cy - radius * math.sin(math.radians(latitude))
+        half = radius * math.cos(math.radians(latitude))
+        out.append(Line((cx - half, yy), (cx + half, yy), "fine", THIN))
+    out.append(Circle(centre, radius, "ink", STROKE))
+    return out
+
+
+def nodes(centre: Point, radius: float) -> list[Shape]:
+    """A sphere of linked nodes: a Fibonacci lattice, its visible side."""
+    cx, cy = centre
+    count, points = 24, []
+    golden = math.pi * (3.0 - math.sqrt(5.0))
+    for i in range(count):
+        z = 1.0 - 2.0 * (i + 0.5) / count
+        ring = math.sqrt(1.0 - z * z)
+        x3, y3 = ring * math.cos(golden * i), ring * math.sin(golden * i)
+        if x3 > -0.1:
+            points.append((cx + 0.82 * radius * y3, cy - 0.82 * radius * z))
+    out: list[Shape] = []
+    for i, point in enumerate(points):
+        nearest = sorted(points[i + 1 :], key=lambda p: math.dist(p, point))[:2]
+        out += [
+            Line(point, other, "fine", THIN)
+            for other in nearest
+            if math.dist(point, other) < 0.75 * radius
+        ]
+    out += [Circle(point, 2.2, "node") for point in points]
+    out.append(Circle(centre, radius, "ink", STROKE))
+    return out
+
+
+def m_letter(x: float, y: float, w: float) -> list[Shape]:
+    points = ((x, y + H), (x, y), (x + w / 2, y + 0.62 * H), (x + w, y), (x + w, y + H))
+    return [Polyline(points, "ink", STROKE)]
+
+
+def logo() -> tuple[list[Shape], float, float]:
+    """The shapes of NOMO, with the width and height they take."""
+    margin, width, gap = 22.0, 64.0, 26.0
+    x_n = margin
+    x_nodes = x_n + width + gap
+    x_m = x_nodes + H + gap
+    x_globe = x_m + width + gap
+    y = margin
+    shapes, left, right = n_chart(x_n, y, width)
+    shapes += nodes((x_nodes + H / 2, y + H / 2), H / 2)
+    shapes += m_letter(x_m, y, width)
+    shapes += globe((x_globe + H / 2, y + H / 2), H / 2)
+    shapes.append(reading_line(left, right, x_n - 12.0, x_globe + H + 12.0, 2.6))
+    shapes += [Circle(point, STROKE * 0.55, "dot") for point in (left, right)]
+    return shapes, x_globe + H + margin, H + 2 * margin
+
+
+def icon(*, small: bool = False) -> tuple[list[Shape], float, float]:
+    """The N chart alone; ``small`` drops the graduations (favicon)."""
+    margin, width = 26.0, 64.0
+    stroke = 14.0 if small else STROKE
+    shapes, left, right = n_chart(margin, margin, width, stroke=stroke, ticks=not small)
+    line_width = 7.0 if small else 3.2
+    shapes.append(
+        reading_line(left, right, margin - 14.0, margin + width + 14.0, line_width)
+    )
+    shapes += [Circle(point, stroke * 0.55, "dot") for point in (left, right)]
+    return shapes, width + 2 * margin, H + 2 * margin