 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

Master the mathematical foundations essential for data science. Explore core concepts in functions, calculus, linear algebra, probability, and dimensionality reduction. Build both theoretical understanding and practical coding experience to strengthen your ability to analyze data, model complex systems, and apply advanced techniques in machine learning.

Explore the foundation of mathematical functions. Learn different types of algebraic and transcendental functions, their properties, and how to implement them in Python to solve real-world problems.

Master the concepts of sets and series, from basic operations to practical applications. Gain hands-on experience implementing set operations and working with arithmetic and geometric series in Python.

Develop a solid understanding of limits, derivatives, integrals, and partial derivatives. Connect theory to practice by implementing these concepts in Python and applying them to optimization through gradient descent.

Build strong knowledge of vectors, matrices, and transformations. Learn decomposition methods and eigenvalue analysis, while reinforcing concepts with Python coding challenges and practical data science applications.

Dive into probability theory and statistics. Study conditional probability, Bayes' theorem, and statistical measures. Implement key concepts in Python, simulate distributions, and strengthen your skills through challenges and quizzes.

Challenge: Quality Control Sampling

Formulas to Use

Normal distribution PDF:

Standard deviation from variance:

Binomial distribution PMF:

Uniform distribution PDF:

Solution