feat(kjoring): thresholds, the conditions of part I, Sobol indices and threshold surfaces

Clarifications 105 to 111, on invented outcomes and made-up draws only. The price
threshold runs the model with the price multiplied by a factor; the thresholds in
a quantity, the indices and two of the surfaces are read from the outcomes per draw.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
This commit is contained in:
Kjell Tore Guttormsen 2026-11-13 17:57:52 +01:00
commit 8d13501653
Signed by: ktg
SSH key fingerprint: SHA256:JakMjO6FTBBzN0Bhfj9saOoEjaFxlSdYuZQQpM/lF9Q
10 changed files with 1561 additions and 79 deletions

View file

@ -288,8 +288,21 @@ def test_del_I_holder_ikke_naar_hver_losning_er_felt() -> None:
assert dommer.del_I(per_losning, median, valg) is Dom.HOLDER_IKKE
per_losning[Losning.C] = _dommer(M6=Dom.HOLDER_IKKE)
assert dommer.del_I(per_losning, median, valg) is Dom.BETINGELSER
# C has none of M1 to M5 under conditions: what is missing is the scale, and no
# threshold is needed (clarifications 103 g and 109)
assert dommer.del_I(per_losning, median, valg, har_terskel={}) is Dom.BETINGELSER
# without conditions that can be named within the range of the sources it does not hold
assert dommer.del_I(per_losning, median, valg, betingelser_kan_navngis=False) is Dom.HOLDER_IKKE
per_losning[Losning.C] = _dommer(M2=Dom.BETINGELSER, M6=Dom.HOLDER_IKKE)
assert dommer.del_I(per_losning, median, valg) is Dom.BETINGELSER
assert dommer.del_I(per_losning, median, valg, har_terskel={}) is Dom.HOLDER_IKKE
uten = {Losning.C: {"M1": True, "M2": False}}
assert dommer.del_I(per_losning, median, valg, har_terskel=uten) is Dom.HOLDER_IKKE
med = {Losning.C: {"M2": True}}
assert dommer.del_I(per_losning, median, valg, har_terskel=med) is Dom.BETINGELSER
# a threshold for a solution that is felled does not help
feil = {Losning.A: {"M2": True}, Losning.B: {"M1": True}}
assert dommer.del_I(per_losning, median, valg, har_terskel=feil) is Dom.HOLDER_IKKE
per_losning[Losning.C] = _dommer(M6=Dom.HOLDER_IKKE)
# the pre-registration says a negative median; a median of exactly zero does not fell
median[Losning.B] = 0.0
per_losning[Losning.C] = _dommer(M4=Dom.HOLDER_IKKE)
@ -317,3 +330,22 @@ def test_hvor_mye_av_dommen_som_skyldes_baner_som_ikke_lar_seg_bygge() -> None:
assert dommer.ved_siden_av_dommen(oppfylt) == pytest.approx((0.25, 0.5))
assert dommer.ved_siden_av_dommen([None, None]) == (1.0, None)
assert dommer.ved_siden_av_dommen([True, True]) == (0.0, 1.0)
def test_betingelsene_kan_navngis_naar_hvert_maal_har_en_terskel_som_teller() -> None:
"""Clarifications 93 and 109: every one of M1 to M5 under conditions; M5 by definition."""
d = _dommer(M1=Dom.BETINGELSER, M3=Dom.BETINGELSER, M5=Dom.BETINGELSER, M6=Dom.BETINGELSER)
assert dommer.maal_under_betingelser(d) == ("M1", "M3", "M5")
assert dommer.kan_navngis(d, {"M1": True, "M3": True})
assert not dommer.kan_navngis(d, {"M1": True, "M3": False})
assert not dommer.kan_navngis(d, {"M1": True})
# M5 alone is named by definition, and M6 needs no threshold
assert dommer.kan_navngis(_dommer(M5=Dom.BETINGELSER), {})
assert dommer.kan_navngis(_dommer(M6=Dom.BETINGELSER), {})
assert dommer.kan_navngis(_dommer(), {})
def test_felt_er_ett_av_M1_til_M5_som_ikke_holder_eller_negativ_median() -> None:
assert dommer.er_felt(_dommer(M5=Dom.HOLDER_IKKE), 1.0)
assert dommer.er_felt(_dommer(), -1.0)
assert not dommer.er_felt(_dommer(M6=Dom.HOLDER_IKKE), 0.0)

View file

@ -1,4 +1,4 @@
"""The run over the draws (chapter 11; clarifications 95 to 103).
"""The run over the draws (chapter 11; clarifications 95 to 111).
Made-up draws only: variants of the made-up set of ``conftest.py``, and invented outcomes per
draw for the verdicts and the timeline. Nothing here says anything about the hypothesis.
@ -10,19 +10,21 @@ does not start within the final year 2060.
from __future__ import annotations
import dataclasses
import math
import statistics
from typing import TYPE_CHECKING
import pytest
from tokenfabrikker import dommer, eierskap, nivaaisert, skala
from tokenfabrikker import dommer, eierskap, nivaaisert, skala, terskler
from tokenfabrikker import kjoring as kj
from tokenfabrikker import kontantstrom as ks
from tokenfabrikker.dommer import Dom, Forsyning, Grunnlag
from tokenfabrikker.kjoring import Bane, Kjoring, Scenario, Utfall
from tokenfabrikker.kontantstrom import Knapphet
from tokenfabrikker.miljo import Kildeverdier
from tokenfabrikker.terskler import Pristerskel, Retning, Rute, Terskel
from tokenfabrikker.utbygging import Kraft, Losning
if TYPE_CHECKING:
@ -409,17 +411,17 @@ def test_dommene_paa_oppdiktede_trekninger_henger_sammen_med_utfallene(
def test_persentilen_er_lineaer_mellom_naboverdiene() -> None:
x = [4.0, 1.0, 3.0, 2.0]
# h = 1 + 3 p: 1.3 gives 1 + 0.3 (2 - 1); 3.7 gives 3 + 0.7 (4 - 3)
assert kj.persentil(x, 0.1) == pytest.approx(1.3)
assert kj.persentil(x, 0.9) == pytest.approx(3.7)
assert kj.persentil(x, 0.5) == statistics.median(x) == 2.5
assert (kj.persentil(x, 0.0), kj.persentil(x, 1.0)) == (1.0, 4.0)
assert dommer.persentil(x, 0.1) == pytest.approx(1.3)
assert dommer.persentil(x, 0.9) == pytest.approx(3.7)
assert dommer.persentil(x, 0.5) == statistics.median(x) == 2.5
assert (dommer.persentil(x, 0.0), dommer.persentil(x, 1.0)) == (1.0, 4.0)
# a whole h is the value itself: five values, p = 0.25 gives the second
assert kj.persentil([10.0, 20.0, 30.0, 40.0, 50.0], 0.25) == 20.0
assert kj.persentil([7.0], 0.1) == kj.persentil([7.0], 0.9) == 7.0
assert dommer.persentil([10.0, 20.0, 30.0, 40.0, 50.0], 0.25) == 20.0
assert dommer.persentil([7.0], 0.1) == dommer.persentil([7.0], 0.9) == 7.0
with pytest.raises(ValueError, match="at least one value"):
kj.persentil([], 0.5)
dommer.persentil([], 0.5)
with pytest.raises(ValueError, match="between 0 and 1"):
kj.persentil([1.0], 10.0)
dommer.persentil([1.0], 10.0)
def test_tidslinjen_over_trekningene_har_med_baner_som_ikke_lar_seg_bygge() -> None:
@ -529,3 +531,326 @@ def test_de_seks_scenarioene_og_stigen_er_de_forhaandsregistrerte() -> None:
]
assert [s.teller for s in kj.SCENARIOER] == [False, True, False, False, False, False]
assert len({s.navn for s in kj.SCENARIOER}) == 6
# ------------------------------ thresholds, conditions and indices over the draws
X10 = [float(v) for v in range(1, 11)]
"""An invented quantity over ten draws: its 10th percentile is 1.9 and its 90th 9.1."""
def _ti_trekninger_der_A_er_positiv_til_og_med(grense: int) -> Kjoring:
"""Ten draws of A on step 5: net present value positive in the first ``grense`` of them."""
return _kjoring([{(Losning.A, 5): _alle(_u(1.0 if j < grense else -1.0))} for j in range(10)])
def test_del_I_avgjores_med_tersklene() -> None:
"""M1 is positive in 7 of 10 draws: at most 8 of the quantity gives 7 of 8."""
kjoring = _ti_trekninger_der_A_er_positiv_til_og_med(7)
M5 = {Losning.A: Dom.HOLDER}
uten = kj.sett_dommer(kjoring, M5)
assert uten.del_I is Dom.BETINGELSER
assert uten.scenarioer[NORM.navn].betingelser is None
assert not uten.scenarioer[NORM.navn].del_I_avgjort
storrelser = {"x": X10, "z": [11.0 - v for v in X10]}
d = kj.sett_dommer(
kjoring, M5, storrelser=storrelser, status={"x": "kilde", "z": "åpen forutsetning"}
)
norm = d.scenarioer[NORM.navn]
assert (d.valg.trinn, d.valg.grunnlag) == (5, Grunnlag.TRINN_25)
assert (d.del_I, norm.del_I_avgjort) == (Dom.BETINGELSER, True)
assert norm.betingelser is not None
b = norm.betingelser[Losning.A]
assert (b.felt, b.maal, b.kan_navngis, b.bare_skalaen_mangler) == (False, ("M1",), True, False)
assert b.terskler == {
"M1": (
Terskel("x", Retning.HOYST, 8.0, 0.8, 0.875, teller=True),
Terskel("z", Retning.MINST, 3.0, 0.8, 0.875, teller=False),
)
}
# the same threshold in a quantity without a source does not count: part I does not hold
d = kj.sett_dommer(
kjoring,
M5,
storrelser=storrelser,
status={"x": "modellvalg", "z": "åpen forutsetning"},
)
norm = d.scenarioer[NORM.navn]
assert d.del_I is Dom.HOLDER_IKKE
assert norm.betingelser is not None
assert not norm.betingelser[Losning.A].kan_navngis
assert [t.teller for t in norm.betingelser[Losning.A].terskler["M1"]] == [False, False]
# and with a quantity that says nothing there is no threshold at all
d = kj.sett_dommer(kjoring, M5, storrelser={"c": [1.0] * 10}, status={"c": "kilde"})
assert d.del_I is Dom.HOLDER_IKKE
norm = d.scenarioer[NORM.navn]
assert norm.betingelser is not None
assert norm.betingelser[Losning.A].terskler == {"M1": ()}
def test_M5_under_betingelser_er_navngitt_og_M6_trenger_ingen_terskel() -> None:
"""Clarifications 93 and 109: A has M5 and M6 under conditions and no threshold anywhere."""
kjoring = _kjoring([{(Losning.A, 5): _alle(_u(M6=0.1))} for _ in range(10)])
d = kj.sett_dommer(
kjoring, {Losning.A: Dom.BETINGELSER}, storrelser={"x": X10}, status={"x": "kilde"}
)
norm = d.scenarioer[NORM.navn]
assert (d.valg.trinn, d.valg.grunnlag) == (5, Grunnlag.TRINN_5)
assert norm.per_trinn[5][Losning.A].maal["M6"].dom is Dom.BETINGELSER
assert d.del_I is Dom.BETINGELSER
assert norm.betingelser is not None
b = norm.betingelser[Losning.A]
assert (b.maal, b.kan_navngis, b.terskler) == (("M5",), True, {"M6": ()})
# with M5 holding only the scale is missing (clarification 103 g)
d = kj.sett_dommer(
kjoring, {Losning.A: Dom.HOLDER}, storrelser={"x": X10}, status={"x": "kilde"}
)
norm = d.scenarioer[NORM.navn]
assert d.del_I is Dom.BETINGELSER
assert norm.betingelser is not 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 trekning(j: int) -> dict[tuple[Losning, int], dict[str, Utfall] | None]:
return {
(Losning.A, 5): _alle(_u(1.0 if j < 4 else 0.2)),
(Losning.C, 5): _alle(_u(0.5)),
}
kjoring = _kjoring([trekning(j) for j in range(10)])
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
assert norm.terskler_M7 == (Terskel("x", Retning.HOYST, 8.0, 0.8, 0.5, teller=False),)
assert (d.del_I, d.del_II) == (Dom.HOLDER, Dom.BETINGELSER)
assert kj.sett_dommer(kjoring, M5).scenarioer[NORM.navn].terskler_M7 == ()
def test_tersklene_trenger_verdier_og_status_for_hver_trekning() -> None:
kjoring = _ti_trekninger_der_A_er_positiv_til_og_med(7)
M5 = {Losning.A: Dom.HOLDER}
with pytest.raises(ValueError, match="both the drawn values and the status"):
kj.sett_dommer(kjoring, M5, storrelser={"x": X10})
with pytest.raises(ValueError, match="one value per draw"):
kj.sett_dommer(kjoring, M5, storrelser={"x": [1.0]}, status={"x": "kilde"})
def test_tallene_ved_siden_av_M6_over_trekningene_som_har_verdi() -> None:
"""Clarification 103 c. One draw cannot be built, one has no year of stable operation."""
utfall: list[Utfall | None] = [
None,
_u(M6=None),
dataclasses.replace(_u(M6=0.1), M6_2050=0.2),
dataclasses.replace(_u(M6=0.3), M6_2050=0.4),
]
side = kj.ved_siden_av_m6(utfall)
assert side["snitt"] == side["median av ti aar"]
assert side["snitt"].antall == 2
assert side["snitt"].median == pytest.approx(0.2)
assert side["snitt"].persentiler == pytest.approx((0.12, 0.28))
assert side["2050"].antall == 2
assert side["2050"].median == pytest.approx(0.3)
assert side["2050"].persentiler == pytest.approx((0.22, 0.38))
# the peak year has a value for every path that can be built: 0, 0.1 and 0.3
assert (side["toppaar"].antall, side["toppaar"].median) == (3, 0.1)
assert side["toppaar"].persentiler == pytest.approx((0.02, 0.26))
ingen = kj.ved_siden_av_m6([None, None])
assert all(x == kj.Sidetall(antall=0, median=None, persentiler=None) for x in ingen.values())
def test_utfallene_indeksene_gis_for() -> None:
"""Four draws of A and C on step 5; A cannot be built in the last."""
a: list[Utfall | None] = [_u(2.0), _u(1.0, M3=0.2, M6=0.01), _u(-1.0, S42=-1.0, M4=False), None]
kjoring = _kjoring(
[
{(Losning.A, 5): None if u is None else _alle(u), (Losning.C, 5): _alle(_u(1.5))}
for u in a
]
)
y = kj.utfall_for_indeksene(kjoring, Losning.A, 5)
assert y == {
"NNV": [2.0, 1.0, -1.0, None],
"byggbar": [1.0, 1.0, 1.0, 0.0],
"M1 holder": [1.0, 1.0, 0.0, 0.0],
"M2 holder": [1.0, 1.0, 0.0, 0.0],
"M3 holder": [1.0, 0.0, 1.0, 0.0],
"M4 holder": [1.0, 1.0, 0.0, 0.0],
"M6 holder": [1.0, 0.0, 1.0, 0.0],
"M3 holder ikke": [0.0, 1.0, 0.0, 0.0],
"M4 holder ikke": [0.0, 0.0, 1.0, 0.0],
# a path that cannot be built counts as under 5 % in M6
"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)
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
assert indekser["M1 holder"] == {"x": 1.0}
assert indekser["M3 holder"] == {"x": 0.0}
# the net present value among the three draws that can be built. With three draws and
# two classes the class is floor(2 r / 3): {2, 1} with the average 1.5, and {-1}
snitt = 2.0 / 3.0
mellom = 2 * (1.5 - snitt) ** 2 + (-1.0 - snitt) ** 2
total = (2.0 - snitt) ** 2 + (1.0 - snitt) ** 2 + (-1.0 - snitt) ** 2
assert indekser["NNV"]["x"] == pytest.approx(mellom / total)
assert kj.sobol_indekser(kjoring, {"x": [1.0, 2.0, 3.0, 4.0]}, Losning.C, 5)["M1 holder"] == {
"x": None
}
def test_flatene_leses_av_utfallene() -> None:
"""Four draws; A cannot be built in the second. Two of the 25 cells are filled per pair."""
a: list[Utfall | None] = [
dataclasses.replace(_u(2.0), c_snitt=300.0),
None,
dataclasses.replace(_u(-1.0), c_snitt=500.0),
dataclasses.replace(_u(4.0), c_snitt=400.0),
]
kjoring = _kjoring([{(Losning.A, 5): None if u is None else _alle(u)} for u in a])
rho = [0.05, 0.05, 0.09, 0.09]
kost = [100.0, 100.0, 200.0, 200.0]
flate = kj.flate_over_trekningene(kjoring, rho, kost, Losning.A, 5)
assert flate[0][0] == Rute(antall=2, andel_positiv=0.5, median=-math.inf)
assert flate[2][2] == Rute(antall=2, andel_positiv=0.5, median=1.5)
assert sum(rute.antall for rad in flate for rute in rad) == 4
# the competitor's price against the Norwegian cost, among the three that can be built:
# classes 0, 1 and 3 of five for both, since class is floor(5 r / 3)
antall, flate = kj.kraftprisflate(kjoring, [800.0, 850.0, 900.0, 950.0], Losning.A, 5)
assert antall == 3
assert flate[0][0] == Rute(antall=1, andel_positiv=1.0, median=2.0)
assert flate[1][3] == Rute(antall=1, andel_positiv=0.0, median=-1.0)
assert flate[3][1] == Rute(antall=1, andel_positiv=1.0, median=4.0)
uten_kost = _kjoring([{(Losning.A, 5): _alle(_u())}])
with pytest.raises(ValueError, match="cost of Norwegian power"):
kj.kraftprisflate(uten_kost, [800.0], Losning.A, 5)
# ------------------------------------------------ the price threshold, through the model
def test_prisfaktoren_en_gir_de_samme_tallene_til_siste_siffer(oppdiktet: LagInndata) -> None:
inn = oppdiktet()
for losning in Losning:
dim = ks.dimensjoner(inn, losning)
plan = ks.lag_plan(inn, losning, dim, N_anlegg=2)
uten = ks.regn_program(inn, losning, plan, Knapphet.VARER, dim=dim)
med = ks.regn_program(inn, losning, plan, Knapphet.VARER, dim=dim, prisfaktor=1.0)
assert med.NNV == uten.NNV
assert kj.nnv_med_prisfaktor(
inn, losning=losning, trinn=2, knapphet=Knapphet.VARER, k=1.0
) == (uten.NNV)
with pytest.raises(ValueError, match="cannot be negative"):
ks.regn_program(inn, losning, plan, Knapphet.VARER, dim=dim, prisfaktor=-0.1)
def test_netto_naaverdi_avtar_ikke_med_prisen_og_faktoren_er_som_et_bortfall(
oppdiktet: LagInndata,
) -> None:
"""17.3: a loss d for every vintage is the price times 1 - eps_d d. Here eps_d is one."""
inn = oppdiktet()
for losning in Losning:
dim = ks.dimensjoner(inn, losning)
plan = ks.lag_plan(inn, losning, dim, N_anlegg=2)
def nnv(k: float, losning: Losning = losning) -> float:
verdi = kj.nnv_med_prisfaktor(
inn, losning=losning, trinn=2, knapphet=Knapphet.NORMALISERING, k=k
)
assert verdi is not None
return verdi
rekke = [nnv(k) for k in (0.0, 0.5, 0.8, 1.0, 1.3, 2.0, 5.0)]
assert rekke == sorted(rekke)
assert rekke[0] < rekke[-1]
med_bortfall = ks.regn_program(
inn, losning, plan, Knapphet.NORMALISERING, dim=dim, bortfall=ks.fast_bortfall(0.2)
)
assert nnv(0.8) == pytest.approx(med_bortfall.NNV, rel=1e-12)
# the avoided emissions follow the capacity sold, not the price
dobbel = ks.regn_program(
inn, losning, plan, Knapphet.NORMALISERING, dim=dim, prisfaktor=2.0
)
assert dobbel.mu_d.andel(2040) == 1.0
assert dobbel.mu_d(2040) == 2.0
def test_pristerskelen_gjennom_modellen(oppdiktet: LagInndata) -> None:
"""Four made-up draws; the median at the threshold is not negative, and negative just below."""
trekninger = _trekninger(oppdiktet)
for losning in (Losning.A, Losning.C, Losning.T_F):
funnet = kj.pristerskel_for_losning(trekninger, losning, 1, NORM)
assert funnet.k is not None
def median(k: float, losning: Losning = losning) -> float:
return dommer.median(
[
kj.nnv_med_prisfaktor(
inn, losning=losning, trinn=1, knapphet=Knapphet.NORMALISERING, k=k
)
for inn in trekninger
]
)
assert median(funnet.k) >= 0
assert funnet.k == 0.0 or median(funnet.k - terskler.K_TOLERANSE) < 0
# shared out over processes the same factors are tried, and the answer is the same
en = kj.pristerskel_for_losning(trekninger, Losning.C, 1, NORM)
assert kj.pristerskel_for_losning(trekninger, Losning.C, 1, NORM, prosesser=2) == en
with pytest.raises(ValueError, match="price scenarios on the main path"):
kj.pristerskel_for_losning(trekninger, Losning.C, 1, LAVT)
with pytest.raises(ValueError, match="at least one draw"):
kj.pristerskel_for_losning([], Losning.C, 1, NORM)
def test_pristerskelen_finnes_ikke_naar_halvparten_ikke_lar_seg_bygge(
oppdiktet: LagInndata,
) -> None:
"""Step 3 of the slow nuclear path cannot be built; with two of four such draws: no median."""
trekninger = [oppdiktet(), oppdiktet(p_v=3000.0), *[oppdiktet(n_reaktor=100.0)] * 2]
assert kj.pristerskel_for_losning(trekninger, Losning.A, 3, NORM) == Pristerskel(
k=None, uten_median=True
)
def test_prisflaten_gir_terskelen_per_klasse_av_reaktorkostnaden(oppdiktet: LagInndata) -> None:
"""Ten made-up draws in five classes of two; each class has the threshold of its own draws."""
kost = [80e6, 90e6, 100e6, 110e6, 120e6, 130e6, 140e6, 150e6, 160e6, 170e6]
trekninger = [oppdiktet(c_N_ref=c) for c in kost]
flate = kj.prisflate(trekninger, kost, Losning.A, 1, NORM)
assert [None if p is None else (p.antall, p.c_N_ref) for p in flate] == [
(2, 85e6),
(2, 105e6),
(2, 125e6),
(2, 145e6),
(2, 165e6),
]
forste = kj.pristerskel_for_losning(trekninger[:2], Losning.A, 1, NORM)
assert flate[0] is not None
assert flate[0].terskel == forste
terskel = [p.terskel.k for p in flate if p is not None]
assert all(k is not None for k in terskel)
# a dearer reactor needs a higher price
assert terskel == sorted(terskel) # type: ignore[type-var]
with pytest.raises(ValueError, match="reactor cost of every draw"):
kj.prisflate(trekninger, kost[:3], Losning.A, 1, NORM)
def test_kraftkostnaden_i_utfallet_er_snittet_over_aargangsleddene(oppdiktet: LagInndata) -> None:
inn = oppdiktet()
bane = kj.regn_bane(inn, Losning.C, 2, (NORM,))
dim = ks.dimensjoner(inn, Losning.C)
plan = ks.lag_plan(inn, Losning.C, dim, N_anlegg=2)
res = ks.regn_program(inn, Losning.C, plan, Knapphet.NORMALISERING, dim=dim)
ledd = nivaaisert.kraftkostnad(inn, res, bedrift=True).aarganger
vekter = [(1.0 + inn["rho_D"]) ** -(a.t_v - plan.T_0) for a in ledd]
snitt = sum(w * a.c_a for w, a in zip(vekter, ledd, strict=True)) / sum(vekter)
assert bane.utfall[NORM.navn].c_snitt == pytest.approx(snitt, rel=1e-12)
assert min(a.c_a for a in ledd) <= snitt <= max(a.c_a for a in ledd)
assert kj.lcoc_v_2025(inn) == ks.regnekraftpris(inn, Knapphet.VARER, 2040).lcoc_v(2025)

254
tests/test_terskler.py Normal file
View file

@ -0,0 +1,254 @@
"""Thresholds and Sobol indices (chapter 16, clarifications 105 to 111).
Invented values and outcomes only, with the answers computed by hand. Nothing here says
anything about the hypothesis.
"""
from __future__ import annotations
import math
from typing import TYPE_CHECKING
import numpy as np
import pytest
from tokenfabrikker import sobol, terskler
from tokenfabrikker.terskler import Pristerskel, Retning, Rute, Terskel
if TYPE_CHECKING:
from collections.abc import Callable
X10 = [float(v) for v in range(1, 11)]
"""Ten draws of one quantity: the 10th percentile is 1.9 and the 90th 9.1."""
# ------------------------------------------------------------ the price threshold
def _teller(f: Callable[[float], float]) -> tuple[Callable[[float], float], list[float]]:
kall: list[float] = []
def g(k: float) -> float:
kall.append(k)
return float(f(k))
return g, kall
@pytest.mark.parametrize(
("f", "rot"),
[
(lambda k: 10.0 * k - 25.0, 2.5),
(lambda k: 3.0 * k - 0.9, 0.3),
(lambda k: min(k - 0.3, 0.1 * (k - 0.3)), 0.3),
(lambda k: -1.0 if k < 3.7 else 1.0, 3.7),
(lambda k: k**3 - 50.0, 50.0 ** (1 / 3)),
(lambda k: k - 99.5, 99.5),
],
)
def test_pristerskelen_er_laveste_faktor_med_median_som_ikke_er_negativ(
f: Callable[[float], float], rot: float
) -> None:
g, kall = _teller(f)
funnet = terskler.pristerskel(g)
assert funnet.k is not None
assert not funnet.over_maks
assert not funnet.uten_median
assert rot <= funnet.k <= rot + terskler.K_TOLERANSE
assert f(funnet.k) >= 0
assert f(funnet.k - terskler.K_TOLERANSE) < 0
# never more than two runs per halving of the bracket
assert len(kall) <= 60
def test_pristerskelen_finner_en_rett_linje_paa_faa_kjoringer() -> None:
g, kall = _teller(lambda k: 10.0 * k - 25.0)
terskler.pristerskel(g)
# 1, 2 and 4 bracket it; the line and the point just below close the bracket
assert kall[:3] == [1.0, 2.0, 4.0]
assert len(kall) == 5
def test_pristerskelen_ved_flat_median_er_det_laveste_punktet() -> None:
"""The median is zero from 2 and up: the threshold is the lowest such factor."""
funnet = terskler.pristerskel(lambda k: min(0.0, k - 2.0))
assert funnet.k is not None
assert 2.0 <= funnet.k <= 2.0 + terskler.K_TOLERANSE
def test_pristerskelen_er_null_naar_medianen_ikke_er_negativ_uten_inntekt() -> None:
assert terskler.pristerskel(lambda k: k) == Pristerskel(k=0.0)
assert terskler.pristerskel(lambda _k: 5.0) == Pristerskel(k=0.0)
def test_pristerskelen_har_ingen_verdi_over_hundre_eller_uten_median() -> None:
assert terskler.pristerskel(lambda k: k - 100.5) == Pristerskel(k=None, over_maks=True)
assert terskler.pristerskel(lambda _k: -math.inf) == Pristerskel(k=None, uten_median=True)
# exactly at the upper end it is found
funnet = terskler.pristerskel(lambda k: -1.0 if k < 100.0 else 0.0)
assert funnet.k == 100.0
def test_kontrollen_mot_kontraktsprisene_bruker_medianen() -> None:
"""The median cost is 20 and the highest contract price 50: k may be at most 2.5."""
lcoc = [10.0, 30.0, 20.0]
assert terskler.innenfor_kontraktsprisene(2.5, lcoc, 50.0) == (True, 2 / 3)
assert terskler.innenfor_kontraktsprisene(2.6, lcoc, 50.0) == (False, 1 / 3)
assert terskler.innenfor_kontraktsprisene(0.0, lcoc, 50.0) == (True, 1.0)
# ----------------------------------------------------- a threshold in one quantity
def test_terskelen_er_den_minst_strenge_betingelsen_innenfor_spennet() -> None:
"""The target is met where x <= 6. At most 9: 6 of 9. At most 8: 6 of 8. At most 7: 6 of 7."""
oppfylt: list[bool | None] = [v <= 6 for v in X10]
assert terskler.terskel(X10, oppfylt, Retning.HOYST) == (7.0, 0.7, 6 / 7)
# at least 2 covers 5 of 9, and it only gets worse
assert terskler.terskel(X10, oppfylt, Retning.MINST) is None
def test_terskelen_naar_andelen_svinger() -> None:
"""Met everywhere but at 1 and 6. At most 5 gives exactly 4 of 5; at least 2 gives 8 of 9."""
oppfylt: list[bool | None] = [v not in (1.0, 6.0) for v in X10]
assert terskler.terskel(X10, oppfylt, Retning.HOYST) == (5.0, 0.5, 0.8)
assert terskler.terskel(X10, oppfylt, Retning.MINST) == (2.0, 0.9, 8 / 9)
def test_terskelen_ligger_aldri_utenfor_10_og_90_persentilen() -> None:
"""Met only at 1: «at most 1» would hold, but 1 is below the 10th percentile, 1.9."""
oppfylt: list[bool | None] = [v == 1.0 for v in X10]
assert terskler.terskel(X10, oppfylt, Retning.HOYST) is None
# met everywhere but at 10: «at most 9» is the least strict candidate, not «at most 10»
oppfylt = [v != 10.0 for v in X10]
assert terskler.terskel(X10, oppfylt, Retning.HOYST) == (9.0, 0.9, 1.0)
def test_en_bane_som_ikke_lar_seg_bygge_oppfyller_ikke_vilkaaret() -> None:
"""Not buildable at 7: at most 7 is then 6 of 7 with the draw in the denominator."""
oppfylt: list[bool | None] = [True, True, True, True, True, True, None, False, False, False]
assert terskler.terskel(X10, oppfylt, Retning.HOYST) == (7.0, 0.7, 6 / 7)
oppfylt = [True, True, True, True, True, None, None, False, False, False]
# at most 7: 5 of 7; at most 6: 5 of 6
assert terskler.terskel(X10, oppfylt, Retning.HOYST) == (6.0, 0.6, 5 / 6)
def test_like_verdier_er_en_kandidat() -> None:
"""Three draws at 1, three at 2 and four at 3: the percentiles are 1 and 3."""
x = [1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 3.0, 3.0, 3.0, 3.0]
oppfylt: list[bool | None] = [True, True, True, True, True, False, False, False, False, False]
assert terskler.terskel(x, oppfylt, Retning.HOYST) == (2.0, 0.6, 5 / 6)
assert terskler.terskel(x, oppfylt, Retning.MINST) is None
# a quantity with the same value in every draw has one candidate, which covers all
assert terskler.terskel([5.0] * 10, oppfylt, Retning.HOYST) is None
assert terskler.terskel([5.0] * 10, [True] * 8 + [False] * 2, Retning.MINST) == (5.0, 1.0, 0.8)
def test_grensen_i_M7_er_halvparten() -> None:
"""Met at 2, 4, 6 and 8: never 80 % of the draws up to a candidate; half of them up to 8."""
oppfylt: list[bool | None] = [v in (2.0, 4.0, 6.0, 8.0) for v in X10]
assert terskler.terskel(X10, oppfylt, Retning.HOYST) is None
assert terskler.terskel(X10, oppfylt, Retning.HOYST, grense=0.5) == (8.0, 0.8, 0.5)
def test_terskelen_trenger_en_verdi_per_trekning() -> None:
with pytest.raises(ValueError, match="one value and one outcome per draw"):
terskler.terskel([1.0, 2.0], [True], Retning.HOYST)
with pytest.raises(ValueError, match="at least one draw"):
terskler.terskel([], [], Retning.HOYST)
def test_terskler_for_et_maal_teller_bare_for_storrelser_med_kilde() -> None:
oppfylt: list[bool | None] = [v <= 6 for v in X10]
storrelser = {"a": X10, "b": [11.0 - v for v in X10], "c": [1.0] * 10}
status = {"a": "kilde", "b": "åpen forutsetning", "c": "kilde"}
assert terskler.terskler_for_maal(storrelser, status, oppfylt) == (
Terskel("a", Retning.HOYST, 7.0, 0.7, 6 / 7, teller=True),
Terskel("b", Retning.MINST, 4.0, 0.7, 6 / 7, teller=False),
)
# ------------------------------------------------------------ the threshold surfaces
def test_flaten_gir_antall_andel_og_median_per_rute() -> None:
"""Two classes per axis: draws 1 and 2 in the first cell, 3 and 4 in the last."""
x = [1.0, 2.0, 3.0, 4.0]
y = [10.0, 10.0, 20.0, 20.0]
flate = terskler.flate(x, y, [5.0, None, -1.0, 3.0], Q=2)
tom = Rute(antall=0, andel_positiv=None, median=None)
assert flate == (
(Rute(antall=2, andel_positiv=0.5, median=-math.inf), tom),
(tom, Rute(antall=2, andel_positiv=0.5, median=1.0)),
)
with pytest.raises(ValueError, match="the same draws"):
terskler.flate(x, y, [1.0])
def test_flaten_har_fem_klasser_per_akse() -> None:
x = [float(j % 5) for j in range(25)]
y = [float(j // 5) for j in range(25)]
flate = terskler.flate(x, y, [1.0] * 25)
assert len(flate) == 5
assert all(
rute == Rute(antall=1, andel_positiv=1.0, median=1.0) for rad in flate for rute in rad
)
# ----------------------------------------------------------------- the Sobol indices
def test_antall_klasser_er_halve_kvadratroten() -> None:
assert [sobol.antall_klasser(N) for N in (1, 16, 35, 36, 100, 9999, 10000)] == [
2,
2,
2,
3,
5,
49,
50,
]
def test_klassen_folger_antall_trekninger_med_lavere_verdi() -> None:
assert sobol.klasser([5.0, 1.0, 3.0, 1.0], 2) == [1, 0, 1, 0]
assert sobol.klasser([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], 3) == [0, 0, 1, 1, 2, 2]
# equal values share a class; 30 % zeros and 70 % ones get a class each with ten classes
x = [0.0] * 3 + [1.0] * 7
assert sobol.klasser(x, 10) == [0] * 3 + [3] * 7
assert sobol.klasser([7.0] * 4, 2) == [0] * 4
def test_indeksen_er_variansen_mellom_klassene_over_variansen() -> None:
x = [1.0, 2.0, 3.0, 4.0]
assert sobol.indeks(x, [0.0, 0.0, 1.0, 1.0]) == 1.0
assert sobol.indeks(x, [0.0, 1.0, 0.0, 1.0]) == 0.0
# averages 1.5 and 4.5 around 3: 2 * 2.25 + 2 * 2.25 = 9, over 4 + 1 + 0 + 9 = 14
assert sobol.indeks(x, [1.0, 2.0, 3.0, 6.0]) == pytest.approx(9 / 14)
# the order of the draws does not matter
assert sobol.indeks([4.0, 1.0, 3.0, 2.0], [6.0, 1.0, 3.0, 2.0]) == pytest.approx(9 / 14)
def test_indeksen_har_ingen_verdi_naar_utfallet_er_likt_i_alle_trekningene() -> None:
assert sobol.indeks([1.0, 2.0, 3.0], [0.1, 0.1, 0.1]) is None
with pytest.raises(ValueError, match="one value and one outcome per draw"):
sobol.indeks([1.0], [])
def test_indeksene_gis_blant_trekningene_som_har_utfallet() -> None:
"""The third draw has no outcome: the index is that of the other four."""
storrelser = {"a": [1.0, 2.0, 9.0, 3.0, 4.0], "b": [1.0, 1.0, 1.0, 1.0, 1.0]}
y = [1.0, 2.0, None, 3.0, 6.0]
assert sobol.indekser(storrelser, y) == {"a": pytest.approx(9 / 14), "b": 0.0}
assert sobol.indekser(storrelser, [None] * 5) == {"a": None, "b": None}
def test_forventningen_uten_virkning_er_om_lag_M_minus_1_over_N_minus_1() -> None:
"""300 invented quantities without any effect on an invented outcome, 400 draws each."""
assert sobol.forventning_uten_virkning(10_000) == 49 / 9999
rng = np.random.default_rng(7)
N = 400
y = rng.normal(size=N).tolist()
indekser = [sobol.indeks(rng.normal(size=N).tolist(), y) for _ in range(300)]
snitt = math.fsum(i for i in indekser if i is not None) / 300
assert sobol.forventning_uten_virkning(N) == 9 / 399
assert snitt == pytest.approx(9 / 399, abs=0.002)

View file

@ -236,9 +236,7 @@ def test_del_I_holder_ikke_forst_naar_alle_fem_er_felt() -> None:
}
median = dict.fromkeys(per_losning, 5.0)
assert dommer.del_I(per_losning, median, _PAA_25) is Dom.BETINGELSER
assert (
dommer.del_I(per_losning, median, _PAA_25, betingelser_kan_navngis=False) is Dom.HOLDER_IKKE
)
assert dommer.del_I(per_losning, median, _PAA_25, har_terskel={}) is Dom.HOLDER_IKKE
median[Losning.T_K] = -1.0
assert dommer.del_I(per_losning, median, _PAA_25) is Dom.HOLDER_IKKE
# the order the solutions stand in does not matter