tokenfabrikker/tests/test_trekninger.py
Kjell Tore Guttormsen a63f66c416
feat(kode): add the levelised equations, the parameter reader and the draws
One pure function per equation for chapters 1 to 3 of the specification
(S1-S21, S36, S43-S47), a strict reader for the frozen parameter file with
checksum, validation and unit conversion, and the 10 000 Monte Carlo draws of
the 87 drawn quantities, stored in data/ and reproducible bit for bit.

Tests: unit tests and edge cases per equation, the reader, the draws, and
known answers from Argonne, NOU 2026: 4, Epoch and NVE with the sources' own
assumptions. Five comparisons miss the 5 % tolerance and are kept as strict
expected failures with the measured deviation. No result for the hypothesis
is computed. ruff ALL and mypy strict pass.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-12 10:08:47 +01:00

262 lines
11 KiB
Python

"""The draws follow the frozen set-up, hit the frozen distributions and can be reproduced.
These tests look at the drawn parameter values only. No model result is computed.
"""
from __future__ import annotations
import json
from typing import TYPE_CHECKING
import numpy as np
import numpy.typing as npt
import pytest
from scipy import stats
from tokenfabrikker import fordelinger, trekninger
from tokenfabrikker import parametere as pm
if TYPE_CHECKING:
from pathlib import Path
Tabell = npt.NDArray[np.float64]
ANTALL_STANDARDFEIL = 4.0
"""Every statistical check allows four standard errors of the sampling error."""
@pytest.fixture(scope="module")
def sett() -> pm.Parametersett:
return pm.les_parametere()
@pytest.fixture(scope="module")
def trukket(sett: pm.Parametersett) -> trekninger.Trekninger:
return trekninger.trekk(sett)
def _kvantil(sett: pm.Parametersett, navn: str, q: float) -> float:
"""The theoretical quantile of a drawn quantity, from its inverse distribution function."""
fordeling = sett.storrelse(navn).fordeling
return float(
fordelinger.invers(fordeling, np.array([q]), heltall=navn in trekninger.HELTALL)[0]
)
# ---------------------------------------------------------------- reproducibility
def test_oppsettet_folger_parameterfila(
sett: pm.Parametersett, trukket: trekninger.Trekninger
) -> None:
assert trukket.tabell.shape == (10_000, 87)
assert trukket.kolonner == tuple(s.navn for s in sett.stokastiske())
assert trukket.tabell.dtype == np.float64
assert np.isfinite(trukket.tabell).all()
def test_samme_fro_gir_samme_trekninger(
sett: pm.Parametersett, trukket: trekninger.Trekninger
) -> None:
assert np.array_equal(trekninger.trekk(sett).tabell, trukket.tabell)
def test_den_lagrede_fila_kan_gjenskapes(
sett: pm.Parametersett, trukket: trekninger.Trekninger
) -> None:
"""``data/trekninger.npy`` is what the generator gives, bit for bit or within tolerance."""
lagret = trekninger.les()
assert lagret.kolonner == trukket.kolonner
assert lagret.enheter == trukket.enheter
dom, avvik = trekninger.kontroller(sett)
assert dom in {"identisk", "innenfor toleranse"}, avvik
beskrivelse = json.loads(
(trekninger.DATAMAPPE / trekninger.BESKRIVELSESFIL).read_text(encoding="utf-8")
)
assert beskrivelse["sha256_parametere"] == pm.FROSSEN_SHA256
assert beskrivelse["antall_trekninger"] == sett.monte_carlo.antall_trekninger
assert beskrivelse["froe"] == sett.monte_carlo.froe
def test_skriv_og_les(
sett: pm.Parametersett, trukket: trekninger.Trekninger, tmp_path: Path
) -> None:
sha256 = trekninger.skriv(trukket, sett, tmp_path)
lest = trekninger.les(tmp_path)
assert np.array_equal(lest.tabell, trukket.tabell)
assert trekninger.kontroller(sett, tmp_path) == ("identisk", 0.0)
assert trekninger.skriv(trukket, sett, tmp_path) == sha256
tabellfil = tmp_path / trekninger.TABELLFIL
raa = bytearray(tabellfil.read_bytes())
raa[-1] ^= 1
tabellfil.write_bytes(bytes(raa))
with pytest.raises(pm.ParameterError, match="does not match the checksum"):
trekninger.les(tmp_path)
def test_kommandolinjen(tmp_path: Path, capsys: pytest.CaptureFixture[str]) -> None:
assert trekninger.main(["lag", "--mappe", str(tmp_path)]) == 0
assert "10000 trekninger av 87 størrelser" in capsys.readouterr().out
assert trekninger.main(["kontroll", "--mappe", str(tmp_path)]) == 0
assert capsys.readouterr().out.startswith("identisk")
# ------------------------------------------------------------ the distributions
def test_alle_trekninger_ligger_innenfor_spennet(
sett: pm.Parametersett, trukket: trekninger.Trekninger
) -> None:
for storrelse in sett.stokastiske():
verdier = trukket.kolonne(storrelse.navn)
fordeling = storrelse.fordeling
if fordeling.type == "diskret":
assert set(np.unique(verdier)) <= set(fordeling.verdier), storrelse.navn
continue
nedre = fordeling.tall["min" if fordeling.type == "lognormal" else "lav"]
ovre = fordeling.tall["maks" if fordeling.type == "lognormal" else "hoy"]
assert nedre <= float(np.min(verdier)), storrelse.navn
assert float(np.max(verdier)) <= ovre, storrelse.navn
@pytest.mark.parametrize("q", [0.05, 0.5, 0.95])
def test_median_og_ytterpunkter_treffer(
sett: pm.Parametersett, trukket: trekninger.Trekninger, q: float
) -> None:
"""The share of draws below the theoretical 5 %, 50 % and 95 % points is 5 %, 50 % and 95 %."""
n = trukket.tabell.shape[0]
slingring = ANTALL_STANDARDFEIL * np.sqrt(q * (1 - q) / n)
for storrelse in sett.stokastiske():
navn = storrelse.navn
if storrelse.fordeling.type == "diskret" or navn in trekninger.HELTALL:
continue
if navn == "KF" and q > 0.5:
continue # the cap at (1 - o_p)(1 - o_f) changes the upper tail
andel = float(np.mean(trukket.kolonne(navn) <= _kvantil(sett, navn, q)))
assert abs(andel - q) <= slingring, (navn, q, andel)
def test_diskrete_fordelinger_treffer_vektene(
sett: pm.Parametersett, trukket: trekninger.Trekninger
) -> None:
n = trukket.tabell.shape[0]
for navn in ("A_krav", "L_H"):
fordeling = sett.storrelse(navn).fordeling
for verdi, vekt in zip(fordeling.verdier, fordeling.vekter, strict=True):
andel = float(np.mean(trukket.kolonne(navn) == verdi))
assert abs(andel - vekt) <= ANTALL_STANDARDFEIL * np.sqrt(vekt * (1 - vekt) / n), navn
def test_n_0_er_heltall_med_lik_sannsynlighet(trukket: trekninger.Trekninger) -> None:
verdier = trukket.kolonne("n_0")
assert np.array_equal(verdier, np.round(verdier))
assert set(np.unique(verdier)) == set(range(1, 21))
andeler = np.bincount(verdier.astype(int))[1:] / verdier.size
assert np.max(np.abs(andeler - 0.05)) <= ANTALL_STANDARDFEIL * np.sqrt(
0.05 * 0.95 / verdier.size
)
def test_overskridelsen_har_median_og_snitt_som_parameterfila_sier(
trukket: trekninger.Trekninger,
) -> None:
"""o_xi: median 0.648, and mean about 1.12 after truncation at 12.8 (the file's note)."""
o_xi = trukket.kolonne("o_xi")
assert float(np.median(o_xi)) == pytest.approx(0.648, rel=0.05)
assert float(np.mean(o_xi)) == pytest.approx(1.12, rel=0.05)
assert float(np.max(o_xi)) <= 12.8
def test_pert_har_riktig_snitt(sett: pm.Parametersett, trukket: trekninger.Trekninger) -> None:
"""A beta-PERT with shape 4 has mean (low + 4 mode + high) / 6."""
for navn in ("tau_N", "L_N", "rho_N", "c_H0", "S0"):
tall = sett.storrelse(navn).fordeling.tall
ventet = (tall["lav"] + 4 * tall["modus"] + tall["hoy"]) / 6
verdier = trukket.kolonne(navn)
slingring = ANTALL_STANDARDFEIL * float(np.std(verdier)) / np.sqrt(verdier.size)
assert abs(float(np.mean(verdier)) - ventet) <= slingring, navn
def test_kapasitetsfaktoren_er_avkortet(trukket: trekninger.Trekninger) -> None:
tak = (1 - trukket.kolonne("o_p")) * (1 - trukket.kolonne("o_f_stor"))
assert np.all(trukket.kolonne("KF") <= tak)
assert 0 < float(np.mean(trukket.kolonne("KF") == tak)) < 0.05
# --------------------------------------------------------------- correlations
def _rangkorrelasjon(a: Tabell, b: Tabell) -> float:
return float(stats.spearmanr(a, b).statistic)
def test_rangkorrelasjonene_treffer(sett: pm.Parametersett, trukket: trekninger.Trekninger) -> None:
n = trukket.tabell.shape[0]
for a, b, parameter in trekninger.KORRELASJONER:
ventet = sett.fast(parameter)
funnet = _rangkorrelasjon(trukket.kolonne(a), trukket.kolonne(b))
assert abs(funnet - ventet) <= ANTALL_STANDARDFEIL / np.sqrt(n), (a, b, funnet)
def test_normalkorrelasjonen_gir_rangkorrelasjonen() -> None:
assert trekninger.normalkorrelasjon(0.5) == pytest.approx(0.5176, abs=1e-4)
assert trekninger.normalkorrelasjon(0.0) == 0.0
assert trekninger.normalkorrelasjon(1.0) == pytest.approx(1.0)
assert trekninger.normalkorrelasjon(-0.5) == -trekninger.normalkorrelasjon(0.5)
def test_alle_andre_par_er_ukorrelerte(trukket: trekninger.Trekninger) -> None:
"""No pair outside the four in chapter 11 has a rank correlation above 0.05."""
korrelasjon = np.asarray(stats.spearmanr(trukket.tabell).statistic)
np.fill_diagonal(korrelasjon, 0.0)
for a, b, _ in trekninger.KORRELASJONER:
i, j = trukket.kolonner.index(a), trukket.kolonner.index(b)
korrelasjon[i, j] = korrelasjon[j, i] = 0.0
assert float(np.max(np.abs(korrelasjon))) < 0.05
# --------------------------------------------------- inverse distribution functions
def test_inverse_fordelingsfunksjoner() -> None:
u = np.array([0.0, 0.25, 0.5, 1.0])
assert fordelinger.invers_jevn(u, lav=2.0, hoy=6.0).tolist() == [2.0, 3.0, 4.0, 6.0]
assert fordelinger.invers_jevn_heltall(u, lav=1.0, hoy=4.0).tolist() == [1.0, 2.0, 3.0, 4.0]
assert fordelinger.invers_logjevn(u, lav=1e-8, hoy=1e-4)[2] == pytest.approx(1e-6)
diskret = fordelinger.invers_diskret(
np.array([0.0, 0.3, 0.31, 0.99, 1.0]), verdier=(3.0, 5.0, 7.0), vekter=(0.3, 0.4, 0.3)
)
assert diskret.tolist() == [3.0, 3.0, 5.0, 7.0, 7.0]
def test_pert_er_betafordelingen() -> None:
a, b = fordelinger.pert_parametere(lav=6.0, modus=9.5, hoy=17.1, form=4.0)
assert (a, b) == pytest.approx((1 + 4 * 3.5 / 11.1, 1 + 4 * 7.6 / 11.1))
u = np.linspace(0.01, 0.99, 9)
ventet = 6.0 + 11.1 * stats.beta.ppf(u, a, b)
assert fordelinger.invers_pert(u, lav=6.0, modus=9.5, hoy=17.1, form=4.0) == pytest.approx(
ventet
)
kant = fordelinger.invers_pert(np.array([0.0, 1.0]), lav=5.0, modus=5.0, hoy=9.0, form=4.0)
assert kant.tolist() == [5.0, 9.0]
def test_avkortet_lognormal() -> None:
u = np.array([0.0, 0.5, 1.0])
uavkortet = fordelinger.invers_lognormal(u[1:2], median=0.648, sigma=1.09, minste=0.0, maks=1e9)
assert uavkortet[0] == pytest.approx(0.648)
avkortet = fordelinger.invers_lognormal(u, median=0.648, sigma=1.09, minste=0.0, maks=12.8)
assert avkortet[0] == 0.0
assert avkortet[2] == pytest.approx(12.8)
assert avkortet[1] < 0.648 + 0.01
andel_under_maks = stats.norm.cdf(np.log(12.8 / 0.648) / 1.09)
assert avkortet[1] == pytest.approx(
0.648 * np.exp(1.09 * stats.norm.ppf(0.5 * andel_under_maks))
)
def test_fast_verdi_trekkes_ikke(sett: pm.Parametersett) -> None:
with pytest.raises(ValueError, match="nothing is drawn"):
fordelinger.invers(sett.storrelse("P_ref").fordeling, np.array([0.5]))
with pytest.raises(ValueError, match="only defined for the uniform type"):
fordelinger.invers(sett.storrelse("tau_N").fordeling, np.array([0.5]), heltall=True)