Simulating projectile motion is a classic dynamics problem. Automating this with Python helps visualize and analyze trajectories. By modeling a projectile launched at an angle with a given initial velocity, you can predict its path using fundamental physics equations. This approach is valuable for understanding motion, optimizing launch parameters, and visualizing results for engineering applications.


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

class TestTask(unittest.TestCase):
    def test_return_type_and_length(self):
        import user_code
        importlib.reload(user_code)
        x, y = user_code.simulate_projectile_motion(10, 30, 0.1)
        _dynamic_test(self,
            isinstance(x, list) and isinstance(y, list) and len(x) == len(y),
            "Returned two lists of equal length.",
            f"Expected two lists of equal length, got: {type(x)}, {type(y)}, lengths: {len(x)}, {len(y)}"
        )

    def test_initial_position(self):
        import user_code
        importlib.reload(user_code)
        x, y = user_code.simulate_projectile_motion(25, 60, 0.05)
        _dynamic_test(self,
            len(x) > 0 and len(y) > 0 and abs(x[0]) < 1e-8 and abs(y[0]) < 1e-8,
            "First position is at (0, 0)",
            f"Expected first position (0,0), got ({x[0]}, {y[0]})"
        )

    def test_last_y_nonnegative_and_next_negative(self):
        import user_code
        importlib.reload(user_code)
        x, y = user_code.simulate_projectile_motion(15, 45, 0.1)
        g = 9.81
        angle_rad = math.radians(45)
        v0 = 15
        dt = 0.1
        n = len(y)
        t_last = (n-1)*dt
        vy = v0 * math.sin(angle_rad)
        y_last = y[-1]
        y_next = vy * (t_last + dt) - 0.5 * g * (t_last + dt)**2
        _dynamic_test(self,
            y_last >= 0 and y_next < 0,
            "Last y is nonnegative, next y would be negative.",
            f"Last y: {y_last}, next y: {y_next}"
        )

    def test_equations_of_motion(self):
        import user_code
        importlib.reload(user_code)
        v0 = 20
        angle_deg = 45
        dt = 0.2
        x, y = user_code.simulate_projectile_motion(v0, angle_deg, dt)
        angle_rad = math.radians(angle_deg)
        vx = v0 * math.cos(angle_rad)
        vy = v0 * math.sin(angle_rad)
        g = 9.81
        for i in range(len(x)):
            t = i * dt
            expected_x = vx * t
            expected_y = vy * t - 0.5 * g * t ** 2
            _dynamic_test(self,
                abs(x[i] - expected_x) < 1e-6 and abs(y[i] - expected_y) < 1e-6,
                f"At step {i}, x and y match equations.",
                f"At step {i}, expected ({expected_x}, {expected_y}), got ({x[i]}, {y[i]})"
            )

    def test_various_angles_and_velocities(self):
        import user_code
        importlib.reload(user_code)
        params = [
            (10, 10, 0.05),
            (50, 80, 0.2),
            (30, 60, 0.1),
            (15, 45, 0.01)
        ]
        for v0, angle, dt in params:
            x, y = user_code.simulate_projectile_motion(v0, angle, dt)
            _dynamic_test(self,
                len(x) > 1 and len(x) == len(y),
                f"Function works for v0={v0}, angle={angle}, dt={dt}",
                f"Failed for v0={v0}, angle={angle}, dt={dt}"
            )

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()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        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] = []
        changed = True

    return '\\n'.join(lines) if changed else code

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


test_main.py

Explore how Python empowers mechanical engineers to solve real-world engineering problems, automate calculations, analyze data, and visualize results. This course blends mechanical engineering concepts with practical Python programming, focusing on applications such as statics, dynamics, thermodynamics, and data analysis.

Learn to use Python for solving statics problems, automating engineering calculations, and visualizing forces and moments.

Apply Python to model, simulate, and analyze dynamic mechanical systems, including motion, vibration, and system response.

Use Python to analyze thermodynamic processes, automate calculations, and visualize engineering data.

Challenge: Simulate Projectile Motion

Solution