docs(rapport): appendices with the parameters and the change list, the reference list, and the two-page summary
Appendix B, appendix C and the reference list are generated from the frozen parameter file, the pre-registration and the source bank. Citations link to their item in the list. The two-page summary states only what the summary in the report states. Draft PDFs of the report and the summary are in pdf/. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
This commit is contained in:
parent
53cf18ae0f
commit
f271f11715
12 changed files with 2105 additions and 67 deletions
BIN
pdf/Tokenfabrikker.pdf
Normal file
BIN
pdf/Tokenfabrikker.pdf
Normal file
Binary file not shown.
BIN
pdf/Tokenfabrikker_sammendrag.pdf
Normal file
BIN
pdf/Tokenfabrikker_sammendrag.pdf
Normal file
Binary file not shown.
|
|
@ -5,8 +5,9 @@
|
|||
#
|
||||
# Every LaTeX run has a hard time limit (TIDSGRENSE seconds, default 120): one pdflatex run has
|
||||
# been seen to hang. The limit is set with perl's alarm, since macOS has no timeout command.
|
||||
# The script first writes vedlegg_kart.tex with lag_vedlegg.py and generert/ (chapter 6) with
|
||||
# lag_resultater.py. It exits non-zero when the
|
||||
# The script first writes vedlegg_kart.tex with lag_vedlegg.py, generert/ (chapter 6) with
|
||||
# lag_resultater.py, the appendices with the parameters and the change list, and the reference
|
||||
# list (lag_vedlegg_parametere.py, lag_vedlegg_endringer.py, lag_referanser.py). It exits non-zero when the
|
||||
# generator fails, a LaTeX run fails or times out, or the last run reports undefined references.
|
||||
# Bash 3.2 and ASCII only. Build output stays in rapport/ and is ignored by git.
|
||||
|
||||
|
|
@ -84,6 +85,10 @@ fi
|
|||
|
||||
python3 lag_vedlegg.py || { echo "FEIL: lag_vedlegg.py" >&2; exit 1; }
|
||||
python3 lag_resultater.py || { echo "FEIL: lag_resultater.py" >&2; exit 1; }
|
||||
python3 lag_vedlegg_parametere.py || { echo "FEIL: lag_vedlegg_parametere.py" >&2; exit 1; }
|
||||
python3 lag_vedlegg_endringer.py || { echo "FEIL: lag_vedlegg_endringer.py" >&2; exit 1; }
|
||||
# Last: the reference list also reads the generated appendices.
|
||||
python3 lag_referanser.py || { echo "FEIL: lag_referanser.py" >&2; exit 1; }
|
||||
|
||||
feil=0
|
||||
for maal in "$@"; do
|
||||
|
|
|
|||
|
|
@ -16,4 +16,4 @@ Ideen om et eget kjernekraftverk for hvert datasenter er inspirert av Sadhguru,
|
|||
tall eller noen påstand her.
|
||||
|
||||
Teksten er lisensiert under CC BY 4.0, koden og dataene under MIT-lisensen. Modellen, kildebanken og
|
||||
dataene ligger på \kommer{lenke til repoet}.
|
||||
dataene ligger på \url{https://git.fromaitochitta.com/open/tokenfabrikker}.
|
||||
|
|
|
|||
|
|
@ -83,9 +83,9 @@ de beste utfallene, slik de to funnene over sier at den kan bli dyrere i de dår
|
|||
avvik fra frysen og føres med dato og grunn (spesifikasjonen kapittel~15).
|
||||
\item \emph{Område 27 hviler mest på språkmodeller.} Av de 90 postene om hva fagmiljøene sier, hviler
|
||||
85 på forsker og kontrollør, som begge er språkmodeller; prosjektet har selv funnet sitatene i fem
|
||||
bærende poster (K27-001, K27-007, K27-017, K27-138 og K27-142). Fire studier av læring i kjernekraft
|
||||
bærende poster \kilde{K27-001, K27-007, K27-017, K27-138, K27-142}. Fire studier av læring i kjernekraft
|
||||
er lest i arbeidsnotat, instituttutgave eller manus, ikke i den publiserte tidsskriftsversjonen, og én
|
||||
av dem bare i sammendrag (K27-008 til K27-011). Ett tall står som «Ikke verifisert» (K27-038). Runden
|
||||
av dem bare i sammendrag \kilde{K27-008 til K27-011}. Ett tall står som «Ikke verifisert» \kilde{K27-038}. Runden
|
||||
var én dag (fagfelleloggen del~19). Ingen parameter bygger på område 27.
|
||||
\end{itemize}
|
||||
|
||||
|
|
|
|||
668
rapport/lag_referanser.py
Normal file
668
rapport/lag_referanser.py
Normal file
|
|
@ -0,0 +1,668 @@
|
|||
# ruff: noqa: INP001
|
||||
r"""Write the reference list of the report: the entries of the source bank it cites.
|
||||
|
||||
The report cites entries in the source bank (``kilder/*.md``) with ``\kilde{K03-020}``,
|
||||
``\kilde{K03-044, K03-045}`` or ``\kilde{K27-007 til K27-011}``. This script collects
|
||||
the cited ids from three places:
|
||||
|
||||
(a) every ``\kilde{...}`` in the hand-written ``rapport/*.tex`` (LaTeX comments are
|
||||
skipped);
|
||||
(b) every ``poster`` list in ``modell/parametere.json`` (the parameter appendix cites
|
||||
them);
|
||||
(c) every ``\kilde{...}`` in ``rapport/generert/vedlegg-*.tex``, when such files exist.
|
||||
|
||||
For each cited id it looks up the entry (``### K03-020 Title`` and its bullet fields)
|
||||
and writes ``rapport/generert/referanser.tex``: a short lead-in with the counts, then
|
||||
one item per entry, sorted by id in natural order, with the id as label (the look of
|
||||
``\kilde``), a hyperlink target named ``kilde:<id>``, the entry's title and its
|
||||
``Kilde`` field as the entry gives it. Nothing is paraphrased: the text is the
|
||||
entry's own, escaped for LaTeX; URLs become ``\url{...}``, Markdown italics
|
||||
``\emph{...}`` and code spans ``\fil{...}``.
|
||||
|
||||
The rule of the project: no reference is written in unless the entry's ``Kontroll``
|
||||
line confirms it. The line is classified from what it says (see ``klasse``). An
|
||||
entry whose class is not in ``TILLATT`` stops the script, unless its id stands in
|
||||
``UNNTAK`` with the operator's decision.
|
||||
|
||||
Standard library only. Same input, same bytes. The script stops with an error, and
|
||||
writes nothing, when a cited id has no entry, when a citation or an entry does not
|
||||
have the expected form, when a cited entry is not confirmed, or when the text holds
|
||||
a character or a Markdown construct the script does not know.
|
||||
|
||||
Run from anywhere: ``python3 rapport/lag_referanser.py``. With ``--sjekk`` it writes
|
||||
nothing and prints everything it found: the ids per origin, every problem at once,
|
||||
the classes of the Kontroll lines with the entries outside the plain classes and
|
||||
where they are cited, and the ids the report mentions outside ``\kilde{}``.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import re
|
||||
import sys
|
||||
from collections import Counter
|
||||
from dataclasses import dataclass
|
||||
from pathlib import Path
|
||||
from urllib.parse import quote
|
||||
|
||||
ROT = Path(__file__).resolve().parent.parent
|
||||
KILDER = ROT / "kilder"
|
||||
RAPPORT = ROT / "rapport"
|
||||
GENERERT = RAPPORT / "generert"
|
||||
PARAMETERE = ROT / "modell" / "parametere.json"
|
||||
UT = GENERERT / "referanser.tex"
|
||||
|
||||
# Cited entries whose Kontroll class is not in TILLATT, let through by the operator's
|
||||
# decision. Key: the id. Value: the date and the reason, as the operator gave them.
|
||||
# Empty: no exception has been decided.
|
||||
UNNTAK: dict[str, str] = {}
|
||||
|
||||
BEKREFTET = "bekreftet"
|
||||
FORBEHOLD = "bekreftet med forbehold"
|
||||
RETTET = "rettet"
|
||||
LAGT_TIL = "lagt til av kontrolløren"
|
||||
IKKE_BEKREFTET = "ikke bekreftet"
|
||||
MANGLER = "mangler"
|
||||
ANNET = "annen ordlyd"
|
||||
KLASSER = (BEKREFTET, FORBEHOLD, RETTET, LAGT_TIL, IKKE_BEKREFTET, MANGLER, ANNET)
|
||||
TILLATT = frozenset({BEKREFTET, FORBEHOLD, RETTET, LAGT_TIL})
|
||||
|
||||
ID = r"K\d{2}[a-z]?-[A-Za-z0-9]+(?:-[A-Za-z0-9]+)*"
|
||||
ER_ID = re.compile(ID)
|
||||
I_TEKST = re.compile(r"(?<![A-Za-z0-9-])" + ID + r"(?![A-Za-z0-9])")
|
||||
OMRAADE = re.compile(r"^K(\d{2})([a-z]?)-")
|
||||
INTERVALL = re.compile(r"^(" + ID + r")\s+til\s+(" + ID + r")$")
|
||||
NUMMERERT = re.compile(r"^(K\d{2}[a-z]?-)(\d+)$")
|
||||
OVERSKRIFT = re.compile(r"^### (Ikke verifisert: )?(" + ID + r") (\S.*)$")
|
||||
ID_OVERSKRIFT = re.compile(r"^#+ (?:Ikke verifisert: )?" + ID + r"\b")
|
||||
FELT = re.compile(r"^- \*\*([^*]+?):\*\*(?: (.*))?$")
|
||||
# A citation is \kilde{ with no space: a definition such as \RenewDocumentCommand \kilde { m }
|
||||
# is not one.
|
||||
KILDE_START = re.compile(r"\\kilde\{")
|
||||
|
||||
# A code span, a URL (it ends at white space, a guillemet, a backtick or an ellipsis) or
|
||||
# Markdown italics (the star opens before a word and closes after one, as in CommonMark).
|
||||
DEL = re.compile(
|
||||
r"`(?P<kode>[^`]*)`"
|
||||
r"|(?P<url>https?://[^\s\u00ab\u00bb`\u2026]+)"
|
||||
r"|(?<![\w*])\*(?=[^\s*])(?P<kursiv>[^*]+?)(?<=[^\s*])\*(?![\w*])"
|
||||
)
|
||||
TRYGG_KODE = re.compile(r"^[A-Za-z0-9._/-]+$")
|
||||
# Printable ASCII but the characters \url cannot take (" is a shorthand in babel norsk).
|
||||
TRYGG_URL = re.compile(r"^[!#-\[\]_a-z|~]+$")
|
||||
SLUTT_URL = ".,;:!?"
|
||||
|
||||
# LaTeX for the ASCII characters that need it in running text.
|
||||
ASCII_TEX = {
|
||||
"\\": r"\textbackslash{}",
|
||||
"{": r"\{",
|
||||
"}": r"\}",
|
||||
"$": r"\$",
|
||||
"&": r"\&",
|
||||
"%": r"\%",
|
||||
"#": r"\#",
|
||||
"_": r"\_",
|
||||
"^": r"\textasciicircum{}",
|
||||
"~": r"\textasciitilde{}",
|
||||
"<": r"\textless{}",
|
||||
">": r"\textgreater{}",
|
||||
"|": r"\textbar{}",
|
||||
'"': r"\textquotedbl{}",
|
||||
}
|
||||
|
||||
# Every non-ASCII character the entries hold, and how it is written. A letter the
|
||||
# T1 encoding has is written as itself (inputenc reads it); the rest as a command.
|
||||
# A character that is not here stops the script.
|
||||
UNICODE_TEX = {
|
||||
"\u00e5": "\u00e5", # a with ring
|
||||
"\u00c5": "\u00c5",
|
||||
"\u00f8": "\u00f8", # o with stroke
|
||||
"\u00d8": "\u00d8",
|
||||
"\u00e6": "\u00e6", # ae
|
||||
"\u00c6": "\u00c6",
|
||||
"\u00e4": "\u00e4", # a with diaeresis
|
||||
"\u00c4": "\u00c4",
|
||||
"\u00f6": "\u00f6", # o with diaeresis
|
||||
"\u00d6": "\u00d6",
|
||||
"\u00fc": "\u00fc", # u with diaeresis
|
||||
"\u00e9": "\u00e9", # e with acute
|
||||
"\u00c9": "\u00c9",
|
||||
"\u00e8": "\u00e8", # e with grave
|
||||
"\u00ea": "\u00ea", # e with circumflex
|
||||
"\u00e7": "\u00e7", # c with cedilla
|
||||
"\u00e0": "\u00e0", # a with grave
|
||||
"\u00e1": "\u00e1", # a with acute
|
||||
"\u00fb": "\u00fb", # u with circumflex
|
||||
"\u00da": "\u00da", # U with acute
|
||||
"\u00ed": "\u00ed", # i with acute
|
||||
"\u00f3": "\u00f3", # o with acute
|
||||
"\u00ab": r"\guillemotleft{}",
|
||||
"\u00bb": r"\guillemotright{}",
|
||||
"\u2013": r"\textendash{}",
|
||||
"\u2014": r"\textemdash{}",
|
||||
"\u2026": r"\textellipsis{}",
|
||||
"\u2018": r"\textquoteleft{}",
|
||||
"\u2019": r"\textquoteright{}",
|
||||
"\u201c": r"\textquotedblleft{}",
|
||||
"\u201d": r"\textquotedblright{}",
|
||||
"\u00a7": r"\S{}",
|
||||
"\u00b6": r"\P{}",
|
||||
"\u2212": r"\textminus{}",
|
||||
"\u2192": r"\textrightarrow{}",
|
||||
"\u20ac": r"\texteuro{}",
|
||||
"\u00a3": r"\pounds{}",
|
||||
"\u00b3": r"\textthreesuperior{}",
|
||||
"\u00b2": r"\texttwosuperior{}",
|
||||
"\u00d7": r"\texttimes{}",
|
||||
"\u00b0": r"\textdegree{}",
|
||||
"\u00b1": r"\textpm{}",
|
||||
"\u2265": r"\ensuremath{\geq}",
|
||||
"\u2264": r"\ensuremath{\leq}",
|
||||
"\u2248": r"\ensuremath{\approx}",
|
||||
"\u2082": r"\textsubscript{2}",
|
||||
"\u00a0": "~", # no-break space
|
||||
}
|
||||
|
||||
LISTE = (
|
||||
r"\begin{itemize}[label={},leftmargin=1.6em,itemindent=-1.6em,labelwidth=0pt,"
|
||||
r"labelsep=0pt,align=left,itemsep=0.6pt plus 0.4pt,parsep=0pt,topsep=4pt]"
|
||||
)
|
||||
# URLs may break after any letter or digit too (with a penalty), so that a long
|
||||
# path never runs into the margin. Set inside the group of the list only.
|
||||
BRUDD = "".join(
|
||||
rf"\do\{c}" for c in "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-"
|
||||
)
|
||||
|
||||
|
||||
class ReferanseError(Exception):
|
||||
"""The input does not have the expected form."""
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class Post:
|
||||
"""One entry of the source bank, as far as the reference list needs it."""
|
||||
|
||||
id: str
|
||||
tittel: str
|
||||
kilde: str
|
||||
kontroll: str | None
|
||||
merket: bool # the heading says "Ikke verifisert:"
|
||||
sted: str # file and line of the heading
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# The source bank
|
||||
|
||||
|
||||
def les_poster(navn: str, tekst: str, feil: list[str]) -> list[Post]:
|
||||
"""Return the entries of one file of the source bank; append problems to ``feil``."""
|
||||
linjer = tekst.splitlines()
|
||||
poster: list[Post] = []
|
||||
i = 0
|
||||
while i < len(linjer):
|
||||
m = OVERSKRIFT.match(linjer[i])
|
||||
if not m:
|
||||
if ID_OVERSKRIFT.match(linjer[i]):
|
||||
feil.append(
|
||||
f"{navn}:{i + 1}: heading with an id that is not an entry: {linjer[i]!r}"
|
||||
)
|
||||
i += 1
|
||||
continue
|
||||
sted = f"kilder/{navn}:{i + 1}"
|
||||
felt: list[tuple[str, list[str]]] = []
|
||||
i += 1
|
||||
while i < len(linjer):
|
||||
linje = linjer[i]
|
||||
if linje.startswith("#"):
|
||||
break
|
||||
f = FELT.match(linje)
|
||||
if f:
|
||||
felt.append((f.group(1), [f.group(2) or ""]))
|
||||
elif not linje.strip() or linje.startswith((" ", "\t")):
|
||||
if felt:
|
||||
felt[-1][1].append(linje.strip())
|
||||
elif linje.strip():
|
||||
feil.append(f"{sted}: indented line before the first field")
|
||||
else:
|
||||
break # text after the entry (a section heading in bold, a table)
|
||||
i += 1
|
||||
poster.append(lag_post(m, felt, sted, feil))
|
||||
return poster
|
||||
|
||||
|
||||
def lag_post(
|
||||
m: re.Match[str], felt: list[tuple[str, list[str]]], sted: str, feil: list[str]
|
||||
) -> Post:
|
||||
"""Put one entry together from its heading and fields."""
|
||||
kilder = [deler for navn, deler in felt if navn == "Kilde"]
|
||||
kontroller = [deler for navn, deler in felt if navn == "Kontroll"]
|
||||
kilde = ""
|
||||
if len(kilder) != 1:
|
||||
feil.append(f"{sted}: {m.group(2)} has {len(kilder)} Kilde fields, not one")
|
||||
else:
|
||||
deler = kilder[0]
|
||||
while deler and not deler[-1]:
|
||||
deler = deler[:-1]
|
||||
if any(d.startswith(("- ", "* ", "|")) for d in deler[1:]):
|
||||
feil.append(f"{sted}: {m.group(2)}: a list or table inside the Kilde field")
|
||||
kilde = " ".join(d for d in deler if d)
|
||||
if not kilde:
|
||||
feil.append(f"{sted}: {m.group(2)}: empty Kilde field")
|
||||
kontroll: str | None = None
|
||||
if len(kontroller) > 1:
|
||||
feil.append(f"{sted}: {m.group(2)} has {len(kontroller)} Kontroll fields")
|
||||
elif kontroller:
|
||||
kontroll = " ".join(d for d in kontroller[0] if d)
|
||||
return Post(m.group(2), m.group(3).strip(), kilde, kontroll, bool(m.group(1)), sted)
|
||||
|
||||
|
||||
def les_banken(feil: list[str]) -> dict[str, Post]:
|
||||
"""Return every entry of the source bank by id."""
|
||||
poster: dict[str, Post] = {}
|
||||
filer = sorted(p for p in KILDER.glob("*.md") if p.name != "README.md")
|
||||
if not filer:
|
||||
msg = f"no files in {KILDER}"
|
||||
raise ReferanseError(msg)
|
||||
for fil in filer:
|
||||
for post in les_poster(fil.name, fil.read_text(encoding="utf-8"), feil):
|
||||
if post.id in poster:
|
||||
feil.append(f"{post.sted}: {post.id} also stands at {poster[post.id].sted}")
|
||||
continue
|
||||
poster[post.id] = post
|
||||
return poster
|
||||
|
||||
|
||||
def klasse(post: Post) -> str:
|
||||
"""Classify the entry's Kontroll line from what it says.
|
||||
|
||||
The line's first words decide: «ikke bekreftet»; «bekreftet som …» or
|
||||
«bekreftet for …» (confirmed as a news item, as a rendering, for one edition
|
||||
or some years: «bekreftet med forbehold»); «bekreftet» (also «bekreftet ved ny
|
||||
kontroll»); «rettet»; «ny post …» or «lagt til …» (added by the controller,
|
||||
who read the primary source). No line is «mangler»; anything else, or a
|
||||
heading that still says «Ikke verifisert:», is «annen ordlyd».
|
||||
"""
|
||||
if post.kontroll is None:
|
||||
return MANGLER
|
||||
t = post.kontroll.strip()
|
||||
if re.match(r"ikke bekreftet\b", t):
|
||||
klasse_ = IKKE_BEKREFTET
|
||||
elif re.match(r"bekreftet (som|for)\b", t):
|
||||
klasse_ = FORBEHOLD
|
||||
elif re.match(r"bekreftet\b", t):
|
||||
klasse_ = BEKREFTET
|
||||
elif re.match(r"rettet\b", t):
|
||||
klasse_ = RETTET
|
||||
elif re.match(r"(ny post|lagt til)\b", t):
|
||||
klasse_ = LAGT_TIL
|
||||
else:
|
||||
klasse_ = ANNET
|
||||
if post.merket and klasse_ in TILLATT:
|
||||
return ANNET # the heading still says "Ikke verifisert:"
|
||||
return klasse_
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Where the report cites
|
||||
|
||||
|
||||
def uten_kommentarer(tekst: str) -> str:
|
||||
"""Remove LaTeX comments, keeping the line breaks."""
|
||||
return "\n".join(re.sub(r"(?<!\\)%.*", "", linje) for linje in tekst.split("\n"))
|
||||
|
||||
|
||||
def utvid(del_: str) -> list[str] | None:
|
||||
"""Return the ids of one part of a citation (an id, or 'A til B'), or None."""
|
||||
if ER_ID.fullmatch(del_):
|
||||
return [del_]
|
||||
m = INTERVALL.match(del_)
|
||||
if not m:
|
||||
return None
|
||||
a, b = NUMMERERT.match(m.group(1)), NUMMERERT.match(m.group(2))
|
||||
if not a or not b or a.group(1) != b.group(1) or len(a.group(2)) != len(b.group(2)):
|
||||
return None
|
||||
fra, til = int(a.group(2)), int(b.group(2))
|
||||
if fra >= til:
|
||||
return None
|
||||
bredde = len(a.group(2))
|
||||
return [f"{a.group(1)}{n:0{bredde}d}" for n in range(fra, til + 1)]
|
||||
|
||||
|
||||
def les_henvisninger(navn: str, tekst: str, feil: list[str]) -> list[tuple[str, str]]:
|
||||
r"""Return (id, file:line) for every id inside a \kilde{...} of a .tex file."""
|
||||
ren = uten_kommentarer(tekst)
|
||||
funnet: list[tuple[str, str]] = []
|
||||
for m in KILDE_START.finditer(ren):
|
||||
linje = ren.count("\n", 0, m.start()) + 1
|
||||
sted = f"{navn}:{linje}"
|
||||
slutt = ren.find("}", m.end())
|
||||
innhold = ren[m.end() : slutt] if slutt >= 0 else ""
|
||||
if slutt < 0 or "{" in innhold or "\\" in innhold:
|
||||
feil.append(f"{sted}: a \\kilde{{...}} that is not a plain list of ids")
|
||||
continue
|
||||
for del_ in innhold.split(","):
|
||||
del_ = " ".join(del_.split()) # noqa: PLW2901
|
||||
ider = utvid(del_)
|
||||
if ider is None:
|
||||
feil.append(f"{sted}: not an id or a range of ids: {del_!r}")
|
||||
continue
|
||||
funnet += [(i, sted) for i in ider]
|
||||
return funnet
|
||||
|
||||
|
||||
def les_parameterposter(data: object, sti: str = "") -> list[tuple[str, str]]:
|
||||
"""Return (id, place) for every id in a ``poster`` list of the parameter file."""
|
||||
funnet: list[tuple[str, str]] = []
|
||||
if isinstance(data, dict):
|
||||
navn = data.get("id")
|
||||
sted = f"modell/parametere.json: {navn}" if isinstance(navn, str) else sti
|
||||
for nokkel, verdi in data.items():
|
||||
if nokkel == "poster":
|
||||
if not isinstance(verdi, list) or not all(isinstance(v, str) for v in verdi):
|
||||
msg = f"{sted or 'modell/parametere.json'}: poster is not a list of ids"
|
||||
raise ReferanseError(msg)
|
||||
funnet += [(v, sted or f"modell/parametere.json: {sti}") for v in verdi]
|
||||
else:
|
||||
funnet += les_parameterposter(verdi, f"{sti}/{nokkel}")
|
||||
elif isinstance(data, list):
|
||||
for n, verdi in enumerate(data):
|
||||
funnet += les_parameterposter(verdi, f"{sti}[{n}]")
|
||||
return funnet
|
||||
|
||||
|
||||
def tex_filer() -> tuple[list[Path], list[Path]]:
|
||||
"""Return the hand-written .tex files of the report and the generated appendix files."""
|
||||
hand = sorted(RAPPORT.glob("*.tex"))
|
||||
generert = sorted(GENERERT.glob("vedlegg-*.tex"))
|
||||
return hand, generert
|
||||
|
||||
|
||||
def les_alle_henvisninger(feil: list[str]) -> dict[str, list[tuple[str, str]]]:
|
||||
"""Return the citations per origin: 'a' hand-written, 'b' parameter file, 'c' generated."""
|
||||
hand, generert = tex_filer()
|
||||
a: list[tuple[str, str]] = []
|
||||
for fil in hand:
|
||||
a += les_henvisninger(f"rapport/{fil.name}", fil.read_text(encoding="utf-8"), feil)
|
||||
c: list[tuple[str, str]] = []
|
||||
for fil in generert:
|
||||
c += les_henvisninger(f"rapport/generert/{fil.name}", fil.read_text(encoding="utf-8"), feil)
|
||||
b = les_parameterposter(json.loads(PARAMETERE.read_text(encoding="utf-8")))
|
||||
for i, sted in b:
|
||||
if not ER_ID.fullmatch(i):
|
||||
feil.append(f"{sted}: not an id: {i!r}")
|
||||
return {"a": a, "b": [(i, s) for i, s in b if ER_ID.fullmatch(i)], "c": c}
|
||||
|
||||
|
||||
def utenfor_kilde() -> list[tuple[str, str]]:
|
||||
r"""Return (id, file:line) for ids the hand-written report text holds outside \kilde{}."""
|
||||
funnet: list[tuple[str, str]] = []
|
||||
hand, _ = tex_filer()
|
||||
for fil in hand:
|
||||
ren = uten_kommentarer(fil.read_text(encoding="utf-8"))
|
||||
ren = re.sub(r"\\kilde\{[^{}]*\}", lambda m: "\n" * m.group(0).count("\n"), ren)
|
||||
for m in I_TEKST.finditer(ren):
|
||||
linje = ren.count("\n", 0, m.start()) + 1
|
||||
funnet.append((m.group(0), f"rapport/{fil.name}:{linje}"))
|
||||
return funnet
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# LaTeX
|
||||
|
||||
|
||||
def sorteringsnokkel(post_id: str) -> tuple[tuple[int, int | str], ...]:
|
||||
"""Natural order: area, then the rest with numbers as numbers (001 before K01)."""
|
||||
deler = re.split(r"(\d+)", post_id)
|
||||
return tuple((0, int(d)) if d.isdigit() else (1, d) for d in deler if d)
|
||||
|
||||
|
||||
def etter_ord(tekst: str, k: int) -> bool:
|
||||
"""True when the character at k follows a word and no word follows it."""
|
||||
return k > 0 and tekst[k - 1].isalnum() and not (k + 1 < len(tekst) and tekst[k + 1].isalnum())
|
||||
|
||||
|
||||
def tex_tegn(tekst: str, sted: str) -> str:
|
||||
"""Escape plain running text (no URLs, code spans or italics) for LaTeX."""
|
||||
ut: list[str] = []
|
||||
for k, tegn in enumerate(tekst):
|
||||
if tegn in ASCII_TEX:
|
||||
ut.append(ASCII_TEX[tegn])
|
||||
elif tegn == "*" and etter_ord(tekst, k):
|
||||
ut.append("*") # a mark after a word, like «1y*»: not Markdown
|
||||
elif tegn in "*`":
|
||||
msg = f"{sted}: a lone {tegn!r} (unpaired Markdown) in {tekst!r}"
|
||||
raise ReferanseError(msg)
|
||||
elif ord(tegn) < 128: # noqa: PLR2004
|
||||
if not tegn.isprintable():
|
||||
msg = f"{sted}: control character {tegn!r}"
|
||||
raise ReferanseError(msg)
|
||||
ut.append(tegn)
|
||||
elif tegn in UNICODE_TEX:
|
||||
ut.append(UNICODE_TEX[tegn])
|
||||
else:
|
||||
msg = f"{sted}: unknown character {tegn!r} (U+{ord(tegn):04X}); add it to UNICODE_TEX"
|
||||
raise ReferanseError(msg)
|
||||
tex = "".join(ut)
|
||||
# Keep the T1 ligatures out: -- (dash), '' (quote), ,, (low quote).
|
||||
for par in ("--", "''", ",,"):
|
||||
while par in tex:
|
||||
tex = tex.replace(par, par[0] + "{}" + par[1])
|
||||
return tex
|
||||
|
||||
|
||||
def tex_url(url: str, sted: str) -> str:
|
||||
r"""A URL as \url{...}, with % and # escaped (hyperref removes the backslash).
|
||||
|
||||
A URL with a letter outside ASCII (``§36-4``, ``inngår``, a template such as
|
||||
``ÅÅÅÅ-MM-DD``) cannot go through \url under pdflatex. It is written as
|
||||
\href with the letters percent-encoded as UTF-8 in the link, and shown as it
|
||||
stands in the entry, in the typewriter font of \url, with break points.
|
||||
"""
|
||||
if TRYGG_URL.match(url):
|
||||
return r"\url{" + url.replace("%", r"\%").replace("#", r"\#") + "}"
|
||||
ascii_ = "".join(c if ord(c) < 128 else quote(c, safe="") for c in url) # noqa: PLR2004
|
||||
if not TRYGG_URL.match(ascii_):
|
||||
msg = f"{sted}: URL with a character \\url cannot take: {url!r}"
|
||||
raise ReferanseError(msg)
|
||||
lenke = ascii_.replace("%", r"\%").replace("#", r"\#")
|
||||
vist = "".join(tex_tegn(c, sted) + (r"\allowbreak{}" if c in "/.-=&?" else "") for c in url)
|
||||
return r"\href{" + lenke + r"}{\texttt{" + vist + "}}"
|
||||
|
||||
|
||||
def klipp_url(url: str) -> str:
|
||||
"""Strip the punctuation that ends the sentence, not the URL."""
|
||||
while True:
|
||||
siste = url[-1]
|
||||
aapen = {")": "(", "]": "["}.get(siste)
|
||||
if siste in SLUTT_URL or (aapen and url.count(aapen) < url.count(siste)):
|
||||
url = url[:-1]
|
||||
else:
|
||||
return url
|
||||
|
||||
|
||||
def tex_tekst(tekst: str, sted: str, *, kursiv: bool = True) -> str:
|
||||
"""Escape a field with Markdown code spans, URLs and italics for LaTeX."""
|
||||
ut: list[str] = []
|
||||
pos = 0
|
||||
while True:
|
||||
m = DEL.search(tekst, pos)
|
||||
if not m:
|
||||
ut.append(tex_tegn(tekst[pos:], sted))
|
||||
return "".join(ut)
|
||||
ut.append(tex_tegn(tekst[pos : m.start()], sted))
|
||||
if m.group("kode") is not None:
|
||||
kode = m.group("kode")
|
||||
if not TRYGG_KODE.match(kode):
|
||||
msg = f"{sted}: code span with characters \\fil cannot take: {kode!r}"
|
||||
raise ReferanseError(msg)
|
||||
ut.append(r"\fil{" + kode + "}")
|
||||
pos = m.end()
|
||||
elif m.group("url") is not None:
|
||||
url = klipp_url(m.group("url"))
|
||||
ut.append(tex_url(url, sted))
|
||||
pos = m.start() + len(url)
|
||||
else:
|
||||
if not kursiv:
|
||||
msg = f"{sted}: italics inside italics in {tekst!r}"
|
||||
raise ReferanseError(msg)
|
||||
ut.append(r"\emph{" + tex_tekst(m.group("kursiv"), sted, kursiv=False) + "}")
|
||||
pos = m.end()
|
||||
|
||||
|
||||
def tex_post(post: Post) -> str:
|
||||
"""One item of the list: target, label, title, the Kilde field."""
|
||||
tittel = tex_tekst(post.tittel, post.sted)
|
||||
skille = " " if post.tittel.rstrip("*")[-1:] in ".?!" else ". "
|
||||
return (
|
||||
rf"\item \hypertarget{{kilde:{post.id}}}{{}}{{\color{{accent}}\textsf{{[{post.id}]}}}}"
|
||||
rf"\enskip {tittel}{skille}{tex_tekst(post.kilde, post.sted)}"
|
||||
)
|
||||
|
||||
|
||||
def omraade(post_id: str) -> str:
|
||||
"""The area of an id: its two digits (and letter, if any)."""
|
||||
m = OMRAADE.match(post_id)
|
||||
if not m:
|
||||
msg = f"no area in {post_id!r}"
|
||||
raise ReferanseError(msg)
|
||||
return m.group(1) + m.group(2)
|
||||
|
||||
|
||||
def lag(poster: list[Post], i_tekst: int, i_vedlegg: int, alle_omraader: int) -> str:
|
||||
"""Return the LaTeX of the reference list."""
|
||||
omraader = len({omraade(p.id) for p in poster})
|
||||
innledning = (
|
||||
rf"\noindent Lista har de {len(poster)} postene i kildebanken som rapporten viser til,"
|
||||
rf" fra {omraader} av de {alle_omraader} områdene i \fil{{kilder/}}: {i_tekst} i teksten"
|
||||
rf" og {i_vedlegg} i parametertabellen i \cref{{app:parametere}} (noen begge steder)."
|
||||
r" Hver post står med tittel og med kildefeltet slik posten gir det: kilde, sted i kilden"
|
||||
r" og lenke. Posten i \fil{kilder/} har i tillegg påstanden, tallene, et ordrett sitat og"
|
||||
r" kontrollen mot primærkilden. Lista er laget av \fil{rapport/lag_referanser.py} og"
|
||||
r" rettes ikke for hånd."
|
||||
)
|
||||
ut = [
|
||||
"% Laget av rapport/lag_referanser.py fra kilder/*.md, rapport/*.tex og",
|
||||
"% modell/parametere.json. Rettes ikke for hånd: kjør skriptet på nytt.",
|
||||
innledning,
|
||||
"",
|
||||
r"\begingroup",
|
||||
r"\fontsize{9}{10.5}\selectfont",
|
||||
r"\raggedright",
|
||||
r"\expandafter\def\expandafter\UrlBreaks\expandafter{\UrlBreaks" + BRUDD + "}",
|
||||
LISTE,
|
||||
]
|
||||
ut += [tex_post(p) for p in poster]
|
||||
ut += [r"\end{itemize}", r"\endgroup", ""]
|
||||
return "\n".join(ut)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Running
|
||||
|
||||
|
||||
@dataclass
|
||||
class Funn:
|
||||
"""Everything the script found, before anything is written."""
|
||||
|
||||
bank: dict[str, Post]
|
||||
henvisninger: dict[str, list[tuple[str, str]]]
|
||||
feil: list[str]
|
||||
|
||||
def steder(self) -> dict[str, list[str]]:
|
||||
"""Where each cited id is cited, in the order found."""
|
||||
steder: dict[str, list[str]] = {}
|
||||
for opphav in ("a", "b", "c"):
|
||||
for i, sted in self.henvisninger[opphav]:
|
||||
steder.setdefault(i, []).append(sted)
|
||||
return steder
|
||||
|
||||
|
||||
def finn() -> Funn:
|
||||
"""Read the source bank and the citations; collect every problem."""
|
||||
feil: list[str] = []
|
||||
bank = les_banken(feil)
|
||||
henvisninger = les_alle_henvisninger(feil)
|
||||
funn = Funn(bank, henvisninger, feil)
|
||||
alle = funn.steder()
|
||||
for i in sorted(alle, key=sorteringsnokkel):
|
||||
hvor = ", ".join(alle[i])
|
||||
if i not in bank:
|
||||
feil.append(f"{i} has no entry in kilder/ (cited at {hvor})")
|
||||
continue
|
||||
k = klasse(bank[i])
|
||||
if k not in TILLATT and i not in UNNTAK:
|
||||
feil.append(
|
||||
f"{i} ({bank[i].sted}) is not confirmed: Kontroll is '{k}' (cited at {hvor})"
|
||||
)
|
||||
try:
|
||||
tex_post(bank[i])
|
||||
except ReferanseError as e:
|
||||
feil.append(str(e))
|
||||
feil.extend(f"{i} stands in UNNTAK but is not cited" for i in sorted(set(UNNTAK) - set(alle)))
|
||||
return funn
|
||||
|
||||
|
||||
def sjekk(funn: Funn) -> int:
|
||||
"""Print what was found; write nothing."""
|
||||
s = sys.stdout.write
|
||||
steder = funn.steder()
|
||||
for opphav, navn in (("a", "rapport/*.tex"), ("b", "parametere.json"), ("c", "generert")):
|
||||
s(f"ids {opphav} ({navn}): {len({i for i, _ in funn.henvisninger[opphav]})}\n")
|
||||
s(f"ids in all: {len(steder)}\n")
|
||||
s(f"entries in the bank: {len(funn.bank)}\n\n")
|
||||
teller: Counter[str] = Counter()
|
||||
for i in steder:
|
||||
if i in funn.bank:
|
||||
teller[klasse(funn.bank[i])] += 1
|
||||
s("Kontroll classes of the cited entries:\n")
|
||||
for k in KLASSER:
|
||||
s(f" {k}: {teller[k]}\n")
|
||||
s("\nCited entries outside the classes bekreftet, rettet and lagt til:\n")
|
||||
for i in sorted(steder, key=sorteringsnokkel):
|
||||
if i in funn.bank and klasse(funn.bank[i]) not in {BEKREFTET, RETTET, LAGT_TIL}:
|
||||
post = funn.bank[i]
|
||||
s(f" {i} [{klasse(post)}] {post.sted}\n Kontroll: {(post.kontroll or '')[:200]}\n")
|
||||
s(f" cited at: {', '.join(steder[i])}\n")
|
||||
s("\nIds mentioned outside \\kilde{} in rapport/*.tex:\n")
|
||||
for i, sted in utenfor_kilde():
|
||||
s(f" {i} at {sted}\n")
|
||||
s(f"\nProblems ({len(funn.feil)}):\n")
|
||||
for f in funn.feil:
|
||||
s(f" {f}\n")
|
||||
return 1 if funn.feil else 0
|
||||
|
||||
|
||||
def main(argv: list[str]) -> int:
|
||||
"""Write the reference list; return 0, or 1 with a message on error."""
|
||||
if argv not in ([], ["--sjekk"]):
|
||||
sys.stderr.write("bruk: lag_referanser.py [--sjekk]\n")
|
||||
return 2
|
||||
try:
|
||||
funn = finn()
|
||||
except (ReferanseError, OSError, json.JSONDecodeError) as e:
|
||||
sys.stderr.write(f"lag_referanser: {e}\n")
|
||||
return 1
|
||||
if argv == ["--sjekk"]:
|
||||
return sjekk(funn)
|
||||
if funn.feil:
|
||||
sys.stderr.write("lag_referanser: the reference list is not written:\n")
|
||||
sys.stderr.writelines(f" {f}\n" for f in funn.feil)
|
||||
return 1
|
||||
steder = funn.steder()
|
||||
poster = [funn.bank[i] for i in sorted(steder, key=sorteringsnokkel)]
|
||||
i_tekst = len({i for i, _ in funn.henvisninger["a"]})
|
||||
i_vedlegg = len({i for i, _ in funn.henvisninger["b"] + funn.henvisninger["c"]})
|
||||
alle_omraader = len({omraade(i) for i in funn.bank})
|
||||
try:
|
||||
tekst = lag(poster, i_tekst, i_vedlegg, alle_omraader)
|
||||
except ReferanseError as e:
|
||||
sys.stderr.write(f"lag_referanser: {e}\n")
|
||||
return 1
|
||||
GENERERT.mkdir(exist_ok=True)
|
||||
UT.write_text(tekst, encoding="utf-8", newline="\n")
|
||||
sys.stdout.write(f"lag_referanser: skrev {UT.relative_to(ROT)} ({len(poster)} poster)\n")
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main(sys.argv[1:]))
|
||||
503
rapport/lag_vedlegg_endringer.py
Normal file
503
rapport/lag_vedlegg_endringer.py
Normal file
|
|
@ -0,0 +1,503 @@
|
|||
# ruff: noqa: INP001
|
||||
r"""Write appendix C of the report: the list «Endringer» of the pre-registration, word for word.
|
||||
|
||||
Reads ``FORHANDSREGISTRERING.md`` from the heading ``## Endringer`` to the end of the file and
|
||||
writes ``rapport/generert/vedlegg-endringer.tex``: a lead-in line (the number of dated entries and
|
||||
the SHA-256 of the file it was read from) and the list itself in ``\small``. Only the layout
|
||||
changes: the date of an entry is set in bold, inline code in ``\texttt`` with break points,
|
||||
``**bold**`` in ``\textbf`` and ``*italic*`` in ``\emph``. The words, numbers and punctuation are
|
||||
those of the source, in the same order.
|
||||
|
||||
The converter knows exactly the Markdown the section uses, read by its indentation:
|
||||
|
||||
* an entry: ``- YYYY-MM-DD: text`` at the margin, continued on lines indented by two spaces;
|
||||
* a numbered point inside an entry: `` N. text`` (indented by two), continued on lines indented
|
||||
to the text of the point; the numbers of one list run on without a gap;
|
||||
* a new paragraph of the entry: a line indented by two after a numbered list or after a blank
|
||||
line;
|
||||
* inline: code spans, ``**bold**`` and ``*italic*`` (properly nested, closed in the paragraph),
|
||||
the backslash escape of CommonMark, and a fixed table of characters.
|
||||
|
||||
Anything else stops the script with the line number, and nothing is written: another heading,
|
||||
a block quote, a table row, a code fence, a bullet inside an entry, a numbered point inside a
|
||||
point, a blank line inside a point, trailing whitespace, a tab, a link or HTML (``[``, ``]``,
|
||||
``<``), an underscore or tilde that could be emphasis or strike-through, and every character
|
||||
not in the table.
|
||||
|
||||
Standard library only. The output depends only on the input file: same input, same bytes.
|
||||
|
||||
Run from anywhere: ``python3 rapport/lag_vedlegg_endringer.py``.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import re
|
||||
import sys
|
||||
from dataclasses import dataclass, field
|
||||
from pathlib import Path
|
||||
|
||||
ROT = Path(__file__).resolve().parent.parent
|
||||
KILDE = ROT / "FORHANDSREGISTRERING.md"
|
||||
UT = ROT / "rapport" / "generert" / "vedlegg-endringer.tex"
|
||||
|
||||
OVERSKRIFT = "## Endringer"
|
||||
INNRYKK = 2
|
||||
OPPDELING = 8 # a long hex string (a checksum, a commit) can break after every eighth character
|
||||
|
||||
ENTRY = re.compile(r"^- (\d{4}-\d{2}-\d{2}): (\S.*)$")
|
||||
PUNKT = re.compile(r"^ (\d+)\. (\S.*)$")
|
||||
LISTEMERKE = re.compile(r"^(?:[-*+] |\d+[.)] )")
|
||||
BLOKKMERKE = re.compile(r"^(?:#|>|\||```|~~~)")
|
||||
HEKS = re.compile(r"[0-9a-f]{16,}")
|
||||
|
||||
# ASCII punctuation that is typeset as it stands. A character that forms a ligature with the next
|
||||
# one under T1 (-- , ,, '' !` ?`) gets an empty group after it when such a pair occurs.
|
||||
VANLIG = frozenset(".,;:()/-+='!?@")
|
||||
LIGATUR = {"-": "-", ",": ",", "'": "'", "!": "`", "?": "`"}
|
||||
|
||||
# ASCII characters that are special to LaTeX and have a plain meaning in the Markdown read here.
|
||||
SPESIELL = {
|
||||
"%": r"\%",
|
||||
"&": r"\&",
|
||||
"#": r"\#",
|
||||
"$": r"\$",
|
||||
"{": r"\{",
|
||||
"}": r"\}",
|
||||
"^": r"\textasciicircum{}",
|
||||
"|": r"\textbar{}",
|
||||
">": r"\textgreater{}",
|
||||
'"': r"\textquotedbl{}",
|
||||
}
|
||||
|
||||
# Characters that inputenc (utf8) and T1 set directly, by code point so that the table is ASCII.
|
||||
DIREKTE = frozenset(
|
||||
{
|
||||
0x00E6, # latin small letter ae
|
||||
0x00F8, # latin small letter o with stroke
|
||||
0x00E5, # latin small letter a with ring above
|
||||
0x00C6, # latin capital letter ae
|
||||
0x00D8, # latin capital letter o with stroke
|
||||
0x00C5, # latin capital letter a with ring above
|
||||
0x00E9, # latin small letter e with acute
|
||||
0x00E8, # latin small letter e with grave
|
||||
0x00EA, # latin small letter e with circumflex
|
||||
0x00E4, # latin small letter a with diaeresis
|
||||
0x00F6, # latin small letter o with diaeresis
|
||||
0x00FC, # latin small letter u with diaeresis
|
||||
0x00C4, # latin capital letter a with diaeresis
|
||||
0x00D6, # latin capital letter o with diaeresis
|
||||
0x00DC, # latin capital letter u with diaeresis
|
||||
0x00AB, # left-pointing double angle quotation mark (T1 has the glyph)
|
||||
0x00BB, # right-pointing double angle quotation mark
|
||||
}
|
||||
)
|
||||
|
||||
# Every other non-ASCII character the converter accepts, by code point, and how it is set under
|
||||
# pdflatex with inputenc utf8 and T1.
|
||||
UNICODE = {
|
||||
# Punctuation and symbols.
|
||||
0x2013: r"\textendash{}", # en dash
|
||||
0x2014: r"\textemdash{}", # em dash
|
||||
0x2026: r"\textellipsis{}", # horizontal ellipsis
|
||||
0x201C: r"\textquotedblleft{}", # left double quotation mark
|
||||
0x201D: r"\textquotedblright{}", # right double quotation mark
|
||||
0x2018: r"\textquoteleft{}", # left single quotation mark
|
||||
0x2019: r"\textquoteright{}", # right single quotation mark
|
||||
0x201E: r"\quotedblbase{}", # double low-9 quotation mark
|
||||
0x00A0: "~", # no-break space
|
||||
0x00B7: r"\textperiodcentered{}", # middle dot
|
||||
0x00D7: r"\texttimes{}", # multiplication sign
|
||||
0x2212: r"\textminus{}", # minus sign
|
||||
0x2032: r"\ensuremath{{}^{\prime}}", # prime
|
||||
0x2192: r"\textrightarrow{}", # rightwards arrow
|
||||
0x2265: r"\ensuremath{\geq}", # greater-than or equal to
|
||||
0x2264: r"\ensuremath{\leq}", # less-than or equal to
|
||||
0x2248: r"\ensuremath{\approx}", # almost equal to
|
||||
0x00B1: r"\textpm{}", # plus-minus sign
|
||||
0x00B0: r"\textdegree{}", # degree sign
|
||||
0x00BD: r"\textonehalf{}", # vulgar fraction one half
|
||||
0x00BC: r"\textonequarter{}", # vulgar fraction one quarter
|
||||
0x00B9: r"\textonesuperior{}", # superscript one
|
||||
0x00B2: r"\texttwosuperior{}", # superscript two
|
||||
0x00B3: r"\textthreesuperior{}", # superscript three
|
||||
0x00A7: r"\S{}", # section sign
|
||||
0x20AC: r"\texteuro{}", # euro sign
|
||||
# Greek letters as they stand in the specification.
|
||||
0x03B1: r"\ensuremath{\alpha}", # greek small letter alpha
|
||||
0x03B2: r"\ensuremath{\beta}", # greek small letter beta
|
||||
0x03B3: r"\ensuremath{\gamma}", # greek small letter gamma
|
||||
0x03B4: r"\ensuremath{\delta}", # greek small letter delta
|
||||
0x03B5: r"\ensuremath{\varepsilon}", # greek small letter epsilon
|
||||
0x03B7: r"\ensuremath{\eta}", # greek small letter eta
|
||||
0x03B8: r"\ensuremath{\theta}", # greek small letter theta
|
||||
0x03BA: r"\ensuremath{\kappa}", # greek small letter kappa
|
||||
0x03BB: r"\ensuremath{\lambda}", # greek small letter lamda
|
||||
0x03BC: r"\ensuremath{\mu}", # greek small letter mu
|
||||
0x03C0: r"\ensuremath{\pi}", # greek small letter pi
|
||||
0x03C1: r"\ensuremath{\rho}", # greek small letter rho
|
||||
0x03C3: r"\ensuremath{\sigma}", # greek small letter sigma
|
||||
0x03C4: r"\ensuremath{\tau}", # greek small letter tau
|
||||
0x03C6: r"\ensuremath{\varphi}", # greek small letter phi
|
||||
0x03C7: r"\ensuremath{\chi}", # greek small letter chi
|
||||
0x03C8: r"\ensuremath{\psi}", # greek small letter psi
|
||||
0x03C9: r"\ensuremath{\omega}", # greek small letter omega
|
||||
0x0394: r"\ensuremath{\Delta}", # greek capital letter delta
|
||||
0x03A3: r"\ensuremath{\Sigma}", # greek capital letter sigma
|
||||
0x03A9: r"\ensuremath{\Omega}", # greek capital letter omega
|
||||
}
|
||||
|
||||
# Characters that may follow a backslash as a CommonMark escape.
|
||||
ASCII_TEGN = frozenset("!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~")
|
||||
|
||||
# Characters that mean something in Markdown, set as themselves (after a backslash, in code).
|
||||
BOKSTAVELIG = {
|
||||
"\\": r"\textbackslash{}",
|
||||
"~": r"\textasciitilde{}",
|
||||
"_": r"\_",
|
||||
"<": r"\textless{}",
|
||||
"[": "[",
|
||||
"]": "]",
|
||||
"*": "*",
|
||||
"`": r"\textasciigrave{}",
|
||||
}
|
||||
|
||||
# Characters after which a code span may break.
|
||||
KODEBRUDD = {
|
||||
"/": r"/\allowbreak{}",
|
||||
".": r".\allowbreak{}",
|
||||
"-": r"-{}\allowbreak{}",
|
||||
"_": r"\_\allowbreak{}",
|
||||
}
|
||||
|
||||
|
||||
class EndringerError(Exception):
|
||||
"""The input does not have the expected form."""
|
||||
|
||||
|
||||
@dataclass
|
||||
class Avsnitt:
|
||||
"""A paragraph of an entry: its source lines without indentation, and the first line number."""
|
||||
|
||||
linjer: list[str]
|
||||
nr: int
|
||||
|
||||
|
||||
@dataclass
|
||||
class Punkt:
|
||||
"""A numbered point: its number, source lines without indentation, first line number."""
|
||||
|
||||
nummer: int
|
||||
linjer: list[str]
|
||||
nr: int
|
||||
|
||||
|
||||
@dataclass
|
||||
class Liste:
|
||||
"""A numbered list inside an entry."""
|
||||
|
||||
punkter: list[Punkt] = field(default_factory=list)
|
||||
|
||||
|
||||
@dataclass
|
||||
class Oppforing:
|
||||
"""A dated entry: the date and its blocks in order."""
|
||||
|
||||
dato: str
|
||||
blokker: list[Avsnitt | Liste]
|
||||
|
||||
|
||||
def feil(nr: int, hva: str, linje: str) -> EndringerError:
|
||||
"""An error that names the line of the pre-registration it stands on."""
|
||||
return EndringerError(f"FORHANDSREGISTRERING.md:{nr}: {hva}: {linje!r}")
|
||||
|
||||
|
||||
def sjekk_innhold(innhold: str, nr: int, linje: str) -> None:
|
||||
"""Stop on a block construct the converter does not know, at the start of a line's text."""
|
||||
if BLOKKMERKE.match(innhold):
|
||||
msg = "heading, block quote, table row or code fence"
|
||||
raise feil(nr, msg, linje)
|
||||
if LISTEMERKE.match(innhold):
|
||||
msg = "list marker where only text is expected"
|
||||
raise feil(nr, msg, linje)
|
||||
|
||||
|
||||
def les_seksjon(tekst: str) -> tuple[list[tuple[int, str]], int]:
|
||||
"""Return the lines after the heading with their numbers, and the heading's line number."""
|
||||
linjer = tekst.split("\n")
|
||||
treff = [i for i, linje in enumerate(linjer) if linje == OVERSKRIFT]
|
||||
if len(treff) != 1:
|
||||
msg = f"the heading {OVERSKRIFT!r} stands {len(treff)} times, not once"
|
||||
raise EndringerError(msg)
|
||||
start = treff[0]
|
||||
resten = linjer[start + 1 :]
|
||||
if resten and resten[-1] == "":
|
||||
resten = resten[:-1] # the newline that ends the file
|
||||
else:
|
||||
msg = "the file does not end with a newline"
|
||||
raise EndringerError(msg)
|
||||
return [(start + 2 + i, linje) for i, linje in enumerate(resten)], start + 1
|
||||
|
||||
|
||||
def les_oppforinger(linjer: list[tuple[int, str]]) -> list[Oppforing]: # noqa: C901, PLR0912, PLR0915
|
||||
"""Read the entries by the indentation of their lines."""
|
||||
oppforinger: list[Oppforing] = []
|
||||
tom_foran = True # a blank line (or the heading) stands before this line
|
||||
for nr, linje in linjer:
|
||||
if "\t" in linje or "\r" in linje:
|
||||
raise feil(nr, "tab or carriage return", linje)
|
||||
if linje != linje.rstrip(" "):
|
||||
raise feil(nr, "trailing whitespace (a hard line break in Markdown)", linje)
|
||||
if not linje:
|
||||
if not oppforinger and not tom_foran:
|
||||
raise feil(nr, "blank line before the first entry", linje)
|
||||
tom_foran = True
|
||||
continue
|
||||
if linje.startswith("- "):
|
||||
m = ENTRY.match(linje)
|
||||
if not m:
|
||||
raise feil(nr, "an entry does not start with a date and a colon", linje)
|
||||
sjekk_innhold(m.group(2), nr, linje)
|
||||
oppforinger.append(Oppforing(m.group(1), [Avsnitt([m.group(2)], nr)]))
|
||||
tom_foran = False
|
||||
continue
|
||||
if not oppforinger:
|
||||
raise feil(nr, "text before the first entry", linje)
|
||||
blokker = oppforinger[-1].blokker
|
||||
siste = blokker[-1]
|
||||
m = PUNKT.match(linje)
|
||||
if m:
|
||||
nummer = int(m.group(1))
|
||||
sjekk_innhold(m.group(2), nr, linje)
|
||||
punkt = Punkt(nummer, [m.group(2)], nr)
|
||||
if isinstance(siste, Liste):
|
||||
if tom_foran:
|
||||
raise feil(nr, "blank line inside a numbered list", linje)
|
||||
if nummer != siste.punkter[-1].nummer + 1:
|
||||
raise feil(nr, "the numbers of a list do not run on", linje)
|
||||
siste.punkter.append(punkt)
|
||||
else:
|
||||
blokker.append(Liste([punkt]))
|
||||
tom_foran = False
|
||||
continue
|
||||
innrykk = len(linje) - len(linje.lstrip(" "))
|
||||
innhold = linje[innrykk:]
|
||||
sjekk_innhold(innhold, nr, linje)
|
||||
if innrykk == INNRYKK:
|
||||
if isinstance(siste, Avsnitt) and not tom_foran:
|
||||
siste.linjer.append(innhold)
|
||||
else:
|
||||
blokker.append(Avsnitt([innhold], nr))
|
||||
elif isinstance(siste, Liste) and not tom_foran:
|
||||
punkt = siste.punkter[-1]
|
||||
if innrykk != INNRYKK + len(f"{punkt.nummer}. "):
|
||||
raise feil(nr, "indentation that continues neither the entry nor the point", linje)
|
||||
punkt.linjer.append(innhold)
|
||||
else:
|
||||
raise feil(nr, "indentation the converter does not know", linje)
|
||||
tom_foran = False
|
||||
if not oppforinger:
|
||||
msg = "the section has no entries"
|
||||
raise EndringerError(msg)
|
||||
return oppforinger
|
||||
|
||||
|
||||
def ukjent(nr: int, hva: str) -> EndringerError:
|
||||
"""An error in a paragraph that starts on line ``nr`` of the pre-registration."""
|
||||
return EndringerError(f"FORHANDSREGISTRERING.md:{nr}: {hva}")
|
||||
|
||||
|
||||
def tegn(c: str, neste: str, nr: int) -> str:
|
||||
"""One character of running text in LaTeX (not one of the Markdown characters)."""
|
||||
if c.isascii() and (c.isalnum() or c in " \n"):
|
||||
return c
|
||||
if c in VANLIG:
|
||||
return c + "{}" if LIGATUR.get(c) == neste else c
|
||||
if c in SPESIELL:
|
||||
return SPESIELL[c]
|
||||
if ord(c) in DIREKTE:
|
||||
return c
|
||||
if ord(c) in UNICODE:
|
||||
return UNICODE[ord(c)]
|
||||
msg = f"a character the converter does not know: {c!r} (U+{ord(c):04X})"
|
||||
raise ukjent(nr, msg)
|
||||
|
||||
|
||||
def bokstavelig(c: str, nr: int) -> str:
|
||||
"""A character that means something in Markdown, set as the character itself."""
|
||||
if c in BOKSTAVELIG:
|
||||
return BOKSTAVELIG[c]
|
||||
return tegn(c, "", nr)
|
||||
|
||||
|
||||
def kode(innhold: str, nr: int) -> str:
|
||||
r"""A code span in \texttt, with break points after / . _ - and inside long hex strings."""
|
||||
if not innhold or innhold != innhold.strip(" ") or "\n" in innhold:
|
||||
msg = "a code span that is empty, padded or broken over lines"
|
||||
raise ukjent(nr, msg)
|
||||
ut: list[str] = []
|
||||
pos = 0
|
||||
for m in HEKS.finditer(innhold):
|
||||
ut.extend(kodetegn(c, nr) for c in innhold[pos : m.start()])
|
||||
heks = m.group(0)
|
||||
ut.append(
|
||||
r"\allowbreak{}".join(heks[k : k + OPPDELING] for k in range(0, len(heks), OPPDELING))
|
||||
)
|
||||
pos = m.end()
|
||||
ut.extend(kodetegn(c, nr) for c in innhold[pos:])
|
||||
return r"\texttt{" + "".join(ut) + "}"
|
||||
|
||||
|
||||
def kodetegn(c: str, nr: int) -> str:
|
||||
"""One character of a code span."""
|
||||
if c.isascii() and c.isalnum():
|
||||
return c
|
||||
if c in KODEBRUDD:
|
||||
return KODEBRUDD[c]
|
||||
return bokstavelig(c, nr)
|
||||
|
||||
|
||||
def kodespenn(tekst: str, i: int, nr: int) -> tuple[str, int]:
|
||||
"""The code span that opens at ``i``, and the position after it."""
|
||||
slutt = tekst.find("`", i + 1)
|
||||
if slutt < 0 or tekst.startswith("``", i):
|
||||
msg = "an unclosed or double code span"
|
||||
raise ukjent(nr, msg)
|
||||
return kode(tekst[i + 1 : slutt], nr), slutt + 1
|
||||
|
||||
|
||||
def stjerne(tekst: str, i: int, apne: list[str], nr: int) -> tuple[str, int]:
|
||||
"""Open or close the emphasis at ``i``; return its LaTeX and the position after the marker."""
|
||||
if tekst.startswith("***", i):
|
||||
msg = "three asterisks in a row"
|
||||
raise ukjent(nr, msg)
|
||||
merke = "**" if tekst.startswith("**", i) else "*"
|
||||
foran = tekst[i - 1] if i > 0 else " "
|
||||
etter = tekst[i + len(merke)] if i + len(merke) < len(tekst) else " "
|
||||
if apne and apne[-1] == merke and not foran.isspace():
|
||||
apne.pop()
|
||||
return "}", i + len(merke)
|
||||
if merke not in apne and not etter.isspace():
|
||||
apne.append(merke)
|
||||
return (r"\textbf{" if merke == "**" else r"\emph{"), i + len(merke)
|
||||
msg = "an asterisk that neither opens nor closes emphasis"
|
||||
raise ukjent(nr, msg)
|
||||
|
||||
|
||||
def vanlig(tekst: str, i: int, nr: int) -> str:
|
||||
"""One character of running text that is not a code span, an asterisk or a backslash."""
|
||||
c = tekst[i]
|
||||
neste = tekst[i + 1] if i + 1 < len(tekst) else ""
|
||||
if c == "_":
|
||||
if not (i > 0 and tekst[i - 1].isalnum() and neste.isalnum()):
|
||||
msg = "an underscore that could be emphasis"
|
||||
raise ukjent(nr, msg)
|
||||
return r"\_"
|
||||
if c == "~":
|
||||
if neste == "~" or (i > 0 and tekst[i - 1] == "~"):
|
||||
msg = "a double tilde (strike-through)"
|
||||
raise ukjent(nr, msg)
|
||||
return r"\textasciitilde{}"
|
||||
if c in "<[]":
|
||||
msg = f"a link or HTML ({c!r})"
|
||||
raise ukjent(nr, msg)
|
||||
if c == " " and neste == "%":
|
||||
return "~" # no line break between a number and its per cent sign
|
||||
return tegn(c, neste, nr)
|
||||
|
||||
|
||||
def inline(tekst: str, nr: int) -> str:
|
||||
"""Convert the inline Markdown of one paragraph (lines joined by newlines) to LaTeX."""
|
||||
ut: list[str] = []
|
||||
apne: list[str] = []
|
||||
i = 0
|
||||
while i < len(tekst):
|
||||
c = tekst[i]
|
||||
if c == "`":
|
||||
bit, i = kodespenn(tekst, i, nr)
|
||||
elif c == "*":
|
||||
bit, i = stjerne(tekst, i, apne, nr)
|
||||
elif c == "\\":
|
||||
neste = tekst[i + 1] if i + 1 < len(tekst) else ""
|
||||
if neste not in ASCII_TEGN:
|
||||
msg = "a backslash that is not a Markdown escape"
|
||||
raise ukjent(nr, msg)
|
||||
bit, i = bokstavelig(neste, nr), i + 2
|
||||
else:
|
||||
bit, i = vanlig(tekst, i, nr), i + 1
|
||||
ut.append(bit)
|
||||
if apne:
|
||||
msg = f"emphasis not closed in the paragraph: {apne}"
|
||||
raise ukjent(nr, msg)
|
||||
return "".join(ut)
|
||||
|
||||
|
||||
def lag_liste(liste: Liste) -> list[str]:
|
||||
"""The LaTeX of a numbered list inside an entry."""
|
||||
forste = liste.punkter[0].nummer
|
||||
storste = liste.punkter[-1].nummer
|
||||
ut = [
|
||||
(
|
||||
rf"\begin{{enumerate}}[label=\arabic*.,start={forste},widest={storste},leftmargin=*,"
|
||||
r"topsep=0.3ex,itemsep=0.15ex,parsep=0pt]"
|
||||
)
|
||||
]
|
||||
ut += [r"\item " + inline("\n".join(p.linjer), p.nr) for p in liste.punkter]
|
||||
ut.append(r"\end{enumerate}")
|
||||
return ut
|
||||
|
||||
|
||||
def lag(tekst: str, sjekksum: str) -> tuple[str, int]:
|
||||
"""Return the LaTeX of the appendix and the number of dated entries."""
|
||||
linjer, _ = les_seksjon(tekst)
|
||||
oppforinger = les_oppforinger(linjer)
|
||||
antall = len(oppforinger)
|
||||
sum_tex = kode(sjekksum, 0)
|
||||
innledning = (
|
||||
r"\noindent Lista under gjengir avsnittet «Endringer» i \fil{FORHANDSREGISTRERING.md}"
|
||||
rf" ordrett og i sin helhet: {antall} daterte punkter, i den rekkefølgen de står der."
|
||||
r" Bare oppsettet er endret: datoen i hvert punkt står med fet skrift, og filnavn og"
|
||||
r" sjekksummer med skrivemaskinskrift. Lista er laget av"
|
||||
r" \fil{rapport/lag_vedlegg_endringer.py} fra fila med SHA-256 " + sum_tex + "."
|
||||
)
|
||||
ut = [
|
||||
"% Laget av rapport/lag_vedlegg_endringer.py fra FORHANDSREGISTRERING.md.",
|
||||
"% Rettes ikke for hånd: kjør skriptet på nytt.",
|
||||
innledning,
|
||||
"",
|
||||
r"{\small",
|
||||
(
|
||||
r"\begin{itemize}[leftmargin=1.1em,label=\textbullet,topsep=1ex,itemsep=0.7ex,"
|
||||
r"parsep=0.5ex,listparindent=0pt]"
|
||||
),
|
||||
]
|
||||
for opp in oppforinger:
|
||||
for i, blokk in enumerate(opp.blokker):
|
||||
if isinstance(blokk, Liste):
|
||||
ut += lag_liste(blokk)
|
||||
continue
|
||||
avsnitt = inline("\n".join(blokk.linjer), blokk.nr)
|
||||
if i == 0:
|
||||
ut.append(rf"\item \textbf{{{opp.dato}:}} " + avsnitt)
|
||||
else:
|
||||
ut += ["", avsnitt]
|
||||
ut += [r"\end{itemize}", "}", ""]
|
||||
return "\n".join(ut), antall
|
||||
|
||||
|
||||
def main() -> int:
|
||||
"""Write the appendix; return 0, or 1 with a message on error."""
|
||||
try:
|
||||
data = KILDE.read_bytes()
|
||||
tekst, antall = lag(data.decode("utf-8"), hashlib.sha256(data).hexdigest())
|
||||
UT.parent.mkdir(exist_ok=True)
|
||||
except (EndringerError, OSError, UnicodeDecodeError) as e:
|
||||
sys.stderr.write(f"lag_vedlegg_endringer: {e}\n")
|
||||
return 1
|
||||
UT.write_text(tekst, encoding="utf-8", newline="\n")
|
||||
sys.stdout.write(f"lag_vedlegg_endringer: skrev {UT.relative_to(ROT)} ({antall} punkter)\n")
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
711
rapport/lag_vedlegg_parametere.py
Normal file
711
rapport/lag_vedlegg_parametere.py
Normal file
|
|
@ -0,0 +1,711 @@
|
|||
# ruff: noqa: INP001
|
||||
r"""Write appendix B of the report: the frozen parameters.
|
||||
|
||||
Reads ``modell/parametere.json`` and writes ``rapport/generert/vedlegg-parametere.tex``: a
|
||||
short lead-in (the version, the number of parameters per status, the SHA-256 of the file), one
|
||||
table row per parameter in the file's order, and the frozen sensitivity list verbatim.
|
||||
|
||||
A parameter row holds the symbol and the id, the name with the unit and where it is used, the
|
||||
distribution with every number it has in the file, the status and the source-bank entries as
|
||||
``\kilde{...}``. A line under the row, across the table, holds the source value, the remark and
|
||||
a fixed value that is a table, when the file has them.
|
||||
|
||||
Numbers follow one rule (``tall``): the shortest decimal string that gives back the same value
|
||||
(Python's ``repr``), without a trailing ``.0``; a decimal comma; a thin space between groups of
|
||||
three digits when the integer part has five digits or more; a minus sign for negative values;
|
||||
and a power of ten when the shortest string has an exponent. No digit is dropped.
|
||||
|
||||
Free text goes through ``tekst``: every character LaTeX treats specially is escaped, and every
|
||||
non-ASCII character must be one of those listed in ``TEGN``. A symbol is set in math mode when
|
||||
it uses only the commands in ``KOMMANDOER`` and plain letters, digits and signs. Anything else
|
||||
stops the script.
|
||||
|
||||
Standard library only. The output depends only on the parameter file and the pre-registration:
|
||||
same input, same bytes. The script stops with an error, and writes nothing, when the file does
|
||||
not have the expected form, when a character or a symbol cannot be rendered, or when the
|
||||
checksum of the file is not the last one stated under «Parameterfrys» in the pre-registration.
|
||||
|
||||
Run from anywhere: ``python3 rapport/lag_vedlegg_parametere.py``.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import json
|
||||
import math
|
||||
import re
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
ROT = Path(__file__).resolve().parent.parent
|
||||
PARAMETERE = ROT / "modell" / "parametere.json"
|
||||
FORHAANDSREG = ROT / "FORHANDSREGISTRERING.md"
|
||||
UT = ROT / "rapport" / "generert" / "vedlegg-parametere.tex"
|
||||
|
||||
ANTALL = 137
|
||||
ANTALL_FOELSOMHETER = 37
|
||||
MAKS_DYBDE = 2
|
||||
FELT = (
|
||||
"id",
|
||||
"symbol",
|
||||
"navn",
|
||||
"enhet",
|
||||
"fordeling",
|
||||
"poster",
|
||||
"status",
|
||||
"ligninger",
|
||||
"kildeverdi",
|
||||
"merknad",
|
||||
)
|
||||
TEKSTFELT = ("id", "symbol", "navn", "enhet", "status", "ligninger", "kildeverdi", "merknad")
|
||||
FORDELINGSFELT = {
|
||||
"fast": ("type", "verdi"),
|
||||
"jevn": ("type", "lav", "hoy"),
|
||||
"logjevn": ("type", "lav", "hoy"),
|
||||
"pert": ("type", "lav", "modus", "hoy", "form"),
|
||||
"lognormal": ("type", "median", "sigma", "min", "maks", "avkorting"),
|
||||
"diskret": ("type", "verdier", "vekter"),
|
||||
}
|
||||
SAMMENSATT = "sammensatt"
|
||||
INGEN = "\u2013" # the file's en dash for "no symbol" and "no unit"
|
||||
|
||||
ID = re.compile(r"^[A-Za-z][A-Za-z0-9_]*$")
|
||||
POST = re.compile(r"^K\d{2}-(?:\d{3}|K\d{2}|Ka\d{2})$")
|
||||
SJEKKSUM = re.compile(r"SHA-256: `([0-9a-f]{64})`")
|
||||
|
||||
# Characters LaTeX treats specially, written so that they print as themselves.
|
||||
SPESIELLE = {
|
||||
"\\": r"\textbackslash{}",
|
||||
"{": r"\{",
|
||||
"}": r"\}",
|
||||
"$": r"\$",
|
||||
"&": r"\&",
|
||||
"#": r"\#",
|
||||
"%": r"\%",
|
||||
"_": r"\_",
|
||||
"^": r"\textasciicircum{}",
|
||||
"~": r"\textasciitilde{}",
|
||||
"<": r"\textless{}",
|
||||
">": r"\textgreater{}",
|
||||
"|": r"\textbar{}",
|
||||
'"': r"\textquotedbl{}", # an active shorthand under babel norsk
|
||||
"`": r"\textasciigrave{}",
|
||||
}
|
||||
# Every non-ASCII character the text may hold, and how it is written for pdflatex with
|
||||
# inputenc utf8 and T1. Letters and guillemets are left to inputenc; the rest are named.
|
||||
TEGN = {
|
||||
"\u00e6": "\u00e6", # ae
|
||||
"\u00f8": "\u00f8", # o with stroke
|
||||
"\u00e5": "\u00e5", # a with ring
|
||||
"\u00c6": "\u00c6", # AE
|
||||
"\u00d8": "\u00d8", # O with stroke
|
||||
"\u00c5": "\u00c5", # A with ring
|
||||
"\u00e9": "\u00e9", # e with acute
|
||||
"\u00ab": "\u00ab", # left guillemet
|
||||
"\u00bb": "\u00bb", # right guillemet
|
||||
"\u00b0": r"\textdegree{}",
|
||||
"\u00b2": r"\textsuperscript{2}",
|
||||
"\u00b3": r"\textsuperscript{3}",
|
||||
"\u00b7": r"\textperiodcentered{}",
|
||||
"\u00d7": r"\texttimes{}",
|
||||
"\u2013": r"\textendash{}",
|
||||
"\u2212": r"\textminus{}",
|
||||
"\u2192": r"\textrightarrow{}",
|
||||
"\u2264": r"\ensuremath{\leq}",
|
||||
"\u2265": r"\ensuremath{\geq}",
|
||||
}
|
||||
# Letters allowed inside \text{...} of a symbol, besides ASCII letters, digits, comma and space.
|
||||
TEKST_I_SYMBOL = frozenset("\u00e6\u00f8\u00e5\u00c6\u00d8\u00c5")
|
||||
KOMMANDOER = frozenset(
|
||||
{
|
||||
"alpha",
|
||||
"bar",
|
||||
"beta",
|
||||
"chi",
|
||||
"Delta",
|
||||
"delta",
|
||||
"ell",
|
||||
"epsilon",
|
||||
"eta",
|
||||
"Gamma",
|
||||
"gamma",
|
||||
"iota",
|
||||
"kappa",
|
||||
"lambda",
|
||||
"mathcal",
|
||||
"mathit",
|
||||
"min",
|
||||
"mu",
|
||||
"nu",
|
||||
"omega",
|
||||
"phi",
|
||||
"pi",
|
||||
"psi",
|
||||
"rho",
|
||||
"sigma",
|
||||
"tau",
|
||||
"theta",
|
||||
"varepsilon",
|
||||
"varphi",
|
||||
"xi",
|
||||
}
|
||||
)
|
||||
SYMBOLTEGN = frozenset("_^{}(),*- ")
|
||||
TEKSTGRUPPE = re.compile(r"\\text\{([^{}\\]*)\}")
|
||||
KOMMANDO = re.compile(r"\\([A-Za-z]+)")
|
||||
|
||||
STRIPE = r"\textendash{}"
|
||||
HODE = r"Symbol og id & Størrelse & Fordeling & Status & Poster \\"
|
||||
SYMBOLBREDDE = "19mm"
|
||||
KOLONNER = rf"@{{}}P{{{SYMBOLBREDDE}}}LP{{36mm}}P{{17mm}}P{{17mm}}@{{}}"
|
||||
UNDERLINJE = (
|
||||
rf"\multicolumn{{4}}{{>{{\raggedright\arraybackslash}}"
|
||||
rf"p{{\dimexpr\linewidth-{SYMBOLBREDDE}-2\tabcolsep\relax}}@{{}}}}"
|
||||
)
|
||||
|
||||
|
||||
class ParameterError(Exception):
|
||||
"""The input does not have the expected form, or something in it cannot be rendered."""
|
||||
|
||||
|
||||
def tekst(s: str) -> str:
|
||||
"""Free text from the file as LaTeX: special characters escaped, non-ASCII from TEGN."""
|
||||
ut: list[str] = []
|
||||
forrige = ""
|
||||
for c in s:
|
||||
if c in SPESIELLE:
|
||||
ut.append(SPESIELLE[c])
|
||||
elif c in TEGN:
|
||||
ut.append(TEGN[c])
|
||||
elif " " <= c <= "~":
|
||||
# Break the T1 ligatures "--" (dash) and ",," (low quotes) by an empty group.
|
||||
if c == forrige and c in "-,":
|
||||
ut.append("{}")
|
||||
ut.append(c)
|
||||
else:
|
||||
msg = f"character {c!r} (U+{ord(c):04X}) has no rendering in TEGN: {s!r}"
|
||||
raise ParameterError(msg)
|
||||
forrige = c
|
||||
return "".join(ut)
|
||||
|
||||
|
||||
def _grupper(siffer: str) -> str:
|
||||
r"""Digits with \, between groups of three when there are five digits or more."""
|
||||
if len(siffer) < 5: # noqa: PLR2004 - four-digit numbers are not grouped in Norwegian
|
||||
return siffer
|
||||
hode = len(siffer) % 3 or 3
|
||||
grupper = [siffer[:hode]] + [siffer[i : i + 3] for i in range(hode, len(siffer), 3)]
|
||||
return r"\,".join(grupper)
|
||||
|
||||
|
||||
def _desimal(s: str) -> str:
|
||||
"""A decimal string without exponent (as repr writes it) in the Norwegian form."""
|
||||
minus = s.startswith("-")
|
||||
s = s.removeprefix("-")
|
||||
heltall, _, brok = s.partition(".")
|
||||
if not heltall.isdigit() or (brok and not brok.isdigit()):
|
||||
msg = f"not a decimal number: {s!r}"
|
||||
raise ParameterError(msg)
|
||||
if brok == "0":
|
||||
brok = ""
|
||||
ut = _grupper(heltall) + ("," + brok if brok else "")
|
||||
return (r"\textminus{}" if minus else "") + ut
|
||||
|
||||
|
||||
def tall(x: float) -> str:
|
||||
"""A number from the file, with every digit it has there (see the module docstring)."""
|
||||
if isinstance(x, bool):
|
||||
msg = f"a truth value where a number is expected: {x!r}"
|
||||
raise ParameterError(msg)
|
||||
if isinstance(x, int):
|
||||
return _desimal(str(x))
|
||||
if not math.isfinite(x):
|
||||
msg = f"not a finite number: {x!r}"
|
||||
raise ParameterError(msg)
|
||||
r = repr(x)
|
||||
if "e" not in r:
|
||||
return _desimal(r)
|
||||
mantisse, _, eksponent = r.partition("e")
|
||||
e = int(eksponent)
|
||||
potens = (r"\textminus{}" if e < 0 else "") + str(abs(e))
|
||||
return _desimal(mantisse) + r"\,\textperiodcentered\,10\textsuperscript{" + potens + "}"
|
||||
|
||||
|
||||
def er_tall(x: object) -> bool:
|
||||
"""Whether x is a JSON number (not a truth value)."""
|
||||
return isinstance(x, (int, float)) and not isinstance(x, bool)
|
||||
|
||||
|
||||
def skalar(x: object) -> str:
|
||||
"""One value inside a fixed value: a number, a text, a truth value or null."""
|
||||
if x is None:
|
||||
return "ingen"
|
||||
if isinstance(x, bool):
|
||||
return "ja" if x else "nei"
|
||||
if isinstance(x, (int, float)):
|
||||
return tall(x)
|
||||
if isinstance(x, str):
|
||||
return tekst(x)
|
||||
msg = f"not a single value: {x!r}"
|
||||
raise ParameterError(msg)
|
||||
|
||||
|
||||
def er_skalar(x: object) -> bool:
|
||||
"""Whether x is a single value (not a list or an object)."""
|
||||
return x is None or isinstance(x, (bool, int, float, str))
|
||||
|
||||
|
||||
def nokkel(k: str) -> str:
|
||||
r"""A key of a fixed value, as it stands in the file, in \texttt."""
|
||||
return r"\texttt{" + tekst(k) + "}"
|
||||
|
||||
|
||||
def _liste(v: list[object]) -> str:
|
||||
if not v or not all(er_skalar(x) for x in v):
|
||||
msg = f"a list that is empty or not of single values: {v!r}"
|
||||
raise ParameterError(msg)
|
||||
return "; ".join(skalar(x) for x in v)
|
||||
|
||||
|
||||
def _indre(v: object) -> str:
|
||||
"""The second level of a table: a single value, a list, or an object of single values."""
|
||||
if er_skalar(v):
|
||||
return skalar(v)
|
||||
if isinstance(v, list):
|
||||
return _liste(v)
|
||||
if isinstance(v, dict):
|
||||
if not v or not all(er_skalar(x) for x in v.values()):
|
||||
msg = f"a table deeper than {MAKS_DYBDE} levels: {v!r}"
|
||||
raise ParameterError(msg)
|
||||
return "; ".join(f"{nokkel(k)} = {skalar(x)}" for k, x in v.items())
|
||||
msg = f"unexpected value: {v!r}"
|
||||
raise ParameterError(msg)
|
||||
|
||||
|
||||
def fast_verdi(v: object) -> tuple[str, list[str]]:
|
||||
"""The cell text for a fixed value, and the lines under the row when it is a table."""
|
||||
if er_tall(v):
|
||||
return "fast " + skalar(v), []
|
||||
if isinstance(v, list) and all(er_skalar(x) for x in v):
|
||||
return "fast " + _liste(v), []
|
||||
if isinstance(v, dict) and v and all(er_skalar(x) for x in v.values()):
|
||||
celle = "".join(rf"\newline {nokkel(k)}: {skalar(x)}" for k, x in v.items())
|
||||
return "fast" + celle, []
|
||||
if isinstance(v, list) and v:
|
||||
return "fast, tabell (verdiene står under)", [_indre(x) for x in v]
|
||||
if isinstance(v, dict) and v:
|
||||
linjer = [f"{nokkel(k)}: {_indre(x)}" for k, x in v.items()]
|
||||
return "fast, tabell (verdiene står under)", linjer
|
||||
msg = f"unexpected fixed value: {v!r}"
|
||||
raise ParameterError(msg)
|
||||
|
||||
|
||||
def _felt(f: dict[str, object], navn: str) -> float:
|
||||
x = f[navn]
|
||||
if not isinstance(x, (int, float)) or isinstance(x, bool):
|
||||
msg = f"field {navn!r} is not a number: {x!r}"
|
||||
raise ParameterError(msg)
|
||||
return x
|
||||
|
||||
|
||||
def _talliste(f: dict[str, object], navn: str) -> list[float]:
|
||||
x = f[navn]
|
||||
if not isinstance(x, list) or not x:
|
||||
msg = f"field {navn!r} is not a list of numbers: {x!r}"
|
||||
raise ParameterError(msg)
|
||||
ut: list[float] = []
|
||||
for v in x:
|
||||
if not isinstance(v, (int, float)) or isinstance(v, bool):
|
||||
msg = f"field {navn!r} is not a list of numbers: {x!r}"
|
||||
raise ParameterError(msg)
|
||||
ut.append(v)
|
||||
return ut
|
||||
|
||||
|
||||
def _jevn(f: dict[str, object], _pert_form: int) -> str:
|
||||
return f"jevn {tall(_felt(f, 'lav'))} {STRIPE} {tall(_felt(f, 'hoy'))}"
|
||||
|
||||
|
||||
def _logjevn(f: dict[str, object], _pert_form: int) -> str:
|
||||
return f"jevn i logaritmen {tall(_felt(f, 'lav'))} {STRIPE} {tall(_felt(f, 'hoy'))}"
|
||||
|
||||
|
||||
def _pert(f: dict[str, object], pert_form: int) -> str:
|
||||
"""PERT low / mode / high; the form only when it is not the file's common one."""
|
||||
punkter = " / ".join(tall(_felt(f, k)) for k in ("lav", "modus", "hoy"))
|
||||
form = _felt(f, "form")
|
||||
tillegg = "" if form == pert_form else f", form {tall(form)}"
|
||||
return f"PERT {punkter}{tillegg}"
|
||||
|
||||
|
||||
def _diskret(f: dict[str, object], _pert_form: int) -> str:
|
||||
verdier = _talliste(f, "verdier")
|
||||
vekter = _talliste(f, "vekter")
|
||||
if len(verdier) != len(vekter):
|
||||
msg = f"{len(verdier)} values but {len(vekter)} weights"
|
||||
raise ParameterError(msg)
|
||||
tekst_verdier = "; ".join(tall(v) for v in verdier)
|
||||
tekst_vekter = "; ".join(tall(v) for v in vekter)
|
||||
return f"diskret {tekst_verdier}" + r"\newline " + f"vekter {tekst_vekter}"
|
||||
|
||||
|
||||
def _lognormal(f: dict[str, object], _pert_form: int) -> str:
|
||||
avkorting = f["avkorting"]
|
||||
if not isinstance(avkorting, str):
|
||||
msg = f"the truncation of a lognormal distribution is not a text: {avkorting!r}"
|
||||
raise ParameterError(msg)
|
||||
return (
|
||||
f"lognormal, median {tall(_felt(f, 'median'))}, sigma {tall(_felt(f, 'sigma'))}, "
|
||||
f"minst {tall(_felt(f, 'min'))}, høyst {tall(_felt(f, 'maks'))}, "
|
||||
f"avkorting: {tekst(avkorting)}"
|
||||
)
|
||||
|
||||
|
||||
SKRIV = {
|
||||
"jevn": _jevn,
|
||||
"logjevn": _logjevn,
|
||||
"pert": _pert,
|
||||
"diskret": _diskret,
|
||||
"lognormal": _lognormal,
|
||||
}
|
||||
|
||||
|
||||
def _sammensatt(f: dict[str, object], pert_form: int) -> str:
|
||||
"""One line per part: the name of the part and its distribution (never a table)."""
|
||||
deler = [k for k in f if k != "type"]
|
||||
if not deler:
|
||||
msg = "a composite distribution with no parts"
|
||||
raise ParameterError(msg)
|
||||
linjer = []
|
||||
for k in deler:
|
||||
celle, under = fordeling(f[k], pert_form, indre=True)
|
||||
if under:
|
||||
msg = f"part {k!r} of a composite distribution is a table"
|
||||
raise ParameterError(msg)
|
||||
linjer.append(f"{tekst(k)}: {celle}")
|
||||
return r"\newline ".join(linjer)
|
||||
|
||||
|
||||
def fordeling(f: object, pert_form: int, *, indre: bool = False) -> tuple[str, list[str]]:
|
||||
"""The cell text for a distribution, and the lines under the row (for a table value)."""
|
||||
if not isinstance(f, dict):
|
||||
msg = f"a distribution is not an object: {f!r}"
|
||||
raise ParameterError(msg)
|
||||
t = f.get("type")
|
||||
if t == SAMMENSATT and not indre:
|
||||
return _sammensatt(f, pert_form), []
|
||||
if not isinstance(t, str) or t not in FORDELINGSFELT:
|
||||
msg = f"unknown distribution type {t!r}"
|
||||
raise ParameterError(msg)
|
||||
if tuple(f) != FORDELINGSFELT[t]:
|
||||
msg = f"distribution {t!r} has the fields {tuple(f)}, expected {FORDELINGSFELT[t]}"
|
||||
raise ParameterError(msg)
|
||||
if t == "fast":
|
||||
return fast_verdi(f["verdi"])
|
||||
return SKRIV[t](f, pert_form), []
|
||||
|
||||
|
||||
def _sjekk_tekstgrupper(s: str) -> None:
|
||||
r"""Every \text{...} in a symbol holds only letters, digits, commas and spaces."""
|
||||
for innhold in TEKSTGRUPPE.findall(s):
|
||||
if not innhold or not all(
|
||||
(c.isascii() and (c.isalnum() or c in ", ")) or c in TEKST_I_SYMBOL for c in innhold
|
||||
):
|
||||
msg = f"symbol {s!r}: \\text{{{innhold}}} holds a character that is not allowed"
|
||||
raise ParameterError(msg)
|
||||
|
||||
|
||||
def _sjekk_resten(s: str, rest: str) -> None:
|
||||
"""What is left of a symbol: allowed characters, scripts with an argument, balanced braces."""
|
||||
dybde = 0
|
||||
for i, c in enumerate(rest):
|
||||
if not (c.isascii() and c.isalnum()) and c not in SYMBOLTEGN:
|
||||
msg = f"symbol {s!r}: character {c!r} is not allowed in a symbol"
|
||||
raise ParameterError(msg)
|
||||
if c in "_^" and (i + 1 == len(rest) or rest[i + 1] in "_^} "):
|
||||
msg = f"symbol {s!r}: {c!r} without an argument"
|
||||
raise ParameterError(msg)
|
||||
dybde += {"{": 1, "}": -1}.get(c, 0)
|
||||
if dybde < 0:
|
||||
break
|
||||
if dybde != 0:
|
||||
msg = f"symbol {s!r}: unbalanced braces"
|
||||
raise ParameterError(msg)
|
||||
|
||||
|
||||
def tex_symbol(s: str) -> str:
|
||||
"""The symbol in math mode, or a dash for none; stops on anything not known to be safe."""
|
||||
if s == INGEN:
|
||||
return STRIPE
|
||||
if not s or s.strip() != s:
|
||||
msg = f"empty symbol or symbol with spaces at the ends: {s!r}"
|
||||
raise ParameterError(msg)
|
||||
_sjekk_tekstgrupper(s)
|
||||
rest = TEKSTGRUPPE.sub("x", s)
|
||||
for kommando in KOMMANDO.findall(rest):
|
||||
if kommando not in KOMMANDOER:
|
||||
msg = f"symbol {s!r}: command \\{kommando} is not in KOMMANDOER"
|
||||
raise ParameterError(msg)
|
||||
_sjekk_resten(s, KOMMANDO.sub("x", rest))
|
||||
return "$" + s + "$"
|
||||
|
||||
|
||||
def tex_id(pid: str) -> str:
|
||||
r"""The parameter id in \texttt, with break points after underscores."""
|
||||
if not ID.match(pid):
|
||||
msg = f"not a plain id: {pid!r}"
|
||||
raise ParameterError(msg)
|
||||
return r"\texttt{" + pid.replace("_", r"\_\allowbreak{}") + "}"
|
||||
|
||||
|
||||
def tex_poster(poster: list[str]) -> str:
|
||||
r"""The source-bank entries, each in \kilde, or a dash when there are none."""
|
||||
for p in poster:
|
||||
if not POST.match(p):
|
||||
msg = f"not a source-bank entry: {p!r}"
|
||||
raise ParameterError(msg)
|
||||
if not poster:
|
||||
return STRIPE
|
||||
# \leavevmode first: the colour in \kilde would otherwise start the cell in vertical mode
|
||||
# and push its first line below the first line of the other cells.
|
||||
return r"\leavevmode " + " ".join(r"\kilde{" + p + "}" for p in poster)
|
||||
|
||||
|
||||
def les_parameter(p: object, statuser: dict[str, str]) -> dict[str, object]:
|
||||
"""Check one parameter object and return it."""
|
||||
if not isinstance(p, dict) or tuple(p) != FELT:
|
||||
msg = f"a parameter does not have exactly the fields {FELT}: {p!r}"
|
||||
raise ParameterError(msg)
|
||||
for k in TEKSTFELT:
|
||||
if not isinstance(p[k], str):
|
||||
msg = f"{p.get('id')!r}: field {k!r} is not a text"
|
||||
raise ParameterError(msg)
|
||||
for k in ("id", "symbol", "navn", "enhet", "status"):
|
||||
if not p[k]:
|
||||
msg = f"{p.get('id')!r}: field {k!r} is empty"
|
||||
raise ParameterError(msg)
|
||||
poster = p["poster"]
|
||||
if not isinstance(poster, list) or not all(isinstance(x, str) for x in poster):
|
||||
msg = f"{p['id']!r}: the entries are not a list of texts"
|
||||
raise ParameterError(msg)
|
||||
if p["status"] not in statuser:
|
||||
msg = f"{p['id']!r}: unknown status {p['status']!r}"
|
||||
raise ParameterError(msg)
|
||||
return p
|
||||
|
||||
|
||||
def rad(p: dict[str, object], pert_form: int) -> list[str]:
|
||||
"""The table lines for one parameter: the row, and the line under it when there is one."""
|
||||
pid, symbol, navn, enhet = str(p["id"]), str(p["symbol"]), str(p["navn"]), str(p["enhet"])
|
||||
status, ligninger = str(p["status"]), str(p["ligninger"])
|
||||
kildeverdi, merknad = str(p["kildeverdi"]), str(p["merknad"])
|
||||
poster = p["poster"]
|
||||
assert isinstance(poster, list) # noqa: S101 - checked in les_parameter
|
||||
celle, tabell = fordeling(p["fordeling"], pert_form)
|
||||
navnecelle = tekst(navn) + r"\newline \textit{Enhet:} " + tekst(enhet)
|
||||
if ligninger:
|
||||
navnecelle += r". \textit{Brukes i:} " + tekst(ligninger)
|
||||
celler = [
|
||||
tex_symbol(symbol) + r"\newline " + tex_id(pid),
|
||||
navnecelle,
|
||||
celle,
|
||||
tekst(status),
|
||||
tex_poster(poster),
|
||||
]
|
||||
deler = []
|
||||
if kildeverdi:
|
||||
deler.append(r"\textit{Kildeverdi:} " + tekst(kildeverdi))
|
||||
if merknad:
|
||||
deler.append(r"\textit{Merknad:} " + tekst(merknad))
|
||||
if tabell:
|
||||
deler.append(r"\textit{Verdi:}\newline " + tabell[0])
|
||||
if not deler:
|
||||
return [" & ".join(celler) + r" \\", r"\addlinespace[3pt]"]
|
||||
# The row and the first line under it stay on one page; the rest of a table value has one
|
||||
# table row per line, so that a long table can break across pages.
|
||||
return [
|
||||
" & ".join(celler) + r" \\*",
|
||||
"& " + UNDERLINJE + "{" + r"\newline ".join(deler) + r"} \\",
|
||||
*("& " + UNDERLINJE + "{" + linje + r"} \\" for linje in tabell[1:]),
|
||||
r"\addlinespace[3pt]",
|
||||
]
|
||||
|
||||
|
||||
def sjekksum_registrert(forhaandsreg: str) -> str:
|
||||
"""The last SHA-256 stated under «Parameterfrys» in the pre-registration."""
|
||||
_, funnet, etter = forhaandsreg.partition("\n## Parameterfrys\n")
|
||||
if not funnet:
|
||||
msg = "the pre-registration has no section «Parameterfrys»"
|
||||
raise ParameterError(msg)
|
||||
seksjon = etter.split("\n## ", 1)[0]
|
||||
summer = SJEKKSUM.findall(seksjon)
|
||||
if not summer:
|
||||
msg = "no SHA-256 under «Parameterfrys» in the pre-registration"
|
||||
raise ParameterError(msg)
|
||||
return str(summer[-1])
|
||||
|
||||
|
||||
def _uten_dubletter(par: list[tuple[str, object]]) -> dict[str, object]:
|
||||
"""A JSON object, refusing a key that stands twice (json would keep the last silently)."""
|
||||
d: dict[str, object] = {}
|
||||
for k, v in par:
|
||||
if k in d:
|
||||
msg = f"the key {k!r} stands twice in one object"
|
||||
raise ParameterError(msg)
|
||||
d[k] = v
|
||||
return d
|
||||
|
||||
|
||||
def _hent(d: dict[str, object], k: str) -> object:
|
||||
if k not in d:
|
||||
msg = f"the file has no field {k!r}"
|
||||
raise ParameterError(msg)
|
||||
return d[k]
|
||||
|
||||
|
||||
def lag(raa: bytes, forhaandsreg: str) -> str:
|
||||
"""Return the LaTeX of the appendix."""
|
||||
sjekksum = hashlib.sha256(raa).hexdigest()
|
||||
registrert = sjekksum_registrert(forhaandsreg)
|
||||
if sjekksum != registrert:
|
||||
msg = (
|
||||
f"the checksum of the file ({sjekksum}) is not the one the pre-registration "
|
||||
f"states under «Parameterfrys» ({registrert})"
|
||||
)
|
||||
raise ParameterError(msg)
|
||||
d = json.loads(raa.decode("utf-8"), object_pairs_hook=_uten_dubletter)
|
||||
if not isinstance(d, dict):
|
||||
msg = "the file is not a JSON object"
|
||||
raise ParameterError(msg)
|
||||
versjon = _hent(d, "versjon")
|
||||
statuser = _hent(d, "status")
|
||||
monte_carlo = _hent(d, "monte_carlo")
|
||||
foelsomheter = _hent(d, "foelsomheter")
|
||||
parametere = _hent(d, "parametere")
|
||||
if not isinstance(versjon, str) or not versjon:
|
||||
msg = f"the version is not a text: {versjon!r}"
|
||||
raise ParameterError(msg)
|
||||
if not isinstance(statuser, dict) or not all(
|
||||
isinstance(k, str) and isinstance(v, str) for k, v in statuser.items()
|
||||
):
|
||||
msg = "the field 'status' is not an object of texts"
|
||||
raise ParameterError(msg)
|
||||
if not isinstance(monte_carlo, dict) or not isinstance(monte_carlo.get("pert_form"), int):
|
||||
msg = "monte_carlo.pert_form is not a whole number"
|
||||
raise ParameterError(msg)
|
||||
pert_form = int(monte_carlo["pert_form"])
|
||||
if not isinstance(parametere, list) or len(parametere) != ANTALL:
|
||||
msg = f"the file does not hold exactly {ANTALL} parameters"
|
||||
raise ParameterError(msg)
|
||||
if (
|
||||
not isinstance(foelsomheter, list)
|
||||
or len(foelsomheter) != ANTALL_FOELSOMHETER
|
||||
or not all(isinstance(s, str) and s for s in foelsomheter)
|
||||
):
|
||||
msg = f"the sensitivity list is not {ANTALL_FOELSOMHETER} non-empty texts"
|
||||
raise ParameterError(msg)
|
||||
rader = [les_parameter(p, statuser) for p in parametere]
|
||||
ider = [str(p["id"]) for p in rader]
|
||||
if len(set(ider)) != len(ider):
|
||||
msg = "an id stands twice"
|
||||
raise ParameterError(msg)
|
||||
|
||||
antall = {s: sum(1 for p in rader if p["status"] == s) for s in statuser}
|
||||
deler = [f"{n} med status «{tekst(s)}» ({tekst(statuser[s])})" for s, n in antall.items() if n]
|
||||
opptelling = "; ".join(deler[:-1]) + " og " + deler[-1] if len(deler) > 1 else deler[0]
|
||||
sum_tekst = r"\allowbreak{}".join(sjekksum[i : i + 16] for i in range(0, len(sjekksum), 16))
|
||||
innledning = [
|
||||
(
|
||||
rf"\noindent Fila er versjon {tekst(versjon)} og har {len(rader)} parametere, som"
|
||||
rf" står i tabellen i samme rekkefølge som i fila: {opptelling}. Sjekksummen (SHA-256)"
|
||||
rf" av fila er \texttt{{{sum_tekst}}}, den samme som forhåndsregistreringen oppgir"
|
||||
r" under «Parameterfrys» for fila som gjelder nå."
|
||||
),
|
||||
"",
|
||||
(
|
||||
r"Fordelingen skrives som i kapittel~14 i spesifikasjonen: «fast» med verdien,"
|
||||
r" «jevn lav \textendash{} høy», «jevn i logaritmen lav \textendash{} høy»,"
|
||||
rf" «PERT lav / modus / høy» (beta-PERT med formparameter {tall(pert_form)}),"
|
||||
r" «diskret» med verdiene og vektene, og «lognormal» med median, sigma og grensene den"
|
||||
r" avkortes ved. En sammensatt parameter har én linje per størrelse. Tall står med alle"
|
||||
r" sifrene de har i fila, med desimalkomma og tynt mellomrom mellom tusener når"
|
||||
r" heltallsdelen har fem sifre eller flere; flere verdier skilles med semikolon. Id-er"
|
||||
r" og nøkler står i skrivemaskinskrift slik de står i fila. Under raden står"
|
||||
r" kildeverdien (kildens tall i kildens egen enhet), merknaden og en fast verdi som er"
|
||||
r" en tabell, når fila har dem."
|
||||
r" En strek for symbol eller poster betyr at fila ikke har noe der; som enhet betyr den"
|
||||
r" at størrelsen er uten enhet."
|
||||
),
|
||||
]
|
||||
ut = [
|
||||
"% Laget av rapport/lag_vedlegg_parametere.py fra modell/parametere.json.",
|
||||
"% Rettes ikke for hånd: kjør skriptet på nytt.",
|
||||
*innledning,
|
||||
"",
|
||||
r"{\footnotesize",
|
||||
r"\setlength{\tabcolsep}{4pt}",
|
||||
r"\renewcommand{\arraystretch}{1.12}",
|
||||
r"\begin{xltabular}{\linewidth}{" + KOLONNER + "}",
|
||||
r"\caption{Parameterne i parameterfila, versjon " + tekst(versjon) + r". Kildeverdien,"
|
||||
r" merknaden og verdier som er tabeller, står i linja under parameteren.}"
|
||||
r"\label{tab:parametere}\\",
|
||||
r"\toprule",
|
||||
HODE,
|
||||
r"\midrule",
|
||||
r"\endfirsthead",
|
||||
r"\toprule",
|
||||
HODE,
|
||||
r"\midrule",
|
||||
r"\endhead",
|
||||
r"\bottomrule",
|
||||
r"\endfoot",
|
||||
]
|
||||
for p in rader:
|
||||
ut += rad(p, pert_form)
|
||||
ut += [r"\end{xltabular}", "}", ""]
|
||||
ut += [
|
||||
(
|
||||
r"\noindent Parameterfila låser også lista over følsomheter."
|
||||
rf" \Cref{{tab:folsomhetsliste}} gjengir den ordrett, {len(foelsomheter)} linjer,"
|
||||
r" nummerert i den rekkefølgen de står i fila."
|
||||
),
|
||||
"",
|
||||
r"{\footnotesize",
|
||||
r"\setlength{\tabcolsep}{4pt}",
|
||||
r"\renewcommand{\arraystretch}{1.12}",
|
||||
r"\begin{xltabular}{\linewidth}{@{}P{8mm}L@{}}",
|
||||
(
|
||||
r"\caption{Den frosne følsomhetslista i parameterfila, ordrett.}"
|
||||
r"\label{tab:folsomhetsliste}\\"
|
||||
),
|
||||
r"\toprule",
|
||||
r"Linje & Følsomhet \\",
|
||||
r"\midrule",
|
||||
r"\endfirsthead",
|
||||
r"\toprule",
|
||||
r"Linje & Følsomhet \\",
|
||||
r"\midrule",
|
||||
r"\endhead",
|
||||
r"\bottomrule",
|
||||
r"\endfoot",
|
||||
]
|
||||
ut += [f"{i} & {tekst(s)} \\\\" for i, s in enumerate(foelsomheter, start=1)]
|
||||
ut += [r"\end{xltabular}", "}", ""]
|
||||
return "\n".join(ut)
|
||||
|
||||
|
||||
def main() -> int:
|
||||
"""Write the appendix; return 0, or 1 with a message on error."""
|
||||
try:
|
||||
tekst_ut = lag(PARAMETERE.read_bytes(), FORHAANDSREG.read_text(encoding="utf-8"))
|
||||
except (ParameterError, OSError, ValueError) as e:
|
||||
sys.stderr.write(f"lag_vedlegg_parametere: {e}\n")
|
||||
return 1
|
||||
UT.parent.mkdir(exist_ok=True)
|
||||
UT.write_text(tekst_ut, encoding="utf-8", newline="\n")
|
||||
sys.stdout.write(f"lag_vedlegg_parametere: skrev {UT.relative_to(ROT)}\n")
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
|
|
@ -1,5 +1,7 @@
|
|||
\documentclass[11pt,a4paper]{article}
|
||||
\input{preamble}
|
||||
\usepackage{xstring}
|
||||
\usepackage{pgfplotstable}
|
||||
\geometry{top=12mm,bottom=12mm,left=18mm,right=18mm}
|
||||
\hypersetup{pdftitle={Tokenfabrikker: sammendrag for beslutningstakere},pdfauthor={Kjell Tore Guttormsen},pdflang={nb-NO}}
|
||||
\pagestyle{fancy}
|
||||
|
|
@ -11,8 +13,19 @@
|
|||
\fancypagestyle{plain}{\fancyhf{}\fancyfoot[C]{\small\thepage}\renewcommand{\headrulewidth}{0pt}}
|
||||
\setlist{itemsep=0.6pt,topsep=1.5pt}
|
||||
\titlespacing*{\section}{0pt}{1.1ex plus .2ex}{0.5ex}
|
||||
\titlespacing*{\paragraph}{0pt}{0.5ex plus .2ex}{0.5em}
|
||||
|
||||
% Skjelett: bare overskrifter og plassholdere. Må holde seg på to sider når det fylles ut.
|
||||
% Tall fra resultatfilene, skrevet av lag_resultater.py (bygg.sh)
|
||||
\input{generert/tall}
|
||||
|
||||
% The note states only what the summary in the report (sammendrag.tex) states; the method is explained
|
||||
% from chapters 1 to 3. Every measured number and verdict word is a key of tall.json.
|
||||
|
||||
% A \tall value ("3,14") as a number pgfplots can read ("3.14"); only for placing bars and labels.
|
||||
\newcommand{\tallsomtall}[2]{\fullexpandarg\StrSubstitute{\tall{#1}}{,}{.}[#2]}
|
||||
% The share "best alone" of one solution on the step with one facility, from generert/dommer-m7.dat
|
||||
% (row 0 is the step with one facility; checked below), in per cent.
|
||||
\newcommand{\hentalene}[2]{\pgfplotstablegetelem{0}{#1}\of\mseven\pgfmathsetmacro#2{100*\pgfplotsretval}}
|
||||
|
||||
\begin{document}
|
||||
\thispagestyle{plain}
|
||||
|
|
@ -25,52 +38,178 @@
|
|||
|
||||
\begin{tcolorbox}[enhanced,colback=boxbg,colframe=accent,boxrule=0.6pt,arc=1.5pt,left=7pt,right=7pt,top=4pt,bottom=4pt]
|
||||
\small
|
||||
\textbf{Kjernebudskap.} \begin{kommerblokk}
|
||||
hypotesen ordrett og den samlede dommen i én til to setninger
|
||||
\end{kommerblokk}
|
||||
\textbf{Kjernebudskap.} Hypotesen er at «statlig eide tokenfabrikker i stor skala lønner seg for Norge og
|
||||
oppfyller vilkårene for strøm og miljø, med den beste av kraftløsningene». Dommen er
|
||||
\textbf{«\tall{dommer.del1}»}. Netto nåverdi for Norge har negativ median for alle fem kraftløsningene, og
|
||||
skalaen nås ikke.
|
||||
\end{tcolorbox}
|
||||
|
||||
\section{Spørsmålet}
|
||||
\begin{kommerblokk}
|
||||
hypotesen ordrett, og at den ble endret av prosjekteier før noe var regnet
|
||||
\end{kommerblokk}
|
||||
Rapporten prøver om AI-datasentre som i prinsippet eies av staten, kan bli en inntektskilde for Norge slik
|
||||
oljen har vært. Slike datasentre kalles tokenfabrikker: datasentre som eksporterer ferdig prosessert
|
||||
regnekraft. Hypotesen står ordrett i rammen over. Prøven er ærlig ment: alle alternativer og
|
||||
alle resultater rapporteres, også de som går imot hypotesen.
|
||||
|
||||
Prosjekteier, som har godkjent kriteriene og hver endring av dem, endret ordlyden i hypotesen 13.~november
|
||||
2026, før noe var regnet. Før endringen hadde hypotesen en egen del om at ett dedikert kjernekraftverk per
|
||||
datasenter er den beste måten å gjøre det på. Nå er det én av fem kraftløsninger som sammenlignes på like vilkår, og ingen løsning har
|
||||
særstilling. Målene og tersklene ble ikke endret.
|
||||
|
||||
\section{Slik er det prøvd}
|
||||
\begin{kommerblokk}
|
||||
forhåndsregistreringen, målene M1--M6, sammenligningen M7 uten dom, de fem kraftløsningene,
|
||||
trekningene og prisscenarioene
|
||||
\end{kommerblokk}
|
||||
\paragraph{Bestemt på forhånd}
|
||||
Målene, tersklene og reglene for dommen ble skrevet ned og godkjent før noe ble regnet. Dette kalles
|
||||
forhåndsregistreringen. Parameterne ble også frosset før noe ble regnet: 137 parametere, hver med verdi,
|
||||
spenn og fordeling.
|
||||
|
||||
\paragraph{Fem kraftløsninger}
|
||||
\textbf{A}: ett dedikert kjernekraftverk per datasenter, som verken tar kraft fra nettet eller gir kraft til det.
|
||||
\textbf{B}: kjernekraft koblet til strømnettet. \textbf{C}: ny fornybar kraft (vind, vann) med lagring og
|
||||
fleksibilitet. \textbf{T-F}: trinnvis utbygging med fornybar kraft, i moduler på nettet, der de første
|
||||
modulene kobles til nettet som finnes, og ny fornybar kraft bygges for hver modul. \textbf{T-K}: som T-F, men modulene som settes i drift når
|
||||
kjernekraft tidligst kan komme, får kjernekraft koblet til nettet. Alle måles mot et nullalternativ uten
|
||||
statlig satsing.
|
||||
|
||||
\paragraph{Seks mål}
|
||||
\textbf{M1} er netto nåverdi for Norge: alle gevinster minus alle kostnader for samfunnet over tid, regnet
|
||||
om til verdien i ett år og målt mot nullalternativet. \textbf{M2} er bedriftsøkonomien: kostnaden per
|
||||
levert enhet regnekraft mot prisen på regnekraft. \textbf{M3} er strømprisen for husholdninger og
|
||||
virksomheter. \textbf{M4} er forsyningssikkerheten for resten av landet. \textbf{M5} er miljøet: blant annet utslipp
|
||||
og naturinngrep fra krafta. \textbf{M6} er skalaen, «den nye oljen»: hva satsingen netto tilfører Norges
|
||||
inntekt per år utover vanlig avkastning på kapitalen, målt mot statens netto kontantstrøm fra petroleum. Hvert mål får én av tre dommer:
|
||||
«holder», «holder under betingelser» eller «holder ikke». M1 holder når netto nåverdi er positiv i minst
|
||||
80~\% av trekningene og medianen er positiv. M6 holder ikke når bidraget er under 5~\% av den.
|
||||
|
||||
\paragraph{Dommen over hypotesen}
|
||||
En kraftløsning er \emph{felt} når minst ett av M1 til M5 «holder ikke», eller når medianen i M1 er
|
||||
negativ. Er alle løsningene felt, holder ikke hypotesen. M6 kan ikke alene felle en løsning. Men er M6
|
||||
under 5~\%, holder ikke hypotesen i den formen den er stilt. Ved siden av dommen står en sammenligning av
|
||||
kraftløsningene (M7): hvor ofte hver løsning har høyest netto nåverdi. Den har ingen terskler og gir ingen
|
||||
dom.
|
||||
|
||||
\paragraph{Usikkerheten}
|
||||
Mye er usikkert, så modellen regnes \tall{dommer.antall} ganger. Hver gang kalles en \emph{trekning}: da
|
||||
trekkes én verdi for hver usikker størrelse fra den frosne fordelingen. Medianen er verdien som halvparten
|
||||
av trekningene ligger under. Prisen på regnekraft kan ingen kilde forutsi. Den legges inn som tre
|
||||
prisscenarioer uten sannsynligheter: «knapphet varer», «normalisering» (knapphetspåslaget i prisen er
|
||||
borte før første anlegg er i drift) og «overkapasitet». Dommen som teller, er dommen i «normalisering».
|
||||
Hver løsning regnes for 1, 5, 10, 20 og 40 anlegg på 1\,000~MW IT-last hvert (strømmen datautstyret
|
||||
bruker). Hvilket av disse trinnene
|
||||
dommene leses av på, følger av faste regler for skalaen (M6).
|
||||
|
||||
\section{Hva modellen finner}
|
||||
\begin{kommerblokk}
|
||||
dommen per mål i «normalisering» på trinnet dommene leses av på, og den samlede dommen
|
||||
\end{kommerblokk}
|
||||
Dommen som teller, er dommen i prisscenarioet «\tall{dommer.teller}», regnet over \tall{dommer.antall}
|
||||
trekninger. M6, skalaen, er under 5~\% i \tall{dommer.normalisering.t1.A.m6.andel-ikke}~\% av trekningene
|
||||
for alle fem løsningene på alle trinn. Med fem anlegg eller flere har ingen av dem et år med stabil drift
|
||||
(alle anleggene i drift) i minst 80~\% av trekningene. Dommene leses derfor av på trinnet med
|
||||
\tall{dommer.trinn} anlegg på 1\,000~MW IT-last, og skalaen nås ikke.
|
||||
|
||||
\begin{kommerblokk}
|
||||
Én figur fra datafilene: sammenligningen av kraftløsningene eller tidslinjen.
|
||||
\end{kommerblokk}
|
||||
\begin{center}
|
||||
\small
|
||||
\setlength{\tabcolsep}{4pt}
|
||||
\renewcommand{\arraystretch}{1.12}
|
||||
\begin{tabularx}{\linewidth}{@{}>{\raggedright\arraybackslash}p{40mm}*{5}{>{\raggedright\arraybackslash}X}@{}}
|
||||
\toprule
|
||||
Mål & A & B & C & T-F & T-K \\
|
||||
\midrule
|
||||
M1 netto nåverdi for Norge & \tall{dommer.normalisering.t1.A.m1.dom} & \tall{dommer.normalisering.t1.B.m1.dom}
|
||||
& \tall{dommer.normalisering.t1.C.m1.dom} & \tall{dommer.normalisering.t1.TF.m1.dom}
|
||||
& \tall{dommer.normalisering.t1.TK.m1.dom} \\
|
||||
M2 bedriftsøkonomi & \tall{dommer.normalisering.t1.A.m2.dom} & \tall{dommer.normalisering.t1.B.m2.dom}
|
||||
& \tall{dommer.normalisering.t1.C.m2.dom} & \tall{dommer.normalisering.t1.TF.m2.dom}
|
||||
& \tall{dommer.normalisering.t1.TK.m2.dom} \\
|
||||
M3 strømpris & \tall{dommer.normalisering.t1.A.m3.dom} & \tall{dommer.normalisering.t1.B.m3.dom}
|
||||
& \tall{dommer.normalisering.t1.C.m3.dom} & \tall{dommer.normalisering.t1.TF.m3.dom}
|
||||
& \tall{dommer.normalisering.t1.TK.m3.dom} \\
|
||||
M4 forsyningssikkerhet & \tall{dommer.normalisering.t1.A.m4.dom} & \tall{dommer.normalisering.t1.B.m4.dom}
|
||||
& \tall{dommer.normalisering.t1.C.m4.dom} & \tall{dommer.normalisering.t1.TF.m4.dom}
|
||||
& \tall{dommer.normalisering.t1.TK.m4.dom} \\
|
||||
M5 miljø & \tall{dommer.normalisering.t1.A.m5} & \tall{dommer.normalisering.t1.B.m5}
|
||||
& \tall{dommer.normalisering.t1.C.m5} & \tall{dommer.normalisering.t1.TF.m5}
|
||||
& \tall{dommer.normalisering.t1.TK.m5} \\
|
||||
M6 skala & \tall{dommer.normalisering.t1.A.m6.dom} & \tall{dommer.normalisering.t1.B.m6.dom}
|
||||
& \tall{dommer.normalisering.t1.C.m6.dom} & \tall{dommer.normalisering.t1.TF.m6.dom}
|
||||
& \tall{dommer.normalisering.t1.TK.m6.dom} \\[2pt]
|
||||
Median M1, mrd.~kr & \tall{dommer.normalisering.t1.A.nnv-median} & \tall{dommer.normalisering.t1.B.nnv-median}
|
||||
& \tall{dommer.normalisering.t1.C.nnv-median} & \tall{dommer.normalisering.t1.TF.nnv-median}
|
||||
& \tall{dommer.normalisering.t1.TK.nnv-median} \\
|
||||
\midrule
|
||||
\multicolumn{6}{@{}l}{\emph{Sammenligningen M7, uten dom, i prosent av trekningene}} \\
|
||||
Best alene & \tall{dommer.m7.normalisering.t1.A.alene} & \tall{dommer.m7.normalisering.t1.B.alene}
|
||||
& \tall{dommer.m7.normalisering.t1.C.alene} & \tall{dommer.m7.normalisering.t1.TF.alene}
|
||||
& \tall{dommer.m7.normalisering.t1.TK.alene} \\
|
||||
Deler plassen & \tall{dommer.m7.normalisering.t1.A.deler} & \tall{dommer.m7.normalisering.t1.B.deler}
|
||||
& \tall{dommer.m7.normalisering.t1.C.deler} & \tall{dommer.m7.normalisering.t1.TF.deler}
|
||||
& \tall{dommer.m7.normalisering.t1.TK.deler} \\
|
||||
\bottomrule
|
||||
\end{tabularx}
|
||||
\end{center}
|
||||
|
||||
\section{Betingelsene}
|
||||
\begin{kommerblokk}
|
||||
betingelsene som kan navngis, med sannsynligheten for hver, eller hvorfor de ikke kan det
|
||||
\end{kommerblokk}
|
||||
Netto nåverdi for Norge er positiv i høyst \tall{dommer.normalisering.t1.C.m1.andel}~\% av trekningene
|
||||
(C), og medianen er negativ for alle fem (2025-kroner, nåverdi i 2027). Hypotesen er
|
||||
«\tall{dommer.del1}» fordi målene ikke nås: alle fem er felt av M1 og den negative medianen, A og B også av
|
||||
M2. Fordi M6 er under 5~\%, holder hypotesen heller ikke i den formen den er stilt (stor skala, «den nye
|
||||
oljen»). Med ett anlegg kunne den høyst blitt «holder under betingelser», men det er M1 og medianen som
|
||||
feller løsningene, ikke trinnet. De andre scenarioene, trinnene og følsomhetene står i kapittel~6 i
|
||||
rapporten.
|
||||
|
||||
\section{Kraftløsningene og eierformene}
|
||||
\begin{kommerblokk}
|
||||
hvor ofte hver løsning kommer best ut, og hva sammenligningen av eierformene viser
|
||||
\end{kommerblokk}
|
||||
\section{Hvilken kraftløsning kommer best ut}
|
||||
M7 viser hvor ofte hver løsning har høyest netto nåverdi, alene eller delt med en annen med nøyaktig samme
|
||||
verdi. Med ett anlegg lar alle fem seg bygge i alle trekningene. C er best alene i
|
||||
\tall{dommer.m7.normalisering.t1.C.alene}~\% av trekningene. T-F og T-K deler plassen i
|
||||
\tall{dommer.m7.normalisering.t1.par.TF-TK}~\%; de er samme utbygging når ingen modul får kjernekraft. At
|
||||
en løsning er best, betyr ikke at den lønner seg.
|
||||
|
||||
\section{Hva modellen er, og hva den ikke er}
|
||||
\begin{kommerblokk}
|
||||
de viktigste kjente begrensningene og hva modellen ikke gjør
|
||||
\end{kommerblokk}
|
||||
\pgfplotstableread{generert/dommer-m7.dat}\mseven
|
||||
\pgfplotstablegetelem{0}{trinn}\of\mseven
|
||||
\ifnum\pgfplotsretval=1 \else\errmessage{dommer-m7.dat: rad 0 er ikke trinnet med ett anlegg}\fi
|
||||
\hentalene{A}{\aA}\hentalene{B}{\aB}\hentalene{C}{\aC}\hentalene{TF}{\aTF}\hentalene{TK}{\aTK}%
|
||||
\tallsomtall{dommer.m7.normalisering.t1.A.deler}{\dA}\tallsomtall{dommer.m7.normalisering.t1.B.deler}{\dB}%
|
||||
\tallsomtall{dommer.m7.normalisering.t1.C.deler}{\dC}\tallsomtall{dommer.m7.normalisering.t1.TF.deler}{\dTF}%
|
||||
\tallsomtall{dommer.m7.normalisering.t1.TK.deler}{\dTK}%
|
||||
\newcommand{\mlabel}[2]{\node[anchor=west,font=\small] at (axis cs:101,#1)
|
||||
{\tall{dommer.m7.normalisering.t1.#2.alene}~\% alene, \tall{dommer.m7.normalisering.t1.#2.deler}~\% deler};}
|
||||
\begin{center}
|
||||
\captionsetup{hypcap=false}
|
||||
\begin{tikzpicture}
|
||||
\begin{axis}[xbar stacked, width=118mm, height=36mm, scale only axis=false,
|
||||
bar width=5.5pt, ymin=0.4, ymax=5.6, ytick={1,...,5}, yticklabels={T-K,T-F,C,B,A},
|
||||
xmin=0, xmax=100, xtick={0,20,...,100}, xlabel={Andel av trekningene, \%},
|
||||
xmajorgrids, grid style={black!12}, clip=false, axis y line*=left, axis x line*=bottom,
|
||||
tick label style={font=\small}, label style={font=\small},
|
||||
legend style={font=\small, at={(0.5,1.03)}, anchor=south, legend columns=2, draw=none},
|
||||
legend cell align=left, reverse legend=false,
|
||||
/pgf/number format/.cd, use comma, 1000 sep={\,}]
|
||||
\addplot[fill=accent, draw=none] coordinates {(\aA,5) (\aB,4) (\aC,3) (\aTF,2) (\aTK,1)};
|
||||
\addlegendentry{best alene}
|
||||
\addplot[fill=cB, draw=none] coordinates {(\dA,5) (\dB,4) (\dC,3) (\dTF,2) (\dTK,1)};
|
||||
\addlegendentry{deler plassen med en annen}
|
||||
\mlabel{5}{A}\mlabel{4}{B}\mlabel{3}{C}\mlabel{2}{TF}\mlabel{1}{TK}
|
||||
\end{axis}
|
||||
\end{tikzpicture}
|
||||
\captionof{figure}{Sammenligningen av kraftløsningene (M7) i «normalisering» med ett anlegg: andelen av
|
||||
trekningene der hver løsning har høyest netto nåverdi alene, og der den deler plassen med en annen. M7
|
||||
gir ingen dom. At en løsning er best, betyr ikke at den lønner seg: medianen er negativ for alle fem.}
|
||||
\end{center}
|
||||
|
||||
\section{De viktigste kjente begrensningene}
|
||||
De seks resultatfilene fra hovedkjøringen er laget på nytt på samme maskin og ble like ned til siste
|
||||
byte, men det er ikke gjort på en annen maskin ennå. 40 av de 137 parameterne er åpne forutsetninger uten kilde som gir verdien, og en
|
||||
terskel i en slik forutsetning teller ikke som betingelse. To funn fra fagmiljøene er ikke dekket av
|
||||
spennene i modellen. Én kilde gir større sjanse for svært store kostnadsoverskridelser for kjernekraft enn
|
||||
fordelingen modellen bruker. Og modellen har ikke noe påslag for å tilpasse et utenlandsk reaktordesign
|
||||
til norsk regelverk. Begge kan gjøre kjernekraft dyrere enn modellen regner med i de dårligste utfallene
|
||||
(A, B og T-K). To observasjoner i de samme kildene trekker motsatt vei, mot raskere bygging og mer læring i
|
||||
de beste utfallene. Fagfellene som har vurdert arbeidet, er språkmodeller (KI). Den uavhengige
|
||||
kontrollkoden er skrevet ut fra samme tekst som modellen, så en feil begge leser likt, oppdages ikke. Se
|
||||
kapittel~7 til~9 i rapporten.
|
||||
|
||||
\begin{tcolorbox}[enhanced,colback=boxbg,colframe=accent,boxrule=0.6pt,arc=1.5pt,left=7pt,right=7pt,top=2.5pt,bottom=2.5pt,before skip=5pt,after skip=5pt]
|
||||
\small
|
||||
\textbf{Rapport, modell og kode:} \kommer{lenke til repoet}
|
||||
\textbf{Rapport, modell, kilder og kode:} \url{https://git.fromaitochitta.com/open/tokenfabrikker}
|
||||
\end{tcolorbox}
|
||||
|
||||
\noindent{\small\textbf{Kilder:} \kommer{kildene}
|
||||
\noindent{\small\textbf{Kilder:} Kildene, med side og ordrett sitat for hver, står i referanselista i
|
||||
rapporten og i kildebanken.
|
||||
\textit{Utarbeidet med omfattende bruk av KI (Claude, Anthropic). Ansvar for innholdet: forfatteren.}}
|
||||
|
||||
\end{document}
|
||||
|
|
|
|||
|
|
@ -77,9 +77,32 @@
|
|||
\Crefname{enumi}{Punkt}{Punktene}
|
||||
|
||||
% ---------- makroer for rapporten ----------
|
||||
% Post i kildebanken (kilder/). En senere runde gjør id-ene om til fulle referanser.
|
||||
% Post i kildebanken (kilder/), med full referanse i lista «Kilder» (refs.tex).
|
||||
% Bruk: \kilde{K27-138} eller \kilde{K03-044, K03-045}.
|
||||
\newcommand{\kilde}[1]{{\color{accent}\textsf{\small[#1]}}}
|
||||
% Hver id blir en lenke til posten i referanselista (\hypertarget{kilde:<id>} i generert/referanser.tex);
|
||||
% «A til B» lenker begge ender. Mellomrommet foran klammen i definisjonen er med vilje:
|
||||
% lag_referanser.py leser «\kilde» fulgt rett av klamme som en henvisning.
|
||||
\ExplSyntaxOn
|
||||
\tl_new:N \l__kilde_tl
|
||||
\seq_new:N \l__kilde_del_seq
|
||||
\cs_new_protected:Npn \__kilde_post:n #1
|
||||
{
|
||||
\seq_set_split:Nnn \l__kilde_del_seq { til } { #1 }
|
||||
\seq_set_map:NNn \l__kilde_del_seq \l__kilde_del_seq
|
||||
{ \exp_not:n { \hyperlink { kilde: ##1 } { ##1 } } }
|
||||
\tl_if_empty:NF \l__kilde_tl { \tl_put_right:Nn \l__kilde_tl { , ~ } }
|
||||
\tl_put_right:Nx \l__kilde_tl
|
||||
{ \seq_use:Nn \l__kilde_del_seq { \c_space_tl til \c_space_tl } }
|
||||
}
|
||||
\NewDocumentCommand \kilde { m }
|
||||
{
|
||||
\group_begin:
|
||||
\tl_clear:N \l__kilde_tl
|
||||
\clist_map_function:nN { #1 } \__kilde_post:n
|
||||
{ \color { accent } \textsf { \small [ \tl_use:N \l__kilde_tl ] } }
|
||||
\group_end:
|
||||
}
|
||||
\ExplSyntaxOff
|
||||
% Fil eller kommando i repoet, skrevet som den står (understrek uten \_), med linjeskift etter / og .
|
||||
\DeclareUrlCommand\fil{\urlstyle{tt}}
|
||||
\setlength{\emergencystretch}{2.5em}
|
||||
|
|
|
|||
|
|
@ -1,21 +1,11 @@
|
|||
% =================================================================
|
||||
% Kilder. Tom struktur: teksten viser foreløpig til poster i kildebanken med \kilde{K..-...}.
|
||||
% En senere runde gjør id-ene om til fulle referanser (\bibitem) her, med kilde, side og lenke
|
||||
% slik posten i kilder/ oppgir dem. Ingen referanse skrives inn uten at posten har en bekreftet
|
||||
% Kontroll-linje.
|
||||
% Kilder. Lista lages av lag_referanser.py (bygg.sh) fra postene i kilder/ som rapporten viser til
|
||||
% med \kilde{K..-...}: postens tittel og feltet Kilde, slik posten oppgir dem. En post uten bekreftet
|
||||
% Kontroll-linje stanser skriptet.
|
||||
% =================================================================
|
||||
\section*{Kilder}\addcontentsline{toc}{section}{Kilder}\label{sec:kilder}
|
||||
|
||||
Henvisninger i hakeparentes, som \kilde{K27-138}, viser til poster i kildebanken (\fil{kilder/}), der
|
||||
hver post har påstand, tall, spenn, kilde med side, ordrett sitat, kvalitet og kontroll mot
|
||||
primærkilden.
|
||||
Henvisninger i hakeparentes, som \kilde{K27-138}, viser til poster i kildebanken (\fil{kilder/}). I
|
||||
PDF-en er hver henvisning en lenke til posten i lista under.
|
||||
|
||||
\begin{kommerblokk}
|
||||
Litteraturlisten, laget fra postene rapporten viser til.
|
||||
\end{kommerblokk}
|
||||
|
||||
% \begin{thebibliography}{99}
|
||||
% \small
|
||||
% \setlength{\itemsep}{0pt}
|
||||
% \bibitem[Forfatter(år)]{nøkkel} ...
|
||||
% \end{thebibliography}
|
||||
\input{generert/referanser}
|
||||
|
|
|
|||
|
|
@ -22,14 +22,12 @@ Funksjonene ligger i \fil{src/tokenfabrikker/}.
|
|||
% -----------------------------------------------------------------
|
||||
\section{Parameterne}\label{app:parametere}
|
||||
|
||||
Parameterne står i \fil{modell/parametere.json} (versjon~1.1, SHA-256
|
||||
\texttt{\small 4b8809bc\dots f16}; \cref{sec:frys}): verdi, spenn, fordeling, status og poster i
|
||||
kildebanken for hver av de 137 parameterne.
|
||||
Tabellen viser de frosne parameterne slik de står i \fil{modell/parametere.json} (\cref{sec:frys}).
|
||||
Den er laget av \fil{rapport/lag_vedlegg_parametere.py} fra fila, som tabellen i kapittel~14 i
|
||||
spesifikasjonen, og rettes ikke for hånd. Henvisningene i hakeparentes er poster i kildebanken
|
||||
(se «Kilder» foran vedleggene).
|
||||
|
||||
\begin{kommerblokk}
|
||||
Tabellen lages fra \fil{modell/parametere.json} av et skript, som tabellen i kapittel 14 i
|
||||
spesifikasjonen, og skrives ikke for hånd.
|
||||
\end{kommerblokk}
|
||||
\input{generert/vedlegg-parametere}
|
||||
|
||||
% -----------------------------------------------------------------
|
||||
\section{Avvik fra forhåndsregistreringen og endringer}\label{app:endringer}
|
||||
|
|
@ -37,10 +35,11 @@ spesifikasjonen, og skrives ikke for hånd.
|
|||
Alle endringer i kriteriene og i parameterfila står med dato og grunn under «Endringer» i
|
||||
\fil{FORHANDSREGISTRERING.md}. Det er gjort ett avvik fra parameterfrysen, 12.~november 2026 (versjon~1.1),
|
||||
før noe var regnet. Hypotesen ble endret av prosjekteier 13.~november 2026, og den nye ordlyden ført inn
|
||||
14.~november 2026, før noe var regnet (\cref{sec:endringen}).
|
||||
14.~november 2026, før noe var regnet (\cref{sec:endringen}). Ett avvik er ført etter at resultatene
|
||||
forelå, 14.~november 2026: rangeringen av eierformene er ikke vist for andre vektinger og grenser
|
||||
(siste punkt i lista og \cref{sec:begrensninger}).
|
||||
|
||||
\begin{kommerblokk}
|
||||
Lista «Endringer» gjengitt i sin helhet, med dato, hva som ble endret, grunnen, og om endringen gjør
|
||||
testen strengere eller mildere. Etter hovedkjøringen: eventuelle feil som stanset kjøringen og ble rettet
|
||||
(avklaring 140~(d)).
|
||||
\end{kommerblokk}
|
||||
Hovedkjøringen på de frosne tallene og kjøringen som laget de to ekstra datafilene, gikk uten feil
|
||||
(fagfelleloggen del~22 og~23), så ingen feil som stanset en kjøring, er rettet.
|
||||
|
||||
\input{generert/vedlegg-endringer}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue