In many scientific and engineering applications, you often need to calculate the area under a curve when an exact formula for the integral is not available. This is common in real-world scenarios, such as determining the total distance traveled by an object when you know its velocity at different times but do not have a simple equation for the path. You can use numerical integration to approximate this area efficiently with SciPy's `scipy.integrate.quad` function.


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

A comprehensive course designed for students with strong math backgrounds and intermediate to advanced Python skills, focusing on leveraging SciPy for scientific computing, optimization, integration, and advanced mathematical operations.

Explore the structure, core modules, and essential features of SciPy for scientific computing.

Dive into SciPy's powerful linear algebra capabilities for solving real-world mathematical problems.

Master optimization techniques and root-finding algorithms using SciPy for scientific and engineering problems.

Explore advanced mathematical operations including integration, interpolation, and basic signal processing with SciPy.

Challenge: Area Under a Curve

Solução

Awesome!

Challenge: Area Under a Curve

Solução