In practical scientific and engineering contexts, you often need to solve systems of linear equations to analyze real-world problems. One such scenario is electrical circuit analysis, where the relationships between voltages and currents in a circuit can be described using linear equations derived from Kirchhoff's laws. SciPy's `scipy.linalg.solve` function provides a robust and efficient way to find solutions to these systems, allowing you to work with real data and complex models.


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

class TestTask(unittest.TestCase):
    def test_sample_solution(self):
        import user_code
        importlib.reload(user_code)
        a = np.array([[10, 2], [3, 8]])
        b = np.array([14, 19])
        result = user_code.analyze_circuit(a, b)
        expected = np.linalg.solve(a, b)
        _dynamic_test(
            self,
            isinstance(result, np.ndarray) and np.allclose(result, expected),
            "Returns correct solution for sample input.",
            f"Expected {expected}, got {result}.",
        )

    def test_other_unique_solution(self):
        import user_code
        importlib.reload(user_code)
        a = np.array([[4, 1], [2, 3]])
        b = np.array([9, 13])
        result = user_code.analyze_circuit(a, b)
        expected = np.linalg.solve(a, b)
        _dynamic_test(
            self,
            isinstance(result, np.ndarray) and np.allclose(result, expected),
            "Returns correct solution for another 2x2 system.",
            f"Expected {expected}, got {result}.",
        )

    def test_zero_rhs(self):
        import user_code
        importlib.reload(user_code)
        a = np.array([[5, -1], [2, 3]])
        b = np.zeros(2)
        result = user_code.analyze_circuit(a, b)
        expected = np.linalg.solve(a, b)
        _dynamic_test(
            self,
            isinstance(result, np.ndarray) and np.allclose(result, expected),
            "Returns correct solution when b contains zeros.",
            f"Expected {expected}, got {result}.",
        )

    def test_shape_and_type(self):
        import user_code
        importlib.reload(user_code)
        a = np.array([[1, 2], [3, 4]])
        b = np.array([5, 6])
        result = user_code.analyze_circuit(a, b)
        _dynamic_test(
            self,
            isinstance(result, np.ndarray) and result.shape == (2,),
            "Returns NumPy array of correct shape.",
            f"Result shape/type incorrect: {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

A comprehensive course designed for students with strong math backgrounds and intermediate to advanced Python skills, focusing on leveraging SciPy for scientific computing, optimization, integration, and advanced mathematical operations.

Explore the structure, core modules, and essential features of SciPy for scientific computing.

Dive into SciPy's powerful linear algebra capabilities for solving real-world mathematical problems.

Master optimization techniques and root-finding algorithms using SciPy for scientific and engineering problems.

Explore advanced mathematical operations including integration, interpolation, and basic signal processing with SciPy.

Challenge: Solving Linear Systems

Soluzione