In vielen wissenschaftlichen und technischen Anwendungen ist es häufig erforderlich, die Fläche unter einer Kurve zu berechnen, wenn keine exakte Formel für das Integral vorliegt. Dies tritt oft in realen Szenarien auf, beispielsweise bei der Bestimmung der insgesamt zurückgelegten Strecke eines Objekts, wenn dessen Geschwindigkeit zu verschiedenen Zeitpunkten bekannt ist, aber keine einfache Gleichung für den Weg existiert. Mit der numerischen Integration lässt sich diese Fläche effizient mit der Funktion `scipy.integrate.quad` von SciPy annähern.


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

class TestTask(unittest.TestCase):
    def test_total_distance_0_to_5(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.total_distance_traveled(0, 5)
        # Analytical integral: int(3t^2+2t+1) dt from 0 to 5 = [t^3 + t^2 + t] from 0 to 5 = (125+25+5)-(0) = 155
        expected = 155.0
        _dynamic_test(
            self,
            math.isclose(result, expected, rel_tol=1e-6),
            "Correct total distance for interval [0, 5]",
            f"Expected {expected}, got {result} for [0, 5]",
        )

    def test_total_distance_2_to_8(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.total_distance_traveled(2, 8)
        # int(3t^2+2t+1) dt = [t^3 + t^2 + t] from 2 to 8
        # At 8: 512 + 64 + 8 = 584
        # At 2: 8 + 4 + 2 = 14
        expected = 584 - 14
        _dynamic_test(
            self,
            math.isclose(result, expected, rel_tol=1e-6),
            "Correct total distance for interval [2, 8]",
            f"Expected {expected}, got {result} for [2, 8]",
        )

    def test_total_distance_same_limits(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.total_distance_traveled(3, 3)
        expected = 0.0
        _dynamic_test(
            self,
            math.isclose(result, expected, rel_tol=1e-12),
            "Returns zero when start_time == end_time",
            f"Expected 0.0, got {result} for [3, 3]",
        )

    def test_total_distance_reversed_limits(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.total_distance_traveled(5, 0)
        # Should be negative of [0,5] case
        expected = -155.0
        _dynamic_test(
            self,
            math.isclose(result, expected, rel_tol=1e-6),
            "Returns negative distance for reversed interval",
            f"Expected {expected}, got {result} for [5, 0]",
        )

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

Ein umfassender Kurs, der für Studierende mit fundierten Mathematikkenntnissen und fortgeschrittenen Python-Kenntnissen konzipiert ist und sich auf die Nutzung von SciPy für wissenschaftliches Rechnen, Optimierung, Integration und fortgeschrittene mathematische Operationen konzentriert.

Erkunden Sie die Struktur, Kernmodule und wesentlichen Funktionen von SciPy für wissenschaftliches Rechnen.

Tauchen Sie ein in die leistungsstarken linearen Algebra-Funktionen von SciPy zur Lösung realer mathematischer Probleme.

Beherrschung von Optimierungstechniken und Nullstellenalgorithmen mit SciPy für wissenschaftliche und technische Fragestellungen.

Erkunden Sie fortgeschrittene mathematische Operationen wie Integration, Interpolation und grundlegende Signalverarbeitung mit SciPy.

Herausforderung: Fläche Unter Einer Kurve

Lösung