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

Behersk de matematiske grunnprinsippene som er essensielle for datavitenskap. Utforsk kjernebegreper innen funksjoner, kalkulus, lineær algebra, sannsynlighet og dimensjonsreduksjon. Bygg både teoretisk forståelse og praktisk programmeringserfaring for å styrke evnen til å analysere data, modellere komplekse systemer og anvende avanserte teknikker innen maskinlæring.

Utforsk grunnlaget for matematiske funksjoner. Lær om ulike typer algebraiske og transcendentale funksjoner, deres egenskaper, og hvordan de kan implementeres i Python for å løse reelle problemer.

Behersk konseptene mengder og rekker, fra grunnleggende operasjoner til praktiske anvendelser. Få praktisk erfaring med å implementere mengdeoperasjoner og arbeide med aritmetiske og geometriske rekker i Python.

Utvikle en solid forståelse av grenser, deriverte, integraler og partiellderiverte. Knytt teori til praksis ved å implementere disse konseptene i Python og anvende dem på optimering gjennom gradient descent.

Bygg solid kunnskap om vektorer, matriser og transformasjoner. Lær dekomponeringsmetoder og egenverdianalyse, samtidig som konseptene styrkes med Python-kodeutfordringer og praktiske anvendelser innen datavitenskap.

Fordyp deg i sannsynlighetsteori og statistikk. Studer betinget sannsynlighet, Bayes’ teorem og statistiske mål. Implementer sentrale konsepter i Python, simuler fordelinger, og styrk ferdighetene dine gjennom utfordringer og quizer.

Utfordring: Løse Et Lineært Ligningssystem Med LU-Dekomponering

Løsning