@pawells/math-extended 1.1.1 → 2.0.0

package/build/matrices/transformations.d.ts

@@ -13,7 +13,7 @@
  * All matrices use homogeneous coordinates for consistent transformation composition.
  * 2D transformations use 3x3 matrices, 3D transformations use 4x4 matrices.
  */
-import { IMatrix3, IMatrix4 } from './types.js';
+import { TMatrix3, TMatrix4 } from './types.js';
 import { TVector2, TVector3 } from '../vectors/types.js';
 /**
  * Creates a 2D rotation matrix for rotating points around the origin.
@@ -30,20 +30,21 @@ import { TVector2, TVector3 } from '../vectors/types.js';
  * ```
  *
  * @param radians - Rotation angle in radians (positive = counterclockwise)
- * @returns {IMatrix3} A 3x3 rotation matrix for 2D transformations
+ * @returns {TMatrix3} A 3x3 rotation matrix for 2D transformations
  *
  * @throws {Error} If radians is not a finite number
  *
  * @example
- * ```typescript
- * // 90-degree counterclockwise rotation
- * const matrix = MatrixRotation2D(Math.PI / 2);
- *
- * // 45-degree clockwise rotation
- * const clockwise = MatrixRotation2D(-Math.PI / 4);
- * ```
+     * ```typescript
+     * ```typescript
+     * // 90-degree counterclockwise rotation
+     * const matrix = MatrixRotation2D(Math.PI / 2);
+     * // 45-degree clockwise rotation
+     * const clockwise = MatrixRotation2D(-Math.PI / 4);
+     * ```
+     * ```
  */
-export declare function MatrixRotation2D(radians: number): IMatrix3;
+export declare function MatrixRotation2D(radians: number): TMatrix3;
 /**
  * Creates a 3D roll rotation matrix (rotation around the X-axis).
  *
@@ -60,17 +61,19 @@ export declare function MatrixRotation2D(radians: number): IMatrix3;
  * ```
  *
  * @param radians - Roll angle in radians (positive = right-hand rule around X-axis)
- * @returns {IMatrix4} A 4x4 roll rotation matrix
+ * @returns {TMatrix4} A 4x4 roll rotation matrix
  *
  * @throws {Error} If radians is not a finite number
  *
  * @example
- * ```typescript
- * // 45-degree roll (banking left in aviation)
- * const rollMatrix = MatrixRotation3DRoll(Math.PI / 4);
- * ```
+     * ```typescript
+     * ```typescript
+     * // 45-degree roll (banking left in aviation)
+     * const rollMatrix = MatrixRotation3DRoll(Math.PI / 4);
+     * ```
+     * ```
  */
-export declare function MatrixRotation3DRoll(radians: number): IMatrix4;
+export declare function MatrixRotation3DRoll(radians: number): TMatrix4;
 /**
  * Creates a 3D pitch rotation matrix (rotation around the Y-axis).
  *
@@ -87,17 +90,19 @@ export declare function MatrixRotation3DRoll(radians: number): IMatrix4;
  * ```
  *
  * @param radians - Pitch angle in radians (positive = nose up in aviation)
- * @returns {IMatrix4} A 4x4 pitch rotation matrix
+ * @returns {TMatrix4} A 4x4 pitch rotation matrix
  *
  * @throws {Error} If radians is not a finite number
  *
  * @example
- * ```typescript
- * // 30-degree pitch up
- * const pitchMatrix = MatrixRotation3DPitch(Math.PI / 6);
- * ```
+     * ```typescript
+     * ```typescript
+     * // 30-degree pitch up
+     * const pitchMatrix = MatrixRotation3DPitch(Math.PI / 6);
+     * ```
+     * ```
  */
-export declare function MatrixRotation3DPitch(radians: number): IMatrix4;
+export declare function MatrixRotation3DPitch(radians: number): TMatrix4;
 /**
  * Creates a 3D yaw rotation matrix (rotation around the Z-axis).
  *
@@ -114,17 +119,19 @@ export declare function MatrixRotation3DPitch(radians: number): IMatrix4;
  * ```
  *
  * @param radians - Yaw angle in radians (positive = turn left in aviation)
- * @returns {IMatrix4} A 4x4 yaw rotation matrix
+ * @returns {TMatrix4} A 4x4 yaw rotation matrix
  *
  * @throws {Error} If radians is not a finite number
  *
  * @example
- * ```typescript
- * // 60-degree yaw left
- * const yawMatrix = MatrixRotation3DYaw(Math.PI / 3);
- * ```
+     * ```typescript
+     * ```typescript
+     * // 60-degree yaw left
+     * const yawMatrix = MatrixRotation3DYaw(Math.PI / 3);
+     * ```
+     * ```
  */
-export declare function MatrixRotation3DYaw(radians: number): IMatrix4;
+export declare function MatrixRotation3DYaw(radians: number): TMatrix4;
 /**
  * Creates a composite 3D rotation matrix from yaw, pitch, and roll components.
  *
@@ -139,22 +146,23 @@ export declare function MatrixRotation3DYaw(radians: number): IMatrix4;
  * @param roll - Roll angle in radians (X-axis rotation) or vector [roll, pitch, yaw]
  * @param pitch - Pitch angle in radians (Y-axis rotation, required if roll is number)
  * @param yaw - Yaw angle in radians (Z-axis rotation, required if roll is number)
- * @returns {IMatrix4} A 4x4 composite rotation matrix
+ * @returns {TMatrix4} A 4x4 composite rotation matrix
  *
  * @throws {Error} If any angle is not a finite number
  *
  * @example
- * ```typescript
- * // Using individual angles (banking, elevation, heading)
- * const rotationMatrix = MatrixRotation3D(0.1, 0.2, 0.3);
- *
- * // Using vector input
- * const eulerAngles: TVector3 = [0.1, 0.2, 0.3];
- * const rotationMatrix2 = MatrixRotation3D(eulerAngles);
- * ```
+     * ```typescript
+     * ```typescript
+     * // Using individual angles (banking, elevation, heading)
+     * const rotationMatrix = MatrixRotation3D(0.1, 0.2, 0.3);
+     * // Using vector input
+     * const eulerAngles: TVector3 = [0.1, 0.2, 0.3];
+     * const rotationMatrix2 = MatrixRotation3D(eulerAngles);
+     * ```
+     * ```
  */
-export declare function MatrixRotation3D(roll: number, pitch: number, yaw: number): IMatrix4;
-export declare function MatrixRotation3D(v: TVector3): IMatrix4;
+export declare function MatrixRotation3D(roll: number, pitch: number, yaw: number): TMatrix4;
+export declare function MatrixRotation3D(v: TVector3): TMatrix4;
 /**
  * Creates a composite 3D rotation matrix from Euler angles specified in degrees.
  *
@@ -167,22 +175,23 @@ export declare function MatrixRotation3D(v: TVector3): IMatrix4;
  * @param roll - Roll angle in degrees (X-axis rotation) or vector [roll, pitch, yaw]
  * @param pitch - Pitch angle in degrees (Y-axis rotation, required if roll is number)
  * @param yaw - Yaw angle in degrees (Z-axis rotation, required if roll is number)
- * @returns {IMatrix4} A 4x4 composite rotation matrix
+ * @returns {TMatrix4} A 4x4 composite rotation matrix
  *
  * @throws {Error} If any angle is not a finite number
  *
  * @example
- * ```typescript
- * // Using individual angles in degrees
- * const rotation = MatrixRotation3DEulerAngles(45, 30, 60);
- *
- * // Using vector input in degrees
- * const angles: TVector3 = [45, 30, 60];
- * const rotation2 = MatrixRotation3DEulerAngles(angles);
- * ```
+     * ```typescript
+     * ```typescript
+     * // Using individual angles in degrees
+     * const rotation = MatrixRotation3DEulerAngles(45, 30, 60);
+     * // Using vector input in degrees
+     * const angles: TVector3 = [45, 30, 60];
+     * const rotation2 = MatrixRotation3DEulerAngles(angles);
+     * ```
+     * ```
  */
-export declare function MatrixRotation3DEulerAngles(roll: number, pitch: number, yaw: number): IMatrix4;
-export declare function MatrixRotation3DEulerAngles(v: TVector3): IMatrix4;
+export declare function MatrixRotation3DEulerAngles(roll: number, pitch: number, yaw: number): TMatrix4;
+export declare function MatrixRotation3DEulerAngles(v: TVector3): TMatrix4;
 /**
  * Creates a 2D scale transformation matrix with flexible input options.
  *
@@ -204,29 +213,28 @@ export declare function MatrixRotation3DEulerAngles(v: TVector3): IMatrix4;
  *
  * @param scale - Uniform scale factor for both axes, OR X-axis scale factor
  * @param y - Y-axis scale factor (only for independent scaling)
- * @returns {IMatrix3} A 3x3 scale transformation matrix
+ * @returns {TMatrix3} A 3x3 scale transformation matrix
  *
  * @throws {Error} If any scale factor is not a finite number
  *
  * @example
- * ```typescript
- * // Uniform scaling (double size)
- * const uniform = MatrixScale2D(2.0);
- *
- * // Independent scaling (stretch horizontally, compress vertically)
- * const stretch = MatrixScale2D(2.0, 0.5);
- *
- * // Vector input
- * const scaleVector: TVector2 = [1.5, 0.8];
- * const vectorScale = MatrixScale2D(scaleVector);
- *
- * // Flip horizontally
- * const flip = MatrixScale2D(-1, 1);
- * ```
+     * ```typescript
+     * ```typescript
+     * // Uniform scaling (double size)
+     * const uniform = MatrixScale2D(2.0);
+     * // Independent scaling (stretch horizontally, compress vertically)
+     * const stretch = MatrixScale2D(2.0, 0.5);
+     * // Vector input
+     * const scaleVector: TVector2 = [1.5, 0.8];
+     * const vectorScale = MatrixScale2D(scaleVector);
+     * // Flip horizontally
+     * const flip = MatrixScale2D(-1, 1);
+     * ```
+     * ```
  */
-export declare function MatrixScale2D(scale: number): IMatrix3;
-export declare function MatrixScale2D(x: number, y: number): IMatrix3;
-export declare function MatrixScale2D(v: TVector2): IMatrix3;
+export declare function MatrixScale2D(scale: number): TMatrix3;
+export declare function MatrixScale2D(x: number, y: number): TMatrix3;
+export declare function MatrixScale2D(v: TVector2): TMatrix3;
 /**
  * Creates a 3D scale transformation matrix with flexible input options.
  *
@@ -250,29 +258,28 @@ export declare function MatrixScale2D(v: TVector2): IMatrix3;
  * @param scale - Uniform scale factor for all axes, OR X-axis scale factor
  * @param y - Y-axis scale factor (only for independent scaling)
  * @param z - Z-axis scale factor (only for independent scaling)
- * @returns {IMatrix4} A 4x4 scale transformation matrix
+ * @returns {TMatrix4} A 4x4 scale transformation matrix
  *
  * @throws {Error} If any scale factor is not a finite number
  *
  * @example
- * ```typescript
- * // Uniform scaling (triple size)
- * const uniform = MatrixScale3D(3.0);
- *
- * // Independent scaling (stretch, compress, normal)
- * const stretch = MatrixScale3D(2.0, 0.5, 1.0);
- *
- * // Vector input
- * const scaleVector: TVector3 = [1.5, 0.8, 2.0];
- * const vectorScale = MatrixScale3D(scaleVector);
- *
- * // Mirror across XY plane
- * const mirror = MatrixScale3D(1, 1, -1);
- * ```
+     * ```typescript
+     * ```typescript
+     * // Uniform scaling (triple size)
+     * const uniform = MatrixScale3D(3.0);
+     * // Independent scaling (stretch, compress, normal)
+     * const stretch = MatrixScale3D(2.0, 0.5, 1.0);
+     * // Vector input
+     * const scaleVector: TVector3 = [1.5, 0.8, 2.0];
+     * const vectorScale = MatrixScale3D(scaleVector);
+     * // Mirror across XY plane
+     * const mirror = MatrixScale3D(1, 1, -1);
+     * ```
+     * ```
  */
-export declare function MatrixScale3D(scale: number): IMatrix4;
-export declare function MatrixScale3D(x: number, y: number, z: number): IMatrix4;
-export declare function MatrixScale3D(v: TVector3): IMatrix4;
+export declare function MatrixScale3D(scale: number): TMatrix4;
+export declare function MatrixScale3D(x: number, y: number, z: number): TMatrix4;
+export declare function MatrixScale3D(v: TVector3): TMatrix4;
 /**
  * Creates a 2D translation transformation matrix.
  *
@@ -287,21 +294,22 @@ export declare function MatrixScale3D(v: TVector3): IMatrix4;
  * ```
  *
  * @param v - Translation vector [x, y] containing offset distances
- * @returns {IMatrix3} A 3x3 translation transformation matrix
+ * @returns {TMatrix3} A 3x3 translation transformation matrix
  *
  * @throws {Error} If the input is not a valid 2D vector
  *
  * @example
- * ```typescript
- * // Move 10 units right, 5 units up
- * const translation = MatrixTranslation2D(10, 5);
- *
- * // Using vector input
- * const offset: TVector2 = [10, 5];
- * const translation2 = MatrixTranslation2D(...offset);
- * ```
+     * ```typescript
+     * ```typescript
+     * // Move 10 units right, 5 units up
+     * const translation = MatrixTranslation2D(10, 5);
+     * // Using vector input
+     * const offset: TVector2 = [10, 5];
+     * const translation2 = MatrixTranslation2D(...offset);
+     * ```
+     * ```
  */
-export declare function MatrixTranslation2D(...v: TVector2): IMatrix3;
+export declare function MatrixTranslation2D(...v: TVector2): TMatrix3;
 /**
  * Creates a 3D translation transformation matrix with flexible input options.
  *
@@ -324,26 +332,26 @@ export declare function MatrixTranslation2D(...v: TVector2): IMatrix3;
  * @param translationOrX - Uniform translation distance for all axes, OR X-axis distance
  * @param y - Y-axis translation distance (only for independent translation)
  * @param z - Z-axis translation distance (only for independent translation)
- * @returns {IMatrix4} A 4x4 translation transformation matrix
+ * @returns {TMatrix4} A 4x4 translation transformation matrix
  *
  * @throws {Error} If any translation distance is not a finite number
  *
  * @example
- * ```typescript
- * // Uniform translation (move 5 units in all directions)
- * const uniform = MatrixTranslation3D(5.0);
- *
- * // Independent translation
- * const independent = MatrixTranslation3D(10, -5, 3);
- *
- * // Vector input
- * const offset: TVector3 = [10, -5, 3];
- * const vectorTranslation = MatrixTranslation3D(...offset);
- * ```
+     * ```typescript
+     * ```typescript
+     * // Uniform translation (move 5 units in all directions)
+     * const uniform = MatrixTranslation3D(5.0);
+     * // Independent translation
+     * const independent = MatrixTranslation3D(10, -5, 3);
+     * // Vector input
+     * const offset: TVector3 = [10, -5, 3];
+     * const vectorTranslation = MatrixTranslation3D(...offset);
+     * ```
+     * ```
  */
-export declare function MatrixTranslation3D(translation: number): IMatrix4;
-export declare function MatrixTranslation3D(x: number, y: number, z: number): IMatrix4;
-export declare function MatrixTranslation3D(v: TVector3): IMatrix4;
+export declare function MatrixTranslation3D(translation: number): TMatrix4;
+export declare function MatrixTranslation3D(x: number, y: number, z: number): TMatrix4;
+export declare function MatrixTranslation3D(v: TVector3): TMatrix4;
 /**
  * Transforms a 2D vector using a 3x3 transformation matrix with homogeneous coordinates.
  *
@@ -363,21 +371,22 @@ export declare function MatrixTranslation3D(v: TVector3): IMatrix4;
  * @throws {Error} If inputs are not valid vector/matrix types
  *
  * @example
- * ```typescript
- * // Rotate a point 90 degrees counterclockwise
- * const rotationMatrix = MatrixRotation2D(Math.PI / 2);
- * const point: TVector2 = [1, 0];
- * const rotatedPoint = MatrixTransform2D(point, rotationMatrix);
- * // Result: approximately [0, 1]
- *
- * // Chain multiple transformations
- * const scale = MatrixScale2D(2, 2);
- * const translate = MatrixTranslation2D(5, 3);
- * const combined = MatrixMultiply(translate, scale);
- * const transformedPoint = MatrixTransform2D(point, combined);
- * ```
+     * ```typescript
+     * ```typescript
+     * // Rotate a point 90 degrees counterclockwise
+     * const rotationMatrix = MatrixRotation2D(Math.PI / 2);
+     * const point: TVector2 = [1, 0];
+     * const rotatedPoint = MatrixTransform2D(point, rotationMatrix);
+     * // Result: approximately [0, 1]
+     * // Chain multiple transformations
+     * const scale = MatrixScale2D(2, 2);
+     * const translate = MatrixTranslation2D(5, 3);
+     * const combined = MatrixMultiply(translate, scale);
+     * const transformedPoint = MatrixTransform2D(point, combined);
+     * ```
+     * ```
  */
-export declare function MatrixTransform2D(vector: TVector2, matrix: IMatrix3): TVector2;
+export declare function MatrixTransform2D(vector: TVector2, matrix: TMatrix3): TVector2;
 /**
  * Transforms a 3D vector using a 4x4 transformation matrix with homogeneous coordinates.
  * Converts to homogeneous coordinates, applies transformation, then converts back to 3D.
@@ -389,13 +398,15 @@ export declare function MatrixTransform2D(vector: TVector2, matrix: IMatrix3): T
  * @throws {Error} If the w component is near zero (degenerate transformation).
  *
  * @example
- * ```typescript
- * const rotationMatrix = MatrixRotation3DYaw(Math.PI / 4);
- * const point: TVector3 = [1, 0, 0];
- * const rotatedPoint = MatrixTransform3D(point, rotationMatrix);
- * ```
+     * ```typescript
+     * ```typescript
+     * const rotationMatrix = MatrixRotation3DYaw(Math.PI / 4);
+     * const point: TVector3 = [1, 0, 0];
+     * const rotatedPoint = MatrixTransform3D(point, rotationMatrix);
+     * ```
+     * ```
  */
-export declare function MatrixTransform3D(vector: TVector3, transform: IMatrix4): TVector3;
+export declare function MatrixTransform3D(vector: TVector3, transform: TMatrix4): TVector3;
 /**
  * Transforms a 3D direction vector using a 3x3 matrix, ignoring translation components.
  * Designed for direction vectors (normals, velocities) where translation should not apply.
@@ -405,13 +416,15 @@ export declare function MatrixTransform3D(vector: TVector3, transform: IMatrix4)
  * @returns {TVector3} The transformed direction vector.
  *
  * @example
- * ```typescript
- * const rotationMatrix = MatrixRotation3DYaw(Math.PI / 4);
- * const normal: TVector3 = [0, 0, 1];
- * const rotatedNormal = MatrixDirection3D(normal, rotationMatrix);
- * ```
+     * ```typescript
+     * ```typescript
+     * const rotationMatrix = MatrixRotation3DYaw(Math.PI / 4);
+     * const normal: TVector3 = [0, 0, 1];
+     * const rotatedNormal = MatrixDirection3D(normal, rotationMatrix);
+     * ```
+     * ```
  */
-export declare function MatrixDirection3D(direction: TVector3, matrix: IMatrix3): TVector3;
+export declare function MatrixDirection3D(direction: TVector3, matrix: TMatrix3): TVector3;
 /**
  * Creates a view matrix for positioning and orienting a 3D camera.
  * Transforms world coordinates to camera coordinates using the "look-at" approach.
@@ -419,18 +432,20 @@ export declare function MatrixDirection3D(direction: TVector3, matrix: IMatrix3)
  * @param eye - Camera position in world coordinates.
  * @param target - Point the camera is looking at.
  * @param up - Up direction vector (usually [0, 1, 0]).
- * @returns {IMatrix4} A 4x4 view transformation matrix.
+ * @returns {TMatrix4} A 4x4 view transformation matrix.
  *
  * @example
- * ```typescript
- * const viewMatrix = MatrixView(
- *   [10, 5, 10],  // Camera position
- *   [0, 0, 0],    // Looking at origin
- *   [0, 1, 0]     // Y-axis is up
- * );
- * ```
+     * ```typescript
+     * ```typescript
+     * const viewMatrix = MatrixView(
+     *   [10, 5, 10],  // Camera position
+     *   [0, 0, 0],    // Looking at origin
+     *   [0, 1, 0]     // Y-axis is up
+     * );
+     * ```
+     * ```
  */
-export declare function MatrixView(eye: TVector3, target: TVector3, up: TVector3): IMatrix4;
+export declare function MatrixView(eye: TVector3, target: TVector3, up: TVector3): TMatrix4;
 /**
  * Creates a perspective projection matrix for 3D rendering.
  * Transforms 3D view coordinates to normalized device coordinates with perspective effect.
@@ -439,21 +454,23 @@ export declare function MatrixView(eye: TVector3, target: TVector3, up: TVector3
  * @param aspect - Aspect ratio of the viewport (width/height).
  * @param near - Distance to near clipping plane (must be positive).
  * @param far - Distance to far clipping plane (must be > near).
- * @returns {IMatrix4} A 4x4 perspective projection matrix.
+ * @returns {TMatrix4} A 4x4 perspective projection matrix.
  *
  * @throws {Error} If parameters are invalid.
  *
  * @example
- * ```typescript
- * const perspectiveMatrix = MatrixPerspective(
- *   Math.PI / 4,  // 45-degree field of view
- *   16 / 9,       // Widescreen aspect ratio
- *   0.1,          // Near plane
- *   1000          // Far plane
- * );
- * ```
+     * ```typescript
+     * ```typescript
+     * const perspectiveMatrix = MatrixPerspective(
+     *   Math.PI / 4,  // 45-degree field of view
+     *   16 / 9,       // Widescreen aspect ratio
+     *   0.1,          // Near plane
+     *   1000          // Far plane
+     * );
+     * ```
+     * ```
  */
-export declare function MatrixPerspective(fovY: number, aspect: number, near: number, far: number): IMatrix4;
+export declare function MatrixPerspective(fovY: number, aspect: number, near: number, far: number): TMatrix4;
 /**
  * Creates an orthographic projection matrix for 3D rendering.
  * Maps a rectangular box to the unit cube [-1, 1]³ without perspective distortion.
@@ -464,18 +481,20 @@ export declare function MatrixPerspective(fovY: number, aspect: number, near: nu
  * @param top - Top boundary of the orthographic volume.
  * @param near - Near clipping plane distance.
  * @param far - Far clipping plane distance.
- * @returns {IMatrix4} A 4x4 orthographic projection matrix.
+ * @returns {TMatrix4} A 4x4 orthographic projection matrix.
  *
  * @throws {Error} If any opposing boundaries are equal.
  *
  * @example
- * ```typescript
- * const orthoMatrix = MatrixOrthographic(
- *   -10, 10,   // Left/Right: 20 units wide
- *   -7.5, 7.5, // Bottom/Top: 15 units tall
- *   -100, 100  // Near/Far: 200 units deep
- * );
- * ```
+     * ```typescript
+     * ```typescript
+     * const orthoMatrix = MatrixOrthographic(
+     *   -10, 10,   // Left/Right: 20 units wide
+     *   -7.5, 7.5, // Bottom/Top: 15 units tall
+     *   -100, 100  // Near/Far: 200 units deep
+     * );
+     * ```
+     * ```
  */
-export declare function MatrixOrthographic(left: number, right: number, bottom: number, top: number, near: number, far: number): IMatrix4;
+export declare function MatrixOrthographic(left: number, right: number, bottom: number, top: number, near: number, far: number): TMatrix4;
 //# sourceMappingURL=transformations.d.ts.map

package/build/matrices/transformations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transformations.d.ts","sourceRoot":"","sources":["../../src/matrices/transformations.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"transformations.d.ts","sourceRoot":"","sources":["../../src/matrices/transformations.ts"],"names":[],"mappings":"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"}