feat(dommer): the power solutions compared on equal terms, and the axes of the surfaces (clarifications 134, 135 and 137)
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>
This commit is contained in:
parent
d650ce219e
commit
5a54fba628
15 changed files with 8804 additions and 758 deletions
File diff suppressed because it is too large
Load diff
File diff suppressed because it is too large
Load diff
|
|
@ -29,10 +29,10 @@
|
|||
"T-K"
|
||||
],
|
||||
"filer": {
|
||||
"dommer.json": "39ba305e19ae04bb77c912d0c7c5547d5e225ca60bd3277000a0ed4890c202b8",
|
||||
"dommer.json": "12ef6afb87d9a161fda090741fe7d6f45bf1c8070ba51304779475eed0962a96",
|
||||
"tidslinje.json": "a6dd290e13a2cee9de1b5030aea553f3c592a64c01ec67d1e6081b7038dbe5bf",
|
||||
"eierformer.json": "5460b8e836edb60638ea56db239ad0d2d1a7ba939c50a55e0deb147a5ca38342",
|
||||
"terskler.json": "6d8df88997947a1bf980258ef7076e1cb97856af100dd0cce1de5bae67f1677e",
|
||||
"folsomheter.json": "879248ce9753a3f76a8df98fb726fb6431a672913f233621d2a85cfa192a54fa"
|
||||
"terskler.json": "b892ba98bdaab46e6d104f21e4182a87ba92ea9047a0151a3175bc62363271f5",
|
||||
"folsomheter.json": "afa6eb1712497eaa22887a2a09f6da31e28396100f5f2a9f022b102ff29bf2da"
|
||||
}
|
||||
}
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -10,19 +10,20 @@ 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 pathlib import Path
|
||||
|
||||
from tokenfabrikker.kjoring import Scenario
|
||||
|
||||
NORM, VARER = kj.SCENARIOER[1], kj.SCENARIOER[0]
|
||||
|
|
@ -134,7 +135,6 @@ def test_dommer_json_har_tallene_sett_dommer_gir() -> None:
|
|||
"grunnlag_for_trinnet",
|
||||
"teller",
|
||||
"del_I",
|
||||
"del_II",
|
||||
"per_scenario",
|
||||
]
|
||||
assert (lest["trinn"], lest["grunnlag_for_trinnet"]) == (5, "25 %-trinnet")
|
||||
|
|
@ -157,7 +157,32 @@ def test_dommer_json_har_tallene_sett_dommer_gir() -> None:
|
|||
# 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
|
||||
assert norm["trinn"][0]["M7"]["dom"] == sd.M7[5].dom.value
|
||||
# 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,
|
||||
|
|
@ -221,6 +246,94 @@ def test_tidslinje_json_har_tallene_over_trekningene() -> None:
|
|||
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},
|
||||
|
|
|
|||
|
|
@ -61,7 +61,7 @@ def test_trekning_uten_verdi_teller_i_nevneren() -> None:
|
|||
assert dommer.median(_utfall((1.0, 4), (None, 6))) == -math.inf
|
||||
|
||||
|
||||
# -------------------------------------------------------------- M1, M2, M7
|
||||
# -------------------------------------------------------------- M1, M2
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
|
|
@ -88,23 +88,32 @@ def test_dom_m2_teller_null_som_oppfylt() -> None:
|
|||
assert dommer.dom_m2(_utfall((1.0, 10), (-1.0, 50), (None, 40))) is Dom.HOLDER_IKKE
|
||||
|
||||
|
||||
def test_dom_m7_a_mot_b_og_c() -> None:
|
||||
"""A is best in 5 of 10 draws: holds. A draw where A cannot be built is not one of them.
|
||||
def test_m7_hvem_som_er_best_blant_a_b_og_c() -> None:
|
||||
"""Clarification 137 a, one rule for each: the highest value among those that can be built.
|
||||
|
||||
The two versions of solution T are left out here; ``test_trinnvis_dommer.py`` has all five.
|
||||
Ten draws. 0-4: A highest. 5-7: B highest (A lower, C equal to A in 5-7). 8-9: A cannot
|
||||
be built, B is negative and C cannot be built either: B is best alone. The two versions of
|
||||
solution T are left out here; ``test_trinnvis_dommer.py`` has all five.
|
||||
"""
|
||||
A = _utfall((10.0, 5), (1.0, 3), (None, 2))
|
||||
B = _utfall((5.0, 5), (2.0, 3), (-9.0, 2))
|
||||
C = _utfall((None, 5), (0.0, 5))
|
||||
assert dommer.a_er_best({Losning.A: A, Losning.B: B, Losning.C: C}) == [True] * 5 + [False] * 5
|
||||
assert dommer.dom_m7({Losning.A: A, Losning.B: B, Losning.C: C}) is Dom.HOLDER
|
||||
alltid_bedre = _utfall((5.0, 5), (2.0, 5))
|
||||
fire = {Losning.A: _utfall((10.0, 4), (1.0, 6)), Losning.B: alltid_bedre, Losning.C: C}
|
||||
assert dommer.dom_m7(fire) is Dom.BETINGELSER
|
||||
en = {Losning.A: _utfall((10.0, 1), (1.0, 9)), Losning.B: alltid_bedre, Losning.C: C}
|
||||
assert dommer.dom_m7(en) is Dom.HOLDER_IKKE
|
||||
# equal is not best
|
||||
assert dommer.a_er_best({Losning.A: [1.0], Losning.B: [1.0], Losning.C: [0.0]}) == [False]
|
||||
C = _utfall((None, 5), (1.0, 3), (None, 2))
|
||||
beste = dommer.beste_per_trekning({Losning.A: A, Losning.B: B, Losning.C: C})
|
||||
assert beste == [(Losning.A,)] * 5 + [(Losning.B,)] * 5
|
||||
# equal values share the place, in the order A, B, C; none built leaves none
|
||||
assert dommer.beste_per_trekning({Losning.A: [1.0], Losning.B: [1.0], Losning.C: [0.0]}) == [
|
||||
(Losning.A, Losning.B)
|
||||
]
|
||||
assert dommer.beste_per_trekning({Losning.C: [3.0], Losning.B: [2.0], Losning.A: [3.0]}) == [
|
||||
(Losning.A, Losning.C)
|
||||
]
|
||||
assert dommer.beste_per_trekning({Losning.A: [None], Losning.B: [None], Losning.C: [None]}) == [
|
||||
()
|
||||
]
|
||||
# C can be best as A can, and a solution that cannot be built is never among the best
|
||||
assert dommer.beste_per_trekning({Losning.A: [None], Losning.B: [-1.0], Losning.C: [0.0]}) == [
|
||||
(Losning.C,)
|
||||
]
|
||||
|
||||
|
||||
# ------------------------------------------------------------------ M3 and M4
|
||||
|
|
@ -320,10 +329,6 @@ def test_del_I_ser_ikke_paa_referansekjoringen() -> None:
|
|||
assert dommer.del_I(per_losning, median, Trinnvalg(10, Grunnlag.TRINN_25)) is Dom.HOLDER_IKKE
|
||||
|
||||
|
||||
def test_del_II_folger_M7() -> None:
|
||||
assert dommer.del_II(Dom.BETINGELSER) is Dom.BETINGELSER
|
||||
|
||||
|
||||
def test_hvor_mye_av_dommen_som_skyldes_baner_som_ikke_lar_seg_bygge() -> None:
|
||||
"""Clarification 69: 2 of 8 draws cannot be built; 3 of the 6 others meet the condition."""
|
||||
oppfylt = [True, None, False, True, None, False, True, False]
|
||||
|
|
|
|||
|
|
@ -7,6 +7,7 @@ draw for the table. Nothing here says anything about the hypothesis.
|
|||
from __future__ import annotations
|
||||
|
||||
import dataclasses
|
||||
import math
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
import pytest
|
||||
|
|
@ -457,7 +458,7 @@ def test_hovedkjoringen_i_tabellen_er_dommene_paa_trinnet() -> None:
|
|||
norm = d.scenarioer[NORM.navn]
|
||||
assert (t.rad, t.scenario, t.gjelder) == (fs.HOVEDKJORINGEN, NORM.navn, ())
|
||||
assert t.losninger == norm.per_trinn[5]
|
||||
assert (t.M7, t.del_I, t.del_II) == (norm.M7[5], norm.del_I, norm.del_II)
|
||||
assert (t.M7, t.del_I) == (norm.M7[5], norm.del_I)
|
||||
assert t.ved_siden_av[Losning.A] == kj.ved_siden_av_m6(hoved.utfall(NORM, Losning.A, 5))
|
||||
with pytest.raises(ValueError, match="no table"):
|
||||
fs.hovedtabell(hoved, M5, Trinnvalg(trinn=None, grunnlag=Grunnlag.INGEN), NORM)
|
||||
|
|
@ -474,13 +475,17 @@ def test_en_rad_i_tabellen_har_radens_utfall_der_den_gjelder_og_hovedkjoringens_
|
|||
assert t.losninger[Losning.C] == fs.hovedtabell(hoved, M5, VALG, NORM).losninger[Losning.C]
|
||||
a = t.losninger[Losning.A]
|
||||
assert (a.maal["M1"].andel_holder, a.maal["M1"].dom, a.median_M1) == (1.0, Dom.HOLDER, 0.1)
|
||||
# the comparison from the row's outcomes: A best in 2, C (the main run's) in 8; no verdict
|
||||
assert t.M7 is not None
|
||||
assert (t.M7.andel_holder, t.M7.dom) == (0.2, Dom.BETINGELSER)
|
||||
assert (t.del_I, t.del_II) == (Dom.HOLDER, Dom.BETINGELSER)
|
||||
assert {a: b.best_alene for a, b in t.M7.losninger.items()} == {Losning.A: 0.2, Losning.C: 0.8}
|
||||
assert (t.M7.delt, t.M7.ingen) == (0.0, 0.0)
|
||||
assert t.del_I is Dom.HOLDER
|
||||
# the main run next to it: 7 of 10 positive, and A best in those 7
|
||||
h = fs.hovedtabell(hoved, M5, VALG, NORM)
|
||||
assert h.M7 is not None
|
||||
assert (h.losninger[Losning.A].maal["M1"].andel_holder, h.M7.andel_holder) == (0.7, 0.7)
|
||||
a_best = h.M7.losninger[Losning.A].best_alene
|
||||
assert (h.losninger[Losning.A].maal["M1"].andel_holder, a_best) == (0.7, 0.7)
|
||||
assert h.M7.losninger[Losning.C].best_alene == 0.3
|
||||
# without a run of the row every solution has the main run's figures
|
||||
(uten,) = fs.tabell(hoved, RADER["3"], None, M5, VALG).values()
|
||||
assert (uten.losninger, uten.M7, uten.del_I) == (h.losninger, h.M7, h.del_I)
|
||||
|
|
@ -504,16 +509,67 @@ def test_M6_mot_medianen_er_en_dom_og_ingen_kjoring() -> None:
|
|||
|
||||
|
||||
def test_C_i_moduler_staar_paa_plassen_til_C_og_endrer_ikke_M7_og_del_I() -> None:
|
||||
"""Row 35: the path beats A in every draw, and is still not one of the five solutions."""
|
||||
"""Row 35: the path beats A in one draw, and is still not one of the five solutions.
|
||||
|
||||
The comparison is the main run's (clarification 135 e): A is best in every draw there.
|
||||
"""
|
||||
hoved = _kjoring([{Losning.A: _u(1.0), Losning.C: _u(0.5)} for _ in range(10)])
|
||||
radkjoring = _kjoring([{Losning.C: _u(-2.0 if j < 9 else 3.0)} for j in range(10)])
|
||||
(t,) = fs.tabell(hoved, RADER["35"], radkjoring, M5, VALG).values()
|
||||
h = fs.hovedtabell(hoved, M5, VALG, NORM)
|
||||
assert t.losninger[Losning.C].maal["M1"].andel_holder == 0.1
|
||||
assert t.losninger[Losning.C].median_M1 == -2.0
|
||||
assert (t.M7, t.del_I, t.del_II) == (h.M7, h.del_I, h.del_II)
|
||||
assert (t.M7, t.del_I) == (h.M7, h.del_I)
|
||||
assert h.M7 is not None
|
||||
assert h.M7.andel_holder == 1.0
|
||||
assert (h.M7.losninger[Losning.A].best_alene, h.M7.losninger[Losning.C].best_alene) == (1.0, 0)
|
||||
|
||||
|
||||
def test_sammenligningen_i_tabellen_gjelder_de_fem_og_summerer_til_en() -> None:
|
||||
"""Clarifications 135 e and 137: row 22 (B, B', C, T-F, T-K) with B' highest, not compared.
|
||||
|
||||
Main run: A 2.0, B 1.0, C 1.0, T-F 0.5, T-K cannot be built in the last two of ten. In the
|
||||
row B rises to 2.0 in the first five draws (sharing the place with A) and to 3.0 in the
|
||||
next five.
|
||||
"""
|
||||
alle = (Losning.A, Losning.B, Losning.B_MERKET, Losning.C, Losning.T_F, Losning.T_K)
|
||||
|
||||
def hovedtrekning(j: int) -> dict[Losning, Utfall | None]:
|
||||
verdier = {Losning.A: 2.0, Losning.B: 1.0, Losning.B_MERKET: 99.0, Losning.C: 1.0}
|
||||
u: dict[Losning, Utfall | None] = {a: _u(v) for a, v in verdier.items()}
|
||||
return {**u, Losning.T_F: _u(0.5), Losning.T_K: None if j >= 8 else _u(0.0)}
|
||||
|
||||
hoved = _kjoring([hovedtrekning(j) for j in range(10)])
|
||||
assert hoved.losninger == alle
|
||||
egne = (Losning.B, Losning.B_MERKET, Losning.C, Losning.T_F, Losning.T_K)
|
||||
radkjoring = _kjoring(
|
||||
[
|
||||
{
|
||||
**{a: hovedtrekning(j)[a] for a in egne},
|
||||
Losning.B: _u(2.0 if j < 5 else 3.0),
|
||||
}
|
||||
for j in range(10)
|
||||
]
|
||||
)
|
||||
(t,) = fs.tabell(hoved, RADER["22"], radkjoring, M5, VALG).values()
|
||||
assert t.gjelder == egne
|
||||
assert t.M7 is not None
|
||||
assert list(t.M7.losninger) == [Losning.A, Losning.B, Losning.C, Losning.T_F, Losning.T_K]
|
||||
andeler = {a: b.best_alene for a, b in t.M7.losninger.items()}
|
||||
assert andeler == {
|
||||
Losning.A: 0.0,
|
||||
Losning.B: 0.5,
|
||||
Losning.C: 0.0,
|
||||
Losning.T_F: 0.0,
|
||||
Losning.T_K: 0.0,
|
||||
}
|
||||
assert (t.M7.delt, t.M7.ingen) == (0.5, 0.0)
|
||||
assert t.M7.losninger[Losning.A].deler_plassen == 0.5
|
||||
assert [p for p, x in t.M7.par.items() if x > 0] == [(Losning.A, Losning.B)]
|
||||
assert t.M7.losninger[Losning.T_K].ikke_byggbar == 0.2
|
||||
assert math.fsum([*andeler.values(), t.M7.delt, t.M7.ingen]) == 1.0
|
||||
h = fs.hovedtabell(hoved, M5, VALG, NORM)
|
||||
assert h.M7 is not None
|
||||
assert (h.M7.losninger[Losning.A].best_alene, h.M7.delt, h.M7.ingen) == (1.0, 0.0, 0.0)
|
||||
|
||||
|
||||
def test_tabellen_har_en_rad_per_scenario_raden_leses_av_i() -> None:
|
||||
|
|
|
|||
|
|
@ -297,15 +297,20 @@ def test_trinnet_settes_i_normalisering_og_gjelder_alle_scenarioene() -> None:
|
|||
d = kj.sett_dommer(_kjoring([trekning() for _ in range(5)]), M5)
|
||||
assert (d.valg.trinn, d.valg.grunnlag) == (5, Grunnlag.TRINN_25)
|
||||
assert d.teller == NORM.navn
|
||||
assert (d.del_I, d.del_II) == (Dom.HOLDER, Dom.HOLDER_IKKE)
|
||||
assert d.del_I is Dom.HOLDER
|
||||
varer = d.scenarioer[VARER.navn]
|
||||
assert (varer.del_I, varer.del_II) == (Dom.HOLDER, Dom.HOLDER_IKKE)
|
||||
assert varer.del_I is Dom.HOLDER
|
||||
assert varer.per_trinn[1][Losning.C].maal["M6"].dom is Dom.HOLDER
|
||||
assert d.scenarioer[NORM.navn].per_trinn[1][Losning.C].maal["M6"].dom is Dom.BETINGELSER
|
||||
assert set(varer.per_trinn[5]) == {Losning.A, Losning.C, Losning.R}
|
||||
assert varer.per_trinn[5][Losning.R].maal["M6"].dom is Dom.HOLDER
|
||||
# the comparison is on every step, among A and C; R is not part of it
|
||||
assert set(varer.M7) == {1, 5}
|
||||
assert varer.M7[5].andel_holder == 0.0
|
||||
assert list(varer.M7[5].losninger) == [Losning.A, Losning.C]
|
||||
assert varer.M7[5].losninger[Losning.A].best_alene == 0.0
|
||||
assert (varer.M7[5].delt, varer.M7[5].ingen) == (0.0, 0.0)
|
||||
assert varer.M7[5].losninger[Losning.C].best_alene == 1.0
|
||||
assert varer.M7[5].par == {(Losning.A, Losning.C): 0.0}
|
||||
|
||||
|
||||
def test_del_I_leses_paa_trinnet_fra_normalisering_ogsaa_naar_scenarioet_er_svakere() -> None:
|
||||
|
|
@ -319,15 +324,18 @@ def test_del_I_leses_paa_trinnet_fra_normalisering_ogsaa_naar_scenarioet_er_svak
|
|||
kjoring = _kjoring([trekning() for _ in range(4)], scenarioer=(LAVT, NORM))
|
||||
d = kj.sett_dommer(kjoring, {Losning.A: Dom.HOLDER})
|
||||
assert (d.valg.trinn, d.valg.grunnlag) == (2, Grunnlag.TRINN_25)
|
||||
assert (d.del_I, d.del_II) == (Dom.HOLDER, Dom.HOLDER)
|
||||
assert d.del_I is Dom.HOLDER
|
||||
lavt = d.scenarioer[LAVT.navn]
|
||||
assert lavt.per_trinn[2][Losning.A].felt
|
||||
# part II follows M7: A is alone in the run and is best wherever it can be built
|
||||
assert (lavt.del_I, lavt.del_II) == (Dom.HOLDER_IKKE, Dom.HOLDER)
|
||||
assert lavt.del_I is Dom.HOLDER_IKKE
|
||||
# A is alone in the run and is best wherever it can be built, whatever its value
|
||||
m7 = lavt.M7[2]
|
||||
assert (m7.losninger[Losning.A].best_alene, m7.delt, m7.ingen, m7.par) == (1.0, 0.0, 0.0, {})
|
||||
|
||||
|
||||
def test_M7_teller_A_mot_de_som_lar_seg_bygge_og_viser_tallene_for_A() -> None:
|
||||
# A is best in draws 0, 2 (C cannot be built there) and 4; equal in 1; not built in 3
|
||||
def test_M7_sammenligner_de_som_lar_seg_bygge_og_viser_tallene_for_hver() -> None:
|
||||
# A is best alone in draws 0, 2 (C cannot be built there) and 4; the two share draw 1;
|
||||
# C is best alone in 3
|
||||
per_trekning: list[dict[tuple[Losning, int], dict[str, Utfall] | None]] = [
|
||||
{(Losning.A, 1): _alle(_u(5.0)), (Losning.C, 1): _alle(_u(1.0))},
|
||||
{(Losning.A, 1): _alle(_u(1.0)), (Losning.C, 1): _alle(_u(1.0))},
|
||||
|
|
@ -338,16 +346,20 @@ def test_M7_teller_A_mot_de_som_lar_seg_bygge_og_viser_tallene_for_A() -> None:
|
|||
M5 = {Losning.A: Dom.HOLDER, Losning.C: Dom.HOLDER}
|
||||
d = kj.sett_dommer(_kjoring(per_trekning), M5)
|
||||
m7 = d.scenarioer[NORM.navn].M7[1]
|
||||
assert m7.andel_holder == 0.6
|
||||
assert m7.dom is Dom.HOLDER
|
||||
assert m7.andel_holder_ikke is None
|
||||
assert m7.ikke_byggbar == 0.2
|
||||
assert m7.oppfylt_blant_byggbare == 0.75
|
||||
assert m7.losninger == {
|
||||
Losning.A: kj.Bestandel(
|
||||
best_alene=0.6, deler_plassen=0.2, ikke_byggbar=0.2, best_alene_blant_byggbare=0.75
|
||||
),
|
||||
Losning.C: kj.Bestandel(
|
||||
best_alene=0.2, deler_plassen=0.2, ikke_byggbar=0.2, best_alene_blant_byggbare=0.25
|
||||
),
|
||||
}
|
||||
assert (m7.delt, m7.par, m7.ingen) == (0.2, {(Losning.A, Losning.C): 0.2}, 0.0)
|
||||
# step 1 holds 25 % but a single facility cannot give «holder» for part I
|
||||
assert (d.valg.trinn, d.del_I, d.del_II) == (1, Dom.BETINGELSER, Dom.HOLDER)
|
||||
assert (d.valg.trinn, d.del_I) == (1, Dom.BETINGELSER)
|
||||
|
||||
|
||||
def test_uten_noe_trinn_holder_ikke_del_I_og_del_II_har_ingen_dom() -> None:
|
||||
def test_uten_noe_trinn_holder_ikke_del_I_og_M7_vises_likevel() -> None:
|
||||
# the path is built in half the draws on both steps: no step can be built in 80 %
|
||||
per_trekning: list[dict[tuple[Losning, int], dict[str, Utfall] | None]] = [
|
||||
{(Losning.A, 1): _alle(_u()), (Losning.A, 2): _alle(_u())},
|
||||
|
|
@ -356,9 +368,173 @@ def test_uten_noe_trinn_holder_ikke_del_I_og_del_II_har_ingen_dom() -> None:
|
|||
d = kj.sett_dommer(_kjoring(per_trekning), {Losning.A: Dom.HOLDER})
|
||||
assert (d.valg.trinn, d.valg.grunnlag) == (None, Grunnlag.INGEN)
|
||||
assert d.del_I is Dom.HOLDER_IKKE
|
||||
assert d.del_II is None
|
||||
# M7 is still shown on every step
|
||||
assert d.scenarioer[NORM.navn].M7[2].andel_holder == 0.5
|
||||
# the comparison is still shown on every step: A is best where it can be built
|
||||
m7 = d.scenarioer[NORM.navn].M7[2]
|
||||
assert (m7.losninger[Losning.A].best_alene, m7.delt, m7.ingen) == (0.5, 0.0, 0.5)
|
||||
assert not hasattr(d, "del_II")
|
||||
|
||||
|
||||
FEM = (Losning.A, Losning.B, Losning.C, Losning.T_F, Losning.T_K)
|
||||
|
||||
FEM_NNV: dict[Losning, list[float | None]] = {
|
||||
# draw: 0 1 2 3 4 5 6 7 8 9
|
||||
Losning.A: [9.0, 1.0, 1.0, 1.0, 1.0, None, None, 3.0, 1.0, None],
|
||||
Losning.B: [1.0, 9.0, 1.0, 1.0, 1.0, None, None, None, 1.0, 5.0],
|
||||
Losning.C: [1.0, 1.0, 9.0, 1.0, None, None, None, 3.0, 1.0, 5.0],
|
||||
Losning.T_F: [1.0, 1.0, 1.0, 9.0, 1.0, None, None, 2.0, 4.0, 5.0],
|
||||
Losning.T_K: [1.0, 1.0, 1.0, 1.0, 9.0, -5.0, None, 1.0, 4.0, 4.0],
|
||||
}
|
||||
"""Ten invented draws: A, B, C, T-F and T-K best alone in turn in 0 to 4; T-K alone (and
|
||||
negative) in 5; nothing built in 6; A and C share in 7; T-F and T-K the same path in 8; B, C
|
||||
and T-F share in 9, where A cannot be built."""
|
||||
|
||||
|
||||
def _fem_kjoring(uten: tuple[Losning, ...] = ()) -> Kjoring:
|
||||
"""The draws of ``FEM_NNV`` on step 1, with R and B' far above and not compared."""
|
||||
|
||||
def bane(a: Losning, j: int) -> dict[str, Utfall] | None:
|
||||
v = FEM_NNV[a][j]
|
||||
return None if v is None else _alle(_u(v))
|
||||
|
||||
return _kjoring(
|
||||
[
|
||||
{
|
||||
**{(a, 1): bane(a, j) for a in FEM if a not in uten},
|
||||
(Losning.R, 1): _alle(_u(100.0)),
|
||||
(Losning.B_MERKET, 1): _alle(_u(100.0)),
|
||||
}
|
||||
for j in range(10)
|
||||
]
|
||||
)
|
||||
|
||||
|
||||
def test_sammenligningen_av_de_fem_haandregnet() -> None:
|
||||
"""Clarification 137 b on the ten draws of ``FEM_NNV``.
|
||||
|
||||
A: alone in 0, shares 7, not built in 5, 6, 9, alone in 1 of its 7. B: alone in 1, shares
|
||||
9, not built in 5, 6, 7, 1 of 7. C: alone in 2, shares 7 and 9, not built in 4, 5, 6, 1 of
|
||||
7. T-F: alone in 3, shares 8 and 9, not built in 5, 6, 1 of 8. T-K: alone in 4 and 5,
|
||||
shares 8, not built in 6, 2 of 9. Shared in 7, 8, 9; none built in 6.
|
||||
"""
|
||||
m7 = kj.sammenligning(FEM_NNV)
|
||||
assert list(m7.losninger) == list(FEM)
|
||||
assert {a: dataclasses.astuple(b) for a, b in m7.losninger.items()} == {
|
||||
Losning.A: (1 / 10, 1 / 10, 3 / 10, 1 / 7),
|
||||
Losning.B: (1 / 10, 1 / 10, 3 / 10, 1 / 7),
|
||||
Losning.C: (1 / 10, 2 / 10, 3 / 10, 1 / 7),
|
||||
Losning.T_F: (1 / 10, 2 / 10, 2 / 10, 1 / 8),
|
||||
Losning.T_K: (2 / 10, 1 / 10, 1 / 10, 2 / 9),
|
||||
}
|
||||
assert (m7.delt, m7.ingen) == (3 / 10, 1 / 10)
|
||||
# every pair in the fixed order; the three sharing draw 9 count for each of their pairs
|
||||
A, B, C, TF, TK = FEM
|
||||
assert list(m7.par.items()) == [
|
||||
((A, B), 0.0),
|
||||
((A, C), 1 / 10),
|
||||
((A, TF), 0.0),
|
||||
((A, TK), 0.0),
|
||||
((B, C), 1 / 10),
|
||||
((B, TF), 1 / 10),
|
||||
((B, TK), 0.0),
|
||||
((C, TF), 1 / 10),
|
||||
((C, TK), 0.0),
|
||||
((TF, TK), 1 / 10),
|
||||
]
|
||||
# «best alene» of the five, «delt» and «ingen» sum to one (exactly in counts: 6 + 3 + 1)
|
||||
summen = math.fsum([*(b.best_alene for b in m7.losninger.values()), m7.delt, m7.ingen])
|
||||
assert summen == pytest.approx(1.0, rel=0.0, abs=1e-15)
|
||||
# the order the solutions are passed in does not matter
|
||||
assert kj.sammenligning({a: FEM_NNV[a] for a in reversed(FEM)}) == m7
|
||||
|
||||
|
||||
def test_T_F_og_T_K_som_samme_bane_deler_plassen_og_er_ikke_ingen() -> None:
|
||||
"""Clarification 137: where T-K gets no nuclear power it is T-F, and the two share the top."""
|
||||
lik: list[float | None] = [7.0, 7.0, 7.0, 7.0]
|
||||
nnv: dict[Losning, list[float | None]] = {
|
||||
Losning.A: [1.0, 9.0, None, None],
|
||||
Losning.B: [1.0, 1.0, None, None],
|
||||
Losning.C: [None, 1.0, None, None],
|
||||
Losning.T_F: lik,
|
||||
Losning.T_K: [*lik[:3], 8.0],
|
||||
}
|
||||
m7 = kj.sammenligning(nnv)
|
||||
assert (m7.delt, m7.ingen) == (0.5, 0.0)
|
||||
assert m7.par[Losning.T_F, Losning.T_K] == 0.5
|
||||
assert m7.losninger[Losning.T_F].deler_plassen == 0.5
|
||||
assert m7.losninger[Losning.T_K].best_alene == 0.25
|
||||
assert m7.losninger[Losning.A].best_alene == 0.25
|
||||
|
||||
|
||||
def test_en_losning_som_ikke_lar_seg_bygge_er_aldri_best() -> None:
|
||||
"""B is never built; under it the four others share the top, or nothing is built."""
|
||||
nnv = {a: [None if a is Losning.B else 0.0, 5.0 if a is Losning.B else None] for a in FEM}
|
||||
nnv[Losning.B] = [None, None]
|
||||
m7 = kj.sammenligning(nnv)
|
||||
b = m7.losninger[Losning.B]
|
||||
assert dataclasses.astuple(b) == (0.0, 0.0, 1.0, None)
|
||||
# draw 0: the four others share the top at zero; draw 1: nothing is built
|
||||
assert (m7.delt, m7.ingen) == (0.5, 0.5)
|
||||
assert all(x.best_alene == 0.0 for x in m7.losninger.values())
|
||||
assert [a for a, x in m7.losninger.items() if x.deler_plassen == 0.5] == [
|
||||
Losning.A,
|
||||
Losning.C,
|
||||
Losning.T_F,
|
||||
Losning.T_K,
|
||||
]
|
||||
assert [p for p, x in m7.par.items() if x == 0.5] == [
|
||||
(Losning.A, Losning.C),
|
||||
(Losning.A, Losning.T_F),
|
||||
(Losning.A, Losning.T_K),
|
||||
(Losning.C, Losning.T_F),
|
||||
(Losning.C, Losning.T_K),
|
||||
(Losning.T_F, Losning.T_K),
|
||||
]
|
||||
|
||||
|
||||
def test_sammenligningen_gjennom_kjoringen_og_uten_A() -> None:
|
||||
"""The run puts the comparison together from the outcomes; R and B' are left out of it."""
|
||||
kjoring = _fem_kjoring()
|
||||
d = kj.sett_dommer(kjoring, dict.fromkeys(kjoring.losninger, Dom.HOLDER))
|
||||
for scenario in (NORM, VARER):
|
||||
assert d.scenarioer[scenario.navn].M7[1] == kj.sammenligning(FEM_NNV)
|
||||
# a run without A compares the four that are in it
|
||||
uten_a = _fem_kjoring(uten=(Losning.A,))
|
||||
m7 = (
|
||||
kj.sett_dommer(uten_a, dict.fromkeys(uten_a.losninger, Dom.HOLDER))
|
||||
.scenarioer[NORM.navn]
|
||||
.M7[1]
|
||||
)
|
||||
assert list(m7.losninger) == [Losning.B, Losning.C, Losning.T_F, Losning.T_K]
|
||||
assert m7 == kj.sammenligning({a: FEM_NNV[a] for a in FEM if a is not Losning.A})
|
||||
# draw 0: the four share at 1; draw 7: C alone; shared in 0, 8 and 9, none built in 6
|
||||
assert (m7.delt, m7.ingen) == (3 / 10, 1 / 10)
|
||||
assert m7.losninger[Losning.C].best_alene == 2 / 10
|
||||
assert m7.par[Losning.B, Losning.C] == 2 / 10
|
||||
assert len(m7.par) == 6
|
||||
# a run with none of the five has no comparison
|
||||
bare_r = _kjoring([{(Losning.R, 1): _alle(_u())}])
|
||||
assert kj.sett_dommer(bare_r, {Losning.R: Dom.HOLDER}).scenarioer[NORM.navn].M7 == {}
|
||||
|
||||
|
||||
def test_sobol_utfallet_M7_er_blant_de_beste_alene_eller_delt() -> None:
|
||||
"""Clarification 137 c: one where the solution is among the best, alone or shared."""
|
||||
kjoring = _fem_kjoring()
|
||||
best = {a: kj.utfall_for_indeksene(kjoring, a, 1)["M7"] for a in FEM}
|
||||
assert best == {
|
||||
Losning.A: [1.0, 0, 0, 0, 0, 0, 0, 1.0, 0, 0],
|
||||
Losning.B: [0, 1.0, 0, 0, 0, 0, 0, 0, 0, 1.0],
|
||||
Losning.C: [0, 0, 1.0, 0, 0, 0, 0, 1.0, 0, 1.0],
|
||||
Losning.T_F: [0, 0, 0, 1.0, 0, 0, 0, 0, 1.0, 1.0],
|
||||
Losning.T_K: [0, 0, 0, 0, 1.0, 1.0, 0, 0, 1.0, 0],
|
||||
}
|
||||
assert "M7" not in kj.utfall_for_indeksene(kjoring, Losning.R, 1)
|
||||
x = [float(j) for j in range(10)]
|
||||
indekser = kj.sobol_indekser(kjoring, {"x": x}, Losning.T_K, 1)
|
||||
# two classes of five: T-K is among the best in 1 of the lower and 2 of the upper
|
||||
snitt = 3 / 10
|
||||
mellom = 5 * (0.2 - snitt) ** 2 + 5 * (0.4 - snitt) ** 2
|
||||
total = 3 * (1 - snitt) ** 2 + 7 * (0 - snitt) ** 2
|
||||
assert indekser["M7"]["x"] == pytest.approx(mellom / total)
|
||||
|
||||
|
||||
def test_dommene_trenger_normalisering_paa_hovedforlopet_en_gang() -> None:
|
||||
|
|
@ -722,8 +898,11 @@ def test_M5_under_betingelser_er_navngitt_og_M6_trenger_ingen_terskel() -> None:
|
|||
assert norm.betingelser[Losning.A].bare_skalaen_mangler
|
||||
|
||||
|
||||
def test_tersklene_for_M7_vises_og_endrer_ingenting() -> None:
|
||||
"""A is best in the first 4 of 10 draws: at most 8 of the quantity gives 4 of 8."""
|
||||
def test_ingen_terskel_soekes_for_M7() -> None:
|
||||
"""Clarification 135 d: A is best in the first 4 of 10 draws, C in the other 6; no threshold.
|
||||
|
||||
Under the old rule this was M7 «holder under betingelser» with a threshold at most 8 of x.
|
||||
"""
|
||||
|
||||
def trekning(j: int) -> dict[tuple[Losning, int], dict[str, Utfall] | None]:
|
||||
return {
|
||||
|
|
@ -735,11 +914,18 @@ def test_tersklene_for_M7_vises_og_endrer_ingenting() -> None:
|
|||
M5 = dict.fromkeys((Losning.A, Losning.C), Dom.HOLDER)
|
||||
d = kj.sett_dommer(kjoring, M5, storrelser={"x": X10}, status={"x": "åpen forutsetning"})
|
||||
norm = d.scenarioer[NORM.navn]
|
||||
assert norm.M7[5].dom is Dom.BETINGELSER
|
||||
(t,) = norm.terskler_M7
|
||||
assert _kjerne(t) == ("x", Retning.HOYST, 8.0, 0.8, 0.5, False)
|
||||
assert (d.del_I, d.del_II) == (Dom.HOLDER, Dom.BETINGELSER)
|
||||
assert kj.sett_dommer(kjoring, M5).scenarioer[NORM.navn].terskler_M7 == ()
|
||||
m7 = norm.M7[5]
|
||||
assert [(a, b.best_alene) for a, b in m7.losninger.items()] == [
|
||||
(Losning.A, 0.4),
|
||||
(Losning.C, 0.6),
|
||||
]
|
||||
assert (m7.delt, m7.ingen) == (0.0, 0.0)
|
||||
assert not hasattr(norm, "terskler_M7")
|
||||
assert norm.betingelser is not None
|
||||
assert all("M7" not in b.terskler for b in norm.betingelser.values())
|
||||
# the comparison is the same with and without the drawn values
|
||||
assert kj.sett_dommer(kjoring, M5).scenarioer[NORM.navn].M7 == norm.M7
|
||||
assert d.del_I is Dom.HOLDER
|
||||
|
||||
|
||||
def test_tersklene_trenger_verdier_og_status_for_hver_trekning() -> None:
|
||||
|
|
@ -798,7 +984,8 @@ def test_utfallene_indeksene_gis_for() -> None:
|
|||
"M6 holder ikke": [0.0, 1.0, 0.0, 1.0],
|
||||
"M7": [1.0, 0.0, 0.0, 0.0],
|
||||
}
|
||||
assert "M7" not in kj.utfall_for_indeksene(kjoring, Losning.C, 5)
|
||||
# C is best where A is lower or cannot be built (clarification 135 d)
|
||||
assert kj.utfall_for_indeksene(kjoring, Losning.C, 5)["M7"] == [0.0, 1.0, 1.0, 1.0]
|
||||
indekser = kj.sobol_indekser(kjoring, {"x": [1.0, 2.0, 3.0, 4.0]}, Losning.A, 5)
|
||||
assert set(indekser) == set(y)
|
||||
# two classes of two draws: M1 follows the class exactly, M3 not at all
|
||||
|
|
|
|||
|
|
@ -116,11 +116,12 @@ def test_m5_for_tk_folger_ikke_trinnet_eller_trekningen() -> None:
|
|||
# ----------------------------------------------------------- M7 with five solutions
|
||||
|
||||
|
||||
def test_m7_a_maa_slaa_hver_av_de_fire_som_lar_seg_bygge() -> None:
|
||||
"""Six invented draws.
|
||||
def test_m7_de_beste_er_de_med_hoyest_verdi_blant_dem_som_lar_seg_bygge() -> None:
|
||||
"""Six invented draws (clarification 137 a).
|
||||
|
||||
1: A highest. 2: T-F higher. 3: T-K equal (strictly higher is required). 4: only A can
|
||||
be built. 5: A cannot be built. 6: A highest among those that can be built.
|
||||
1: A highest. 2: T-F highest. 3: A and T-K share the highest value. 4: only A can be built.
|
||||
5: A cannot be built and the four others share one value. 6: A highest among those that can
|
||||
be built.
|
||||
"""
|
||||
nnv: dict[Losning, list[float | None]] = {
|
||||
Losning.A: [10.0, 10.0, 10.0, 10.0, None, 10.0],
|
||||
|
|
@ -129,33 +130,52 @@ def test_m7_a_maa_slaa_hver_av_de_fire_som_lar_seg_bygge() -> None:
|
|||
Losning.T_F: [5.0, 11.0, 5.0, None, 1.0, None],
|
||||
Losning.T_K: [5.0, 5.0, 10.0, None, 1.0, 9.0],
|
||||
}
|
||||
assert dommer.a_er_best(nnv) == [True, False, False, True, False, True]
|
||||
assert dommer.dom_m7(nnv) is Dom.HOLDER # three of six
|
||||
# without the two versions of T, A is also best in draws 2 and 3
|
||||
tre = {a: nnv[a] for a in (Losning.A, Losning.B, Losning.C)}
|
||||
assert dommer.a_er_best(tre) == [True, True, True, True, False, True]
|
||||
A, B, C, TF, TK = dommer.DOMSLOSNINGER
|
||||
assert dommer.beste_per_trekning(nnv) == [(A,), (TF,), (A, TK), (A,), (B, C, TF, TK), (A,)]
|
||||
# without the two versions of T, A is best alone in draws 2 and 3 too, B and C share draw 5
|
||||
tre = {a: nnv[a] for a in (A, B, C)}
|
||||
assert dommer.beste_per_trekning(tre) == [(A,), (A,), (A,), (A,), (B, C), (A,)]
|
||||
# the order the solutions stand in does not matter
|
||||
snudd = {a: nnv[a] for a in reversed(list(nnv))}
|
||||
assert dommer.a_er_best(snudd) == dommer.a_er_best(nnv)
|
||||
assert dommer.beste_per_trekning(snudd) == dommer.beste_per_trekning(nnv)
|
||||
|
||||
|
||||
def test_m7_andelene() -> None:
|
||||
"""A is best in 4 of 10 and in 1 of 10 draws against a T-F that is otherwise higher."""
|
||||
andre = {a: _utfall((5.0, 10)) for a in (Losning.B, Losning.C, Losning.T_K)}
|
||||
tf_fire = {Losning.A: _utfall((10.0, 10)), Losning.T_F: _utfall((1.0, 4), (20.0, 6))}
|
||||
tf_en = {Losning.A: _utfall((10.0, 10)), Losning.T_F: _utfall((1.0, 1), (20.0, 9))}
|
||||
assert dommer.dom_m7({**andre, **tf_fire}) is Dom.BETINGELSER
|
||||
assert dommer.dom_m7({**andre, **tf_en}) is Dom.HOLDER_IKKE
|
||||
@pytest.mark.parametrize("vinner", [Losning.A, Losning.B, Losning.C, Losning.T_F, Losning.T_K])
|
||||
def test_m7_hver_av_de_fem_kan_vaere_best(vinner: Losning) -> None:
|
||||
"""The rule is the same for all five: the one above the others is best, whichever it is."""
|
||||
nnv: dict[Losning, list[float | None]] = {
|
||||
a: [3.0 if a is vinner else 1.0, None if a is vinner else 2.0] for a in dommer.DOMSLOSNINGER
|
||||
}
|
||||
# draw 2: the winner cannot be built, and the four others share the place
|
||||
andre = tuple(a for a in dommer.DOMSLOSNINGER if a is not vinner)
|
||||
assert dommer.beste_per_trekning(nnv) == [(vinner,), andre]
|
||||
|
||||
|
||||
def test_m7_gjelder_a_mot_b_c_tf_og_tk() -> None:
|
||||
"""Without A there is nothing to judge; R and B' are not part of M7."""
|
||||
with pytest.raises(ValueError, match="M7 compares A"):
|
||||
dommer.a_er_best({Losning.B: [1.0], Losning.C: [2.0]})
|
||||
with pytest.raises(ValueError, match="M7 compares A"):
|
||||
dommer.a_er_best({Losning.A: [1.0], Losning.R: [2.0]})
|
||||
with pytest.raises(ValueError, match="M7 compares A"):
|
||||
dommer.a_er_best({Losning.A: [1.0], Losning.B_MERKET: [2.0]})
|
||||
def test_m7_T_F_og_T_K_like_deler_plassen() -> None:
|
||||
"""Where no module of T-K gets nuclear power, T-K is T-F: the two share, not none (137)."""
|
||||
nnv: dict[Losning, list[float | None]] = {
|
||||
Losning.A: [1.0, 1.0, None],
|
||||
Losning.B: [2.0, 9.0, None],
|
||||
Losning.C: [3.0, 1.0, None],
|
||||
Losning.T_F: [7.0, 7.0, 7.0],
|
||||
Losning.T_K: [7.0, 7.0, 7.0],
|
||||
}
|
||||
TF, TK = Losning.T_F, Losning.T_K
|
||||
assert dommer.beste_per_trekning(nnv) == [(TF, TK), (Losning.B,), (TF, TK)]
|
||||
|
||||
|
||||
def test_m7_uten_a_sammenlignes_de_som_er_med() -> None:
|
||||
"""A run without A compares those of the five that are in it; R and B' are not part of M7."""
|
||||
assert dommer.beste_per_trekning({Losning.B: [1.0, None], Losning.C: [2.0, None]}) == [
|
||||
(Losning.C,),
|
||||
(),
|
||||
]
|
||||
assert dommer.beste_per_trekning({Losning.T_K: [-1.0]}) == [(Losning.T_K,)]
|
||||
for med in ({Losning.A: [1.0], Losning.R: [2.0]}, {Losning.A: [1.0], Losning.B_MERKET: [2.0]}):
|
||||
with pytest.raises(ValueError, match="M7 compares A, B, C, T-F and T-K"):
|
||||
dommer.beste_per_trekning(med)
|
||||
with pytest.raises(ValueError, match="M7 compares"):
|
||||
dommer.beste_per_trekning({})
|
||||
|
||||
|
||||
# ------------------------------------------------------ the ladder with five solutions
|
||||
|
|
|
|||
|
|
@ -174,6 +174,9 @@ def test_kontroll_med_to_prosesser_er_identisk(
|
|||
for navn in df.ALLE_FILER:
|
||||
assert f"{navn}: identisk\n" in ut
|
||||
assert "Samlet: identisk (største relative avvik 0). Grunnlaget er merket «oppdiktet»." in ut
|
||||
# a line per file as it is made, in the order they are made, before the verdicts (134)
|
||||
linjer = ut.splitlines()
|
||||
assert linjer[: len(df.ALLE_FILER)] == [f"Laget {navn}" for navn in df.ALLE_FILER]
|
||||
|
||||
|
||||
def test_kontroll_sier_endret_og_gir_feilkode(
|
||||
|
|
@ -275,6 +278,13 @@ def test_scenario_med_egne_verdier_og_sammenlign(hoved: Path, liten: Path, tmp_p
|
|||
assert list(trinn[0]["losninger"]) == ["A", "C"]
|
||||
m1 = trinn[0]["losninger"]["A"]["M1"]
|
||||
assert list(m1) == ["a", "b", "endring_andel_holder"]
|
||||
# the comparison in M7 for the solutions both have, then «delt» and «ingen»; no part II
|
||||
m7 = trinn[0]["M7"]
|
||||
assert list(m7) == ["A", "C", "delt", "ingen"]
|
||||
for x in m7.values():
|
||||
assert list(x) == ["a", "b", "endring"]
|
||||
assert x["endring"] == x["b"] - x["a"]
|
||||
assert list(per_scenario["normalisering"]) == ["trinn", "del_I"]
|
||||
median = trinn[0]["losninger"]["A"]["median_M1"]
|
||||
if median["a"] is not None and median["b"] is not None:
|
||||
assert median["endring"] == median["b"] - median["a"]
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue