auditstat 0.1.9__py3-none-any.whl

auditstat/__init__.py

@@ -0,0 +1,6 @@
+"""
+auditstat: Python-pakket voor statistische auditmethoden.
+
+Subpakket:
+    stratified: gestratificeerde steekproefaudits (HARo-compatibel)
+"""

auditstat/_formatting.py

@@ -0,0 +1,32 @@
+"""Gedeelde hulpfuncties voor Nederlandse getalnotatie in plots.
+
+Nederlandse notatie gebruikt een komma als decimaalteken en een punt als
+duizendtal-scheidingsteken (bijv. "1.234,56"), het omgekeerde van de
+Engelse/Amerikaanse notatie die matplotlib standaard gebruikt voor
+astabels, legenda's en titels.
+"""
+
+import matplotlib.pyplot as plt
+
+
+def nl_getal(x, decimalen=2):
+    """Formatteert een getal met Nederlandse notatie (vast aantal
+    decimalen, komma als decimaalteken, punt als duizendtal-
+    scheidingsteken)."""
+    fmt = f"{x:,.{decimalen}f}"
+    return fmt.replace(",", "X").replace(".", ",").replace("X", ".")
+
+
+def nl_getal_variabel(x):
+    """Formatteert een getal met een door Python zelf gekozen, compact
+    aantal decimalen (zoals %g), maar met komma als decimaalteken.
+    Geschikt voor labels waar de precisie per waarde sterk uiteenloopt
+    (bijv. 0,5 / 0,05 / 0,005)."""
+    return f"{x:g}".replace(".", ",")
+
+
+def nl_tick_formatter(decimalen=2):
+    """Geeft een matplotlib-tickformatter terug die getallen weergeeft
+    met Nederlandse notatie (komma als decimaalteken, punt als
+    duizendtal-scheidingsteken)."""
+    return plt.FuncFormatter(lambda x, _pos=None: nl_getal(x, decimalen))

auditstat/sso/__init__.py

@@ -0,0 +1,6 @@
+"""
+auditstat: Python-pakket voor statistische auditmethoden.
+
+Subpakket:
+    sso: (in voorbereiding)
+"""

auditstat/sso/evalueer_SSO_klant_gestratificeerd.py

@@ -0,0 +1,56 @@
+from auditstat.sso.strata_SSO_klant import bouw_strata_SSO_klant
+from auditstat.stratified.eval_stratified import eval_stratified
+
+
+def evalueer_SSO_klant_gestratificeerd(
+    post_typen,
+    model="binomiaal",
+    zekerheid=0.95,
+    methode="FFT samen",
+    granulariteit=None,
+):
+    """
+    Evalueert een klant gestratificeerd (één stratum per type post), op
+    basis van SSO-steekproeven per type post.
+
+    Bouwt eerst de stratatabel via ``bouw_strata_SSO_klant`` en roept
+    daarna ``eval_stratified`` aan. Zie ``bouw_strata_SSO_klant`` voor het
+    formaat van ``post_typen``, en ``eval_stratified`` voor de overige
+    parameters en het resultaatformaat.
+
+    Per type post wordt een effectieve steekproefomvang en een effectief
+    aantal fouten bij de klant gekalibreerd via ``moment_match_SSO``
+    (gemiddelde- en variantie-matching op het ``model``-kansmodel), zodat
+    de gestratificeerde evaluatie zowel het juiste gemiddelde als (voor
+    zover mogelijk binnen de Beta/Gamma-familie) de juiste variantie van
+    de werkelijke, continue exacte SSO-onzekerheid draagt — zie
+    ``bouw_strata_SSO_klant`` en ``moment_match_SSO`` voor de details.
+
+    Parameters
+    ----------
+    post_typen : list[dict]
+        Zie ``bouw_strata_SSO_klant``.
+    model : {"binomiaal", "poisson"}
+        Kansmodel voor de gestratificeerde convolutieberekening.
+    zekerheid : float
+        Gewenste statistische zekerheid, tussen 0 en 1.
+    methode : {"FFT paarsgewijs", "FFT samen", "direct", "Monte Carlo"}
+        Methode voor de convolutieberekening.
+    granulariteit : int, optioneel
+        Zie ``eval_stratified``; standaard ``None`` (automatisch bepaald).
+
+    Returns
+    -------
+    dict
+        Het resultaat van ``eval_stratified``, inclusief de kanskromme
+        (bruikbaar met ``auditstat.stratified.plot_kanskromme.plot_kanskromme``)
+        en de opgebouwde stratatabel onder ``"steekproeven"``.
+    """
+    steekproeven = bouw_strata_SSO_klant(post_typen, model=model)
+    return eval_stratified(
+        steekproeven=steekproeven,
+        model=model,
+        zekerheid=zekerheid,
+        methode=methode,
+        granulariteit=granulariteit,
+    )

auditstat/sso/max_fout_benaderd_SSO.py

@@ -0,0 +1,19 @@
+from scipy import stats
+
+from auditstat.sso.n_klant_k_klant_SSO import n_klant_k_klant_SSO
+
+
+def max_fout_benaderd_SSO(n, k, N_klant, zekerheid=0.95, verdeling="binomiaal"):
+    """
+    Berekent de benaderde maximale foutfractie voor een SSO-klant.
+    """
+    n_klant, k_klant = n_klant_k_klant_SSO(n, k, N_klant)
+
+    if verdeling == "binomiaal":
+        # Vlakke prior (Beta(1,1)), posterior is Beta(k_klant+1, n_klant-k_klant+1)
+        return stats.beta.ppf(zekerheid, k_klant + 1, n_klant - k_klant + 1)
+    elif verdeling == "poisson":
+        # Vlakke prior Gamma(1,0), posterior voor de fractie is Gamma(k_klant+1, schaal=1/n_klant)
+        return stats.gamma.ppf(zekerheid, a=k_klant + 1, scale=1.0 / n_klant)
+    else:
+        raise ValueError("Kies 'binomiaal' of 'poisson'")

auditstat/sso/max_fout_exact_SSO.py

@@ -0,0 +1,48 @@
+import numpy as np
+from scipy import stats
+from scipy.interpolate import interp1d
+
+
+def _continue_kwantiel(cdf_func, max_val, target_p):
+    """Interpolatie helper om discrete verdelingen continu te maken."""
+    x_vals = np.arange(0, int(max_val) + 3)
+    y_vals = cdf_func(x_vals)
+
+    # Verwijder duplicaten om interpolatie fouten te voorkomen (bij staarten)
+    unique_y, indices = np.unique(y_vals, return_index=True)
+    unique_x = x_vals[indices]
+
+    if target_p <= unique_y[0]:
+        return float(unique_x[0])
+
+    interp_func = interp1d(
+        unique_y, unique_x, kind="linear", bounds_error=False, fill_value=(0, max_val)
+    )
+    return float(interp_func(target_p))
+
+
+def max_fout_exact_SSO(n, k, N_klant, zekerheid=0.95, verdeling="binomiaal"):
+    """
+    Berekent de exacte maximale foutfractie voor een SSO-klant,
+    met continue doortrekking van de discrete voorspellende verdelingen.
+    """
+    if verdeling == "binomiaal":
+        # Voorspellende verdeling: Beta-Binomiaal (N_klant, alpha=k+1, beta=n-k+1)
+        def cdf_func(x):
+            return stats.betabinom.cdf(x, N_klant, k + 1, n - k + 1)
+
+        aantal_fouten = _continue_kwantiel(cdf_func, N_klant, zekerheid)
+        return aantal_fouten / N_klant
+
+    elif verdeling == "poisson":
+        # Voorspellende verdeling: Negatief-Binomiaal (r=k+1, p=n/(n+N_klant))
+        # scipy.stats.nbinom hanteert het aantal mislukkingen, we passen parameters hierop aan.
+        p_succes = n / (n + N_klant)
+
+        def cdf_func(x):
+            return stats.nbinom.cdf(x, k + 1, p_succes)
+
+        aantal_fouten = _continue_kwantiel(cdf_func, N_klant, zekerheid)
+        return aantal_fouten / N_klant
+    else:
+        raise ValueError("Kies 'binomiaal' of 'poisson'")

auditstat/sso/max_fout_exact_continu_SSO.py

@@ -0,0 +1,107 @@
+import numpy as np
+from scipy.optimize import brentq
+from scipy.special import betainc, betaln, gammaln
+
+
+def _betabinom_continu_pdf(x, N_klant, alpha, beta):
+    """Continue (reële) uitbreiding van de Beta-Binomiaal kansmassafunctie.
+
+    Vervangt de binomiaalcoëfficiënt C(N_klant, x) door zijn continue
+    uitbreiding via de Gammafunctie, zodat x reële waarden in [0, N_klant]
+    mag aannemen in plaats van uitsluitend gehele getallen. Op gehele x
+    komt dit exact overeen met scipy.stats.betabinom.pmf(x, N_klant,
+    alpha, beta); ertussenin levert het een analytisch vloeiende
+    dichtheid op in plaats van een trapsgewijze interpolatie.
+    """
+    log_coef = gammaln(N_klant + 1) - gammaln(x + 1) - gammaln(N_klant - x + 1)
+    log_dichtheid = (
+        log_coef + betaln(x + alpha, N_klant - x + beta) - betaln(alpha, beta)
+    )
+    return np.exp(log_dichtheid)
+
+
+def _betabinom_continu_cdf_grid(N_klant, alpha, beta, aantal_punten=4000):
+    """Geeft (x_grid, cdf_grid) terug: een genormaliseerde cumulatieve
+    verdeling van de continue Beta-Binomiaal-dichtheid op [0, N_klant]."""
+    x = np.linspace(0, N_klant, aantal_punten)
+    dichtheid = _betabinom_continu_pdf(x, N_klant, alpha, beta)
+    cdf = np.concatenate((
+        [0.0],
+        np.cumsum((dichtheid[1:] + dichtheid[:-1]) / 2 * np.diff(x)),
+    ))
+    # Normaliseren: numerieke kwadratuur over een eindig grid benadert de
+    # (exacte) integraal van 1 niet perfect; dit forceert cdf(N_klant) = 1.
+    cdf = cdf / cdf[-1]
+    return x, dichtheid, cdf
+
+
+def max_fout_exact_continu_SSO(
+    n, k, N_klant, zekerheid=0.95, verdeling="binomiaal", aantal_punten=4000
+):
+    """
+    Berekent de maximale foutfractie bij de klant via een continue
+    uitbreiding van het exacte model (Beta-Binomiaal resp.
+    Negatief-Binomiaal), zonder de twee onzekerheidslagen samen te
+    voegen zoals bij max_fout_benaderd_SSO.
+
+    max_fout_exact_SSO rekent met de werkelijke, discrete voorspellende
+    verdeling en trekt alleen de resulterende kwantielfunctie lineair
+    door tussen gehele waarden. Hier wordt in plaats daarvan de
+    kansmassafunctie zélf analytisch doorgetrokken naar reële x: voor
+    "binomiaal" via de Gammafunctie-uitbreiding van de
+    binomiaalcoëfficiënt (zie _betabinom_continu_pdf), voor "poisson"
+    via de gesloten-vorm-identiteit tussen de Negatief-Binomiale CDF en
+    de regularized incomplete beta-functie (die zelf al analytisch is
+    in het aantal "fouten"). Beide onzekerheidslagen blijven behouden:
+    de posterior-onzekerheid over de ware foutkans (Beta) én de
+    steekproefvariabiliteit van die foutkans toegepast op de (hier
+    continu benaderde) klantpopulatie van omvang N_klant.
+
+    Parameters
+    ----------
+    n, k : int
+        Omvang en aantal fouten in de steekproef bij SSO.
+    N_klant : int
+        Aantal posten bij de klant.
+    zekerheid : float, standaard 0.95
+        Gewenste statistische zekerheid.
+    verdeling : {"binomiaal", "poisson"}, standaard "binomiaal"
+    aantal_punten : int, standaard 4000
+        Resolutie van het grid voor de numerieke integratie (alleen
+        gebruikt voor verdeling="binomiaal"; "poisson" gebruikt een
+        gesloten-vorm CDF en heeft dit niet nodig).
+
+    Returns
+    -------
+    float
+        Maximale foutfractie (aantal fouten / N_klant) bij de gekozen
+        zekerheid.
+    """
+    if N_klant <= 0:
+        raise ValueError("N_klant moet groter zijn dan 0.")
+    if not (0 < zekerheid < 1):
+        raise ValueError("zekerheid moet tussen 0 en 1 liggen.")
+
+    if verdeling == "binomiaal":
+        alpha, beta = k + 1, n - k + 1
+        x, _, cdf = _betabinom_continu_cdf_grid(N_klant, alpha, beta, aantal_punten)
+        aantal_fouten = float(np.interp(zekerheid, cdf, x))
+        return aantal_fouten / N_klant
+
+    elif verdeling == "poisson":
+        r = k + 1
+        p_succes = n / (n + N_klant)
+
+        def cdf_func(x):
+            return betainc(r, x + 1, p_succes)
+
+        if cdf_func(0.0) >= zekerheid:
+            aantal_fouten = 0.0
+        elif cdf_func(N_klant) <= zekerheid:
+            aantal_fouten = float(N_klant)
+        else:
+            aantal_fouten = brentq(lambda x: cdf_func(x) - zekerheid, 0.0, N_klant)
+        return aantal_fouten / N_klant
+
+    else:
+        raise ValueError("Kies 'binomiaal' of 'poisson'")

auditstat/sso/max_fout_heterogeen_SSO.py

@@ -0,0 +1,164 @@
+import numpy as np
+from scipy.special import comb
+from scipy.stats import poisson
+
+
+def _posterior_theta_klant_binomiaal(n, k, f, theta_grid):
+    """Niet-genormaliseerde posterior-dichtheid van theta_klant (binomiaal).
+
+    Model: n_X (het aantal van de n SSO-brede steekproefposten dat bij
+    klant X hoort) ~ Binomiaal(n, f). Klant X heeft een eigen, van de
+    rest van de SSO-populatie onafhankelijke foutkans theta_klant met
+    vlakke Beta(1, 1)-prior; de rest van de SSO-populatie heeft een
+    eigen, eveneens vlakke Beta(1, 1)-prior op theta_rest. Alleen de
+    som k = k_X + k_rest wordt waargenomen, niet de opsplitsing.
+
+    Omdat een Beta-Binomiaal-marginale verdeling met vlakke prior
+    discreet uniform is (P(l | m) = 1 / (m + 1)), marginaliseert
+    theta_rest weg tot een constante gewichtsfactor per (n_X, k_X)-
+    combinatie. Wat overblijft is een eindige dubbele som die hieronder
+    direct wordt opgeteld.
+    """
+    post = np.zeros_like(theta_grid, dtype=float)
+    m_waarden = np.arange(0, n + 1)
+    gewicht_m = comb(n, m_waarden) * f**m_waarden * (1 - f) ** (n - m_waarden)
+    for m, w_m in zip(m_waarden, gewicht_m, strict=False):
+        if w_m == 0.0:
+            continue
+        marginaal_rest = 1.0 / (n - m + 1)
+        j_min = max(0, k - (n - m))
+        j_max = min(m, k)
+        if j_min > j_max:
+            continue
+        bijdrage = np.zeros_like(theta_grid)
+        for j in range(j_min, j_max + 1):
+            bijdrage += comb(m, j) * theta_grid**j * (1 - theta_grid) ** (m - j)
+        post += w_m * marginaal_rest * bijdrage
+    return post
+
+
+def _posterior_theta_klant_poisson(n, k, f, theta_grid):
+    """Niet-genormaliseerde posterior-dichtheid van theta_klant (poisson).
+
+    Analoge constructie als bij _posterior_theta_klant_binomiaal, maar
+    met een Poisson/Gamma-model in plaats van Binomiaal/Beta: n_X ~
+    Binomiaal(n, f) (de opsplitsing van de steekproef over klant en
+    rest is een eigenschap van het steekproefontwerp en verandert niet
+    met het foutmodel), en gegeven n_X = m, k_X | theta_klant ~
+    Poisson(m * theta_klant) met vlakke (oneigenlijke) prior op
+    theta_klant; analoog voor de rest met expositie n - m.
+
+    Een vlakke prior op een Poisson-snelheid marginaliseert tot een
+    (oneigenlijke, maar voor elk vast expositieaantal constante)
+    gewicht 1 / (n - m) voor elk mogelijk aantal fouten in de rest. Bij
+    n_X = n is er geen rest-expositie: dan ligt k_X = k vast en is er
+    geen marginalisatie nodig.
+    """
+    post = np.zeros_like(theta_grid, dtype=float)
+    m_waarden = np.arange(0, n + 1)
+    gewicht_m = comb(n, m_waarden) * f**m_waarden * (1 - f) ** (n - m_waarden)
+    for m, w_m in zip(m_waarden, gewicht_m, strict=False):
+        if w_m == 0.0:
+            continue
+        if m == n:
+            bijdrage = poisson.pmf(k, mu=m * theta_grid)
+        else:
+            marginaal_rest = 1.0 / (n - m)
+            bijdrage = np.zeros_like(theta_grid)
+            for j in range(0, k + 1):
+                bijdrage += poisson.pmf(j, mu=m * theta_grid)
+            bijdrage = marginaal_rest * bijdrage
+        post += w_m * bijdrage
+    return post
+
+
+def _kwantiel_van_theta_posterior(theta_grid, dichtheid, p):
+    """Kwantiel van een dichtheid gegeven op een vast grid, via lineaire
+    interpolatie van de (genormaliseerde) cumulatieve verdeling."""
+    cdf = np.concatenate((
+        [0.0],
+        np.cumsum((dichtheid[1:] + dichtheid[:-1]) / 2 * np.diff(theta_grid)),
+    ))
+    cdf = cdf / cdf[-1]
+    return float(np.interp(p, cdf, theta_grid))
+
+
+def max_fout_heterogeen_SSO(
+    n, k, f, zekerheid=0.95, verdeling="binomiaal", aantal_theta=4001
+):
+    """
+    Berekent de maximale foutfractie bij een SSO-klant onder een
+    heterogeniteitsmodel: klant X heeft een eigen, van de rest van de
+    SSO-populatie onafhankelijke foutkans, in plaats van de impliciete
+    aanname van max_fout_exact_SSO / max_fout_exact_continu_SSO dat
+    elke post (van elke klant) verwisselbaar is met dezelfde,
+    SSO-brede foutkans (de "uitwisselbare" aanname).
+
+    Alleen de relatieve omvang van klant X binnen de totale
+    SSO-populatie is nodig (f = N_klant / N_totaal), niet N_klant of
+    N_totaal afzonderlijk: de totale SSO-populatie wordt verondersteld
+    zeer groot (effectief oneindig) te zijn, zowel in aantal posten als
+    in waarde, zodat trekken van de steekproef de populatie niet
+    noemenswaardig uitput. Onder diezelfde aanname convergeert de
+    werkelijke foutfractie bij klant X (die zelf ook een grote
+    populatie heeft) naar zijn eigen foutkans theta_klant; het
+    teruggegeven kwantiel is dus het kwantiel van de posterior van
+    theta_klant zelf, niet van een voorspellende telverdeling over een
+    eindige N_klant.
+
+    Model
+    -----
+    Van de n SSO-brede steekproefposten horen er n_X ~ Binomiaal(n, f)
+    toevallig bij klant X. Klant X heeft een eigen vlakke prior op zijn
+    foutkans theta_klant, onafhankelijk van de (eveneens vlakke) prior
+    op de foutkans van de rest van de SSO-populatie. Alleen de totale
+    som k = k_X + k_rest wordt waargenomen; de posterior van
+    theta_klant marginaliseert over alle mogelijke opsplitsingen.
+
+    Grenswaarden: bij f = 1 (alle steekproefposten horen bij klant X)
+    komt dit exact overeen met het bestaande uitwisselbare model
+    (Beta(k + 1, n - k + 1) resp. Gamma(k + 1, n), het laatste
+    getrunceerd naar [0, 1]). Bij f = 0 bevat de SSO-brede steekproef
+    geen informatie over klant X en blijft de posterior gelijk aan de
+    vlakke prior (uniform op [0, 1]).
+
+    Parameters
+    ----------
+    n, k : int
+        Omvang en aantal fouten in de SSO-brede steekproef.
+    f : float
+        Relatieve omvang van klant X binnen de totale SSO-populatie
+        (N_klant / N_totaal), tussen 0 en 1.
+    zekerheid : float, standaard 0.95
+        Gewenste statistische zekerheid.
+    verdeling : {"binomiaal", "poisson"}, standaard "binomiaal"
+    aantal_theta : int, standaard 4001
+        Resolutie van het grid voor theta_klant op [0, 1].
+
+    Returns
+    -------
+    float
+        Maximale foutfractie bij klant X bij de gekozen zekerheid,
+        onder het heterogeniteitsmodel.
+    """
+    if not isinstance(n, (int, np.integer)) or n <= 0:
+        raise ValueError("n moet een positief geheel getal zijn.")
+    if not isinstance(k, (int, np.integer)) or k < 0:
+        raise ValueError("k moet een niet-negatief geheel getal zijn.")
+    if k > n:
+        raise ValueError("k mag niet groter zijn dan n.")
+    if not (0 <= f <= 1):
+        raise ValueError("f moet tussen 0 en 1 liggen.")
+    if not (0 < zekerheid < 1):
+        raise ValueError("zekerheid moet tussen 0 en 1 liggen.")
+
+    theta_grid = np.linspace(0.0, 1.0, aantal_theta)
+
+    if verdeling == "binomiaal":
+        dichtheid = _posterior_theta_klant_binomiaal(n, k, f, theta_grid)
+    elif verdeling == "poisson":
+        dichtheid = _posterior_theta_klant_poisson(n, k, f, theta_grid)
+    else:
+        raise ValueError("Kies 'binomiaal' of 'poisson'")
+
+    return _kwantiel_van_theta_posterior(theta_grid, dichtheid, zekerheid)

auditstat/sso/moment_match_SSO.py

@@ -0,0 +1,110 @@
+import warnings
+
+
+def moment_match_SSO(n, k, N_klant, verdeling="binomiaal"):
+    """
+    Kalibreert een effectieve steekproefomvang (n_eff) en een effectief
+    aantal fouten (k_eff) bij de klant, zodanig dat de resulterende
+    Beta- (binomiaal) resp. Gamma-verdeling (poisson) dezelfde
+    gemiddelde en variantie heeft als de werkelijke, continue exacte
+    samengestelde verdeling van ``max_fout_exact_continu_SSO``
+    (Beta-Binomiaal resp. Negatief-Binomiaal).
+
+    Achtergrond
+    -----------
+    ``n_klant_k_klant_SSO`` (gebruikt door ``max_fout_benaderd_SSO``)
+    poolt de SSO-steekproef en de klantpopulatie tot één kleinere
+    "as-if"-steekproef. Dat voegt de twee onzekerheidslagen samen
+    (posterior-onzekerheid over de ware foutkans, én
+    steekproefvariabiliteit van die foutkans bij de klant) tot één
+    enkele laag, en levert daardoor zowel een vertekend gemiddelde als
+    een te lage variantie op (zie ``max_fout_exact_continu_SSO`` voor de
+    precieze, continue versie van het exacte tweelagen-model).
+
+    Deze functie kiest in plaats daarvan (n_eff, k_eff) zó dat de
+    Beta(k_eff + 1, n_eff - k_eff + 1)- resp. Gamma(k_eff + 1, schaal=1 /
+    n_eff)-verdeling dezelfde eerste twee momenten heeft als de
+    werkelijke samengestelde verdeling van de foutfractie bij de klant.
+    Dit is bedoeld om als (n_laag, k_laag)-paar te dienen voor
+    ``eval_stratified``, dat zelf intern een Beta- resp.
+    Gamma-verdeling per stratum opbouwt uit (n_laag, k_laag) — zo
+    draagt de gestratificeerde evaluatie zowel het juiste gemiddelde als
+    (voor zover binnen de Beta/Gamma-familie mogelijk) de juiste
+    variantie van de werkelijke tweelagen-onzekerheid.
+
+    Omdat de Beta- en Gamma-familie een beperkte spreiding kunnen
+    weergeven bij een gegeven gemiddelde, kan dit bij een kleine
+    N_klant (t.o.v. de SSO-steekproef) resulteren in een (n_eff, k_eff)
+    buiten het toegestane bereik (k_eff < 0 of k_eff > n_eff). In dat
+    geval wordt geklemd aan de dichtstbijzijnde geldige grens en wordt
+    een ``RuntimeWarning`` afgevuurd.
+
+    Parameters
+    ----------
+    n : int of float
+        Steekproefomvang bij de SSO.
+    k : int of float
+        Aantal fouten in de steekproef bij de SSO.
+    N_klant : int of float
+        Aantal posten bij de klant.
+    verdeling : {"binomiaal", "poisson"}, standaard "binomiaal"
+        Moet overeenkomen met het ``model``-argument waarmee het
+        resulterende (n_eff, k_eff)-paar straks aan ``eval_stratified``
+        wordt doorgegeven.
+
+    Returns
+    -------
+    tuple[float, float]
+        (n_eff, k_eff)
+    """
+    if n <= 0:
+        raise ValueError("n moet groter zijn dan 0.")
+    if N_klant <= 0:
+        raise ValueError("N_klant moet groter zijn dan 0.")
+    if k < 0:
+        raise ValueError("k mag niet negatief zijn.")
+    if k > n:
+        raise ValueError("k mag niet groter zijn dan n.")
+
+    if verdeling == "binomiaal":
+        alpha, beta_ = k + 1, n - k + 1
+        s = alpha + beta_
+        gemiddelde = alpha / s
+        variantie = alpha * beta_ * (s + N_klant) / (s**2 * (s + 1) * N_klant)
+        s_eff = gemiddelde * (1 - gemiddelde) / variantie - 1
+        n_eff = s_eff - 2
+        k_eff = gemiddelde * s_eff - 1
+
+    elif verdeling == "poisson":
+        r = k + 1
+        p_succes = n / (n + N_klant)
+        gemiddelde_aantal = r * (1 - p_succes) / p_succes
+        variantie_aantal = r * (1 - p_succes) / p_succes**2
+        gemiddelde = gemiddelde_aantal / N_klant
+        variantie = variantie_aantal / N_klant**2
+        n_eff = gemiddelde / variantie
+        k_eff = gemiddelde**2 / variantie - 1
+
+    else:
+        raise ValueError("Kies 'binomiaal' of 'poisson'")
+
+    geklemd = False
+    if k_eff < 0:
+        k_eff = 0.0
+        geklemd = True
+    if n_eff < k_eff:
+        n_eff = k_eff
+        geklemd = True
+    if geklemd:
+        warnings.warn(
+            "De werkelijke spreiding van de foutfractie bij de klant kon niet "
+            "exact gekalibreerd worden binnen de Beta/Gamma-familie (N_klant is "
+            "klein t.o.v. de SSO-steekproef n). Het (n_eff, k_eff)-paar is "
+            "geklemd aan de dichtstbijzijnde geldige grens; de resulterende "
+            "gestratificeerde evaluatie onderschat in dit geval mogelijk de "
+            "werkelijke onzekerheid.",
+            RuntimeWarning,
+            stacklevel=2,
+        )
+
+    return n_eff, k_eff

auditstat/sso/n_klant_k_klant_SSO.py

@@ -0,0 +1,38 @@
+def n_klant_k_klant_SSO(n, k, N_klant):
+    """
+    Herleidt een effectieve steekproefomvang (n_klant) en een effectief
+    aantal fouten (k_klant) bij de klant, op basis van een steekproef bij
+    de SSO (n, k) en de omvang van de klantpopulatie (N_klant).
+
+    Dit combineert de bewijskracht van de SSO-steekproef met de omvang
+    van de klantpopulatie tot een enkele, kleinere effectieve steekproef
+    bij de klant zelf (n_klant <= min(n, N_klant)), met k_klant naar rato
+    verdeeld. Dit is dezelfde benadering als gebruikt in
+    max_fout_benaderd_SSO.
+
+    Parameters
+    ----------
+    n : int of float
+        Steekproefomvang bij de SSO.
+    k : int of float
+        Aantal fouten in de steekproef bij de SSO.
+    N_klant : int of float
+        Aantal posten bij de klant.
+
+    Returns
+    -------
+    tuple[float, float]
+        (n_klant, k_klant)
+    """
+    if n <= 0:
+        raise ValueError("n moet groter zijn dan 0.")
+    if N_klant <= 0:
+        raise ValueError("N_klant moet groter zijn dan 0.")
+    if k < 0:
+        raise ValueError("k mag niet negatief zijn.")
+    if k > n:
+        raise ValueError("k mag niet groter zijn dan n.")
+
+    n_klant = (n * N_klant) / (n + N_klant)
+    k_klant = (n_klant / n) * k
+    return n_klant, k_klant