Whiz Tools

מחשבון Z-Score

הקדמה

ה-Z-Score (או הציון הסטנדרטי) הוא מדד סטטיסטי שמתאר את הקשר של ערך לממוצע של קבוצת ערכים. הוא מצביע על כמה סטיות תקן אלמנט נמצא מהממוצע. ה-Z-Score הוא כלי חיוני בסטטיסטיקה, המאפשר את הסטנדרטיזציה של מערכות נתונים שונות וזיהוי ערכים חריגים.

נוסחה

ה-Z-Score מחושב באמצעות הנוסחה הבאה:

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

איפה:

  • zz = Z-Score
  • xx = נקודת נתון בודדת
  • μ\mu = ממוצע קבוצת הנתונים
  • σ\sigma = סטיית תקן של קבוצת הנתונים

נוסחה זו מחשבת את מספר הסטיות התקן שנקודת נתון נמצאת מהממוצע.

חישוב

כדי לחשב את ה-Z-Score של נקודת נתון:

  1. חשב את הממוצע (μ\mu):

    סכום כל נקודות הנתון וחלק את התוצאה במספר נקודות הנתון.

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

  2. חשב את סטיית התקן (σ\sigma):

    • שונות (σ2\sigma^2):

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

    • סטיית תקן:

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

  3. חשב את ה-Z-Score:

    החלף את הערכים בנוסחת ה-Z-Score.

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

מקרים קצה

  • סטיית תקן אפס (σ=0\sigma = 0):

    כאשר כל נקודות הנתון זהות, סטיית התקן היא אפס, מה שהופך את ה-Z-Score לבלתי מוגדר מכיוון שאין אפשרות לחלק באפס. במקרה זה, המושג של Z-Score אינו חל.

  • נקודת נתון שווה לממוצע (x=μx = \mu):

    אם נקודת הנתון שווה לממוצע, ה-Z-Score הוא אפס, מה שמעיד שהיא בדיוק ממוצעת.

  • קלטים לא מספריים:

    ודא שכל הקלטים הם מספריים. קלטים לא מספריים יגרמו לשגיאות חישוב.

הסתברות מצטברת

ההסתברות המצטברת הקשורה ל-Z-Score מייצגת את ההסתברות שמשתנה אקראי מהתפלגות נורמלית סטנדרטית יהיה קטן או שווה לערך הנתון. זו השטח מתחת לעקומת ההתפלגות הנורמלית משמאל ל-Z-Score המוגדר.

מתמטית, ההסתברות המצטברת PP מחושבת באמצעות פונקציית ההתפלגות המצטברת (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

איפה:

  • Φ(z)\Phi(z) = CDF של ההתפלגות הנורמלית הסטנדרטית ב-zz

ההסתברות המצטברת היא חיונית בסטטיסטיקה לקביעת הסבירות של ערך להתרחש בטווח מסוים. היא בשימוש נרחב בתחומים כמו בקרת איכות, פיננסים ומדעי החברה.

דיאגרמת SVG

להלן דיאגרמת SVG הממחישה את עקומת ההתפלגות הנורמלית הסטנדרטית ואת ה-Z-Score:

μ x z

התפלגות נורמלית סטנדרטית

איור: עקומת התפלגות נורמלית עם Z-Score מוצל

דיאגרמה זו מציגה את עקומת ההתפלגות הנורמלית עם הממוצע μ\mu במרכז. האזור המוצל מייצג את ההסתברות המצטברת עד לנקודת הנתון xx, המתאימה ל-Z-Score.

שימושים

יישומים

  • סטנדרטיזציה בין סולמות שונים:

    Z-Scores מאפשרים השוואה בין נתונים מסולמות שונים על ידי סטנדרטיזציה של מערכות הנתונים.

  • זיהוי ערכים חריגים:

    זיהוי נקודות נתון שהן מרוחקות באופן משמעותי מהממוצע (למשל, Z-Scores פחות מ--3 או יותר מ-3).

  • בדיקות סטטיסטיות:

    בשימוש בבדיקות השערות, כולל בדיקות Z, כדי לקבוע אם ממוצע דגימה שונה באופן משמעותי מממוצע אוכלוסייה ידוע.

  • בקרת איכות:

    בייצור, Z-Scores מסייעים במעקב אחר תהליכים כדי להבטיח שהתוצרים נשארים בטווחים מקובלים.

  • פיננסים והשקעות:

    הערכת ביצועי מניות על ידי השוואת תשואות ביחס לביצועים הממוצעים של השוק.

אלטרנטיבות

  • T-Score:

    דומה ל-Z-Score אך בשימוש כאשר גודל הדגימה קטן וסטיית התקן של האוכלוסייה אינה ידועה.

  • דרגת אחוזון:

    מציינת את האחוז של ציונים בהתפלגות התדירות שלה שווים או נמוכים ממנה.

  • יחידות סטיית תקן:

    שימוש בערכים גולמיים של סטיית תקן מבלי לסטנדרטיזציה כ-Z-Scores.

היסטוריה

המושג Z-Score נובע מעבודות על ההתפלגות הנורמלית על ידי קרל פרידריך גאוס במאה ה-19. ההתפלגות הנורמלית הסטנדרטית, שהיא יסודית ל-Z-Scores, פותחה עוד יותר על ידי סטטיסטיקאים כמו אברהם דה מוובר ופייר-סימון לפלס. השימוש ב-Z-Scores הפך לנרחב עם התקדמות השיטות הסטטיסטיות במאה ה-20, במיוחד במבחנים פסיכולוגיים ובקרת איכות.

דוגמאות

Excel

## חשב Z-Score ב-Excel
## בהנחה שנקודת הנתון בתא A2, ממוצע בתא B2, סטיית תקן בתא C2
=(A2 - B2) / C2

R

## חשב Z-Score ב-R
calculate_z_score <- function(x, mean, sd) {
  if (sd == 0) {
    stop("סטיית תקן לא יכולה להיות אפס.")
  }
  z <- (x - mean) / sd
  return(z)
}

## דוגמת שימוש:
x <- 85
mu <- 75
sigma <- 5
z_score <- calculate_z_score(x, mu, sigma)
print(paste("Z-score:", z_score))

MATLAB

% חשב Z-Score ב-MATLAB
function z = calculate_z_score(x, mu, sigma)
    if sigma == 0
        error('סטיית תקן לא יכולה להיות אפס.');
    end
    z = (x - mu) / sigma;
end

% דוגמת שימוש:
x = 90;
mu = 80;
sigma = 8;
z = calculate_z_score(x, mu, sigma);
fprintf('Z-score: %.2f\n', z);

JavaScript

// חשב Z-Score ב-JavaScript
function calculateZScore(x, mu, sigma) {
  if (sigma === 0) {
    throw new Error('סטיית תקן לא יכולה להיות אפס.');
  }
  return (x - mu) / sigma;
}

// דוגמת שימוש:
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

## חשב Z-Score ב-Python
def calculate_z_score(x, mu, sigma):
    if sigma == 0:
        raise ValueError("סטיית תקן לא יכולה להיות אפס.")
    return (x - mu) / sigma

## דוגמת שימוש:
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

// חשב Z-Score ב-Java
public class ZScoreCalculator {
    public static double calculateZScore(double x, double mu, double sigma) {
        if (sigma == 0) {
            throw new IllegalArgumentException("סטיית תקן לא יכולה להיות אפס.");
        }
        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++

// חשב Z-Score ב-C++
#include <iostream>
#include <stdexcept>

double calculate_z_score(double x, double mu, double sigma) {
    if (sigma == 0) {
        throw std::invalid_argument("סטיית תקן לא יכולה להיות אפס.");
    }
    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

## חשב Z-Score ב-Ruby
def calculate_z_score(x, mu, sigma)
  raise ArgumentError, "סטיית תקן לא יכולה להיות אפס." if sigma == 0
  (x - mu) / sigma
end

## דוגמת שימוש:
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
// חשב Z-Score ב-PHP
function calculate_z_score($x, $mu, $sigma) {
  if ($sigma == 0) {
    throw new Exception("סטיית תקן לא יכולה להיות אפס.");
  }
  return ($x - $mu) / $sigma;
}

// דוגמת שימוש:
$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

// חשב Z-Score ב-Rust
fn calculate_z_score(x: f64, mu: f64, sigma: f64) -> Result<f64, String> {
    if sigma == 0.0 {
        return Err("סטיית תקן לא יכולה להיות אפס.".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#

// חשב Z-Score ב-C#
using System;

public class ZScoreCalculator
{
    public static double CalculateZScore(double x, double mu, double sigma)
    {
        if (sigma == 0)
            throw new ArgumentException("סטיית תקן לא יכולה להיות אפס.");
        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

// חשב Z-Score ב-Go
package main

import (
    "errors"
    "fmt"
)

func calculateZScore(x, mu, sigma float64) (float64, error) {
    if sigma == 0 {
        return 0, errors.New("סטיית תקן לא יכולה להיות אפס")
    }
    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

// חשב Z-Score ב-Swift
func calculateZScore(x: Double, mu: Double, sigma: Double) throws -> Double {
    if sigma == 0 {
        throw NSError(domain: "סטיית תקן לא יכולה להיות אפס.", code: 1, userInfo: nil)
    }
    return (x - mu) / sigma
}

// דוגמת שימוש:
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)
}

מקורות

  1. ציון סטנדרטי - ויקיפדיה

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

  2. הבנת Z-Scores - Statistics Solutions

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

  3. התפלגות נורמלית ו-Z-Scores - Khan Academy

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

משאבים נוספים

Loading related tools...
Feedback