quantized-lab 0.8.0__py3-none-any.whl

quantized/routes/stats_design.py

@@ -0,0 +1,321 @@
+"""Thin routes: designed-experiment ANOVA + post-hoc + the test chooser + GLM/survival/ROC.
+
+Split from routes/stats.py (500-line module ceiling); same /api/stats prefix.
+GAP_PLAN #30 adds GLM (logistic/Poisson), survival (KM/log-rank/Cox), and ROC methods.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from quantized.calc.stats_anova2 import adjust_pvalues, anova2, dunnett_test, tukey_hsd
+from quantized.calc.stats_anova_ext import anova2_unbalanced, repeated_measures_anova
+from quantized.calc.stats_glm import logistic_regression, poisson_regression
+from quantized.calc.stats_roc import auc, roc_curve, youden_optimal_threshold
+from quantized.calc.stats_survival import cox_proportional_hazards, kaplan_meier, logrank_test
+from quantized.calc.stats_tests import recommend_test
+from quantized.routes._payload import to_jsonable
+
+router = APIRouter(prefix="/api/stats", tags=["stats"])
+
+
+def _wrap(result: dict[str, Any]) -> dict[str, Any]:
+    return to_jsonable(result)  # type: ignore[no-any-return]
+
+
+class Anova2Request(BaseModel):
+    cells: list[list[list[float]]]  # [A-level][B-level][replicates], balanced
+    alpha: float = 0.05
+
+
+@router.post("/anova2")
+def anova2_route(req: Anova2Request) -> dict[str, Any]:
+    """Balanced two-way factorial ANOVA with interaction."""
+    try:
+        return _wrap(anova2(req.cells, alpha=req.alpha))
+    except (ValueError, IndexError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+
+
+class Anova2UnbalancedRequest(BaseModel):
+    values: list[float]
+    factor_a: list[str]
+    factor_b: list[str]
+    ss_type: int = 3  # 2 or 3
+    alpha: float = 0.05
+
+
+@router.post("/anova2-unbalanced")
+def anova2_unbalanced_route(req: Anova2UnbalancedRequest) -> dict[str, Any]:
+    """Unbalanced two-way ANOVA (Type II/III SS) from long-format columns."""
+    try:
+        return _wrap(
+            anova2_unbalanced(
+                np.asarray(req.values, dtype=float),
+                req.factor_a, req.factor_b,
+                ss_type=req.ss_type, alpha=req.alpha,
+            )
+        )
+    except (ValueError, IndexError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+
+
+class RepeatedMeasuresRequest(BaseModel):
+    data: list[list[float]]  # rows = subjects, columns = conditions
+    alpha: float = 0.05
+
+
+@router.post("/anova-rm")
+def anova_rm_route(req: RepeatedMeasuresRequest) -> dict[str, Any]:
+    """One-way repeated-measures (within-subjects) ANOVA + sphericity."""
+    try:
+        return _wrap(repeated_measures_anova(req.data, alpha=req.alpha))
+    except (ValueError, IndexError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+
+
+class PostHocRequest(BaseModel):
+    groups: list[list[float]]
+    alpha: float = 0.05
+    control: int = 0  # dunnett only
+    alternative: str = "two-sided"  # dunnett only
+
+
+@router.post("/tukey")
+def tukey_route(req: PostHocRequest) -> dict[str, Any]:
+    """Tukey HSD all-pairs post-hoc."""
+    try:
+        return _wrap(tukey_hsd([np.asarray(g, dtype=float) for g in req.groups], alpha=req.alpha))
+    except (ValueError, IndexError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+
+
+@router.post("/dunnett")
+def dunnett_route(req: PostHocRequest) -> dict[str, Any]:
+    """Dunnett many-to-one post-hoc vs a control group."""
+    try:
+        return _wrap(
+            dunnett_test(
+                [np.asarray(g, dtype=float) for g in req.groups],
+                control=req.control, alpha=req.alpha, alternative=req.alternative,
+            )
+        )
+    except (ValueError, IndexError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+
+
+class RecommendRequest(BaseModel):
+    groups: list[list[float]]
+    paired: bool = False
+    alpha: float = 0.05
+
+
+@router.post("/recommend")
+def recommend_route(req: RecommendRequest) -> dict[str, Any]:
+    """The 'which test?' chooser: assumption checks -> recommended test."""
+    try:
+        return _wrap(
+            recommend_test(
+                [np.asarray(g, dtype=float) for g in req.groups],
+                paired=req.paired, alpha=req.alpha,
+            )
+        )
+    except (ValueError, IndexError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+
+
+class AdjustPRequest(BaseModel):
+    p_values: list[float]
+    method: str = "holm"
+
+
+@router.post("/adjust-p")
+def adjust_p_route(req: AdjustPRequest) -> dict[str, Any]:
+    """Bonferroni / Holm / Benjamini-Hochberg p-value adjustment."""
+    try:
+        return _wrap(adjust_pvalues(req.p_values, method=req.method))
+    except (ValueError, IndexError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+
+
+# ── GLM (Logistic & Poisson) ──────────────────────────────────────────────
+
+
+class GlmRequest(BaseModel):
+    """Request for logistic or Poisson GLM.
+
+    ``predictors`` is a list of *k predictor columns* (each a same-length
+    array of n observations) — ``[[x1_1..x1_n], [x2_1..x2_n], ...]`` — not a
+    list of n row records. Same convention as ``calc.stats_glm``/
+    ``calc.stats_multivar``; the intercept is added automatically.
+    """
+    predictors: list[list[float]]
+    y: list[float]
+    alpha: float = 0.05
+
+
+@router.post("/glm-logistic")
+def glm_logistic_route(req: GlmRequest) -> dict[str, Any]:
+    """Logistic regression with coefficients, SEs, z-stats, p-values, AIC."""
+    try:
+        predictors = [np.asarray(c, dtype=float) for c in req.predictors]
+        y = np.asarray(req.y, dtype=float)
+        return _wrap(logistic_regression(predictors, y, alpha=req.alpha))
+    except RuntimeError as exc:
+        raise HTTPException(status_code=501, detail=str(exc)) from exc
+    except (ValueError, IndexError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+
+
+@router.post("/glm-poisson")
+def glm_poisson_route(req: GlmRequest) -> dict[str, Any]:
+    """Poisson regression with coefficients, SEs, z-stats, p-values, AIC."""
+    try:
+        predictors = [np.asarray(c, dtype=float) for c in req.predictors]
+        y = np.asarray(req.y, dtype=float)
+        return _wrap(poisson_regression(predictors, y, alpha=req.alpha))
+    except RuntimeError as exc:
+        raise HTTPException(status_code=501, detail=str(exc)) from exc
+    except (ValueError, IndexError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+
+
+# ── Survival Analysis ─────────────────────────────────────────────────────
+
+
+class SurvivalRequest(BaseModel):
+    """Request for Kaplan-Meier or log-rank test."""
+    time: list[float]
+    event: list[float]
+
+
+class KaplanMeierRequest(SurvivalRequest):
+    """Kaplan-Meier curve request."""
+    pass
+
+
+class LogRankRequest(BaseModel):
+    """Request for log-rank test between two groups."""
+    time1: list[float]
+    event1: list[float]
+    time2: list[float]
+    event2: list[float]
+
+
+class CoxRequest(BaseModel):
+    """Request for Cox proportional-hazards model.
+
+    ``predictors`` is a list of *k predictor columns* (each length n),
+    same convention as ``GlmRequest.predictors`` — not a list of row
+    records.
+    """
+    time: list[float]
+    event: list[float]
+    predictors: list[list[float]]
+
+
+@router.post("/kaplan-meier")
+def kaplan_meier_route(req: KaplanMeierRequest) -> dict[str, Any]:
+    """Kaplan-Meier survival curve with Greenwood CIs."""
+    try:
+        time = np.asarray(req.time, dtype=float)
+        event = np.asarray(req.event, dtype=float)
+        return _wrap(kaplan_meier(time, event))
+    except RuntimeError as exc:
+        raise HTTPException(status_code=501, detail=str(exc)) from exc
+    except (ValueError, IndexError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+
+
+@router.post("/logrank")
+def logrank_route(req: LogRankRequest) -> dict[str, Any]:
+    """Log-rank test comparing two survival curves."""
+    try:
+        return _wrap(
+            logrank_test(
+                np.asarray(req.time1, dtype=float), np.asarray(req.event1, dtype=float),
+                np.asarray(req.time2, dtype=float), np.asarray(req.event2, dtype=float),
+            )
+        )
+    except RuntimeError as exc:
+        raise HTTPException(status_code=501, detail=str(exc)) from exc
+    except (ValueError, IndexError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+
+
+@router.post("/cox-ph")
+def cox_ph_route(req: CoxRequest) -> dict[str, Any]:
+    """Cox proportional-hazards model."""
+    try:
+        predictors = [np.asarray(c, dtype=float) for c in req.predictors]
+        return _wrap(
+            cox_proportional_hazards(
+                np.asarray(req.time, dtype=float), np.asarray(req.event, dtype=float),
+                predictors,
+            )
+        )
+    except RuntimeError as exc:
+        raise HTTPException(status_code=501, detail=str(exc)) from exc
+    except (ValueError, IndexError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+
+
+# ── ROC & AUC ─────────────────────────────────────────────────────────────
+
+
+class RocRequest(BaseModel):
+    """Request for ROC curve."""
+    y_true: list[float]
+    y_score: list[float]
+
+
+class AucRequest(BaseModel):
+    """Request for AUC computation."""
+    fpr: list[float]
+    tpr: list[float]
+
+
+class YoudenRequest(BaseModel):
+    """Request for Youden optimal threshold."""
+    fpr: list[float]
+    tpr: list[float]
+    thresholds: list[float]
+
+
+@router.post("/roc-curve")
+def roc_curve_route(req: RocRequest) -> dict[str, Any]:
+    """ROC curve points (FPR, TPR) at all thresholds."""
+    try:
+        y_true = np.asarray(req.y_true, dtype=float)
+        y_score = np.asarray(req.y_score, dtype=float)
+        return _wrap(roc_curve(y_true, y_score))
+    except (ValueError, IndexError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+
+
+@router.post("/auc")
+def auc_route(req: AucRequest) -> dict[str, Any]:
+    """Area Under the ROC Curve (trapezoidal rule)."""
+    try:
+        auc_val = auc(np.asarray(req.fpr, dtype=float), np.asarray(req.tpr, dtype=float))
+        return _wrap({"auc": auc_val})
+    except (ValueError, IndexError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+
+
+@router.post("/youden-threshold")
+def youden_route(req: YoudenRequest) -> dict[str, Any]:
+    """Youden J-statistic optimal threshold selection."""
+    try:
+        return _wrap(
+            youden_optimal_threshold(
+                np.asarray(req.fpr, dtype=float), np.asarray(req.tpr, dtype=float),
+                np.asarray(req.thresholds, dtype=float),
+            )
+        )
+    except (ValueError, IndexError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc

quantized/routes/substrates.py

@@ -0,0 +1,46 @@
+"""Thin substrate routes. Wraps ``calc.substrates`` (reference table +
+lattice-mismatch formula). Validate -> call the pure fn -> serialize.
+
+GET endpoints expose the substrate reference table (list + single lookup);
+the POST endpoint computes the epitaxial lattice mismatch f = (a_f - a_s)/a_s.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from quantized.calc import substrates
+
+router = APIRouter(prefix="/api/substrates", tags=["substrates"])
+
+
+class MismatchRequest(BaseModel):
+    a_film: float
+    a_sub: float
+
+
+@router.get("")
+def list_substrates() -> dict[str, list[dict[str, Any]]]:
+    """Full substrate reference table (list of property dicts)."""
+    return {"substrates": substrates.substrate_table()}
+
+
+@router.get("/{name}")
+def get_substrate(name: str) -> dict[str, Any]:
+    """Single substrate property card by name (case-insensitive)."""
+    try:
+        return substrates.get_substrate(name)
+    except ValueError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+
+
+@router.post("/mismatch")
+def mismatch(req: MismatchRequest) -> dict[str, Any]:
+    """f = (a_film - a_sub)/a_sub, with tensile/compressive/matched label."""
+    try:
+        return substrates.lattice_mismatch(req.a_film, req.a_sub)
+    except ValueError as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc

quantized/routes/superconductor.py

@@ -0,0 +1,139 @@
+"""Thin superconductivity routes. Wraps ``calc.superconductor`` (pure formulas):
+material presets / London depth / coherence length / GL parameter / critical
+fields / depairing current / BCS gap. Validate -> call the pure fn -> serialize.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from quantized.calc import superconductor
+
+router = APIRouter(prefix="/api/superconductor", tags=["superconductor"])
+
+
+class LondonRequest(BaseModel):
+    lambda0: float | None = None
+    t: float
+    tc: float | None = None
+    material: str | None = None
+
+
+class CoherenceRequest(BaseModel):
+    xi0: float | None = None
+    t: float
+    tc: float | None = None
+    material: str | None = None
+
+
+class GlRequest(BaseModel):
+    lambda_: float | None = None
+    xi: float | None = None
+    material: str | None = None
+    t: float | None = None
+
+
+class CriticalFieldsRequest(BaseModel):
+    hc0: float | None = None
+    tc: float | None = None
+    t: float
+    material: str | None = None
+    lambda_: float | None = None
+    xi: float | None = None
+    kappa: float | None = None
+
+
+class DepairingRequest(BaseModel):
+    hc0: float | None = None
+    lambda0: float | None = None
+    tc: float | None = None
+    t: float
+    material: str | None = None
+
+
+class BcsGapRequest(BaseModel):
+    tc: float
+    t: float | None = None
+
+
+class PresetsRequest(BaseModel):
+    material: str | None = None
+
+
+def _call(fn: Callable[..., dict[str, Any]], *args: Any, **kwargs: Any) -> dict[str, Any]:
+    try:
+        return fn(*args, **kwargs)
+    except ValueError as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+
+
+@router.post("/material-presets")
+def material_presets(req: PresetsRequest) -> dict[str, Any]:
+    """Material property table (all, or a single named material)."""
+    return _call(superconductor.material_presets, req.material)
+
+
+@router.post("/london-depth")
+def london_depth(req: LondonRequest) -> dict[str, Any]:
+    """λ(T) = λ₀/√(1 − (T/Tc)⁴) (nm)."""
+    return _call(
+        superconductor.london_depth, req.lambda0, req.t, req.tc, material=req.material
+    )
+
+
+@router.post("/coherence-length")
+def coherence_length(req: CoherenceRequest) -> dict[str, Any]:
+    """ξ(T) = ξ₀/√(1 − (T/Tc)²) (nm)."""
+    return _call(
+        superconductor.coherence_length, req.xi0, req.t, req.tc, material=req.material
+    )
+
+
+@router.post("/gl-parameter")
+def gl_parameter(req: GlRequest) -> dict[str, Any]:
+    """κ = λ/ξ; type I/II classification."""
+    return _call(
+        superconductor.gl_parameter,
+        req.lambda_,
+        req.xi,
+        material=req.material,
+        t=req.t,
+    )
+
+
+@router.post("/critical-fields")
+def critical_fields(req: CriticalFieldsRequest) -> dict[str, Any]:
+    """Hc, Hc1, Hc2 (Oe) and superconductor type."""
+    return _call(
+        superconductor.critical_fields,
+        req.hc0,
+        req.tc,
+        req.t,
+        material=req.material,
+        lambda_=req.lambda_,
+        xi=req.xi,
+        kappa=req.kappa,
+    )
+
+
+@router.post("/depairing-current")
+def depairing_current(req: DepairingRequest) -> dict[str, Any]:
+    """Jd = Hc(T)/(3√6·π·λ(T)) (A/cm² and MA/cm²)."""
+    return _call(
+        superconductor.depairing_current,
+        req.hc0,
+        req.lambda0,
+        req.tc,
+        req.t,
+        material=req.material,
+    )
+
+
+@router.post("/bcs-gap")
+def bcs_gap(req: BcsGapRequest) -> dict[str, Any]:
+    """Δ₀ = 1.764·k_B·Tc (meV); Mühlschlegel Δ(T) when T given."""
+    return _call(superconductor.bcs_gap, req.tc, req.t)

quantized/routes/thermal.py

@@ -0,0 +1,57 @@
+"""Thin thermal-property routes. Wraps ``calc.thermal`` (pure formulas):
+Wiedemann-Franz law / Debye temperature / thermal diffusivity. Validate ->
+call the pure fn -> serialize.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from quantized.calc import thermal
+
+router = APIRouter(prefix="/api/thermal", tags=["thermal"])
+
+
+class WiedemannFranzRequest(BaseModel):
+    sigma: float  # electrical conductivity (S/cm)
+    temperature: float  # K
+
+
+class DebyeRequest(BaseModel):
+    v_s: float  # average sound velocity (m/s)
+    n: float  # atomic number density (atoms/m^3)
+
+
+class DiffusivityRequest(BaseModel):
+    kappa: float  # thermal conductivity (W/m/K)
+    rho: float  # mass density (kg/m^3)
+    cp: float  # specific heat (J/kg/K)
+
+
+def _call(fn: Callable[..., dict[str, Any]], *args: Any, **kwargs: Any) -> dict[str, Any]:
+    try:
+        return fn(*args, **kwargs)
+    except ValueError as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+
+
+@router.post("/wiedemann-franz")
+def wiedemann_franz(req: WiedemannFranzRequest) -> dict[str, Any]:
+    """κ = L₀·σ·T (W/(m·K))."""
+    return _call(thermal.wiedemann_franz, req.sigma, req.temperature)
+
+
+@router.post("/debye")
+def debye(req: DebyeRequest) -> dict[str, Any]:
+    """Θ_D = (ħ/k_B)·v_s·(6π²·n)^(1/3) (K)."""
+    return _call(thermal.debye_temperature, req.v_s, req.n)
+
+
+@router.post("/diffusivity")
+def diffusivity(req: DiffusivityRequest) -> dict[str, Any]:
+    """α = κ/(ρ·c_p) (m²/s)."""
+    return _call(thermal.thermal_diffusivity, req.kappa, req.rho, req.cp)