tokenfabrikker/tests/test_trekninger.py
Kjell Tore Guttormsen ea26cd4226
feat(trekninger): read parameter file 1.1 and store the new draws
The loader knows the new checksum and the units of the new quantities
(g CO2 per kWh, cubic metres per MWh). 10 000 draws of 91 quantities with the
same seed; the four new ones are the last columns. All columns have new
numbers, because the random numbers are laid out row by row. The stream for
yearly events is byte for byte the same; only its description records the new
checksum. Tests for the counts, the new quantities and the checksum in the
pre-registration. README, CHANGELOG and CLAUDE.md updated.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-12 23:07:09 +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, 91)
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 91 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)