A student is given a small system of linear equations representing the balance of flows in a simple network.  

The system is expressed as:

$$
A \vec{x} = \vec{b}
$$

Where:

- $$A$$ is a $$3×3$$ matrix;  
- $$\vec{b}$$ is the vector of known quantities.  

The student's goal is to solve for $$\vec{x}$$ by performing LU decomposition on matrix $$A$$, then using forward and backward substitution to find the solution.  

Compare your solution with `numpy`'s built-in solver to verify correctness.  

```python


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

Master the mathematical foundations essential for data science. Explore core concepts in functions, calculus, linear algebra, probability, and dimensionality reduction. Build both theoretical understanding and practical coding experience to strengthen your ability to analyze data, model complex systems, and apply advanced techniques in machine learning.

Explore the foundation of mathematical functions. Learn different types of algebraic and transcendental functions, their properties, and how to implement them in Python to solve real-world problems.

Master the concepts of sets and series, from basic operations to practical applications. Gain hands-on experience implementing set operations and working with arithmetic and geometric series in Python.

Develop a solid understanding of limits, derivatives, integrals, and partial derivatives. Connect theory to practice by implementing these concepts in Python and applying them to optimization through gradient descent.

Build strong knowledge of vectors, matrices, and transformations. Learn decomposition methods and eigenvalue analysis, while reinforcing concepts with Python coding challenges and practical data science applications.

Dive into probability theory and statistics. Study conditional probability, Bayes' theorem, and statistical measures. Implement key concepts in Python, simulate distributions, and strengthen your skills through challenges and quizzes.

Challenge: Solving a Linear System with LU Decomposition

Lösung

Awesome!

Challenge: Solving a Linear System with LU Decomposition

Lösung

Awesome!