Calculating resultant forces and moments is a fundamental skill for mechanical engineers. This challenge will help you automate these calculations using Python. You will use your knowledge of **vector addition** and **moments** to process a list of forces, each defined by its magnitude, direction, and point of application, and compute both the overall (`resultant`) force and the net moment about a given origin point.


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_arbitrary_forces_resultant(self):
        import user_code
        importlib.reload(user_code)
        forces = [
            (10, 0, 2, 3),   # 10N right at (2,3)
            (5, 90, 4, 1),   # 5N up at (4,1)
            (7, 180, 0, 0)   # 7N left at origin
        ]
        origin = (0, 0)
        result = user_code.resultant_force_and_moment(forces, origin)
        expected_magnitude = math.hypot(10 - 7, 5)
        expected_angle = math.degrees(math.atan2(5, 3))
        _dynamic_test(
            self,
            isinstance(result, tuple) and isinstance(result[0], tuple) and abs(result[0][0] - expected_magnitude) < 1e-6 and abs(result[0][1] - expected_angle) < 1e-6,
            "Correct resultant force magnitude and angle for arbitrary forces.",
            f"Expected resultant: ({expected_magnitude}, {expected_angle}), got {result[0]}"
        )

    def test_arbitrary_forces_moment(self):
        import user_code
        importlib.reload(user_code)
        forces = [
            (10, 0, 2, 3),   # 10N right at (2,3)
            (5, 90, 4, 1),   # 5N up at (4,1)
            (7, 180, 0, 0)   # 7N left at origin
        ]
        origin = (0, 0)
        result = user_code.resultant_force_and_moment(forces, origin)
        # Moment = x*Fy - y*Fx for each force
        m1 = 2 * 0 - 3 * 10  # (2,3), Fx=10, Fy=0
        m2 = 4 * 5 - 1 * 0   # (4,1), Fx=0, Fy=5
        m3 = 0 * 0 - 0 * (-7) # (0,0), Fx=-7, Fy=0
        expected_moment = m1 + m2 + m3
        _dynamic_test(
            self,
            abs(result[1] - expected_moment) < 1e-6,
            "Correct net moment about origin for provided forces.",
            f"Expected moment: {expected_moment}, got {result[1]}"
        )

    def test_zero_resultant_force(self):
        import user_code
        importlib.reload(user_code)
        forces = [
            (5, 0, 0, 0),
            (5, 180, 0, 0)
        ]
        origin = (0, 0)
        result = user_code.resultant_force_and_moment(forces, origin)
        _dynamic_test(
            self,
            abs(result[0][0]) < 1e-6 and abs(result[0][1]) < 1e-6,
            "Handles zero resultant force: returns (0,0) for magnitude and angle.",
            f"Expected (0,0), got {result[0]}"
        )

    def test_all_forces_at_origin(self):
        import user_code
        importlib.reload(user_code)
        forces = [
            (3, 45, 0, 0),
            (4, -45, 0, 0)
        ]
        origin = (0, 0)
        result = user_code.resultant_force_and_moment(forces, origin)
        _dynamic_test(
            self,
            abs(result[1]) < 1e-6,
            "Net moment is zero when all forces applied at origin.",
            f"Expected moment 0, got {result[1]}"
        )

    def test_negative_angles_and_positions(self):
        import user_code
        importlib.reload(user_code)
        forces = [
            (8, -90, -2, -2), # 8N down at (-2,-2)
            (6, 135, -3, 1)   # 6N up-left at (-3,1)
        ]
        origin = (0, 0)
        result = user_code.resultant_force_and_moment(forces, origin)
        # Just check the calculation is performed and values are floats
        _dynamic_test(
            self,
            isinstance(result, tuple) and isinstance(result[0], tuple) and isinstance(result[0][0], float) and isinstance(result[0][1], float) and isinstance(result[1], float),
            "Handles negative force angles and positions correctly.",
            f"Expected float values for resultant and moment, got {result}"
        )

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: Resultant Force and Moment

解答