Whiz Tools

Z-Score Calculator

Introduktion

Z-score (eller standard score) er en statistisk måling, der beskriver en værdis forhold til gennemsnittet af en gruppe værdier. Det angiver, hvor mange standardafvigelser et element er fra gennemsnittet. Z-score er et vigtigt værktøj i statistik, der muliggør standardisering af forskellige datasæt og identifikation af outliers.

Formel

Z-score beregnes ved hjælp af følgende formel:

z=x−μσz = \frac{x - \mu}{\sigma}

Hvor:

  • zz = z-score
  • xx = individuel datapunkt
  • μ\mu = gennemsnit af datasættet
  • σ\sigma = standardafvigelse af datasættet

Denne formel beregner antallet af standardafvigelser, et datapunkt er fra gennemsnittet.

Beregning

For at beregne z-score for et datapunkt:

  1. Beregn Gennemsnittet (μ\mu):

    Summér alle datapunkter og del med antallet af datapunkter.

    μ=∑i=1nxin\mu = \frac{\sum_{i=1}^{n} x_i}{n}

  2. Beregn Standardafvigelsen (σ\sigma):

    • Varians (σ2\sigma^2):

      σ2=∑i=1n(xi−μ)2n\sigma^2 = \frac{\sum_{i=1}^{n} (x_i - \mu)^2}{n}

    • Standardafvigelse:

      σ=σ2\sigma = \sqrt{\sigma^2}

  3. Beregn Z-Score:

    Indsæt værdierne i z-score formelen.

    z=x−μσz = \frac{x - \mu}{\sigma}

Edge Cases

  • Zero Standardafvigelse (σ=0\sigma = 0):

    Når alle datapunkter er identiske, er standardafvigelsen nul, hvilket gør z-score udefineret, fordi du ikke kan dividere med nul. I dette tilfælde gælder begrebet z-score ikke.

  • Datapunkt Lige med Gennemsnittet (x=μx = \mu):

    Hvis datapunktet er lig med gennemsnittet, er z-score nul, hvilket indikerer, at det er præcis gennemsnittet.

  • Ikke-numeriske Indgange:

    Sørg for, at alle indgange er numeriske. Ikke-numeriske indgange vil resultere i beregningsfejl.

Kumulativ Sandsynlighed

Den kumulative sandsynlighed forbundet med en z-score repræsenterer sandsynligheden for, at en tilfældig variabel fra en standard normalfordeling vil være mindre end eller lig med den angivne værdi. Det er arealet under normalfordelingskurven til venstre for den specificerede z-score.

Matematisk beregnes den kumulative sandsynlighed PP ved hjælp af den kumulative fordelingsfunktion (CDF) for standard normalfordeling:

P(Z≤z)=Φ(z)=12π∫−∞ze−t2/2 dtP(Z \leq z) = \Phi(z) = \frac{1}{\sqrt{2\pi}} \int_{-\infty}^{z} e^{-t^2/2} \, dt

Hvor:

  • Φ(z)\Phi(z) = CDF for standard normalfordeling ved zz

Den kumulative sandsynlighed er essentiel i statistik for at bestemme sandsynligheden for, at en værdi forekommer inden for et bestemt område. Det bruges bredt inden for områder som kvalitetskontrol, finans og samfundsvidenskaber.

SVG Diagram

Nedenfor er et SVG-diagram, der illustrerer standard normalfordelingskurven og z-score:

μ x z

Standard Normalfordeling

Figur: Standard Normalfordelingskurve med Z-Score Skygget

Dette diagram viser normalfordelingskurven med gennemsnittet μ\mu i midten. Det skyggeområde repræsenterer den kumulative sandsynlighed op til datapunktet xx, der svarer til z-score.

Anvendelsestilfælde

Applikationer

  • Standardisering på tværs af forskellige skalaer:

    Z-scores muliggør sammenligning mellem data fra forskellige skalaer ved at standardisere datasættene.

  • Outlier Detektion:

    Identificering af datapunkter, der er betydeligt fjerne fra gennemsnittet (f.eks. z-scores mindre end -3 eller større end 3).

  • Statistisk Testning:

    Bruges i hypotesetestning, herunder z-tests, for at bestemme, om et stikprøvegennemsnit signifikant adskiller sig fra et kendt populationsgennemsnit.

  • Kvalitetskontrol:

    I fremstillingen hjælper z-scores med at overvåge processer for at sikre, at output forbliver inden for acceptable grænser.

  • Finans og Investering:

    Vurdering af aktiepræstation ved at sammenligne afkast i forhold til det gennemsnitlige marked.

Alternativer

  • T-Score:

    Ligner z-score, men bruges når stikprøvestørrelsen er lille, og populationsstandardafvigelsen er ukendt.

  • Percentil Rang:

    Angiver procentdelen af scores i dens hyppighedsfordeling, der er lig med eller lavere end den.

  • Standardafvigelses Enheder:

    Brug af rå standardafvigelsesværdier uden at standardisere som z-scores.

Historie

Begrebet z-score stammer fra arbejdet med normalfordelingen af Carl Friedrich Gauss i det tidlige 19. århundrede. Den standard normale fordeling, som er grundlæggende for z-scores, blev yderligere udviklet af statistikere som Abraham de Moivre og Pierre-Simon Laplace. Brugen af z-scores blev udbredt med udviklingen af statistiske metoder i det 20. århundrede, især inden for psykologisk testning og kvalitetskontrol.

Eksempler

Excel

## Beregn z-score i Excel
## Antager datapunkt i celle A2, gennemsnit i celle B2, standardafvigelse i celle C2
=(A2 - B2) / C2

R

## Beregn z-score i R
calculate_z_score <- function(x, mean, sd) {
  if (sd == 0) {
    stop("Standardafvigelse kan ikke være nul.")
  }
  z <- (x - mean) / sd
  return(z)
}

## Eksempel på brug:
x <- 85
mu <- 75
sigma <- 5
z_score <- calculate_z_score(x, mu, sigma)
print(paste("Z-score:", z_score))

MATLAB

% Beregn z-score i MATLAB
function z = calculate_z_score(x, mu, sigma)
    if sigma == 0
        error('Standardafvigelse kan ikke være nul.');
    end
    z = (x - mu) / sigma;
end

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

JavaScript

// Beregn z-score i JavaScript
function calculateZScore(x, mu, sigma) {
  if (sigma === 0) {
    throw new Error('Standardafvigelse kan ikke være nul.');
  }
  return (x - mu) / sigma;
}

// Eksempel på brug:
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

## Beregn z-score i Python
def calculate_z_score(x, mu, sigma):
    if sigma == 0:
        raise ValueError("Standardafvigelse kan ikke være nul.")
    return (x - mu) / sigma

## Eksempel på brug:
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

// Beregn z-score i Java
public class ZScoreCalculator {
    public static double calculateZScore(double x, double mu, double sigma) {
        if (sigma == 0) {
            throw new IllegalArgumentException("Standardafvigelse kan ikke være nul.");
        }
        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++

// Beregn z-score i C++
#include <iostream>
#include <stdexcept>

double calculate_z_score(double x, double mu, double sigma) {
    if (sigma == 0) {
        throw std::invalid_argument("Standardafvigelse kan ikke være nul.");
    }
    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

## Beregn z-score i Ruby
def calculate_z_score(x, mu, sigma)
  raise ArgumentError, "Standardafvigelse kan ikke være nul." if sigma == 0
  (x - mu) / sigma
end

## Eksempel på brug:
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
// Beregn z-score i PHP
function calculate_z_score($x, $mu, $sigma) {
  if ($sigma == 0) {
    throw new Exception("Standardafvigelse kan ikke være nul.");
  }
  return ($x - $mu) / $sigma;
}

// Eksempel på brug:
$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

// Beregn z-score i Rust
fn calculate_z_score(x: f64, mu: f64, sigma: f64) -> Result<f64, String> {
    if sigma == 0.0 {
        return Err("Standardafvigelse kan ikke være nul.".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#

// Beregn z-score i C#
using System;

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

// Beregn z-score i Go
package main

import (
    "errors"
    "fmt"
)

func calculateZScore(x, mu, sigma float64) (float64, error) {
    if sigma == 0 {
        return 0, errors.New("standardafvigelse kan ikke være nul")
    }
    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

// Beregn z-score i Swift
func calculateZScore(x: Double, mu: Double, sigma: Double) throws -> Double {
    if sigma == 0 {
        throw NSError(domain: "Standardafvigelse kan ikke være nul.", code: 1, userInfo: nil)
    }
    return (x - mu) / sigma
}

// Eksempel på brug:
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)
}

Referencer

  1. Standard Score - Wikipedia

    https://en.wikipedia.org/wiki/Standard_score

  2. Forståelse af Z-Scores - Statistics Solutions

    https://www.statisticssolutions.com/understanding-z-scores/

  3. Normalfordeling og Z-Scores - Khan Academy

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

Yderligere Ressourcer

Loading related tools...
Feedback