Distribuciones
Samuel Santander-Julen Lopez
2026-05-12
1. DISTRIBUCIÓN LOGNORMAL
-DEFINICIÓN:
La distribución log-normal es una distribución de probabilidad continua de una variable aleatoria cuyo logaritmo natural sigue una distribución normal. En el contexto de la Gestión de Datos y la Ingeniería Industrial, es fundamental porque modela fenómenos que no pueden ser negativos y que presentan una asimetría hacia la derecha (valores extremos positivos).
A diferencia de la distribución normal, que es simétrica, la log-normal es ideal para representar datos que tienen un “límite inferior” en cero pero un potencial de crecimiento muy alto.
\[f(x) = \frac{1}{x\sigma\sqrt{2\pi}} e^{-\frac{1}{2}\left(\frac{\ln(x)-\mu}{\sigma}\right)^2}\]
Donde:
- \(x\): Valores observados.
- \(\mu\): Localización (media logarítmica).
- \(\sigma\): Escala (desviación estándar logarítmica).
-EJEMPLO: Aplicación en Industria Láctea
Modelado del recuento bacteriano (UFC/ml) en la recepción de leche cruda.
En una planta de procesamiento de lácteos, se mide la cantidad de Unidades Formadoras de Colonias (UFC) por mililitro en la leche cruda que llega de las fincas. Este valor es crítico para determinar la calidad del producto y el pago al productor.
-Variables del Modelo:
- \(x\): Concentración de microorganismos.
- \(\mu\): Nivel base de higiene del hato.
- \(\sigma\): Variabilidad en el cumplimiento de la cadena de frío.
¿Por qué es Lognormal?
Límite inferior: El recuento de bacterias no puede ser menor a cero.
Asimetría positiva: La mayoría de los proveedores entregan leche con niveles bajos de bacterias (dentro de la norma), pero ocasionalmente hay “picos” muy altos debido a fallas en la cadena de frío o en el ordeño. Estos valores extremos crean la “cola larga” a la derecha de la gráfica.
-Importancia: Permite predecir la vida útil del producto final y optimizar el proceso de pasteurización.
ALGORITMO EN R
Gráfica
library(knitr)
library(kableExtra)
# ==========================================
# 1. FUNCIONES AUXILIARES (HECHAS A PIE)
# ==========================================
manual_sqrt <- function(n) {
if (n < 0) return(NaN)
res <- n / 2
for (i in 1:15) {
res <- 0.5 * (res + (n / res))
}
return(res)
}
manual_exp <- function(x) {
res <- 1
term <- 1
for (i in 1:50) {
term <- term * (x / i)
res <- res + term
}
return(res)
}
manual_log <- function(x) {
if (x <= 0) return(NaN)
y <- 2.0
for (i in 1:10) {
ey <- manual_exp(y)
y <- y + 2 * (x - ey) / (x + ey)
}
return(y)
}
manual_round <- function(x, digitos) {
factor <- 10^digitos
resultado <- as.integer(x * factor + 0.5) / factor
return(resultado)
}
# ==========================================
# 2. ALGORITMO LOGNORMAL (100% MANUAL)
# ==========================================
algoritmo_lognormal_puro <- function(x, mu, sigma) {
pi_val <- 3.14159265358979
raiz_2pi <- manual_sqrt(2 * pi_val)
ln_x <- manual_log(x)
denominador_constante <- x * sigma * raiz_2pi
constante <- 1 / denominador_constante
diferencia <- ln_x - mu
numerador_exp <- -(diferencia * diferencia)
denominador_exp <- 2 * (sigma * sigma)
valor_exponencial <- manual_exp(numerador_exp / denominador_exp)
densidad <- constante * valor_exponencial
return(densidad)
}
# ==========================================
# 3. CONFIGURACIÓN Y PROCESAMIENTO
# ==========================================
mu_val <- 2.5
sigma_val <- 0.8
n_puntos <- 500
x_seq <- seq(0.1, 60, length.out = n_puntos)
y_values <- numeric(n_puntos)
for (i in 1:n_puntos) {
y_values[i] <- algoritmo_lognormal_puro(x_seq[i], mu_val, sigma_val)
}
# ==========================================
# 4. GRÁFICA
# ==========================================
plot(x_seq, y_values,
type = "l",
col = "red",
lwd = 3,
main = "Distribución Lognormal: Calidad en Producción Láctea",
xlab = "Recuento Bacteriano (UFC/ml)",
ylab = "Densidad de Probabilidad",
panel.first = grid())
polygon(c(x_seq, rev(x_seq)),
c(y_values, rep(0, length(y_values))),
col = rgb(1, 0, 0, 0.1),
border = NA)
# ==========================================
# 5. TABLA
# ==========================================
resultado_puntual <- algoritmo_lognormal_puro(15, mu_val, sigma_val)
datos_tabla <- data.frame(
Parámetro = c("Valor evaluado (x)", "Media log (mu)", "Desviación (sigma)", "Densidad Resultante"),
Descripción = c("UFC/ml", "Escala de higiene", "Variabilidad", "f(x) calculada a pie"),
Valor = c(15, mu_val, sigma_val, manual_round(resultado_puntual, 6))
)
kable(datos_tabla,
caption = "Análisis Lognormal: Algoritmo Manual sin Funciones Nativas",
align = "llc") %>%
kable_styling(bootstrap_options = c("striped", "hover", "bordered"), full_width = F) %>%
row_spec(0, background = "red", color = "white", bold = TRUE)| Parámetro | Descripción | Valor |
|---|---|---|
| Valor evaluado (x) | UFC/ml | 15.00000 |
| Media log (mu) | Escala de higiene | 2.50000 |
| Desviación (sigma) | Variabilidad | 0.80000 |
| Densidad Resultante | f(x) calculada a pie | 0.03214 |
COMPARACIÓN CON LA FUNCIÓN DE R
library(knitr)
library(kableExtra)
# Parámetros del ejemplo (x=15, mu=2.5, sigma=0.8)
x_comp <- 15
mu_comp <- 2.5
sigma_comp <- 0.8
# Resultado del algoritmo manual (mismo cálculo de la tabla)
manual_sqrt_c <- function(n) {
res <- n / 2
for (i in 1:15) { res <- 0.5 * (res + (n / res)) }
return(res)
}
manual_exp_c <- function(x) {
res <- 1; term <- 1
for (i in 1:50) { term <- term * (x / i); res <- res + term }
return(res)
}
manual_log_c <- function(x) {
y <- 2.0
for (i in 1:10) { ey <- manual_exp_c(y); y <- y + 2 * (x - ey) / (x + ey) }
return(y)
}
pi_val_c <- 3.14159265358979
raiz_2pi_c <- manual_sqrt_c(2 * pi_val_c)
ln_x_c <- manual_log_c(x_comp)
constante_c <- 1 / (x_comp * sigma_comp * raiz_2pi_c)
diferencia_c <- ln_x_c - mu_comp
exp_val_c <- manual_exp_c(-(diferencia_c * diferencia_c) / (2 * sigma_comp^2))
resultado_manual_ln <- constante_c * exp_val_c
# Resultado con función nativa de R
resultado_nativo_ln <- dlnorm(x_comp, meanlog = mu_comp, sdlog = sigma_comp)
# Tabla comparativa
comp_ln <- data.frame(
Método = c("Algoritmo Manual", "Función dlnorm() de R"),
Resultado = c(round(resultado_manual_ln, 8), round(resultado_nativo_ln, 8)),
Coinciden = c("", ifelse(round(resultado_manual_ln, 5) == round(resultado_nativo_ln, 5), "Sí", "No"))
)
kable(comp_ln,
caption = "Comparación: Algoritmo Manual vs dlnorm() — x=15, mu=2.5, sigma=0.8",
align = "lcc") %>%
kable_styling(bootstrap_options = c("striped", "bordered"), full_width = F, position = "center") %>%
row_spec(0, background = "red", color = "white", bold = TRUE) %>%
row_spec(2, bold = TRUE, background = "#F9F9F9", color = "darkred")| Método | Resultado | Coinciden |
|---|---|---|
| Algoritmo Manual | 0.0321398 | |
| Función dlnorm() de R | 0.0321398 | Sí |
2. DISTRIBUCIÓN GAUSSIANA
-DEFINICIÓN:
Es una distribución de probabilidad de variable continua que se caracteriza por su forma de campana simétrica. Representa cómo se agrupan los datos alrededor de un valor central.
FÓRMULA
\[f(x) = \frac{1}{\sigma \sqrt{2\pi}} e^{-\frac{1}{2} \left( \frac{x - \mu}{\sigma} \right)^2}\]
Donde:
- \(f(x)\): Función de Densidad de Probabilidad.
- \(\mu\) (mu): Media o valor central.
- \(\sigma\) (sigma): Desviación Estándar.
- \(\sigma^2\): Varianza.
- \(e\): Constante de Euler (\(\approx 2.71828\)).
- \(\pi\): Constante pi (\(\approx 3.14159\)).
- \(x\): Variable aleatoria continua.
APLICACIÓN DEL EJERCICIO EN LA DISTRIBUCIÓN GAUSSIANA
Control de Peso en el Envasado de Leche
En la etapa final de producción, una máquina automatizada llena bolsas o envases de leche con un contenido nominal de 1000 ml. Debido a la precisión mecánica de la llenadora, el volumen real de cada envase varía ligeramente. Como Ingeniero Industrial, utilizas la distribución Gaussiana para asegurar que el proceso sea estable y que la cantidad de producto entregado al consumidor cumpla con los estándares de calidad y legalidad.
Variables del ejercicio:
- \(x\): Volumen real de leche en un envase específico.
- \(\mu\): El valor promedio al que está calibrada la máquina (1000 ml).
- \(\sigma\): Indica la precisión de la máquina.
ALGORITMO EN R
algoritmo_gaussiano_puro <- function(x, mu, sigma) {
pi_val <- 3.14159265358979
e_val <- 2.71828182845904
coeficiente <- 1 / (sigma * (2 * pi_val)^0.5)
exponente_valor <- -((x - mu)^2) / (2 * sigma^2)
densidad <- coeficiente * (e_val ^ exponente_valor)
return(densidad)
}
volumen_x <- 1002
media_mu <- 1000
sigma_sd <- 1.5
resultado <- algoritmo_gaussiano_puro(volumen_x, media_mu, sigma_sd)
print(resultado)## [1] 0.10934GRÁFICA
TABLA
| Concepto | Unidad | Valor |
|---|---|---|
| Variable de Control (x) | Mililitros (ml) | 1002.00000 |
| Media de Proceso (mu) | Mililitros (ml) | 1000.00000 |
| Desviación Estándar (sigma) | Mililitros (ml) | 1.50000 |
| Densidad Calculada f(x) | Probabilidad | 0.10934 |
Análisis: En conclusión, el análisis muestra que el proceso de llenado es altamente confiable, ya que la campana simétrica confirma que la máquina está centrada en el objetivo de 1000 ml con una variabilidad muy baja. El envase de 1002 ml evaluado con el algoritmo se encuentra dentro del rango normal de operación, lo que significa que el proceso está bajo control, no se está desperdiciando producto en exceso y se cumple con los estándares de calidad exigidos en la industria láctea.
COMPARACIÓN CON LA FUNCIÓN EN R
library(knitr)
library(kableExtra)
# Parámetros del ejemplo (x=1002, mu=1000, sigma=1.5)
x_cg <- 1002
mu_cg <- 1000
sigma_cg <- 1.5
# Resultado del algoritmo manual
pi_val_cg <- 3.14159265358979
e_val_cg <- 2.71828182845904
coef_cg <- 1 / (sigma_cg * (2 * pi_val_cg)^0.5)
exp_cg <- -((x_cg - mu_cg)^2) / (2 * sigma_cg^2)
resultado_manual_g <- coef_cg * (e_val_cg ^ exp_cg)
# Resultado con función nativa de R
resultado_nativo_g <- dnorm(x_cg, mean = mu_cg, sd = sigma_cg)
# Tabla comparativa
comp_g <- data.frame(
Método = c("Algoritmo Manual", "Función dnorm() de R"),
Resultado = c(round(resultado_manual_g, 8), round(resultado_nativo_g, 8)),
Coinciden = c("", ifelse(round(resultado_manual_g, 5) == round(resultado_nativo_g, 5), "Sí", "No"))
)
kable(comp_g,
caption = "Comparación: Algoritmo Manual vs dnorm() — x=1002, mu=1000, sigma=1.5",
align = "lcc") %>%
kable_styling(bootstrap_options = c("striped", "bordered"), full_width = F, position = "center") %>%
row_spec(0, background = "red", color = "white", bold = TRUE) %>%
row_spec(2, bold = TRUE, background = "#F9F9F9", color = "darkred")| Método | Resultado | Coinciden |
|---|---|---|
| Algoritmo Manual | 0.10934 | |
| Función dnorm() de R | 0.10934 | Sí |
3. DISTRIBUCIÓN CHI CUADRADO
-DEFINICIÓN:
Imagina que lanzas una moneda 100 veces. Esperas que caigan 50 caras y 50 sellos. Pero, en la vida real, obtienes 45 caras y 55 sellos.
¿Esa diferencia es por pura suerte? ¿O es que la moneda está trucada?
La Chi-cuadrado mide esa “distancia” entre lo que esperabas y lo que observaste. Si la distancia es muy grande, la distribución te dirá que la diferencia no es casualidad.
FÓRMULA
\[f(x) = \frac{1}{2^{\frac{k}{2}} \Gamma \left( \frac{k}{2} \right)} x^{\frac{k}{2} - 1} e^{-\frac{x}{2}}\]
Donde:
- \(f(x)\): Función de densidad de probabilidad para \(x > 0\).
- \(k\): Grados de libertad.
- \(\Gamma\): Función Gamma.
- \(e\): Base de los logaritmos naturales (\(\approx 2.71828\)).
- \(x\): Valor de la variable aleatoria.
APLICACIÓN DEL EJERCICIO EN LA DISTRIBUCIÓN CHI CUADRADO
Control de Inocuidad Láctea
En una planta procesadora de leche en Colombia, el departamento de Gestión de Datos realiza un seguimiento diario de las impurezas o sedimentos encontrados en las muestras de leche cruda antes de la pasteurización.
Variables del ejercicio:
- Frecuencias Observadas (\(O_i\)): 0 impurezas: 85 lotes, 1 impureza: 40 lotes, 2 impurezas: 18 lotes, 3+ impurezas: 7 lotes.
- Frecuencias Esperadas (\(E_i\)): \(E_0\): 82, \(E_1\): 44, \(E_2\): 16, \(E_3\): 8.
- Nivel de significancia (\(\alpha\)): 0.05.
- Grados de libertad (\(k\)): 3.
ALGORITMO EN R
obs <- c(85, 40, 18, 7)
esp <- c(82, 44, 16, 8)
diferencia <- obs - esp
diferencia_sq <- diferencia * diferencia
proporcion_error <- diferencia_sq / esp
chi_calculado <- proporcion_error[1] +
proporcion_error[2] +
proporcion_error[3] +
proporcion_error[4]
grados_libertad <- 3
valor_critico_tabla <- 7.815
print("--- RESULTADOS DEL ANALISIS INDUSTRIAL ---")## [1] "--- RESULTADOS DEL ANALISIS INDUSTRIAL ---"print("Valor de Chi-cuadrado calculado:")## [1] "Valor de Chi-cuadrado calculado:"print(chi_calculado)## [1] 0.8483925print("Valor Critico de Referencia:")## [1] "Valor Critico de Referencia:"print(valor_critico_tabla)## [1] 7.815if (chi_calculado < valor_critico_tabla) {
print("ESTADO: PROCESO ESTABLE")
print("La recepcion de leche se ajusta a los estandares esperados.")
} else {
print("ESTADO: DESVIACION DETECTADA")
print("Revisar inmediatamente los filtros y la higiene en el acopio.")
}## [1] "ESTADO: PROCESO ESTABLE"
## [1] "La recepcion de leche se ajusta a los estandares esperados."GRÁFICA
categorias <- c("0 Imp.", "1 Imp.", "2 Imp.", "3+ Imp.")
obs_graf <- c(85, 40, 18, 7)
esp_graf <- c(82, 44, 16, 8)
datos_comparativos <- rbind(obs_graf, esp_graf)
barplot(datos_comparativos,
beside = TRUE,
names.arg = categorias,
col = c("dodgerblue4", "darkorange"),
main = "Análisis de Impurezas: Observado vs. Esperado",
xlab = "Nivel de Impurezas por Muestra",
ylab = "Frecuencia (Lotes)",
border = "white",
ylim = c(0, 100))
legend("topright",
legend = c("Observado (Planta)", "Esperado (Teoría)"),
fill = c("dodgerblue4", "darkorange"),
bty = "n")
grid(nx = NA, ny = NULL, lty = 2, col = "gray85")
TABLA
library(knitr)
library(kableExtra)
obs_t <- c(85, 40, 18, 7)
esp_t <- c(82, 44, 16, 8)
dif_t <- obs_t - esp_t
prop_t <- (dif_t * dif_t) / esp_t
categorias_nombres <- c("0 Impurezas", "1 Impureza", "2 Impurezas", "3+ Impurezas")
tabla_industrial <- data.frame(
Categoria = categorias_nombres,
Obs = obs_t,
Esp = esp_t,
Dif = dif_t,
Contribucion = prop_t
)
knitr::kable(
tabla_industrial,
col.names = c("Categoría", "Obs (O)", "Esp (E)", "Dif (O-E)", "Valor (O-E)²/E"),
align = "c",
digits = 4,
format = "pandoc"
)| Categoría | Obs (O) | Esp (E) | Dif (O-E) | Valor (O-E)²/E |
|---|---|---|---|---|
| 0 Impurezas | 85 | 82 | 3 | 0.1098 |
| 1 Impureza | 40 | 44 | -4 | 0.3636 |
| 2 Impurezas | 18 | 16 | 2 | 0.2500 |
| 3+ Impurezas | 7 | 8 | -1 | 0.1250 |
ANÁLISIS
El análisis de los datos obtenidos en la planta de lácteos muestra que el proceso de recepción de leche cruda presenta una alta adherencia al modelo teórico de Poisson, ya que el valor del estadístico \(\chi^2\) calculado es significativamente bajo. Al observar tanto la gráfica comparativa como la tabla de resultados, se evidencia que la mayor parte de los lotes (85 observados frente a 82 esperados) no presentan impurezas, y aunque la categoría de una sola impureza registró la mayor diferencia respecto a la teoría, esta no es suficiente para invalidar la estabilidad del sistema. En conclusión, dado que las frecuencias reales siguen de cerca las proyecciones estadísticas, se confirma que las operaciones de filtrado e inocuidad en la zona de producción se encuentran bajo control estadístico y cumplen con los estándares de calidad requeridos para el procesamiento industrial.
COMPARACIÓN CON LA FUNCIÓN DE R
library(knitr)
library(kableExtra)
# Parámetros del ejemplo: obs, esp, gl=3
obs_cc <- c(85, 40, 18, 7)
esp_cc <- c(82, 44, 16, 8)
gl_cc <- 3
# Estadístico manual (suma de (O-E)^2/E)
dif_cc <- obs_cc - esp_cc
chi_manual <- (dif_cc[1]*dif_cc[1]/esp_cc[1]) +
(dif_cc[2]*dif_cc[2]/esp_cc[2]) +
(dif_cc[3]*dif_cc[3]/esp_cc[3]) +
(dif_cc[4]*dif_cc[4]/esp_cc[4])
# Estadístico con función nativa de R
prueba_nativa <- chisq.test(obs_cc, p = esp_cc / sum(esp_cc))
chi_nativo <- prueba_nativa$statistic
# Tabla comparativa
comp_chi <- data.frame(
Método = c("Algoritmo Manual", "Función chisq.test() de R"),
Chi_cuadrado = c(round(chi_manual, 6), round(chi_nativo, 6)),
Coinciden = c("", ifelse(round(chi_manual, 4) == round(chi_nativo, 4), "Sí", "No"))
)
kable(comp_chi,
caption = "Comparación: Algoritmo Manual vs chisq.test() — gl=3",
align = "lcc",
col.names = c("Método", "Chi² Calculado", "Coinciden")) %>%
kable_styling(bootstrap_options = c("striped", "bordered"), full_width = F, position = "center") %>%
row_spec(0, background = "red", color = "white", bold = TRUE) %>%
row_spec(2, bold = TRUE, background = "#F9F9F9", color = "darkred")| Método | Chi² Calculado | Coinciden | |
|---|---|---|---|
| Algoritmo Manual | 0.848392 | ||
| X-squared | Función chisq.test() de R | 0.848392 | Sí |
4. DISTRIBUCIÓN DE POISSON
-DEFINICIÓN:
La Distribución de Poisson es una herramienta estadística que nos ayuda a predecir cuántas veces es probable que ocurra un evento determinado durante un periodo de tiempo específico o en un espacio definido.
Para comprender la Distribución de Poisson desde una perspectiva de ingeniería, es necesario considerar que esta se fundamenta en la existencia de un promedio conocido de ocurrencias (\(\lambda\)) dentro de un intervalo continuo, la independencia absoluta entre cada evento (donde el pasado no afecta la probabilidad futura) y la naturaleza aleatoria de sucesos que poseen una probabilidad de ocurrencia simultánea despreciable. Estos tres pilares permiten modelar procesos estables donde el interés principal es predecir la variabilidad de eventos discretos en un marco de tiempo o espacio determinado.
FÓRMULA
\[P(X = k) = \frac{\lambda^k e^{-\lambda}}{k!}\]
DONDE:
- \(P(X = k)\): Probabilidad de que ocurran exactamente \(k\) eventos.
- \(\lambda\): Promedio de ocurrencias en un intervalo determinado.
- \(e\): Constante de Euler (\(\approx 2.71828\)).
- \(k!\): Factorial del número de eventos.
-APLICACIÓN DEL EJERCICIO EN LA DISTRIBUCIÓN DE POISSON
Control de Calidad en Planta de Lácteos
Siguiendo con el estudio integral de nuestra planta procesadora de lácteos, tras haber analizado la variabilidad del peso y la grasa con otras distribuciones, ahora nos enfocaremos en la frecuencia de impurezas detectadas en los tanques durante la etapa de filtrado inicial.
A diferencia de los pesos (que son continuos), el conteo de impurezas por lote es un evento discreto. Por ello, aplicaremos la Distribución de Poisson para validar si la aparición de estos elementos sigue un patrón aleatorio bajo control o si existen picos que afecten la seguridad alimentaria del proceso.
Variables del ejercicio:
\(\lambda = 1.2\): Este valor representa el promedio de impurezas encontradas por cada lote de leche inspeccionado, calculado a partir de los datos reales de producción de la planta.
\(k = 2\): Es el número específico de eventos que queremos evaluar para este ejemplo (la probabilidad de encontrar exactamente 2 impurezas en un lote seleccionado al azar).
\(e = 2.71828\): Es la constante matemática de Euler necesaria para completar la función de densidad de Poisson.
\(n = 150\): Es el número total de lotes de leche que conforman la muestra del reporte técnico para el análisis de calidad.
ALGORITMO EN R
# --- Algoritmo Manual de Distribución de Poisson ---
# 1. Definición de variables
lambda_p <- 1.2 # Promedio de impurezas por lote
k_p <- 2 # Objetivo: probabilidad de exactamente 2 impurezas
e_p <- 2.71828 # Constante de Euler
n_p <- 150 # Tamaño de la muestra de lotes de leche
# 2. Cálculo manual de la fórmula de Poisson
numerador <- (lambda_p^k_p) * (e_p^-lambda_p)
denominador <- factorial(k_p)
probabilidad_individual <- numerador / denominador
# 3. Frecuencia esperada
frecuencia_esperada <- n_p * probabilidad_individual
# 4. Data frame de resultados
resultado_final <- data.frame(
Concepto = c("Probabilidad P(X=2)", "Lotes Esperados (E)"),
Valor = c(probabilidad_individual, frecuencia_esperada)
)
resultado_final## Concepto Valor
## 1 Probabilidad P(X=2) 0.21686
## 2 Lotes Esperados (E) 32.52900GRÁFICA
# --- Gráfica Distribución de Poisson ---
lambda_p <- 1.2
e_p <- 2.71828
k_objetivo <- 2
prob_k2 <- 0.21686
x_valores <- 0:6
y_probabilidades <- (lambda_p^x_valores * e_p^-lambda_p) / factorial(x_valores)
grafica <- barplot(y_probabilidades,
names.arg = x_valores,
col = ifelse(x_valores == k_objetivo, "firebrick", "dodgerblue4"),
main = "Análisis de Frecuencia de Impurezas (Poisson)",
xlab = "Impurezas por Lote (k)",
ylab = "Probabilidad",
ylim = c(0, 0.4))
text(x = grafica, y = y_probabilidades,
label = round(y_probabilidades, 3), pos = 3, cex = 0.8)
abline(h = prob_k2, col = "red", lty = 2)
TABLA
library(knitr)
library(kableExtra)
# 1. Parámetros de la Planta
lambda_p <- 1.2
k_objetivo <- 2
e_val <- 2.71828
# 2. Cálculo manual de Poisson
numerador <- (lambda_p^k_objetivo) * (e_val^-lambda_p)
denominador <- factorial(k_objetivo)
resultado_poisson <- numerador / denominador
# 3. Data frame para la tabla
datos_poisson <- data.frame(
Concepto = c("Variable de Control (k)",
"Media del Proceso (lambda)",
"Constante de Euler (e)",
"Densidad Calculada f(k)"),
Unidad = c("Impurezas",
"Impurezas/Lote",
"Adimensional",
"Probabilidad"),
Valor = c(format(k_objetivo, nsmall = 5),
format(lambda_p, nsmall = 5),
format(e_val, nsmall = 5),
round(resultado_poisson, 5))
)
# 4. Tabla con estilo
kable(datos_poisson,
caption = "Resultados del Modelo Poisson: Frecuencia de Impurezas en Lotes",
align = "llc",
booktabs = TRUE) %>%
kable_styling(bootstrap_options = c("striped", "bordered", "condensed"),
full_width = F, position = "center") %>%
row_spec(0, background = "red", color = "white", bold = TRUE) %>%
row_spec(4, bold = TRUE, background = "#F9F9F9", color = "darkred")| Concepto | Unidad | Valor |
|---|---|---|
| Variable de Control (k) | Impurezas | 2.00000 |
| Media del Proceso (lambda) | Impurezas/Lote | 1.20000 |
| Constante de Euler (e) | Adimensional | 2.71828 |
| Densidad Calculada f(k) | Probabilidad | 0.21686 |
COMPARACIÓN CON R
library(knitr)
library(kableExtra)
# Parámetros del ejemplo (lambda=1.2, k=2)
lambda_cp <- 1.2
k_cp <- 2
e_cp <- 2.71828
# Resultado del algoritmo manual
resultado_manual_p <- ((lambda_cp^k_cp) * (e_cp^-lambda_cp)) / factorial(k_cp)
# Resultado con función nativa de R
resultado_nativo_p <- dpois(k_cp, lambda = lambda_cp)
# Tabla comparativa
comp_p <- data.frame(
Método = c("Algoritmo Manual", "Función dpois() de R"),
Resultado = c(round(resultado_manual_p, 8), round(resultado_nativo_p, 8)),
Coinciden = c("", ifelse(round(resultado_manual_p, 4) == round(resultado_nativo_p, 4), "Sí", "No"))
)
kable(comp_p,
caption = "Comparación: Algoritmo Manual vs dpois() — lambda=1.2, k=2",
align = "lcc") %>%
kable_styling(bootstrap_options = c("striped", "bordered"), full_width = F, position = "center") %>%
row_spec(0, background = "red", color = "white", bold = TRUE) %>%
row_spec(2, bold = TRUE, background = "#F9F9F9", color = "darkred")| Método | Resultado | Coinciden |
|---|---|---|
| Algoritmo Manual | 0.2168600 | |
| Función dpois() de R | 0.2168598 | Sí |
5. DISTRIBUCIÓN EXPONENCIAL
-DEFINICIÓN:
La Distribución Exponencial es una herramienta de la estadística que se utiliza para medir el tiempo que pasa entre dos eventos. Si la distribución de Poisson cuenta cuántas veces sucede algo, la Exponencial mide cuánto tardamos en ver que ese algo vuelva a ocurrir.
Se usa principalmente para predecir tiempos de espera o duraciones en sistemas de ingeniería y servicios.
-FÓRMULA:
\[P(X \leq t) = 1 - e^{-\lambda t}\]
Donde:
- \(P(X \leq t)\): Probabilidad Acumulada.
- \(X\): Tiempo de espera o tiempo entre fallas.
- \(t\): Tiempo específico de evaluación.
- \(e\): Constante de Euler (\(\approx 2.71828\)).
- \(\lambda\): Tasa de ocurrencia.
-APLICACIÓN DEL EJERCICIO EN LA DISTRIBUCIÓN EXPONENCIAL
Utilizamos la Distribución Exponencial para modelar el tiempo que transcurre entre fallas mecánicas de las selladoras térmicas. Si la tasa de fallas es de 0.5 por día, el objetivo es calcular la probabilidad de que una máquina falle antes de completar un ciclo de trabajo de 3 días.
Variables del ejercicio:
- \(t = 3\): Periodo de 3 días de evaluación.
- \(\lambda = 0.5\): Frecuencia promedio de 0.5 fallas por día.
- \(e = 2.71828\): Constante de Euler.
- \(P(X \leq 3)\): Probabilidad de que la máquina falle antes de los 3 días.
ALGORITMO EN R
t_evaluado <- 3
lambda_fallas <- 0.5
e_euler <- 2.71828
exponente_manual <- -(lambda_fallas * t_evaluado)
e_elevado <- e_euler ^ exponente_manual
probabilidad_resultante <- 1 - e_elevado
probabilidad_resultante## [1] 0.7768696GRÁFICA
lambda_val <- 0.5
e_euler <- 2.71828
x <- 0:10
y <- lambda_val * (e_euler ^ -(lambda_val * x))
plot(x, y,
type = "o",
col = "blue",
main = "Fallas en Selladoras",
xlab = "Dias",
ylab = "Probabilidad")
abline(v = 3, col = "red")
text(5, 0.4, "Probabilidad = 0.77687")
TABLA
library(knitr)
library(kableExtra)
conceptos <- c("Tasa de Fallas (Lambda)",
"Tiempo de Evaluación (t)",
"Constante de Euler (e)",
"Probabilidad Acumulada P(X <= 3)")
unidades <- c("Fallas/Día",
"Días de Operación",
"Constante Matemática",
"Porcentaje de Riesgo")
valores <- c("0.50000", "3.00000", "2.71828", "0.77687")
tabla_exponencial <- data.frame(Concepto = conceptos,
Unidad = unidades,
Valor = valores)
kable(tabla_exponencial,
caption = "Resultados de la Fase 3: Confiabilidad en Planta de Lácteos",
align = "llc",
booktabs = TRUE) %>%
kable_styling(bootstrap_options = c("striped", "bordered", "condensed"),
full_width = F, position = "center") %>%
row_spec(0, background = "red", color = "white", bold = TRUE) %>%
row_spec(4, bold = TRUE, background = "#F9F9F9", color = "darkred")| Concepto | Unidad | Valor |
|---|---|---|
| Tasa de Fallas (Lambda) | Fallas/Día | 0.50000 |
| Tiempo de Evaluación (t) | Días de Operación | 3.00000 |
| Constante de Euler (e) | Constante Matemática | 2.71828 |
| Probabilidad Acumulada P(X <= 3) | Porcentaje de Riesgo | 0.77687 |
COMPARACIÓN CON LA FUNCIÓN DE R
library(knitr)
library(kableExtra)
# Parámetros del ejemplo (lambda=0.5, t=3)
lambda_ce <- 0.5
t_ce <- 3
e_ce <- 2.71828
# Resultado del algoritmo manual P(X <= t) = 1 - e^(-lambda*t)
resultado_manual_e <- 1 - (e_ce ^ -(lambda_ce * t_ce))
# Resultado con función nativa de R
resultado_nativo_e <- pexp(t_ce, rate = lambda_ce)
# Tabla comparativa
comp_e <- data.frame(
Método = c("Algoritmo Manual", "Función pexp() de R"),
Resultado = c(round(resultado_manual_e, 8), round(resultado_nativo_e, 8)),
Coinciden = c("", ifelse(round(resultado_manual_e, 4) == round(resultado_nativo_e, 4), "Sí", "No"))
)
kable(comp_e,
caption = "Comparación: Algoritmo Manual vs pexp() — lambda=0.5, t=3",
align = "lcc") %>%
kable_styling(bootstrap_options = c("striped", "bordered"), full_width = F, position = "center") %>%
row_spec(0, background = "red", color = "white", bold = TRUE) %>%
row_spec(2, bold = TRUE, background = "#F9F9F9", color = "darkred")| Método | Resultado | Coinciden |
|---|---|---|
| Algoritmo Manual | 0.7768696 | |
| Función pexp() de R | 0.7768698 | Sí |
Referencias
Montgomery, D. C., & Runger, G. C. (2018). Applied statistics and probability for engineers (7th ed.). John Wiley & Sons.
Wackerly, D. D., Mendenhall, W., & Scheaffer, R. L. (2008). Estadística matemática con aplicaciones (7ª ed.). Cengage Learning.
R Core Team. (2024). R: A language and environment for statistical computing (Version 4.4.1). R Foundation for Statistical Computing. https://www.R-project.org/
Montgomery, D. C. (2020). Introduction to statistical quality control (8th ed.). John Wiley & Sons.
Instituto Colombiano de Normas Técnicas y Certificación. (2016). NTC 399: Leche cruda. Requisitos. ICONTEC.