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>
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, 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)
|