Statistics

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

Calcule l'écart type de l'échantillon de la collection itr.

L'algorithme renvoie un estimateur de l'écart type de la distribution générative sous l'hypothèse que chaque entrée de itr est un échantillon tiré de la même distribution inconnue, avec les échantillons non corrélés. Pour les tableaux, ce calcul est équivalent à calculer sqrt(sum((itr .- mean(itr)).^2) / (length(itr) - 1)). Si corrected est true, alors la somme est mise à l'échelle avec n-1, tandis que la somme est mise à l'échelle avec n si corrected est false, avec n le nombre d'éléments dans itr.

Si itr est un AbstractArray, dims peut être fourni pour calculer l'écart type sur les dimensions.

Un mean pré-calculé peut être fourni. Lorsque dims est spécifié, mean doit être un tableau de la même forme que mean(itr, dims=dims) (des dimensions singleton supplémentaires à la fin sont autorisées).

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

Calcule l'écart type de l'échantillon de la collection itr, avec la ou les moyennes connues mean.

L'algorithme renvoie un estimateur de l'écart type de la distribution générative sous l'hypothèse que chaque entrée de itr est un échantillon tiré de la même distribution inconnue, les échantillons étant non corrélés. Pour les tableaux, ce calcul est équivalent à calculer sqrt(sum((itr .- mean(itr)).^2) / (length(itr) - 1)). Si corrected est true, alors la somme est mise à l'échelle avec n-1, tandis que la somme est mise à l'échelle avec n si corrected est false, avec n le nombre d'éléments dans itr.

Si itr est un AbstractArray, dims peut être fourni pour calculer l'écart type sur les dimensions. Dans ce cas, mean doit être un tableau de la même forme que mean(itr, dims=dims) (des dimensions singleton supplémentaires à la fin sont autorisées).

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

Calcule la variance d'échantillon de la collection itr.

L'algorithme renvoie un estimateur de la variance de la distribution générative sous l'hypothèse que chaque entrée de itr est un échantillon tiré de la même distribution inconnue, avec les échantillons non corrélés. Pour les tableaux, ce calcul est équivalent à calculer sum((itr .- mean(itr)).^2) / (length(itr) - 1). Si corrected est true, alors la somme est mise à l'échelle avec n-1, tandis que la somme est mise à l'échelle avec n si corrected est false, où n est le nombre d'éléments dans itr.

Si itr est un AbstractArray, dims peut être fourni pour calculer la variance sur les dimensions.

Une mean pré-calculée peut être fournie. Lorsque dims est spécifié, mean doit être un tableau ayant la même forme que mean(itr, dims=dims) (des dimensions singleton supplémentaires à la fin sont autorisées).

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

Calcule la variance d'échantillon de la collection itr, avec la ou les moyennes connues mean.

L'algorithme renvoie un estimateur de la variance de la distribution générative sous l'hypothèse que chaque entrée de itr est un échantillon tiré de la même distribution inconnue, les échantillons étant non corrélés. Pour les tableaux, ce calcul est équivalent à calculer sum((itr .- mean(itr)).^2) / (length(itr) - 1). Si corrected est true, alors la somme est mise à l'échelle avec n-1, tandis que la somme est mise à l'échelle avec n si corrected est false, avec n le nombre d'éléments dans itr.

Si itr est un AbstractArray, dims peut être fourni pour calculer la variance sur les dimensions. Dans ce cas, mean doit être un tableau de la même forme que mean(itr, dims=dims) (des dimensions singleton supplémentaires à la fin sont autorisées).

cor(x::AbstractVector)

Return the number one.

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

Calcule la matrice de corrélation de Pearson de la matrice X le long de la dimension dims.

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

Calcule la corrélation de Pearson entre les vecteurs x et y.

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

Calcule la corrélation de Pearson entre les vecteurs ou matrices X et Y le long de la dimension dims.

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

Calcule la variance du vecteur x. Si corrected est true (par défaut), alors la somme est mise à l'échelle avec n-1, tandis que la somme est mise à l'échelle avec n si corrected est false, où n = length(x).

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

Calcule la matrice de covariance de la matrice X le long de la dimension dims. Si corrected est true (par défaut), alors la somme est mise à l'échelle avec n-1, tandis que la somme est mise à l'échelle avec n si corrected est false, où n = size(X, dims).

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

Calcule la covariance entre les vecteurs x et y. Si corrected est true (par défaut), calcule $\frac{1}{n-1}\sum_{i=1}^n (x_i-\bar x) (y_i-\bar y)^*$ où $*$ désigne le conjugué complexe et n = length(x) = length(y). Si corrected est false, calcule $\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)

Calcule la covariance entre les vecteurs ou matrices X et Y le long de la dimension dims. Si corrected est true (par défaut), alors la somme est mise à l'échelle avec n-1, tandis que la somme est mise à l'échelle avec n si corrected est false, où n = size(X, dims) = size(Y, dims).

mean!(r, v)

Calcule la moyenne de v sur les dimensions singleton de r, et écrit les résultats dans r.

Exemples

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)

Calculez la moyenne de tous les éléments d'une collection.

Exemples

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)

Appliquez la fonction f à chaque élément de la collection itr et prenez la moyenne.

julia> using Statistics

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

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

mean(f, A::AbstractArray; dims)

Applique la fonction f à chaque élément du tableau A et prend la moyenne sur les dimensions 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)

Calcule la moyenne d'un tableau sur les dimensions données.

Exemples

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)

Comme median, mais peut écraser le vecteur d'entrée.

median(itr)

Calculez la médiane de tous les éléments d'une collection. Pour un nombre pair d'éléments, il n'existe pas d'élément médian exact, donc le résultat équivaut à calculer la moyenne de deux éléments médians.

Exemples

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)

Calcule la médiane d'un tableau le long des dimensions données.

Exemples

julia> using Statistics

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

middle(x)

Calculez le milieu d'une valeur scalaire, ce qui équivaut à x lui-même, mais du type de middle(x, x) pour la cohérence.

middle(x, y)

Calculez le milieu de deux nombres x et y, ce qui est équivalent en valeur et en type à calculer leur moyenne ((x + y) / 2).

middle(a::AbstractArray)

Calcule le milieu d'un tableau a, ce qui consiste à trouver ses extrêmes puis à calculer leur moyenne.

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)

Calcule le(s) quantile(s) d'un vecteur v à une probabilité spécifiée ou un vecteur ou un tuple de probabilités p sur l'intervalle [0,1]. Si p est un vecteur, un tableau de sortie optionnel q peut également être spécifié. (S'il n'est pas fourni, un nouveau tableau de sortie est créé.) L'argument clé sorted indique si v peut être supposé trié ; si false (par défaut), alors les éléments de v seront partiellement triés sur place.

Les quantiles d'échantillon sont définis par Q(p) = (1-γ)*x[j] + γ*x[j+1], où x[j] est la j-ème statistique d'ordre de v, j = floor(n*p + m), m = alpha + p*(1 - alpha - beta) et γ = n*p + m - j.

Par défaut (alpha = beta = 1), les quantiles sont calculés par interpolation linéaire entre les points ((k-1)/(n-1), x[k]), pour k = 1:n où n = length(v). Cela correspond à la Définition 7 de Hyndman et Fan (1996), et est le même que le défaut de R et NumPy.

Les arguments clés alpha et beta correspondent aux mêmes paramètres dans Hyndman et Fan, les définir à des valeurs différentes permet de calculer des quantiles avec n'importe laquelle des méthodes 4-9 définies dans cet article :

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

Références

• Hyndman, R.J et Fan, Y. (1996) "Sample Quantiles in Statistical Packages", The American Statistician, Vol. 50, No. 4, pp. 361-365
• Quantile sur Wikipedia détaille les différentes définitions de quantile

Exemples

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)

Calcule les quantiles d'une collection itr à une probabilité spécifiée ou un vecteur ou un tuple de probabilités p sur l'intervalle [0,1]. L'argument clé sorted indique si itr peut être supposé trié.

Les quantiles d'échantillon sont définis par Q(p) = (1-γ)*x[j] + γ*x[j+1], où x[j] est le j-ème ordre statistique de itr, j = floor(n*p + m), m = alpha + p*(1 - alpha - beta) et γ = n*p + m - j.

Par défaut (alpha = beta = 1), les quantiles sont calculés par interpolation linéaire entre les points ((k-1)/(n-1), x[k]), pour k = 1:n où n = length(itr). Cela correspond à la Définition 7 de Hyndman et Fan (1996), et est le même que le défaut de R et NumPy.

Les arguments clés alpha et beta correspondent aux mêmes paramètres dans Hyndman et Fan, les définir à des valeurs différentes permet de calculer des quantiles avec n'importe laquelle des méthodes 4-9 définies dans cet article :

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

Références

• Hyndman, R.J et Fan, Y. (1996) "Sample Quantiles in Statistical Packages", The American Statistician, Vol. 50, No. 4, pp. 361-365
• Quantile sur Wikipedia détaille les différentes définitions de quantiles

Exemples

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