> ## 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.

# Korrelation & Regression

> Pearson-, Spearman-, Kendall-Tau-, partielle Korrelation, punktbiseriale Korrelation, Matrizen, Kovarianz und einfache lineare Regression in kstats-correlation.

`kstats-correlation` deckt zwei verwandte Aufgaben ab: die Stärke des Zusammenhangs zwischen Variablen messen und eine lineare Beziehung modellieren. Das Modul ist in zwei Abschnitte unterteilt, die diese Unterscheidung widerspiegeln.

## Korrelation

### Pearson-Korrelation

Misst die Stärke und Richtung des **linearen** Zusammenhangs zwischen zwei numerischen Variablen. Der Koeffizient reicht von -1 (perfekt negativ) bis +1 (perfekt positiv).

```kotlin theme={"system"}
val x = doubleArrayOf(1.0, 2.0, 3.0, 4.0, 5.0)
val y = doubleArrayOf(2.1, 3.9, 6.2, 7.8, 10.1)

val r = pearsonCorrelation(x, y)
r.coefficient            // 0.9987
r.pValue                 // 0.0001
r.n                      // 5
```

Verwenden Sie Pearson, wenn beide Variablen stetig sind und die Beziehung annähernd linear ist. Empfindlich gegenüber Ausreißern.

### Spearman-Korrelation

Wendet die Pearson-Korrelation auf die **Ränge** der Daten an. Misst monotone Zusammenhänge — ob die Variablen dazu tendieren, gemeinsam zu steigen, unabhängig von der Linearität.

```kotlin theme={"system"}
val x = doubleArrayOf(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0)
val y = doubleArrayOf(2.0, 4.0, 8.0, 16.0, 32.0, 64.0, 128.0, 256.0)

val r = spearmanCorrelation(x, y)
r.coefficient            // 1.0 — perfect monotonic relationship
r.pValue                 // 0.0
```

Verwenden Sie Spearman, wenn die Beziehung monoton, aber nicht zwingend linear ist, oder wenn die Daten Ausreißer enthalten.

### Kendall Tau

Zählt konkordante und diskordante Paare zur Messung der ordinalen Assoziation. Robuster als Spearman bei kleinen Stichproben und vielen Bindungen.

```kotlin theme={"system"}
val x = doubleArrayOf(1.0, 2.0, 3.0, 4.0, 5.0)
val y = doubleArrayOf(1.0, 3.0, 2.0, 5.0, 4.0)

val tau = kendallTau(x, y)
tau.coefficient          // 0.6
tau.pValue               // p-value for tau
```

<Tip>
  Die Kendall-Tau-Implementierung läuft in $O(n \log n)$ Zeit mithilfe eines Merge-Sort-basierten Algorithmus und ist damit auch für große Datensätze effizient.
</Tip>

### Punktbiseriale Korrelation

Misst den Zusammenhang zwischen einer **binären** Variable (kodiert als 0/1 Ganzzahlen) und einer **stetigen** Variable. Entspricht der Pearson-Korrelation, wenn eine Variable dichotom ist.

```kotlin theme={"system"}
val binary     = intArrayOf(0, 0, 0, 1, 1, 1, 1)
val continuous = doubleArrayOf(1.0, 2.0, 1.5, 4.0, 5.0, 4.5, 3.5)

val r = pointBiserialCorrelation(binary, continuous)
r.coefficient            // positive — group 1 has higher values
r.pValue                 // p-value
```

Geeignet, wenn eine Variable von Natur aus binär ist: Behandlung/Kontrolle, bestanden/nicht bestanden, männlich/weiblich.

### Partielle Korrelation

Misst den Zusammenhang zwischen zwei Variablen **nach Kontrolle** einer dritten Variable. Entfernt den Effekt der Störvariablen.

```kotlin theme={"system"}
val x = doubleArrayOf(1.0, 2.0, 3.0, 4.0, 5.0)
val y = doubleArrayOf(2.0, 4.0, 5.0, 4.0, 5.0)
val z = doubleArrayOf(1.0, 1.0, 2.0, 3.0, 3.0)

val r = partialCorrelation(x, y, z)
r.coefficient            // correlation between x and y, controlling for z
r.pValue                 // p-value
```

Verwenden Sie sie, wenn eine dritte Variable den scheinbaren Zusammenhang zwischen den ersten beiden erklären könnte.

### Korrelations- und Kovarianzmatrizen

Für die Analyse mehrerer Variablen können paarweise Matrizen erstellt werden. Jede Zelle $(i, j)$ enthält die Korrelation (oder Kovarianz) zwischen den Variablen $i$ und $j$.

```kotlin theme={"system"}
val x = doubleArrayOf(1.0, 2.0, 3.0, 4.0, 5.0)
val y = doubleArrayOf(2.1, 3.9, 6.2, 7.8, 10.1)
val z = doubleArrayOf(5.0, 4.0, 3.0, 2.0, 1.0)

val corr = correlationMatrix(x, y, z)
corr[0][1]               // Pearson r between x and y ≈ 0.9987
corr[0][2]               // Pearson r between x and z = -1.0

val cov = covarianceMatrix(x, y, z)
cov[0][0]                // variance of x = 2.5
cov[0][1]                // covariance of x and y
```

### Wahl der Korrelationsmethode

| Anwendungsfall                                                  | Funktion                                    |
| --------------------------------------------------------------- | ------------------------------------------- |
| Linearer Zusammenhang zwischen zwei numerischen Variablen       | `pearsonCorrelation()`                      |
| Monotoner Zusammenhang, robust gegenüber Ausreißern             | `spearmanCorrelation()`                     |
| Ordinaler Zusammenhang mit expliziter Bindungsbehandlung        | `kendallTau()`                              |
| Binäre vs. stetige Variable                                     | `pointBiserialCorrelation()`                |
| Zusammenhang nach Entfernung des Effekts einer dritten Variable | `partialCorrelation()`                      |
| Paarweise Zusammenfassungen für viele Variablen                 | `correlationMatrix()`, `covarianceMatrix()` |

<Accordion title="Mathematische Details">
  **Pearson:**

  $$
  r = \frac{\sum_i (x_i - \bar{x})(y_i - \bar{y})}{\sqrt{\sum_i (x_i - \bar{x})^2 \sum_i (y_i - \bar{y})^2}}
  $$

  **Spearman:** Pearson-Korrelation angewandt auf Ränge.

  **Kendall tau-b:**

  $$
  \tau_b = \frac{C - D}{\sqrt{(C + D + T_X)(C + D + T_Y)}}
  $$

  wobei $C$ = konkordante Paare, $D$ = diskordante Paare, $T_X$ = nur auf X gebundene Paare, $T_Y$ = nur auf Y gebundene Paare.

  **Partielle Korrelation:**

  $$
  r_{xy \cdot z} = \frac{r_{xy} - r_{xz} \cdot r_{yz}}{\sqrt{(1 - r_{xz}^2)(1 - r_{yz}^2)}}
  $$
</Accordion>

## Regression

### Einfache lineare Regression

Passt die Gerade $\hat{y} = \beta_0 + \beta_1 x$ mittels gewöhnlicher kleinster Quadrate an die Daten an. Das Ergebnis umfasst Steigung, Achsenabschnitt, Bestimmtheitsmaß ($R^2$), Standardfehler, Residuen und eine Vorhersagefunktion.

```kotlin theme={"system"}
val x = doubleArrayOf(1.0, 2.0, 3.0, 4.0, 5.0)
val y = doubleArrayOf(2.1, 3.9, 6.2, 7.8, 10.1)

val model = simpleLinearRegression(x, y)
model.slope                  // 1.99
model.intercept              // 0.06
model.rSquared               // 0.9973
model.standardErrorSlope     // standard error of the slope estimate
model.standardErrorIntercept // standard error of the intercept estimate
model.n                      // 5
model.residuals              // [0.05, -0.07, 0.15, -0.17, 0.05]

// Prediction
model.predict(6.0)           // 11.99
model.predict(doubleArrayOf(6.0, 7.0, 8.0)) // batch prediction
```

<Accordion title="Mathematische Details">
  $$
  \hat{\beta}_1 = \frac{\sum_i (x_i - \bar{x})(y_i - \bar{y})}{\sum_i (x_i - \bar{x})^2}, \qquad
  \hat{\beta}_0 = \bar{y} - \hat{\beta}_1 \bar{x}
  $$

  $$
  R^2 = 1 - \frac{\sum_i (y_i - \hat{y}_i)^2}{\sum_i (y_i - \bar{y})^2}
  $$
</Accordion>

## API-Referenz

<Card title="Vollständige API-Referenz" icon="book-open" href="https://oremif.github.io/kstats">
  Alle Korrelationsfunktionen, Ergebnistypen und Parameterüberladungen in der Dokka-generierten Referenz durchsuchen.
</Card>