@flighthq/geometry 0.1.0

package/src/vector2.test.ts

@@ -0,0 +1,958 @@
+import {
+  addVector2,
+  clampVector2,
+  cloneVector2,
+  copyVector2,
+  createVector2,
+  createVector2FromPolar,
+  divideVector2,
+  equalsVector2,
+  getVector2AngleBetween,
+  getVector2Distance,
+  getVector2DistanceSquared,
+  getVector2Dot,
+  getVector2Length,
+  getVector2LengthSquared,
+  interpolateVector2,
+  maxVector2,
+  minVector2,
+  multiplyVector2,
+  nearEqualsVector2,
+  negateVector2,
+  normalizeVector2,
+  offsetVector2,
+  reflectVector2,
+  scaleVector2,
+  scaleVector2ToLength,
+  setVector2,
+  setVector2FromFloat32Array,
+  setVector2FromPolar,
+  setVector2FromVector3,
+  subtractVector2,
+  writeVector2ToFloat32Array,
+} from '@flighthq/geometry';
+import type { Vector2 } from '@flighthq/types';
+
+let pt: Vector2;
+let pt2: Vector2;
+
+beforeEach(() => {
+  pt = createVector2();
+  pt2 = createVector2();
+});
+
+describe('addVector2', () => {
+  it('adds two coordinates', () => {
+    pt.x = 2;
+    pt.y = 10;
+    pt2.x = 4;
+    pt2.y = 20;
+
+    const result = createVector2();
+    addVector2(result, pt, pt2);
+    expect(result.x).toBe(6);
+    expect(result.y).toBe(30);
+    expect(result).not.toBe(pt);
+    expect(result).not.toBe(pt2);
+  });
+
+  it('works correctly if first vector is out', () => {
+    pt.x = 3;
+    pt.y = 7;
+    pt2.x = 5;
+    pt2.y = 10;
+
+    addVector2(pt, pt, pt2);
+    expect(pt.x).toBe(8);
+    expect(pt.y).toBe(17);
+    expect(pt2.x).toBe(5);
+    expect(pt2.y).toBe(10);
+  });
+
+  it('works correctly if second vector is out', () => {
+    pt.x = 2;
+    pt.y = 10;
+    pt2.x = 4;
+    pt2.y = 20;
+
+    addVector2(pt2, pt, pt2);
+    expect(pt.x).toBe(2);
+    expect(pt.y).toBe(10);
+    expect(pt2.x).toBe(6);
+    expect(pt2.y).toBe(30);
+  });
+
+  it('allows a vector-like object', () => {
+    const pt = { x: 2, y: 10 };
+    const pt2 = { x: 4, y: 20 };
+
+    const result = { x: 0, y: 0 };
+    addVector2(result, pt, pt2);
+    expect(result.x).toBe(6);
+    expect(result.y).toBe(30);
+    expect(result).not.toBe(pt);
+    expect(result).not.toBe(pt2);
+  });
+});
+
+describe('clampVector2', () => {
+  it('clamps each component independently', () => {
+    const out = createVector2();
+    const value = createVector2(5, -2);
+    const min = createVector2(0, 0);
+    const max = createVector2(3, 3);
+    clampVector2(out, value, min, max);
+    expect(out.x).toBe(3);
+    expect(out.y).toBe(0);
+  });
+
+  it('leaves values within range unchanged', () => {
+    const out = createVector2();
+    const value = createVector2(1, 2);
+    const min = createVector2(0, 0);
+    const max = createVector2(3, 3);
+    clampVector2(out, value, min, max);
+    expect(out.x).toBe(1);
+    expect(out.y).toBe(2);
+  });
+
+  it('supports out === value', () => {
+    const v = createVector2(5, -1);
+    clampVector2(v, v, createVector2(0, 0), createVector2(3, 3));
+    expect(v.x).toBe(3);
+    expect(v.y).toBe(0);
+  });
+});
+
+describe('cloneVector2', () => {
+  it('creates a copy of a vector', () => {
+    pt.x = 1;
+    pt.y = 2;
+    const result = cloneVector2(pt);
+    expect(result.x).toBe(pt.x);
+    expect(result.y).toBe(pt.y);
+  });
+
+  it('returns a Vector2 instance', () => {
+    const pt = { x: 1, y: 2 };
+    const result: Vector2 = cloneVector2(pt);
+    expect(result).not.toBeNull();
+  });
+});
+
+describe('copyVector2', () => {
+  it('copies coordinates from one vector to another', () => {
+    pt2.x = 1;
+    pt2.y = 2;
+    copyVector2(pt, pt2);
+    expect(pt.x).toBe(1);
+    expect(pt.y).toBe(2);
+  });
+
+  it('supports out === source', () => {
+    pt.x = 1;
+    pt.y = 2;
+    copyVector2(pt, pt);
+    expect(pt.x).toBe(1);
+    expect(pt.y).toBe(2);
+  });
+
+  it('allows a vector-like object', () => {
+    const pt2 = { x: 1, y: 2 };
+    copyVector2(pt, pt2);
+    expect(pt.x).toBe(1);
+    expect(pt.y).toBe(2);
+  });
+});
+
+describe('createVector2', () => {
+  it('returns a Vector2 with default coordinates', () => {
+    const p: Vector2 = createVector2();
+    expect(p).not.toBeNull();
+    expect(p.x).toBe(0);
+    expect(p.y).toBe(0);
+  });
+
+  it('sets the specified x and y coordinates', () => {
+    const p = createVector2(2, 4);
+    expect(p.x).toBe(2);
+    expect(p.y).toBe(4);
+  });
+
+  it('allows a vector-like object', () => {
+    const p = { x: 2, y: 4 };
+    expect(p.x).toBe(2);
+    expect(p.y).toBe(4);
+  });
+});
+
+describe('createVector2FromPolar', () => {
+  it('makes a createVector2 and calls polar', () => {
+    const pt = createVector2FromPolar(5, 0);
+    setVector2FromPolar(pt2, 5, 0);
+    expect(equalsVector2(pt, pt2)).toBe(true);
+  });
+});
+
+describe('divideVector2', () => {
+  it('divides component-wise', () => {
+    const out = createVector2();
+    divideVector2(out, createVector2(6, 8), createVector2(2, 4));
+    expect(out.x).toBe(3);
+    expect(out.y).toBe(2);
+  });
+
+  it('produces 0 for zero divisor components', () => {
+    const out = createVector2();
+    divideVector2(out, createVector2(6, 8), createVector2(0, 4));
+    expect(out.x).toBe(0);
+    expect(out.y).toBe(2);
+  });
+
+  it('supports out === source', () => {
+    const v = createVector2(6, 8);
+    divideVector2(v, v, createVector2(2, 4));
+    expect(v.x).toBe(3);
+    expect(v.y).toBe(2);
+  });
+});
+
+describe('equalsVector2', () => {
+  it('returns true if vectors are identical, false otherwise', () => {
+    expect(equalsVector2(pt, pt2)).toBe(true);
+    pt.x = 1;
+    expect(equalsVector2(pt, pt2)).toBe(false);
+    pt2.x = 1;
+    expect(equalsVector2(pt, pt2)).toBe(true);
+  });
+
+  it('allows a vector-like object', () => {
+    const pt2 = { x: 0, y: 0 };
+    expect(equalsVector2(pt, pt2)).toBe(true);
+    pt.x = 1;
+    expect(equalsVector2(pt, pt2)).toBe(false);
+    pt2.x = 1;
+    expect(equalsVector2(pt, pt2)).toBe(true);
+  });
+});
+
+describe('getVector2AngleBetween', () => {
+  it('returns 0 for identical vectors', () => {
+    const a = createVector2(1, 0);
+    expect(getVector2AngleBetween(a, a)).toBeCloseTo(0);
+  });
+
+  it('returns PI/2 for perpendicular vectors', () => {
+    const a = createVector2(1, 0);
+    const b = createVector2(0, 1);
+    expect(getVector2AngleBetween(a, b)).toBeCloseTo(Math.PI / 2);
+  });
+
+  it('returns PI for opposite vectors', () => {
+    const a = createVector2(1, 0);
+    const b = createVector2(-1, 0);
+    expect(getVector2AngleBetween(a, b)).toBeCloseTo(Math.PI);
+  });
+
+  it('returns NaN for a zero-length vector', () => {
+    const a = createVector2(0, 0);
+    const b = createVector2(1, 0);
+    expect(getVector2AngleBetween(a, b)).toBeNaN();
+  });
+});
+
+describe('getVector2Distance', () => {
+  const testCases = [
+    { a: [100, 0], b: [0, 0], expected: 100 },
+    { a: [0, 100], b: [0, 0], expected: 100 },
+    { a: [3, 4], b: [0, 0], expected: 5 },
+    { a: [5, 12], b: [0, 0], expected: 13 },
+    { a: [8, 15], b: [0, 0], expected: 17 },
+  ];
+
+  it('calculates Euclidean distance between vectors', () => {
+    for (const { a, b, expected } of testCases) {
+      pt.x = a[0];
+      pt.y = a[1];
+      pt2.x = b[0];
+      pt2.y = b[1];
+      expect(getVector2Distance(pt, pt2)).toBe(expected);
+    }
+  });
+
+  it('allows a vector-like object', () => {
+    for (const { a, b, expected } of testCases) {
+      const pt = { x: a[0], y: a[1] };
+      const pt2 = { x: b[0], y: b[1] };
+      expect(getVector2Distance(pt, pt2)).toBe(expected);
+    }
+  });
+});
+
+describe('getVector2DistanceSquared', () => {
+  it('returns the squared distance between two vectors', () => {
+    const a = createVector2(1, 1);
+    const b = createVector2(4, 5);
+    expect(getVector2DistanceSquared(a, b)).toBe(25); // 3^2 + 4^2
+  });
+
+  it('allows a vector-like object', () => {
+    const a = { x: 1, y: 1 };
+    const b = { x: 4, y: 5 };
+    expect(getVector2DistanceSquared(a, b)).toBe(25);
+  });
+});
+
+describe('getVector2Dot', () => {
+  it('returns the dot product of two vectors', () => {
+    const a = createVector2(1, 2);
+    const b = createVector2(4, 5);
+    expect(getVector2Dot(a, b)).toBe(14); // 1*4 + 2*5
+  });
+
+  it('allows a vector-like object', () => {
+    const a = { x: 1, y: 2 };
+    const b = { x: 4, y: 5 };
+    expect(getVector2Dot(a, b)).toBe(14);
+  });
+});
+
+describe('getVector2Length', () => {
+  const testCases = [
+    { x: 100, y: 0, expected: 100 },
+    { x: 0, y: 100, expected: 100 },
+    { x: 3, y: 4, expected: 5 },
+    { x: 5, y: 12, expected: 13 },
+    { x: 8, y: 15, expected: 17 },
+  ];
+
+  it('returns the length of the vector', () => {
+    for (const { x, y, expected } of testCases) {
+      pt.x = x;
+      pt.y = y;
+      expect(getVector2Length(pt)).toBe(expected);
+    }
+  });
+
+  it('allows a vector-like object', () => {
+    for (const { x, y, expected } of testCases) {
+      const pt = { x: x, y: y };
+      expect(getVector2Length(pt)).toBe(expected);
+    }
+  });
+});
+
+describe('getVector2LengthSquared', () => {
+  it('returns the square of the length', () => {
+    pt.x = 3;
+    pt.y = 4;
+    expect(getVector2LengthSquared(pt)).toBe(9 + 16); // 3^2 + 4^2 = 9 + 16 = 25
+  });
+
+  it('returns 0 for the origin (0, 0)', () => {
+    expect(getVector2LengthSquared(pt)).toBe(0);
+  });
+
+  it('handles negative values correctly', () => {
+    pt.x = -3;
+    pt.y = -4;
+    expect(getVector2LengthSquared(pt)).toBe(9 + 16); // 9 + 16 = 25
+  });
+
+  it('handles non-integer values', () => {
+    pt.x = 2.5;
+    pt.y = 4.5;
+    expect(getVector2LengthSquared(pt)).toBe(2.5 * 2.5 + 4.5 * 4.5); // 6.25 + 20.25 = 26.5
+  });
+
+  it('allows a vector-like object', () => {
+    const pt = { x: 3, y: 4 };
+    expect(getVector2LengthSquared(pt)).toBe(9 + 16); // 3^2 + 4^2 = 9 + 16 = 25
+  });
+});
+
+describe('interpolateVector2', () => {
+  const cases = [
+    { t: 0, expected: (a: number, _: number) => a },
+    { t: 1, expected: (_: number, b: number) => b },
+    { t: 0.5, expected: (a: number, b: number) => (a + b) / 2 },
+    { t: 10, expected: (a: number, b: number) => a + (b - a) * 10 },
+    { t: -1, expected: (a: number, b: number) => a + (b - a) * -1 },
+  ];
+
+  it('interpolates and extrapolates correctly', () => {
+    pt.x = 0;
+    pt.y = 0;
+    pt2.x = 100;
+    pt2.y = 100;
+
+    for (const { t, expected } of cases) {
+      const result = createVector2();
+      interpolateVector2(result, pt, pt2, t);
+      expect(result.x).toBe(expected(pt.x, pt2.x));
+      expect(result.y).toBe(expected(pt.y, pt2.y));
+    }
+  });
+
+  it('works correctly if out is the first vector', () => {
+    pt.x = 10;
+    pt.y = 20;
+    pt2.x = 30;
+    pt2.y = 40;
+
+    interpolateVector2(pt, pt, pt2, 0.5);
+    expect(pt.x).toBe(20);
+    expect(pt.y).toBe(30);
+    expect(pt2.x).toBe(30);
+    expect(pt2.y).toBe(40);
+  });
+
+  it('works correctly if out is the second vector', () => {
+    pt.x = 10;
+    pt.y = 20;
+    pt2.x = 30;
+    pt2.y = 40;
+
+    interpolateVector2(pt2, pt, pt2, 0.5);
+    expect(pt.x).toBe(10);
+    expect(pt.y).toBe(20);
+    expect(pt2.x).toBe(20);
+    expect(pt2.y).toBe(30);
+  });
+
+  it('handles extreme extrapolation values for t', () => {
+    pt.x = 0;
+    pt.y = 0;
+    pt2.x = 100;
+    pt2.y = 100;
+
+    const result = createVector2();
+    interpolateVector2(result, pt, pt2, 1000);
+    expect(result.x).toBe(100000);
+    expect(result.y).toBe(100000);
+  });
+
+  it('allows vector-like objects', () => {
+    const pt = { x: 0, y: 0 };
+    const pt2 = { x: 100, y: 100 };
+
+    for (const { t, expected } of cases) {
+      const result = { x: 0, y: 0 };
+      interpolateVector2(result, pt, pt2, t);
+      expect(result.x).toBe(expected(pt.x, pt2.x));
+      expect(result.y).toBe(expected(pt.y, pt2.y));
+    }
+  });
+});
+
+describe('maxVector2', () => {
+  it('returns the component-wise maximum', () => {
+    const out = createVector2();
+    maxVector2(out, createVector2(1, 5), createVector2(3, 2));
+    expect(out.x).toBe(3);
+    expect(out.y).toBe(5);
+  });
+
+  it('supports out === a', () => {
+    const a = createVector2(1, 5);
+    const b = createVector2(3, 2);
+    maxVector2(a, a, b);
+    expect(a.x).toBe(3);
+    expect(a.y).toBe(5);
+  });
+});
+
+describe('minVector2', () => {
+  it('returns the component-wise minimum', () => {
+    const out = createVector2();
+    minVector2(out, createVector2(1, 5), createVector2(3, 2));
+    expect(out.x).toBe(1);
+    expect(out.y).toBe(2);
+  });
+
+  it('supports out === a', () => {
+    const a = createVector2(1, 5);
+    const b = createVector2(3, 2);
+    minVector2(a, a, b);
+    expect(a.x).toBe(1);
+    expect(a.y).toBe(2);
+  });
+});
+
+describe('multiplyVector2', () => {
+  it('multiplies component-wise (Hadamard)', () => {
+    const out = createVector2();
+    multiplyVector2(out, createVector2(2, 3), createVector2(4, 5));
+    expect(out.x).toBe(8);
+    expect(out.y).toBe(15);
+  });
+
+  it('supports out === a', () => {
+    const a = createVector2(2, 3);
+    multiplyVector2(a, a, createVector2(4, 5));
+    expect(a.x).toBe(8);
+    expect(a.y).toBe(15);
+  });
+});
+
+describe('nearEqualsVector2', () => {
+  it('returns true for identical vectors', () => {
+    const a = createVector2(1, 2);
+    expect(nearEqualsVector2(a, a)).toBe(true);
+  });
+
+  it('returns true when difference is within default tolerance', () => {
+    const a = createVector2(1, 2);
+    const b = createVector2(1 + 1e-7, 2);
+    expect(nearEqualsVector2(a, b)).toBe(true);
+  });
+
+  it('returns false when difference exceeds default tolerance', () => {
+    const a = createVector2(1, 2);
+    const b = createVector2(1 + 1e-5, 2);
+    expect(nearEqualsVector2(a, b)).toBe(false);
+  });
+
+  it('respects a custom tolerance', () => {
+    const a = createVector2(1, 2);
+    const b = createVector2(1.05, 2);
+    expect(nearEqualsVector2(a, b, 0.1)).toBe(true);
+    expect(nearEqualsVector2(a, b, 0.01)).toBe(false);
+  });
+});
+
+describe('negateVector2', () => {
+  it('inverts the values of the vector components', () => {
+    const v = createVector2(1, -2);
+    const result = createVector2();
+    negateVector2(result, v);
+    expect(result.x).toBe(-1);
+    expect(result.y).toBe(2);
+  });
+
+  it('supports out === source', () => {
+    const v = createVector2(1, -2);
+    negateVector2(v, v);
+    expect(v.x).toBe(-1);
+    expect(v.y).toBe(2);
+  });
+});
+
+describe('normalizeVector2', () => {
+  it('produces a unit vector', () => {
+    const pt = createVector2(3, 4);
+    const result = createVector2();
+    normalizeVector2(result, pt);
+    expect(pt).not.toBe(result);
+    expect(result.x).toBeCloseTo(0.6);
+    expect(result.y).toBeCloseTo(0.8);
+    expect(getVector2Length(result)).toBeCloseTo(1);
+  });
+
+  it('returns the original length', () => {
+    const pt = createVector2(3, 4);
+    const result = createVector2();
+    const length = normalizeVector2(result, pt);
+    expect(length).toBeCloseTo(5);
+  });
+
+  it('returns zero for a zero-length vector', () => {
+    const pt = createVector2(0, 0);
+    const result = createVector2();
+    const length = normalizeVector2(result, pt);
+    expect(result).not.toBe(pt);
+    expect(result.x).toBe(0);
+    expect(result.y).toBe(0);
+    expect(length).toBe(0);
+  });
+
+  it('handles very small vectors correctly', () => {
+    const pt = createVector2(0.0001, 0.0001);
+    const result = createVector2();
+    normalizeVector2(result, pt);
+    expect(result.x).toBeCloseTo(0.7071, 4);
+    expect(result.y).toBeCloseTo(0.7071, 4);
+    expect(getVector2Length(result)).toBeCloseTo(1);
+  });
+
+  it('supports out === source', () => {
+    const pt = createVector2(3, 4);
+    const length = normalizeVector2(pt, pt);
+    expect(pt.x).toBeCloseTo(0.6);
+    expect(pt.y).toBeCloseTo(0.8);
+    expect(length).toBeCloseTo(5);
+  });
+
+  it('allows a vector-like object', () => {
+    const pt = { x: 3, y: 4 };
+    const result = { x: 0, y: 0 };
+    normalizeVector2(result, pt);
+    expect(pt).not.toBe(result);
+    expect(result.x).toBeCloseTo(0.6);
+    expect(result.y).toBeCloseTo(0.8);
+    expect(getVector2Length(result)).toBeCloseTo(1);
+  });
+});
+
+describe('offsetVector2', () => {
+  it('adjusts the value of a vector', () => {
+    const result = createVector2();
+    offsetVector2(result, pt, 10, 100);
+    expect(result.x).toBe(10);
+    expect(result.y).toBe(100);
+  });
+
+  it('works with negative deltas', () => {
+    const result = createVector2();
+    offsetVector2(result, pt, -5, -10);
+    expect(result.x).toBe(-5);
+    expect(result.y).toBe(-10);
+  });
+
+  it('supports out === source', () => {
+    const pt = createVector2(1, 2);
+    offsetVector2(pt, pt, 3, 4);
+    expect(pt.x).toBe(4);
+    expect(pt.y).toBe(6);
+  });
+
+  it('allows a vector-like object', () => {
+    const result = { x: 0, y: 0 };
+    offsetVector2(result, pt, 10, 100);
+    expect(result.x).toBe(10);
+    expect(result.y).toBe(100);
+  });
+});
+
+describe('reflectVector2', () => {
+  it('reflects incident vector about a normal', () => {
+    const out = createVector2();
+    // Reflect (1, -1) about the y-axis normal (1, 0)
+    reflectVector2(out, createVector2(1, -1), createVector2(1, 0));
+    expect(out.x).toBeCloseTo(-1, 6);
+    expect(out.y).toBeCloseTo(-1, 6);
+  });
+
+  it('reflects straight down about horizontal normal gives straight up', () => {
+    const out = createVector2();
+    reflectVector2(out, createVector2(0, -1), createVector2(0, 1));
+    expect(out.x).toBeCloseTo(0, 6);
+    expect(out.y).toBeCloseTo(1, 6);
+  });
+
+  it('supports out === incident', () => {
+    const v = createVector2(1, -1);
+    reflectVector2(v, v, createVector2(1, 0));
+    expect(v.x).toBeCloseTo(-1, 6);
+    expect(v.y).toBeCloseTo(-1, 6);
+  });
+});
+
+describe('scaleVector2', () => {
+  it('scales the vector by a scalar', () => {
+    const v = createVector2(1, 2);
+    const result = createVector2();
+    scaleVector2(result, v, 3);
+    expect(result.x).toBe(3);
+    expect(result.y).toBe(6);
+  });
+
+  it('supports out === source', () => {
+    const v = createVector2(1, 2);
+    scaleVector2(v, v, 3);
+    expect(v.x).toBe(3);
+    expect(v.y).toBe(6);
+  });
+});
+
+describe('scaleVector2ToLength', () => {
+  it('scales a vector to the specified length', () => {
+    const pt = createVector2(3, 4);
+    const result = createVector2();
+    scaleVector2ToLength(result, pt, 10);
+    expect(pt).not.toBe(result);
+    expect(result.x).toBeCloseTo(6);
+    expect(result.y).toBeCloseTo(8);
+    expect(getVector2Length(result)).toBeCloseTo(10);
+  });
+
+  it('returns zero for a zero-length vector', () => {
+    const pt = createVector2(0, 0);
+    const result = createVector2();
+    scaleVector2ToLength(result, pt, 5);
+    expect(result).not.toBe(pt);
+    expect(result.x).toBe(0);
+    expect(result.y).toBe(0);
+    expect(getVector2Length(result)).toBe(0);
+  });
+
+  it('scales vector to zero length', () => {
+    const pt = createVector2(3, 4);
+    const result = createVector2();
+    scaleVector2ToLength(result, pt, 0);
+    expect(result.x).toBe(0);
+    expect(result.y).toBe(0);
+    expect(getVector2Length(result)).toBe(0);
+  });
+
+  it('scales vector to negative length', () => {
+    const pt = createVector2(3, 4);
+    const result = createVector2();
+    scaleVector2ToLength(result, pt, -10);
+    expect(result.x).toBeCloseTo(-6);
+    expect(result.y).toBeCloseTo(-8);
+    expect(getVector2Length(result)).toBeCloseTo(10);
+  });
+
+  it('supports out === source', () => {
+    const pt = createVector2(3, 4);
+    scaleVector2ToLength(pt, pt, 10);
+    expect(pt.x).toBeCloseTo(6);
+    expect(pt.y).toBeCloseTo(8);
+    expect(getVector2Length(pt)).toBeCloseTo(10);
+  });
+
+  it('allows a vector-like object', () => {
+    const pt = { x: 3, y: 4 };
+    const result = { x: 0, y: 0 };
+    scaleVector2ToLength(result, pt, 10);
+    expect(pt).not.toBe(result);
+    expect(result.x).toBeCloseTo(6);
+    expect(result.y).toBeCloseTo(8);
+    expect(getVector2Length(result)).toBeCloseTo(10);
+  });
+});
+
+describe('setVector2', () => {
+  it('updates coordinates of a vector', () => {
+    setVector2(pt, 2, 10);
+    expect(pt.x).toBe(2);
+    expect(pt.y).toBe(10);
+  });
+
+  it('sets both coordinates to zero correctly', () => {
+    pt.x = 1;
+    pt.y = 2;
+    setVector2(pt, 0, 0);
+    expect(pt.x).toBe(0);
+    expect(pt.y).toBe(0);
+  });
+
+  it('allows a vector-like object', () => {
+    const pt = { x: 0, y: 0 };
+    setVector2(pt, 2, 10);
+    expect(pt.x).toBe(2);
+    expect(pt.y).toBe(10);
+  });
+});
+
+describe('setVector2FromFloat32Array', () => {
+  it('writes the vector from 2 values at the offset', () => {
+    const array = new Float32Array(2);
+    array[0] = 1;
+    array[1] = 2;
+    const vector = { x: 100, y: 100 };
+    setVector2FromFloat32Array(vector, 0, array);
+    expect(vector.x).toBe(1);
+    expect(vector.y).toBe(2);
+  });
+});
+
+describe('setVector2FromPolar', () => {
+  it('returns a vector at the given length along the x-axis when angle is 0', () => {
+    const p = createVector2();
+    setVector2FromPolar(p, 5, 0);
+    expect(p.x).toBeCloseTo(5);
+    expect(p.y).toBeCloseTo(0);
+    expect(getVector2Length(p)).toBeCloseTo(5);
+  });
+
+  it('returns a vector at the given length along the y-axis when angle is π/2', () => {
+    const p = createVector2();
+    setVector2FromPolar(p, 3, Math.PI / 2);
+    expect(p.x).toBeCloseTo(0);
+    expect(p.y).toBeCloseTo(3);
+    expect(getVector2Length(p)).toBeCloseTo(3);
+  });
+
+  it('returns a vector in the correct quadrant for angle π', () => {
+    const p = createVector2();
+    setVector2FromPolar(p, 4, Math.PI);
+    expect(p.x).toBeCloseTo(-4);
+    expect(p.y).toBeCloseTo(0);
+    expect(getVector2Length(p)).toBeCloseTo(4);
+  });
+
+  it('returns a vector in the correct quadrant for angle 3π/2', () => {
+    const p = createVector2();
+    setVector2FromPolar(p, 2, (3 * Math.PI) / 2);
+    expect(p.x).toBeCloseTo(0);
+    expect(p.y).toBeCloseTo(-2);
+    expect(getVector2Length(p)).toBeCloseTo(2);
+  });
+
+  it('handles zero length', () => {
+    const p = createVector2();
+    setVector2FromPolar(p, 0, Math.PI / 4);
+    expect(p.x).toBeCloseTo(0);
+    expect(p.y).toBeCloseTo(0);
+    expect(getVector2Length(p)).toBeCloseTo(0);
+  });
+
+  it('handles negative length', () => {
+    const p = createVector2();
+    setVector2FromPolar(p, -5, 0);
+    expect(p.x).toBeCloseTo(-5);
+    expect(p.y).toBeCloseTo(0);
+    expect(getVector2Length(p)).toBeCloseTo(5); // length property is always positive
+  });
+
+  it('handles arbitrary angles', () => {
+    const angle = Math.PI / 4; // 45 degrees
+    const len = Math.sqrt(2);
+    const p = createVector2();
+    setVector2FromPolar(p, len, angle);
+    expect(p.x).toBeCloseTo(1);
+    expect(p.y).toBeCloseTo(1);
+    expect(getVector2Length(p)).toBeCloseTo(len);
+  });
+
+  it('allows vector-like objects', () => {
+    const p = { x: 0, y: 0 };
+    setVector2FromPolar(p, 5, 0);
+    expect(p.x).toBeCloseTo(5);
+    expect(p.y).toBeCloseTo(0);
+  });
+});
+
+describe('setVector2FromVector3', () => {
+  it('copies x and y from a Vector3Like, dropping z', () => {
+    const src = { x: 3, y: 7, z: 99 };
+    const out = createVector2();
+    setVector2FromVector3(out, src);
+    expect(out.x).toBe(3);
+    expect(out.y).toBe(7);
+  });
+
+  it('is safe when out shares x/y memory with source (plain object)', () => {
+    const out = createVector2(1, 2);
+    const src = { x: out.x, y: out.y, z: 5 };
+    setVector2FromVector3(out, src);
+    expect(out.x).toBe(1);
+    expect(out.y).toBe(2);
+  });
+});
+
+describe('subtractVector2', () => {
+  it('subtracts the coordinates of two vectors into a new vector', () => {
+    pt.x = 5;
+    pt.y = 10;
+    pt2.x = 2;
+    pt2.y = 4;
+
+    const result = createVector2();
+    subtractVector2(result, pt, pt2);
+
+    expect(result.x).toBe(3);
+    expect(result.y).toBe(6);
+  });
+
+  it('handles negative results correctly', () => {
+    pt.x = 2;
+    pt.y = 3;
+    pt2.x = 5;
+    pt2.y = 10;
+
+    const result = createVector2();
+    subtractVector2(result, pt, pt2);
+
+    expect(result.x).toBe(-3);
+    expect(result.y).toBe(-7);
+  });
+
+  it('returns zero when subtracting a vector from itself', () => {
+    pt.x = 7;
+    pt.y = -3;
+
+    const result = createVector2();
+    subtractVector2(result, pt, pt);
+
+    expect(result.x).toBe(0);
+    expect(result.y).toBe(0);
+  });
+
+  it('supports out === source', () => {
+    pt.x = 5;
+    pt.y = 10;
+    pt2.x = 2;
+    pt2.y = 4;
+    subtractVector2(pt, pt, pt2);
+    expect(pt.x).toBe(3);
+    expect(pt.y).toBe(6);
+  });
+
+  it('supports out === other', () => {
+    pt.x = 5;
+    pt.y = 10;
+    pt2.x = 2;
+    pt2.y = 4;
+    subtractVector2(pt2, pt, pt2);
+    expect(pt2.x).toBe(3);
+    expect(pt2.y).toBe(6);
+  });
+
+  it('works when source or target vectors are at the origin', () => {
+    pt.x = 0;
+    pt.y = 0;
+    pt2.x = 5;
+    pt2.y = 10;
+
+    const result = createVector2();
+    subtractVector2(result, pt, pt2);
+    expect(result.x).toBe(-5);
+    expect(result.y).toBe(-10);
+
+    const result2 = createVector2();
+    subtractVector2(result2, pt2, pt);
+    expect(result2.x).toBe(5);
+    expect(result2.y).toBe(10);
+  });
+
+  it('works with very small values and results near zero', () => {
+    pt.x = 0.0001;
+    pt.y = 0.0001;
+    pt2.x = 0.0001;
+    pt2.y = 0.0001;
+
+    const result = createVector2();
+    subtractVector2(result, pt, pt2);
+    expect(result.x).toBeCloseTo(0);
+    expect(result.y).toBeCloseTo(0);
+  });
+
+  it('allows vector-like objects', () => {
+    const pt = { x: 5, y: 10 };
+    const pt2 = { x: 2, y: 4 };
+
+    const result = { x: 0, y: 0 };
+    subtractVector2(result, pt, pt2);
+
+    expect(result.x).toBe(3);
+    expect(result.y).toBe(6);
+
+    // Ensure new object is returned
+    expect(result).not.toBe(pt);
+    expect(result).not.toBe(pt2);
+  });
+});
+
+describe('writeVector2ToFloat32Array', () => {
+  it('writes 2 values at the offset', () => {
+    const array = new Float32Array(6);
+    const vector = { x: 1, y: 2 };
+    writeVector2ToFloat32Array(array, 0, vector);
+    for (let i = 0; i < 2; i++) {
+      expect(array[i]).toBe(i + 1);
+    }
+  });
+});