Wahrscheinlichkeitsverteilungen

kstats-distributions bietet eine einheitliche API für stetige und diskrete Wahrscheinlichkeitsmodelle. Jede Verteilung unterstützt denselben Arbeitsablauf: Konstruktion mit Parametern, Abfrage statistischer Eigenschaften, Auswertung von Wahrscheinlichkeiten, Berechnung von Quantilen und Ziehung von Zufallsstichproben.

Arbeiten mit einer Verteilung

val normal = NormalDistribution(mu = 0.0, sigma = 1.0)

// Statistical properties
normal.mean                  // 0.0
normal.variance              // 1.0
normal.standardDeviation     // 1.0
normal.skewness              // 0.0
normal.kurtosis              // 0.0
normal.entropy               // 1.4189

// Evaluate
normal.pdf(0.0)              // 0.3989 — density at x = 0
normal.cdf(1.96)             // 0.9750 — P(X ≤ 1.96)
normal.sf(1.96)              // 0.0250 — P(X > 1.96) = 1 - cdf

// Invert
normal.quantile(0.975)       // 1.9600 — value at the 97.5th percentile

// Sample
normal.sample(Random(42))           // single random draw
normal.sample(5, Random(42))        // 5 random draws

Gemeinsame API

Jede Verteilung implementiert gemeinsame statistische Eigenschaften: mean, variance, standardDeviation, skewness, kurtosis und entropy. Die Auswertungsmethoden unterscheiden sich zwischen stetigen und diskreten Verteilungen:

Operation	Stetig	Diskret
Punktwert	`pdf(x)` — Dichte	`pmf(k)` — exakte Wahrscheinlichkeit
Log-Punktwert	`logPdf(x)`	`logPmf(k)`
Kumulativ	`cdf(x)` — $P(X \le x)$	`cdf(k)` — $P(X \le k)$
Oberer Rand	`sf(x)` — $P(X > x)$	`sf(k)` — $P(X > k)$
Quantil	`quantile(p)` → `Double`	`quantileInt(p)` → `Int`
Stichprobe	`sample(random)` → `Double`	`sample(random)` → `Int`
Batch-Stichprobe	`sample(n, random)` → `DoubleArray`	`sample(n, random)` → `IntArray`

Konstruktoren validieren Parameter sofort. Ungültige Werte (negative Standardabweichung, Wahrscheinlichkeit außerhalb von [0, 1], nicht-positive Freiheitsgrade) lösen bereits bei der Konstruktion eine InvalidParameterException aus, nicht erst bei der Auswertung.

Stetige Verteilungen

Symmetrisch / Allgemein
Positiv reellwertig
Beschränkt
Extremwert / Schwere Ränder

NormalDistribution(mu, sigma)

Die Gaußverteilung. Modelliert Daten, die symmetrisch um einen Mittelwert gruppiert sind, mit einer charakteristischen Glockenkurve.Parameter: mu — Mittelwert, sigma — Standardabweichung (muss positiv sein)

val d = NormalDistribution(mu = 100.0, sigma = 15.0)
d.mean       // 100.0
d.cdf(115.0) // 0.8413
d.quantile(0.975) // 129.3994

Verwenden, wenn Daten annähernd symmetrisch und unbeschränkt sind.

StudentTDistribution(degreesOfFreedom)

Schwerere Ränder als die Normalverteilung. Nähert sich der Normalverteilung bei steigenden Freiheitsgraden an.Parameter: df — Freiheitsgrade (muss positiv sein)

val d = StudentTDistribution(degreesOfFreedom = 10.0)
d.mean       // 0.0
d.cdf(2.228) // ≈ 0.975
d.quantile(0.975) // 2.2281

Verwenden für Konfidenzintervalle und t-Tests bei kleinem Stichprobenumfang.

LogisticDistribution(mu, scale)

Ähnliche Form wie die Normalverteilung, jedoch mit schwereren Rändern. Die CDF hat eine geschlossene logistische Funktion.Parameter: location — Zentrum, scale — Skalenparameter (muss positiv sein)

val d = LogisticDistribution(mu = 0.0, scale = 1.0)
d.mean       // 0.0
d.cdf(0.0)   // 0.5
d.pdf(0.0)   // 0.25

Verwenden, wenn eine geschlossene CDF benötigt wird oder die Daten etwas schwerere Ränder als die Normalverteilung aufweisen.

CauchyDistribution(location, scale)

Extrem schwere Ränder. Mittelwert und Varianz sind undefiniert.Parameter: location — Zentrum (Median), scale — Halbwertsbreite bei halber Maximalhöhe (muss positiv sein)

val d = CauchyDistribution(location = 0.0, scale = 1.0)
d.pdf(0.0)        // 0.3183
d.cdf(0.0)        // 0.5
d.quantile(0.75)  // 1.0

Verwenden bei Daten mit extremen Ausreißern, bei denen der Mittelwert keine aussagekräftige Zusammenfassung ist.

LaplaceDistribution(mu, scale)

Doppel-Exponentialverteilung. Schärfere Spitze und schwerere Ränder als die Normalverteilung.Parameter: location — Zentrum (Mittelwert und Median), scale — Skalenparameter (muss positiv sein)

val d = LaplaceDistribution(mu = 0.0, scale = 1.0)
d.mean       // 0.0
d.variance   // 2.0
d.pdf(0.0)   // 0.5

Verwenden bei Daten mit einer scharfen Spitze im Zentrum und exponentiellen Rändern.

ExponentialDistribution(rate)

Modelliert die Zeit zwischen Ereignissen in einem Poisson-Prozess. Gedächtnislosigkeit.Parameter: rate — Ereignisrate, der Kehrwert des Mittelwerts (muss positiv sein)

val d = ExponentialDistribution(rate = 2.0)
d.mean       // 0.5
d.cdf(1.0)   // 0.8647
d.quantile(0.5) // 0.3466

Verwenden für Wartezeiten, Dauern und Zwischenankunftszeiten.

GammaDistribution(shape, rate)

Verallgemeinert die Exponentialverteilung. Modelliert die Summe unabhängiger exponentialverteilter Zufallsvariablen.Parameter: shape — Formparameter

k

(muss positiv sein), scale — Skalenparameter

\theta

(muss positiv sein)

val d = GammaDistribution(shape = 2.0, rate = 0.5)
d.mean       // 4.0
d.variance   // 8.0
d.cdf(4.0)   // 0.5940

Verwenden für positive stetige Daten mit Rechtsschiefe, etwa aggregierte Wartezeiten oder Niederschlagsmengen.

WeibullDistribution(shape, scale)

Flexible Verteilung für Zuverlässigkeits- und Überlebensanalysen.Parameter: shape — Form

k

(muss positiv sein), scale — Skala

\lambda

(muss positiv sein)

val d = WeibullDistribution(shape = 1.5, scale = 1.0)
d.mean       // 0.9027
d.cdf(1.0)   // 0.6321

Verwenden für Ausfallzeitdaten, Windgeschwindigkeitsmodellierung und Überlebensanalysen.

LogNormalDistribution(mu, sigma)

Der Logarithmus der Variablen ist normalverteilt. Stets positiv, rechtsschief.Parameter: mu — Mittelwert des Logarithmus, sigma — Standardabweichung des Logarithmus (muss positiv sein)

val d = LogNormalDistribution(mu = 0.0, sigma = 1.0)
d.mean          // 1.6487
d.quantile(0.5) // 1.0
d.cdf(1.0)      // 0.5

Verwenden für multiplikative Prozesse: Aktienkurse, biologische Messungen, Dateigrößen.

NakagamiDistribution(mu, omega)

Modelliert die Amplitude von Mehrwege-Fading in der drahtlosen Kommunikation.Parameter: shape — Form

m \ge 0{,}5

, spread — Streuung

\Omega

(muss positiv sein)

val d = NakagamiDistribution(mu = 1.0, omega = 1.0)
d.mean       // 0.8862
d.variance   // 0.2146

Verwenden für die Modellierung von Signalhüllkurven in Schwundkanälen.

LevyDistribution(mu, c)

Verteilung mit schweren Rändern und unendlichem Mittelwert. Ein Spezialfall der stabilen Verteilung.Parameter: location — Verschiebungsparameter, scale — Skalenparameter (muss positiv sein)

val d = LevyDistribution(mu = 0.0, c = 1.0)
d.cdf(1.0)   // 0.3173
d.sf(1.0)    // 0.6827

Verwenden für Extremwertmodellierung mit sehr schweren rechten Rändern.

BetaDistribution(alpha, beta)

Definiert auf [0, 1]. Flexible Form, gesteuert durch zwei Parameter.Parameter: alpha — Form

\alpha

(muss positiv sein), beta — Form

\beta

(muss positiv sein)

val d = BetaDistribution(alpha = 2.0, beta = 5.0)
d.mean       // 0.2857
d.cdf(0.3)   // 0.5798
d.pdf(0.2)   // 2.4576

Verwenden für Anteile, Wahrscheinlichkeiten und beschränkte Daten auf [0, 1].

UniformDistribution(min, max)

Gleiche Wahrscheinlichkeit über das Intervall [a, b].Parameter: a — untere Grenze, b — obere Grenze (es muss a < b gelten)

val d = UniformDistribution(min = 0.0, max = 10.0)
d.mean       // 5.0
d.variance   // 8.3333
d.cdf(3.0)   // 0.3

Verwenden, wenn alle Werte in einem Bereich gleich wahrscheinlich sind.

TriangularDistribution(a, b, c)

Beschränkte Verteilung mit Spitze am Modus. Definiert durch Minimum, Maximum und Modus.Parameter: a — Minimum, b — Maximum, c — Modus (es muss a ≤ c ≤ b gelten)

val d = TriangularDistribution(a = 0.0, b = 10.0, c = 3.0)
d.mean       // 4.3333
d.cdf(3.0)   // 0.3

Verwenden für grobe Schätzungen, wenn nur Minimum, Maximum und wahrscheinlichster Wert bekannt sind.

ParetoDistribution(shape, scale)

Potenzgesetzverteilung. Modelliert Phänomene, bei denen ein kleiner Anteil der Werte einen großen Teil des Gesamtbetrags ausmacht.Parameter: xm — Minimalwert (Skala, muss positiv sein), alpha — Form (Randindex, muss positiv sein)

val d = ParetoDistribution(shape = 2.0, scale = 1.0)
d.mean       // 2.0
d.cdf(2.0)   // 0.75

Verwenden für Vermögensverteilungen, Stadtgrößen und Dateigrößen.

GumbelDistribution(mu, beta)

Extremwertverteilung (Typ I). Modelliert das Maximum einer Stichprobe aus vielen Verteilungen.Parameter: location — Modus, scale — Streuung (muss positiv sein)

val d = GumbelDistribution(mu = 0.0, beta = 1.0)
d.mean       // 0.5772
d.cdf(0.0)   // 0.3679

Verwenden für Extremwertanalysen: Höchsttemperaturen, Hochwasserstände, strukturelle Belastungen.

ChiSquaredDistribution(degreesOfFreedom)

Die Verteilung der Summe der Quadrate standardnormalverteilter Zufallsvariablen. Zentral für Chi-Quadrat-Tests und Konfidenzintervalle für die Varianz.Parameter: df — Freiheitsgrade (muss positiv sein)

val d = ChiSquaredDistribution(degreesOfFreedom = 5.0)
d.mean       // 5.0
d.variance   // 10.0
d.cdf(11.07) // ≈ 0.95

Intern für Chi-Quadrat-Tests oder direkte Varianzinferenz verwenden.

FDistribution(dfNumerator, dfDenominator)

Verhältnis zweier Chi-Quadrat-Variablen dividiert durch ihre Freiheitsgrade. Zentral für F-Tests und ANOVA.Parameter: df1 — Zähler-Freiheitsgrade (muss positiv sein), df2 — Nenner-Freiheitsgrade (muss positiv sein)

val d = FDistribution(dfNumerator = 5.0, dfDenominator = 10.0)
d.mean       // 1.25
d.cdf(3.33)  // ≈ 0.95

Intern für ANOVA und F-Tests verwenden.

Diskrete Verteilungen

Zählung / Ereignis
Sampling / Zusammengesetzt
Einfach / Gleichverteilt
Schwere Ränder / Rang

PoissonDistribution(rate)

Modelliert die Anzahl von Ereignissen in einem festen Intervall, wenn Ereignisse unabhängig mit konstanter Rate auftreten.Parameter: lambda — erwartete Anzahl der Ereignisse (muss positiv sein)

val d = PoissonDistribution(rate = 3.0)
d.mean          // 3.0
d.pmf(5)        // 0.1008
d.cdf(5)        // 0.9161
d.quantileInt(0.95) // 6

Verwenden für Zähldaten: Defekte pro Charge, Ankünfte pro Stunde, Ereignisse pro Tag.

BinomialDistribution(trials, probability)

Modelliert die Anzahl der Erfolge in einer festen Anzahl unabhängiger Bernoulli-Versuche.Parameter: trials — Anzahl der Versuche (muss nicht-negativ sein), probability — Erfolgswahrscheinlichkeit pro Versuch (muss in [0, 1] liegen)

val d = BinomialDistribution(trials = 10, probability = 0.3)
d.mean          // 3.0
d.pmf(3)        // 0.2668
d.cdf(3)        // 0.6496
d.quantileInt(0.5) // 3

Verwenden für Ja/Nein-Experimente, die eine bekannte Anzahl von Malen wiederholt werden.

NegativeBinomialDistribution(successes, probability)

Modelliert die Anzahl der Misserfolge vor Erreichen einer bestimmten Anzahl von Erfolgen.Parameter: r — Anzahl der Erfolge (muss positiv sein), p — Erfolgswahrscheinlichkeit (muss in (0, 1] liegen)

val d = NegativeBinomialDistribution(successes = 5, probability = 0.5)
d.mean          // 5.0
d.variance      // 10.0
d.pmf(3)        // probability of exactly 3 failures before 5 successes

Verwenden für überdisperse Zähldaten oder zur Modellierung der Versuchsanzahl bis zum Erreichen eines Ziels.

GeometricDistribution(probability)

Modelliert die Anzahl der Versuche bis zum ersten Erfolg. Ein Spezialfall der negativen Binomialverteilung.Parameter: probability — Erfolgswahrscheinlichkeit pro Versuch (muss in (0, 1] liegen)

val d = GeometricDistribution(probability = 0.3)
d.mean          // 3.3333
d.pmf(1)        // 0.3
d.cdf(3)        // 0.657

Verwenden für Fragen der Art „wie viele Versuche bis zum Erfolg”.

HypergeometricDistribution(population, successes, draws)

Modelliert die Anzahl der Erfolge bei Ziehungen ohne Zurücklegen aus einer endlichen Grundgesamtheit.Parameter: populationSize — Gesamtpopulation, successStates — Anzahl der Erfolgselemente, trials — Anzahl der Ziehungen

val d = HypergeometricDistribution(population = 50, successes = 10, draws = 5)
d.mean          // 1.0
d.pmf(2)        // probability of exactly 2 successes in 5 draws

Verwenden, wenn Ziehen ohne Zurücklegen relevant ist: Qualitätskontrolle, Kartenspiele, Lotterieprobleme.

BetaBinomialDistribution(trials, alpha, beta)

Zusammengesetzte Verteilung, bei der die Erfolgswahrscheinlichkeit einer Beta-Verteilung folgt. Höhere Varianz als eine Standard-Binomialverteilung.Parameter: trials — Anzahl der Versuche, alpha — Beta-Formparameter, beta — Beta-Formparameter

val d = BetaBinomialDistribution(trials = 10, alpha = 2.0, beta = 3.0)
d.mean          // 4.0
d.pmf(4)        // probability of exactly 4 successes

Verwenden für überdisperse Binomialdaten, bei denen die Erfolgswahrscheinlichkeit variiert.

BernoulliDistribution(probability)

Ein einzelner Versuch mit zwei Ergebnissen: Erfolg (1) oder Misserfolg (0). Die einfachste diskrete Verteilung.Parameter: probability — Erfolgswahrscheinlichkeit (muss in [0, 1] liegen)

val d = BernoulliDistribution(probability = 0.7)
d.mean          // 0.7
d.pmf(1)        // 0.7
d.pmf(0)        // 0.3

Verwenden für Münzwurf-ähnliche binäre Ergebnisse.

UniformDiscreteDistribution(min, max)

Gleiche Wahrscheinlichkeit für jede ganze Zahl in [a, b].Parameter: a — untere Grenze, b — obere Grenze (es muss a ≤ b gelten)

val d = UniformDiscreteDistribution(min = 1, max = 6)
d.mean          // 3.5
d.pmf(3)        // 0.1667
d.cdf(3)        // 0.5

Verwenden für faire Würfel und gleichverteilte ganzzahlige Zufallsauswahl.

ZipfDistribution(numberOfElements, exponent)

Potenzgesetzverteilung über die Ränge 1 bis n. Die Häufigkeit ist umgekehrt proportional zum Rang.Parameter: n — Anzahl der Elemente (muss positiv sein), s — Exponent (muss positiv sein)

val d = ZipfDistribution(numberOfElements = 100, exponent = 1.0)
d.pmf(1)        // probability of rank 1 (the most common)
d.pmf(100)      // probability of rank 100 (the least common)

Verwenden für Worthäufigkeiten, Stadtgrößen und Website-Traffic-Verteilungen.

LogarithmicDistribution(probability)

Auch als logarithmische Reihenverteilung bekannt. Modelliert die Anzahl der Arten mit einer bestimmten Abundanz.Parameter: p — Parameter in (0, 1)

val d = LogarithmicDistribution(probability = 0.5)
d.mean          // 1.4427
d.pmf(1)        // 0.7213
d.pmf(2)        // 0.1803

Verwenden für Artenabundanzdaten und ähnliche langschwänzige Zählverteilungen.

Auswahl einer Verteilung

Im Zweifelsfall beginnen Sie mit NormalDistribution für stetige Daten und PoissonDistribution für Zähldaten. Diese sind die gängigsten Standardverteilungen und dienen als vernünftige Ausgangspunkte.

Datenform	Empfohlener Ausgangspunkt
Symmetrische reellwertige Daten	`NormalDistribution`, `StudentTDistribution`, `LogisticDistribution`
Positive reellwertige Daten	`ExponentialDistribution`, `GammaDistribution`, `WeibullDistribution`, `LogNormalDistribution`
Daten beschränkt auf [0, 1]	`BetaDistribution`
Beschränkt auf ein bekanntes Intervall	`UniformDistribution`, `TriangularDistribution`
Zähldaten und Ereignissummen	`PoissonDistribution`, `BinomialDistribution`, `NegativeBinomialDistribution`
Zähldaten ohne Zurücklegen	`HypergeometricDistribution`
Daten mit schweren Rändern	`CauchyDistribution`, `ParetoDistribution`, `LevyDistribution`
Rang-Häufigkeits-Daten	`ZipfDistribution`, `LogarithmicDistribution`

API-Referenz

Vollständige API-Referenz

Durchsuchen Sie alle Verteilungskonstruktoren, Methoden und Eigenschaften in der Dokka-generierten Referenz.

Getting Started

Module

Wahrscheinlichkeitsverteilungen

Arbeiten mit einer Verteilung

Gemeinsame API

Stetige Verteilungen

Diskrete Verteilungen

Auswahl einer Verteilung

API-Referenz

Vollständige API-Referenz

​Arbeiten mit einer Verteilung

​Gemeinsame API

​Stetige Verteilungen

​Diskrete Verteilungen

​Auswahl einer Verteilung

​API-Referenz

Vollständige API-Referenz

Arbeiten mit einer Verteilung

Gemeinsame API

Stetige Verteilungen

Diskrete Verteilungen

Auswahl einer Verteilung

API-Referenz