Calculadora de Z-Score para Análisis Estadístico y Datos

Calculadora de Z-Score

Introducción

El z-score (o puntuación estándar) es una medida estadística que describe la relación de un valor con la media de un grupo de valores. Indica cuántas desviaciones estándar se encuentra un elemento de la media. El z-score es una herramienta crucial en estadística, permitiendo la estandarización de diferentes conjuntos de datos e identificación de valores atípicos.

Fórmula

El z-score se calcula utilizando la siguiente fórmula:

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

Donde:

$z$ = z-score
$x$ = punto de datos individual
$\mu$ = media del conjunto de datos
$\sigma$ = desviación estándar del conjunto de datos

Esta fórmula calcula el número de desviaciones estándar que un punto de datos se encuentra de la media.

Cálculo

Para calcular el z-score de un punto de datos:

Calcular la Media ( $\mu$ ):

Suma todos los puntos de datos y divide por el número de puntos de datos.
$\mu = \frac{\sum_{i=1}^{n} x_i}{n}$
Calcular la Desviación Estándar ( $\sigma$ ):
- Varianza ( $\sigma^2$ ):
  $\sigma^2 = \frac{\sum_{i=1}^{n} (x_i - \mu)^2}{n}$
- Desviación Estándar:
  $\sigma = \sqrt{\sigma^2}$
Calcular el Z-Score:

Sustituir los valores en la fórmula del z-score.
$z = \frac{x - \mu}{\sigma}$

Casos Especiales

Desviación Estándar Cero ( $\sigma = 0$ ):

Cuando todos los puntos de datos son idénticos, la desviación estándar es cero, lo que hace que el z-score sea indefinido porque no se puede dividir por cero. En este caso, el concepto de z-score no se aplica.
Punto de Datos Igual a la Media ( $x = \mu$ ):

Si el punto de datos es igual a la media, el z-score es cero, lo que indica que es exactamente promedio.
Entradas No Numéricas:

Asegúrese de que todas las entradas sean numéricas. Las entradas no numéricas resultarán en errores de cálculo.

Probabilidad Acumulativa

La probabilidad acumulativa asociada a un z-score representa la probabilidad de que una variable aleatoria de una distribución normal estándar sea menor o igual al valor dado. Es el área bajo la curva de distribución normal a la izquierda del z-score especificado.

Matemáticamente, la probabilidad acumulativa $P$ se calcula utilizando la función de distribución acumulativa (CDF) de la distribución normal estándar:

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

Donde:

$\Phi(z)$ = CDF de la distribución normal estándar en $z$

La probabilidad acumulativa es esencial en estadística para determinar la probabilidad de que un valor ocurra dentro de un cierto rango. Se utiliza ampliamente en campos como el control de calidad, las finanzas y las ciencias sociales.

Diagrama SVG

A continuación se muestra un diagrama SVG que ilustra la curva de distribución normal estándar y el z-score:

μ x z

Distribución Normal Estándar

Figura: Curva de Distribución Normal Estándar con Z-Score Sombreado

Este diagrama muestra la curva de distribución normal con la media $\mu$ en el centro. El área sombreada representa la probabilidad acumulativa hasta el punto de datos $x$ , correspondiente al z-score.

Casos de Uso

Aplicaciones

Estandarización a Través de Diferentes Escalas:

Los z-scores permiten la comparación entre datos de diferentes escalas al estandarizar los conjuntos de datos.
Detección de Valores Atípicos:

Identificación de puntos de datos que están significativamente distantes de la media (por ejemplo, z-scores menores a -3 o mayores a 3).
Pruebas Estadísticas:

Utilizado en pruebas de hipótesis, incluidos z-tests, para determinar si una media de muestra difiere significativamente de una media poblacional conocida.
Control de Calidad:

En la fabricación, los z-scores ayudan a monitorear procesos para asegurar que los resultados se mantengan dentro de límites aceptables.
Finanzas e Inversión:

Evaluar el rendimiento de acciones comparando retornos relativos al rendimiento promedio del mercado.

Alternativas

T-Score:

Similar al z-score pero utilizado cuando el tamaño de la muestra es pequeño y la desviación estándar de la población es desconocida.
Rango Percentil:

Indica el porcentaje de puntuaciones en su distribución de frecuencia que son iguales o inferiores a él.
Unidades de Desviación Estándar:

Usar valores de desviación estándar en bruto sin estandarizar como z-scores.

Historia

El concepto de z-score proviene del trabajo sobre la distribución normal por Carl Friedrich Gauss a principios del siglo XIX. La distribución normal estándar, fundamental para los z-scores, fue desarrollada aún más por estadísticos como Abraham de Moivre y Pierre-Simon Laplace. El uso de z-scores se volvió generalizado con el avance de los métodos estadísticos en el siglo XX, particularmente en pruebas psicológicas y control de calidad.

Ejemplos

Excel

## Calcular z-score en Excel
## Suponiendo que el punto de datos está en la celda A2, la media en la celda B2, la desviación estándar en la celda C2
=(A2 - B2) / C2

R

## Calcular z-score en R
calculate_z_score <- function(x, mean, sd) {
  if (sd == 0) {
    stop("La desviación estándar no puede ser cero.")
  }
  z <- (x - mean) / sd
  return(z)
}

## Ejemplo de uso:
x <- 85
mu <- 75
sigma <- 5
z_score <- calculate_z_score(x, mu, sigma)
print(paste("Z-score:", z_score))

MATLAB

% Calcular z-score en MATLAB
function z = calculate_z_score(x, mu, sigma)
    if sigma == 0
        error('La desviación estándar no puede ser cero.');
    end
    z = (x - mu) / sigma;
end

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

JavaScript

// Calcular z-score en JavaScript
function calculateZScore(x, mu, sigma) {
  if (sigma === 0) {
    throw new Error('La desviación estándar no puede ser cero.');
  }
  return (x - mu) / sigma;
}

// Ejemplo de uso:
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

## Calcular z-score en Python
def calculate_z_score(x, mu, sigma):
    if sigma == 0:
        raise ValueError("La desviación estándar no puede ser cero.")
    return (x - mu) / sigma

## Ejemplo de uso:
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

// Calcular z-score en Java
public class ZScoreCalculator {
    public static double calculateZScore(double x, double mu, double sigma) {
        if (sigma == 0) {
            throw new IllegalArgumentException("La desviación estándar no puede ser cero.");
        }
        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++

// Calcular z-score en C++
#include <iostream>
#include <stdexcept>

double calculate_z_score(double x, double mu, double sigma) {
    if (sigma == 0) {
        throw std::invalid_argument("La desviación estándar no puede ser cero.");
    }
    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

## Calcular z-score en Ruby
def calculate_z_score(x, mu, sigma)
  raise ArgumentError, "La desviación estándar no puede ser cero." if sigma == 0
  (x - mu) / sigma
end

## Ejemplo de uso:
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
// Calcular z-score en PHP
function calculate_z_score($x, $mu, $sigma) {
  if ($sigma == 0) {
    throw new Exception("La desviación estándar no puede ser cero.");
  }
  return ($x - $mu) / $sigma;
}

// Ejemplo de uso:
$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

// Calcular z-score en Rust
fn calculate_z_score(x: f64, mu: f64, sigma: f64) -> Result<f64, String> {
    if sigma == 0.0 {
        return Err("La desviación estándar no puede ser cero.".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#

// Calcular z-score en C#
using System;

public class ZScoreCalculator
{
    public static double CalculateZScore(double x, double mu, double sigma)
    {
        if (sigma == 0)
            throw new ArgumentException("La desviación estándar no puede ser cero.");
        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

// Calcular z-score en Go
package main

import (
    "errors"
    "fmt"
)

func calculateZScore(x, mu, sigma float64) (float64, error) {
    if sigma == 0 {
        return 0, errors.New("la desviación estándar no puede ser cero")
    }
    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

// Calcular z-score en Swift
func calculateZScore(x: Double, mu: Double, sigma: Double) throws -> Double {
    if sigma == 0 {
        throw NSError(domain: "La desviación estándar no puede ser cero.", code: 1, userInfo: nil)
    }
    return (x - mu) / sigma
}

// Ejemplo de uso:
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)
}

Referencias

Puntuación Estándar - Wikipedia

https://es.wikipedia.org/wiki/Puntuaci%C3%B3n_est%C3%A1ndar
Entendiendo Z-Scores - Statistics Solutions

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

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

Recursos Adicionales

Calculadora Interactiva de Z-Score

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

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

Loading related tools...