あなたは棒製造工場の品質管理マネージャーです。生産プロセスをモデル化するために、3種類の確率分布を用いて測定値と不良品数をシミュレーションする必要があります。
- 棒の重量（連続値）には正規分布を使用；
- バッチ内の不良棒の本数（離散値）には二項分布を使用；
- 棒の長さの許容範囲（連続値）には一様分布を使用。

あなたの課題は、講義で学んだ数式や概念をPythonコードに**翻訳すること**です。組み込みのnumpyの乱数サンプリング関数（例：`np.random.normal`）や、他のライブラリの分布用直接サンプリングメソッドは**絶対に使用しないでください**。代わりに、基本的なPython（例：`random.random()`、`random.gauss()`）と分布の原理を用いてサンプル生成を手動で実装してください。


注意

### 使用する数式

### 正規分布の確率密度関数（PDF）:

$$
f(x) = \frac{1}{\sigma\sqrt{2\pi}}e^{-\frac{(x - \mu)^2}{2\sigma^2}}
$$
 
### 分散から標準偏差の算出:

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

### 二項分布の確率質量関数（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)!}
$$
 
### 一様分布の確率密度関数（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

データサイエンスに不可欠な数学的基礎を習得します。関数、微積分、線形代数、確率、次元削減の主要な概念を探求します。理論的理解と実践的なコーディング経験の両方を構築し、データ分析、複雑なシステムのモデリング、機械学習における高度な手法の適用能力を強化します。

数学関数の基礎を探求します。さまざまな種類の代数関数および超越関数、その性質、およびそれらをPythonで実装して実世界の問題を解決する方法について学びます。

集合と級数の概念を基礎的な操作から実践的な応用まで習得します。Pythonで集合演算を実装し、等差数列および等比数列を扱う実践的な経験を得られます。

極限、導関数、積分、偏導関数についての確かな理解を身につけます。これらの概念をPythonで実装し、勾配降下法による最適化への応用を通じて理論と実践を結びつけます。

ベクトル、行列、変換に関する強固な知識の構築。分解法および固有値解析の学習。Pythonによるコーディング課題や実践的なデータサイエンス応用を通じた概念の強化。

確率論と統計学を深く学びます。条件付き確率、ベイズの定理、統計的指標を学習します。Pythonで主要な概念を実装し、分布をシミュレーションし、課題やクイズを通じてスキルを強化します。

チャレンジ：品質管理サンプリング

使用する数式

正規分布の確率密度関数（PDF）:

分散から標準偏差の算出:

二項分布の確率質量関数（PMF）:

一様分布の確率密度関数（PDF）:

解答