Calculadora de Z-Score para Análise Estatística e Dados

Calculadora de Z-Score

Introdução

O z-score (ou escore padrão) é uma medida estatística que descreve a relação de um valor com a média de um grupo de valores. Indica quantos desvios padrão um elemento está distante da média. O z-score é uma ferramenta crucial em estatística, permitindo a padronização de diferentes conjuntos de dados e a identificação de outliers.

Fórmula

O z-score é calculado usando a seguinte fórmula:

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

Onde:

$z$ = z-score
$x$ = ponto de dados individual
$\mu$ = média do conjunto de dados
$\sigma$ = desvio padrão do conjunto de dados

Esta fórmula calcula o número de desvios padrão que um ponto de dados está distante da média.

Cálculo

Para calcular o z-score de um ponto de dados:

Calcule a Média ( $\mu$ ):

Some todos os pontos de dados e divida pelo número de pontos de dados.
$\mu = \frac{\sum_{i=1}^{n} x_i}{n}$
Calcule o Desvio Padrão ( $\sigma$ ):
- Variância ( $\sigma^2$ ):
  $\sigma^2 = \frac{\sum_{i=1}^{n} (x_i - \mu)^2}{n}$
- Desvio Padrão:
  $\sigma = \sqrt{\sigma^2}$
Calcule o Z-Score:

Substitua os valores na fórmula do z-score.
$z = \frac{x - \mu}{\sigma}$

Casos Limite

Desvio Padrão Zero ( $\sigma = 0$ ):

Quando todos os pontos de dados são idênticos, o desvio padrão é zero, tornando o z-score indefinido, pois não se pode dividir por zero. Nesse caso, o conceito de z-score não se aplica.
Ponto de Dados Igual à Média ( $x = \mu$ ):

Se o ponto de dados for igual à média, o z-score é zero, indicando que é exatamente a média.
Entradas Não Numéricas:

Certifique-se de que todas as entradas são numéricas. Entradas não numéricas resultarão em erros de cálculo.

Probabilidade Cumulativa

A probabilidade cumulativa associada a um z-score representa a probabilidade de que uma variável aleatória de uma distribuição normal padrão seja menor ou igual ao valor dado. É a área sob a curva de distribuição normal à esquerda do z-score especificado.

Matematicamente, a probabilidade cumulativa $P$ é calculada usando a função de distribuição cumulativa (CDF) da distribuição normal padrão:

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

Onde:

$\Phi(z)$ = CDF da distribuição normal padrão em $z$

A probabilidade cumulativa é essencial em estatística para determinar a probabilidade de um valor ocorrer dentro de um determinado intervalo. É amplamente utilizada em áreas como controle de qualidade, finanças e ciências sociais.

Diagrama SVG

Abaixo está um diagrama SVG ilustrando a curva de distribuição normal padrão e o z-score:

μ x z

Distribuição Normal Padrão

Figura: Curva de Distribuição Normal Padrão com Z-Score Sombreada

Este diagrama mostra a curva de distribuição normal com a média $\mu$ no centro. A área sombreada representa a probabilidade cumulativa até o ponto de dados $x$ , correspondente ao z-score.

Casos de Uso

Aplicações

Padronização Entre Diferentes Escalas:

Z-scores permitem comparação entre dados de diferentes escalas ao padronizar os conjuntos de dados.
Detecção de Outliers:

Identificação de pontos de dados que estão significativamente distantes da média (por exemplo, z-scores menores que -3 ou maiores que 3).
Teste Estatístico:

Usado em testes de hipótese, incluindo testes z, para determinar se uma média de amostra difere significativamente de uma média populacional conhecida.
Controle de Qualidade:

Na fabricação, z-scores ajudam a monitorar processos para garantir que os resultados permaneçam dentro de limites aceitáveis.
Finanças e Investimentos:

Avaliando o desempenho de ações comparando retornos em relação ao desempenho médio do mercado.

Alternativas

T-Score:

Semelhante ao z-score, mas usado quando o tamanho da amostra é pequeno e o desvio padrão populacional é desconhecido.
Classificação Percentil:

Indica a porcentagem de pontuações em sua distribuição de frequência que são iguais ou inferiores a ela.
Unidades de Desvio Padrão:

Usando valores de desvio padrão bruto sem padronizar como z-scores.

História

O conceito de z-score deriva do trabalho sobre a distribuição normal por Carl Friedrich Gauss no início do século XIX. A distribuição normal padrão, fundamental para os z-scores, foi desenvolvida ainda mais por estatísticos como Abraham de Moivre e Pierre-Simon Laplace. O uso de z-scores se tornou generalizado com o avanço dos métodos estatísticos no século XX, particularmente em testes psicológicos e controle de qualidade.

Exemplos

Excel

## Calcular z-score no Excel
## Supondo que o ponto de dados esteja na célula A2, a média na célula B2 e o desvio padrão na célula C2
=(A2 - B2) / C2

R

## Calcular z-score em R
calculate_z_score <- function(x, mean, sd) {
  if (sd == 0) {
    stop("O desvio padrão não pode ser zero.")
  }
  z <- (x - mean) / sd
  return(z)
}

## Exemplo 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 em MATLAB
function z = calculate_z_score(x, mu, sigma)
    if sigma == 0
        error('O desvio padrão não pode ser zero.');
    end
    z = (x - mu) / sigma;
end

% Exemplo 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 em JavaScript
function calculateZScore(x, mu, sigma) {
  if (sigma === 0) {
    throw new Error('O desvio padrão não pode ser zero.');
  }
  return (x - mu) / sigma;
}

// Exemplo 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 em Python
def calculate_z_score(x, mu, sigma):
    if sigma == 0:
        raise ValueError("O desvio padrão não pode ser zero.")
    return (x - mu) / sigma

## Exemplo 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 em Java
public class ZScoreCalculator {
    public static double calculateZScore(double x, double mu, double sigma) {
        if (sigma == 0) {
            throw new IllegalArgumentException("O desvio padrão não pode ser 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++

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

double calculate_z_score(double x, double mu, double sigma) {
    if (sigma == 0) {
        throw std::invalid_argument("O desvio padrão não pode ser 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

## Calcular z-score em Ruby
def calculate_z_score(x, mu, sigma)
  raise ArgumentError, "O desvio padrão não pode ser zero." if sigma == 0
  (x - mu) / sigma
end

## Exemplo 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 em PHP
function calculate_z_score($x, $mu, $sigma) {
  if ($sigma == 0) {
    throw new Exception("O desvio padrão não pode ser zero.");
  }
  return ($x - $mu) / $sigma;
}

// Exemplo 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 em Rust
fn calculate_z_score(x: f64, mu: f64, sigma: f64) -> Result<f64, String> {
    if sigma == 0.0 {
        return Err("O desvio padrão não pode ser 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#

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

public class ZScoreCalculator
{
    public static double CalculateZScore(double x, double mu, double sigma)
    {
        if (sigma == 0)
            throw new ArgumentException("O desvio padrão não pode ser 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

// Calcular z-score em Go
package main

import (
    "errors"
    "fmt"
)

func calculateZScore(x, mu, sigma float64) (float64, error) {
    if sigma == 0 {
        return 0, errors.New("o desvio padrão não pode ser 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

// Calcular z-score em Swift
func calculateZScore(x: Double, mu: Double, sigma: Double) throws -> Double {
    if sigma == 0 {
        throw NSError(domain: "O desvio padrão não pode ser zero.", code: 1, userInfo: nil)
    }
    return (x - mu) / sigma
}

// Exemplo 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)
}

Referências

Escore Padrão - Wikipedia

https://pt.wikipedia.org/wiki/Escore_padr%C3%A3o
Compreendendo Z-Scores - Statistics Solutions

https://www.statisticssolutions.com/understanding-z-scores/
Distribuição Normal e Z-Scores - Khan Academy

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

Recursos Adicionais

Calculadora Interativa de Z-Score

https://www.socscistatistics.com/pvalues/normaldistribution.aspx
Visualizando a Distribuição Normal

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

Loading related tools...