Whiz Tools

Z-Score Calculator

Introduction

z-score (અથવા માનક સ્કોર) એ આંકડાશાસ્ત્રીય માપદંડ છે જે મૂલ્યના સમૂહના સરેરાશ સાથેના સંબંધને વર્ણવે છે. તે દર્શાવે છે કે કોઈ તત્વ સરેરાશથી કેટલાય માનક વિસંગતીઓ દૂર છે. z-score આંકડાશાસ્ત્રમાં એક મહત્વપૂર્ણ સાધન છે, જે વિવિધ ડેટાસેટ્સને માનક બનાવવા અને આઉટલાયર્સને ઓળખવા માટેની મંજૂરી આપે છે.

Formula

z-score ની ગણતરી નીચેની સૂત્રનો ઉપયોગ કરીને કરવામાં આવે છે:

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

જ્યાં:

  • zz = z-score
  • xx = વ્યક્તિગત ડેટા પોઇન્ટ
  • μ\mu = ડેટાસેટનો સરેરાશ
  • σ\sigma = ડેટાસેટનો માનક વિસંગતિ

આ સૂત્ર એ ગણતરી કરે છે કે ડેટા પોઇન્ટ સરેરાશથી કેટલાય માનક વિસંગતીઓ દૂર છે.

Calculation

ડેટા પોઇન્ટનો 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}

Edge Cases

  • શૂન્ય માનક વિસંગતિ (σ=0\sigma = 0):

    જ્યારે તમામ ડેટા પોઇન્ટ્સ સમાન હોય ત્યારે માનક વિસંગતિ શૂન્ય હોય છે, z-score અવિન્ય હોય છે કારણ કે તમે શૂન્ય દ્વારા ભાગ આપી શકતા નથી. આ કેસમાં, z-score નો વિચાર લાગુ પડતો નથી.

  • સરેરાશ સાથે સમાન ડેટા પોઇન્ટ (x=μx = \mu):

    જો ડેટા પોઇન્ટ સરેરાશ સાથે સમાન હોય, તો z-score શૂન્ય હોય છે, જે દર્શાવે છે કે તે ચોક્કસ સરેરાશ છે.

  • ગણિતીય ઇનપુટ્સ:

    ખાતરી કરો કે તમામ ઇનપુટ્સ ગણિતીય છે. ગેર-ગણિતીય ઇનપુટ્સ ગણતરીની ભૂલનો પરિણામ આપે છે.

Cumulative Probability

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) = z પર માનક સામાન્ય વિતરણનું CDF

સંકલિત સંભાવના આંકડાશાસ્ત્રમાં મહત્વપૂર્ણ છે કારણ કે તે ચોક્કસ શ્રેણીમાં મૂલ્યના ઘટવા માટેની સંભાવનાને નક્કી કરવામાં મદદ કરે છે. તે ગુણવત્તા નિયંત્રણ, નાણાકીય અને સામાજિક વિજ્ઞાન જેવા ક્ષેત્રોમાં વ્યાપકપણે ઉપયોગમાં લેવાય છે.

SVG Diagram

નીચે એક SVG આકૃતિ છે જે માનક સામાન્ય વિતરણ વક્ર અને z-score ને દર્શાવે છે:

μ x z

માનક સામાન્ય વિતરણ

આકૃતિ: z-score સાથેનું માનક સામાન્ય વિતરણ વક્ર

આ આકૃતિમાં માનક વિતરણ વક્ર છે જેમાં સરેરાશ μ\mu કેન્દ્રમાં છે. છાયિત વિસ્તાર ડેટા પોઇન્ટ xx સુધીની સંકલિત સંભાવનાને દર્શાવે છે, જે z-score સાથે સંબંધિત છે.

Use Cases

Applications

  • વિભિન્ન સ્કેલ્સમાં માનકકરણ:

    z-scores વિવિધ સ્કેલ્સમાંથી ડેટાને સરખાવા માટેની મંજૂરી આપે છે.

  • આઉટલાયર શોધ:

    તે ડેટા પોઇન્ટ્સને ઓળખવા માટે જે સરેરાશથી નોંધપાત્ર રીતે દૂર છે (ઉદાહરણ તરીકે, z-scores -3 કરતા ઓછા અથવા 3 કરતા વધુ).

  • આંકડાશાસ્ત્રીય પરીક્ષણ:

    નમૂના સરેરાશ જાણીતું વસ્તી સરેરાશથી નોંધપાત્ર રીતે અલગ છે કે નહીં તે નક્કી કરવા માટે z-tests સહિતની હિપોથિસિસ પરીક્ષણોમાં ઉપયોગમાં લેવાય છે.

  • ગુણવત્તા નિયંત્રણ:

    ઉત્પાદન ક્ષેત્રમાં, z-scores પ્રક્રિયાઓની દેખરેખ રાખવામાં મદદ કરે છે જેથી ખાતરી થાય કે આઉટપુટ સ્વીકૃત મર્યાદાઓમાં રહે છે.

  • નાણાં અને રોકાણ:

    સરેરાશ બજારના પ્રદર્શનની સરખામણી કરીને સ્ટોકના પ્રદર્શનને આંકવા માટે.

Alternatives

  • T-Score:

    z-score ની જેમ પરંતુ જ્યારે નમૂના કદ નાના હોય અને વસ્તી માનક વિસંગતિ અજાણ હોય ત્યારે ઉપયોગમાં લેવાય છે.

  • પ્રતિશત રેન્ક:

    તે દર્શાવે છે કે તેના ફ્રિક્વન્સી વિતરણમાં કેટલા સ્કોર સમાન અથવા ઓછા છે.

  • માનક વિસંગતિ એકમો:

    z-scores તરીકે માનક બનાવ્યા વિના કાચા માનક વિસંગતિ મૂલ્યોનો ઉપયોગ કરવો.

History

z-score નો વિચાર 19મી સદીના આરંભમાં કાર્લ ફ્રિડ્રિચ ગોસ દ્વારા સામાન્ય વિતરણ પરના કાર્યમાંથી ઉદ્ભવ્યો. z-scores માટેની મૂળભૂત માનક સામાન્ય વિતરણને એબ્રાહમ ડે મોઇવ્ર અને પિયર-સિમોન લાપ્લેસ જેવા આંકડાશાસ્ત્રીઓ દ્વારા વધુ વિકસાવવામાં આવ્યું. 20મી સદીમાં આંકડાશાસ્ત્રીય પદ્ધતિઓના વિકાસ સાથે z-scores નો ઉપયોગ વ્યાપકપણે થયો, ખાસ કરીને માનસશાસ્ત્રીય પરીક્ષણ અને ગુણવત્તા નિયંત્રણમાં.

Examples

Excel

## Excel માં z-score ની ગણતરી કરો
## માન લો કે ડેટા પોઇન્ટ A2 માં છે, સરેરાશ B2 માં છે, અને માનક વિસંગતિ C2 માં છે
=(A2 - B2) / C2

R

## R માં z-score ની ગણતરી કરો
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

% MATLAB માં z-score ની ગણતરી કરો
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

// JavaScript માં z-score ની ગણતરી કરો
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

## Python માં z-score ની ગણતરી કરો
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

// Java માં z-score ની ગણતરી કરો
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++

// C++ માં z-score ની ગણતરી કરો
#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

## Ruby માં z-score ની ગણતરી કરો
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
// PHP માં z-score ની ગણતરી કરો
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

// Rust માં z-score ની ગણતરી કરો
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#

// C# માં z-score ની ગણતરી કરો
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

// Go માં z-score ની ગણતરી કરો
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

// Swift માં z-score ની ગણતરી કરો
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)
}

References

  1. Standard Score - Wikipedia

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

  2. Understanding Z-Scores - Statistics Solutions

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

  3. Normal Distribution and Z-Scores - Khan Academy

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

Additional Resources

Loading related tools...
Feedback