Z-Score Rechner für statistische Analysen und Standardisierung

Z-Score Rechner

Einführung

Der z-Score (oder Standardwert) ist ein statistisches Maß, das die Beziehung eines Wertes zum Mittelwert einer Gruppe von Werten beschreibt. Er zeigt an, wie viele Standardabweichungen ein Element vom Mittelwert entfernt ist. Der z-Score ist ein wichtiges Werkzeug in der Statistik, das die Standardisierung verschiedener Datensätze und die Identifizierung von Ausreißern ermöglicht.

Formel

Der z-Score wird mit der folgenden Formel berechnet:

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

Wo:

$z$ = z-Score
$x$ = individueller Datenpunkt
$\mu$ = Mittelwert des Datensatzes
$\sigma$ = Standardabweichung des Datensatzes

Diese Formel berechnet die Anzahl der Standardabweichungen, die ein Datenpunkt vom Mittelwert entfernt ist.

Berechnung

Um den z-Score eines Datenpunkts zu berechnen:

Berechnen Sie den Mittelwert ( $\mu$ ):

Addieren Sie alle Datenpunkte und teilen Sie durch die Anzahl der Datenpunkte.
$\mu = \frac{\sum_{i=1}^{n} x_i}{n}$
Berechnen Sie die Standardabweichung ( $\sigma$ ):
- Varianz ( $\sigma^2$ ):
  $\sigma^2 = \frac{\sum_{i=1}^{n} (x_i - \mu)^2}{n}$
- Standardabweichung:
  $\sigma = \sqrt{\sigma^2}$
Berechnen Sie den Z-Score:

Setzen Sie die Werte in die z-Score-Formel ein.
$z = \frac{x - \mu}{\sigma}$

Randfälle

Null Standardabweichung ( $\sigma = 0$ ):

Wenn alle Datenpunkte identisch sind, ist die Standardabweichung null, was den z-Score undefiniert macht, da man nicht durch null teilen kann. In diesem Fall ist das Konzept eines z-Scores nicht anwendbar.
Datenpunkt gleich Mittelwert ( $x = \mu$ ):

Wenn der Datenpunkt dem Mittelwert entspricht, ist der z-Score null, was anzeigt, dass er genau durchschnittlich ist.
Nicht-numerische Eingaben:

Stellen Sie sicher, dass alle Eingaben numerisch sind. Nicht-numerische Eingaben führen zu Berechnungsfehlern.

Kumulative Wahrscheinlichkeit

Die kumulative Wahrscheinlichkeit, die mit einem z-Score verbunden ist, stellt die Wahrscheinlichkeit dar, dass eine Zufallsvariable aus einer Standardnormalverteilung kleiner oder gleich dem angegebenen Wert ist. Es ist die Fläche unter der Normalverteilungskurve links vom angegebenen z-Score.

Mathematisch wird die kumulative Wahrscheinlichkeit $P$ unter Verwendung der kumulativen Verteilungsfunktion (CDF) der Standardnormalverteilung berechnet:

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

Wo:

$\Phi(z)$ = CDF der Standardnormalverteilung bei $z$

Die kumulative Wahrscheinlichkeit ist in der Statistik wichtig, um die Wahrscheinlichkeit zu bestimmen, dass ein Wert innerhalb eines bestimmten Bereichs auftritt. Sie wird häufig in Bereichen wie Qualitätskontrolle, Finanzen und Sozialwissenschaften verwendet.

SVG-Diagramm

Unten ist ein SVG-Diagramm, das die Standardnormalverteilungskurve und den z-Score veranschaulicht:

μ x z

Standardnormalverteilung

Abbildung: Standardnormalverteilungskurve mit schattiertem Z-Score

Dieses Diagramm zeigt die Normalverteilungskurve mit dem Mittelwert $\mu$ in der Mitte. Der schattierte Bereich repräsentiert die kumulative Wahrscheinlichkeit bis zum Datenpunkt $x$ , der dem z-Score entspricht.

Anwendungsfälle

Anwendungen

Standardisierung über verschiedene Skalen:

Z-Scores ermöglichen den Vergleich von Daten aus verschiedenen Skalen, indem sie die Datensätze standardisieren.
Ausreißererkennung:

Identifizierung von Datenpunkten, die signifikant vom Mittelwert abweichen (z. B. z-Scores kleiner als -3 oder größer als 3).
Statistische Tests:

Verwendung in Hypothesentests, einschließlich z-Tests, um zu bestimmen, ob sich ein Stichprobenmittelwert signifikant von einem bekannten Populationsmittelwert unterscheidet.
Qualitätskontrolle:

In der Fertigung helfen z-Scores, Prozesse zu überwachen, um sicherzustellen, dass die Ergebnisse innerhalb akzeptabler Grenzen bleiben.
Finanzen und Investitionen:

Bewertung der Aktienleistung durch den Vergleich der Renditen im Verhältnis zur durchschnittlichen Marktleistung.

Alternativen

T-Score:

Ähnlich wie der z-Score, wird jedoch verwendet, wenn die Stichprobengröße klein ist und die Populationsstandardabweichung unbekannt ist.
Perzentilrang:

Gibt den Prozentsatz der Werte in seiner Häufigkeitsverteilung an, die gleich oder niedriger sind als er.
Standardabweichungseinheiten:

Verwendung von Rohstandardabweichungswerten, ohne sie als z-Scores zu standardisieren.

Geschichte

Das Konzept des z-Scores stammt aus der Arbeit über die Normalverteilung von Carl Friedrich Gauss im frühen 19. Jahrhundert. Die Standardnormalverteilung, die für z-Scores grundlegend ist, wurde von Statistikern wie Abraham de Moivre und Pierre-Simon Laplace weiterentwickelt. Die Verwendung von z-Scores wurde mit dem Fortschritt statistischer Methoden im 20. Jahrhundert weit verbreitet, insbesondere in psychologischen Tests und der Qualitätskontrolle.

Beispiele

Excel

## Berechnung des z-Scores in Excel
## Angenommener Datenpunkt in Zelle A2, Mittelwert in Zelle B2, Standardabweichung in Zelle C2
=(A2 - B2) / C2

R

## Berechnung des z-Scores in R
calculate_z_score <- function(x, mean, sd) {
  if (sd == 0) {
    stop("Die Standardabweichung darf nicht null sein.")
  }
  z <- (x - mean) / sd
  return(z)
}

## Beispielverwendung:
x <- 85
mu <- 75
sigma <- 5
z_score <- calculate_z_score(x, mu, sigma)
print(paste("Z-Score:", z_score))

MATLAB

% Berechnung des z-Scores in MATLAB
function z = calculate_z_score(x, mu, sigma)
    if sigma == 0
        error('Die Standardabweichung darf nicht null sein.');
    end
    z = (x - mu) / sigma;
end

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

JavaScript

// Berechnung des z-Scores in JavaScript
function calculateZScore(x, mu, sigma) {
  if (sigma === 0) {
    throw new Error('Die Standardabweichung darf nicht null sein.');
  }
  return (x - mu) / sigma;
}

// Beispielverwendung:
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

## Berechnung des z-Scores in Python
def calculate_z_score(x, mu, sigma):
    if sigma == 0:
        raise ValueError("Die Standardabweichung darf nicht null sein.")
    return (x - mu) / sigma

## Beispielverwendung:
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

// Berechnung des z-Scores in Java
public class ZScoreCalculator {
    public static double calculateZScore(double x, double mu, double sigma) {
        if (sigma == 0) {
            throw new IllegalArgumentException("Die Standardabweichung darf nicht null sein.");
        }
        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++

// Berechnung des z-Scores in C++
#include <iostream>
#include <stdexcept>

double calculate_z_score(double x, double mu, double sigma) {
    if (sigma == 0) {
        throw std::invalid_argument("Die Standardabweichung darf nicht null sein.");
    }
    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

## Berechnung des z-Scores in Ruby
def calculate_z_score(x, mu, sigma)
  raise ArgumentError, "Die Standardabweichung darf nicht null sein." if sigma == 0
  (x - mu) / sigma
end

## Beispielverwendung:
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
// Berechnung des z-Scores in PHP
function calculate_z_score($x, $mu, $sigma) {
  if ($sigma == 0) {
    throw new Exception("Die Standardabweichung darf nicht null sein.");
  }
  return ($x - $mu) / $sigma;
}

// Beispielverwendung:
$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

// Berechnung des z-Scores in Rust
fn calculate_z_score(x: f64, mu: f64, sigma: f64) -> Result<f64, String> {
    if sigma == 0.0 {
        return Err("Die Standardabweichung darf nicht null sein.".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#

// Berechnung des z-Scores in C#
using System;

public class ZScoreCalculator
{
    public static double CalculateZScore(double x, double mu, double sigma)
    {
        if (sigma == 0)
            throw new ArgumentException("Die Standardabweichung darf nicht null sein.");
        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

// Berechnung des z-Scores in Go
package main

import (
    "errors"
    "fmt"
)

func calculateZScore(x, mu, sigma float64) (float64, error) {
    if sigma == 0 {
        return 0, errors.New("Die Standardabweichung darf nicht null sein")
    }
    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

// Berechnung des z-Scores in Swift
func calculateZScore(x: Double, mu: Double, sigma: Double) throws -> Double {
    if sigma == 0 {
        throw NSError(domain: "Die Standardabweichung darf nicht null sein.", code: 1, userInfo: nil)
    }
    return (x - mu) / sigma
}

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

Referenzen

Standardwert - Wikipedia

https://de.wikipedia.org/wiki/Standardwert
Verstehen von Z-Scores - Statistiklösungen

https://www.statisticssolutions.com/understanding-z-scores/
Normalverteilung und Z-Scores - Khan Academy

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

Zusätzliche Ressourcen

Interaktiver Z-Score-Rechner

https://www.socscistatistics.com/pvalues/normaldistribution.aspx
Visualisierung der Normalverteilung

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

Loading related tools...