M7 gives, for each of the five solutions, the share of the draws in which it is best alone and in which it shares the place, with no verdict on A; part II and the thresholds for M7 are gone. T-F and T-K share the place where they are the same path. The surfaces carry the classes along their axes, and kontroll prints a line per file. The made-up reference files are regenerated: everything outside the comparison is unchanged to the last digit. Nothing is computed on the frozen parameters. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
436 lines
16 KiB
Python
436 lines
16 KiB
Python
"""The data files of the main run and the comparison of ``kontroll`` (clarifications 128, 129).
|
|
|
|
Invented outcomes per draw for the builders, and made-up files for the comparison. The files
|
|
of a real (made-up) run are tested in ``test_verktoy.py``. Nothing here says anything about
|
|
the hypothesis.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import math
|
|
import shutil
|
|
from pathlib import Path
|
|
from typing import TYPE_CHECKING
|
|
|
|
import pytest
|
|
|
|
from tokenfabrikker import datafiler as df
|
|
from tokenfabrikker import grunnlag as gl
|
|
from tokenfabrikker import kjoring as kj
|
|
from tokenfabrikker import terskler
|
|
from tokenfabrikker.dommer import Dom, Forsyning
|
|
from tokenfabrikker.kjoring import Bane, Kjoring, Utfall
|
|
from tokenfabrikker.utbygging import Kraft, Losning
|
|
|
|
if TYPE_CHECKING:
|
|
from tokenfabrikker.kjoring import Scenario
|
|
|
|
NORM, VARER = kj.SCENARIOER[1], kj.SCENARIOER[0]
|
|
|
|
X40 = [float(v) for v in range(1, 41)]
|
|
"""An invented quantity over forty draws: its 10th percentile is 4.9 and its 90th 36.1."""
|
|
|
|
|
|
def _u(NNV: float, M6: float | None = 0.3) -> Utfall:
|
|
return Utfall(
|
|
NNV=NNV,
|
|
S42=1.0,
|
|
M3=0.0,
|
|
M4=Forsyning(ikke_svakere_uten_tiltak=True, svakere_ogsaa_med_tiltak=False),
|
|
M6=M6,
|
|
M6_snitt=M6,
|
|
M6_median=M6,
|
|
M6_2050=None,
|
|
M6_topp=0.0 if M6 is None else M6,
|
|
stabilt_aar=None if M6 is None else 2040,
|
|
toppaar=2040,
|
|
)
|
|
|
|
|
|
def _bane(utfall: Utfall | None, scenarioer: tuple[Scenario, ...]) -> Bane:
|
|
return Bane(
|
|
byggbar=utfall is not None,
|
|
forste_aar=2028,
|
|
tidslinje={Kraft.NY_FORNYBAR: (0.0, 100.0, 1000.0)},
|
|
utfall={} if utfall is None else dict.fromkeys((s.navn for s in scenarioer), utfall),
|
|
)
|
|
|
|
|
|
def _kjoring() -> Kjoring:
|
|
"""Forty invented draws of A and B on step 5: A positive in the first 28, B mostly unbuilt."""
|
|
scenarioer = (VARER, NORM)
|
|
return Kjoring(
|
|
stige=(5,),
|
|
scenarioer=scenarioer,
|
|
losninger=(Losning.A, Losning.B),
|
|
trekninger=tuple(
|
|
{
|
|
(Losning.A, 5): _bane(_u(1.0 + j if j < 28 else -1.0 - j), scenarioer),
|
|
(Losning.B, 5): _bane(_u(-2.0) if j < 15 else None, scenarioer),
|
|
}
|
|
for j in range(40)
|
|
),
|
|
)
|
|
|
|
|
|
M5 = {Losning.A: Dom.HOLDER, Losning.B: Dom.BETINGELSER}
|
|
STORRELSER = {"x": X40, "z": [41.0 - v for v in X40]}
|
|
STATUS = {"x": "kilde", "z": "åpen forutsetning"}
|
|
HODE: dict[str, object] = {"grunnlag": {"merke": "oppdiktet", "sjekksummer": {}}}
|
|
|
|
|
|
# ------------------------------------------------------------------- the format
|
|
|
|
|
|
def test_formatet_er_utf8_lf_innrykk_en_og_ingen_koder() -> None:
|
|
tekst = df.json_tekst({"b": [1, 2.5], "a": "ø «holder»", "c": None, "d": (0.1,)})
|
|
assert tekst == (
|
|
'{\n "b": [\n 1,\n 2.5\n ],\n "a": "ø «holder»",\n "c": null,\n "d": [\n 0.1\n ]\n}\n'
|
|
)
|
|
assert "\r" not in tekst
|
|
assert tekst.endswith("}\n")
|
|
assert not tekst.endswith("\n\n")
|
|
|
|
|
|
def test_ingen_avrunding_og_ingen_uendelighet() -> None:
|
|
tall = [0.1 + 0.2, 1 / 3, 2.0**-1074, 1e300, -123456.78901234567]
|
|
assert json.loads(df.json_tekst(tall)) == tall
|
|
assert all(str(x) in df.json_tekst(tall) for x in tall)
|
|
for feil in (math.inf, -math.inf, math.nan):
|
|
with pytest.raises(ValueError, match="cannot be written"):
|
|
df.json_tekst({"x": [feil]})
|
|
with pytest.raises(TypeError, match="not a plain JSON value"):
|
|
df.json_tekst({"x": {1, 2}})
|
|
|
|
|
|
def test_rekkefolgen_i_stigen_scenarioene_og_losningene() -> None:
|
|
stige, scenarioer, losninger = df.ordne(
|
|
(5, 1, 2), (kj.SCENARIOER[3], NORM, VARER), (Losning.T_K, Losning.A, Losning.B_MERKET)
|
|
)
|
|
assert stige == (1, 2, 5)
|
|
assert scenarioer == (VARER, NORM, kj.SCENARIOER[3])
|
|
assert losninger == (Losning.A, Losning.B_MERKET, Losning.T_K)
|
|
with pytest.raises(ValueError, match="stands twice"):
|
|
df.ordne((1, 1), (NORM,), (Losning.A,))
|
|
|
|
|
|
# ---------------------------------------------------------------- the builders
|
|
|
|
|
|
def _lest(data: object) -> object:
|
|
return json.loads(df.json_tekst(data))
|
|
|
|
|
|
def test_dommer_json_har_tallene_sett_dommer_gir() -> None:
|
|
kjoring = _kjoring()
|
|
dommer = kj.sett_dommer(kjoring, M5, storrelser=STORRELSER, status=STATUS)
|
|
data = df.lag_dommer(HODE, kjoring, dommer)
|
|
lest = _lest(data)
|
|
assert lest == data | {} # every float reads back to the same float
|
|
assert isinstance(lest, dict)
|
|
assert list(lest) == [
|
|
"grunnlag",
|
|
"trinn",
|
|
"grunnlag_for_trinnet",
|
|
"teller",
|
|
"del_I",
|
|
"per_scenario",
|
|
]
|
|
assert (lest["trinn"], lest["grunnlag_for_trinnet"]) == (5, "25 %-trinnet")
|
|
assert (lest["teller"], lest["del_I"]) == ("normalisering", dommer.del_I.value)
|
|
assert [s["navn"] for s in lest["per_scenario"]] == ["knapphet varer", "normalisering"]
|
|
norm = lest["per_scenario"][1]
|
|
sd = dommer.scenarioer["normalisering"]
|
|
a = norm["trinn"][0]["losninger"]["A"]
|
|
assert list(a) == ["M1", "M2", "M3", "M4", "M5", "M6", "median_M1", "ved_siden_av_M6"]
|
|
m1 = sd.per_trinn[5][Losning.A].maal["M1"]
|
|
assert a["M1"] == {
|
|
"dom": m1.dom.value,
|
|
"andel_holder": m1.andel_holder,
|
|
"andel_holder_ikke": None,
|
|
"ikke_byggbar": 0.0,
|
|
"oppfylt_blant_byggbare": m1.oppfylt_blant_byggbare,
|
|
}
|
|
assert a["median_M1"] == sd.per_trinn[5][Losning.A].median_M1
|
|
assert a["M5"] == "holder"
|
|
# B cannot be built in 25 of 40 draws: the median in M1 has no value
|
|
assert sd.per_trinn[5][Losning.B].median_M1 == -math.inf
|
|
assert norm["trinn"][0]["losninger"]["B"]["median_M1"] is None
|
|
# M7 is the comparison: A is best in all 40 draws, B cannot be built in 25 (135 f)
|
|
assert norm["trinn"][0]["M7"] == {
|
|
"A": {
|
|
"best_alene": 1.0,
|
|
"deler_plassen": 0.0,
|
|
"ikke_byggbar": 0.0,
|
|
"best_alene_blant_byggbare": 1.0,
|
|
},
|
|
"B": {
|
|
"best_alene": 0.0,
|
|
"deler_plassen": 0.0,
|
|
"ikke_byggbar": 0.625,
|
|
"best_alene_blant_byggbare": 0.0,
|
|
},
|
|
"delt": {"andel": 0.0, "par": [{"losninger": ["A", "B"], "andel": 0.0}]},
|
|
"ingen": {"andel": 0.0},
|
|
}
|
|
assert norm["trinn"][0]["M7"] == df.sammenligning(sd.M7[5])
|
|
assert list(norm) == [
|
|
"navn",
|
|
"teller",
|
|
"trinn",
|
|
"del_I",
|
|
"del_I_avgjort",
|
|
"betingelser",
|
|
]
|
|
ved = kj.ved_siden_av_m6(kjoring.utfall(NORM, Losning.A, 5))["snitt"]
|
|
assert a["ved_siden_av_M6"]["snitt"] == {
|
|
"antall": ved.antall,
|
|
"median": ved.median,
|
|
"p10": ved.persentiler[0] if ved.persentiler else None,
|
|
"p90": ved.persentiler[1] if ved.persentiler else None,
|
|
}
|
|
# the conditions of A with the threshold that counts, and taken together
|
|
b = norm["betingelser"]["A"]
|
|
assert (b["felt"], b["maal"], b["kan_navngis"]) == (False, ["M1"], True)
|
|
terskel = b["terskler"]["M1"][0]
|
|
assert list(terskel) == [
|
|
"storrelse",
|
|
"retning",
|
|
"verdi",
|
|
"sannsynlighet",
|
|
"andel_oppfylt",
|
|
"teller",
|
|
"kilde",
|
|
"indeks",
|
|
"paavist",
|
|
"begge_halvdeler",
|
|
]
|
|
assert (terskel["storrelse"], terskel["retning"], terskel["verdi"]) == ("x", "høyst", 35.0)
|
|
assert terskel["teller"] is True
|
|
assert b["samtidig"]["valgt"]["M1"] == terskel
|
|
assert norm["del_I"] == "holder under betingelser"
|
|
assert norm["del_I_avgjort"] is True
|
|
|
|
|
|
def test_dommer_json_uten_terskler_sier_at_del_I_ikke_er_avgjort() -> None:
|
|
kjoring = _kjoring()
|
|
lest = _lest(df.lag_dommer(HODE, kjoring, kj.sett_dommer(kjoring, M5)))
|
|
assert isinstance(lest, dict)
|
|
norm = lest["per_scenario"][1]
|
|
assert (norm["del_I"], norm["del_I_avgjort"], norm["betingelser"]) == (
|
|
"holder under betingelser",
|
|
False,
|
|
None,
|
|
)
|
|
|
|
|
|
def test_tidslinje_json_har_tallene_over_trekningene() -> None:
|
|
kjoring = _kjoring()
|
|
lest = _lest(df.lag_tidslinje(HODE, kjoring))
|
|
assert isinstance(lest, dict)
|
|
assert lest["typer"] == [*(x.value for x in Kraft), "alle"]
|
|
linje = kj.tidslinje_over_trekningene(kjoring, Losning.B, 5)
|
|
rader = lest["per_losning"]["B"][0]["typer"]["ny fornybar kraft"]
|
|
assert lest["per_losning"]["B"][0]["trinn"] == 5
|
|
assert [r["aar"] for r in rader] == [2028, 2029, 2030]
|
|
for r, x in zip(rader, linje[Kraft.NY_FORNYBAR.value], strict=True):
|
|
assert r == {
|
|
"aar": x.aar,
|
|
"median": x.median,
|
|
"p10": x.persentiler[0],
|
|
"p90": x.persentiler[1],
|
|
"andel_minst_100_MW": x.andel_minst[0],
|
|
"andel_minst_1000_MW": x.andel_minst[1],
|
|
}
|
|
assert isinstance(rader[0]["aar"], int)
|
|
|
|
|
|
def test_sammenligningen_i_M7_staar_i_fast_rekkefolge_med_delt_og_ingen_sist() -> None:
|
|
"""Clarification 137 d: the four shares per solution, then «delt» with the pairs, «ingen»."""
|
|
m7 = kj.Sammenligning(
|
|
losninger={
|
|
Losning.A: kj.Bestandel(0.25, 0.25, 0.5, 0.5),
|
|
Losning.C: kj.Bestandel(0.25, 0.25, 0.0, 0.25),
|
|
Losning.T_K: kj.Bestandel(0.0, 0.0, 1.0, None),
|
|
},
|
|
delt=0.25,
|
|
par={
|
|
(Losning.A, Losning.C): 0.25,
|
|
(Losning.A, Losning.T_K): 0.0,
|
|
(Losning.C, Losning.T_K): 0.0,
|
|
},
|
|
ingen=0.25,
|
|
)
|
|
lest = _lest(df.sammenligning(m7))
|
|
assert isinstance(lest, dict)
|
|
assert list(lest) == ["A", "C", "T-K", "delt", "ingen"]
|
|
assert lest["T-K"] == {
|
|
"best_alene": 0.0,
|
|
"deler_plassen": 0.0,
|
|
"ikke_byggbar": 1.0,
|
|
"best_alene_blant_byggbare": None,
|
|
}
|
|
assert lest["delt"] == {
|
|
"andel": 0.25,
|
|
"par": [
|
|
{"losninger": ["A", "C"], "andel": 0.25},
|
|
{"losninger": ["A", "T-K"], "andel": 0.0},
|
|
{"losninger": ["C", "T-K"], "andel": 0.0},
|
|
],
|
|
}
|
|
assert lest["ingen"] == {"andel": 0.25}
|
|
alene = [lest[a]["best_alene"] for a in ("A", "C", "T-K")]
|
|
assert math.fsum([*alene, lest["delt"]["andel"], lest["ingen"]["andel"]]) == 1.0
|
|
|
|
|
|
def test_aksene_i_flatene_har_antall_og_median_per_klasse() -> None:
|
|
"""Clarification 134: five classes as the surface makes them; a class without draws is empty.
|
|
|
|
Ten values: the class is floor(5 r / 10), two draws per class, the median the midpoint.
|
|
Three distinct values in six draws: the classes 0, 1 and 3 (floor(5 r / 6) for r = 0, 2, 4).
|
|
"""
|
|
x = [10.0, 1.0, 9.0, 2.0, 8.0, 3.0, 7.0, 4.0, 6.0, 5.0]
|
|
assert df.akse(x) == [
|
|
{"antall": 2, "median": 1.5},
|
|
{"antall": 2, "median": 3.5},
|
|
{"antall": 2, "median": 5.5},
|
|
{"antall": 2, "median": 7.5},
|
|
{"antall": 2, "median": 9.5},
|
|
]
|
|
assert df.akse([1.0, 1.0, 2.0, 2.0, 3.0, 3.0]) == [
|
|
{"antall": 2, "median": 1.0},
|
|
{"antall": 2, "median": 2.0},
|
|
{"antall": 0, "median": None},
|
|
{"antall": 2, "median": 3.0},
|
|
{"antall": 0, "median": None},
|
|
]
|
|
assert df.akse([]) == [{"antall": 0, "median": None}] * 5
|
|
# the counts are those of the surface's cells summed along the other axis
|
|
y = [float(j % 3) for j in range(10)]
|
|
flate = terskler.flate(x, y, [1.0] * 10)
|
|
assert [sum(r.antall for r in rad) for rad in flate] == [k["antall"] for k in df.akse(x)] # type: ignore[index]
|
|
assert [sum(rad[j].antall for rad in flate) for j in range(5)] == [
|
|
k["antall"] # type: ignore[index]
|
|
for k in df.akse(y)
|
|
]
|
|
|
|
|
|
def test_hovedkjoringen_sier_fra_om_hver_fil_etter_hvert(tmp_path: Path) -> None:
|
|
"""Clarification 134: a line per file as it is made; the files are those it writes."""
|
|
sti = Path(__file__).resolve().parent / "oppdiktet" / "grunnlag.json"
|
|
data = json.loads(sti.read_text(encoding="utf-8"))
|
|
data["trekninger"] = data["trekninger"][:1]
|
|
liten = tmp_path / "grunnlag.json"
|
|
liten.write_text(json.dumps(data, ensure_ascii=False), encoding="utf-8")
|
|
laget: list[str] = []
|
|
skrevet = df.skriv_hovedkjoring(
|
|
gl.fra_fil(liten),
|
|
tmp_path / "ut",
|
|
stige=(1,),
|
|
filer=(df.DOMMER, df.TIDSLINJE),
|
|
laget=laget.append,
|
|
)
|
|
assert laget == list(skrevet) == [df.DOMMER, df.TIDSLINJE]
|
|
|
|
|
|
def test_d_stjerne_med_den_faste_eps_d_og_med_0_5_og_2() -> None:
|
|
assert df.d_stjerne(0.6, 1.0) == [
|
|
{"eps_d": 1.0, "d_stjerne": 0.4},
|
|
{"eps_d": 0.5, "d_stjerne": 0.8},
|
|
{"eps_d": 2.0, "d_stjerne": 0.2},
|
|
]
|
|
assert [x["d_stjerne"] for x in df.d_stjerne(None, 1.0)] == [None, None, None] # type: ignore[index]
|
|
|
|
|
|
# --------------------------------------------------------------- the comparison
|
|
|
|
|
|
def _mappe(sti: Path, filer: dict[str, object]) -> Path:
|
|
sti.mkdir()
|
|
for navn, data in filer.items():
|
|
df.skriv(sti / navn, data)
|
|
return sti
|
|
|
|
|
|
FILER: dict[str, object] = {
|
|
"dommer.json": {"trinn": 5, "andel": 0.1 + 0.2, "dom": "holder", "x": [1.5, None, True]},
|
|
"innhold.json": {"stige": [1, 5], "filer": {"dommer.json": "abc"}},
|
|
}
|
|
|
|
|
|
def test_like_mapper_er_identiske(tmp_path: Path) -> None:
|
|
a, b = _mappe(tmp_path / "a", FILER), _mappe(tmp_path / "b", FILER)
|
|
r = df.sammenlign_mapper(a, b, filer=tuple(FILER))
|
|
assert (r.dom, r.storste_avvik, r.hvor) == ("identisk", 0.0, None)
|
|
assert [f.dom for f in r.filer] == ["identisk", "identisk"]
|
|
|
|
|
|
def test_siste_siffer_er_innenfor_toleransen(tmp_path: Path) -> None:
|
|
andel = 0.1 + 0.2
|
|
ny = math.nextafter(andel, 1.0)
|
|
a = _mappe(tmp_path / "a", FILER)
|
|
b = _mappe(tmp_path / "b", {**FILER, "dommer.json": {**FILER["dommer.json"], "andel": ny}}) # type: ignore[dict-item]
|
|
r = df.sammenlign_mapper(a, b, filer=tuple(FILER))
|
|
assert r.dom == "innenfor toleranse"
|
|
assert r.filer[0].dom == "innenfor toleranse"
|
|
assert r.storste_avvik == abs(ny - andel) / ny
|
|
assert r.hvor == "dommer.json:$.andel"
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
("endring", "forskjell"),
|
|
[
|
|
({"andel": 0.30000001}, "$.andel"),
|
|
({"dom": "holder ikke"}, "$.dom"),
|
|
({"trinn": 5.0}, "$.trinn: heltall mot desimaltall"),
|
|
({"trinn": 6}, "$.trinn"),
|
|
({"x": [1.5, None, 1]}, "$.x[2]: sannhetsverdi mot heltall"),
|
|
({"x": [1.5, None]}, "$.x: 3 mot 2 elementer"),
|
|
],
|
|
)
|
|
def test_alt_annet_er_endret(tmp_path: Path, endring: dict[str, object], forskjell: str) -> None:
|
|
dommer = FILER["dommer.json"]
|
|
assert isinstance(dommer, dict)
|
|
a = _mappe(tmp_path / "a", FILER)
|
|
b = _mappe(tmp_path / "b", {**FILER, "dommer.json": {**dommer, **endring}})
|
|
r = df.sammenlign_mapper(a, b, filer=tuple(FILER))
|
|
assert r.dom == "endret"
|
|
assert r.filer[0].forskjell is not None
|
|
assert r.filer[0].forskjell.startswith(forskjell)
|
|
|
|
|
|
def test_feltenes_rekkefolge_og_et_felt_som_mangler_er_endret(tmp_path: Path) -> None:
|
|
dommer = FILER["dommer.json"]
|
|
assert isinstance(dommer, dict)
|
|
snudd = dict(reversed(list(dommer.items())))
|
|
uten = {k: v for k, v in dommer.items() if k != "dom"}
|
|
for nr, endret in enumerate((snudd, uten)):
|
|
a = _mappe(tmp_path / f"a{nr}", FILER)
|
|
b = _mappe(tmp_path / f"b{nr}", {**FILER, "dommer.json": endret})
|
|
r = df.sammenlign_mapper(a, b, filer=tuple(FILER))
|
|
assert r.dom == "endret"
|
|
assert r.filer[0].forskjell == "$: ulike felt eller ulik rekkefølge"
|
|
|
|
|
|
def test_en_fil_som_mangler_er_endret(tmp_path: Path) -> None:
|
|
a = _mappe(tmp_path / "a", FILER)
|
|
b = _mappe(tmp_path / "b", {"innhold.json": FILER["innhold.json"]})
|
|
r = df.sammenlign_mapper(a, b, filer=tuple(FILER))
|
|
assert r.dom == "endret"
|
|
assert r.filer[0].forskjell == "den lagrede fila finnes ikke"
|
|
|
|
|
|
def test_sjekksummene_i_innhold_holdes_utenfor_den_tolerante_proven(tmp_path: Path) -> None:
|
|
a = _mappe(tmp_path / "a", FILER)
|
|
b = _mappe(
|
|
tmp_path / "b",
|
|
{**FILER, "innhold.json": {"stige": [1, 5], "filer": {"dommer.json": "def"}}},
|
|
)
|
|
r = df.sammenlign_mapper(a, b, filer=tuple(FILER))
|
|
assert [f.dom for f in r.filer] == ["identisk", "innenfor toleranse"]
|
|
assert r.dom == "innenfor toleranse"
|
|
c = tmp_path / "c"
|
|
shutil.copytree(b, c)
|
|
df.skriv(c / "innhold.json", {"stige": [1, 6], "filer": {"dommer.json": "def"}})
|
|
assert df.sammenlign_mapper(a, c, filer=tuple(FILER)).dom == "endret"
|