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

class TestLUChallenge(unittest.TestCase):

    def test_variables_exist_and_shapes(self):
        reasons = []
        A = getattr(user_code, "A", None)
        b = getattr(user_code, "b", None)
        L = getattr(user_code, "L", None)
        U = getattr(user_code, "U", None)
        y = getattr(user_code, "y", None)
        x = getattr(user_code, "x", None)

        if not (isinstance(A, np.ndarray) and A.shape == (3,3)):
            reasons.append(f"A must be 3x3 ndarray; got {None if A is None else A.shape}")
        if not (isinstance(b, np.ndarray) and b.shape == (3,)):
            reasons.append(f"b must be shape (3,); got {None if b is None else b.shape}")
        if not (isinstance(L, np.ndarray) and L.shape == (3,3)):
            reasons.append(f"L must be 3x3 ndarray; got {None if L is None else L.shape}")
        if not (isinstance(U, np.ndarray) and U.shape == (3,3)):
            reasons.append(f"U must be 3x3 ndarray; got {None if U is None else U.shape}")
        if not (isinstance(y, np.ndarray) and y.shape == (3,)):
            reasons.append(f"y must be shape (3,); got {None if y is None else y.shape}")
        if not (isinstance(x, np.ndarray) and x.shape == (3,)):
            reasons.append(f"x must be shape (3,); got {None if x is None else x.shape}")

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

    def test_LU_structure_and_reconstruction(self):
        reasons = []
        A, L, U = user_code.A, user_code.L, user_code.U

        # L: ones on diagonal, zeros above
        if not np.allclose(np.diag(L), np.ones(3), atol=ATOL, rtol=RTOL):
            reasons.append("L diagonal must be all ones")
        if not np.allclose(np.triu(L, k=1), np.zeros_like(np.triu(L, k=1)), atol=ATOL, rtol=RTOL):
            reasons.append("L must be lower triangular (zeros above diagonal)")

        # U: zeros below diagonal
        if not np.allclose(np.tril(U, k=-1), np.zeros_like(np.tril(U, k=-1)), atol=ATOL, rtol=RTOL):
            reasons.append("U must be upper triangular (zeros below diagonal)")

        # Reconstruction
        if not np.allclose(L @ U, A, atol=1e-7, rtol=1e-6):
            reasons.append("L @ U does not reconstruct A within tolerance")

        _dynamic(self,
                 len(reasons) == 0,
                 "PASS: L/U structure and A â L@U",
                 "FAIL: " + " | ".join(reasons) if reasons else "FAIL")

    def test_forward_and_backward(self):
        reasons = []
        A, b, L, U, y, x = user_code.A, user_code.b, user_code.L, user_code.U, user_code.y, user_code.x

        # Forward: Ly â b
        if not np.allclose(L @ y, b, atol=1e-7, rtol=1e-6):
            reasons.append("Forward substitution incorrect: L @ y != b")

        # Backward: Ux â y
        if not np.allclose(U @ x, y, atol=1e-7, rtol=1e-6):
            reasons.append("Backward substitution incorrect: U @ x != y")

        _dynamic(self,
                 len(reasons) == 0,
                 "PASS: forward (Ly=b) & backward (Ux=y) checks",
                 "FAIL: " + " | ".join(reasons) if reasons else "FAIL")

    def test_solution_matches_numpy(self):
        reasons = []
        A, b, x = user_code.A, user_code.b, user_code.x
        x_np = np.linalg.solve(A, b)

        if not np.allclose(x, x_np, atol=1e-7, rtol=1e-6):
            reasons.append(f"x does not match np.linalg.solve: expected {x_np}, got {x}")

        _dynamic(self,
                 len(reasons) == 0,
                 "PASS: x matches NumPy solution",
                 "FAIL: " + " | ".join(reasons) if reasons else "FAIL")


test_code.py

Behärska de matematiska grunderna som är avgörande för datavetenskap. Utforska centrala begrepp inom funktioner, analys, linjär algebra, sannolikhet och dimensionsreduktion. Bygg både teoretisk förståelse och praktisk kodningsvana för att stärka din förmåga att analysera data, modellera komplexa system och tillämpa avancerade tekniker inom maskininlärning.

Utforska grunderna för matematiska funktioner. Lär dig olika typer av algebraiska och transcendenta funktioner, deras egenskaper och hur de implementeras i Python för att lösa verkliga problem.

Behärska begreppen mängder och serier, från grundläggande operationer till praktiska tillämpningar. Få praktisk erfarenhet av att implementera mängdoperationer och arbeta med aritmetiska och geometriska serier i Python.

Utveckla en gedigen förståelse för gränsvärden, derivator, integraler och partiella derivator. Koppla teori till praktik genom att implementera dessa koncept i Python och tillämpa dem på optimering med hjälp av gradientnedstigning.

Bygg gedigna kunskaper om vektorer, matriser och transformationer. Lär dig dekompositionsmetoder och egenvärdesanalys, samtidigt som begreppen förstärks med Python-programmeringsutmaningar och praktiska tillämpningar inom data science.

Fördjupa dig i sannolikhetsteori och statistik. Studera betingad sannolikhet, Bayes sats och statistiska mått. Implementera centrala koncept i Python, simulera fördelningar och stärk dina färdigheter genom utmaningar och frågesporter.

Utmaning: Lösning av ett Linjärt Ekvationssystem med LU-faktorisering

Lösning

Awesome!

Utmaning: Lösning av ett Linjärt Ekvationssystem med LU-faktorisering

Lösning