Every measured number in the prose and the tables is read from data/resultater/ by rapport/lag_resultater.py (modules in rapport/resultater/) and carries file, path and raw value in rapport/generert/tall.json. Chapter 8 says what is missing: the ranking of the ownership forms under other weightings and limits is not computed, and the reproduction is on one machine. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
200 lines
7.9 KiB
Python
200 lines
7.9 KiB
Python
"""Chapter 6, «Eierformene»: the four ownership forms on the step the verdicts are read on.
|
|
|
|
Reads ``eierformer.json`` (clarifications 98, 123 and 128 c of the specification) and writes four
|
|
table bodies to ``rapport/generert/``:
|
|
|
|
- ``eierformer-verdi.tex``: value for the public (``verdi``, ``oppgjor``, ``andel_av_overskudd``,
|
|
``andel_for_oppgjor``) per solution and form;
|
|
- ``eierformer-risiko.tex``: cost of capital (``r_e``, ``LCOC``) and risk for the state
|
|
(``tapssannsynlighet``, ``daarligste``, ``kapital_ute``) per solution and form;
|
|
- ``eierformer-rangering.tex``: the draws the table rests on and the rule of the pre-registration
|
|
(``antall_byggbare``, ``rangering``) per solution;
|
|
- ``eierformer-kontantstrom.tex``: the state's net cash flow next to M6 (``statens_kontantstrom``).
|
|
|
|
Every number shown is returned as a ``Tall`` under a key that starts with ``eierformer.``.
|
|
Standard library only.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from typing import TYPE_CHECKING, Any
|
|
|
|
from resultater.felles import LOSNING, Tall, fra_fil, les
|
|
|
|
if TYPE_CHECKING:
|
|
from pathlib import Path
|
|
|
|
FIL = "eierformer.json"
|
|
|
|
# (name in the file, short name in keys, label in the tables). The labels are the
|
|
# pre-registration's candidates, shortened; the chapter gives the full names.
|
|
FORMER = (
|
|
("direkte", "direkte", "Direkte"),
|
|
("heleid_selskap", "heleid", "Heleid selskap"),
|
|
("majoritet_boers", "majoritet", "Majoritet med børs"),
|
|
("petroleumsmodell", "petroleum", "Petroleumsmodellen"),
|
|
)
|
|
NAVN = {fil: etikett for fil, _, etikett in FORMER}
|
|
KORT = {fil: kort for fil, kort, _ in FORMER}
|
|
|
|
# (field, key, conversion, decimals) per column, in the order of the tables.
|
|
VERDI = (
|
|
("verdi", "verdi", "mrd", 1),
|
|
("oppgjor", "oppgjor", "mrd", 1),
|
|
("andel_av_overskudd", "andel-overskudd", "pst", 1),
|
|
("andel_for_oppgjor", "andel-for-oppgjor", "pst", 1),
|
|
)
|
|
RISIKO = (
|
|
("r_e", "re", "pst", 1),
|
|
("LCOC", "lcoc", "mill", 1),
|
|
("tapssannsynlighet", "tap", "pst", 2),
|
|
("daarligste", "daarligste", "mrd", 1),
|
|
("kapital_ute", "kapital-ute", "mrd", 1),
|
|
)
|
|
# The column specification and the head of each table (the head may span several lines).
|
|
RAMME = {
|
|
"verdi": (
|
|
"@{}llrrrr@{}",
|
|
"Løsning & Eierform & Verdi & Oppgjør & Andel av samlet overskudd & Andel før oppgjør \\\\",
|
|
),
|
|
"risiko": (
|
|
"@{}llrrrrr@{}",
|
|
(
|
|
"& & \\multicolumn{2}{c}{Kapitalkostnad} & \\multicolumn{3}{c}{Risiko for staten} "
|
|
"\\\\\n\\cmidrule(lr){3-4}\\cmidrule(l){5-7}\n"
|
|
"Løsning & Eierform & $r_e$ & Kostnad for regnekraft & Tap & 5~\\% dårligste & "
|
|
"Kapital ute \\\\"
|
|
),
|
|
),
|
|
"rangering": (
|
|
"@{}lrllll@{}",
|
|
"Løsning & Trekninger & Rangert & Over grensen på 25~\\% & Går ut & Står likt \\\\",
|
|
),
|
|
"kontantstrom": (
|
|
"@{}lrrrr@{}",
|
|
"Løsning & Trekninger & Median & 10-persentil & 90-persentil \\\\",
|
|
),
|
|
}
|
|
KONTANTSTROM = (("antall", "tall", 0), ("median", "pst", 1), ("p10", "pst", 1), ("p90", "pst", 1))
|
|
|
|
|
|
def _losning_tekst(losning: str) -> str:
|
|
"""The code of a solution as the tables print it (B' with a prime in math mode)."""
|
|
return "$B'$" if losning == "B'" else losning
|
|
|
|
|
|
def _former(navn: list[str]) -> str:
|
|
"""A list of ownership forms as words, in the order of the parameter file."""
|
|
if not navn:
|
|
return "ingen"
|
|
if len(navn) == len(FORMER):
|
|
return "alle fire"
|
|
rekke = [NAVN[f] for f, _, _ in FORMER if f in navn]
|
|
return ", ".join(rekke)
|
|
|
|
|
|
def lag(data: Path, ut: Path) -> dict[str, Tall]:
|
|
"""Write the four table bodies and return every number they and the prose show."""
|
|
fil = les(data, FIL)
|
|
tall: dict[str, Tall] = {
|
|
"eierformer.trinn": fra_fil(fil, FIL, ("trinn",), "tall", 0),
|
|
"eierformer.grunnlag-for-trinnet": fra_fil(fil, FIL, ("grunnlag_for_trinnet",), "tekst"),
|
|
"eierformer.scenario": fra_fil(fil, FIL, ("scenario",), "tekst"),
|
|
"eierformer.antall-trekninger": fra_fil(fil, FIL, ("antall_trekninger",), "tall", 0),
|
|
}
|
|
verdi_rader: list[str] = []
|
|
risiko_rader: list[str] = []
|
|
rangering_rader: list[str] = []
|
|
strom_rader: list[str] = []
|
|
for losning, tabell in fil["per_losning"].items():
|
|
lk = LOSNING[losning]
|
|
navn = _losning_tekst(losning)
|
|
if tabell is None:
|
|
tom = f"{navn} & \\multicolumn{{5}}{{l}}{{ingen tabell}} \\\\"
|
|
verdi_rader.append(tom)
|
|
risiko_rader.append(tom)
|
|
rangering_rader.append(tom)
|
|
strom_rader.append(tom)
|
|
continue
|
|
antall = fra_fil(fil, FIL, ("per_losning", losning, "antall_byggbare"), "tall", 0)
|
|
tall[f"eierformer.{lk}.antall-byggbare"] = antall
|
|
for nr, (form, _, etikett) in enumerate(FORMER):
|
|
forste = f"\\multirow{{4}}{{*}}{{{navn}}}" if nr == 0 else ""
|
|
celler_v = _celler(fil, tall, losning, form, VERDI)
|
|
celler_r = _celler(fil, tall, losning, form, RISIKO)
|
|
verdi_rader.append(f"{forste} & {etikett} & {' & '.join(celler_v)} \\\\")
|
|
risiko_rader.append(f"{forste} & {etikett} & {' & '.join(celler_r)} \\\\")
|
|
verdi_rader.append("\\midrule")
|
|
risiko_rader.append("\\midrule")
|
|
rangering_rader.append(_rangering(tabell["rangering"], navn, antall))
|
|
strom_rader.append(_kontantstrom(fil, tall, losning, navn))
|
|
for rader in (verdi_rader, risiko_rader):
|
|
if rader and rader[-1] == "\\midrule":
|
|
rader.pop()
|
|
for navn_fil, rader in (
|
|
("verdi", verdi_rader),
|
|
("risiko", risiko_rader),
|
|
("rangering", rangering_rader),
|
|
("kontantstrom", strom_rader),
|
|
):
|
|
spec, hode = RAMME[navn_fil]
|
|
tekst = "\n".join(
|
|
[
|
|
f"\\begin{{tabular}}{{{spec}}}",
|
|
"\\toprule",
|
|
hode,
|
|
"\\midrule",
|
|
*rader,
|
|
"\\bottomrule",
|
|
"\\end{tabular}",
|
|
]
|
|
)
|
|
(ut / f"eierformer-{navn_fil}.tex").write_text(tekst + "\n", encoding="utf-8")
|
|
return tall
|
|
|
|
|
|
def _celler(
|
|
fil: Any, # noqa: ANN401
|
|
tall: dict[str, Tall],
|
|
losning: str,
|
|
form: str,
|
|
kolonner: tuple[tuple[str, str, str, int], ...],
|
|
) -> list[str]:
|
|
"""The cells of one row: one ``Tall`` per field, registered under its key."""
|
|
celler = []
|
|
for felt, nokkel, omregning, desimaler in kolonner:
|
|
sti = ("per_losning", losning, "kriterier", form, felt)
|
|
t = fra_fil(fil, FIL, sti, omregning, desimaler)
|
|
tall[f"eierformer.{LOSNING[losning]}.{KORT[form]}.{nokkel}"] = t
|
|
celler.append(t.vist)
|
|
return celler
|
|
|
|
|
|
def _rangering(rangering: dict[str, Any], navn: str, antall: Tall) -> str:
|
|
"""One row of the table of the rule: who is ranked, who is over the limit, who goes out."""
|
|
rangert = _former(list(rangering["rangert"]))
|
|
over = _former(list(rangering["over_risikogrensen"]))
|
|
ute = (
|
|
"; ".join(f"{NAVN[f]} ({grunn})" for f, grunn in rangering["ute"].items())
|
|
if rangering["ute"]
|
|
else "ingen"
|
|
)
|
|
like = (
|
|
"; ".join(", ".join(NAVN[f] for f in gruppe) for gruppe in rangering["like"])
|
|
if rangering["like"]
|
|
else "ingen"
|
|
)
|
|
return f"{navn} & {antall.vist} & {rangert} & {over} & {ute} & {like} \\\\"
|
|
|
|
|
|
def _kontantstrom(fil: Any, tall: dict[str, Tall], losning: str, navn: str) -> str: # noqa: ANN401
|
|
"""One row of the state's net cash flow next to M6 (clarification 123)."""
|
|
if fil["per_losning"][losning]["statens_kontantstrom"] is None:
|
|
return f"{navn} & \\multicolumn{{4}}{{l}}{{ingen trekning med stabil drift}} \\\\"
|
|
celler = []
|
|
for felt, omregning, desimaler in KONTANTSTROM:
|
|
sti = ("per_losning", losning, "statens_kontantstrom", felt)
|
|
t = fra_fil(fil, FIL, sti, omregning, desimaler)
|
|
tall[f"eierformer.{LOSNING[losning]}.kontantstrom.{felt}"] = t
|
|
celler.append(t.vist)
|
|
return f"{navn} & {' & '.join(celler)} \\\\"
|