Z-skoori kalkulaator: Arvutage z-skoor andmepunktide jaoks

Z-Score Kalkulaator

Sissejuhatus

z-skoor (või standardiseeritud skoor) on statistiline mõõt, mis kirjeldab väärtuse suhet väärtuste grupi keskmisega. See näitab, kui palju standardhälbeid on element keskmisest eemal. Z-skoor on oluline tööriist statistikast, võimaldades erinevate andmestike standardiseerimist ja äärmuslike väärtuste tuvastamist.

Valem

Z-skoor arvutatakse järgmise valemi abil:

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

Kus:

$z$ = z-skoor
$x$ = individuaalne andmepunkt
$\mu$ = andmestiku keskmine
$\sigma$ = andmestiku standardhälve

See valem arvutab, kui palju standardhälbeid on andmepunkt keskmisest eemal.

Arvutamine

Andmepunkti z-skoori arvutamiseks:

Arvuta keskmine ( $\mu$ ):

Summa kõik andmepunktid ja jaga andmepunktide arvuga.
$\mu = \frac{\sum_{i=1}^{n} x_i}{n}$
Arvuta standardhälve ( $\sigma$ ):
- Variatsioon ( $\sigma^2$ ):
  $\sigma^2 = \frac{\sum_{i=1}^{n} (x_i - \mu)^2}{n}$
- Standardhälve:
  $\sigma = \sqrt{\sigma^2}$
Arvuta z-skoor:

Asenda väärtused z-skoori valemisse.
$z = \frac{x - \mu}{\sigma}$

Äärmuslikud juhtumid

Null standardhälve ( $\sigma = 0$ ):

Kui kõik andmepunktid on identsed, on standardhälve null, muutes z-skoori määramatuks, kuna nulliga jagamine ei ole võimalik. Sellisel juhul z-skoori mõistet ei kohaldata.
Andmepunkt võrdub keskmisega ( $x = \mu$ ):

Kui andmepunkt võrdub keskmisega, on z-skoor null, mis näitab, et see on täpselt keskmine.
Mitte-numbrilised sisendid:

Veendu, et kõik sisendid on numbrilised. Mitte-numbrilised sisendid põhjustavad arvutusvigu.

Kumulatiivne tõenäosus

Kumulatiivne tõenäosus, mis on seotud z-skooriga, esindab tõenäosust, et juhuslik muutuja standardse normaaljaotuse raames on väiksem või võrdne antud väärtusega. See on ala normaaljaotuse kõveral, mis asub määratud z-skoori vasakul.

Matemaatiliselt arvutatakse kumulatiivne tõenäosus $P$ standardse normaaljaotuse kumulatiivse jaotuse funktsiooni (CDF) abil:

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

Kus:

$\Phi(z)$ = CDF standardse normaaljaotuse puhul z-skooriga

Kumulatiivne tõenäosus on statistikast oluline, et määrata, kui tõenäoliselt esineb väärtus teatud vahemikus. Seda kasutatakse laialdaselt kvaliteedikontrollis, rahanduses ja sotsiaalteadustes.

SVG Diagramm

Allpool on SVG diagramm, mis illustreerib standardse normaaljaotuse kõverat ja z-skoori:

μ x z

Standardne normaaljaotus

Joonis: Standardne normaaljaotuse kõver z-skoori varjutatud alaga

See diagramm näitab normaaljaotuse kõverat, mille keskel on keskmine $\mu$ . Varjutatud ala esindab kumulatiivset tõenäosust kuni andmepunktini $x$ , mis vastab z-skoorile.

Kasutusalad

Rakendused

Standardiseerimine erinevate skaalade vahel:

Z-skoorid võimaldavad andmete võrdlemist erinevatelt skaaladelt, standardiseerides andmestikud.
Äärmuslike väärtuste tuvastamine:

Tuvastamine, kui andmepunktid on märkimisväärselt kaugel keskmisest (nt z-skoorid, mis on väiksemad kui -3 või suuremad kui 3).
Statistiline testimine:

Kasutatakse hüpoteeside testimisel, sealhulgas z-testides, et määrata, kas proovide keskmine erineb oluliselt tuntud populatsiooni keskmisest.
Kvaliteedikontroll:

Tootmises aitavad z-skoorid jälgida protsesse, et tagada väljundite jäämine vastuvõetavatesse piiridesse.
Rahandus ja investeerimine:

Aktsiate tootluse hindamine, võrreldes tootlust keskmise turu tootlusega.

Alternatiivid

T-skoor:

Sarnane z-skoorile, kuid kasutatakse, kui proovide suurus on väike ja populatsiooni standardhälve on teadmata.
Protsentuaalne reiting:

Näitab protsentide arvu, mille skoorid on võrdsed või madalamad.
Standardhälbeühikud:

Kasutades toore standardhälbe väärtusi ilma z-skooride standardiseerimiseta.

Ajalugu

Z-skoori mõiste tuleneb Carl Friedrich Gaussi töödest normaaljaotuse teemal 19. sajandi alguses. Standardne normaaljaotus, mis on z-skooride aluseks, töötati välja edasiste statistikutega nagu Abraham de Moivre ja Pierre-Simon Laplace. Z-skooride kasutamine sai laialdaselt levinud 20. sajandi statistiliste meetodite arengu käigus, eriti psühholoogilistes testides ja kvaliteedikontrollis.

Näited

Excel

## Arvuta z-skoor Excelis
## Eeldades, et andmepunkt on lahtris A2, keskmine lahtris B2, standardhälve lahtris C2
=(A2 - B2) / C2

R

## Arvuta z-skoor R-is
calculate_z_score <- function(x, mean, sd) {
  if (sd == 0) {
    stop("Standardhälve ei saa olla null.");
  }
  z <- (x - mean) / sd
  return(z)
}

## Näide kasutamisest:
x <- 85
mu <- 75
sigma <- 5
z_score <- calculate_z_score(x, mu, sigma)
print(paste("Z-skoor:", z_score))

MATLAB

% Arvuta z-skoor MATLAB-is
function z = calculate_z_score(x, mu, sigma)
    if sigma == 0
        error('Standardhälve ei saa olla null.');
    end
    z = (x - mu) / sigma;
end

% Näide kasutamisest:
x = 90;
mu = 80;
sigma = 8;
z = calculate_z_score(x, mu, sigma);
fprintf('Z-skoor: %.2f\n', z);

JavaScript

// Arvuta z-skoor JavaScriptis
function calculateZScore(x, mu, sigma) {
  if (sigma === 0) {
    throw new Error('Standardhälve ei saa olla null.');
  }
  return (x - mu) / sigma;
}

// Näide kasutamisest:
const x = 100;
const mu = 85;
const sigma = 7;
try {
  const z = calculateZScore(x, mu, sigma);
  console.log(`Z-skoor: ${z.toFixed(2)}`);
} catch (error) {
  console.error(error.message);
}

Python

## Arvuta z-skoor Pythonis
def calculate_z_score(x, mu, sigma):
    if sigma == 0:
        raise ValueError("Standardhälve ei saa olla null.")
    return (x - mu) / sigma

## Näide kasutamisest:
x = 95
mu = 88
sigma = 4
try:
    z = calculate_z_score(x, mu, sigma)
    print("Z-skoor:", round(z, 2))
except ValueError as e:
    print(e)

Java

// Arvuta z-skoor Java-s
public class ZScoreCalculator {
    public static double calculateZScore(double x, double mu, double sigma) {
        if (sigma == 0) {
            throw new IllegalArgumentException("Standardhälve ei saa olla 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-skoor: %.2f%n", z);
        } catch (IllegalArgumentException e) {
            System.err.println(e.getMessage());
        }
    }
}

C/C++

// Arvuta z-skoor C++-s
#include <iostream>
#include <stdexcept>

double calculate_z_score(double x, double mu, double sigma) {
    if (sigma == 0) {
        throw std::invalid_argument("Standardhälve ei saa olla 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-skoor: " << z << std::endl;
    } catch (const std::exception &e) {
        std::cerr << e.what() << std::endl;
    }

    return 0;
}

Ruby

## Arvuta z-skoor Ruby-s
def calculate_z_score(x, mu, sigma)
  raise ArgumentError, "Standardhälve ei saa olla null." if sigma == 0
  (x - mu) / sigma
end

## Näide kasutamisest:
x = 105
mu = 100
sigma = 5
begin
  z = calculate_z_score(x, mu, sigma)
  puts "Z-skoor: #{z.round(2)}"
rescue ArgumentError => e
  puts e.message
end

PHP

<?php
// Arvuta z-skoor PHP-s
function calculate_z_score($x, $mu, $sigma) {
  if ($sigma == 0) {
    throw new Exception("Standardhälve ei saa olla null.");
  }
  return ($x - $mu) / $sigma;
}

// Näide kasutamisest:
$x = 115;
$mu = 110;
$sigma = 5;

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

Rust

// Arvuta z-skoor Rustis
fn calculate_z_score(x: f64, mu: f64, sigma: f64) -> Result<f64, String> {
    if sigma == 0.0 {
        return Err("Standardhälve ei saa olla 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-skoor: {:.2}", z),
        Err(e) => println!("{}", e),
    }
}

C#

// Arvuta z-skoor C#-s
using System;

public class ZScoreCalculator
{
    public static double CalculateZScore(double x, double mu, double sigma)
    {
        if (sigma == 0)
            throw new ArgumentException("Standardhälve ei saa olla 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-skoor: {z:F2}");
        }
        catch (ArgumentException e)
        {
            Console.WriteLine(e.Message);
        }
    }
}

Go

// Arvuta z-skoor Go-s
package main

import (
    "errors"
    "fmt"
)

func calculateZScore(x, mu, sigma float64) (float64, error) {
    if sigma == 0 {
        return 0, errors.New("standardhälve ei saa olla 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-skoor: %.2f\n", z)
    }
}

Swift

// Arvuta z-skoor Swiftis
func calculateZScore(x: Double, mu: Double, sigma: Double) throws -> Double {
    if sigma == 0 {
        throw NSError(domain: "Standardhälve ei saa olla null.", code: 1, userInfo: nil)
    }
    return (x - mu) / sigma
}

// Näide kasutamisest:
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-skoor: \(String(format: "%.2f", z))")
} catch let error as NSError {
    print(error.domain)
}

Viidatud allikad

Standard Score - Wikipedia

https://en.wikipedia.org/wiki/Standard_score
Z-skooride mõistmine - Statistics Solutions

https://www.statisticssolutions.com/understanding-z-scores/
Normaaljaotus ja z-skoorid - Khan Academy

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

Täiendavad ressursid

Interaktiivne z-skoori kalkulaator

https://www.socscistatistics.com/pvalues/normaldistribution.aspx
Normaaljaotuse visualiseerimine

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

Loading related tools...