Summary  
This chapter explains how to represent and solve systems of linear equations in code using algebraic elimination and symbolic computation.  

General domain of usage  
Engineering

**Video: Introduction to Solving Linear Systems**

This video introduces the concept of solving linear systems, highlighting both graphical and algebraic approaches. You will see how systems of equations can be represented visually as lines on a plane and how their intersection points correspond to solutions. The video also discusses why solving such systems is fundamental in mathematics and real-world applications.

Solving a linear system means finding values for the unknowns that satisfy all equations in the system at once. For a system of two equations with two variables, each equation represents a line on a two-dimensional plane. Graphically, solving the system means finding the point where these two lines intersect. If the lines cross at a single point, there is one unique solution. If the lines are parallel and never meet, there is no solution. If the lines coincide (are the same line), there are infinitely many solutions.

Algebraically, a linear system can be written as:
$$
a_1 x + b_1 y = c_1\\
a_2 x + b_2 y = c_2
$$

where $$a_1$$, $$b_1$$, $$c_1$$, $$a_2$$, $$b_2$$, and $$c_2$$ are known numbers, and $$x$$ and $$y$$ are the unknowns to solve for. The goal is to find the values of $$x$$ and $$y$$ that make both equations true at the same time.

from sympy import symbols, Eq, solve

# Define symbolic variables
x, y = symbols('x y')

# Set up the equations
eq1 = Eq(2*x + 3*y, 13)
eq2 = Eq(3*x - 2*y, 4)

solution = solve((eq1, eq2), (x, y))

# Print the solution
print("x =", solution[x])
print("y =", solution[y])

The SymPy approach solves the system of equations using symbolic computation. First, you define symbolic variables `x` and `y` to represent the unknowns. Next, you set up the two equations using these variables. By calling `sympy.solve` with the list of equations and the variables to solve for, SymPy computes the exact, symbolic solution for both `x` and `y`. This method is more concise than manual algebra, and it leverages SymPy's symbolic engine to find exact solutions without rounding errors, making it especially powerful for complex or general systems.

import unittest
import sympy as sp
import ast
import re   
import io
import sys

class TestTask(unittest.TestCase):
    def test_unique_solution(self):
        # 2x + 3y = 13, 3x - 2y = 4
        # expected: x = 38/13, y = 31/13
        code = self._get_injected_code(2, 3, 13, 3, -2, 4)
        ns = {'sp': sp}
        exec(code, ns)
        
        solution = ns.get('solution')
        x, y = sp.symbols('x y')
        
        expected_x = 38/13
        expected_y = 31/13
        
        is_correct = False
        if isinstance(solution, dict) and x in solution and y in solution:
            is_correct = abs(float(solution[x]) - expected_x) < 1e-7 and abs(float(solution[y]) - expected_y) < 1e-7

        _dynamic_test(
            self,
            is_correct,
            "Correct solution returned for unique system (2x+3y=13, 3x-2y=4)",
            f"Expected x ≈ {expected_x:.3f}, y ≈ {expected_y:.3f}. Got {solution}",
        )

    def test_unique_solution_fractional(self):
        # 1x + 2y = 5, 3x + 4y = 11
        # expected: x = 1.0, y = 2.0
        code = self._get_injected_code(1, 2, 5, 3, 4, 11)
        ns = {'sp': sp}
        exec(code, ns)
        
        solution = ns.get('solution')
        x, y = sp.symbols('x y')
        
        expected_x = 1.0
        expected_y = 2.0
        
        is_correct = False
        if isinstance(solution, dict) and x in solution and y in solution:
            is_correct = abs(float(solution[x]) - expected_x) < 1e-7 and abs(float(solution[y]) - expected_y) < 1e-7

        _dynamic_test(
            self,
            is_correct,
            "Correct solution returned for unique system (1x+2y=5, 3x+4y=11)",
            f"Expected x = 1.0, y = 2.0. Got {solution}",
        )

    def test_negative_coefficients(self):
        # -x + y = 1, 2x - 3y = -4
        # expected: x = 1.0, y = 2.0
        code = self._get_injected_code(-1, 1, 1, 2, -3, -4)
        ns = {'sp': sp}
        exec(code, ns)
        
        solution = ns.get('solution')
        x, y = sp.symbols('x y')
        
        expected_x = 1.0
        expected_y = 2.0
        
        is_correct = False
        if isinstance(solution, dict) and x in solution and y in solution:
            is_correct = abs(float(solution[x]) - expected_x) < 1e-7 and abs(float(solution[y]) - expected_y) < 1e-7

        _dynamic_test(
            self,
            is_correct,
            "Handles negative coefficients correctly",
            f"Expected x = 1.0, y = 2.0. Got {solution}",
        )

    def test_printed_output(self):
        code = self._get_injected_code(1, 2, 5, 3, 4, 11)
        ns = {'sp': sp}
        
        f = io.StringIO()
        sys_stdout = sys.stdout
        sys.stdout = f
        try:
            exec(code, ns)
        finally:
            sys.stdout = sys_stdout
            
        output = f.getvalue()
        
        # Depending on how SymPy prints, it should contain 1 and 2
        found = '1' in output and '2' in output
        
        _dynamic_test(
            self,
            found,
            "The solution is printed successfully.",
            "The solution was not printed properly. Make sure to use print(solution).",
        )

    def _get_injected_code(self, a1, b1, c1, a2, b2, c2):
        with open('user_code.py', 'r') as f:
            code = f.read()
        
        nl = chr(10)
        vars_list = [f"a1={a1}", f"b1={b1}", f"c1={c1}", f"a2={a2}", f"b2={b2}", f"c2={c2}"]
        vars_setup = nl.join(vars_list) + nl
        
        return vars_setup + code

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\s{2,}", " ", text)
    text = re.sub(r"\s*([,:?])\s*", r"\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]
    if not assign_nodes:
        return code
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True
        
    return chr(10).join(lines) if changed else code

if __name__ == "__main__":
    unittest.main()

test_main.py

Establish core mathematical intuition for data science by manipulating vectors, multiplying matrices, solving linear systems, and computing eigenvalues for dimensionality reduction, all utilizing Python.

All core linear algebra concepts for data science in one section, with each chapter building on the previous to develop a strong mathematical foundation using Python.

Solving Linear Systems

Løsning