Calculateur de Z-Score pour l'analyse statistique avancée

Calculateur de Z-Score

Introduction

Le z-score (ou score standard) est une mesure statistique qui décrit la relation d'une valeur par rapport à la moyenne d'un groupe de valeurs. Il indique combien d'écarts-types un élément est éloigné de la moyenne. Le z-score est un outil crucial en statistiques, permettant la standardisation de différents ensembles de données et l'identification des valeurs aberrantes.

Formule

Le z-score est calculé à l'aide de la formule suivante :

z = \frac{x - \mu}{\sigma}

Où :

$z$ = z-score
$x$ = point de données individuel
$\mu$ = moyenne de l'ensemble de données
$\sigma$ = écart-type de l'ensemble de données

Cette formule calcule le nombre d'écarts-types qu'un point de données est éloigné de la moyenne.

Calcul

Pour calculer le z-score d'un point de données :

Calculer la Moyenne ( $\mu$ ) :

Additionnez tous les points de données et divisez par le nombre de points de données.
$\mu = \frac{\sum_{i=1}^{n} x_i}{n}$
Calculer l'Écart-Type ( $\sigma$ ) :
- Variance ( $\sigma^2$ ) :
  $\sigma^2 = \frac{\sum_{i=1}^{n} (x_i - \mu)^2}{n}$
- Écart-Type :
  $\sigma = \sqrt{\sigma^2}$
Calculer le Z-Score :

Remplacez les valeurs dans la formule du z-score.
$z = \frac{x - \mu}{\sigma}$

Cas Particuliers

Écart-Type Nul ( $\sigma = 0$ ) :

Lorsque tous les points de données sont identiques, l'écart-type est nul, rendant le z-score indéfini car vous ne pouvez pas diviser par zéro. Dans ce cas, le concept de z-score ne s'applique pas.
Point de Données Égal à la Moyenne ( $x = \mu$ ) :

Si le point de données est égal à la moyenne, le z-score est zéro, indiquant qu'il est exactement moyen.
Entrées Non Numériques :

Assurez-vous que toutes les entrées sont numériques. Les entrées non numériques entraîneront des erreurs de calcul.

Probabilité Cumulative

La probabilité cumulative associée à un z-score représente la probabilité qu'une variable aléatoire d'une distribution normale standard soit inférieure ou égale à la valeur donnée. C'est la zone sous la courbe de distribution normale à gauche du z-score spécifié.

Mathématiquement, la probabilité cumulative $P$ est calculée à l'aide de la fonction de distribution cumulative (CDF) de la distribution normale standard :

P(Z \leq z) = \Phi(z) = \frac{1}{\sqrt{2\pi}} \int_{-\infty}^{z} e^{-t^2/2} \, dt

Où :

$\Phi(z)$ = CDF de la distribution normale standard à $z$

La probabilité cumulative est essentielle en statistiques pour déterminer la probabilité qu'une valeur se produise dans une certaine plage. Elle est largement utilisée dans des domaines tels que le contrôle de qualité, la finance et les sciences sociales.

Diagramme SVG

Voici un diagramme SVG illustrant la courbe de distribution normale standard et le z-score :

μ x z

Distribution Normale Standard

Figure : Courbe de Distribution Normale Standard avec Z-Score Ombreé

Ce diagramme montre la courbe de distribution normale avec la moyenne $\mu$ au centre. La zone ombragée représente la probabilité cumulative jusqu'au point de données $x$ , correspondant au z-score.

Cas d'Utilisation

Applications

Standardisation à Travers Différentes Échelles :

Les z-scores permettent de comparer des données provenant de différentes échelles en standardisant les ensembles de données.
Détection des Valeurs Aberrantes :

Identification des points de données qui sont significativement éloignés de la moyenne (par exemple, z-scores inférieurs à -3 ou supérieurs à 3).
Tests Statistiques :

Utilisés dans les tests d'hypothèses, y compris les z-tests, pour déterminer si une moyenne d'échantillon diffère significativement d'une moyenne de population connue.
Contrôle de Qualité :

En fabrication, les z-scores aident à surveiller les processus pour garantir que les résultats restent dans des limites acceptables.
Finance et Investissement :

Évaluation de la performance des actions en comparant les rendements par rapport à la performance moyenne du marché.

Alternatives

T-Score :

Semblable au z-score mais utilisé lorsque la taille de l'échantillon est petite et que l'écart-type de la population est inconnu.
Rang Percentile :

Indique le pourcentage de scores dans sa distribution de fréquence qui sont égaux ou inférieurs à lui.
Unités d'Écart-Type :

Utilisation des valeurs d'écart-type brutes sans standardiser en tant que z-scores.

Histoire

Le concept de z-score découle des travaux sur la distribution normale par Carl Friedrich Gauss au début du XIXe siècle. La distribution normale standard, fondamentale pour les z-scores, a été développée par des statisticiens tels qu'Abraham de Moivre et Pierre-Simon Laplace. L'utilisation des z-scores est devenue répandue avec l'avancement des méthodes statistiques au XXe siècle, en particulier dans les tests psychologiques et le contrôle de qualité.

Exemples

Excel

## Calculer le z-score dans Excel
## Supposons que le point de données soit dans la cellule A2, la moyenne dans la cellule B2, l'écart-type dans la cellule C2
=(A2 - B2) / C2

R

## Calculer le z-score dans R
calculate_z_score <- function(x, mean, sd) {
  if (sd == 0) {
    stop("L'écart-type ne peut pas être zéro.")
  }
  z <- (x - mean) / sd
  return(z)
}

## Exemple d'utilisation :
x <- 85
mu <- 75
sigma <- 5
z_score <- calculate_z_score(x, mu, sigma)
print(paste("Z-score :", z_score))

MATLAB

% Calculer le z-score dans MATLAB
function z = calculate_z_score(x, mu, sigma)
    if sigma == 0
        error('L''écart-type ne peut pas être zéro.');
    end
    z = (x - mu) / sigma;
end

% Exemple d'utilisation :
x = 90;
mu = 80;
sigma = 8;
z = calculate_z_score(x, mu, sigma);
fprintf('Z-score : %.2f\n', z);

JavaScript

// Calculer le z-score en JavaScript
function calculateZScore(x, mu, sigma) {
  if (sigma === 0) {
    throw new Error('L''écart-type ne peut pas être zéro.');
  }
  return (x - mu) / sigma;
}

// Exemple d'utilisation :
const x = 100;
const mu = 85;
const sigma = 7;
try {
  const z = calculateZScore(x, mu, sigma);
  console.log(`Z-score : ${z.toFixed(2)}`);
} catch (error) {
  console.error(error.message);
}

Python

## Calculer le z-score en Python
def calculate_z_score(x, mu, sigma):
    if sigma == 0:
        raise ValueError("L'écart-type ne peut pas être zéro.")
    return (x - mu) / sigma

## Exemple d'utilisation :
x = 95
mu = 88
sigma = 4
try:
    z = calculate_z_score(x, mu, sigma)
    print("Z-score :", round(z, 2))
except ValueError as e:
    print(e)

Java

// Calculer le z-score en Java
public class ZScoreCalculator {
    public static double calculateZScore(double x, double mu, double sigma) {
        if (sigma == 0) {
            throw new IllegalArgumentException("L'écart-type ne peut pas être zéro.");
        }
        return (x - mu) / sigma;
    }

    public static void main(String[] args) {
        double x = 110;
        double mu = 100;
        double sigma = 5;

        try {
            double z = calculateZScore(x, mu, sigma);
            System.out.printf("Z-score : %.2f%n", z);
        } catch (IllegalArgumentException e) {
            System.err.println(e.getMessage());
        }
    }
}

C/C++

// Calculer le z-score en C++
#include <iostream>
#include <stdexcept>

double calculate_z_score(double x, double mu, double sigma) {
    if (sigma == 0) {
        throw std::invalid_argument("L'écart-type ne peut pas être zéro.");
    }
    return (x - mu) / sigma;
}

int main() {
    double x = 130;
    double mu = 120;
    double sigma = 10;

    try {
        double z = calculate_z_score(x, mu, sigma);
        std::cout << "Z-score : " << z << std::endl;
    } catch (const std::exception &e) {
        std::cerr << e.what() << std::endl;
    }

    return 0;
}

Ruby

## Calculer le z-score en Ruby
def calculate_z_score(x, mu, sigma)
  raise ArgumentError, "L'écart-type ne peut pas être zéro." if sigma == 0
  (x - mu) / sigma
end

## Exemple d'utilisation :
x = 105
mu = 100
sigma = 5
begin
  z = calculate_z_score(x, mu, sigma)
  puts "Z-score : #{z.round(2)}"
rescue ArgumentError => e
  puts e.message
end

PHP

<?php
// Calculer le z-score en PHP
function calculate_z_score($x, $mu, $sigma) {
  if ($sigma == 0) {
    throw new Exception("L'écart-type ne peut pas être zéro.");
  }
  return ($x - $mu) / $sigma;
}

// Exemple d'utilisation :
$x = 115;
$mu = 110;
$sigma = 5;

try {
  $z = calculate_z_score($x, $mu, $sigma);
  echo "Z-score : " . round($z, 2);
} catch (Exception $e) {
  echo $e->getMessage();
}
?>

Rust

// Calculer le z-score en Rust
fn calculate_z_score(x: f64, mu: f64, sigma: f64) -> Result<f64, String> {
    if sigma == 0.0 {
        return Err("L'écart-type ne peut pas être zéro.".to_string());
    }
    Ok((x - mu) / sigma)
}

fn main() {
    let x = 125.0;
    let mu = 115.0;
    let sigma = 5.0;

    match calculate_z_score(x, mu, sigma) {
        Ok(z) => println!("Z-score : {:.2}", z),
        Err(e) => println!("{}", e),
    }
}

C#

// Calculer le z-score en C#
using System;

public class ZScoreCalculator
{
    public static double CalculateZScore(double x, double mu, double sigma)
    {
        if (sigma == 0)
            throw new ArgumentException("L'écart-type ne peut pas être zéro.");
        return (x - mu) / sigma;
    }

    public static void Main()
    {
        double x = 135;
        double mu = 125;
        double sigma = 5;

        try
        {
            double z = CalculateZScore(x, mu, sigma);
            Console.WriteLine($"Z-score : {z:F2}");
        }
        catch (ArgumentException e)
        {
            Console.WriteLine(e.Message);
        }
    }
}

Go

// Calculer le z-score en Go
package main

import (
    "errors"
    "fmt"
)

func calculateZScore(x, mu, sigma float64) (float64, error) {
    if sigma == 0 {
        return 0, errors.New("l'écart-type ne peut pas être zéro")
    }
    return (x - mu) / sigma, nil
}

func main() {
    x := 140.0
    mu := 130.0
    sigma := 5.0

    z, err := calculateZScore(x, mu, sigma)
    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Printf("Z-score : %.2f\n", z)
    }
}

Swift

// Calculer le z-score en Swift
func calculateZScore(x: Double, mu: Double, sigma: Double) throws -> Double {
    if sigma == 0 {
        throw NSError(domain: "L'écart-type ne peut pas être zéro.", code: 1, userInfo: nil)
    }
    return (x - mu) / sigma
}

// Exemple d'utilisation :
let x = 120.0
let mu = 110.0
let sigma = 5.0

do {
    let z = try calculateZScore(x: x, mu: mu, sigma: sigma)
    print("Z-score : \(String(format: "%.2f", z))")
} catch let error as NSError {
    print(error.domain)
}

Références

Score Standard - Wikipédia

https://fr.wikipedia.org/wiki/Score_standard
Comprendre les Z-Scores - Statistics Solutions

https://www.statisticssolutions.com/understanding-z-scores/
Distribution Normale et Z-Scores - Khan Academy

https://www.khanacademy.org/math/statistics-probability/modeling-distributions-of-data/z-scores/a/z-scores-review

Ressources Supplémentaires

Calculateur de Z-Score Interactif

https://www.socscistatistics.com/pvalues/normaldistribution.aspx
Visualiser la Distribution Normale

https://seeing-theory.brown.edu/normal-distribution/index.html

Loading related tools...