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>
262 lines
11 KiB
Python
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)
|