Whiz Tools

Z-Score Calculator

Introduction

z-score (ಅಥವಾ ಮಾನದಂಡ ಅಂಕ) ಒಂದು ಸಂಖ್ಯಾತ್ಮಕ ಅಳೆಯುವಿಕೆ, ಇದು ಒಂದು ಮೌಲ್ಯದ ಸಮೂಹದ ಮೌಲ್ಯಗಳ ಸರಾಸರಿ (mean) ಗೆ ಸಂಬಂಧವನ್ನು ವಿವರಿಸುತ್ತದೆ. ಇದು ಒಂದು ಅಂಶವು ಸರಾಸರಿ ಯಿಂದ ಎಷ್ಟು ಮಾನದಂಡ ವ್ಯತ್ಯಾಸಗಳಷ್ಟು ದೂರವಿದೆ ಎಂಬುದನ್ನು ಸೂಚಿಸುತ್ತದೆ. z-score ಸಂಖ್ಯಾಶಾಸ್ತ್ರದಲ್ಲಿ ಅತ್ಯಂತ ಮುಖ್ಯವಾದ ಸಾಧನವಾಗಿದೆ, ಇದು ವಿಭಿನ್ನ ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ಮಾನದಂಡಗೊಳಿಸಲು ಮತ್ತು ಹೊರಗೊಮ್ಮಲುಗಳನ್ನು ಗುರುತಿಸಲು ಅನುಮತಿಸುತ್ತದೆ.

Formula

z-score ಅನ್ನು ಕೆಳಗಿನ ಸೂತ್ರವನ್ನು ಬಳಸಿಕೊಂಡು ಲೆಕ್ಕಹಾಕಲಾಗುತ್ತದೆ:

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

Where:

  • 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

Where:

  • Φ(z)\Phi(z) = z ನಲ್ಲಿ ಮಾನದಂಡ ಸಾಮಾನ್ಯ ವಿತರಣೆಯ CDF

ಸಂಗ್ರಹಿತ ಸಂಭವನೀಯತೆ ಸಂಖ್ಯಾಶಾಸ್ತ್ರದಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ಶ್ರೇಣಿಯ ಒಳಗೆ ಒಬ್ಬ ವ್ಯಕ್ತಿಯ ಸಂಭವನೀಯತೆಯನ್ನು ನಿರ್ಧರಿಸಲು ಅಗತ್ಯವಿದೆ. ಇದು ಗುಣಮಟ್ಟದ ನಿಯಂತ್ರಣ, ಹಣಕಾಸು ಮತ್ತು ಸಾಮಾಜಿಕ ವಿಜ್ಞಾನಗಳಲ್ಲಿ ವ್ಯಾಪಕವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ.

SVG Diagram

ಕೆಳಗಿನ SVG ಚಿತ್ರವು ಮಾನದಂಡ ಸಾಮಾನ್ಯ ವಿತರಣಾ ವಕ್ರ ಮತ್ತು z-score ಅನ್ನು ಚಿತ್ರಿಸುತ್ತದೆ:

μ x z

ಮಾನದಂಡ ಸಾಮಾನ್ಯ ವಿತರಣಾ ವಕ್ರ

ಚಿತ್ರ: z-score ಗೆ ಶೇಡಿಂಗ್ ಮಾಡಿದ ಮಾನದಂಡ ಸಾಮಾನ್ಯ ವಿತರಣಾ ವಕ್ರ

ಈ ಚಿತ್ರವು ಸರಾಸರಿ μ\mu ಕೇಂದ್ರದಲ್ಲಿ ಇರುವ ಸಾಮಾನ್ಯ ವಿತರಣಾ ವಕ್ರವನ್ನು ತೋರಿಸುತ್ತದೆ. ಶೇಡಿಂಗ್ ಮಾಡಿದ ಪ್ರದೇಶವು z-score ಗೆ ಸಂಬಂಧಿಸಿದಂತೆ ಡೇಟಾ ಅಂಕಿ xx ಗೆ ಸಂಬಂಧಿಸಿದಂತೆ ಸಂಗ್ರಹಿತ ಸಂಭವನೀಯತೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.

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