259 lines
11 KiB
Python
259 lines
11 KiB
Python
"""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
|
|
# a quantity with few values has fewer classes with draws, and a lower expectation
|
|
x = [0.0] * 100 + [1.0] * 100 + [2.0] * 200
|
|
assert sobol.klasser_med_trekninger(x) == 3
|
|
assert sobol.klasser_med_trekninger(rng.normal(size=N).tolist()) == 10
|
|
assert sobol.forventning_uten_virkning(N, 3) == 2 / 399
|
|
assert snitt == pytest.approx(9 / 399, abs=0.002)
|