import unittest
import numpy as np
import user_code  # ÐºÐ¾Ð´ ÑÑÑÐ´ÐµÐ½ÑÐ°

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-10
RTOL = 1e-9

class TestQualityControlProb(unittest.TestCase):

    def test_variables_exist_and_types(self):
        reasons = []

        # Scalars & counts
        total_rods = getattr(user_code, "total_rods", None)
        defective = getattr(user_code, "defective", None)
        long_ = getattr(user_code, "long", None)
        defective_and_long = getattr(user_code, "defective_and_long", None)

        # Probabilities
        P_D_or_L = getattr(user_code, "P_D_or_L", None)
        P_D_given_L = getattr(user_code, "P_D_given_L", None)

        # Sampling params & outputs
        population_mean = getattr(user_code, "population_mean", None)
        population_std = getattr(user_code, "population_std", None)
        sample_size = getattr(user_code, "sample_size", None)
        sample_lengths = getattr(user_code, "sample_lengths", None)
        sample_mean = getattr(user_code, "sample_mean", None)
        sample_variance = getattr(user_code, "sample_variance", None)
        sample_std = getattr(user_code, "sample_std", None)

        # Basic presence & type checks
        if not isinstance(total_rods, (int, np.integer)):
            reasons.append("total_rods must be int")
        if not isinstance(defective, (int, np.integer)):
            reasons.append("defective must be int")
        if not isinstance(long_, (int, np.integer)):
            reasons.append("long must be int")
        if not isinstance(defective_and_long, (int, np.integer)):
            reasons.append("defective_and_long must be int")

        if not isinstance(P_D_or_L, (float, np.floating)):
            reasons.append("P_D_or_L must be float")
        if not isinstance(P_D_given_L, (float, np.floating)):
            reasons.append("P_D_given_L must be float")

        if not isinstance(population_mean, (int, float, np.integer, np.floating)):
            reasons.append("population_mean must be numeric")
        if not isinstance(population_std, (int, float, np.integer, np.floating)):
            reasons.append("population_std must be numeric")
        if not isinstance(sample_size, (int, np.integer)):
            reasons.append("sample_size must be int")

        if not (isinstance(sample_lengths, np.ndarray) and sample_lengths.shape == (sample_size,)):
            reasons.append(f"sample_lengths must be ndarray of shape ({sample_size},)")
        if not isinstance(sample_mean, (float, np.floating)):
            reasons.append("sample_mean must be float")
        if not isinstance(sample_variance, (float, np.floating)):
            reasons.append("sample_variance must be float")
        if not isinstance(sample_std, (float, np.floating)):
            reasons.append("sample_std must be float")

        _dynamic(self,
                 len(reasons) == 0,
                 "PASS: variables exist with correct types/shapes",
                 "FAIL: " + " | ".join(reasons) if reasons else "FAIL")

    def test_probabilities_correct(self):
        reasons = []

        total_rods = user_code.total_rods
        defective = user_code.defective
        long_ = user_code.long
        defective_and_long = user_code.defective_and_long

        expected_union = (defective/total_rods) + (long_/total_rods) - (defective_and_long/total_rods)
        expected_cond = (defective_and_long/total_rods) / (long_/total_rods)

        if not np.isclose(user_code.P_D_or_L, expected_union, atol=ATOL, rtol=RTOL):
            reasons.append(f"P(D âª L) incorrect: expected {expected_union}, got {user_code.P_D_or_L}")
        if not np.isclose(user_code.P_D_given_L, expected_cond, atol=ATOL, rtol=RTOL):
            reasons.append(f"P(D|L) incorrect: expected {expected_cond}, got {user_code.P_D_given_L}")

        _dynamic(self,
                 len(reasons) == 0,
                 "PASS: probabilities (union & conditional) are correct",
                 "FAIL: " + " | ".join(reasons) if reasons else "FAIL")

    def test_sampling_reproducible_and_stats(self):
        reasons = []

        # Recompute expected sample deterministically with the same seed & params
        population_mean = user_code.population_mean
        population_std = user_code.population_std
        sample_size = user_code.sample_size

        np.random.seed(0)
        expected_sample = np.random.normal(loc=population_mean, scale=population_std, size=sample_size)
        expected_mean = np.mean(expected_sample)
        expected_var = np.var(expected_sample, ddof=1)
        expected_std = np.std(expected_sample, ddof=1)

        # Compare arrays & stats
        if not (isinstance(user_code.sample_lengths, np.ndarray) and user_code.sample_lengths.shape == expected_sample.shape):
            reasons.append("sample_lengths shape mismatch")
        else:
            if not np.allclose(user_code.sample_lengths, expected_sample, atol=1e-12, rtol=1e-12):
                reasons.append("sample_lengths not reproducible with seed=0 and given parameters")

        if not np.isclose(user_code.sample_mean, expected_mean, atol=ATOL, rtol=RTOL):
            reasons.append(f"sample_mean incorrect: expected {expected_mean}, got {user_code.sample_mean}")
        if not np.isclose(user_code.sample_variance, expected_var, atol=ATOL, rtol=RTOL):
            reasons.append(f"sample_variance incorrect (use ddof=1): expected {expected_var}, got {user_code.sample_variance}")
        if not np.isclose(user_code.sample_std, expected_std, atol=ATOL, rtol=RTOL):
            reasons.append(f"sample_std incorrect (use ddof=1): expected {expected_std}, got {user_code.sample_std}")

        _dynamic(self,
                 len(reasons) == 0,
                 "PASS: sampling is reproducible & stats (mean/var/std) correct",
                 "FAIL: " + " | ".join(reasons) if reasons else "FAIL")


test_code.py

Padroneggia le basi matematiche essenziali per la data science. Esplora concetti fondamentali su funzioni, calcolo, algebra lineare, probabilità e riduzione della dimensionalità. Costruisci sia una comprensione teorica sia esperienza pratica di programmazione per rafforzare la capacità di analizzare dati, modellare sistemi complessi e applicare tecniche avanzate nel machine learning.

Esplora le basi delle funzioni matematiche. Scopri i diversi tipi di funzioni algebriche e trascendenti, le loro proprietà e come implementarle in Python per risolvere problemi reali.

Padroneggia i concetti di insiemi e serie, dalle operazioni di base alle applicazioni pratiche. Acquisisci esperienza pratica nell'implementazione delle operazioni sugli insiemi e nel lavoro con serie aritmetiche e geometriche in Python.

Sviluppare una solida comprensione di limiti, derivate, integrali e derivate parziali. Collegare la teoria alla pratica implementando questi concetti in Python e applicandoli all'ottimizzazione tramite discesa del gradiente.

Acquisizione di solide conoscenze su vettori, matrici e trasformazioni. Studio dei metodi di decomposizione e analisi degli autovalori, con consolidamento dei concetti tramite esercizi di programmazione in Python e applicazioni pratiche nella data science.

Approfondimento sulla teoria della probabilità e sulla statistica. Studio della probabilità condizionata, del teorema di Bayes e delle misure statistiche. Implementazione dei concetti chiave in Python, simulazione di distribuzioni e consolidamento delle competenze tramite esercizi e quiz.

Sfida: Analisi della Probabilità nel Controllo Qualità

Soluzione

Awesome!

Sfida: Analisi della Probabilità nel Controllo Qualità

Soluzione