Z-Score Kalkulators: Aprēķiniet Standarta Vērtību Datu Punktiem

Z-Score kalkulators

Ievads

Z-score (vai standarta rādītājs) ir statistikas mērījums, kas apraksta vērtības attiecību pret vērtību grupas vidējo. Tas norāda, cik daudz standarta noviržu elements ir no vidējā. Z-score ir būtisks rīks statistikā, kas ļauj standartizēt dažādus datu kopas un identificēt novirzes.

Formula

Z-score tiek aprēķināts, izmantojot sekojošo formulu:

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

Kur:

$z$ = z-score
$x$ = individuālais datu punkts
$\mu$ = datu kopas vidējais
$\sigma$ = datu kopas standarta novirze

Šī formula aprēķina, cik daudz standarta noviržu datu punkts ir no vidējā.

Aprēķins

Lai aprēķinātu z-score datu punktam:

Aprēķiniet vidējo ( $\mu$ ):

Sadaliet visu datu punktu summu ar datu punktu skaitu.
$\mu = \frac{\sum_{i=1}^{n} x_i}{n}$
Aprēķiniet standarta novirzi ( $\sigma$ ):
- Variācija ( $\sigma^2$ ):
  $\sigma^2 = \frac{\sum_{i=1}^{n} (x_i - \mu)^2}{n}$
- Standarta novirze:
  $\sigma = \sqrt{\sigma^2}$
Aprēķiniet z-score:

Aizvietojiet vērtības z-score formulā.
$z = \frac{x - \mu}{\sigma}$

Malas gadījumi

Nulles standarta novirze ( $\sigma = 0$ ):

Kad visi datu punkti ir identiski, standarta novirze ir nulle, padarot z-score nenoteiktu, jo jūs nevarat dalīt ar nulli. Šajā gadījumā z-score koncepts nav piemērojams.
Datu punkts, kas vienāds ar vidējo ( $x = \mu$ ):

Ja datu punkts ir vienāds ar vidējo, z-score ir nulle, norādot, ka tas ir tieši vidējais.
Nekvalitatīvi ievadi:

Pārliecinieties, ka visi ievadi ir skaitliski. Nekvalitatīvi ievadi radīs aprēķina kļūdas.

Kumulatīvā varbūtība

Kumulatīvā varbūtība, kas saistīta ar z-score, pārstāv varbūtību, ka nejauša mainīgā vērtība no standarta normālās sadalījuma būs mazāka vai vienāda ar konkrēto vērtību. Tas ir laukums zem normālās sadalījuma līknes pa kreisi no noteiktā z-score.

Matemātiski kumulatīvā varbūtība $P$ tiek aprēķināta, izmantojot standarta normālās sadalījuma kumulatīvo sadalījuma funkciju (CDF):

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

Kur:

$\Phi(z)$ = CDF standarta normālajā sadalījumā pie $z$

Kumulatīvā varbūtība ir būtiska statistikā, lai noteiktu, cik liela ir iespēja, ka vērtība notiks noteiktā diapazonā. To plaši izmanto tādās jomās kā kvalitātes kontrole, finanses un sociālās zinātnes.

SVG diagramma

Zemāk ir SVG diagramma, kas ilustrē standarta normālās sadalījuma līkni un z-score:

μ x z

Standarta normālā sadalījuma

Attēls: Standarta normālā sadalījuma līkne ar z-score apgaismojumu

Šī diagramma parāda normālās sadalījuma līkni ar vidējo $\mu$ centrā. Apgaismotā zona attēlo kumulatīvo varbūtību līdz datu punktam $x$ , kas atbilst z-score.

Lietošanas gadījumi

Pielietojumi

Standartizācija dažādās skalās:

Z-scores ļauj salīdzināt datus no dažādām skalām, standartizējot datu kopas.
Noviržu noteikšana:

Identificējot datu punktus, kas ir būtiski attālināti no vidējā (piemēram, z-scores, kas ir mazāki par -3 vai lielāki par 3).
Statistiskā testēšana:

Izmanto hipotēžu testēšanā, tostarp z-testos, lai noteiktu, vai parauga vidējais būtiski atšķiras no zināmā populācijas vidējā.
Kvalitātes kontrole:

Ražošanā z-scores palīdz uzraudzīt procesus, lai nodrošinātu, ka rezultāti paliek pieņemamajos ierobežojumos.
Finanses un ieguldījumi:

Novērtējot akciju sniegumu, salīdzinot atdevi attiecībā pret vidējo tirgus sniegumu.

Alternatīvas

T-score:

Līdzīgs z-score, bet tiek izmantots, kad parauga lielums ir mazs un populācijas standarta novirze nav zināma.
Percentila ranga:

Norāda procentuālo daļu rezultātu savā biežuma sadalījumā, kas ir vienādi vai zemāki par to.
Standarta novirzes vienības:

Izmantojot neapstrādātas standarta novirzes vērtības bez standartizācijas kā z-scores.

Vēsture

Z-score koncepts izriet no normālās sadalījuma pētījumiem, ko veica Karls Fridrihs Gausa 19. gadsimta sākumā. Standarta normālā sadalījuma, kas ir pamatā z-scores, tālāk attīstīja statistiķi, piemēram, Abrahams de Moivre un Pjērs-Simons Laplace. Z-scores lietošana kļuva plaši izplatīta ar statistikas metožu attīstību 20. gadsimtā, it īpaši psiholoģiskajā testēšanā un kvalitātes kontrolē.

Piemēri

Excel

## Aprēķiniet z-score Excel
## Pieņemot, ka datu punkts ir šūnā A2, vidējais šūnā B2, standarta novirze šūnā C2
=(A2 - B2) / C2

R

## Aprēķiniet z-score R
calculate_z_score <- function(x, mean, sd) {
  if (sd == 0) {
    stop("Standarta novirze nevar būt nulle.")
  }
  z <- (x - mean) / sd
  return(z)
}

## Piemēra izmantošana:
x <- 85
mu <- 75
sigma <- 5
z_score <- calculate_z_score(x, mu, sigma)
print(paste("Z-score:", z_score))

MATLAB

% Aprēķiniet z-score MATLAB
function z = calculate_z_score(x, mu, sigma)
    if sigma == 0
        error('Standarta novirze nevar būt nulle.');
    end
    z = (x - mu) / sigma;
end

% Piemēra izmantošana:
x = 90;
mu = 80;
sigma = 8;
z = calculate_z_score(x, mu, sigma);
fprintf('Z-score: %.2f\n', z);

JavaScript

// Aprēķiniet z-score JavaScript
function calculateZScore(x, mu, sigma) {
  if (sigma === 0) {
    throw new Error('Standarta novirze nevar būt nulle.');
  }
  return (x - mu) / sigma;
}

// Piemēra izmantošana:
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

## Aprēķiniet z-score Python
def calculate_z_score(x, mu, sigma):
    if sigma == 0:
        raise ValueError("Standarta novirze nevar būt nulle.")
    return (x - mu) / sigma

## Piemēra izmantošana:
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

// Aprēķiniet z-score Java
public class ZScoreCalculator {
    public static double calculateZScore(double x, double mu, double sigma) {
        if (sigma == 0) {
            throw new IllegalArgumentException("Standarta novirze nevar būt nulle.");
        }
        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++

// Aprēķiniet z-score C++
#include <iostream>
#include <stdexcept>

double calculate_z_score(double x, double mu, double sigma) {
    if (sigma == 0) {
        throw std::invalid_argument("Standarta novirze nevar būt nulle.");
    }
    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

## Aprēķiniet z-score Ruby
def calculate_z_score(x, mu, sigma)
  raise ArgumentError, "Standarta novirze nevar būt nulle." if sigma == 0
  (x - mu) / sigma
end

## Piemēra izmantošana:
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
// Aprēķiniet z-score PHP
function calculate_z_score($x, $mu, $sigma) {
  if ($sigma == 0) {
    throw new Exception("Standarta novirze nevar būt nulle.");
  }
  return ($x - $mu) / $sigma;
}

// Piemēra izmantošana:
$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

// Aprēķiniet z-score Rust
fn calculate_z_score(x: f64, mu: f64, sigma: f64) -> Result<f64, String> {
    if sigma == 0.0 {
        return Err("Standarta novirze nevar būt nulle.".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#

// Aprēķiniet z-score C#
using System;

public class ZScoreCalculator
{
    public static double CalculateZScore(double x, double mu, double sigma)
    {
        if (sigma == 0)
            throw new ArgumentException("Standarta novirze nevar būt nulle.");
        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

// Aprēķiniet z-score Go
package main

import (
    "errors"
    "fmt"
)

func calculateZScore(x, mu, sigma float64) (float64, error) {
    if sigma == 0 {
        return 0, errors.New("standarta novirze nevar būt nulle")
    }
    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

// Aprēķiniet z-score Swift
func calculateZScore(x: Double, mu: Double, sigma: Double) throws -> Double {
    if sigma == 0 {
        throw NSError(domain: "Standarta novirze nevar būt nulle.", code: 1, userInfo: nil)
    }
    return (x - mu) / sigma
}

// Piemēra izmantošana:
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)
}

Atsauces

Standarta rādītājs - Vikipēdija

https://en.wikipedia.org/wiki/Standard_score
Z-scores izpratne - Statistikas risinājumi

https://www.statisticssolutions.com/understanding-z-scores/
Normālā sadalījuma un z-scores - Khan Academy

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

Papildu resursi

Interaktīvs z-score kalkulators

https://www.socscistatistics.com/pvalues/normaldistribution.aspx
Normālā sadalījuma vizualizācija

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

Loading related tools...