 You are the quality control manager at a rod manufacturing factory. You need to simulate measurements and defect counts using three different probability distributions to model your production process:
- Normal distribution for rod weights (continuous);
- Binomial distribution for the number of defective rods in batches (discrete);
- Uniform distribution for rod length tolerances (continuous).

Your task is to **translate the formulas and concepts from your lecture into Python code**. You **must NOT** use built-in numpy random sampling functions (e.g., `np.random.normal`) or any other library's direct sampling methods for the distributions. Instead, implement sample generation manually using the underlying principles and basic Python (e.g., `random.random()`, `random.gauss()`).


Note

### Formulas to Use

### Normal distribution PDF:

$$
f(x) = \frac{1}{\sigma\sqrt{2\pi}}e^{-\frac{(x - \mu)^2}{2\sigma^2}}
$$
 
### Standard deviation from variance:

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

### Binomial distribution PMF:

$$
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)!}
$$
 
### Uniform distribution PDF:

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

        # Presence & basic types
        if not isinstance(mu, (int, float)):
            reasons.append("mu must be numeric")
        if not (isinstance(variance, (int, float)) and variance > 0):
            reasons.append("variance must be positive numeric")
        if not isinstance(sigma, (int, float)):
            reasons.append("sigma must be numeric")
        else:
            if isinstance(variance, (int, float)) and variance > 0:
                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}")

        if not (isinstance(n, int) and n > 0):
            reasons.append("n must be positive int")
        if not (isinstance(p, (int, float)) and 0 <= p <= 1):
            reasons.append("p must be in [0,1]")
        if not (isinstance(a, (int, float)) and isinstance(b, (int, float)) and a < b):
            reasons.append("uniform bounds must satisfy a < b (numeric)")

        _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 = user_code.mu, user_code.sigma
        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")

        # Generous tolerances (sampling error ~ 1/sqrt(N)), use fixed cushions
        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 = user_code.n, user_code.p
        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))
        # Â±6 SE margin (very lenient) or small absolute fallback if variance=0
        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 = user_code.a, user_code.b
        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

This course distills the essentials of Python's math module, focusing on trigonometric functions, logarithmic operations, and mathematical constants. Learners will gain hands-on experience using Python to perform these standard mathematical computations, ideal for beginners seeking practical skills with the math module.

Challenge: Quality Control Sampling

Formulas to Use

Normal distribution PDF:

Standard deviation from variance:

Binomial distribution PMF:

Uniform distribution PDF:

Solution