Whiz Tools

Z-Score Skaičiuoklė

Įvadas

Z-reikšmė (arba standartinė reikšmė) yra statistinis matavimas, kuris apibūdina vertės santykį su grupės reikšmių vidurkiu. Ji rodo, kiek standartinių nuokrypių elementas yra nuo vidurkio. Z-reikšmė yra svarbi statistikoje, leidžianti standartizuoti skirtingus duomenų rinkinius ir identifikuoti nuokrypius.

Formulė

Z-reikšmė skaičiuojama naudojant šią formulę:

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

Kur:

  • zz = z-reikšmė
  • xx = atskira duomenų reikšmė
  • μ\mu = duomenų rinkinio vidurkis
  • σ\sigma = duomenų rinkinio standartinis nuokrypis

Ši formulė apskaičiuoja, kiek standartinių nuokrypių duomenų taškas yra nuo vidurkio.

Skaičiavimas

Norint apskaičiuoti z-reikšmę duomenų taškui:

  1. Apskaičiuokite vidurkį (μ\mu):

    Sudėkite visus duomenų taškus ir padalinkite iš duomenų taškų skaičiaus.

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

  2. Apskaičiuokite standartinį nuokrypį (σ\sigma):

    • Variacija (σ2\sigma^2):

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

    • Standartinis nuokrypis:

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

  3. Apskaičiuokite z-reikšmę:

    Įstatykite reikšmes į z-reikšmės formulę.

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

Kraštutiniai atvejai

  • Nulinis standartinis nuokrypis (σ=0\sigma = 0):

    Kai visi duomenų taškai yra identiški, standartinis nuokrypis yra nulinis, todėl z-reikšmė yra neapibrėžta, nes negalite dalinti iš nulio. Tokiu atveju z-reikšmės samprata netaikoma.

  • Duomenų taškas lygus vidurkiui (x=μx = \mu):

    Jei duomenų taškas lygus vidurkiui, z-reikšmė yra nulis, nurodanti, kad jis yra tiksliai vidutinis.

  • Nenumatiniai įvestys:

    Užtikrinkite, kad visos įvestys būtų numerinės. Nenumatiniai įvestys sukels skaičiavimo klaidas.

Kumulatyvinė tikimybė

Kumulatyvinė tikimybė, susijusi su z-reikšme, atspindi tikimybę, kad atsitiktinė reikšmė iš standartinės normaliosios paskirstymo bus mažesnė arba lygi nurodytai vertei. Tai yra plotas po normaliojo paskirstymo kreive kairėje nuo nurodytos z-reikšmės.

Matematiškai, kumulatyvinė tikimybė PP skaičiuojama naudojant standartinės normaliosios paskirstymo kumulatyvinę funkciją (CDF):

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

Kur:

  • Φ(z)\Phi(z) = CDF standartinės normaliosios paskirstymo z-reikšmei

Kumulatyvinė tikimybė yra esminė statistikoje nustatant, kiek tikėtina, kad vertė pasirodys tam tikrame intervale. Ji plačiai naudojama tokiose srityse kaip kokybės kontrolė, finansai ir socialiniai mokslai.

SVG Diagrama

Žemiau pateikta SVG diagrama, iliustruojanti standartinės normaliosios paskirstymo kreivę ir z-reikšmę:

μ x z

Standartinė normalioji paskirstymo

Paveikslas: Standartinė normalioji paskirstymo kreivė su z-reikšme šešėliuota

Ši diagrama rodo normaliosios paskirstymo kreivę su vidurkiu μ\mu centre. Šešėliuota zona atspindi kumulatyvinę tikimybę iki duomenų taško xx, atitinkančio z-reikšmę.

Naudojimo atvejai

Taikymas

  • Standartizavimas skirtinguose mastuose:

    Z-reikšmės leidžia palyginti duomenis iš skirtingų mastų, standartizuojant duomenų rinkinius.

  • Nuokrypių nustatymas:

    Identifikuojant duomenų taškus, kurie yra žymiai nutolę nuo vidurkio (pvz., z-reikšmės mažesnės nei -3 arba didesnės nei 3).

  • Statistiniai testai:

    Naudojama hipotezių testavime, įskaitant z-testus, siekiant nustatyti, ar imties vidurkis žymiai skiriasi nuo žinomo populiacijos vidurkio.

  • Kokybės kontrolė:

    Gamyboje z-reikšmės padeda stebėti procesus, kad užtikrintų, jog rezultatai išliktų priimtinuose ribose.

  • Finansai ir investicijos:

    Vertinant akcijų našumą, palyginant grąžas su vidutine rinkos našuma.

Alternatyvos

  • T-reikšmė:

    Panaši į z-reikšmę, tačiau naudojama, kai imties dydis yra mažas ir populiacijos standartinis nuokrypis nežinomas.

  • Procentinė reitingo:

    Nurodo procentą rezultatų savo dažnio paskirstyme, kurie yra lygūs arba mažesni už jį.

  • Standartinio nuokrypio vienetai:

    Naudojant žalius standartinio nuokrypio vertes, nesistengiant standartizuoti kaip z-reikšmes.

Istorija

Z-reikšmės samprata kyla iš normaliojo paskirstymo tyrimų, kuriuos atliko Karlas Friedrichas Gaussas XIX a. pradžioje. Standartinė normalioji paskirstymo, kuri yra pagrindinė z-reikšmių, toliau buvo vystoma tokių statistikų kaip Abrahomas de Moivre'as ir Pierre'as-Simonas Laplace'as. Z-reikšmių naudojimas tapo plačiai paplitęs su statistinių metodų plėtra XX a., ypač psichologinių testų ir kokybės kontrolės srityse.

Pavyzdžiai

Excel

## Apskaičiuoti z-reikšmę Excel programoje
## Priklausomai nuo duomenų taško A2 langelyje, vidurkio B2 langelyje, standartinio nuokrypio C2 langelyje
=(A2 - B2) / C2

R

## Apskaičiuoti z-reikšmę R
calculate_z_score <- function(x, mean, sd) {
  if (sd == 0) {
    stop("Standartinis nuokrypis negali būti nulinis.")
  }
  z <- (x - mean) / sd
  return(z)
}

## Pavyzdinis naudojimas:
x <- 85
mu <- 75
sigma <- 5
z_score <- calculate_z_score(x, mu, sigma)
print(paste("Z-reikšmė:", z_score))

MATLAB

% Apskaičiuoti z-reikšmę MATLAB
function z = calculate_z_score(x, mu, sigma)
    if sigma == 0
        error('Standartinis nuokrypis negali būti nulinis.');
    end
    z = (x - mu) / sigma;
end

% Pavyzdinis naudojimas:
x = 90;
mu = 80;
sigma = 8;
z = calculate_z_score(x, mu, sigma);
fprintf('Z-reikšmė: %.2f\n', z);

JavaScript

// Apskaičiuoti z-reikšmę JavaScript
function calculateZScore(x, mu, sigma) {
  if (sigma === 0) {
    throw new Error('Standartinis nuokrypis negali būti nulinis.');
  }
  return (x - mu) / sigma;
}

// Pavyzdinis naudojimas:
const x = 100;
const mu = 85;
const sigma = 7;
try {
  const z = calculateZScore(x, mu, sigma);
  console.log(`Z-reikšmė: ${z.toFixed(2)}`);
} catch (error) {
  console.error(error.message);
}

Python

## Apskaičiuoti z-reikšmę Python
def calculate_z_score(x, mu, sigma):
    if sigma == 0:
        raise ValueError("Standartinis nuokrypis negali būti nulinis.")
    return (x - mu) / sigma

## Pavyzdinis naudojimas:
x = 95
mu = 88
sigma = 4
try:
    z = calculate_z_score(x, mu, sigma)
    print("Z-reikšmė:", round(z, 2))
except ValueError as e:
    print(e)

Java

// Apskaičiuoti z-reikšmę Java
public class ZScoreCalculator {
    public static double calculateZScore(double x, double mu, double sigma) {
        if (sigma == 0) {
            throw new IllegalArgumentException("Standartinis nuokrypis negali būti nulinis.");
        }
        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-reikšmė: %.2f%n", z);
        } catch (IllegalArgumentException e) {
            System.err.println(e.getMessage());
        }
    }
}

C/C++

// Apskaičiuoti z-reikšmę C++
#include <iostream>
#include <stdexcept>

double calculate_z_score(double x, double mu, double sigma) {
    if (sigma == 0) {
        throw std::invalid_argument("Standartinis nuokrypis negali būti nulinis.");
    }
    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-reikšmė: " << z << std::endl;
    } catch (const std::exception &e) {
        std::cerr << e.what() << std::endl;
    }

    return 0;
}

Ruby

## Apskaičiuoti z-reikšmę Ruby
def calculate_z_score(x, mu, sigma)
  raise ArgumentError, "Standartinis nuokrypis negali būti nulinis." if sigma == 0
  (x - mu) / sigma
end

## Pavyzdinis naudojimas:
x = 105
mu = 100
sigma = 5
begin
  z = calculate_z_score(x, mu, sigma)
  puts "Z-reikšmė: #{z.round(2)}"
rescue ArgumentError => e
  puts e.message
end

PHP

<?php
// Apskaičiuoti z-reikšmę PHP
function calculate_z_score($x, $mu, $sigma) {
  if ($sigma == 0) {
    throw new Exception("Standartinis nuokrypis negali būti nulinis.");
  }
  return ($x - $mu) / $sigma;
}

// Pavyzdinis naudojimas:
$x = 115;
$mu = 110;
$sigma = 5;

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

Rust

// Apskaičiuoti z-reikšmę Rust
fn calculate_z_score(x: f64, mu: f64, sigma: f64) -> Result<f64, String> {
    if sigma == 0.0 {
        return Err("Standartinis nuokrypis negali būti nulinis.".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-reikšmė: {:.2}", z),
        Err(e) => println!("{}", e),
    }
}

C#

// Apskaičiuoti z-reikšmę C#
using System;

public class ZScoreCalculator
{
    public static double CalculateZScore(double x, double mu, double sigma)
    {
        if (sigma == 0)
            throw new ArgumentException("Standartinis nuokrypis negali būti nulinis.");
        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-reikšmė: {z:F2}");
        }
        catch (ArgumentException e)
        {
            Console.WriteLine(e.Message);
        }
    }
}

Go

// Apskaičiuoti z-reikšmę Go
package main

import (
    "errors"
    "fmt"
)

func calculateZScore(x, mu, sigma float64) (float64, error) {
    if sigma == 0 {
        return 0, errors.New("standartinis nuokrypis negali būti nulinis")
    }
    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-reikšmė: %.2f\n", z)
    }
}

Swift

// Apskaičiuoti z-reikšmę Swift
func calculateZScore(x: Double, mu: Double, sigma: Double) throws -> Double {
    if sigma == 0 {
        throw NSError(domain: "Standartinis nuokrypis negali būti nulinis.", code: 1, userInfo: nil)
    }
    return (x - mu) / sigma
}

// Pavyzdinis naudojimas:
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-reikšmė: \(String(format: "%.2f", z))")
} catch let error as NSError {
    print(error.domain)
}

Nuorodos

  1. Standartinė reikšmė - Vikipedija

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

  2. Z-reikšmių supratimas - Statistikos sprendimai

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

  3. Normalus paskirstymas ir z-reikšmės - Khan Academy

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

Papildomos ištekliai

Loading related tools...
Feedback