Implementing Loop Invariant Motion for Particle Simulation in Go

This challenge focuses on implementing a fundamental concept in physics simulations: loop invariant motion. You will develop a Go program that simulates the movement of a particle within a defined boundary, ensuring that the particle consistently stays within these bounds throughout its motion. This is crucial for creating stable and predictable simulations in various applications, from games to scientific modeling.

Problem Description

Your task is to create a Go function that simulates the motion of a particle. The particle has a position (x, y) and a velocity (vx, vy). The simulation should take a number of steps, and in each step, the particle's position should be updated based on its velocity. Crucially, you must ensure that the particle's position always remains within a specified rectangular boundary. If a particle's movement would cause it to go beyond the boundary, its velocity should be adjusted to reflect a "bounce" off the boundary, keeping the particle inside.

Key Requirements:

1. Particle Structure: Define a struct to represent a particle with fields for X, Y (position), and VX, VY (velocity).
2. Boundary Definition: Define a rectangular boundary with MinX, MaxX, MinY, MaxY fields.
3. Simulation Function: Create a function that takes a particle, a boundary, and the number of simulation steps as input.
4. Motion Update: In each step, update the particle's X and Y position by adding VX and VY respectively.
5. Boundary Reflection (Loop Invariant): Implement logic to detect when the particle is about to cross or has crossed a boundary. When a boundary is hit:
   • If X goes beyond MaxX, set X = MaxX and reverse VX (make VX = -VX).
   • If X goes below MinX, set X = MinX and reverse VX (make VX = -VX).
   • If Y goes beyond MaxY, set Y = MaxY and reverse VY (make VY = -VY).
   • If Y goes below MinY, set Y = MinY and reverse VY (make VY = -VY).
   • Important: Handle the case where the particle might be exactly on the boundary and its velocity would push it outwards. The reflection logic should correctly handle this.
6. Return Value: The simulation function should return the final state of the particle after all steps.

Expected Behavior:

The particle should move according to its velocity. When it encounters a boundary, it should appear to "bounce" off it, changing its velocity component perpendicular to that boundary and staying within the bounds.

Edge Cases to Consider:

• Particle starting exactly on a boundary: The logic should prevent it from immediately leaving the boundary.
• Particle starting outside the boundary: The initial step should correctly correct its position and velocity.
• Zero velocity: The particle should remain stationary.
• Very large velocities: Ensure the reflection logic works correctly even with large velocity values.
• Simultaneous boundary hits: If a particle hits a corner, both X and Y velocity components should be reversed.

Examples

Example 1:

Input:
Particle: {X: 5.0, Y: 5.0, VX: 2.0, VY: 1.0}
Boundary: {MinX: 0.0, MaxX: 10.0, MinY: 0.0, MaxY: 10.0}
Steps: 3

Output:
Particle: {X: 10.0, Y: 8.0, VX: -2.0, VY: 1.0}

Explanation:
Step 1:
- Pos: {X: 7.0, Y: 6.0}
- Vel: {VX: 2.0, VY: 1.0} (No boundary hit)

Step 2:
- Pos: {X: 9.0, Y: 7.0}
- Vel: {VX: 2.0, VY: 1.0} (No boundary hit)

Step 3:
- Pos: {X: 11.0, Y: 8.0}
- Vel: {VX: 2.0, VY: 1.0}
- Boundary Hit: X is beyond MaxX (10.0).
- Correction: X becomes 10.0, VX becomes -2.0.
- Final Pos: {X: 10.0, Y: 8.0}
- Final Vel: {VX: -2.0, VY: 1.0}

Example 2:

Input:
Particle: {X: 1.0, Y: 9.0, VX: -0.5, VY: 0.5}
Boundary: {MinX: 0.0, MaxX: 5.0, MinY: 0.0, MaxY: 10.0}
Steps: 4

Output:
Particle: {X: 0.0, Y: 10.0, VX: 0.5, VY: -0.5}

Explanation:
Step 1:
- Pos: {X: 0.5, Y: 9.5}
- Vel: {VX: -0.5, VY: 0.5}

Step 2:
- Pos: {X: 0.0, Y: 10.0}
- Vel: {VX: -0.5, VY: 0.5}
- Boundary Hit: X hits MinX (0.0), Y hits MaxY (10.0).
- Correction: X becomes 0.0, VX becomes 0.5. Y becomes 10.0, VY becomes -0.5.
- Final Pos: {X: 0.0, Y: 10.0}
- Final Vel: {VX: 0.5, VY: -0.5}

Step 3:
- Pos: {X: 0.5, Y: 9.5}
- Vel: {VX: 0.5, VY: -0.5}

Step 4:
- Pos: {X: 1.0, Y: 9.0}
- Vel: {VX: 0.5, VY: -0.5}

Example 3: Particle starting outside boundary

Input:
Particle: {X: 12.0, Y: 5.0, VX: -3.0, VY: 0.0}
Boundary: {MinX: 0.0, MaxX: 10.0, MinY: 0.0, MaxY: 10.0}
Steps: 1

Output:
Particle: {X: 10.0, Y: 5.0, VX: 3.0, VY: 0.0}

Explanation:
Step 1:
- Initial Pos: {X: 12.0, Y: 5.0}
- Initial Vel: {VX: -3.0, VY: 0.0}
- Proposed Pos: {X: 9.0, Y: 5.0} (after applying velocity without boundary check)
- Boundary Hit: X (12.0) was beyond MaxX (10.0).
- Correction: The logic should first correct the position to be *at* the boundary if it's outside. Then, apply velocity.
    - If the initial position is outside, a common approach is to first correct it to the boundary. So, 12.0 becomes 10.0.
    - Then, the velocity is applied. However, the problem description implies that velocity update *happens* first, and then boundary checks. Let's follow that:
    - Proposed Pos: {X: 12.0 - 3.0 = 9.0, Y: 5.0}  <- This interpretation would be wrong if we assume velocity is applied first.
    - Let's re-evaluate based on "if a particle's movement would cause it to go beyond". This implies we calculate the *next* position, then check boundaries.

    Revised Explanation for Example 3:
    Step 1 (Initial check/correction if outside):
    - Particle starts at X: 12.0, which is > MaxX (10.0).
    - Correction: Set X to MaxX (10.0) and reverse VX.
    - Particle state after initial correction: {X: 10.0, Y: 5.0, VX: 3.0, VY: 0.0}
    - Now, apply the simulation step with the corrected particle state:
        - Update Pos: X = 10.0 + 3.0 = 13.0, Y = 5.0 + 0.0 = 5.0
        - Proposed Pos: {X: 13.0, Y: 5.0}
        - Boundary Hit: X (13.0) is beyond MaxX (10.0).
        - Correction: X becomes 10.0, VX becomes -3.0.
        - Final Pos: {X: 10.0, Y: 5.0}
        - Final Vel: {VX: -3.0, VY: 0.0}

    *Self-correction*: The prompt states "if a particle's movement would cause it to go beyond the boundary, its velocity should be adjusted". This implies a check *after* the position update. For Example 3, if the particle *starts* outside, it's a special case that needs handling *before* the main loop or as the very first action in the first step. A robust simulation would first clamp the position to the boundary if it's outside, then proceed with motion.

    Let's refine Example 3 explanation to reflect a common robust approach:
    Step 1:
    - Initial Particle: {X: 12.0, Y: 5.0, VX: -3.0, VY: 0.0}
    - Boundary: {MinX: 0.0, MaxX: 10.0, MinY: 0.0, MaxY: 10.0}
    - Check initial position: X (12.0) is greater than MaxX (10.0).
    - Action: Clamp X to MaxX (10.0) and reverse VX.
    - Particle state *before* motion update for step 1: {X: 10.0, Y: 5.0, VX: 3.0, VY: 0.0}
    - Now, perform the motion update for step 1:
        - New X = 10.0 + 3.0 = 13.0
        - New Y = 5.0 + 0.0 = 5.0
    - Check new position against boundaries:
        - X (13.0) is beyond MaxX (10.0).
        - Action: Set X to MaxX (10.0) and reverse VX.
        - Final Particle state for step 1: {X: 10.0, Y: 5.0, VX: -3.0, VY: 0.0}
    - Since only 1 step is requested, this is the final output.
    - **Output:** Particle: {X: 10.0, Y: 5.0, VX: -3.0, VY: 0.0}

Constraints

• Particle position (X, Y) and velocity (VX, VY) will be float64.
• Boundary limits (MinX, MaxX, MinY, MaxY) will be float64.
• The number of simulation steps will be an int.
• All boundary limits will be valid: MinX < MaxX and MinY < MaxY.
• The simulation function should be reasonably efficient for up to 1,000,000 steps.

Notes

• The core idea here is to maintain the loop invariant: "The particle's position is always within the defined boundary."
• Be careful with floating-point comparisons. For this problem, direct comparisons (>, <, <=, >=) should suffice, but in more complex simulations, epsilon-based comparisons might be necessary.
• Consider the order of operations: update position, then check and correct for boundaries.
• Think about how to handle a particle that might be exactly on a boundary when a step begins. Your reflection logic should ensure it doesn't "escape" in that single step.
• A common approach for reflections is to check for boundary crossings after updating the position. If a crossing occurs, then adjust the position to be exactly on the boundary and reverse the relevant velocity component.
• For the initial state where a particle might be outside the boundary, you can either:
  1. Clamp its position to the boundary and reverse its velocity before the first simulation step.
  2. Handle this within the first step's boundary checks. The latter is generally more consistent with the loop invariant principle.