Hands‑On: Vector Math & Simulation (Advanced)

Implement a readonly struct Vector2 with fields double X, Y, constructor, Length, Normalized(), and operators +, -, unary -, scalar *, Dot(in Vector2 a, in Vector2 b), and Deconstruct(out double x, out double y). Ensure no hidden copies and no boxing.
Implement a struct BoundingBox with fields Vector2 Min, Max (mutable is fine here). Add Contains(in Vector2 p) and Inflate(double delta).
Implement a class Particle with Vector2 Position, Vector2 Velocity. Add void Step(double dt, in BoundingBox bounds) that moves the particle and bounces on edges (invert velocity on collision).
Write a Main that creates 100 particles with random velocities inside a 100×100 box and advances them for 1,000 steps, accumulating the total distance traveled.
Pitfall demo: Add a public Vector2 this[int i] { get; set; } indexer to a Particles container that stores a List<Vector2> positions. Show that foreach (var pos in positions) then mutating pos.X++ does not change the stored element; then fix it by using indexing or for with the assignment.

Acceptance Criteria

Vector2 is readonly struct, methods that read only take parameters as in.
No allocation or boxing in the hot loop (avoid object, ArrayList, LINQ in the inner step).
The simulation runs and prints the total distance traveled and the final average speed.

Hints — Vector Math & Simulation (Guided)

General tips

Keep Vector2 a readonly struct and use in parameters where you read but don’t mutate to avoid copies.
Avoid LINQ, closures, and allocations inside the inner simulation loop. Pre‑allocate collections with capacity.
Prefer inclusive bounds (>= Min and <= Max) so particles resting on edges are considered inside.

Task 1 — Vector2

Length: Math.Sqrt(X*X + Y*Y).
Normalized(): divide by length when length > 0, otherwise return (0,0) to avoid NaN.
Operator hints (signatures):
- public static Vector2 operator +(in Vector2 a, in Vector2 b)
- public static Vector2 operator -(in Vector2 a, in Vector2 b)
- public static Vector2 operator *(in Vector2 a, double k)
Dot(in a, in b) returns a.X*b.X + a.Y*b.Y.
Deconstruct(out double x, out double y) assigns x = X; y = Y;.

Task 2 — BoundingBox

Contains(p): p.X >= Min.X && p.X <= Max.X && p.Y >= Min.Y && p.Y <= Max.Y.
Inflate(d): Min = (Min.X - d, Min.Y - d) and Max = (Max.X + d, Max.Y + d).
Consider a constructor guard to ensure Min <= Max on both axes if inputs might be unsorted.

Task 3 — Particle.Step

Integrate: next = Position + Velocity * dt.
Bounce X:
- If next.X < bounds.Min.X: set next.X = bounds.Min.X and make vx = +Math.Abs(vx).
- If next.X > bounds.Max.X: set next.X = bounds.Max.X and make vx = -Math.Abs(vx).
Bounce Y similarly with vy.
Finally assign Position = next; Velocity = (vx, vy);.
If particles occasionally “tunnel” through edges, reduce dt or iterate collision resolution per axis.

Task 4 — Simulation loop

Create particles with random positions in [0,100] and velocities as dir.Normalized() * speed.
Accumulate distance as total += p.Speed * dt each step.
Use new List<Particle>(capacity: 100) to avoid resizes; seed Random for reproducibility.

Task 5 — Mutable‑struct pitfall demo

In foreach (var pos in positions), pos is a copy (value type); changing it doesn’t modify the stored element.
Show the issue, then fix by:
- Using an indexer: var tmp = list[i]; /* mutate tmp */ list[i] = tmp;, or
- Switching to arrays/Span<T> if you need ref access; List<T> does not expose ref elements.

Testing & verification ideas

Assert Vector2.Dot(a,b) == Vector2.Dot(b,a) and that Normalized().Length is ~1 (within epsilon).
After each step, assert bounds.Contains(p.Position); if false, check bounce/clamp math.
Log a few positions/velocities at edges to verify sign inversions.

Performance checks (optional)

Ensure the hot loop allocates 0 bytes (no boxing/closures). You can spot accidental allocations by avoiding string concatenation inside loops and keeping ToString() calls out of the hot path.

0% Complete