R Academy · Aula

Geração de distribuições aleatórias

Faça amostragens das distribuições normal, uniforme, binomial e de Poisson.

Geração de distribuições aleatórias é uma aula grátis de R Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de R Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de R Academy inclui 4 aulas no total.

Funções de distribuição do R

O R fornece quatro funções para cada distribuição: r (aleatória), d (densidade), p (probabilidade acumulada) e q (quantil). As funções r* geram amostras aleatórias.

# Pattern: r<dist>(n, param1, param2, ...)
# d<dist>(x, ...) -> density/probability
# p<dist>(q, ...) -> cumulative probability
# q<dist>(p, ...) -> quantile

# Example with normal distribution:
rnorm(5, mean = 0, sd = 1)    # 5 random draws
dnorm(0, mean = 0, sd = 1)    # density at x=0
pnorm(1.96, mean = 0, sd = 1) # P(X <= 1.96)
qnorm(0.975, mean = 0, sd = 1) # z-score for 97.5%
cat('Four functions: r, d, p, q for each distribution')

rnorm(): distribuição normal

rnorm(n, mean, sd) gera n amostras de N(mean, sd²). O padrão é a normal padrão N(0,1). A distribuição normal é a principal ferramenta da estatística — o teorema do limite central garante sua ampla ocorrência.

set.seed(42)
# Standard normal (mean=0, sd=1)
z_scores <- rnorm(1000)
mean(z_scores)  # ~0
sd(z_scores)    # ~1

# Custom normal (IQ scores: mean=100, sd=15)
set.seed(42)
iq_scores <- rnorm(100, mean = 100, sd = 15)
mean(iq_scores)  # ~100
sd(iq_scores)    # ~15
summary(iq_scores)

# About 68% within 1 sd
mean(abs(iq_scores - 100) < 15)  # ~0.68

runif(): distribuição uniforme

runif(n, min, max) gera n amostras distribuídas uniformemente entre min e max. Todos os valores no intervalo são igualmente prováveis. Padrão: runif(n) fornece valores em [0, 1].

set.seed(7)
# Default: uniform on [0, 1]
u <- runif(5)
print(u)  # values in (0, 1)

# Uniform on [a, b]
temps <- runif(100, min = -10, max = 40)  # temperatures
mean(temps)   # ~15 (midpoint)
range(temps)  # should be within [-10, 40]

# Discrete simulation using floor()
dice_rolls <- floor(runif(10, min = 1, max = 7))
print(dice_rolls)  # integers 1-6
table(floor(runif(600, 1, 7)))  # roughly equal counts

rbinom(): distribuição binomial

rbinom(n, size, prob) simula n experimentos binomiais, cada um consistindo em size tentativas de Bernoulli com probabilidade de sucesso prob. Use size=1 para obter resultados de Bernoulli.

set.seed(123)
# 10 coin flips (prob=0.5), repeated 5 times
coin_flips <- rbinom(5, size = 10, prob = 0.5)
print(coin_flips)  # number of heads each time

# Bernoulli: single flip (size=1)
flips <- rbinom(20, size = 1, prob = 0.5)
print(flips)  # 0s and 1s
mean(flips)   # ~0.5

# Biased coin (prob=0.7)
biased <- rbinom(1000, size = 1, prob = 0.7)
mean(biased)  # ~0.7

# Many trials: normal approximation kicks in
hundred_flips <- rbinom(1000, size = 100, prob = 0.5)
mean(hundred_flips)  # ~50

rpois(): distribuição de Poisson

rpois(n, lambda) gera n amostras de uma distribuição de Poisson com taxa λ. Modela dados de contagem (eventos por intervalo): visitas a um site por minuto, defeitos por unidade e chamadas por hora.

set.seed(5)
# Calls received per hour (average 3)
calls <- rpois(24, lambda = 3)  # 24 hours
print(calls)  # integers, mostly 1-6
mean(calls)   # ~3 (expectation = lambda)
var(calls)    # ~3 (variance = lambda for Poisson)

# Count the distribution
table(calls)

# Rare events (lambda=0.5)
rare_events <- rpois(100, lambda = 0.5)
table(rare_events)  # mostly 0s and 1s
mean(rare_events)   # ~0.5

rexp(): distribuição exponencial

rexp(n, rate) gera n amostras da distribuição exponencial com a taxa especificada. Modela o tempo entre eventos (tempos entre chegadas). Média = 1/rate. Propriedade de ausência de memória.

set.seed(42)
# Time between customer arrivals (rate=2 per minute)
# Mean wait time = 1/2 = 0.5 minutes
arrival_times <- rexp(100, rate = 2)
mean(arrival_times)  # ~0.5
sd(arrival_times)    # ~0.5 (mean = sd for exponential)

# Simulate a queue
cumulative_arrivals <- cumsum(rexp(10, rate = 3))
print(round(cumulative_arrivals, 3))

# Exponential CDF: P(X <= x) = 1 - exp(-rate*x)
pexp(0.5, rate = 2)   # P(wait <= 0.5 min)
mean(arrival_times <= 0.5)  # empirical estimate

sample(): amostragem discreta

sample(x, size, replace) extrai size elementos do vetor x. replace=FALSE (padrão) corresponde à amostragem sem reposição; replace=TRUE permite valores repetidos.

set.seed(10)
# Sample without replacement (like drawing cards)
cards <- 1:52
hand <- sample(cards, size = 5, replace = FALSE)
print(hand)  # 5 unique cards

# Sample with replacement (bootstrap)
x <- c(10, 20, 30, 40, 50)
bootstrap_sample <- sample(x, size = 5, replace = TRUE)
print(bootstrap_sample)  # may have repeats

# Simulate rolling two dice 1000 times
dice <- function() sum(sample(1:6, 2, replace = TRUE))
rolls <- replicate(1000, dice())
table(rolls) / 1000  # empirical probabilities

Amostragem ponderada

sample(x, size, replace, prob) usa pesos de probabilidade. O vetor prob atribui probabilidades relativas a cada elemento — útil para distribuições discretas não uniformes.

set.seed(99)
# Loaded die: 6 is twice as likely
faces <- 1:6
weights <- c(1, 1, 1, 1, 1, 2)  # relative
norm_weights <- weights / sum(weights)

rolls <- sample(faces, size = 1000, replace = TRUE,
                prob = norm_weights)
table(rolls) / 1000
# 6 appears ~2/7 ~= 0.286 of the time

# Categorical sampling
categories <- c('A', 'B', 'C')
probs <- c(0.5, 0.3, 0.2)
sample(categories, 10, replace = TRUE, prob = probs)

rgeom() e rnbinom(): distribuições de contagem

rgeom(n, prob) conta as falhas antes do primeiro sucesso. rnbinom(n, size, prob) conta as falhas antes de size sucessos. Ambas modelam dados de contagem sobredispersos (com mais variância que a distribuição de Poisson).

set.seed(42)
# Geometric: flips until first head (prob=0.3)
# Number of FAILURES before first success
flips_until_head <- rgeom(10, prob = 0.3) + 1  # +1 for the success
print(flips_until_head)
mean(flips_until_head)  # ~1/0.3 = 3.33

# Negative binomial: overdispersed count data
# e.g., number of parasites per host
counts <- rnbinom(100, size = 2, prob = 0.4)
mean(counts)   # ~3 (theoretical: size*(1-p)/p)
var(counts)    # much larger than mean -> overdispersed

# Compare variance to Poisson with same mean
pois_counts <- rpois(100, lambda = mean(counts))
var(counts) / var(pois_counts)  # > 1

rt() e rf(): distribuições t e F

rt(n, df) gera amostras distribuídas segundo t com df graus de liberdade. À medida que df → ∞, ela converge para a normal. rf(n, df1, df2) gera amostras distribuídas segundo F — a razão entre variáveis qui-quadrado.

set.seed(1)
# t distribution: heavier tails than normal
t_vals <- rt(1000, df = 5)
mean(t_vals)  # ~0
sd(t_vals)    # > 1 (inflated by heavy tails)

# Compare to normal
n_vals <- rnorm(1000)
# t has more extreme values (heavy tails)
sum(abs(t_vals) > 3)   # e.g., ~30
sum(abs(n_vals) > 3)   # e.g., ~3

# F distribution: used in ANOVA F-tests
f_vals <- rf(1000, df1 = 5, df2 = 20)
range(f_vals)   # always positive
mean(f_vals)    # ~df2/(df2-2) = 20/18 = 1.11

Visualizando distribuições aleatórias

Histogramas e gráficos de densidade visualizam o formato das distribuições simuladas. Compare a densidade empírica com as curvas de densidade teóricas usando hist() com a sobreposição de curve(dnorm(...)).

set.seed(42)
x <- rnorm(10000, mean = 5, sd = 2)

# Quick summary statistics
summary(x)
cat('Mean:', mean(x), '\n')
cat('SD:', sd(x), '\n')
cat('Skewness (should be ~0 for normal):',
    mean(((x - mean(x))/sd(x))^3), '\n')

# Empirical quantiles vs theoretical
quantile(x, c(0.025, 0.25, 0.5, 0.75, 0.975))
# Compare to theoretical:
qnorm(c(0.025, 0.25, 0.5, 0.75, 0.975),
      mean = 5, sd = 2)

Verificação rápida

Teste seu conhecimento sobre as funções de distribuição aleatória do R.

Recapitulação: distribuições aleatórias

Principais conclusões: rnorm(n, mean, sd) para a normal; runif(n, min, max) para a uniforme; rbinom(n, size, prob) para a binomial; rpois(n, lambda) para contagens de Poisson; rexp(n, rate) para tempos de espera exponenciais; sample(x, size, replace) para amostragem discreta. Use sempre set.seed() antes de gerar números aleatórios em análises reproduzíveis.

set.seed(42)
# Quick reference of common distributions:
rnorm(3, mean = 0, sd = 1)        # Normal
runif(3, min = 0, max = 1)        # Uniform
rbinom(3, size = 10, prob = 0.5)  # Binomial
rpois(3, lambda = 3)              # Poisson
rexp(3, rate = 1)                 # Exponential
rt(3, df = 10)                    # Student t
rf(3, df1 = 5, df2 = 20)          # F distribution
rgeom(3, prob = 0.3)              # Geometric
sample(1:10, 3, replace = TRUE)   # Discrete uniform
cat('R has 20+ built-in distributions')

Perguntas Frequentes

A aula “Geração de distribuições aleatórias” é grátis?

Sim — o texto completo de “Geração de distribuições aleatórias” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de R Academy, atualize para CoddyKit PRO. O curso de R Academy inclui 4 aulas no total.

O que vou aprender em “Geração de distribuições aleatórias”?

Faça amostragens das distribuições normal, uniforme, binomial e de Poisson. Você pratica R Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar R Academy?

Nenhuma experiência prévia é necessária. R Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Geração de distribuições aleatórias”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de R Academy?

Sim. Cada aula de R Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para R Academy