
import unittest
import user_code
import ast
import re   
import unittest
import importlib
import numpy as np

class TestTask(unittest.TestCase):
    def test_returns_true_for_all_negative_real_parts(self):
        import user_code
        importlib.reload(user_code)
        # Stable system: eigenvalues -1, -2
        A = np.array([[-1, 0], [0, -2]])
        result = user_code.is_system_stable(A)
        _dynamic_test(
            self,
            result == True,
            "Returns True for matrix with eigenvalues -1, -2 (all negative real parts)",
            f"Expected True for stable system, got {result}",
        )

    def test_returns_false_for_non_negative_real_part(self):
        import user_code
        importlib.reload(user_code)
        # Unstable system: eigenvalues 1, -2
        B = np.array([[1, 0], [0, -2]])
        result = user_code.is_system_stable(B)
        _dynamic_test(
            self,
            result == False,
            "Returns False for matrix with eigenvalues 1, -2 (one non-negative real part)",
            f"Expected False for unstable system, got {result}",
        )

    def test_handles_complex_eigenvalues(self):
        import user_code
        importlib.reload(user_code)
        # Eigenvalues: -1+2j, -1-2j (real part -1)
        C = np.array([[-1, -2], [2, -1]])
        result = user_code.is_system_stable(C)
        _dynamic_test(
            self,
            result == True,
            "Returns True for matrix with complex eigenvalues with negative real parts",
            f"Expected True for stable system with complex eigenvalues, got {result}",
        )

    def test_handles_larger_matrix(self):
        import user_code
        importlib.reload(user_code)
        # 3x3 matrix, eigenvalues -1, -2, -3
        D = np.diag([-1, -2, -3])
        result = user_code.is_system_stable(D)
        _dynamic_test(
            self,
            result == True,
            "Returns True for 3x3 matrix with all negative real eigenvalues",
            f"Expected True for stable 3x3 system, got {result}",
        )

    def test_returns_false_for_zero_real_part(self):
        import user_code
        importlib.reload(user_code)
        # Eigenvalues: 0, -1
        E = np.array([[0, 0], [0, -1]])
        result = user_code.is_system_stable(E)
        _dynamic_test(
            self,
            result == False,
            "Returns False for matrix with eigenvalue 0 (real part not negative)",
            f"Expected False for system with eigenvalue 0, got {result}",
        )

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()
    for i, node in enumerate(tree.body):
        if isinstance(node, ast.Assign):
            for target in node.targets:
                if isinstance(target, ast.Name) and target.id == var_name:
                    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] = []
                    
                    return '\\n'.join(lines)
    return code

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


test_main.py

Een uitgebreide cursus ontworpen voor studenten met een sterke wiskundige achtergrond en gemiddelde tot gevorderde Python-vaardigheden, gericht op het benutten van SciPy voor wetenschappelijk rekenen, optimalisatie, integratie en geavanceerde wiskundige bewerkingen.

Verken de structuur, kernmodules en essentiële functies van SciPy voor wetenschappelijk rekenen.

Duik in de krachtige lineaire algebra mogelijkheden van SciPy voor het oplossen van wiskundige problemen uit de praktijk.

Beheers optimalisatietechnieken en algoritmen voor het vinden van nulpunten met behulp van SciPy voor wetenschappelijke en technische vraagstukken.

Verken geavanceerde wiskundige bewerkingen, waaronder integratie, interpolatie en basis signaalverwerking met SciPy.

Challenge: Toepassingen van Eigenwaarden

Oplossing