Käytännön tieteellisissä ja insinööritieteiden sovelluksissa lineaaristen yhtälöryhmien ratkaiseminen on usein tarpeen todellisten ongelmien analysoimiseksi. Yksi esimerkki tästä on sähköpiirien analyysi, jossa piirin jännitteiden ja virtojen väliset suhteet voidaan kuvata Kirchhoffin lakien perusteella johdetuilla lineaarisilla yhtälöillä. SciPyn `scipy.linalg.solve`-funktio tarjoaa vankan ja tehokkaan tavan ratkaista nämä yhtälöryhmät, mahdollistaen työskentelyn todellisten tietojen ja monimutkaisten mallien kanssa.


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

Kattava kurssi, joka on suunniteltu opiskelijoille, joilla on vahva matemaattinen tausta ja keskitason tai edistyneet Python-taidot, keskittyen SciPyn hyödyntämiseen tieteellisessä laskennassa, optimoinnissa, integroinnissa ja edistyneissä matemaattisissa operaatioissa.

Tutustu SciPyn rakenteeseen, ydinkirjastoihin ja keskeisiin ominaisuuksiin tieteellisessä laskennassa.

Syvenny SciPyn tehokkaisiin lineaarialgebran ominaisuuksiin todellisten matemaattisten ongelmien ratkaisemiseksi.

Hallitse optimointitekniikat ja juurtenetsintäalgoritmit SciPy:n avulla tieteellisiin ja teknisiin ongelmiin.

Tutustu edistyneisiin matemaattisiin operaatioihin, kuten integrointiin, interpolointiin ja perussignaalinkäsittelyyn SciPy-kirjastolla.

Haaste: Lineaaristen Yhtälöryhmien Ratkaiseminen

Ratkaisu