Whiz Tools

Z-score Kalkulator

Introduksjon

Z-score (eller standard score) er et statistisk mål som beskriver et verdiforhold til gjennomsnittet av en gruppe verdier. Det indikerer hvor mange standardavvik et element er fra gjennomsnittet. Z-scoren er et viktig verktøy i statistikk, som gjør det mulig å standardisere forskjellige datasett og identifisere avvik.

Formel

Z-scoren beregnes ved hjelp av følgende formel:

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

Hvor:

  • zz = z-score
  • xx = individuell datapunkt
  • μ\mu = gjennomsnittet av datasettet
  • σ\sigma = standardavviket av datasettet

Denne formelen beregner antall standardavvik et datapunkt er fra gjennomsnittet.

Beregning

For å beregne z-scoren til et datapunkt:

  1. Beregn Gjennomsnittet (μ\mu):

    Summer alle datapunktene og del på antall datapunkter.

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

  2. Beregn Standardavviket (σ\sigma):

    • Varians (σ2\sigma^2):

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

    • Standardavvik:

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

  3. Beregn Z-scoren:

    Sett inn verdiene i z-score formelen.

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

Kanttilfeller

  • Null Standardavvik (σ=0\sigma = 0):

    Når alle datapunktene er identiske, er standardavviket null, noe som gjør z-scoren udefinert fordi du ikke kan dele på null. I dette tilfellet gjelder ikke begrepet z-score.

  • Datapunkt Lik Gjennomsnittet (x=μx = \mu):

    Hvis datapunktet er lik gjennomsnittet, er z-scoren null, noe som indikerer at det er akkurat gjennomsnittlig.

  • Ikke-numeriske Inndata:

    Sørg for at alle inndata er numeriske. Ikke-numeriske inndata vil resultere i beregningsfeil.

Kumulativ Sannsynlighet

Den kumulative sannsynligheten assosiert med en z-score representerer sannsynligheten for at en tilfeldig variabel fra en standard normalfordeling vil være mindre enn eller lik den gitte verdien. Det er området under normalfordelingskurven til venstre for den spesifiserte z-scoren.

Matematisk beregnes den kumulative sannsynligheten PP ved hjelp av den kumulative fordelingsfunksjonen (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 sannsynligheten er viktig i statistikk for å bestemme sannsynligheten for at en verdi forekommer innenfor et bestemt område. Den brukes mye innen kvalitetskontroll, finans og samfunnsvitenskap.

SVG Diagram

Nedenfor er et SVG-diagram som illustrerer standard normalfordelingskurven og z-scoren:

μ x z

Standard Normalfordeling

Figur: Standard Normalfordelingskurve med Z-score Skygget

Dette diagrammet viser normalfordelingskurven med gjennomsnittet μ\mu i sentrum. Det skyggeområdet representerer den kumulative sannsynligheten opp til datapunktet xx, som tilsvarer z-scoren.

Bruksområder

Applikasjoner

  • Standardisering på Tvers av Ulike Skalaer:

    Z-scores gjør det mulig å sammenligne data fra forskjellige skalaer ved å standardisere datasettene.

  • Avviksdeteksjon:

    Identifisere datapunkter som er betydelig fjernt fra gjennomsnittet (f.eks. z-scores mindre enn -3 eller større enn 3).

  • Statistisk Testing:

    Brukt i hypotesetesting, inkludert z-tester, for å avgjøre om et utvalgsgjennomsnitt avviker betydelig fra et kjent populasjonsgjennomsnitt.

  • Kvalitetskontroll:

    I produksjon hjelper z-scores med å overvåke prosesser for å sikre at utdataene forblir innen akseptable grenser.

  • Finans og Investering:

    Vurdere aksjeutvikling ved å sammenligne avkastning i forhold til gjennomsnittlig markedsytelse.

Alternativer

  • T-Score:

    Ligner på z-scoren, men brukes når utvalgsstørrelsen er liten og populasjonsstandardavviket er ukjent.

  • Prosentil Rangering:

    Indikerer prosentandelen av poeng i sin frekvensfordeling som er lik eller lavere enn den.

  • Standardavvik Enheter:

    Bruke rå standardavviksverdier uten å standardisere som z-scores.

Historie

Konseptet med z-score stammer fra arbeidet med normalfordelingen av Carl Friedrich Gauss på tidlig 1800-tallet. Den standard normalfordelingen, som er grunnleggende for z-scores, ble videreutviklet av statistikere som Abraham de Moivre og Pierre-Simon Laplace. Bruken av z-scores ble utbredt med utviklingen av statistiske metoder på 1900-tallet, spesielt innen psykologisk testing og kvalitetskontroll.

Eksempler

Excel

## Beregn z-score i Excel
## Anta datapunkt i celle A2, gjennomsnitt i celle B2, standardavvik i celle C2
=(A2 - B2) / C2

R

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

## Eksempel på bruk:
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('Standardavvik kan ikke være null.');
    end
    z = (x - mu) / sigma;
end

% Eksempel på bruk:
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('Standardavvik kan ikke være null.');
  }
  return (x - mu) / sigma;
}

// Eksempel på bruk:
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("Standardavvik kan ikke være null.")
    return (x - mu) / sigma

## Eksempel på bruk:
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("Standardavvik kan ikke være null.");
        }
        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("Standardavvik kan ikke være null.");
    }
    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, "Standardavvik kan ikke være null." if sigma == 0
  (x - mu) / sigma
end

## Eksempel på bruk:
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("Standardavvik kan ikke være null.");
  }
  return ($x - $mu) / $sigma;
}

// Eksempel på bruk:
$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("Standardavvik kan ikke være null.".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("Standardavvik kan ikke være null.");
        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("standardavvik kan ikke være null")
    }
    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: "Standardavvik kan ikke være null.", code: 1, userInfo: nil)
    }
    return (x - mu) / sigma
}

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

Referanser

  1. Standard Score - Wikipedia

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

  2. Forstå 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

Ytterligere Ressurser

Loading related tools...
Feedback