Z-score Calculator voor Statistische Analyse en Normalisatie

Z-Score Calculator

Inleiding

De z-score (of standaardscore) is een statistische maatstaf die de relatie van een waarde tot het gemiddelde van een groep waarden beschrijft. Het geeft aan hoeveel standaarddeviaties een element van het gemiddelde afligt. De z-score is een cruciaal hulpmiddel in de statistiek, dat de standaardisatie van verschillende datasets mogelijk maakt en de identificatie van uitschieters vergemakkelijkt.

Formule

De z-score wordt berekend met de volgende formule:

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

Waarbij:

$z$ = z-score
$x$ = individuele datapunt
$\mu$ = gemiddelde van de dataset
$\sigma$ = standaarddeviatie van de dataset

Deze formule berekent het aantal standaarddeviaties dat een datapunt van het gemiddelde afligt.

Berekening

Om de z-score van een datapunt te berekenen:

Bereken het Gemiddelde ( $\mu$ ):

Tel alle datapunten op en deel door het aantal datapunten.
$\mu = \frac{\sum_{i=1}^{n} x_i}{n}$
Bereken de Standaarddeviatie ( $\sigma$ ):
- Varianties ( $\sigma^2$ ):
  $\sigma^2 = \frac{\sum_{i=1}^{n} (x_i - \mu)^2}{n}$
- Standaarddeviatie:
  $\sigma = \sqrt{\sigma^2}$
Bereken de Z-Score:

Vul de waarden in de z-score formule in.
$z = \frac{x - \mu}{\sigma}$

Randgevallen

Nul Standaarddeviatie ( $\sigma = 0$ ):

Wanneer alle datapunten identiek zijn, is de standaarddeviatie nul, waardoor de z-score niet gedefinieerd is omdat je niet door nul kunt delen. In dit geval is het concept van een z-score niet van toepassing.
Datapunt Gelijk aan Gemiddelde ( $x = \mu$ ):

Als het datapunt gelijk is aan het gemiddelde, is de z-score nul, wat aangeeft dat het precies gemiddeld is.
Niet-Numerieke Invoer:

Zorg ervoor dat alle invoer numeriek is. Niet-numerieke invoer zal leiden tot berekeningsfouten.

Cumulatieve Kans

De cumulatieve kans die aan een z-score is gekoppeld, vertegenwoordigt de kans dat een willekeurige variabele uit een standaard normale verdeling kleiner dan of gelijk aan de gegeven waarde is. Het is het gebied onder de normale verdelingscurve links van de opgegeven z-score.

Wiskundig wordt de cumulatieve kans $P$ berekend met behulp van de cumulatieve distributiefunctie (CDF) van de standaard normale verdeling:

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

Waarbij:

$\Phi(z)$ = CDF van de standaard normale verdeling bij $z$

De cumulatieve kans is essentieel in de statistiek voor het bepalen van de waarschijnlijkheid dat een waarde binnen een bepaald bereik voorkomt. Het wordt veel gebruikt in gebieden zoals kwaliteitscontrole, financiën en sociale wetenschappen.

SVG Diagram

Hieronder staat een SVG-diagram dat de standaard normale verdelingscurve en de z-score illustreert:

μ x z

Standaard Normale Verdeling

Figuur: Standaard Normale Verdelingscurve met Z-Score Schaduwen

Dit diagram toont de normale verdelingscurve met het gemiddelde $\mu$ in het midden. Het schaduwgebied vertegenwoordigt de cumulatieve kans tot het datapunt $x$ , dat overeenkomt met de z-score.

Gebruikscases

Toepassingen

Standaardisatie Tussen Verschillende Schalen:

Z-scores maken vergelijking tussen gegevens van verschillende schalen mogelijk door de datasets te standaardiseren.
Uitschieter Detectie:

Identificeren van datapunten die significant van het gemiddelde afwijken (bijv. z-scores kleiner dan -3 of groter dan 3).
Statistische Testen:

Gebruikt in hypothesetests, inclusief z-tests, om te bepalen of een steekproefgemiddelde significant verschilt van een bekend populatiegemiddelde.
Kwaliteitscontrole:

In de productie helpen z-scores processen te monitoren om ervoor te zorgen dat de output binnen aanvaardbare grenzen blijft.
Financiën en Investeringen:

Beoordelen van aandelenprestaties door rendementen te vergelijken ten opzichte van de gemiddelde marktprestaties.

Alternatieven

T-Score:

Vergelijkbaar met de z-score, maar gebruikt wanneer de steekproefgrootte klein is en de populatiestandaarddeviatie onbekend is.
Percentiel Rang:

Geeft het percentage scores in de frequentieverdeling aan die gelijk zijn aan of lager dan het.
Standaarddeviatie Eenheden:

Gebruik van ruwe standaarddeviatie waarden zonder te standaardiseren als z-scores.

Geschiedenis

Het concept van de z-score is voortgekomen uit het werk over de normale verdeling door Carl Friedrich Gauss in het begin van de 19e eeuw. De standaard normale verdeling, die fundamenteel is voor z-scores, werd verder ontwikkeld door statistici zoals Abraham de Moivre en Pierre-Simon Laplace. Het gebruik van z-scores werd wijdverspreid met de vooruitgang van statistische methoden in de 20e eeuw, met name in psychologische tests en kwaliteitscontrole.

Voorbeelden

Excel

## Bereken z-score in Excel
## Aangenomen dat datapunt in cel A2, gemiddelde in cel B2, standaarddeviatie in cel C2
=(A2 - B2) / C2

R

## Bereken z-score in R
calculate_z_score <- function(x, mean, sd) {
  if (sd == 0) {
    stop("Standaarddeviatie kan niet nul zijn.")
  }
  z <- (x - mean) / sd
  return(z)
}

## Voorbeeld gebruik:
x <- 85
mu <- 75
sigma <- 5
z_score <- calculate_z_score(x, mu, sigma)
print(paste("Z-score:", z_score))

MATLAB

% Bereken z-score in MATLAB
function z = calculate_z_score(x, mu, sigma)
    if sigma == 0
        error('Standaarddeviatie kan niet nul zijn.');
    end
    z = (x - mu) / sigma;
end

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

JavaScript

// Bereken z-score in JavaScript
function calculateZScore(x, mu, sigma) {
  if (sigma === 0) {
    throw new Error('Standaarddeviatie kan niet nul zijn.');
  }
  return (x - mu) / sigma;
}

// Voorbeeld gebruik:
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

## Bereken z-score in Python
def calculate_z_score(x, mu, sigma):
    if sigma == 0:
        raise ValueError("Standaarddeviatie kan niet nul zijn.")
    return (x - mu) / sigma

## Voorbeeld gebruik:
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

// Bereken z-score in Java
public class ZScoreCalculator {
    public static double calculateZScore(double x, double mu, double sigma) {
        if (sigma == 0) {
            throw new IllegalArgumentException("Standaarddeviatie kan niet nul zijn.");
        }
        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++

// Bereken z-score in C++
#include <iostream>
#include <stdexcept>

double calculate_z_score(double x, double mu, double sigma) {
    if (sigma == 0) {
        throw std::invalid_argument("Standaarddeviatie kan niet nul zijn.");
    }
    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

## Bereken z-score in Ruby
def calculate_z_score(x, mu, sigma)
  raise ArgumentError, "Standaarddeviatie kan niet nul zijn." if sigma == 0
  (x - mu) / sigma
end

## Voorbeeld gebruik:
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
// Bereken z-score in PHP
function calculate_z_score($x, $mu, $sigma) {
  if ($sigma == 0) {
    throw new Exception("Standaarddeviatie kan niet nul zijn.");
  }
  return ($x - $mu) / $sigma;
}

// Voorbeeld gebruik:
$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

// Bereken z-score in Rust
fn calculate_z_score(x: f64, mu: f64, sigma: f64) -> Result<f64, String> {
    if sigma == 0.0 {
        return Err("Standaarddeviatie kan niet nul zijn.".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#

// Bereken z-score in C#
using System;

public class ZScoreCalculator
{
    public static double CalculateZScore(double x, double mu, double sigma)
    {
        if (sigma == 0)
            throw new ArgumentException("Standaarddeviatie kan niet nul zijn.");
        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

// Bereken z-score in Go
package main

import (
    "errors"
    "fmt"
)

func calculateZScore(x, mu, sigma float64) (float64, error) {
    if sigma == 0 {
        return 0, errors.New("standaarddeviatie kan niet nul zijn")
    }
    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

// Bereken z-score in Swift
func calculateZScore(x: Double, mu: Double, sigma: Double) throws -> Double {
    if sigma == 0 {
        throw NSError(domain: "Standaarddeviatie kan niet nul zijn.", code: 1, userInfo: nil)
    }
    return (x - mu) / sigma
}

// Voorbeeld gebruik:
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)
}

Referenties

Standaardscore - Wikipedia

https://en.wikipedia.org/wiki/Standard_score
Z-Scores Begrijpen - Statistics Solutions

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

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

Aanvullende Bronnen

Interactieve Z-Score Calculator

https://www.socscistatistics.com/pvalues/normaldistribution.aspx
Visualiseren van de Normale Verdeling

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

Loading related tools...