You have explored how to apply **Kirchhoff's Voltage Law (KVL)** to basic and moderately complex circuits, and learned to set up and solve the resulting equations using Python's linear algebra tools. In this challenge, you will use these skills to analyze a two-loop circuit with three resistors and two voltage sources. Recall that **KVL** states the sum of voltage drops and rises around any closed loop is zero, allowing you to translate circuit diagrams into systems of equations. Python's `scipy.linalg` library provides efficient methods for solving such systems, making it a powerful tool for electrical circuit analysis.


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

class TestTask(unittest.TestCase):
    def test_returns_correct_currents_for_sample(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.solve_multi_loop_circuit(100, 150, 220, 10, 5)
        _dynamic_test(
            self,
            result is not None and isinstance(result, tuple) and len(result) == 2,
            "Function returns a tuple of two values for sample input.",
            f"Expected a tuple of two current values, got: {result}",
        )
        # Calculate expected currents using the same method
        A = np.array([[250, -150], [-150, 370]])
        b = np.array([10, 5])
        expected = np.linalg.solve(A, b)
        I1_exp, I2_exp = expected[0], expected[1]
        _dynamic_test(
            self,
            np.isclose(result[0], I1_exp, atol=1e-6) and np.isclose(result[1], I2_exp, atol=1e-6),
            f"Returns correct currents for (100, 150, 220, 10, 5)",
            f"Expected currents ({I1_exp}, {I2_exp}), got {result}",
        )

    def test_arbitrary_positive_values(self):
        import user_code
        importlib.reload(user_code)
        # Arbitrary positive values
        R1, R2, R3, V1, V2 = 50, 40, 60, 20, 10
        result = user_code.solve_multi_loop_circuit(R1, R2, R3, V1, V2)
        _dynamic_test(
            self,
            result is not None and isinstance(result, tuple) and len(result) == 2,
            "Function returns a tuple of two values for arbitrary positive input.",
            f"Expected a tuple of two current values, got: {result}",
        )
        # Calculate expected currents
        A = np.array([[R1+R2, -R2], [-R2, R2+R3]])
        b = np.array([V1, V2])
        expected = np.linalg.solve(A, b)
        I1_exp, I2_exp = expected[0], expected[1]
        _dynamic_test(
            self,
            np.isclose(result[0], I1_exp, atol=1e-6) and np.isclose(result[1], I2_exp, atol=1e-6),
            f"Returns correct currents for ({R1}, {R2}, {R3}, {V1}, {V2})",
            f"Expected currents ({I1_exp}, {I2_exp}), got {result}",
        )

    def test_nonzero_positive_resistors_and_voltages(self):
        import user_code
        importlib.reload(user_code)
        # All resistors and voltages are positive and nonzero
        R1, R2, R3, V1, V2 = 10, 20, 30, 40, 50
        result = user_code.solve_multi_loop_circuit(R1, R2, R3, V1, V2)
        _dynamic_test(
            self,
            result is not None and isinstance(result, tuple) and len(result) == 2,
            "Function returns a tuple of two values for all positive nonzero values.",
            f"Expected a tuple of two current values, got: {result}",
        )
        # Calculate expected currents
        A = np.array([[R1+R2, -R2], [-R2, R2+R3]])
        b = np.array([V1, V2])
        expected = np.linalg.solve(A, b)
        I1_exp, I2_exp = expected[0], expected[1]
        _dynamic_test(
            self,
            np.isclose(result[0], I1_exp, atol=1e-6) and np.isclose(result[1], I2_exp, atol=1e-6),
            f"Returns correct currents for ({R1}, {R2}, {R3}, {V1}, {V2})",
            f"Expected currents ({I1_exp}, {I2_exp}), 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()
    changed = False
    # Collect all assignment nodes to modify
    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 nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    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 '\\n'.join(lines) if changed else code

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


test_main.py

Explore how Python empowers electrical engineers to analyze circuits, process signals, and model systems. This course blends practical coding with real-world electrical engineering scenarios, using Python and its scientific libraries to solve authentic engineering problems.

Learn how Python can be used to analyze electrical circuits, calculate parameters, and visualize circuit behavior.

Discover how Python can be used to analyze, visualize, and process electrical signals relevant to engineering applications.

Use Python to model, simulate, and visualize electrical systems and their dynamic behavior.

Challenge: Multi-Loop Circuit Solver

Solution