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:
parent
7e3ab007f8
commit
8d13501653
10 changed files with 1561 additions and 79 deletions
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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
254
tests/test_terskler.py
Normal 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)
|
||||
|
|
@ -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
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue