Dans de nombreuses applications scientifiques et d'ingénierie, il est souvent nécessaire de calculer l'aire sous une courbe lorsqu'aucune formule exacte pour l'intégrale n'est disponible. Cette situation est fréquente dans des scénarios réels, comme la détermination de la distance totale parcourue par un objet lorsque sa vitesse est connue à différents moments, sans disposer d'une équation simple pour la trajectoire. L'intégration numérique permet d'approximer efficacement cette aire à l'aide de la fonction `scipy.integrate.quad` de SciPy.


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

Un cours complet conçu pour les étudiants ayant de solides bases en mathématiques et des compétences intermédiaires à avancées en Python, axé sur l'utilisation de SciPy pour le calcul scientifique, l'optimisation, l'intégration et les opérations mathématiques avancées.

Découvrez la structure, les modules principaux et les fonctionnalités essentielles de SciPy pour le calcul scientifique.

Plongez dans les puissantes capacités d'algèbre linéaire de SciPy pour résoudre des problèmes mathématiques concrets.

Maîtriser les techniques d'optimisation et les algorithmes de recherche de racines avec SciPy pour des problèmes scientifiques et d'ingénierie.

Explorez des opérations mathématiques avancées, y compris l'intégration, l'interpolation et le traitement du signal de base avec SciPy.

Défi : Aire sous une Courbe

Solution