Eres el gerente de control de calidad en una fábrica de fabricación de varillas. Necesitas simular mediciones y conteos de defectos utilizando tres distribuciones de probabilidad diferentes para modelar tu proceso de producción:
- Distribución normal para los pesos de las varillas (continua);
- Distribución binomial para el número de varillas defectuosas en lotes (discreta);
- Distribución uniforme para las tolerancias de longitud de las varillas (continua).

Tu tarea es **traducir las fórmulas y conceptos de tu clase a código Python**. **NO debes** usar funciones integradas de muestreo aleatorio de numpy (por ejemplo, `np.random.normal`) ni métodos directos de muestreo de ninguna otra biblioteca para las distribuciones. En su lugar, implementa la generación de muestras manualmente utilizando los principios subyacentes y Python básico (por ejemplo, `random.random()`, `random.gauss()`).


Nota

### Fórmulas a utilizar

### PDF de la distribución normal:

$$
f(x) = \frac{1}{\sigma\sqrt{2\pi}}e^{-\frac{(x - \mu)^2}{2\sigma^2}}
$$
 
### Desviación estándar a partir de la varianza:

$$
\sigma = \sqrt{\text{variance}}
$$

### PMF de la distribución binomial:

$$
P(X = k) = \begin{pmatrix}n\\k\end{pmatrix}n^k(1-n)^{n-k},\quad \text{where}\begin{pmatrix}n\\k\end{pmatrix} = \frac{n!}{k!(n-k)!}
$$
 
### PDF de la distribución uniforme:

$$
f(x) = \frac{1}{b-a}\quad \text{for}\quad a \le x \le b
$$

import unittest
import math
import random
import numpy as np
import user_code  # student's submission

def _dynamic(tc, ok, ok_msg, fail_msg):
    tc._testMethodName = ok_msg if ok else fail_msg
    (tc.assertTrue if ok else tc.fail)(tc._testMethodName)

ATOL = 1e-7
RTOL = 1e-6

class TestQCDistributionsV2(unittest.TestCase):

    def test_params_and_sigma(self):
        reasons = []
        mu = getattr(user_code, "mu", None)
        variance = getattr(user_code, "variance", None)
        sigma = getattr(user_code, "sigma", None)
        n = getattr(user_code, "n", None)
        p = getattr(user_code, "p", None)
        a = getattr(user_code, "a", None)
        b = getattr(user_code, "b", None)

        # Check exact parameters matching instructions
        if mu != 200: reasons.append("mu must be 200")
        if variance != 25: reasons.append("variance must be 25")
        if n != 20: reasons.append("n must be 20")
        if not (isinstance(p, (int, float)) and math.isclose(p, 0.05, rel_tol=1e-9)): 
            reasons.append("p must be 0.05")
        if not (isinstance(a, (int, float)) and math.isclose(a, 49.5, rel_tol=1e-9)): 
            reasons.append("a must be 49.5")
        if not (isinstance(b, (int, float)) and math.isclose(b, 50.5, rel_tol=1e-9)): 
            reasons.append("b must be 50.5")

        if not isinstance(sigma, (int, float)):
            reasons.append("sigma must be numeric")
        elif variance == 25:
            exp_sigma = math.sqrt(variance)
            if not math.isclose(sigma, exp_sigma, rel_tol=1e-9, abs_tol=1e-12):
                reasons.append(f"sigma must equal sqrt(variance): expected {exp_sigma}, got {sigma}")

        _dynamic(
            self,
            len(reasons) == 0,
            "PASS: parameters valid & sigma computed from variance",
            "FAIL: " + " | ".join(reasons) if reasons else "FAIL"
        )

    def test_functions_exist_and_return_sizes(self):
        reasons = []
        for name in ("sample_normal", "sample_binomial", "sample_uniform"):
            fn = getattr(user_code, name, None)
            if not callable(fn):
                reasons.append(f"{name} must be a function")

        if len(reasons) == 0:
            # Smoke-run with small sizes to confirm signatures
            try:
                random.seed(1)
                normals = user_code.sample_normal(user_code.mu, user_code.sigma, size=17)
                bins = user_code.sample_binomial(user_code.n, user_code.p, size=19)
                unis = user_code.sample_uniform(user_code.a, user_code.b, size=23)
                if not (len(normals) == 17 and len(bins) == 19 and len(unis) == 23):
                    reasons.append("sampling functions must respect the 'size' argument")
            except Exception as e:
                reasons.append(f"sampling call error: {e}")

        _dynamic(
            self,
            len(reasons) == 0,
            "PASS: sampling functions exist and respect sizes",
            "FAIL: " + " | ".join(reasons) if reasons else "FAIL"
        )

    def test_normal_sampling_stats(self):
        mu, sigma = 200, 5.0
        random.seed(12345)
        samples = user_code.sample_normal(mu, sigma, size=15000)
        arr = np.asarray(samples, dtype=float)

        reasons = []
        if arr.ndim != 1 or arr.size != 15000 or not np.isfinite(arr).all():
            reasons.append("sample_normal must return a 1D finite sequence of requested size")

        mean_tol = 0.12 * max(1.0, abs(sigma))
        std_tol  = 0.12 * max(1.0, abs(sigma))

        m = float(np.mean(arr))
        s = float(np.std(arr, ddof=0))
        if abs(m - mu) > mean_tol:
            reasons.append(f"Normal mean off: expected ~{mu}, got {m}")
        if abs(s - sigma) > std_tol:
            reasons.append(f"Normal std off: expected ~{sigma}, got {s}")

        _dynamic(
            self,
            len(reasons) == 0,
            "PASS: normal sampling ~correct mean/std",
            "FAIL: " + " | ".join(reasons) if reasons else "FAIL"
        )

    def test_binomial_sampling_stats(self):
        n, p = 20, 0.05
        random.seed(24680)
        samples = user_code.sample_binomial(n, p, size=20000)
        arr = np.asarray(samples, dtype=float)

        reasons = []
        if arr.ndim != 1 or arr.size != 20000:
            reasons.append("sample_binomial must return a 1D sequence of requested size")
        if np.min(arr) < 0 or np.max(arr) > n:
            reasons.append("binomial samples must lie in [0, n]")

        expected_mean = n * p
        expected_var = n * p * (1 - p)
        sample_mean = float(np.mean(arr))
        
        se = math.sqrt(expected_var / arr.size) if expected_var > 0 else 0.0
        margin = 6 * se if se > 0 else 0.15
        if abs(sample_mean - expected_mean) > margin + 0.05:
            reasons.append(f"Binomial mean off: expected ~{expected_mean}, got {sample_mean}")

        _dynamic(
            self,
            len(reasons) == 0,
            "PASS: binomial sampling ~correct mean & bounds",
            "FAIL: " + " | ".join(reasons) if reasons else "FAIL"
        )

    def test_uniform_sampling_stats(self):
        a, b = 49.5, 50.5
        random.seed(13579)
        samples = user_code.sample_uniform(a, b, size=20000)
        arr = np.asarray(samples, dtype=float)

        reasons = []
        if arr.ndim != 1 or arr.size != 20000:
            reasons.append("sample_uniform must return a 1D sequence of requested size")
        if np.min(arr) < a - 1e-9 or np.max(arr) > b + 1e-9:
            reasons.append("uniform samples must lie in [a, b]")

        expected_mean = (a + b) / 2.0
        expected_var = ((b - a) ** 2) / 12.0
        sample_mean = float(np.mean(arr))
        sample_var = float(np.var(arr, ddof=0))

        mean_tol = max(0.01, 0.05 * (b - a))
        var_tol  = max(0.01, 0.12 * expected_var)

        if abs(sample_mean - expected_mean) > mean_tol:
            reasons.append(f"Uniform mean off: expected ~{expected_mean}, got {sample_mean}")
        if abs(sample_var - expected_var) > var_tol:
            reasons.append(f"Uniform variance off: expected ~{expected_var}, got {sample_var}")

        _dynamic(
            self,
            len(reasons) == 0,
            "PASS: uniform sampling ~correct mean/var & range",
            "FAIL: " + " | ".join(reasons) if reasons else "FAIL"
        )

test_code.py

Domina los fundamentos matemáticos esenciales para la ciencia de datos. Explora conceptos clave en funciones, cálculo, álgebra lineal, probabilidad y reducción de dimensionalidad. Desarrolla tanto la comprensión teórica como la experiencia práctica en programación para fortalecer tu capacidad de analizar datos, modelar sistemas complejos y aplicar técnicas avanzadas en aprendizaje automático.

Explora los fundamentos de las funciones matemáticas. Estudia los diferentes tipos de funciones algebraicas y trascendentales, sus propiedades y cómo implementarlas en Python para resolver problemas del mundo real.

Domina los conceptos de conjuntos y series, desde operaciones básicas hasta aplicaciones prácticas. Adquiere experiencia práctica implementando operaciones con conjuntos y trabajando con series aritméticas y geométricas en Python.

Desarrollar una comprensión sólida de límites, derivadas, integrales y derivadas parciales. Conectar la teoría con la práctica implementando estos conceptos en Python y aplicándolos a la optimización mediante descenso por gradiente.

Desarrolla un conocimiento sólido de vectores, matrices y transformaciones. Aprende métodos de descomposición y análisis de valores propios, reforzando los conceptos con desafíos de codificación en Python y aplicaciones prácticas en ciencia de datos.

Explora la teoría de la probabilidad y la estadística. Estudia la probabilidad condicional, el teorema de Bayes y las medidas estadísticas. Implementa conceptos clave en Python, simula distribuciones y refuerza tus habilidades mediante desafíos y cuestionarios.

Desafío: Muestreo para Control de Calidad

Fórmulas a utilizar

PDF de la distribución normal:

Desviación estándar a partir de la varianza:

PMF de la distribución binomial:

PDF de la distribución uniforme:

Solución