Calculadora de Z-Score per a Anàlisi Estadística

Calculadora de Z-Score

Introducció

El z-score (o puntuació estàndard) és una mesura estadística que descriu la relació d'un valor amb la mitjana d'un grup de valors. Indica quantes desviacions estàndard un element es troba de la mitjana. El z-score és una eina crucial en estadística, que permet la standardització de diferents conjunts de dades i la identificació de valors atípics.

Fórmula

El z-score es calcula mitjançant la següent fórmula:

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

On:

$z$ = z-score
$x$ = punt de dades individual
$\mu$ = mitjana del conjunt de dades
$\sigma$ = desviació estàndard del conjunt de dades

Aquesta fórmula calcula el nombre de desviacions estàndard que un punt de dades es troba de la mitjana.

Càlcul

Per calcular el z-score d'un punt de dades:

Calcular la Mitjana ( $\mu$ ):

Suma tots els punts de dades i divideix per el nombre de punts de dades.
$\mu = \frac{\sum_{i=1}^{n} x_i}{n}$
Calcular la Desviació Estàndard ( $\sigma$ ):
- Variància ( $\sigma^2$ ):
  $\sigma^2 = \frac{\sum_{i=1}^{n} (x_i - \mu)^2}{n}$
- Desviació Estàndard:
  $\sigma = \sqrt{\sigma^2}$
Calcular el Z-Score:

Substitueix els valors a la fórmula del z-score.
$z = \frac{x - \mu}{\sigma}$

Casos Límit

Desviació Estàndard Zero ( $\sigma = 0$ ):

Quan tots els punts de dades són idèntics, la desviació estàndard és zero, fent que el z-score sigui indefinit perquè no es pot dividir per zero. En aquest cas, el concepte de z-score no s'aplica.
Punt de Dades Igual a la Mitjana ( $x = \mu$ ):

Si el punt de dades és igual a la mitjana, el z-score és zero, indicant que és exactament mitjà.
Entrades No Numèriques:

Assegura't que totes les entrades siguin numèriques. Les entrades no numèriques resultaran en errors de càlcul.

Probabilitat Cumulativa

La probabilitat acumulada associada a un z-score representa la probabilitat que una variable aleatòria d'una distribució normal estàndard sigui menor o igual al valor donat. És l'àrea sota la corba de distribució normal a l'esquerra del z-score especificat.

Matemàticament, la probabilitat acumulada $P$ es calcula mitjançant la funció de distribució acumulativa (CDF) de la distribució normal estàndard:

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

On:

$\Phi(z)$ = CDF de la distribució normal estàndard a $z$

La probabilitat acumulada és essencial en estadística per determinar la probabilitat que un valor ocorri dins d'un cert rang. S'utilitza àmpliament en camps com el control de qualitat, les finances i les ciències socials.

Diagrama SVG

A continuació es mostra un diagrama SVG que il·lustra la corba de distribució normal estàndard i el z-score:

μ x z

Distribució Normal Estàndard

Figura: Corba de Distribució Normal Estàndard amb Z-Score Sombreat

Aquest diagrama mostra la corba de distribució normal amb la mitjana $\mu$ al centre. L'àrea sombregada representa la probabilitat acumulada fins al punt de dades $x$ , corresponent al z-score.

Casos d'Ús

Aplicacions

Standardització a través de Diferents Escales:

Els z-scores permeten la comparació entre dades de diferents escales mitjançant la standardització dels conjunts de dades.
Detecció de Valors Atípics:

Identificació de punts de dades que són significativament llunyans de la mitjana (per exemple, z-scores menors que -3 o majors que 3).
Proves Estadístiques:

Utilitzat en proves d'hipòtesis, incloent proves z, per determinar si una mitjana de mostra difereix significativament d'una mitjana poblacional coneguda.
Control de Qualitat:

En fabricació, els z-scores ajuden a monitorar processos per assegurar que els resultats es mantinguin dins de límits acceptables.
Finances i Inversió:

Avaluar el rendiment de les accions comparant els rendiments relatius al rendiment mitjà del mercat.

Alternatives

T-Score:

Similar al z-score però utilitzat quan la mida de la mostra és petita i la desviació estàndard poblacional és desconeguda.
Rang Percentil:

Indica el percentatge de puntuacions en la seva distribució de freqüència que són iguals o inferiors a ell.
Unitats de Desviació Estàndard:

Utilitzant valors de desviació estàndard en brut sense standarditzar com a z-scores.

Història

El concepte de z-score prové del treball sobre la distribució normal de Carl Friedrich Gauss a principis del segle XIX. La distribució normal estàndard, fonamental per als z-scores, va ser desenvolupada més a fons per estadístics com Abraham de Moivre i Pierre-Simon Laplace. L'ús de z-scores es va fer àmpliament conegut amb l'avançament dels mètodes estadístics al segle XX, particularment en proves psicològiques i control de qualitat.

Exemples

Excel

1## Calcular z-score a Excel
2## Suposant que el punt de dades està a la cel·la A2, la mitjana a la cel·la B2, la desviació estàndard a la cel·la C2
3=(A2 - B2) / C2
4

R

1## Calcular z-score a R
2calculate_z_score <- function(x, mean, sd) {
3  if (sd == 0) {
4    stop("La desviació estàndard no pot ser zero.")
5  }
6  z <- (x - mean) / sd
7  return(z)
8}
9
10## Exemple d'ús:
11x <- 85
12mu <- 75
13sigma <- 5
14z_score <- calculate_z_score(x, mu, sigma)
15print(paste("Z-score:", z_score))
16

MATLAB

1% Calcular z-score a MATLAB
2function z = calculate_z_score(x, mu, sigma)
3    if sigma == 0
4        error('La desviació estàndard no pot ser zero.');
5    end
6    z = (x - mu) / sigma;
7end
8
9% Exemple d'ús:
10x = 90;
11mu = 80;
12sigma = 8;
13z = calculate_z_score(x, mu, sigma);
14fprintf('Z-score: %.2f\n', z);
15

JavaScript

1// Calcular z-score a JavaScript
2function calculateZScore(x, mu, sigma) {
3  if (sigma === 0) {
4    throw new Error('La desviació estàndard no pot ser zero.');
5  }
6  return (x - mu) / sigma;
7}
8
9// Exemple d'ús:
10const x = 100;
11const mu = 85;
12const sigma = 7;
13try {
14  const z = calculateZScore(x, mu, sigma);
15  console.log(`Z-score: ${z.toFixed(2)}`);
16} catch (error) {
17  console.error(error.message);
18}
19

Python

1## Calcular z-score a Python
2def calculate_z_score(x, mu, sigma):
3    if sigma == 0:
4        raise ValueError("La desviació estàndard no pot ser zero.")
5    return (x - mu) / sigma
6
7## Exemple d'ús:
8x = 95
9mu = 88
10sigma = 4
11try:
12    z = calculate_z_score(x, mu, sigma)
13    print("Z-score:", round(z, 2))
14except ValueError as e:
15    print(e)
16

Java

1// Calcular z-score a Java
2public class ZScoreCalculator {
3    public static double calculateZScore(double x, double mu, double sigma) {
4        if (sigma == 0) {
5            throw new IllegalArgumentException("La desviació estàndard no pot ser zero.");
6        }
7        return (x - mu) / sigma;
8    }
9
10    public static void main(String[] args) {
11        double x = 110;
12        double mu = 100;
13        double sigma = 5;
14
15        try {
16            double z = calculateZScore(x, mu, sigma);
17            System.out.printf("Z-score: %.2f%n", z);
18        } catch (IllegalArgumentException e) {
19            System.err.println(e.getMessage());
20        }
21    }
22}
23

C/C++

1// Calcular z-score a C++
2#include <iostream>
3#include <stdexcept>
4
5double calculate_z_score(double x, double mu, double sigma) {
6    if (sigma == 0) {
7        throw std::invalid_argument("La desviació estàndard no pot ser zero.");
8    }
9    return (x - mu) / sigma;
10}
11
12int main() {
13    double x = 130;
14    double mu = 120;
15    double sigma = 10;
16
17    try {
18        double z = calculate_z_score(x, mu, sigma);
19        std::cout << "Z-score: " << z << std::endl;
20    } catch (const std::exception &e) {
21        std::cerr << e.what() << std::endl;
22    }
23
24    return 0;
25}
26

Ruby

1## Calcular z-score a Ruby
2def calculate_z_score(x, mu, sigma)
3  raise ArgumentError, "La desviació estàndard no pot ser zero." if sigma == 0
4  (x - mu) / sigma
5end
6
7## Exemple d'ús:
8x = 105
9mu = 100
10sigma = 5
11begin
12  z = calculate_z_score(x, mu, sigma)
13  puts "Z-score: #{z.round(2)}"
14rescue ArgumentError => e
15  puts e.message
16end
17

PHP

1<?php
2// Calcular z-score a PHP
3function calculate_z_score($x, $mu, $sigma) {
4  if ($sigma == 0) {
5    throw new Exception("La desviació estàndard no pot ser zero.");
6  }
7  return ($x - $mu) / $sigma;
8}
9
10// Exemple d'ús:
11$x = 115;
12$mu = 110;
13$sigma = 5;
14
15try {
16  $z = calculate_z_score($x, $mu, $sigma);
17  echo "Z-score: " . round($z, 2);
18} catch (Exception $e) {
19  echo $e->getMessage();
20}
21?>
22

Rust

1// Calcular z-score a Rust
2fn calculate_z_score(x: f64, mu: f64, sigma: f64) -> Result<f64, String> {
3    if sigma == 0.0 {
4        return Err("La desviació estàndard no pot ser zero.".to_string());
5    }
6    Ok((x - mu) / sigma)
7}
8
9fn main() {
10    let x = 125.0;
11    let mu = 115.0;
12    let sigma = 5.0;
13
14    match calculate_z_score(x, mu, sigma) {
15        Ok(z) => println!("Z-score: {:.2}", z),
16        Err(e) => println!("{}", e),
17    }
18}
19

C#

1// Calcular z-score a C#
2using System;
3
4public class ZScoreCalculator
5{
6    public static double CalculateZScore(double x, double mu, double sigma)
7    {
8        if (sigma == 0)
9            throw new ArgumentException("La desviació estàndard no pot ser zero.");
10        return (x - mu) / sigma;
11    }
12
13    public static void Main()
14    {
15        double x = 135;
16        double mu = 125;
17        double sigma = 5;
18
19        try
20        {
21            double z = CalculateZScore(x, mu, sigma);
22            Console.WriteLine($"Z-score: {z:F2}");
23        }
24        catch (ArgumentException e)
25        {
26            Console.WriteLine(e.Message);
27        }
28    }
29}
30

Go

1// Calcular z-score a Go
2package main
3
4import (
5    "errors"
6    "fmt"
7)
8
9func calculateZScore(x, mu, sigma float64) (float64, error) {
10    if sigma == 0 {
11        return 0, errors.New("la desviació estàndard no pot ser zero")
12    }
13    return (x - mu) / sigma, nil
14}
15
16func main() {
17    x := 140.0
18    mu := 130.0
19    sigma := 5.0
20
21    z, err := calculateZScore(x, mu, sigma)
22    if err != nil {
23        fmt.Println(err)
24    } else {
25        fmt.Printf("Z-score: %.2f\n", z)
26    }
27}
28

Swift

1// Calcular z-score a Swift
2func calculateZScore(x: Double, mu: Double, sigma: Double) throws -> Double {
3    if sigma == 0 {
4        throw NSError(domain: "La desviació estàndard no pot ser zero.", code: 1, userInfo: nil)
5    }
6    return (x - mu) / sigma
7}
8
9// Exemple d'ús:
10let x = 120.0
11let mu = 110.0
12let sigma = 5.0
13
14do {
15    let z = try calculateZScore(x: x, mu: mu, sigma: sigma)
16    print("Z-score: \(String(format: "%.2f", z))")
17} catch let error as NSError {
18    print(error.domain)
19}
20

Referències

Puntuació Estàndard - Wikipedia

https://ca.wikipedia.org/wiki/Puntuaci%C3%B3_est%C3%A0ndard
Entenent els Z-Scores - Statistics Solutions

https://www.statisticssolutions.com/understanding-z-scores/
Distribució Normal i Z-Scores - Khan Academy

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

Recursos Addicionals

Calculadora Interactiva de Z-Score

https://www.socscistatistics.com/pvalues/normaldistribution.aspx
Visualitzant la Distribució Normal

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

Calculadora de Z-Score per a Anàlisi Estadística

Documentació