quantized-lab 0.8.0__py3-none-any.whl

quantized/calc/fit_findxy.py

@@ -0,0 +1,80 @@
+"""Inverse-evaluate a fitted curve: X -> Y, and Y -> X (ALL crossings). MAIN #15.
+
+Pure calc layer. ``find_y`` is a direct model evaluation at one point.
+``find_x`` samples ``model_fcn(x, params)`` on a dense grid over
+``[x_min, x_max]``, brackets every sign change (or exact zero) of
+``y(x) - target``, and refines each bracket with ``scipy.optimize.brentq`` --
+so a non-monotonic curve (e.g. a Gaussian) reports every crossing, not just
+the first. ``model_fcn`` is a plain ``fcn(x, p) -> y`` callable, the same
+shape used by both ``calc.fit_models.evaluate`` (registry models) and
+``calc.fit_equation.equation_model`` (saved custom equations) -- so this
+module works identically for either, and the route layer only has to pick
+which one produced the callable.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Sequence
+
+import numpy as np
+from numpy.typing import NDArray
+from scipy.optimize import brentq
+
+__all__ = ["ModelFn", "find_x", "find_y"]
+
+ModelFn = Callable[[NDArray[np.float64], NDArray[np.float64]], NDArray[np.float64]]
+
+
+def find_y(fcn: ModelFn, params: Sequence[float], x: float) -> float:
+    """Evaluate the fitted model at a single x."""
+    p = np.asarray(params, dtype=float)
+    y = fcn(np.asarray([x], dtype=float), p)
+    return float(np.asarray(y, dtype=float).ravel()[0])
+
+
+def find_x(
+    fcn: ModelFn,
+    params: Sequence[float],
+    target: float,
+    x_min: float,
+    x_max: float,
+    *,
+    grid_points: int = 2000,
+) -> list[float]:
+    """All x in [x_min, x_max] where ``fcn(x, params) == target``.
+
+    Returns crossings in ascending order; an empty list (not an error) when
+    the curve never reaches ``target`` over the range -- e.g. a monotonic
+    curve entirely above or below it.
+    """
+    if x_max <= x_min:
+        raise ValueError("x_max must be greater than x_min")
+    if grid_points < 2:
+        raise ValueError("grid_points must be at least 2")
+    p = np.asarray(params, dtype=float)
+    xs = np.linspace(x_min, x_max, grid_points)
+    ys = np.asarray(fcn(xs, p), dtype=float).ravel()
+    g = ys - target
+
+    def g_at(xv: float) -> float:
+        yv = fcn(np.asarray([xv], dtype=float), p)
+        return float(np.asarray(yv, dtype=float).ravel()[0]) - target
+
+    # Grid spacing sets the merge tolerance below: a root that lands exactly
+    # on a grid node is found once via the `g0 == 0` branch, so the following
+    # bracket (whose left endpoint is that same node) must not re-report it.
+    dx_tol = (x_max - x_min) / (grid_points - 1) * 1e-6
+    roots: list[float] = []
+    for i in range(grid_points - 1):
+        g0, g1 = float(g[i]), float(g[i + 1])
+        if not (np.isfinite(g0) and np.isfinite(g1)):
+            continue  # degenerate model params (e.g. div-by-zero) -- skip
+        if g0 == 0.0:
+            if not roots or xs[i] - roots[-1] > dx_tol:
+                roots.append(float(xs[i]))
+            continue
+        if g0 * g1 < 0.0:
+            roots.append(brentq(g_at, float(xs[i]), float(xs[i + 1])))
+    if np.isfinite(g[-1]) and g[-1] == 0.0 and (not roots or xs[-1] - roots[-1] > dx_tol):
+        roots.append(float(xs[-1]))
+    return roots

quantized/calc/fit_models.py

@@ -0,0 +1,195 @@
+"""Curve-fit model library. Port of fitting.models (the model evaluators).
+
+Pure calc layer. Each model is ``f(x, p) -> y``; ``FIT_MODELS`` maps a model name
+to its evaluator plus metadata (p0 / lower / upper bounds / paramNames). Closed-
+form models live here; helper-based magnetic/thermal models (Langevin, Brillouin,
+Stoner-Wohlfarth, Debye, Einstein) are registered in ``fit_models_special``.
+"""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Callable
+from typing import Any
+
+import numpy as np
+from numpy.typing import ArrayLike, NDArray
+
+from .peakshapes import pseudo_voigt
+
+__all__ = ["FIT_MODELS", "evaluate", "model_names", "register_model", "unregister_model"]
+
+_INF = float("inf")
+_EPS = float(np.finfo(float).eps)
+_FWHM_PER_SIGMA = 2.0 * math.sqrt(2.0 * math.log(2.0))
+
+ModelFn = Callable[[NDArray[np.float64], NDArray[np.float64]], NDArray[np.float64]]
+
+FIT_MODELS: dict[str, dict[str, Any]] = {}
+
+
+def register_model(
+    name: str, category: str, fcn: ModelFn, param_names: list[str],
+    p0: list[float], lb: list[float], ub: list[float],
+) -> None:
+    FIT_MODELS[name] = {
+        "fcn": fcn, "category": category, "paramNames": param_names,
+        "p0": p0, "lb": lb, "ub": ub, "nParams": len(p0),
+    }
+
+
+def unregister_model(name: str) -> None:
+    """Remove a registered model (used to unload plugin-contributed models)."""
+    FIT_MODELS.pop(name, None)
+
+
+def evaluate(name: str, x: ArrayLike, p: ArrayLike) -> NDArray[np.float64]:
+    """Evaluate model ``name`` at points ``x`` with parameters ``p``."""
+    fcn: ModelFn = FIT_MODELS[name]["fcn"]
+    return np.asarray(fcn(np.asarray(x, dtype=float), np.asarray(p, dtype=float)), dtype=float)
+
+
+def model_names() -> list[str]:
+    return list(FIT_MODELS)
+
+
+# ── Linear / polynomial ─────────────────────────────────────────────────
+def _linear(x: NDArray[np.float64], p: NDArray[np.float64]) -> NDArray[np.float64]:
+    return np.asarray(p[0] * x + p[1], dtype=float)
+
+
+def _quadratic(x: NDArray[np.float64], p: NDArray[np.float64]) -> NDArray[np.float64]:
+    return np.asarray(p[0] * x**2 + p[1] * x + p[2], dtype=float)
+
+
+def _cubic(x: NDArray[np.float64], p: NDArray[np.float64]) -> NDArray[np.float64]:
+    return np.asarray(p[0] * x**3 + p[1] * x**2 + p[2] * x + p[3], dtype=float)
+
+
+def _poly4(x: NDArray[np.float64], p: NDArray[np.float64]) -> NDArray[np.float64]:
+    return np.asarray(p[0] * x**4 + p[1] * x**3 + p[2] * x**2 + p[3] * x + p[4], dtype=float)
+
+
+# ── Decay / growth ──────────────────────────────────────────────────────
+def _exp_decay(x: NDArray[np.float64], p: NDArray[np.float64]) -> NDArray[np.float64]:
+    return np.asarray(p[0] * np.exp(-x / p[1]) + p[2], dtype=float)
+
+
+def _stretched_exp(x: NDArray[np.float64], p: NDArray[np.float64]) -> NDArray[np.float64]:
+    return np.asarray(p[0] * np.exp(-((x / p[1]) ** p[2])) + p[3], dtype=float)
+
+
+def _biexp_decay(x: NDArray[np.float64], p: NDArray[np.float64]) -> NDArray[np.float64]:
+    return np.asarray(p[0] * np.exp(-x / p[1]) + p[2] * np.exp(-x / p[3]) + p[4], dtype=float)
+
+
+def _exp_growth(x: NDArray[np.float64], p: NDArray[np.float64]) -> NDArray[np.float64]:
+    return np.asarray(p[0] * np.exp(x / p[1]) + p[2], dtype=float)
+
+
+def _sat_growth(x: NDArray[np.float64], p: NDArray[np.float64]) -> NDArray[np.float64]:
+    return np.asarray(p[0] * (1 - np.exp(-x / p[1])) + p[2], dtype=float)
+
+
+# ── Peak shapes ─────────────────────────────────────────────────────────
+def _gaussian(x: NDArray[np.float64], p: NDArray[np.float64]) -> NDArray[np.float64]:
+    return np.asarray(p[0] * np.exp(-((x - p[1]) ** 2) / (2 * p[2] ** 2)), dtype=float)
+
+
+def _lorentzian(x: NDArray[np.float64], p: NDArray[np.float64]) -> NDArray[np.float64]:
+    return np.asarray(p[0] / (1 + ((x - p[1]) / p[2]) ** 2), dtype=float)
+
+
+def _pseudo_voigt(x: NDArray[np.float64], p: NDArray[np.float64]) -> NDArray[np.float64]:
+    return pseudo_voigt(x, float(p[1]), _FWHM_PER_SIGMA * float(p[2]), float(p[0]), float(p[3]))
+
+
+# ── Power / sigmoid / misc ──────────────────────────────────────────────
+def _power_law(x: NDArray[np.float64], p: NDArray[np.float64]) -> NDArray[np.float64]:
+    return np.asarray(p[0] * np.abs(x) ** p[1] + p[2], dtype=float)
+
+
+def _allometric(x: NDArray[np.float64], p: NDArray[np.float64]) -> NDArray[np.float64]:
+    return np.asarray(p[0] * np.abs(x) ** p[1], dtype=float)
+
+
+def _logistic(x: NDArray[np.float64], p: NDArray[np.float64]) -> NDArray[np.float64]:
+    return np.asarray(p[0] / (1 + np.exp(-p[1] * (x - p[2]))) + p[3], dtype=float)
+
+
+def _tanh(x: NDArray[np.float64], p: NDArray[np.float64]) -> NDArray[np.float64]:
+    return np.asarray(p[0] * np.tanh(p[1] * (x - p[2])) + p[3], dtype=float)
+
+
+def _curie_weiss(x: NDArray[np.float64], p: NDArray[np.float64]) -> NDArray[np.float64]:
+    return np.asarray(p[0] / (x - p[1]), dtype=float)
+
+
+def _bloch(x: NDArray[np.float64], p: NDArray[np.float64]) -> NDArray[np.float64]:
+    return np.asarray(p[0] * (1 - p[1] * x**1.5), dtype=float)
+
+
+def _arrhenius(x: NDArray[np.float64], p: NDArray[np.float64]) -> NDArray[np.float64]:
+    return np.asarray(p[0] * np.exp(-p[1] / x), dtype=float)
+
+
+def _vft(x: NDArray[np.float64], p: NDArray[np.float64]) -> NDArray[np.float64]:
+    return np.asarray(p[0] * np.exp(p[1] / (8.617e-5 * (x - p[2]))), dtype=float)
+
+
+def _langmuir(x: NDArray[np.float64], p: NDArray[np.float64]) -> NDArray[np.float64]:
+    return np.asarray(p[0] * x / (p[1] + x), dtype=float)
+
+
+def _logarithmic(x: NDArray[np.float64], p: NDArray[np.float64]) -> NDArray[np.float64]:
+    return np.asarray(p[0] * np.log(np.abs(x) + _EPS) + p[1], dtype=float)
+
+
+def _sqrt(x: NDArray[np.float64], p: NDArray[np.float64]) -> NDArray[np.float64]:
+    return np.asarray(p[0] * np.sqrt(np.abs(x)) + p[1], dtype=float)
+
+
+# ── Registry (closed-form models) ───────────────────────────────────────
+register_model("Linear", "Linear", _linear, ["m", "b"], [1, 0], [-_INF, -_INF], [_INF, _INF])
+register_model("Quadratic", "Linear", _quadratic, ["a", "b", "c"], [0, 1, 0],
+               [-_INF, -_INF, -_INF], [_INF, _INF, _INF])
+register_model("Cubic", "Linear", _cubic, ["a", "b", "c", "d"], [0, 0, 1, 0],
+               [-_INF] * 4, [_INF] * 4)
+register_model("Poly 4", "Linear", _poly4, ["a", "b", "c", "d", "e"], [0, 0, 0, 1, 0],
+               [-_INF] * 5, [_INF] * 5)
+register_model("Exponential Decay", "Decay", _exp_decay, ["A", "τ", "C"], [1, 1, 0],
+               [-_INF, 0, -_INF], [_INF, _INF, _INF])
+register_model("Stretched Exponential", "Decay", _stretched_exp, ["A", "τ", "β", "C"],
+               [1, 1, 0.5, 0], [-_INF, 0, 0, -_INF], [_INF, _INF, 2, _INF])
+register_model("Bi-exponential Decay", "Decay", _biexp_decay, ["A₁", "τ₁", "A₂", "τ₂", "C"],
+               [1, 1, 0.5, 5, 0], [-_INF, 0, -_INF, 0, -_INF], [_INF] * 5)
+register_model("Exponential Growth", "Growth", _exp_growth, ["A", "τ", "C"], [1, 1, 0],
+               [-_INF, 0, -_INF], [_INF, _INF, _INF])
+register_model("Saturation Growth", "Growth", _sat_growth, ["A", "τ", "C"], [1, 1, 0],
+               [-_INF, 0, -_INF], [_INF, _INF, _INF])
+register_model("Gaussian", "Peak", _gaussian, ["A", "μ", "σ"], [1, 0, 1],
+               [-_INF, -_INF, 0], [_INF, _INF, _INF])
+register_model("Lorentzian", "Peak", _lorentzian, ["A", "x₀", "γ"], [1, 0, 1],
+               [-_INF, -_INF, 0], [_INF, _INF, _INF])
+register_model("Pseudo-Voigt", "Peak", _pseudo_voigt, ["A", "x₀", "w", "η"], [1, 0, 1, 0.5],
+               [-_INF, -_INF, 0, 0], [_INF, _INF, _INF, 1])
+register_model("Power Law", "Power", _power_law, ["A", "n", "C"], [1, 1, 0],
+               [-_INF, -_INF, -_INF], [_INF, _INF, _INF])
+register_model("Allometric", "Power", _allometric, ["A", "n"], [1, 1], [-_INF, -_INF], [_INF, _INF])
+register_model("Logistic", "Sigmoid", _logistic, ["A", "k", "x₀", "C"], [1, 1, 0, 0],
+               [-_INF, 0, -_INF, -_INF], [_INF, _INF, _INF, _INF])
+register_model("Tanh", "Sigmoid", _tanh, ["A", "k", "x₀", "C"], [1, 1, 0, 0],
+               [-_INF, 0, -_INF, -_INF], [_INF, _INF, _INF, _INF])
+register_model("Curie-Weiss", "Magnetic", _curie_weiss, ["C", "θ"], [1, 0],
+               [0, -_INF], [_INF, _INF])
+register_model("Bloch T^3/2", "Magnetic", _bloch, ["M₀", "B"], [1, 1e-5], [0, 0], [_INF, _INF])
+register_model("Arrhenius", "Thermal", _arrhenius, ["A", "Eₐ/kB"], [1, 1000], [0, 0], [_INF, _INF])
+register_model("VFT", "Decay", _vft, ["τ₀", "Ea_eV", "T₀"], [1e-10, 0.05, 0], [0, 0, 0],
+               [1, 10, _INF])
+register_model("Langmuir", "Thermal", _langmuir, ["A", "K"], [1, 1], [0, 0], [_INF, _INF])
+register_model("Logarithmic", "Other", _logarithmic, ["a", "b"], [1, 0], [-_INF, -_INF],
+               [_INF, _INF])
+register_model("Square Root", "Other", _sqrt, ["a", "b"], [1, 0], [-_INF, -_INF], [_INF, _INF])
+
+# Register the helper-based magnetic/heat-capacity models (side-effect import).
+from . import fit_models_special  # noqa: E402, F401

quantized/calc/fit_models_special.py

@@ -0,0 +1,189 @@
+"""Helper-based fitting models (magnetic + heat-capacity). Extends fit_models.
+
+Imported for its registration side effects (see the import at the bottom of
+fit_models.py). Models: Langevin, Brillouin, Stoner-Wohlfarth, Debye, Einstein,
+Debye+Einstein. Port of the local helpers in fitting/models.m.
+
+The ``Hysteresis``-category models (tanh loop, two-component F+P, linear
+background, approach-to-saturation, Langevin+background) are a port of
+``+fitting/hysteresisModels.m`` — the catalogue the magnetometry hysteresis
+workshop offers for M-H loop fitting. They are empirical loop descriptors, not
+full Stoner-Wohlfarth astroid solutions (see Cullity & Graham, "Introduction to
+Magnetic Materials", 2nd ed., Ch. 7/9/11; Akulov, Z. Phys. 67, 794 (1931)).
+"""
+
+from __future__ import annotations
+
+import math
+
+import numpy as np
+from numpy.typing import NDArray
+from scipy.integrate import quad
+
+from .fit_models import register_model
+
+_INF = float("inf")
+_EPS = float(np.finfo(float).eps)
+_R = 8.314  # molar gas constant J/(mol·K)
+_DEBYE_LIMIT = 4 * math.pi**4 / 15  # integral_0^inf x^4 e^x/(e^x-1)^2 dx
+
+
+def _langevin(x: NDArray[np.float64], p: NDArray[np.float64]) -> NDArray[np.float64]:
+    a, b = float(p[0]), float(p[1])
+    u = x / max(b, _EPS)
+    out = np.empty_like(u, dtype=float)
+    small = np.abs(u) < 1e-4
+    out[small] = a * (u[small] / 3 - u[small] ** 3 / 45)
+    us = u[~small]
+    out[~small] = a * (1.0 / np.tanh(us) - 1.0 / us)
+    return np.asarray(out, dtype=float)
+
+
+def _brillouin_bj(j: float, y: NDArray[np.float64]) -> NDArray[np.float64]:
+    if j == 0:
+        return np.zeros_like(y, dtype=float)
+    a = (2 * j + 1) / (2 * j)
+    b = 1 / (2 * j)
+    out = np.empty_like(y, dtype=float)
+    small = np.abs(y) < 1e-6
+    out[small] = (j + 1) / (3 * j) * y[small]
+    yl = y[~small]
+    out[~small] = a / np.tanh(a * yl) - b / np.tanh(b * yl)
+    return out
+
+
+def _brillouin(x: NDArray[np.float64], p: NDArray[np.float64]) -> NDArray[np.float64]:
+    ms, j, g, t = float(p[0]), float(p[1]), float(p[2]), float(p[3])
+    y = g * 5.7884e-5 * j * x / (8.617e-5 * t)
+    return np.asarray(ms * _brillouin_bj(j, y), dtype=float)
+
+
+def _stoner_wohlfarth(x: NDArray[np.float64], p: NDArray[np.float64]) -> NDArray[np.float64]:
+    ms, hc = float(p[0]), float(p[1])
+    hk = max(float(p[2]), _EPS)
+    heff = x - np.sign(x) * hc
+    return np.asarray(ms * np.tanh(heff / hk), dtype=float)
+
+
+def _debye_integrand(t: float) -> float:
+    et = math.exp(t)
+    return t**4 * et / max((et - 1) ** 2, _EPS)
+
+
+def _debye_integral(u: float) -> float:
+    if u > 30:
+        return _DEBYE_LIMIT
+    if u < 1e-4:
+        return u**3 / 3
+    val, _ = quad(_debye_integrand, 0.0, u, epsrel=1e-6, epsabs=1e-10)
+    return float(val)
+
+
+def _debye(x: NDArray[np.float64], p: NDArray[np.float64]) -> NDArray[np.float64]:
+    gamma, theta, n = float(p[0]), max(float(p[1]), 1.0), max(float(p[2]), 0.0)
+    t = np.asarray(x, dtype=float).ravel()
+    out = np.empty(t.size)
+    for k in range(t.size):
+        tk = max(float(t[k]), 0.01)
+        u = theta / tk
+        c_lat = 9 * _R * (1 / u) ** 3 * _debye_integral(u)
+        out[k] = gamma * tk + n * c_lat * 1000
+    return out
+
+
+def _einstein_lattice(theta: float, tk: float) -> float:
+    u = theta / tk
+    eu = math.exp(min(u, 500))
+    return 3 * _R * u**2 * eu / max((eu - 1) ** 2, _EPS)
+
+
+def _einstein(x: NDArray[np.float64], p: NDArray[np.float64]) -> NDArray[np.float64]:
+    gamma, theta, n = float(p[0]), max(float(p[1]), 1.0), max(float(p[2]), 0.0)
+    t = np.asarray(x, dtype=float).ravel()
+    out = np.empty(t.size)
+    for k in range(t.size):
+        tk = max(float(t[k]), 0.01)
+        out[k] = gamma * tk + n * _einstein_lattice(theta, tk) * 1000
+    return out
+
+
+def _debye_einstein(x: NDArray[np.float64], p: NDArray[np.float64]) -> NDArray[np.float64]:
+    gamma = float(p[0])
+    theta_d, n_d = max(float(p[1]), 1.0), max(float(p[2]), 0.0)
+    theta_e, n_e = max(float(p[3]), 1.0), max(float(p[4]), 0.0)
+    t = np.asarray(x, dtype=float).ravel()
+    out = np.empty(t.size)
+    for k in range(t.size):
+        tk = max(float(t[k]), 0.01)
+        c_d = 9 * _R * (1 / (theta_d / tk)) ** 3 * _debye_integral(theta_d / tk)
+        c_e = _einstein_lattice(theta_e, tk)
+        out[k] = gamma * tk + (n_d * c_d + n_e * c_e) * 1000
+    return out
+
+
+# ── Hysteresis (magnetic M-H loop descriptors) ──────────────────────────
+def _tanh_hysteresis(x: NDArray[np.float64], p: NDArray[np.float64]) -> NDArray[np.float64]:
+    """M = Ms·tanh((H - Hc)/Hw). Soft-ferromagnet loop. p = [Ms, Hc, Hw]."""
+    ms, hc, hw = float(p[0]), float(p[1]), max(abs(float(p[2])), _EPS)
+    return np.asarray(ms * np.tanh((x - hc) / hw), dtype=float)
+
+
+def _two_component(x: NDArray[np.float64], p: NDArray[np.float64]) -> NDArray[np.float64]:
+    """M = Ms·tanh((H - Hc)/Hw) + χ·H. Ferromagnetic loop + linear (para) BG.
+
+    p = [Ms, Hc, Hw, χ].
+    """
+    ms, hc, hw, chi = float(p[0]), float(p[1]), max(abs(float(p[2])), _EPS), float(p[3])
+    return np.asarray(ms * np.tanh((x - hc) / hw) + chi * x, dtype=float)
+
+
+def _linear_background(x: NDArray[np.float64], p: NDArray[np.float64]) -> NDArray[np.float64]:
+    """M = χ·H + offset. Pure linear (dia/paramagnetic) background. p = [χ, offset]."""
+    return np.asarray(float(p[0]) * x + float(p[1]), dtype=float)
+
+
+def _approach_saturation(x: NDArray[np.float64], p: NDArray[np.float64]) -> NDArray[np.float64]:
+    """M = Ms(1 - a/|H| - b/H²) + χ·H. High-field Akulov expansion. p = [Ms, a, b, χ]."""
+    ms, a, b, chi = float(p[0]), float(p[1]), float(p[2]), float(p[3])
+    xv = np.asarray(x, dtype=float)
+    return np.asarray(
+        ms * (1.0 - a / (np.abs(xv) + _EPS) - b / (xv**2 + _EPS)) + chi * xv, dtype=float
+    )
+
+
+def _langevin_bg(x: NDArray[np.float64], p: NDArray[np.float64]) -> NDArray[np.float64]:
+    """M = Ms·L(αH) + χ·H, L(u) = coth(u) - 1/u. Superparamagnet + BG. p = [Ms, α, χ]."""
+    ms, alpha, chi = float(p[0]), float(p[1]), float(p[2])
+    u = alpha * np.asarray(x, dtype=float)
+    out = np.empty_like(u, dtype=float)
+    small = np.abs(u) < 1e-4
+    out[small] = ms * (u[small] / 3.0 - u[small] ** 3 / 45.0)
+    us = u[~small]
+    out[~small] = ms * (1.0 / np.tanh(us) - 1.0 / us)
+    return np.asarray(out + chi * np.asarray(x, dtype=float), dtype=float)
+
+
+register_model("Tanh Hysteresis", "Hysteresis", _tanh_hysteresis, ["Ms", "Hc", "Hw"],
+               [1e-3, 100, 200], [0, -_INF, 0], [_INF, _INF, _INF])
+register_model("Two-Component (F+P)", "Hysteresis", _two_component, ["Ms", "Hc", "Hw", "χ"],
+               [1e-3, 100, 200, 0], [0, -_INF, 0, -_INF], [_INF, _INF, _INF, _INF])
+register_model("Linear Background", "Hysteresis", _linear_background, ["χ", "offset"],
+               [1e-7, 0], [-_INF, -_INF], [_INF, _INF])
+register_model("Approach to Saturation", "Hysteresis", _approach_saturation,
+               ["Ms", "a", "b", "χ"], [1e-3, 1, 1, 0], [0, 0, 0, -_INF],
+               [_INF, _INF, _INF, _INF])
+register_model("Langevin + Background", "Hysteresis", _langevin_bg, ["Ms", "μ/kT", "χ"],
+               [1e-3, 1e-3, 0], [0, 0, -_INF], [_INF, _INF, _INF])
+
+register_model("Langevin", "Magnetic", _langevin, ["A", "B"], [1, 1], [0, 0], [_INF, _INF])
+register_model("Brillouin", "Magnetic", _brillouin, ["Ms", "J", "g", "T"], [1, 0.5, 2, 300],
+               [0, 0.5, 0, 0], [_INF, 7, 10, 1000])
+register_model("Stoner-Wohlfarth", "Magnetic", _stoner_wohlfarth, ["Ms", "Hc", "Hk"],
+               [1, 100, 500], [0, 0, 0], [_INF, _INF, _INF])
+register_model("Debye", "Thermal", _debye, ["gamma", "thetaD", "n"], [5, 200, 1],
+               [0, 1, 0.1], [_INF, _INF, 20])
+register_model("Einstein", "Thermal", _einstein, ["gamma", "thetaE", "n"], [5, 150, 1],
+               [0, 1, 0.1], [_INF, _INF, 20])
+register_model("Debye+Einstein", "Thermal", _debye_einstein,
+               ["gamma", "thetaD", "n_D", "thetaE", "n_E"], [5, 200, 0.8, 150, 0.2],
+               [0, 1, 0, 1, 0], [_INF, _INF, 20, _INF, 20])

quantized/calc/fit_odr.py

@@ -0,0 +1,99 @@
+"""Orthogonal distance (Deming) regression. Port of fitting.odrFit.
+
+Pure calc layer. Linear fit ``y = slope·x + intercept`` minimising the squared
+*perpendicular* distances (errors in both x and y), with a variance ratio
+``lambda = σy²/σx²`` (λ→∞ → OLS, λ→0 → inverse OLS, λ=1 → symmetric ODR). The
+estimator is closed-form (Deming); standard errors come from jackknife
+leave-one-out refits — exactly as the MATLAB original.
+"""
+
+from __future__ import annotations
+
+import math
+from typing import Any
+
+import numpy as np
+from numpy.typing import ArrayLike, NDArray
+
+__all__ = ["odr_fit"]
+
+_EPS = float(np.finfo(float).eps)
+
+
+def _deming_fit(x: NDArray[np.float64], y: NDArray[np.float64], lam: float) -> tuple[float, float]:
+    """Closed-form Deming regression on centered moments (port of demingFit)."""
+    xbar, ybar = float(np.mean(x)), float(np.mean(y))
+    xc = x - xbar
+    yc = y - ybar
+    sxx = float(np.sum(xc**2))
+    syy = float(np.sum(yc**2))
+    sxy = float(np.sum(xc * yc))
+    if abs(sxy) < _EPS:
+        slope = 0.0  # no linear correlation → flat line anchored at the mean
+    else:
+        disc = (syy - lam * sxx) ** 2 + 4.0 * lam * sxy**2
+        slope = (syy - lam * sxx + math.copysign(1.0, sxy) * math.sqrt(disc)) / (2.0 * sxy)
+    intercept = ybar - slope * xbar
+    return slope, intercept
+
+
+def odr_fit(
+    x: ArrayLike,
+    y: ArrayLike,
+    *,
+    lambda_: float = 1.0,
+    x_error: ArrayLike | None = None,
+    y_error: ArrayLike | None = None,
+) -> dict[str, Any]:
+    """Deming/orthogonal linear regression. Port of fitting.odrFit.
+
+    ``lambda_`` is the σy²/σx² ratio (default 1 → symmetric ODR). If both
+    ``x_error`` and ``y_error`` are given, λ is derived as
+    ``(mean(y_error)/mean(x_error))²``. Returns a dict with ``slope``/``intercept``,
+    jackknife ``slopeErr``/``interceptErr``, ``lambda``, ``rss``, ``rmse``, ``n``.
+    """
+    xv = np.asarray(x, dtype=float).ravel()
+    yv = np.asarray(y, dtype=float).ravel()
+    if xv.size != yv.size:
+        raise ValueError("x and y must have the same length")
+    n = xv.size
+    if n < 3:
+        raise ValueError(f"ODR requires at least 3 points (got {n})")
+
+    lam = float(lambda_)
+    if lam <= 0:
+        raise ValueError("lambda_ must be positive")
+    if x_error is not None and y_error is not None:
+        xe_mean = float(np.nanmean(np.asarray(x_error, dtype=float)))
+        ye_mean = float(np.nanmean(np.asarray(y_error, dtype=float)))
+        if xe_mean <= 0:
+            raise ValueError("mean x_error must be positive")
+        lam = (ye_mean / xe_mean) ** 2
+
+    slope, intercept = _deming_fit(xv, yv, lam)
+
+    # Orthogonal residuals: perpendicular distance from each point to the line.
+    res = (slope * xv - yv + intercept) / math.sqrt(slope**2 + 1.0)
+    rss = float(np.sum(res**2))
+    rmse = math.sqrt(rss / n)
+
+    # Jackknife standard errors — refit n times leaving one point out.
+    slopes = np.empty(n)
+    intercepts = np.empty(n)
+    for k in range(n):
+        mask = np.arange(n) != k
+        slopes[k], intercepts[k] = _deming_fit(xv[mask], yv[mask], lam)
+    factor = (n - 1) / n
+    slope_err = math.sqrt(factor * float(np.sum((slopes - np.mean(slopes)) ** 2)))
+    intercept_err = math.sqrt(factor * float(np.sum((intercepts - np.mean(intercepts)) ** 2)))
+
+    return {
+        "slope": slope,
+        "intercept": intercept,
+        "slopeErr": slope_err,
+        "interceptErr": intercept_err,
+        "lambda": lam,
+        "rss": rss,
+        "rmse": rmse,
+        "n": n,
+    }