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

Hallitse data-analytiikan kannalta olennaiset matemaattiset perusteet. Syvenny funktioiden, analyysin, lineaarialgebran, todennäköisyyden ja ulottuvuuden vähentämisen ydinkäsitteisiin. Rakenna sekä teoreettista ymmärrystä että käytännön ohjelmointitaitoja vahvistaaksesi kykyäsi analysoida dataa, mallintaa monimutkaisia järjestelmiä ja soveltaa edistyneitä koneoppimismenetelmiä.

Tutustu matemaattisten funktioiden perusteisiin. Opiskele erilaisia algebrallisia ja transsendenttisia funktioita, niiden ominaisuuksia sekä niiden toteuttamista Pythonilla reaalimaailman ongelmien ratkaisemiseksi.

Hallitse joukkojen ja sarjojen käsitteet perusoperaatioista käytännön sovelluksiin. Saat käytännön kokemusta joukko-operaatioiden toteuttamisesta sekä aritmeettisten ja geometristen sarjojen käsittelystä Pythonilla.

Perusteellinen ymmärrys rajoista, derivaatasta, integraaleista ja osittaisderivaatasta. Teorian ja käytännön yhdistäminen toteuttamalla nämä käsitteet Pythonilla ja soveltamalla niitä optimointiin gradienttimenetelmän avulla.

Vahvista osaamista vektoreista, matriiseista ja muunnoksista. Opiskele hajotelmamenetelmiä ja ominaisarvoanalyysiä, ja syvennä käsitteitä Python-ohjelmointitehtävien sekä käytännön data-analytiikkasovellusten avulla.

Syvenny todennäköisyysteoriaan ja tilastotieteeseen. Tarkastele ehdollista todennäköisyyttä, Bayesin kaavaa ja tilastollisia tunnuslukuja. Toteuta keskeisiä käsitteitä Pythonilla, simuloi jakaumia ja vahvista osaamistasi haasteiden ja tietovisojen avulla.

Haaste: Lineaarisen Yhtälöryhmän Ratkaiseminen LU-hajotelmalla

Ratkaisu

Awesome!

Haaste: Lineaarisen Yhtälöryhmän Ratkaiseminen LU-hajotelmalla

Ratkaisu