Statistics

std(itr; corrected::Bool=true, mean=nothing[, dims])

Berechne die Stichprobenstandardabweichung der Sammlung itr.

Der Algorithmus gibt einen Schätzer der Standardabweichung der generativen Verteilung zurück, unter der Annahme, dass jeder Eintrag von itr eine Stichprobe aus derselben unbekannten Verteilung ist, wobei die Stichproben unkorreliert sind. Für Arrays entspricht diese Berechnung der Berechnung von sqrt(sum((itr .- mean(itr)).^2) / (length(itr) - 1)). Wenn corrected true ist, wird die Summe mit n-1 skaliert, während die Summe mit n skaliert wird, wenn corrected false ist, wobei n die Anzahl der Elemente in itr ist.

Wenn itr ein AbstractArray ist, können dims angegeben werden, um die Standardabweichung über Dimensionen zu berechnen.

Ein vorab berechneter mean kann bereitgestellt werden. Wenn dims angegeben ist, muss mean ein Array mit derselben Form wie mean(itr, dims=dims) sein (zusätzliche nachfolgende Singleton-Dimensionen sind erlaubt).

!!! Hinweis Wenn das Array NaN oder missing Werte enthält, ist das Ergebnis ebenfalls NaN oder missing (missing hat Vorrang, wenn das Array beide enthält). Verwenden Sie die Funktion skipmissing, um missing-Einträge zu überspringen und die Standardabweichung der nicht fehlenden Werte zu berechnen.

stdm(itr, mean; corrected::Bool=true[, dims])

Berechne die Stichprobenstandardabweichung der Sammlung itr, mit bekannten Mittelwert(en) mean.

Der Algorithmus gibt einen Schätzer der Standardabweichung der generativen Verteilung zurück, unter der Annahme, dass jeder Eintrag von itr eine Stichprobe aus derselben unbekannten Verteilung ist, wobei die Stichproben unkorreliert sind. Für Arrays entspricht diese Berechnung der Berechnung von sqrt(sum((itr .- mean(itr)).^2) / (length(itr) - 1)). Wenn corrected true ist, wird die Summe mit n-1 skaliert, während die Summe mit n skaliert wird, wenn corrected false ist, wobei n die Anzahl der Elemente in itr ist.

Wenn itr ein AbstractArray ist, können dims angegeben werden, um die Standardabweichung über Dimensionen zu berechnen. In diesem Fall muss mean ein Array mit derselben Form wie mean(itr, dims=dims) sein (zusätzliche nachfolgende Singleton-Dimensionen sind erlaubt).

```

var(itr; corrected::Bool=true, mean=nothing[, dims])

Berechne die Stichprobenvarianz der Sammlung itr.

Der Algorithmus gibt einen Schätzer der Varianz der generativen Verteilung zurück, unter der Annahme, dass jeder Eintrag von itr eine Stichprobe ist, die aus derselben unbekannten Verteilung gezogen wurde, wobei die Stichproben unkorreliert sind. Für Arrays entspricht diese Berechnung sum((itr .- mean(itr)).^2) / (length(itr) - 1). Wenn corrected true ist, wird die Summe mit n-1 skaliert, während die Summe mit n skaliert wird, wenn corrected false ist, wobei n die Anzahl der Elemente in itr ist.

Wenn itr ein AbstractArray ist, können dims angegeben werden, um die Varianz über Dimensionen zu berechnen.

Ein vorab berechneter mean kann bereitgestellt werden. Wenn dims angegeben ist, muss mean ein Array mit derselben Form wie mean(itr, dims=dims) sein (zusätzliche nachfolgende Singleton-Dimensionen sind erlaubt).

varm(itr, mean; dims, corrected::Bool=true)

Berechne die Stichprobenvarianz der Sammlung itr, mit bekannten Mittelwert(en) mean.

Der Algorithmus gibt einen Schätzer der Varianz der generativen Verteilung zurück, unter der Annahme, dass jeder Eintrag von itr eine Stichprobe aus derselben unbekannten Verteilung ist, wobei die Stichproben unkorreliert sind. Für Arrays entspricht diese Berechnung sum((itr .- mean(itr)).^2) / (length(itr) - 1). Wenn corrected true ist, wird die Summe mit n-1 skaliert, während die Summe mit n skaliert wird, wenn corrected false ist, wobei n die Anzahl der Elemente in itr ist.

Wenn itr ein AbstractArray ist, können dims angegeben werden, um die Varianz über Dimensionen zu berechnen. In diesem Fall muss mean ein Array mit derselben Form wie mean(itr, dims=dims) sein (zusätzliche nachfolgende Singleton-Dimensionen sind erlaubt).

!!! Hinweis Wenn das Array NaN oder missing Werte enthält, ist das Ergebnis ebenfalls NaN oder missing (missing hat Vorrang, wenn das Array beide enthält). Verwenden Sie die Funktion skipmissing, um missing-Einträge zu überspringen und die Varianz der nicht fehlenden Werte zu berechnen.

cor(x::AbstractVector)

Return the number one.

cor(X::AbstractMatrix; dims::Int=1)

Berechne die Pearson-Korrelationsmatrix der Matrix X entlang der Dimension dims.

cor(x::AbstractVector, y::AbstractVector)

Berechne die Pearson-Korrelation zwischen den Vektoren x und y.

cor(X::AbstractVecOrMat, Y::AbstractVecOrMat; dims=1)

Berechne die Pearson-Korrelation zwischen den Vektoren oder Matrizen X und Y entlang der Dimension dims.

cov(x::AbstractVector; corrected::Bool=true)

Berechne die Varianz des Vektors x. Wenn corrected true ist (der Standardwert), wird die Summe mit n-1 skaliert, während die Summe mit n skaliert wird, wenn corrected false ist, wobei n = length(x) ist.

cov(X::AbstractMatrix; dims::Int=1, corrected::Bool=true)

Berechne die Kovarianzmatrix der Matrix X entlang der Dimension dims. Wenn corrected true ist (der Standardwert), wird die Summe mit n-1 skaliert, während die Summe mit n skaliert wird, wenn corrected false ist, wobei n = size(X, dims) ist.

cov(x::AbstractVector, y::AbstractVector; corrected::Bool=true)

Berechnet die Kovarianz zwischen den Vektoren x und y. Wenn corrected true ist (der Standardwert), berechnet es $\frac{1}{n-1}\sum_{i=1}^n (x_i-\bar x) (y_i-\bar y)^*$, wobei $*$ den komplexen Konjugierten bezeichnet und n = length(x) = length(y). Wenn corrected false ist, berechnet es $\frac{1}{n}\sum_{i=1}^n (x_i-\bar x) (y_i-\bar y)^*$.

cov(X::AbstractVecOrMat, Y::AbstractVecOrMat; dims::Int=1, corrected::Bool=true)

Berechnet die Kovarianz zwischen den Vektoren oder Matrizen X und Y entlang der Dimension dims. Wenn corrected true ist (der Standardwert), wird die Summe mit n-1 skaliert, während die Summe mit n skaliert wird, wenn corrected false ist, wobei n = size(X, dims) = size(Y, dims).

mean!(r, v)

Berechne den Mittelwert von v über die Einzel-Dimensionen von r und schreibe die Ergebnisse in r.

Beispiele

julia> using Statistics

julia> v = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> mean!([1., 1.], v)
2-element Vector{Float64}:
 1.5
 3.5

julia> mean!([1. 1.], v)
1×2 Matrix{Float64}:
 2.0  3.0

mean(itr)

Berechne den Mittelwert aller Elemente in einer Sammlung.

!!! Hinweis Wenn itr NaN oder missing Werte enthält, ist das Ergebnis ebenfalls NaN oder missing (missing hat Vorrang, wenn das Array beides enthält). Verwende die Funktion skipmissing, um missing-Einträge zu ignorieren und den Mittelwert der nicht fehlenden Werte zu berechnen.

Beispiele

julia> using Statistics

julia> mean(1:20)
10.5

julia> mean([1, missing, 3])
missing

julia> mean(skipmissing([1, missing, 3]))
2.0

mean(f, itr)

Wenden Sie die Funktion f auf jedes Element der Sammlung itr an und berechnen Sie den Durchschnitt.

julia> using Statistics

julia> mean(√, [1, 2, 3])
1.3820881233139908

julia> mean([√1, √2, √3])
1.3820881233139908

mean(f, A::AbstractArray; dims)

Wenden Sie die Funktion f auf jedes Element des Arrays A an und berechnen Sie den Mittelwert über die Dimensionen dims.

julia> using Statistics

julia> mean(√, [1, 2, 3])
1.3820881233139908

julia> mean([√1, √2, √3])
1.3820881233139908

julia> mean(√, [1 2 3; 4 5 6], dims=2)
2×1 Matrix{Float64}:
 1.3820881233139908
 2.2285192400943226

mean(A::AbstractArray; dims)

Berechne den Mittelwert eines Arrays über die angegebenen Dimensionen.

Beispiele

julia> using Statistics

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> mean(A, dims=1)
1×2 Matrix{Float64}:
 2.0  3.0

julia> mean(A, dims=2)
2×1 Matrix{Float64}:
 1.5
 3.5

median!(v)

Wie median, kann aber den Eingangsvektor überschreiben.

median(itr)

Berechne den Median aller Elemente in einer Sammlung. Bei einer geraden Anzahl von Elementen existiert kein exakter Medianwert, sodass das Ergebnis dem Mittelwert von zwei Medianwerten entspricht.

!!! Hinweis Wenn itr NaN oder missing Werte enthält, ist das Ergebnis ebenfalls NaN oder missing (missing hat Vorrang, wenn itr beide enthält). Verwende die Funktion skipmissing, um missing-Einträge zu ignorieren und den Median der nicht fehlenden Werte zu berechnen.

Beispiele

julia> using Statistics

julia> median([1, 2, 3])
2.0

julia> median([1, 2, 3, 4])
2.5

julia> median([1, 2, missing, 4])
missing

julia> median(skipmissing([1, 2, missing, 4]))
2.0

median(A::AbstractArray; dims)

Berechne den Median eines Arrays entlang der angegebenen Dimensionen.

Beispiele

julia> using Statistics

julia> median([1 2; 3 4], dims=1)
1×2 Matrix{Float64}:
 2.0  3.0

middle(x)

Berechne die Mitte eines Skalarwerts, der dem Wert x selbst entspricht, jedoch vom Typ middle(x, x) zur Konsistenz.

middle(x, y)

Berechne die Mitte von zwei Zahlen x und y, die sowohl im Wert als auch im Typ dem Mittelwert ((x + y) / 2) entspricht.

middle(a::AbstractArray)

Berechne die Mitte eines Arrays a, indem die Extrema gefunden und dann deren Mittelwert berechnet werden.

julia> using Statistics

julia> middle(1:10)
5.5

julia> a = [1,2,3.6,10.9]
4-element Vector{Float64}:
  1.0
  2.0
  3.6
 10.9

julia> middle(a)
5.95

quantile!([q::AbstractArray, ] v::AbstractVector, p; sorted=false, alpha::Real=1.0, beta::Real=alpha)

Berechnet das Quantil(e) eines Vektors v bei einer angegebenen Wahrscheinlichkeit oder einem Vektor oder Tupel von Wahrscheinlichkeiten p im Intervall [0,1]. Wenn p ein Vektor ist, kann auch ein optionales Ausgabearray q angegeben werden. (Wenn nicht bereitgestellt, wird ein neues Ausgabearray erstellt.) Das Schlüsselwortargument sorted gibt an, ob v als sortiert angenommen werden kann; wenn false (der Standard), werden die Elemente von v teilweise in-place sortiert.

Die Stichprobenquantile werden definiert durch Q(p) = (1-γ)*x[j] + γ*x[j+1], wobei x[j] die j-te Ordnungsstatistik von v ist, j = floor(n*p + m), m = alpha + p*(1 - alpha - beta) und γ = n*p + m - j.

Standardmäßig (alpha = beta = 1) werden Quantile durch lineare Interpolation zwischen den Punkten ((k-1)/(n-1), x[k]) berechnet, für k = 1:n, wobei n = length(v). Dies entspricht Definition 7 von Hyndman und Fan (1996) und ist dasselbe wie der Standard in R und NumPy.

Die Schlüsselwortargumente alpha und beta entsprechen denselben Parametern in Hyndman und Fan; sie auf unterschiedliche Werte zu setzen, ermöglicht die Berechnung von Quantilen mit einer der Methoden 4-9, die in diesem Papier definiert sind:

• Def. 4: alpha=0, beta=1
• Def. 5: alpha=0.5, beta=0.5 (MATLAB-Standard)
• Def. 6: alpha=0, beta=0 (Excel PERCENTILE.EXC, Python-Standard, Stata altdef)
• Def. 7: alpha=1, beta=1 (Julia, R und NumPy-Standard, Excel PERCENTILE und PERCENTILE.INC, Python 'inclusive')
• Def. 8: alpha=1/3, beta=1/3
• Def. 9: alpha=3/8, beta=3/8

Referenzen

• Hyndman, R.J und Fan, Y. (1996) "Sample Quantiles in Statistical Packages", The American Statistician, Vol. 50, No. 4, S. 361-365
• Quantile auf Wikipedia beschreibt die verschiedenen Quantildefinitionen

Beispiele

julia> using Statistics

julia> x = [3, 2, 1];

julia> quantile!(x, 0.5)
2.0

julia> x
3-element Vector{Int64}:
 1
 2
 3

julia> y = zeros(3);

julia> quantile!(y, x, [0.1, 0.5, 0.9]) === y
true

julia> y
3-element Vector{Float64}:
 1.2000000000000002
 2.0
 2.8000000000000003

quantile(itr, p; sorted=false, alpha::Real=1.0, beta::Real=alpha)

Berechnen Sie das(e) Quantil(e) einer Sammlung itr bei einer angegebenen Wahrscheinlichkeit oder einem Vektor oder Tupel von Wahrscheinlichkeiten p im Intervall [0,1]. Das Schlüsselwortargument sorted gibt an, ob itr als sortiert angenommen werden kann.

Die Stichprobenquantile werden definiert durch Q(p) = (1-γ)*x[j] + γ*x[j+1], wobei x[j] die j-te Ordnungsstatistik von itr ist, j = floor(n*p + m), m = alpha + p*(1 - alpha - beta) und γ = n*p + m - j.

Standardmäßig (alpha = beta = 1) werden Quantile durch lineare Interpolation zwischen den Punkten ((k-1)/(n-1), x[k]) berechnet, für k = 1:n, wobei n = length(itr). Dies entspricht Definition 7 von Hyndman und Fan (1996) und ist dasselbe wie das Standardverhalten von R und NumPy.

Die Schlüsselwortargumente alpha und beta entsprechen denselben Parametern in Hyndman und Fan; sie auf unterschiedliche Werte zu setzen, ermöglicht die Berechnung von Quantilen mit einer der Methoden 4-9, die in diesem Papier definiert sind:

• Def. 4: alpha=0, beta=1
• Def. 5: alpha=0.5, beta=0.5 (MATLAB-Standard)
• Def. 6: alpha=0, beta=0 (Excel PERCENTILE.EXC, Python-Standard, Stata altdef)
• Def. 7: alpha=1, beta=1 (Julia, R und NumPy-Standard, Excel PERCENTILE und PERCENTILE.INC, Python 'inclusive')
• Def. 8: alpha=1/3, beta=1/3
• Def. 9: alpha=3/8, beta=3/8

Referenzen

• Hyndman, R.J und Fan, Y. (1996) "Sample Quantiles in Statistical Packages", The American Statistician, Vol. 50, No. 4, S. 361-365
• Quantile auf Wikipedia beschreibt die verschiedenen Quantildefinitionen

Beispiele

julia> using Statistics

julia> quantile(0:20, 0.5)
10.0

julia> quantile(0:20, [0.1, 0.5, 0.9])
3-element Vector{Float64}:
  2.0
 10.0
 18.000000000000004

julia> quantile(skipmissing([1, 10, missing]), 0.5)
5.5