unitx 0.13.2__tar.gz → 0.13.4__tar.gz

{unitx-0.13.2 → unitx-0.13.4}/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 ## [Unreleased]
 
+## [0.13.4] - 2026-10-23
+
+### Fixed
+
+- Preserve exact extra scales and structural unit formatting for affine points
+  in anonymous zero-origin linear coordinates across text, LaTeX, HTML and siunitx.
+  Stored readings and named coordinate labels are unchanged.
+
+### Added
+
+- Add an Arrhenius fitting notebook with absolute temperatures, activation-energy
+  estimates and standard errors, a fitted curve and first-order rate predictions.
+
+## [0.13.3] - 2026-10-22
+
+### Added
+
+- `unitx.serialization.to_dict()` / `from_dict()` exchange scalar Quantities,
+  affine points and their units as versioned JSON-compatible records. Preserve
+  int/float/Fraction/Decimal magnitudes, exact extra scales, formal unit identity
+  and coordinate references; validate existing registry meanings without
+  registering units. NumPy, complex magnitudes and subclasses are not supported.
+- Add `SerializationError` for invalid records and failed restoration, and an
+  independent `VersionError` for unsupported explicit versions. Both derive
+  from `UnitxError` and `ValueError`; decoding preserves underlying causes.
+
 ## [0.13.2] - 2026-10-22
 
 ### Added

{unitx-0.13.2 → unitx-0.13.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: unitx
-Version: 0.13.2
+Version: 0.13.4
 Summary: Physical units, quantities, and unit conversion with exact unit algebra, type hints, and NumPy integration.
 Project-URL: Homepage, https://github.com/DaitTHU/unitx
 Project-URL: Documentation, https://github.com/DaitTHU/unitx/blob/main/docs/README.md
@@ -195,9 +195,9 @@ Use `.value` or `.value_in(unit)` at plotting and external-library boundaries.
 implicit unit removal. NumPy's type stubs do not describe every wrapped
 operation; see the [typing guide](https://github.com/DaitTHU/unitx/blob/main/docs/typing.md).
 
-The [physics notebooks](https://github.com/DaitTHU/unitx/blob/main/examples/README.md)
-cover blackbody radiation, damped motion, wave-packet spreading, attenuation,
-and measurement uncertainty.
+The [scientific examples](https://github.com/DaitTHU/unitx/blob/main/examples/README.md)
+cover reaction-rate fitting, blackbody radiation, damped motion, wave-packet
+spreading, attenuation, and measurement uncertainty.
 
 ## Blackbody radiation
 
@@ -213,7 +213,7 @@ from matplotlib import pyplot as plt
 from unitx.si import SI, si
 
 wavelength = np.linspace(0.01, 3, 100)[:, None] * si.um
-temperature = np.array([3000, 4000, 5000]) * si.K
+temperature = np.asarray([3000, 4000, 5000]) * si.K
 exponent = SI.h * SI.c / (wavelength * SI.kB * temperature)
 radiance = 2 * SI.h * SI.c**2 / (wavelength**5 * np.expm1(exponent))
 radiance = radiance.to('kW/sr/m2/nm')

{unitx-0.13.2 → unitx-0.13.4}/README.md

@@ -167,9 +167,9 @@ Use `.value` or `.value_in(unit)` at plotting and external-library boundaries.
 implicit unit removal. NumPy's type stubs do not describe every wrapped
 operation; see the [typing guide](https://github.com/DaitTHU/unitx/blob/main/docs/typing.md).
 
-The [physics notebooks](https://github.com/DaitTHU/unitx/blob/main/examples/README.md)
-cover blackbody radiation, damped motion, wave-packet spreading, attenuation,
-and measurement uncertainty.
+The [scientific examples](https://github.com/DaitTHU/unitx/blob/main/examples/README.md)
+cover reaction-rate fitting, blackbody radiation, damped motion, wave-packet
+spreading, attenuation, and measurement uncertainty.
 
 ## Blackbody radiation
 
@@ -185,7 +185,7 @@ from matplotlib import pyplot as plt
 from unitx.si import SI, si
 
 wavelength = np.linspace(0.01, 3, 100)[:, None] * si.um
-temperature = np.array([3000, 4000, 5000]) * si.K
+temperature = np.asarray([3000, 4000, 5000]) * si.K
 exponent = SI.h * SI.c / (wavelength * SI.kB * temperature)
 radiance = 2 * SI.h * SI.c**2 / (wavelength**5 * np.expm1(exponent))
 radiance = radiance.to('kW/sr/m2/nm')

{unitx-0.13.2 → unitx-0.13.4}/docs/README.md

@@ -16,9 +16,10 @@ reading about an older version.
 | Call unit-aware mathematical functions or read a clock | [Standard-library enhancements](stdlib.md) |
 | Calculate with arrays, masks, reductions and output buffers | [NumPy support](numpy.md) |
 | Format text or export LaTeX, HTML and siunitx | [Display and formatting](display.md) |
+| Save and restore scalar quantities as JSON-compatible records | [Scalar data exchange](serialization.md) |
 | Understand annotations and NumPy inference limits | [Typing](typing.md) |
 | Update code written for an earlier release | [Migration notes](migration.md) |
-| Run scientific examples | [Physics notebooks](../examples/README.md) |
+| Run scientific examples | [Scientific examples](../examples/README.md) |
 | Test or contribute a change | [Contributing](../CONTRIBUTING.md) |
 
 For a first read, follow units and quantities, then the catalogue. Read the

{unitx-0.13.2 → unitx-0.13.4}/docs/display.md

@@ -17,6 +17,26 @@ markup or raw TeX commands. Unicode symbols remain Unicode and require font
 support in the renderer. These strings are for presentation, not serialization.
 `repr()` and `Unit.expression()` keep their existing reconstruction contracts.
 
+An AffineQuantity in an anonymous zero-origin linear coordinate displays its
+complete difference Unit, including any extra scale and rational powers. The
+stored reading is unchanged. Named coordinates keep their own labels:
+
+```pycon
+>>> from unitx.unit import ScaledUnit
+>>> from unitx.factor import Factor
+>>> point = 3 @ ScaledUnit('m', scale=Factor(2))
+>>> str(point)
+'3⋅2⋅m'
+>>> format(point, '.2f')
+'3.00 (2⋅m)'
+>>> point.to_quantity('m').value
+Fraction(6, 1)
+
+```
+
+LaTeX, HTML and siunitx use the same structural unit rendering as a linear
+Quantity with that complete Unit; formatting never converts the reading.
+
 ## Quantity format syntax
 
 `format(q, 'numeric_spec;style')`, or `f'{q:numeric_spec;style}'`, selects:

unitx-0.13.4/docs/serialization.md

@@ -0,0 +1,225 @@
+# Scalar data exchange
+
+`unitx.serialization.to_dict()` returns a versioned record made of dictionaries,
+lists, strings, null and an integer format version. `from_dict()` restores it.
+Use Python's JSON functions, or another transport for the same data structure:
+
+```pycon
+>>> import json
+>>> from decimal import Decimal
+>>> from fractions import Fraction
+>>> from unitx import AffineQuantity, AffineUnit, Quantity, Unit
+>>> from unitx.serialization import from_dict, to_dict
+>>> original = Quantity(Fraction(1, 3), 'cm')
+>>> text = json.dumps(to_dict(original), allow_nan=False)
+>>> restored = from_dict(json.loads(text))
+>>> type(restored.value) is Fraction
+True
+>>> restored.value, restored.unit
+(Fraction(1, 3), Unit('cm'))
+>>> restored == original
+True
+
+```
+
+The module supports `Unit`, `ScaledUnit`, `AffineUnit`, scalar `Quantity` and
+scalar `AffineQuantity`. Import the two functions from `unitx.serialization`;
+they are not package-root exports. No optional dependency is required.
+
+## Stored numbers
+
+Magnitudes must be exact instances of Python `int`, `float`, `Fraction` or
+`Decimal`. Booleans, complex numbers, numeric subclasses, custom magnitudes,
+NumPy scalars and arrays are rejected with TypeError. A round trip preserves
+the stored magnitude's type and value without converting its unit.
+
+| Type tag | `value` field | Meaning |
+| --- | --- | --- |
+| `int` | A canonical decimal integer string | Retains integers beyond the exact range of a JSON consumer's floating-point numbers |
+| `fraction` | Two integer strings, `[numerator, denominator]` | Exact rational, with positive denominator |
+| `float` | `float.hex()` text | Exact finite binary value, including subnormals and signed zero; `inf`, `-inf` and `nan` are also supported |
+| `decimal` | Decimal text | Retains sign, coefficient, trailing zeros and exponent; infinities and NaNs are supported |
+
+Float NaNs preserve their category; NaN payload bits and sign are not part of
+the format. Decimal NaN payloads and signaling status are retained. Export
+and import do not round a Decimal magnitude in the active context. Invalid
+Decimal strings are rejected even when the caller disables InvalidOperation
+traps, without setting flags in the caller's context.
+
+All numerical data except the format version use strings. Consequently strict
+JSON encoding with `allow_nan=False` works even for nonfinite magnitudes.
+Python's normal integer-string conversion and Decimal representation limits
+still apply.
+
+## Units and points
+
+The format preserves the formal product, including prefixes and rational
+exponents. Equal physical scale does not merge distinct units such as Hz and
+Bq, and `km/m` retains its nontrivial dimensionless scale. A ScaledUnit stores
+its additional Factor separately, including when that Factor is one:
+
+```pycon
+>>> from unitx import pi
+>>> from unitx.unit import ScaledUnit
+>>> scaled = ScaledUnit('m', pi ** Fraction(1, 3))
+>>> rebuilt = from_dict(json.loads(json.dumps(to_dict(scaled))))
+>>> type(rebuilt) is ScaledUnit and rebuilt.scale == scaled.scale
+True
+>>> rebuilt**3 == scaled**3
+True
+
+```
+
+An AffineUnit stores its physical origin, difference unit and logarithmic kind.
+Registered coordinates also retain their canonical registered symbol;
+anonymous coordinates remain anonymous. Points stay AffineQuantity objects:
+
+```pycon
+>>> point = AffineQuantity(Decimal('20.00'), 'degC')
+>>> rebuilt = from_dict(json.loads(json.dumps(to_dict(point))))
+>>> type(rebuilt) is AffineQuantity and rebuilt.unit == point.unit
+True
+>>> rebuilt.value.as_tuple() == point.value.as_tuple()
+True
+>>> epoch = AffineUnit(Quantity(946684800, 's'), delta_unit='s')
+>>> custom = AffineQuantity(Fraction(1, 2), epoch)
+>>> from_dict(to_dict(custom)).unit == epoch
+True
+
+```
+
+This preserves the existing model's information. It does not add clock identity,
+timezone or source labels to time points. Point arithmetic and the existing
+hashability rules are unchanged.
+
+## Registry requirements
+
+Import resolves spellings against the receiving process's existing registry.
+Register custom units explicitly during application initialization before
+decoding records that refer to them. Unknown spellings raise SerializationError
+with the original UnitSymbolError retained as `__cause__`.
+Decoding never registers or replaces definitions, and neither function changes
+the input object or record.
+
+A linear unit record contains its canonical formal identity and its combined
+dimension, SI Factor and logarithmic degree. Import checks these against the
+resolved unit. A registered coordinate must also match the saved physical
+origin, its formal reference and difference units, and logarithmic kind.
+Conflicts raise SerializationError rather than silently changing the result.
+
+These checks describe the resulting unit, not a complete registry snapshot.
+They do not compare names, aliases, prefix policies or each individual unit's
+conversion metadata when changes cancel within a product. The receiving
+application remains responsible for compatible unit definitions. Factor checks
+compare exact formal state: a changed symbolic approximation or a different
+unresolved-integer decomposition can cause rejection even if physical values
+are approximately equal. No floating-point tolerance is used to infer equality.
+
+## Version 1 record format
+
+Only the outermost object has `"version": 1`; every object record has a `type`.
+For example, an integer length is represented as:
+
+```json
+{
+  "version": 1,
+  "type": "quantity",
+  "value": {"type": "int", "value": "3"},
+  "unit": {
+    "type": "unit",
+    "expression": "m",
+    "identity": [["", "m", "1", "1"]],
+    "dimension": [["0", "1"], ["1", "1"], ["0", "1"], ["0", "1"], ["0", "1"], ["0", "1"], ["0", "1"]],
+    "factor": [],
+    "log_degree": ["0", "1"]
+  }
+}
+```
+
+The object records have these exact fields:
+
+| `type` | Fields in addition to `type` |
+| --- | --- |
+| `quantity`, `affine_quantity` | `value` scalar record, `unit` linear/affine unit record respectively |
+| `unit` | `expression`, `identity`, `dimension`, `factor`, `log_degree` |
+| `scaled_unit` | The unit fields plus `scale`, a Factor component list |
+| `affine_unit` | `origin` linear Quantity record, `delta_unit` linear unit record, `kind` null/`power`/`amplitude`, `symbol` canonical registered string or null |
+
+`identity` is a sorted list of `[prefix_symbol, unprefixed_symbol, numerator,
+denominator]` terms; the last two strings encode the nonzero exponent.
+`dimension` lists seven rational pairs in T, L, M, I, Theta, N, J order.
+`log_degree` is another rational pair.
+
+Factor component lists preserve the formal integer/symbolic bases and rational
+exponents. The empty list represents one. Each component has an `exponent`
+pair and one of these base descriptions:
+
+| Component `type` | Other fields |
+| --- | --- |
+| `prime` | `value`: prime integer string |
+| `symbolic` | `symbol`: literal label, `value`: positive finite float.hex() approximation |
+| `unfactored` | `value`: unresolved integer string, `limit`: stored factorization-limit integer string |
+
+Symbolic labels are reconstructed as SymbolicConstant objects, never evaluated
+as code. Their mathematical construction requirements remain the caller's
+responsibility. Unresolved bases keep the existing incomplete-factorization
+limitations and emit IncompleteFactorWarning on reconstruction.
+
+Unknown versions, tags, missing or extra fields and invalid nested records are
+rejected. The version is independent of the package release number; future
+incompatible record changes require a new format version. This is a data
+format, not a Python class/subclass reconstruction protocol. No `eval`, dynamic
+class imports, JSON encoder subclasses, file I/O or configurable codec registry
+are involved. Applications parsing external input should apply their own size
+and resource limits.
+
+## Errors
+
+Import the error classes from `unitx.exceptions`. The public boundaries are:
+
+| Operation and failure | Exception |
+| --- | --- |
+| `to_dict()` receives an unsupported object or magnitude | TypeError |
+| `from_dict()` receives a non-dictionary top-level input | TypeError |
+| A record specifies an unsupported integer format version | VersionError |
+| A record has no version or the version is not an integer | SerializationError |
+| Invalid fields, missing definitions, conflicting unit meanings or failed reconstruction | SerializationError |
+
+VersionError and SerializationError both inherit UnitxError and ValueError.
+They are independent classes: VersionError is available for explicit version
+checks elsewhere in unitx as well. It currently describes the record format
+version, not the installed package version. Catch the two classes separately
+for different recovery actions, or catch UnitxError for both:
+
+```pycon
+>>> from unitx.exceptions import SerializationError, UnitxError, VersionError
+>>> try:
+...     from_dict({'version': 2})
+... except VersionError:
+...     print('Unsupported record version')
+Unsupported record version
+>>> try:
+...     from_dict({'version': 1, 'type': 'unknown'})
+... except SerializationError:
+...     print('Invalid record')
+Invalid record
+
+```
+
+Underlying numeric, parsing and coordinate exceptions, including
+UnitSymbolError, UnitSyntaxError and DimensionError, are retained as
+`error.__cause__` when wrapped. Explicit record-validation errors use
+SerializationError directly. Exceptions outside the expected validation
+families, such as RuntimeError, are not wrapped.
+
+The return type of `from_dict()` is a union of the supported object classes;
+use `isinstance` when code requires a specific class. Its scalar magnitude type
+is the supported union, since arbitrary input data cannot statically determine
+the original numerical type.
+
+Numerical encodings follow the Python documentation for
+[float hexadecimal conversion](https://docs.python.org/3/library/stdtypes.html#float.hex),
+[Decimal construction](https://docs.python.org/3/library/decimal.html#decimal.Decimal)
+and [JSON data exchange](https://docs.python.org/3/library/json.html).
+
+[Documentation index](README.md) · [Scalar behavior](scalars.md) · [Custom units](custom-units.md)

{unitx-0.13.2 → unitx-0.13.4}/docs/typing.md

@@ -26,6 +26,11 @@ for its array overloads. `unitx.time` clocks return `AffineQuantity[int]`;
 duration adapters use ordinary Quantity objects. `time.from_datetime()` returns
 `AffineQuantity[int]`; `time.to_datetime()` returns an aware datetime.
 
+`unitx.serialization.from_dict()` returns a union of the supported unit and
+scalar quantity classes. Use `isinstance` to narrow it. The magnitude type is
+`int | float | Fraction | Decimal`; the input record determines its runtime type.
+See [scalar data exchange](serialization.md).
+
 A signature such as `Quantity[float]` does not require metres rather than
 seconds. An `Annotated` label alone does not teach a type checker dimensional
 algebra. unitx does not currently supply dimension-parameterized quantities

{unitx-0.13.2 → unitx-0.13.4}/examples/README.md

@@ -1,4 +1,4 @@
-# Physics notebooks
+# Scientific examples
 
 These notebooks use unitx for dimensional calculations and NumPy for numerical
 work. Each contains a model, assumptions, plots, and numerical checks. The
@@ -11,6 +11,7 @@ material parameters and measurement draws are illustrative, not experimental dat
 | [Gaussian wave packet](gaussian_wavepacket.ipynb) | Free electron propagation and uncertainty | Probability-density units, quantum constants, unit-aware integration |
 | [Optical attenuation](optical_attenuation.ipynb) | Transmission through absorbing layers | prod/multiply.reduce, input masks, Quantity initial, fixed-unit out |
 | [Pendulum uncertainty](pendulum_uncertainty.ipynb) | Correlated input uncertainties and Monte Carlo propagation | Mean/std/var units, mixed measurement units, explicit quantiles |
+| [Arrhenius fit](arrhenius_fit.ipynb) | Estimate activation energy from synthetic reaction rates | Absolute temperatures, regression boundary, parameter units and model-based standard errors |
 
 ## Run
 
@@ -22,8 +23,8 @@ python -m pip install -e '.[numpy]' matplotlib jupyterlab
 jupyter lab examples/
 ```
 
-Open a notebook and run all cells from the beginning. These notebooks require
-unitx 0.8.4 or newer for product reductions and unit-aware integration.
+Open a notebook and run all cells from the beginning. Use the current checkout
+so that all demonstrated APIs are available.
 The examples do not download datasets or write files. Keep physical quantities in calculations;
 plot their `.value` and derive labels from their `.unit`. Convert only to choose
 a useful display scale or to align units at a numerical boundary. Quantiles use

unitx-0.13.4/examples/arrhenius_fit.ipynb

@@ -0,0 +1,236 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "arrhenius_fit-00",
+   "metadata": {},
+   "source": [
+    "# Estimate an activation energy from reaction-rate data\n",
+    "\n",
+    "Fit a temperature-dependent first-order rate constant, estimate its molar\n",
+    "activation energy, and predict a rate and half-life inside the observed interval.\n",
+    "Run the setup in [examples/README.md](README.md) first.\n",
+    "\n",
+    "The [IUPAC Arrhenius equation](https://goldbook.iupac.org/terms/view/A00446) is\n",
+    "$$\n",
+    "k(T)=A\\exp\\!\\left(-\\frac{E_a}{RT}\\right).\n",
+    "$$\n",
+    "Here $T$ is absolute temperature, $R$ is the molar gas constant, $E_a$ is the\n",
+    "molar activation energy, and $A$ has the same units as the rate constant $k$.\n",
+    "We assume $E_a$ and $A$ remain constant over this temperature interval.\n",
+    "\n",
+    "These are **synthetic data**, not measurements of a named reaction. They were\n",
+    "generated with $E_a=52\\,\\mathrm{kJ/mol}$ and $A=2\\times10^7\\,\\mathrm{s^{-1}}$,\n",
+    "with fixed log-rate perturbations $[0.020,-0.025,0.010,-0.015,0.025,-0.015]$,\n",
+    "then rounded. The known generating parameters provide a numerical check;\n",
+    "they do not validate the model for a real reaction."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "id": "arrhenius_fit-01",
+   "metadata": {},
+   "source": [
+    "import numpy as np\n",
+    "from matplotlib import pyplot as plt\n",
+    "\n",
+    "from unitx import math\n",
+    "from unitx.si import SI, si\n",
+    "\n",
+    "# Recorded Celsius temperatures are points, not temperature differences.\n",
+    "temperature_readings = np.asarray([15, 25, 35, 45, 55, 65]) @ si.degC\n",
+    "temperature = temperature_readings.to_quantity(si.K)\n",
+    "rate = np.asarray([0.458888, 0.908486, 1.858462, 3.430419, 6.499562, 10.972105]) / si.min\n",
+    "reference_rate = 1 / si.min"
+   ],
+   "execution_count": null,
+   "outputs": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "arrhenius_fit-02",
+   "metadata": {},
+   "source": [
+    "## Fit at an explicit numerical boundary\n",
+    "\n",
+    "Normalize the rate before taking its logarithm:\n",
+    "$$\n",
+    "x=\\frac{1}{T},\\qquad y=\\ln\\!\\left(\\frac{k}{k_{\\rm ref}}\\right),\\qquad\n",
+    " y=mx+b.\n",
+    "$$\n",
+    "Thus $m=-E_a/R$ has unit K, $b=\\ln(A/k_{\\rm ref})$ is dimensionless, and\n",
+    "$$\n",
+    "E_a=-mR,\\qquad A=k_{\\rm ref}\\exp(b).\n",
+    "$$\n",
+    "\n",
+    "The temperatures have already been converted to K, so `(1 / temperature).value`\n",
+    "contains inverse temperatures in K$^{-1}$. `np.polyfit` receives these numerical\n",
+    "values and the dimensionless log rates. Attach K to its fitted slope before\n",
+    "continuing the physical calculation. Keep the fitted scalars in NumPy's\n",
+    "floating-point domain; unitx's NumPy adapter evaluates catalogue constants in\n",
+    "that domain without changing `SI.R`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "id": "arrhenius_fit-03",
+   "metadata": {},
+   "source": [
+    "log_rate = math.log(rate / reference_rate)\n",
+    "coefficients, covariance = np.polyfit(\n",
+    "    (1 / temperature).value,\n",
+    "    log_rate.value,\n",
+    "    deg=1,\n",
+    "    cov=True,\n",
+    ")\n",
+    "slope = np.float64(coefficients[0]) * si.K\n",
+    "slope_standard_error = np.sqrt(np.float64(covariance[0, 0])) * slope.unit\n",
+    "activation_energy = (-slope * SI.R).to('kJ/mol')\n",
+    "energy_standard_error = (slope_standard_error * SI.R).to(activation_energy.unit)\n",
+    "prefactor = (reference_rate * math.exp(np.float64(coefficients[1]))).to('s^-1')\n",
+    "\n",
+    "print(f'Activation energy: {activation_energy:.3f}')\n",
+    "print(f'Standard error from residual scatter: {energy_standard_error:.3f}')\n",
+    "print(f'Prefactor: {prefactor:.4g}')"
+   ],
+   "execution_count": null,
+   "outputs": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "arrhenius_fit-04",
+   "metadata": {},
+   "source": [
+    "## Interpret and plot the fit\n",
+    "\n",
+    "Ordinary least squares here assumes negligible temperature error and independent\n",
+    "log-rate errors with a common variance. The covariance returned by `polyfit`\n",
+    "estimates that variance from residual scatter, using $6-2=4$ residual degrees\n",
+    "of freedom. Therefore $R\\sqrt{\\operatorname{Cov}_{00}}$ is a model-based standard\n",
+    "error for $E_a$, not a confidence interval or a measure of systematic error.\n",
+    "The estimates of $A$ and $E_a$ are correlated; no prediction uncertainty band is\n",
+    "computed here.\n",
+    "\n",
+    "Expect an activation energy near $51.9\\,\\mathrm{kJ/mol}$ with standard error\n",
+    "near $0.45\\,\\mathrm{kJ/mol}$. Plot a dimensionless inverse-temperature coordinate,\n",
+    "$1000\\,\\mathrm{K}/T$. The label is derived from the same scale used in the plot.\n",
+    "The curve spans only the observed temperature range."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "id": "arrhenius_fit-05",
+   "metadata": {},
+   "source": [
+    "curve_temperature = (\n",
+    "    np.linspace(temperature.value.min(), temperature.value.max(), 200, dtype=np.float64) * si.K\n",
+    ")\n",
+    "curve_rate = prefactor * math.exp(-activation_energy / (SI.R * curve_temperature))\n",
+    "temperature_scale = 1000 * si.K\n",
+    "plot_temperature = temperature_scale / temperature\n",
+    "curve_coordinate = temperature_scale / curve_temperature\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(6, 4), layout='constrained')\n",
+    "ax.scatter(plot_temperature.value, log_rate.value, label='Synthetic observations')\n",
+    "ax.plot(\n",
+    "    curve_coordinate.value,\n",
+    "    math.log(curve_rate / reference_rate).value,\n",
+    "    label='Arrhenius fit',\n",
+    ")\n",
+    "ax.set(\n",
+    "    xlabel=f'{temperature_scale} / T',\n",
+    "    ylabel='ln(k / k_ref)',\n",
+    "    title='Activation-energy fit',\n",
+    ")\n",
+    "ax.legend()\n",
+    "ax.grid(True, alpha=0.25)\n",
+    "plt.show()"
+   ],
+   "execution_count": null,
+   "outputs": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "arrhenius_fit-06",
+   "metadata": {},
+   "source": [
+    "## Predict inside the observed interval\n",
+    "\n",
+    "At a fixed temperature, a first-order decay obeys $c(t)=c(0)\\exp(-kt)$, hence\n",
+    "$$\n",
+    "t_{1/2}=\\frac{\\ln 2}{k}.\n",
+    "$$\n",
+    "Use the fitted parameters to predict at $40\\,{}^\\circ\\mathrm C$, inside the\n",
+    "15--65 $^\\circ\\mathrm C$ data interval. Convert the temperature point to a Kelvin\n",
+    "quantity before evaluating the exponent. This is a prediction under the stated\n",
+    "Arrhenius and first-order models, with no allowance for model error."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "id": "arrhenius_fit-07",
+   "metadata": {},
+   "source": [
+    "prediction_reading = np.float64(40) @ si.degC\n",
+    "prediction_temperature = prediction_reading.to_quantity(si.K)\n",
+    "predicted_rate = prefactor * math.exp(-activation_energy / (SI.R * prediction_temperature))\n",
+    "half_life = (math.log(2) / predicted_rate).to(si.s)\n",
+    "\n",
+    "print(f'Predicted rate at {prediction_reading}: {predicted_rate.to(rate.unit):.4f}')\n",
+    "print(f'First-order half-life: {half_life:.2f}')"
+   ],
+   "execution_count": null,
+   "outputs": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "arrhenius_fit-08",
+   "metadata": {},
+   "source": [
+    "## Numerical checks\n",
+    "\n",
+    "Compare the estimates with the known generating parameters. Also check that\n",
+    "converting the input rate storage unit does not alter the normalized fit data,\n",
+    "and that the reconstructed physical model agrees with the fitted straight line.\n",
+    "The half-life identity checks the prediction's time/rate units together."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "id": "arrhenius_fit-09",
+   "metadata": {},
+   "source": [
+    "assert activation_energy.isclose(52 * si.kJ / si.mol, rel_tol=0.02)\n",
+    "assert prefactor.isclose(2e7 / si.s, rel_tol=0.1)\n",
+    "assert (predicted_rate * half_life).isclose(math.log(2), rel_tol=1e-12)\n",
+    "np.testing.assert_allclose(\n",
+    "    math.log(rate.to('s^-1') / reference_rate).value,\n",
+    "    log_rate.value,\n",
+    "    rtol=1e-12,\n",
+    "    atol=1e-12,\n",
+    ")\n",
+    "fitted_rate = prefactor * math.exp(-activation_energy / (SI.R * temperature))\n",
+    "np.testing.assert_allclose(\n",
+    "    math.log(fitted_rate / reference_rate).value,\n",
+    "    coefficients[0] * (1 / temperature).value + coefficients[1],\n",
+    "    rtol=1e-12,\n",
+    "    atol=1e-12,\n",
+    ")"
+   ],
+   "execution_count": null,
+   "outputs": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

{unitx-0.13.2 → unitx-0.13.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = 'hatchling.build'
 
 [project]
 name = 'unitx'
-version = '0.13.2'
+version = '0.13.4'
 description = 'Physical units, quantities, and unit conversion with exact unit algebra, type hints, and NumPy integration.'
 readme = 'README.md'
 requires-python = '>=3.12'

{unitx-0.13.2 → unitx-0.13.4}/pyrightconfig.json

@@ -3,6 +3,7 @@
     "src/unitx/_display.py",
     "src/unitx/math.py",
     "src/unitx/time.py",
+    "src/unitx/serialization.py",
     "src/unitx/affineunit.py",
     "src/unitx/affinequantity.py",
     "src/unitx/_conversion.py",
@@ -18,6 +19,7 @@
     "tests/typing"
   ],
   "strict": [
+    "src/unitx/serialization.py",
     "src/unitx/quantity.py",
     "tests/typing",
     "tests/numpy_typing",