You will implement and compare **two numerical ODE solvers** for the initial value problem (IVP):

$$
\frac{dy}{dt} = f(t, y), \qquad y(t_0)=y_0
$$

You will implement:

**Euler Method**

* First-order method (less accurate).
* Can become unstable for stiff or sensitive problems.

**Runge–Kutta 4 (RK4)**

* Fourth-order method (more accurate).
* Typically more stable than Euler for the same step size.

You will solve the test ODE:

$$
\frac{dy}{dt} = y,\quad y(0)=1
$$

The analytical solution is:

$$
y(t)=e^t
$$


import unittest
import importlib
import user_code


class TestODESolverAccuracy(unittest.TestCase):

    def setUp(self):
        importlib.reload(user_code)

    def test_returns_tuple(self):
        result = user_code.solve_and_compare(h=0.1)

        _dynamic_test(
            self,
            isinstance(result, tuple) and len(result) == 2,
            "solve_and_compare returns a tuple (Euler error, RK4 error)",
            f"Expected a tuple of length 2, got: {result}",
        )

    def test_errors_are_non_negative(self):
        euler_error, rk4_error = user_code.solve_and_compare(h=0.1)

        _dynamic_test(
            self,
            euler_error >= 0 and rk4_error >= 0,
            "Both Euler and RK4 errors are non-negative",
            f"Errors must be non-negative, got Euler={euler_error}, RK4={rk4_error}",
        )

    def test_errors_decrease_with_smaller_step(self):
        euler_big, rk4_big = user_code.solve_and_compare(h=0.2)
        euler_small, rk4_small = user_code.solve_and_compare(h=0.05)

        _dynamic_test(
            self,
            euler_small < euler_big,
            "Euler error decreases when step size is reduced",
            f"Euler error did not decrease: h=0.2 → {euler_big}, h=0.05 → {euler_small}",
        )

        _dynamic_test(
            self,
            rk4_small < rk4_big,
            "RK4 error decreases when step size is reduced",
            f"RK4 error did not decrease: h=0.2 → {rk4_big}, h=0.05 → {rk4_small}",
        )

    def test_reasonable_accuracy(self):
        euler_error, rk4_error = user_code.solve_and_compare(h=0.1)

        _dynamic_test(
            self,
            euler_error < 1.0,
            "Euler method produces a reasonable approximation",
            f"Euler error too large: {euler_error}",
        )

        _dynamic_test(
            self,
            rk4_error < 1.0,
            "RK4 method produces a reasonable approximation",
            f"RK4 error too large: {rk4_error}",
        )


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)


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


test_main.py

Master the essential numerical methods for approximating mathematical problems on computers. This course blends mathematical intuition, algorithmic reasoning, and hands-on Python implementation to equip you with the tools for scientific computing.

Explore the motivations, limitations, and core concepts underlying numerical computation, including error sources and convergence.

Delve into the implementation and analysis of foundational numerical algorithms for differentiation, integration, and root-finding.

Master numerical approaches for solving ordinary differential equations and analyzing dynamic system stability.

Challenge: ODE Solver Accuracy and Stability

Lösung