@pawells/math-extended 2.0.0 → 3.0.0

package/build/vectors/core.js

@@ -3,7 +3,7 @@
  * Provides a comprehensive set of vector operations with type safety and error checking.
  */
 import { Clamp } from '../clamp.js';
-import { AssertVector, AssertVectors, AssertVectorValue, VectorError, AssertVector2, AssertVector3 } from './asserts.js';
+import { AssertVector, AssertVector2, AssertVector3, AssertVectorNonZero, AssertVectorSameSize, ValidateVectorSameSize, VectorError } from './asserts.js';
 /**
  * Creates a deep copy of a vector.
  * Essential for avoiding mutations when performing operations that should preserve the original vector.
@@ -13,11 +13,11 @@ import { AssertVector, AssertVectors, AssertVectorValue, VectorError, AssertVect
  * @returns A new vector with identical components
  *
  * @example
-     * ```typescript
-     * const original = [1, 2, 3];
-     * const copy = VectorClone(original);
-     * copy[0] = 10; // original remains unchanged
-     * ```
+ * ```typescript
+ * const original = [1, 2, 3];
+ * const copy = VectorClone(original);
+ * copy[0] = 10; // original remains unchanged
+ * ```
  */
 export function VectorClone(vector) {
     AssertVector(vector);
@@ -34,22 +34,21 @@ export function VectorClone(vector) {
  * @returns True if vectors are equal within tolerance, false otherwise
  *
  * @example
-     * ```typescript
-     * const a = [1.0001, 2.0001];
-     * const b = [1.0002, 2.0002];
-     * const exactlyEqual = VectorEquals(a, b); // false
-     * const approximatelyEqual = VectorEquals(a, b, 0.001); // true
-     * ```
+ * ```typescript
+ * const a = [1.0001, 2.0001];
+ * const b = [1.0002, 2.0002];
+ * const exactlyEqual = VectorEquals(a, b); // false
+ * const approximatelyEqual = VectorEquals(a, b, 0.001); // true
+ * ```
  */
 export function VectorEquals(a, b, tolerance = 0) {
-    AssertVectors([a, b]);
-    if (a.length !== b.length)
+    if (!ValidateVectorSameSize([a, b]))
         return false;
+    AssertVector(a);
+    AssertVector(b);
     for (let i = 0; i < a.length; i++) {
         const av = a[i];
-        AssertVectorValue(av, {});
         const bv = b[i];
-        AssertVectorValue(bv, {});
         if (tolerance !== 0) {
             if (Math.abs(av - bv) > tolerance)
                 return false;
@@ -68,18 +67,17 @@ export function VectorEquals(a, b, tolerance = 0) {
  * @returns String representation of the vector
  *
  * @example
-     * ```typescript
-     * const vec = [1, 2, 3];
-     * const parens = VectorToString(vec, 'parens'); // "(1, 2, 3)"
-     * const brackets = VectorToString(vec, 'brackets'); // "[1, 2, 3]"
-     * ```
+ * ```typescript
+ * const vec = [1, 2, 3];
+ * const parens = VectorToString(vec, 'parens'); // "(1, 2, 3)"
+ * const brackets = VectorToString(vec, 'brackets'); // "[1, 2, 3]"
+ * ```
  */
 export function VectorToString(vector, style = 'parens') {
     AssertVector(vector);
     const components = vector.map((v) => v.toString()).join(', ');
-    if (style === 'parens') {
+    if (style === 'parens')
         return `(${components})`;
-    }
     return `[${components}]`;
 }
 /**
@@ -92,20 +90,20 @@ export function VectorToString(vector, style = 'parens') {
  * @returns New vector where each component is the sum of corresponding components
  *
  * @example
-     * ```typescript
-     * const position = [10, 20, 30];
-     * const velocity = [1, -2, 0.5];
-     * const newPosition = VectorAdd(position, velocity); // [11, 18, 30.5]
-     * ```
+ * ```typescript
+ * const position = [10, 20, 30];
+ * const velocity = [1, -2, 0.5];
+ * const newPosition = VectorAdd(position, velocity); // [11, 18, 30.5]
+ * ```
  */
 export function VectorAdd(a, b) {
-    AssertVectors([a, b]);
+    AssertVector(a);
+    AssertVector(b);
+    AssertVectorSameSize([a, b]);
     const result = [];
     for (let i = 0; i < a.length; i++) {
         const av = a[i];
-        AssertVectorValue(av, {});
         const bv = b[i];
-        AssertVectorValue(bv, {});
         result.push(av + bv);
     }
     return result;
@@ -120,20 +118,20 @@ export function VectorAdd(a, b) {
  * @returns New vector where each component is the difference of corresponding components
  *
  * @example
-     * ```typescript
-     * const target = [100, 50, 0];
-     * const current = [80, 30, 0];
-     * const direction = VectorSubtract(target, current); // [20, 20, 0]
-     * ```
+ * ```typescript
+ * const target = [100, 50, 0];
+ * const current = [80, 30, 0];
+ * const direction = VectorSubtract(target, current); // [20, 20, 0]
+ * ```
  */
 export function VectorSubtract(a, b) {
-    AssertVectors([a, b]);
+    AssertVector(a);
+    AssertVector(b);
+    AssertVectorSameSize([a, b]);
     const result = [];
     for (let i = 0; i < a.length; i++) {
         const av = a[i];
-        AssertVectorValue(av, {}, { index: i });
         const bv = b[i];
-        AssertVectorValue(bv, {}, { index: i });
         result.push(av - bv);
     }
     return result;
@@ -148,30 +146,28 @@ export function VectorSubtract(a, b) {
  * @returns New vector with multiplied components
  *
  * @example
-     * ```typescript
-     * const velocity = [10, 5, 0];
-     * const scaled = VectorMultiply(velocity, 2); // [20, 10, 0] - scalar multiplication
-     * const factors = [1, -1, 0.5];
-     * const componentWise = VectorMultiply(velocity, factors); // [10, -5, 0] - component-wise
-     * ```
+ * ```typescript
+ * const velocity = [10, 5, 0];
+ * const scaled = VectorMultiply(velocity, 2); // [20, 10, 0] - scalar multiplication
+ * const factors = [1, -1, 0.5];
+ * const componentWise = VectorMultiply(velocity, factors); // [10, -5, 0] - component-wise
+ * ```
  */
 export function VectorMultiply(a, b) {
+    AssertVector(a);
     const result = [];
     if (Array.isArray(b)) {
-        if (b.length !== a.length)
-            throw new Error('Vector Size Mismatch');
+        AssertVector(b);
+        AssertVectorSameSize([a, b]);
         for (let i = 0; i < a.length; i++) {
             const av = a[i];
-            AssertVectorValue(av, {});
             const bv = b[i];
-            AssertVectorValue(bv, {});
             const prod = av * bv;
             result.push(Object.is(prod, -0) ? 0 : prod);
         }
     }
     else if (typeof b === 'number') {
         for (const av of a) {
-            AssertVectorValue(av, {});
             const prod = av * b;
             result.push(Object.is(prod, -0) ? 0 : prod);
         }
@@ -187,11 +183,11 @@ export function VectorMultiply(a, b) {
  * @returns The straight-line distance between the two points represented by the vectors
  *
  * @example
-     * ```typescript
-     * const pointA = [0, 0, 0];
-     * const pointB = [3, 4, 0];
-     * const distance = VectorDistance(pointA, pointB); // 5.0 (3-4-5 triangle)
-     * ```
+ * ```typescript
+ * const pointA = [0, 0, 0];
+ * const pointB = [3, 4, 0];
+ * const distance = VectorDistance(pointA, pointB); // 5.0 (3-4-5 triangle)
+ * ```
  */
 export function VectorDistance(a, b) {
     return Math.sqrt(VectorDistanceSquared(a, b));
@@ -206,20 +202,20 @@ export function VectorDistance(a, b) {
  * @returns The squared distance between vectors
  *
  * @example
-     * ```typescript
-     * const pointA = [1, 1];
-     * const pointB = [4, 5];
-     * const distSq = VectorDistanceSquared(pointA, pointB); // 25 (faster than distance comparison)
-     * ```
+ * ```typescript
+ * const pointA = [1, 1];
+ * const pointB = [4, 5];
+ * const distSq = VectorDistanceSquared(pointA, pointB); // 25 (faster than distance comparison)
+ * ```
  */
 export function VectorDistanceSquared(a, b) {
-    AssertVectors([a, b]);
+    AssertVector(a);
+    AssertVector(b);
+    AssertVectorSameSize([a, b]);
     let sum = 0;
     for (let i = 0; i < a.length; i++) {
         const av = a[i];
-        AssertVectorValue(av, {});
         const bv = b[i];
-        AssertVectorValue(bv, {});
         const diff = bv - av;
         sum += diff * diff;
     }
@@ -235,22 +231,22 @@ export function VectorDistanceSquared(a, b) {
  * @returns The dot product (scalar value)
  *
  * @example
-     * ```typescript
-     * const forward = [0, 0, 1];
-     * const direction = [0, 0, 2];
-     * const dot = VectorDot(forward, direction); // 2 (same direction)
-     * const perpendicular = [1, 0, 0];
-     * const dotPerp = VectorDot(forward, perpendicular); // 0 (perpendicular)
-     * ```
+ * ```typescript
+ * const forward = [0, 0, 1];
+ * const direction = [0, 0, 2];
+ * const dot = VectorDot(forward, direction); // 2 (same direction)
+ * const perpendicular = [1, 0, 0];
+ * const dotPerp = VectorDot(forward, perpendicular); // 0 (perpendicular)
+ * ```
  */
 export function VectorDot(a, b) {
-    AssertVectors([a, b]);
+    AssertVector(a);
+    AssertVector(b);
+    AssertVectorSameSize([a, b]);
     let dotProduct = 0;
     for (let i = 0; i < a.length; i++) {
         const av = a[i];
-        AssertVectorValue(av, {});
         const bv = b[i];
-        AssertVectorValue(bv, {});
         dotProduct += av * bv;
     }
     return dotProduct;
@@ -266,12 +262,12 @@ export function VectorDot(a, b) {
  * @throws {VectorError} If the vector is zero or has infinite magnitude
  *
  * @example
-     * ```typescript
-     * const vector = [3, 4, 0];
-     * const normalized = VectorNormalize(vector); // [0.6, 0.8, 0] (magnitude = 1)
-     * const direction = [10, 0, 0];
-     * const unitDirection = VectorNormalize(direction); // [1, 0, 0]
-     * ```
+ * ```typescript
+ * const vector = [3, 4, 0];
+ * const normalized = VectorNormalize(vector); // [0.6, 0.8, 0] (magnitude = 1)
+ * const direction = [10, 0, 0];
+ * const unitDirection = VectorNormalize(direction); // [1, 0, 0]
+ * ```
  */
 export function VectorNormalize(a) {
     AssertVector(a);
@@ -283,7 +279,6 @@ export function VectorNormalize(a) {
     const result = VectorClone(a);
     for (let i = 0; i < a.length; i++) {
         const av = a[i];
-        AssertVectorValue(av, {});
         result[i] = av / magnitude;
     }
     return result;
@@ -296,20 +291,18 @@ export function VectorNormalize(a) {
  * @returns The magnitude (length) of the vector
  *
  * @example
-     * ```typescript
-     * const velocity = [3, 4, 0];
-     * const speed = VectorMagnitude(velocity); // 5.0
-     * const unitVector = [1, 0, 0];
-     * const unitLength = VectorMagnitude(unitVector); // 1.0
-     * ```
+ * ```typescript
+ * const velocity = [3, 4, 0];
+ * const speed = VectorMagnitude(velocity); // 5.0
+ * const unitVector = [1, 0, 0];
+ * const unitLength = VectorMagnitude(unitVector); // 1.0
+ * ```
  */
 export function VectorMagnitude(a) {
     AssertVector(a);
     let sum = 0;
-    for (const av of a) {
-        AssertVectorValue(av, {});
+    for (const av of a)
         sum += av * av;
-    }
     return Math.sqrt(sum);
 }
 /**
@@ -321,20 +314,18 @@ export function VectorMagnitude(a) {
  * @returns New vector with absolute values of all components
  *
  * @example
-     * ```typescript
-     * const vector = [-3, 4, -2];
-     * const absolute = VectorAbs(vector); // [3, 4, 2]
-     * const mixed = [1.5, -2.7, 0];
-     * const absValues = VectorAbs(mixed); // [1.5, 2.7, 0]
-     * ```
+ * ```typescript
+ * const vector = [-3, 4, -2];
+ * const absolute = VectorAbs(vector); // [3, 4, 2]
+ * const mixed = [1.5, -2.7, 0];
+ * const absValues = VectorAbs(mixed); // [1.5, 2.7, 0]
+ * ```
  */
 export function VectorAbs(a) {
     AssertVector(a);
     const result = [];
-    for (const av of a) {
-        AssertVectorValue(av, {});
+    for (const av of a)
         result.push(Math.abs(av));
-    }
     return result;
 }
 /**
@@ -345,12 +336,12 @@ export function VectorAbs(a) {
  * @returns True if all components are zero, false otherwise
  *
  * @example
-     * ```typescript
-     * const zero = [0, 0, 0];
-     * const isZero = VectorIsZero(zero); // true
-     * const notZero = [0, 0.001, 0];
-     * const isNotZero = VectorIsZero(notZero); // false
-     * ```
+ * ```typescript
+ * const zero = [0, 0, 0];
+ * const isZero = VectorIsZero(zero); // true
+ * const notZero = [0, 0.001, 0];
+ * const isNotZero = VectorIsZero(notZero); // false
+ * ```
  */
 export function VectorIsZero(vector) {
     return vector.every((v) => v === 0);
@@ -366,17 +357,19 @@ export function VectorIsZero(vector) {
  * @throws {VectorError} If either vector is zero
  *
  * @example
-     * ```typescript
-     * const right = [1, 0, 0];
-     * const up = [0, 1, 0];
-     * const angle = VectorAngle(right, up); // π/2 (90 degrees)
-     * const forward = [0, 0, 1];
-     * const backward = [0, 0, -1];
-     * const oppositeAngle = VectorAngle(forward, backward); // π (180 degrees)
-     * ```
+ * ```typescript
+ * const right = [1, 0, 0];
+ * const up = [0, 1, 0];
+ * const angle = VectorAngle(right, up); // π/2 (90 degrees)
+ * const forward = [0, 0, 1];
+ * const backward = [0, 0, -1];
+ * const oppositeAngle = VectorAngle(forward, backward); // π (180 degrees)
+ * ```
  */
 export function VectorAngle(a, b) {
-    AssertVectors([a, b]);
+    AssertVector(a);
+    AssertVector(b);
+    AssertVectorSameSize([a, b]);
     if (VectorIsZero(a) || VectorIsZero(b))
         throw new VectorError('Cannot Calculate Angle with Zero Vectors');
     const dot = VectorDot(a, b);
@@ -384,6 +377,32 @@ export function VectorAngle(a, b) {
     const cosTheta = Clamp(dot / magProduct, -1, 1);
     return Math.acos(cosTheta);
 }
+/**
+ * Limits (clamps) the magnitude of a vector to a maximum value.
+ * If the vector's magnitude exceeds the maximum, scales it down proportionally while preserving direction.
+ * If the magnitude is below the maximum, the vector is returned unchanged.
+ *
+ * @param vector - The input vector to limit
+ * @param maxMagnitude - The maximum allowed magnitude (must be >= 0)
+ * @returns A new vector with magnitude limited to maxMagnitude
+ * @throws {VectorError} If vector is invalid or maxMagnitude is invalid
+ *
+ * @example
+ * ```typescript
+ *   const v = [3, 4]; // magnitude 5
+ *   VectorLimit(v, 3); // [1.8, 2.4] — magnitude now 3
+ * ```
+ */
+export function VectorLimit(vector, maxMagnitude) {
+    AssertVector(vector);
+    if (maxMagnitude < 0)
+        throw new VectorError(`maxMagnitude must be non-negative: ${maxMagnitude}`);
+    const mag = VectorMagnitude(vector);
+    if (mag <= maxMagnitude || mag === 0)
+        return VectorClone(vector);
+    const scale = maxMagnitude / mag;
+    return VectorMultiply(vector, scale);
+}
 /**
  * Rotates a 2D vector by the specified angle in radians.
  * Essential for 2D transformations, sprite rotations, and directional calculations.
@@ -393,11 +412,11 @@ export function VectorAngle(a, b) {
  * @returns New rotated 2D vector
  *
  * @example
-     * ```typescript
-     * const right = [1, 0];
-     * const rotated90 = Vector2Rotate(right, Math.PI / 2); // [0, 1] (up)
-     * const rotated180 = Vector2Rotate(right, Math.PI); // [-1, 0] (left)
-     * ```
+ * ```typescript
+ * const right = [1, 0];
+ * const rotated90 = Vector2Rotate(right, Math.PI / 2); // [0, 1] (up)
+ * const rotated180 = Vector2Rotate(right, Math.PI); // [-1, 0] (left)
+ * ```
  */
 export function Vector2Rotate(vector, radians) {
     AssertVector2(vector);
@@ -417,11 +436,11 @@ export function Vector2Rotate(vector, radians) {
  * @returns Unit vector pointing in the specified direction
  *
  * @example
-     * ```typescript
-     * const right = Vector2FromAngle(0); // [1, 0]
-     * const up = Vector2FromAngle(Math.PI / 2); // [0, 1]
-     * const diagonal = Vector2FromAngle(Math.PI / 4); // [0.707, 0.707]
-     * ```
+ * ```typescript
+ * const right = Vector2FromAngle(0); // [1, 0]
+ * const up = Vector2FromAngle(Math.PI / 2); // [0, 1]
+ * const diagonal = Vector2FromAngle(Math.PI / 4); // [0.707, 0.707]
+ * ```
  */
 export function Vector2FromAngle(radians) {
     return [Math.cos(radians), Math.sin(radians)];
@@ -436,12 +455,12 @@ export function Vector2FromAngle(radians) {
  * @returns Scalar cross product (positive = counterclockwise, negative = clockwise)
  *
  * @example
-     * ```typescript
-     * const right = [1, 0];
-     * const up = [0, 1];
-     * const cross = Vector2Cross(right, up); // 1 (counterclockwise)
-     * const crossReverse = Vector2Cross(up, right); // -1 (clockwise)
-     * ```
+ * ```typescript
+ * const right = [1, 0];
+ * const up = [0, 1];
+ * const cross = Vector2Cross(right, up); // 1 (counterclockwise)
+ * const crossReverse = Vector2Cross(up, right); // -1 (clockwise)
+ * ```
  */
 export function Vector2Cross(a, b) {
     AssertVector2(a);
@@ -459,11 +478,11 @@ export function Vector2Cross(a, b) {
  * @throws {VectorError} If vector b is zero
  *
  * @example
-     * ```typescript
-     * const force = [5, 3, 0];
-     * const surface = [1, 0, 0];
-     * const perpendicular = Vector3Reject(force, surface); // [0, 3, 0]
-     * ```
+ * ```typescript
+ * const force = [5, 3, 0];
+ * const surface = [1, 0, 0];
+ * const perpendicular = Vector3Reject(force, surface); // [0, 3, 0]
+ * ```
  */
 export function Vector3Reject(a, b) {
     AssertVector3(a);
@@ -485,24 +504,24 @@ export function Vector3Reject(a, b) {
  * @throws {VectorError} If vector b is zero
  *
  * @example
-     * ```typescript
-     * const force = [5, 3, 0];
-     * const surface = [1, 0, 0];
-     * const parallel = VectorProject(force, surface); // [5, 0, 0]
-     * ```
+ * ```typescript
+ * const force = [5, 3, 0];
+ * const surface = [1, 0, 0];
+ * const parallel = VectorProject(force, surface); // [5, 0, 0]
+ * ```
  */
 export function VectorProject(a, b) {
-    AssertVectors([a, b]);
+    AssertVector(a);
+    AssertVector(b);
+    AssertVectorSameSize([a, b]);
     if (VectorIsZero(b))
         throw new VectorError('Cannot project onto a zero vector');
     const dot = VectorDot(a, b);
     const magSquared = VectorDot(b, b);
     const scalar = dot / magSquared;
     const result = [];
-    for (const bv of b) {
-        AssertVectorValue(bv, {});
+    for (const bv of b)
         result.push(scalar * bv);
-    }
     return result;
 }
 /**
@@ -516,11 +535,11 @@ export function VectorProject(a, b) {
  * @throws {VectorError} If the normal is a zero vector
  *
  * @example
-     * ```typescript
-     * const incoming = [1, -1, 0];
-     * const normal = [0, 1, 0]; // surface normal (upward)
-     * const reflected = Vector3Reflect(incoming, normal); // [1, 1, 0]
-     * ```
+ * ```typescript
+ * const incoming = [1, -1, 0];
+ * const normal = [0, 1, 0]; // surface normal (upward)
+ * const reflected = Vector3Reflect(incoming, normal); // [1, 1, 0]
+ * ```
  */
 export function Vector3Reflect(incident, normal) {
     AssertVector3(incident);
@@ -540,12 +559,12 @@ export function Vector3Reflect(incident, normal) {
  * @returns Vector perpendicular to both a and b (following right-hand rule)
  *
  * @example
-     * ```typescript
-     * const right = [1, 0, 0];
-     * const forward = [0, 0, 1];
-     * const up = Vector3Cross(right, forward); // [0, 1, 0]
-     * const normal = Vector3Cross([1, 0, 0], [0, 1, 0]); // [0, 0, 1]
-     * ```
+ * ```typescript
+ * const right = [1, 0, 0];
+ * const forward = [0, 0, 1];
+ * const up = Vector3Cross(right, forward); // [0, 1, 0]
+ * const normal = Vector3Cross([1, 0, 0], [0, 1, 0]); // [0, 0, 1]
+ * ```
  */
 export function Vector3Cross(a, b) {
     AssertVector3(a);
@@ -566,11 +585,11 @@ export function Vector3Cross(a, b) {
  * @returns Magnitude of the cross product
  *
  * @example
-     * ```typescript
-     * const side1 = [3, 0, 0];
-     * const side2 = [0, 4, 0];
-     * const area = VectorCrossMagnitude(side1, side2); // 12 (area of rectangle)
-     * ```
+ * ```typescript
+ * const side1 = [3, 0, 0];
+ * const side2 = [0, 4, 0];
+ * const area = VectorCrossMagnitude(side1, side2); // 12 (area of rectangle)
+ * ```
  */
 export function VectorCrossMagnitude(a, b) {
     AssertVector3(a);
@@ -589,12 +608,12 @@ export function VectorCrossMagnitude(a, b) {
  * @returns Signed volume (positive = right-handed orientation)
  *
  * @example
-     * ```typescript
-     * const x = [1, 0, 0];
-     * const y = [0, 1, 0];
-     * const z = [0, 0, 1];
-     * const volume = Vector3ScalarTripleProduct(x, y, z); // 1 (unit cube)
-     * ```
+ * ```typescript
+ * const x = [1, 0, 0];
+ * const y = [0, 1, 0];
+ * const z = [0, 0, 1];
+ * const volume = Vector3ScalarTripleProduct(x, y, z); // 1 (unit cube)
+ * ```
  */
 export function Vector3ScalarTripleProduct(a, b, c) {
     AssertVector3(a);
@@ -614,12 +633,12 @@ export function Vector3ScalarTripleProduct(a, b, c) {
  * @returns Vector result of a × (b × c)
  *
  * @example
-     * ```typescript
-     * const a = [1, 0, 0];
-     * const b = [0, 1, 0];
-     * const c = [0, 0, 1];
-     * const result = Vector3TripleProduct(a, b, c); // [0, 0, 0]
-     * ```
+ * ```typescript
+ * const a = [1, 0, 0];
+ * const b = [0, 1, 0];
+ * const c = [0, 0, 1];
+ * const result = Vector3TripleProduct(a, b, c); // [0, 0, 0]
+ * ```
  */
 export function Vector3TripleProduct(a, b, c) {
     AssertVector3(a);
@@ -639,22 +658,22 @@ export function Vector3TripleProduct(a, b, c) {
  * @returns The reflected vector
  *
  * @example
-     * ```typescript
-     * const incoming = [1, -1, 0];
-     * const wall = [0, 1, 0]; // vertical wall normal
-     * const bounced = VectorReflect(incoming, wall); // [1, 1, 0]
-     * ```
+ * ```typescript
+ * const incoming = [1, -1, 0];
+ * const wall = [0, 1, 0]; // vertical wall normal
+ * const bounced = VectorReflect(incoming, wall); // [1, 1, 0]
+ * ```
  */
 export function VectorReflect(incident, normal) {
-    AssertVectors([incident, normal]);
+    AssertVector(incident);
+    AssertVector(normal);
+    AssertVectorSameSize([incident, normal]);
     const normalizedNormal = VectorNormalize(normal);
     const dot = VectorDot(incident, normalizedNormal);
     const result = [];
     for (let i = 0; i < incident.length; i++) {
         const iv = incident[i];
-        AssertVectorValue(iv, {});
         const nnv = normalizedNormal[i];
-        AssertVectorValue(nnv, {});
         result.push(iv - (2 * dot * nnv));
     }
     return result;
@@ -669,25 +688,18 @@ export function VectorReflect(incident, normal) {
  * @returns Vector with all components negated
  *
  * @example
-     * ```typescript
-     * const forward = [0, 0, 1];
-     * const backward = VectorNegate(forward); // [0, 0, -1]
-     * const velocity = [5, -3, 2];
-     * const opposite = VectorNegate(velocity); // [-5, 3, -2]
-     * ```
+ * ```typescript
+ * const forward = [0, 0, 1];
+ * const backward = VectorNegate(forward); // [0, 0, -1]
+ * const velocity = [5, -3, 2];
+ * const opposite = VectorNegate(velocity); // [-5, 3, -2]
+ * ```
  */
 export function VectorNegate(a) {
+    AssertVector(a);
     const result = [];
-    for (const av of a) {
-        AssertVectorValue(av, {});
-        // Special handling for zero to avoid negative zero (-0)
-        if (av === 0) {
-            result.push(0);
-        }
-        else {
-            result.push(-1 * av);
-        }
-    }
+    for (const av of a)
+        result.push(av === 0 ? 0 : -1 * av);
     return result;
 }
 /**
@@ -701,23 +713,22 @@ export function VectorNegate(a) {
  * @throws {VectorError} If any divisor component is zero
  *
  * @example
-     * ```typescript
-     * const velocity = [20, 10, 0];
-     * const halved = VectorDivide(velocity, 2); // [10, 5, 0] - scalar division
-     * const factors = [2, 5, 1];
-     * const componentWise = VectorDivide(velocity, factors); // [10, 2, 0] - component-wise
-     * ```
+ * ```typescript
+ * const velocity = [20, 10, 0];
+ * const halved = VectorDivide(velocity, 2); // [10, 5, 0] - scalar division
+ * const factors = [2, 5, 1];
+ * const componentWise = VectorDivide(velocity, factors); // [10, 2, 0] - component-wise
+ * ```
  */
 export function VectorDivide(a, b) {
+    AssertVector(a);
     const result = [];
     if (Array.isArray(b)) {
-        if (b.length !== a.length)
-            throw new VectorError('Vector Size Mismatch');
+        AssertVector(b);
+        AssertVectorSameSize([a, b]);
         for (let i = 0; i < a.length; i++) {
             const av = a[i];
-            AssertVectorValue(av, {});
             const bv = b[i];
-            AssertVectorValue(bv, {});
             if (bv === 0)
                 throw new VectorError(`Division by zero at component [${i}]`);
             const quot = av / bv;
@@ -728,7 +739,6 @@ export function VectorDivide(a, b) {
         if (b === 0)
             throw new VectorError('Division by zero scalar');
         for (const av of a) {
-            AssertVectorValue(av, {});
             const quot = av / b;
             result.push(Object.is(quot, -0) ? 0 : quot);
         }
@@ -747,90 +757,25 @@ export function VectorDivide(a, b) {
  * @returns New vector with each component clamped between min and max
  *
  * @example
-     * ```typescript
-     * const v = [5, -3, 12, 0];
-     * VectorClamp(v, 0, 10); // [5, 0, 10, 0] - scalar bounds
-     * const mins = [0, -5, 0, -1];
-     * const maxs = [10, 5, 8, 1];
-     * VectorClamp(v, mins, maxs); // [5, -3, 8, 0] - per-component bounds
-     * ```
+ * ```typescript
+ * const v = [5, -3, 12, 0];
+ * VectorClamp(v, 0, 10); // [5, 0, 10, 0] - scalar bounds
+ * const mins = [0, -5, 0, -1];
+ * const maxs = [10, 5, 8, 1];
+ * VectorClamp(v, mins, maxs); // [5, -3, 8, 0] - per-component bounds
+ * ```
  */
 export function VectorClamp(a, min, max) {
     AssertVector(a);
     const result = [];
     for (let i = 0; i < a.length; i++) {
         const av = a[i];
-        AssertVectorValue(av, {});
         const minV = Array.isArray(min) ? min[i] : min;
         const maxV = Array.isArray(max) ? max[i] : max;
         result.push(Math.max(minV, Math.min(av, maxV)));
     }
     return result;
 }
-/**
- * Limits the magnitude of a vector to a maximum value.
- * If the vector's magnitude exceeds the limit, scales it down proportionally.
- * Preserves direction while constraining magnitude.
- *
- * @template T - The vector type extending TVector
- * @param a - Vector to limit
- * @param max - Maximum allowed magnitude
- * @returns Vector with magnitude limited to max
- * @throws {VectorError} If max is negative
- *
- * @example
-     * ```typescript
-     * const velocity = [15, 20, 0]; // magnitude ≈ 25
-     * const limited = VectorLimit(velocity, 10); // magnitude = 10, same direction
-     * const small = [1, 1, 0]; // magnitude ≈ 1.414
-     * const unchanged = VectorLimit(small, 5); // unchanged since already under limit
-     * ```
-export function VectorGramSchmidt<T extends TAnyVector>(vectors: T[], normalize: boolean = false): TVectorResult<T>[] {
-    if (vectors.length === 0) throw new VectorError('GramSchmidt: Empty Vector Set');
-    const [firstVector] = vectors;
-    if (!firstVector) throw new VectorError('GramSchmidt: Undefined First Vector');
-    const dimension = firstVector.length;
-    for (const [i, vector] of vectors.entries()) {
-        AssertVector(vector);
-        if (vector.length !== dimension) throw new VectorError(`GramSchmidt: Vector at index ${i} has different dimension than first vector. Expected ${dimension}, got ${vector.length}`);
-        if (VectorIsZero(vector)) throw new VectorError(`GramSchmidt: Vector at index ${i} is a zero vector. Cannot orthogonalize zero vectors.`);
-    }
-
-    const result: TVectorResult<T>[] = [];
-
-    for (const [i, currentVector] of vectors.entries()) {
-        AssertVector(currentVector);
-
-        // Start with a clone of the current vector
-        let orthogonalVector = VectorClone(currentVector);
-
-        // Subtract projections of all previous vectors
-        for (let j = 0; j < i; j++) {
-            const previousVector = result[j];
-            AssertVector(previousVector);
-
-            // Both vectors have the same dimension, projection result is compatible
-            const vectorT = currentVector as unknown as T;
-            const prevT = previousVector as unknown as T;
-            const projection = VectorProject(vectorT, prevT);
-            orthogonalVector = VectorSubtract(orthogonalVector as unknown as T, projection as unknown as T);
-        }
-        
-        if (VectorIsZero(orthogonalVector as unknown as T)) {
-            throw new VectorError(`GramSchmidt: Vector at index ${i} is linearly dependent on previous vectors. Cannot orthogonalize linearly dependent vectors.`);
-        }
-        
-        if (normalize) {
-            orthogonalVector = VectorNormalize(orthogonalVector as unknown as T);
-        }
-        
-        result.push(orthogonalVector as TVectorResult<T>);
-    }
-
-    return result;
-}}
-}
-
 /**
  * Performs Gram-Schmidt orthogonalization on a set of vectors.
  * Converts a set of linearly independent vectors into an orthogonal (or orthonormal) set.
@@ -843,11 +788,11 @@ export function VectorGramSchmidt<T extends TAnyVector>(vectors: T[], normalize:
  * @throws {VectorError} If vectors are linearly dependent or invalid
  *
  * @example
-     * ```typescript
-     * const vectors = [[1, 1, 0], [1, 0, 1], [0, 1, 1]];
-     * const orthogonal = VectorGramSchmidt(vectors); // Orthogonal set
-     * const orthonormal = VectorGramSchmidt(vectors, true); // Orthonormal set
-     * ```
+ * ```typescript
+ * const vectors = [[1, 1, 0], [1, 0, 1], [0, 1, 1]];
+ * const orthogonal = VectorGramSchmidt(vectors); // Orthogonal set
+ * const orthonormal = VectorGramSchmidt(vectors, true); // Orthonormal set
+ * ```
  */
 export function VectorGramSchmidt(vectors, normalize = false) {
     if (vectors.length === 0)
@@ -860,21 +805,22 @@ export function VectorGramSchmidt(vectors, normalize = false) {
         AssertVector(vector);
         if (vector.length !== dimension)
             throw new VectorError(`GramSchmidt: Vector at index ${i} has different dimension than first vector. Expected ${dimension}, got ${vector.length}`);
-        if (VectorIsZero(vector))
-            throw new VectorError(`GramSchmidt: Vector at index ${i} is a zero vector. Cannot orthogonalize zero vectors.`);
+        AssertVectorNonZero(vector, `GramSchmidt vector at index ${i}`);
     }
     const result = [];
     for (const [i, currentVector] of vectors.entries()) {
         AssertVector(currentVector);
-        let orthogonalVector = VectorClone(currentVector);
+        // Start with a clone; TVectorResult<T> is dimensionally equivalent to T at runtime
+        const orthogonalBase = VectorClone(currentVector);
+        let orthogonalVector = orthogonalBase;
         for (let j = 0; j < i; j++) {
             const previousVector = result[j];
             AssertVector(previousVector);
+            // Project current onto previous: TVectorResult<T> shares dimensionality with T
             const projection = VectorProject(currentVector, previousVector);
             orthogonalVector = VectorSubtract(orthogonalVector, projection);
         }
-        if (VectorIsZero(orthogonalVector))
-            throw new VectorError(`GramSchmidt: Vector at index ${i} is linearly dependent on previous vectors. Cannot orthogonalize linearly dependent vectors.`);
+        AssertVectorNonZero(orthogonalVector, `GramSchmidt orthogonalized vector at index ${i}`);
         if (normalize)
             orthogonalVector = VectorNormalize(orthogonalVector);
         result.push(orthogonalVector);