Whiz Tools

Calcolatore Z-Score

Introduzione

Lo z-score (o punteggio standard) è una misura statistica che descrive la relazione di un valore rispetto alla media di un gruppo di valori. Indica quante deviazioni standard un elemento si discosta dalla media. Lo z-score è uno strumento cruciale in statistica, che consente la standardizzazione di diversi set di dati e l'identificazione di valori anomali.

Formula

Lo z-score viene calcolato utilizzando la seguente formula:

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

Dove:

  • zz = z-score
  • xx = punto dati individuale
  • μ\mu = media del set di dati
  • σ\sigma = deviazione standard del set di dati

Questa formula calcola il numero di deviazioni standard di un punto dati dalla media.

Calcolo

Per calcolare lo z-score di un punto dati:

  1. Calcolare la Media (μ\mu):

    Somma tutti i punti dati e dividi per il numero di punti dati.

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

  2. Calcolare la Deviazione Standard (σ\sigma):

    • Varianza (σ2\sigma^2):

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

    • Deviazione Standard:

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

  3. Calcolare lo Z-Score:

    Sostituisci i valori nella formula dello z-score.

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

Casi Limite

  • Deviazione Standard Zero (σ=0\sigma = 0):

    Quando tutti i punti dati sono identici, la deviazione standard è zero, rendendo lo z-score indefinito perché non puoi dividere per zero. In questo caso, il concetto di z-score non si applica.

  • Punto Dati Uguale alla Media (x=μx = \mu):

    Se il punto dati è uguale alla media, lo z-score è zero, indicando che è esattamente nella media.

  • Input Non Numerici:

    Assicurati che tutti gli input siano numerici. Gli input non numerici causeranno errori di calcolo.

Probabilità Cumulativa

La probabilità cumulativa associata a uno z-score rappresenta la probabilità che una variabile casuale di una distribuzione normale standard sia minore o uguale al valore dato. È l'area sotto la curva di distribuzione normale a sinistra dello z-score specificato.

Matematicamente, la probabilità cumulativa PP viene calcolata utilizzando la funzione di distribuzione cumulativa (CDF) della distribuzione normale standard:

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

Dove:

  • Φ(z)\Phi(z) = CDF della distribuzione normale standard a zz

La probabilità cumulativa è essenziale in statistica per determinare la probabilità che un valore si verifichi all'interno di un certo intervallo. È ampiamente utilizzata in campi come il controllo qualità, la finanza e le scienze sociali.

Diagramma SVG

Di seguito è riportato un diagramma SVG che illustra la curva di distribuzione normale standard e lo z-score:

μ x z

Distribuzione Normale Standard

Figura: Curva di Distribuzione Normale Standard con Z-Score Ombreggiato

Questo diagramma mostra la curva di distribuzione normale con la media μ\mu al centro. L'area ombreggiata rappresenta la probabilità cumulativa fino al punto dati xx, corrispondente allo z-score.

Casi d'Uso

Applicazioni

  • Standardizzazione tra Scale Diverse:

    Gli z-score consentono il confronto tra dati provenienti da scale diverse standardizzando i set di dati.

  • Identificazione di Valori Anomali:

    Identificazione di punti dati che si discostano significativamente dalla media (ad es., z-score inferiori a -3 o superiori a 3).

  • Test Statistici:

    Utilizzati nei test di ipotesi, inclusi i test z, per determinare se una media campionaria si discosta significativamente da una media di popolazione nota.

  • Controllo Qualità:

    Nella produzione, gli z-score aiutano a monitorare i processi per garantire che i risultati rimangano entro limiti accettabili.

  • Finanza e Investimenti:

    Valutazione delle performance azionarie confrontando i rendimenti rispetto alla performance media del mercato.

Alternative

  • T-Score:

    Simile allo z-score ma utilizzato quando la dimensione del campione è piccola e la deviazione standard della popolazione è sconosciuta.

  • Classifica Percentile:

    Indica la percentuale di punteggi nella sua distribuzione di frequenza che sono uguali o inferiori ad esso.

  • Unità di Deviazione Standard:

    Utilizzo dei valori di deviazione standard grezzi senza standardizzazione come z-score.

Storia

Il concetto di z-score deriva dal lavoro sulla distribuzione normale di Carl Friedrich Gauss all'inizio del XIX secolo. La distribuzione normale standard, fondamentale per gli z-score, è stata ulteriormente sviluppata da statistici come Abraham de Moivre e Pierre-Simon Laplace. L'uso degli z-score è diventato ampiamente diffuso con l'avanzamento dei metodi statistici nel XX secolo, in particolare nei test psicologici e nel controllo qualità.

Esempi

Excel

## Calcolare z-score in Excel
## Supponendo che il punto dati sia nella cella A2, la media nella cella B2, la deviazione standard nella cella C2
=(A2 - B2) / C2

R

## Calcolare z-score in R
calculate_z_score <- function(x, mean, sd) {
  if (sd == 0) {
    stop("La deviazione standard non può essere zero.")
  }
  z <- (x - mean) / sd
  return(z)
}

## Esempio di utilizzo:
x <- 85
mu <- 75
sigma <- 5
z_score <- calculate_z_score(x, mu, sigma)
print(paste("Z-score:", z_score))

MATLAB

% Calcolare z-score in MATLAB
function z = calculate_z_score(x, mu, sigma)
    if sigma == 0
        error('La deviazione standard non può essere zero.');
    end
    z = (x - mu) / sigma;
end

% Esempio di utilizzo:
x = 90;
mu = 80;
sigma = 8;
z = calculate_z_score(x, mu, sigma);
fprintf('Z-score: %.2f\n', z);

JavaScript

// Calcolare z-score in JavaScript
function calculateZScore(x, mu, sigma) {
  if (sigma === 0) {
    throw new Error('La deviazione standard non può essere zero.');
  }
  return (x - mu) / sigma;
}

// Esempio di utilizzo:
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

## Calcolare z-score in Python
def calculate_z_score(x, mu, sigma):
    if sigma == 0:
        raise ValueError("La deviazione standard non può essere zero.")
    return (x - mu) / sigma

## Esempio di utilizzo:
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

// Calcolare z-score in Java
public class ZScoreCalculator {
    public static double calculateZScore(double x, double mu, double sigma) {
        if (sigma == 0) {
            throw new IllegalArgumentException("La deviazione standard non può essere zero.");
        }
        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++

// Calcolare z-score in C++
#include <iostream>
#include <stdexcept>

double calculate_z_score(double x, double mu, double sigma) {
    if (sigma == 0) {
        throw std::invalid_argument("La deviazione standard non può essere zero.");
    }
    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

## Calcolare z-score in Ruby
def calculate_z_score(x, mu, sigma)
  raise ArgumentError, "La deviazione standard non può essere zero." if sigma == 0
  (x - mu) / sigma
end

## Esempio di utilizzo:
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
// Calcolare z-score in PHP
function calculate_z_score($x, $mu, $sigma) {
  if ($sigma == 0) {
    throw new Exception("La deviazione standard non può essere zero.");
  }
  return ($x - $mu) / $sigma;
}

// Esempio di utilizzo:
$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

// Calcolare z-score in Rust
fn calculate_z_score(x: f64, mu: f64, sigma: f64) -> Result<f64, String> {
    if sigma == 0.0 {
        return Err("La deviazione standard non può essere zero.".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#

// Calcolare z-score in C#
using System;

public class ZScoreCalculator
{
    public static double CalculateZScore(double x, double mu, double sigma)
    {
        if (sigma == 0)
            throw new ArgumentException("La deviazione standard non può essere zero.");
        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

// Calcolare z-score in Go
package main

import (
    "errors"
    "fmt"
)

func calculateZScore(x, mu, sigma float64) (float64, error) {
    if sigma == 0 {
        return 0, errors.New("la deviazione standard non può essere zero")
    }
    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

// Calcolare z-score in Swift
func calculateZScore(x: Double, mu: Double, sigma: Double) throws -> Double {
    if sigma == 0 {
        throw NSError(domain: "La deviazione standard non può essere zero.", code: 1, userInfo: nil)
    }
    return (x - mu) / sigma
}

// Esempio di utilizzo:
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)
}

Riferimenti

  1. Punteggio Standard - Wikipedia

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

  2. Comprendere gli Z-Scores - Statistics Solutions

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

  3. Distribuzione Normale e Z-Scores - Khan Academy

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

Risorse Aggiuntive

Loading related tools...
Feedback