Inom många vetenskapliga och tekniska tillämpningar stöter du ofta på icke-linjära ekvationer som inte kan lösas analytiskt och kräver numeriska metoder. Modulen `scipy.optimize` erbjuder kraftfulla algoritmer för att hitta rötterna till sådana ekvationer, vilket möjliggör modellering och analys av verkliga system. I denna utmaning kommer du att tillämpa dina kunskaper om rotlösning genom att lösa en icke-linjär ekvation som representerar en fysisk process med hjälp av `scipy.optimize.root`.


import unittest
import user_code
import ast
import re   
import unittest
import importlib
import math
import re

class TestTask(unittest.TestCase):
    def test_solution_is_float(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'solve_nonlinear_equation', None)
        _dynamic_test(
            self,
            callable(func),
            "solve_nonlinear_equation is defined and callable",
            "solve_nonlinear_equation function is missing or not callable"
        )
        result = func()
        _dynamic_test(
            self,
            isinstance(result, float),
            "Returned value is a float",
            f"Returned value is not a float: {result}"
        )

    def test_equation_is_solved(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'solve_nonlinear_equation', None)
        eq_func = getattr(user_code, 'physical_process_equation', None)
        _dynamic_test(
            self,
            callable(func) and callable(eq_func),
            "Functions are callable",
            "solve_nonlinear_equation or physical_process_equation is missing or not callable"
        )
        root_val = func()
        val = eq_func(root_val)
        _dynamic_test(
            self,
            abs(val) < 1e-6,
            f"Root value {root_val} satisfies the equation (f(x) ≈ 0)",
            f"Root value {root_val} does not satisfy the equation: f(x) = {val}"
        )

    def test_initial_guess_used(self):
        code = ""
        with open("user_code.py", "r") as f:
            code = f.read()
        # Remove all whitespace for robust matching
        code_no_ws = re.sub(r"\s+", "", code)
        found = ("root(physical_process_equation,2.0" in code_no_ws)
        _dynamic_test(
            self,
            found,
            "Initial guess 2.0 is used in root-finding",
            "Expected initial guess of 2.0 in root-finding call"
        )

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

En omfattande kurs utformad för studenter med starka matematiska kunskaper och medelgoda till avancerade Python-färdigheter, med fokus på att använda SciPy för vetenskapliga beräkningar, optimering, integration och avancerade matematiska operationer.

Utforska strukturen, kärnmodulerna och de grundläggande funktionerna i SciPy för vetenskapliga beräkningar.

Fördjupa dig i SciPys kraftfulla linjäralgebrafunktioner för att lösa verkliga matematiska problem.

Behärska optimeringstekniker och rotfinningsalgoritmer med hjälp av SciPy för vetenskapliga och tekniska problem.

Utforska avancerade matematiska operationer inklusive integration, interpolation och grundläggande signalbehandling med SciPy.

Challenge: Solving Nonlinear Equations

Lösning