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

Domine os fundamentos matemáticos essenciais para ciência de dados. Explore conceitos centrais em funções, cálculo, álgebra linear, probabilidade e redução de dimensionalidade. Desenvolva tanto o entendimento teórico quanto a experiência prática em programação para aprimorar sua capacidade de analisar dados, modelar sistemas complexos e aplicar técnicas avançadas em aprendizado de máquina.

Explore os fundamentos das funções matemáticas. Conheça diferentes tipos de funções algébricas e transcendentais, suas propriedades e como implementá-las em Python para resolver problemas do mundo real.

Domine os conceitos de conjuntos e séries, desde operações básicas até aplicações práticas. Adquira experiência prática implementando operações com conjuntos e trabalhando com séries aritméticas e geométricas em Python.

Desenvolva uma compreensão sólida de limites, derivadas, integrais e derivadas parciais. Conecte a teoria à prática implementando esses conceitos em Python e aplicando-os à otimização por meio do gradiente descendente.

Construa conhecimento sólido sobre vetores, matrizes e transformações. Aprenda métodos de decomposição e análise de autovalores, reforçando os conceitos com desafios de programação em Python e aplicações práticas em ciência de dados.

Explore teoria da probabilidade e estatística. Estude probabilidade condicional, teorema de Bayes e medidas estatísticas. Implemente conceitos fundamentais em Python, simule distribuições e aprimore suas habilidades por meio de desafios e questionários.

Desafio: Resolução de um Sistema Linear com Decomposição LU

Solução

Awesome!

Desafio: Resolução de um Sistema Linear com Decomposição LU

Solução