> ## Documentation Index
> Fetch the complete documentation index at: https://kstats.oremif.org/llms.txt
> Use this file to discover all available pages before exploring further.

# Verteilung auswählen

> Ordnen Sie Ihre Daten der richtigen Wahrscheinlichkeitsverteilung zu — mit praxisnahen Beispielen und Verifikation.

{/*---IMPORT org.oremif.kstats.hypothesis.samples.DocsSamples--*/}

<Card title="Kotlin Notebook" icon="notebook" href="https://github.com/Oremif/kstats/blob/master/samples/choosing-a-distribution.ipynb">
  Probieren Sie diesen Leitfaden als Kotlin Notebook mit Kandy-Visualisierungen aus — führen Sie die Zellen aus, um Diagramme zu sehen und die Daten interaktiv zu erkunden.
</Card>

Jede Verteilung kodiert Annahmen darüber, welche Werte möglich sind und wie wahrscheinlich sie auftreten. Dieser Leitfaden gruppiert Verteilungen nach der Art der modellierten Daten und zeigt, wie Sie die Anpassungsgüte überprüfen.

## Entscheidungstabelle

| Datentyp                                        | Beispieldomäne                                   | Verteilung                     | Konstruktor                                            |
| ----------------------------------------------- | ------------------------------------------------ | ------------------------------ | ------------------------------------------------------ |
| Symmetrische Messungen um einen Mittelwert      | Sitzungsdauer von Nutzern                        | `NormalDistribution`           | `NormalDistribution(mu, sigma)`                        |
| Schwerere Ränder als Normal, kleine Stichproben | Geschätzte Mittelwerte mit wenigen Beobachtungen | `StudentTDistribution`         | `StudentTDistribution(degreesOfFreedom)`               |
| Positive Wartezeiten oder Dauern                | Zeit zwischen Server-Fehlern                     | `ExponentialDistribution`      | `ExponentialDistribution(rate)`                        |
| Positive Dauern mit Verschleißmuster            | Lebensdauer von Hardware-Komponenten             | `WeibullDistribution`          | `WeibullDistribution(shape, scale)`                    |
| Rechtsschief verteilte positive Werte           | API-Antwortzeiten                                | `LogNormalDistribution`        | `LogNormalDistribution(mu, sigma)`                     |
| Anteile oder Raten in \[0, 1]                   | Klickrate                                        | `BetaDistribution`             | `BetaDistribution(alpha, beta)`                        |
| Ereigniszählungen pro Intervall                 | Fehler pro Stunde                                | `PoissonDistribution`          | `PoissonDistribution(rate)`                            |
| Erfolge bei fester Anzahl von Versuchen         | Konversionen aus Seitenaufrufen                  | `BinomialDistribution`         | `BinomialDistribution(trials, probability)`            |
| Überdispergierte Zählungen                      | Support-Tickets pro Tag                          | `NegativeBinomialDistribution` | `NegativeBinomialDistribution(successes, probability)` |
| Starker rechter Rand bei positiven Daten        | Einkommensverteilung, Dateigrößen                | `ParetoDistribution`           | `ParetoDistribution(shape, scale)`                     |

## Dauern und Wartezeiten

<Tabs>
  <Tab title="Antwortzeiten">
    ```kotlin theme={"system"}
    // API response times — often right-skewed with a long tail
    val responseTime = LogNormalDistribution(mu = 4.5, sigma = 0.8)

    responseTime.mean              // expected average in ms
    responseTime.quantile(0.95)    // P95 latency
    responseTime.quantile(0.99)    // P99 latency
    responseTime.cdf(200.0)        // probability of responding under 200ms
    ```
  </Tab>

  <Tab title="Zeit zwischen Ereignissen">
    ```kotlin theme={"system"}
    // Time between server errors — memoryless waiting process
    val timeBetweenErrors = ExponentialDistribution(rate = 0.5)

    timeBetweenErrors.mean          // average time between errors
    timeBetweenErrors.sf(10.0)      // probability of waiting longer than 10 units
    timeBetweenErrors.quantile(0.5) // median waiting time
    ```
  </Tab>

  <Tab title="Komponentenlebensdauer">
    ```kotlin theme={"system"}
    // Hardware component lifetime — models wear-out (shape > 1) or burn-in (shape < 1)
    val componentLifetime = WeibullDistribution(shape = 2.0, scale = 5000.0)

    componentLifetime.quantile(0.1)  // 10% of components fail before this time
    componentLifetime.cdf(3000.0)    // probability of failure before 3000 hours
    componentLifetime.sf(4000.0)     // probability of surviving past 4000 hours
    ```
  </Tab>
</Tabs>

## Zählungen und Ereignisse

<Tabs>
  <Tab title="Ereigniszählungen">
    ```kotlin theme={"system"}
    // Errors per hour on a production server
    val errorsPerHour = PoissonDistribution(rate = 3.2)

    errorsPerHour.pmf(0)            // probability of zero errors
    errorsPerHour.cdf(5)            // probability of at most 5 errors
    errorsPerHour.quantileInt(0.99) // error count exceeded only 1% of the time
    ```
  </Tab>

  <Tab title="Feste Versuchsanzahl">
    ```kotlin theme={"system"}
    // Conversions out of 1000 page views with 3.5% conversion rate
    val conversions = BinomialDistribution(trials = 1000, probability = 0.035)

    conversions.mean    // expected number of conversions
    conversions.pmf(40) // probability of exactly 40 conversions
    conversions.sf(50)  // probability of more than 50 conversions
    ```
  </Tab>

  <Tab title="Überdispergierte Zählungen">
    ```kotlin theme={"system"}
    // Support tickets until 5th resolution (variance > mean)
    val tickets = NegativeBinomialDistribution(successes = 5, probability = 0.1)

    tickets.mean     // expected ticket count
    tickets.variance // larger than mean — overdispersion
    ```
  </Tab>
</Tabs>

## Anteile und Raten

```kotlin theme={"system"}
// Click-through rate estimated from 120 clicks in 4000 impressions
val ctr = BetaDistribution(alpha = 120.0, beta = 3880.0)

ctr.mean            // point estimate of CTR
ctr.quantile(0.025) // lower bound of 95% credible interval
ctr.quantile(0.975) // upper bound
ctr.cdf(0.035)      // probability that true CTR is below 3.5%
```

## Allgemeine symmetrische Verteilungen

```kotlin theme={"system"}
// User session duration in minutes (roughly symmetric)
val sessionDuration = NormalDistribution(mu = 12.5, sigma = 3.2)

sessionDuration.cdf(15.0)      // probability of session under 15 min
sessionDuration.quantile(0.95) // 95th percentile

// Small-sample estimate — heavier tails give more conservative intervals
val smallSampleEstimate = StudentTDistribution(degreesOfFreedom = 8.0)
smallSampleEstimate.quantile(0.975) // critical value for 95% CI
```

## Anpassungsgüte überprüfen

Vergleichen Sie nach der Wahl einer Verteilung diese mit den beobachteten Daten mithilfe des Kolmogorov-Smirnov-Tests.

```kotlin theme={"system"}
val processingTimesMs = doubleArrayOf(
    45.2, 51.8, 48.1, 52.3, 47.6, 49.9, 53.1, 46.5, 50.7, 48.8,
    51.2, 47.3, 49.1, 52.8, 46.9, 50.3, 48.5, 51.6, 47.8, 49.4
)

// Fit a Normal from sample statistics
val fitted = NormalDistribution(
    mu = processingTimesMs.mean(),
    sigma = processingTimesMs.standardDeviation()
)

val ks = kolmogorovSmirnovTest(processingTimesMs, fitted)
ks.statistic // KS statistic — smaller means better fit
ks.pValue    // high p-value means data does not contradict the distribution
```

<Note>
  Ein nicht-signifikanter KS-Test beweist nicht, dass die Verteilung korrekt ist — er bedeutet lediglich, dass die Daten dieser Wahl nicht stark widersprechen.
</Note>