0Pricing
R Academy · Lección

Generación de distribuciones aleatorias

Muestree de distribuciones normal, uniforme, binomial y de Poisson.

Generación de distribuciones aleatorias es una lección gratuita de R Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de R Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de R Academy incluye 4 lecciones en total.

Funciones de distribución de R

R proporciona cuatro funciones para cada distribución: r (aleatoria), d (densidad), p (probabilidad acumulada) y q (cuantil). Las funciones r* generan muestras aleatorias.

# 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(): distribución normal

rnorm(n, mean, sd) genera n muestras de N(mean, sd²). El valor predeterminado es la normal estándar N(0,1). La distribución normal es la herramienta fundamental de la estadística; el teorema del límite central garantiza su importancia.

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(): distribución uniforme

runif(n, min, max) genera n muestras distribuidas uniformemente entre min y max. Todos los valores del intervalo son igualmente probables. Valor predeterminado: runif(n) proporciona valores en [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(): distribución binomial

rbinom(n, size, prob) simula n experimentos binomiales, cada uno compuesto por size ensayos de Bernoulli con probabilidad de éxito prob. Utilice size=1 para obtener realizaciones 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(): distribución de Poisson

rpois(n, lambda) genera n muestras de una distribución de Poisson con tasa λ. Modela datos de conteo (eventos por intervalo): visitas a un sitio web por minuto, defectos por unidad o llamadas 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(): distribución exponencial

rexp(n, rate) genera n muestras de la distribución exponencial con la tasa especificada. Modela el tiempo entre eventos (tiempos entre llegadas). Media = 1/rate. Propiedad de falta de memoria.

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(): muestreo discreto

sample(x, size, replace) extrae size elementos del vector x. replace=FALSE (valor predeterminado) corresponde a un muestreo sin reemplazo; 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

Muestreo ponderado

sample(x, size, replace, prob) utiliza pesos de probabilidad. El vector prob asigna probabilidades relativas a cada elemento; resulta útil para distribuciones discretas no 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() y rnbinom(): distribuciones de conteo

rgeom(n, prob) cuenta los fracasos antes del primer éxito. rnbinom(n, size, prob) cuenta los fracasos antes de size éxitos. Ambas modelan datos de conteo sobredispersos (con más varianza que 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() y rf(): distribuciones t y F

rt(n, df) genera muestras con distribución t y df grados de libertad. Cuando df → ∞, converge a la distribución normal. rf(n, df1, df2) genera muestras con distribución F: el cociente de variables ji-cuadrado.

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

Visualización de distribuciones aleatorias

Los histogramas y los gráficos de densidad permiten visualizar la forma de las distribuciones simuladas. Compare la densidad empírica con las curvas de densidad teóricas utilizando hist() con una superposición 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)

Comprobación rápida

Compruebe sus conocimientos sobre las funciones de distribución aleatoria de R.

Resumen: distribuciones aleatorias

Ideas clave: rnorm(n, mean, sd) para la normal; runif(n, min, max) para la uniforme; rbinom(n, size, prob) para la binomial; rpois(n, lambda) para conteos de Poisson; rexp(n, rate) para tiempos de espera exponenciales; sample(x, size, replace) para el muestreo discreto. Utilice siempre set.seed() antes de generar números aleatorios en análisis reproducibles.

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')

Preguntas frecuentes

¿La lección «Generación de distribuciones aleatorias» es gratis?

Sí — el texto completo de «Generación de distribuciones aleatorias» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de R Academy, actualiza a CoddyKit PRO. El curso de R Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Generación de distribuciones aleatorias»?

Muestree de distribuciones normal, uniforme, binomial y de Poisson. Practicas R Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar R Academy?

No se requiere experiencia previa. R Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Generación de distribuciones aleatorias»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de R Academy?

Sí. Cada lección de R Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. set.seed() y reproducibilidad
  2. Generación de distribuciones aleatorias
  3. Fundamentos de la simulación de Monte Carlo
  4. Remuestreo bootstrap en R
← Volver a R Academy