@equinor/videx-linear-algebra 1.0.11 → 1.0.13

package/dist/index.d.ts

@@ -1,287 +1,287 @@
-/**
- * Interface for arrays and vector-like class structures.
- */
-export interface VectorLike {
-    /**
-     * Length of vector-like object.
-     */
-    length: number;
-    /**
-     * Numeric indices.
-     */
-    [index: number]: number;
-}
-/**
- * Copy the values of one vector to another without creating a new object.
- * @param source Source vector
- * @param target Target vector
- * @returns Target vector as a copy of source
- *
- * @example
- * copy([3, 4], [2, 2]); // Returns: [3, 4]
- */
-export declare function copy<T extends VectorLike>(source: VectorLike, target: T): T;
-/**
- * a + b
- *
- * Component-wise addition of two n-dimensional vectors.
- * Target is used to store the results.
- * @param a Left operand
- * @param b Right operand
- * @param target Target for storing the results (Default: a)
- * @return Resulting vector
- *
- * @example
- * add([1, 2], [3, 4], new Array(2)); // Returns: [4, 6]
- */
-export declare function add<T extends VectorLike>(a: T, b: VectorLike, target?: T): T;
-/**
- * v1 + ... + vM
- *
- * Component-wise addition of M n-dimensional vectors. Target is
- * used to store the results.
- * @param vectors Array of vectors with length n.
- * @param target Target for storing the results (Default: vectors[0])
- * @return Resulting vector
- *
- * @example
- * addAll([ [1, 2], [3, 4], [5, 6] ], new Array(2)); // Returns: [9, 12]
- */
-export declare function addAll<T extends VectorLike>(vectors: T[], target?: T): T;
-/**
- * a - b
- *
- * Component-wise subtraction of two n-dimensional vectors.
- * Target is used to store the results.
- * @param a Left operand
- * @param b Right operand
- * @param target Target for storing the results (Default: a)
- * @return Resulting vector
- *
- * @example
- * sub([4, 3], [2, 1], new Array(2)); // Returns: [2, 2]
- */
-export declare function sub<T extends VectorLike>(a: T, b: VectorLike, target?: T): T;
-/**
- * v1 - ... - vM
- *
- * Component-wise subtraction of M n-dimensional vectors from a. Target is
- * used to store the results.
- * @param a Vector with length n.
- * @param vectors Array of vectors with length n.
- * @param target Target for storing the results (Default: a)
- * @return Resulting vector
- *
- * @example
- * subAll([9, 9], [ [2, 3], [0, 2] ], new Array(2)); // Returns: [7, 4]
- */
-export declare function subAll<T extends VectorLike>(a: T, vectors: VectorLike[], target?: T): T;
-/**
- * Component-wise scaling of vector.
- * @param a Vector to scale
- * @param factor Scaling factor
- * @param target Target for storing the results (Default: a)
- * @return Resulting vector
- *
- * @example
- * scale([1, 2, 3], 2, new Array(3)); // Returns: [2, 4, 6]
- */
-export declare function scale<T extends VectorLike>(a: T, factor: number, target?: T): T;
-/**
- * Computes the sum of squares
- * @param a Target vector
- * @return Sum of squares
- *
- * @example
- * sumsqr([1, 2, 3]); // Returns: 14
- */
-export declare function sumsqr(a: VectorLike): number;
-/**
- * Computes the magnitude of a vector.
- * @param a Target vector
- * @return Magnitude of vector
- *
- * @example
- * magnitude([3, 4]); // Returns: 5
- */
-export declare function magnitude(a: VectorLike): number;
-/**
- * Normalizes a vector
- * @param a Vector to normalize
- * @param target Target for storing the results (Default: a)
- * @return Normalized vector
- *
- * @example
- * magnitude([0, 10, 0], new Array(3)); // Returns: [0, 1, 0]
- */
-export declare function normalize<T extends VectorLike>(a: T, target?: T): T;
-/**
- * Fill an array/vector with given value.
- * @param value Value to fill
- * @param target Target for storing the results
- * @returns Filled vector
- *
- * @example
- * fill(1, new Array(3)); // Returns: [1, 1, 1]
- */
-export declare function fill<T extends VectorLike>(value: number, target: T): T;
-/**
- * Get the vector going from b to a.
- * @param a Start coordinates
- * @param b End coordinates
- * @param target Target for storing the results (Default: a)
- * @return Vector going from a to b
- *
- * @example
- * dir([2, 1], [3, 0], new Array(2)); // Returns: [1, -1]
- */
-export declare function dir<T extends VectorLike>(a: T, b: VectorLike, target?: T): T;
-/**
- * Calculate the distance between two coordinates.
- * @param a Start coordinates
- * @param b End coordinates
- * @return Distance between coordinates
- *
- * @example
- * dist([1, 2], [4, 6]); // Returns: 5
- */
-export declare function dist(a: VectorLike, b: VectorLike): number;
-/**
- * Calculate the dot product between two vectors.
- * @param a Left operand
- * @param b Right operand
- * @return Dot product
- *
- * @example
- * dist([1, 2], [3, 4]); // Returns: 11
- */
-export declare function dot(a: VectorLike, b: VectorLike): number;
-/**
- * a × b
- *
- * Find cross product of vectors. Only defined for 3d vectors.
- * @param a Left operand (3d vector)
- * @param b Right operand (3d vector)
- * @param target Target for storing the results (Default: a)
- * @return Cross product of vectors
- *
- * @example
- * cross([1, 0, 0], [0, 1, 0]); // Returns: [0, 0, 1]
- */
-export declare function cross<T extends VectorLike>(a: T, b: VectorLike, target?: T): T;
-/**
- * a ∙ b × c
- *
- * Find triple product between three vectors. Only defined for 3d vectors.
- * @param a Left operand for dot product (3d vector)
- * @param b Left operand for cross product (3d vector)
- * @param c Right operand for cross product (3d vector)
- * @return Triple product of vectors
- *
- * @example
- * triple([1, 0, 0], [0, 1, 0], [0, 0, 1]); // Returns: 1
- */
-export declare function triple(a: VectorLike, b: VectorLike, c: VectorLike): number;
-/**
- * Clamp all values of a vector
- * @param a Values to clamp
- * @param min Minimum value (Default: 0)
- * @param max Maximum value (Default: 1)
- * @param target Target for storing the results (Default: a)
- * @return Vector with clamped values
- *
- * @example
- * clamp([0, 1, 2, 3], 1, 2, new Array(4)); // Returns: [1, 1, 2, 2]
- */
-export declare function clamp<T extends VectorLike>(a: T, min?: number, max?: number, target?: T): T;
-/**
- * GLSL step for all values of a vector
- * @param edges Edges of the step function
- * @param x Value used to generate the step function
- * @param target Target for storing the results (Default: edges)
- * @return results for each value in edges
- *
- * @example
- * step([0, 1, 2, 3], 1.5, new Array(4)); // Returns: [1, 1, 0, 0]
- */
-export declare function step<T extends VectorLike>(edges: T, x: number, target?: T): T;
-/**
- * Mix (interpolate) vectors (similar to glsl implementation).
- * @param a Vector to interpolate from
- * @param b Vector to interpolate to
- * @param t Interpolation parameter, 0 = a and 1 = b
- * @param target Target for storing the results (Default: a)
- * @return The interpolated vector
- *
- * @example
- * mix([1, 3], [3, 5], 0.5, new Array(2)); // Returns: [2, 4]
- */
-export declare function mix<T extends VectorLike>(a: T, b: VectorLike, t: number, target?: T): T;
-/**
- * Modify each component of a vector with given function.
- * @param a Vector to modify
- * @param modifier Function used to modify component
- * @param target Target for storing the results (Default: a)
- * @return Vector with modified values
- *
- * @example
- * modify([1.12, 1.55], Math.round, new Array(2)); // Returns: [1, 2]
- */
-export declare function modify<T extends VectorLike>(a: T, modifier: (_arg0: number, _arg1: number) => number, target?: T): T;
-/**
- * Returns true if all elements of a vector is zero, otherwise returns false.
- * @param a Target vector
- * @param epsilon Accepted deviation from 0.00 (Default: 0)
- * @returns Is target zero vector?
- *
- * @example
- * isZeroVector([0, 0.000023, 0], 0.001); // Returns: true
- */
-export declare function isZeroVector(a: VectorLike, epsilon?: number): boolean;
-/**
- * Reverses the components of a vector with an performance of O(n/2).
- * @param vector The vector to reverse
- * @returns Reversed vector
- *
- * @example
- * reverse([1, 2, 3]); // Returns: [3, 2, 1]
- */
-export declare function reverse<T extends VectorLike>(vector: T): T;
-/**
- * Flatten a collection of vectors to a single array.
- * @param vectors Array of vectors
- * @return Single array with all values
- *
- * @example
- * flatten([ [1, 2], [3, 4], [5, 6] ]); // Returns [1, 2, 3, 4, 5, 6]
- */
-export declare function flatten(vectors: VectorLike[]): number[];
-/**
- * Reshapes an array of values to a collection of vectors with given dimensions.
- * @param array Single array with all values
- * @param dimensions Dimensions per vector
- * @return Array of vectors with given dimensions
- *
- * @example
- * reshape([1, 2, 3, 4, 5, 6], 3); // Returns [ [1, 2, 3], [4, 5, 6] ]
- */
-export declare function reshape(array: number[], dimensions: number): number[][];
-/**
- * Determines if a point lies within a triangle in 2D space.
- * Inspired by: https://stackoverflow.com/a/9755252/5946596
- * @param {VectorLike} p - The point to check [x, y].
- * @param {VectorLike} a - Vertex A of the triangle [x, y].
- * @param {VectorLike} b - Vertex B of the triangle [x, y].
- * @param {VectorLike} c - Vertex C of the triangle [x, y].
- * @param {number} inwardAdjustment - Scales inward adjustment relative to distance for edge handling (default: 1e-6).
- * @returns {boolean} True if the point is strictly inside the triangle; otherwise, false.
- *
- * @example
- * isPointInTriangle([0.25, 0.25], [0, 0], [1, 0], [0, 1]); // Returns true
- */
-export declare function isPointInTriangle(p: VectorLike, a: VectorLike, b: VectorLike, c: VectorLike, inwardAdjustment?: number): boolean;
-/**
- * Wrapper function for isPointInTriangle which allows an array of vectors.
- * @returns {boolean} True if the point is strictly inside the triangle; otherwise, false.
- */
-export declare function isPointInTriangleArray(p: VectorLike, triangle: [VectorLike, VectorLike, VectorLike], tolerance?: number): boolean;
+/**
+ * Interface for arrays and vector-like class structures.
+ */
+export interface VectorLike {
+    /**
+     * Length of vector-like object.
+     */
+    length: number;
+    /**
+     * Numeric indices.
+     */
+    [index: number]: number;
+}
+/**
+ * Copy the values of one vector to another without creating a new object.
+ * @param source Source vector
+ * @param target Target vector
+ * @returns Target vector as a copy of source
+ *
+ * @example
+ * copy([3, 4], [2, 2]); // Returns: [3, 4]
+ */
+export declare function copy<T extends VectorLike>(source: VectorLike, target: T): T;
+/**
+ * a + b
+ *
+ * Component-wise addition of two n-dimensional vectors.
+ * Target is used to store the results.
+ * @param a Left operand
+ * @param b Right operand
+ * @param target Target for storing the results (Default: a)
+ * @return Resulting vector
+ *
+ * @example
+ * add([1, 2], [3, 4], new Array(2)); // Returns: [4, 6]
+ */
+export declare function add<T extends VectorLike>(a: T, b: VectorLike, target?: T): T;
+/**
+ * v1 + ... + vM
+ *
+ * Component-wise addition of M n-dimensional vectors. Target is
+ * used to store the results.
+ * @param vectors Array of vectors with length n.
+ * @param target Target for storing the results (Default: vectors[0])
+ * @return Resulting vector
+ *
+ * @example
+ * addAll([ [1, 2], [3, 4], [5, 6] ], new Array(2)); // Returns: [9, 12]
+ */
+export declare function addAll<T extends VectorLike>(vectors: T[], target?: T): T;
+/**
+ * a - b
+ *
+ * Component-wise subtraction of two n-dimensional vectors.
+ * Target is used to store the results.
+ * @param a Left operand
+ * @param b Right operand
+ * @param target Target for storing the results (Default: a)
+ * @return Resulting vector
+ *
+ * @example
+ * sub([4, 3], [2, 1], new Array(2)); // Returns: [2, 2]
+ */
+export declare function sub<T extends VectorLike>(a: T, b: VectorLike, target?: T): T;
+/**
+ * v1 - ... - vM
+ *
+ * Component-wise subtraction of M n-dimensional vectors from a. Target is
+ * used to store the results.
+ * @param a Vector with length n.
+ * @param vectors Array of vectors with length n.
+ * @param target Target for storing the results (Default: a)
+ * @return Resulting vector
+ *
+ * @example
+ * subAll([9, 9], [ [2, 3], [0, 2] ], new Array(2)); // Returns: [7, 4]
+ */
+export declare function subAll<T extends VectorLike>(a: T, vectors: VectorLike[], target?: T): T;
+/**
+ * Component-wise scaling of vector.
+ * @param a Vector to scale
+ * @param factor Scaling factor
+ * @param target Target for storing the results (Default: a)
+ * @return Resulting vector
+ *
+ * @example
+ * scale([1, 2, 3], 2, new Array(3)); // Returns: [2, 4, 6]
+ */
+export declare function scale<T extends VectorLike>(a: T, factor: number, target?: T): T;
+/**
+ * Computes the sum of squares
+ * @param a Target vector
+ * @return Sum of squares
+ *
+ * @example
+ * sumsqr([1, 2, 3]); // Returns: 14
+ */
+export declare function sumsqr(a: VectorLike): number;
+/**
+ * Computes the magnitude of a vector.
+ * @param a Target vector
+ * @return Magnitude of vector
+ *
+ * @example
+ * magnitude([3, 4]); // Returns: 5
+ */
+export declare function magnitude(a: VectorLike): number;
+/**
+ * Normalizes a vector
+ * @param a Vector to normalize
+ * @param target Target for storing the results (Default: a)
+ * @return Normalized vector
+ *
+ * @example
+ * magnitude([0, 10, 0], new Array(3)); // Returns: [0, 1, 0]
+ */
+export declare function normalize<T extends VectorLike>(a: T, target?: T): T;
+/**
+ * Fill an array/vector with given value.
+ * @param value Value to fill
+ * @param target Target for storing the results
+ * @returns Filled vector
+ *
+ * @example
+ * fill(1, new Array(3)); // Returns: [1, 1, 1]
+ */
+export declare function fill<T extends VectorLike>(value: number, target: T): T;
+/**
+ * Get the vector going from b to a.
+ * @param a Start coordinates
+ * @param b End coordinates
+ * @param target Target for storing the results (Default: a)
+ * @return Vector going from a to b
+ *
+ * @example
+ * dir([2, 1], [3, 0], new Array(2)); // Returns: [1, -1]
+ */
+export declare function dir<T extends VectorLike>(a: T, b: VectorLike, target?: T): T;
+/**
+ * Calculate the distance between two coordinates.
+ * @param a Start coordinates
+ * @param b End coordinates
+ * @return Distance between coordinates
+ *
+ * @example
+ * dist([1, 2], [4, 6]); // Returns: 5
+ */
+export declare function dist(a: VectorLike, b: VectorLike): number;
+/**
+ * Calculate the dot product between two vectors.
+ * @param a Left operand
+ * @param b Right operand
+ * @return Dot product
+ *
+ * @example
+ * dist([1, 2], [3, 4]); // Returns: 11
+ */
+export declare function dot(a: VectorLike, b: VectorLike): number;
+/**
+ * a × b
+ *
+ * Find cross product of vectors. Only defined for 3d vectors.
+ * @param a Left operand (3d vector)
+ * @param b Right operand (3d vector)
+ * @param target Target for storing the results (Default: a)
+ * @return Cross product of vectors
+ *
+ * @example
+ * cross([1, 0, 0], [0, 1, 0]); // Returns: [0, 0, 1]
+ */
+export declare function cross<T extends VectorLike>(a: T, b: VectorLike, target?: T): T;
+/**
+ * a ∙ b × c
+ *
+ * Find triple product between three vectors. Only defined for 3d vectors.
+ * @param a Left operand for dot product (3d vector)
+ * @param b Left operand for cross product (3d vector)
+ * @param c Right operand for cross product (3d vector)
+ * @return Triple product of vectors
+ *
+ * @example
+ * triple([1, 0, 0], [0, 1, 0], [0, 0, 1]); // Returns: 1
+ */
+export declare function triple(a: VectorLike, b: VectorLike, c: VectorLike): number;
+/**
+ * Clamp all values of a vector
+ * @param a Values to clamp
+ * @param min Minimum value (Default: 0)
+ * @param max Maximum value (Default: 1)
+ * @param target Target for storing the results (Default: a)
+ * @return Vector with clamped values
+ *
+ * @example
+ * clamp([0, 1, 2, 3], 1, 2, new Array(4)); // Returns: [1, 1, 2, 2]
+ */
+export declare function clamp<T extends VectorLike>(a: T, min?: number, max?: number, target?: T): T;
+/**
+ * GLSL step for all values of a vector
+ * @param edges Edges of the step function
+ * @param x Value used to generate the step function
+ * @param target Target for storing the results (Default: edges)
+ * @return results for each value in edges
+ *
+ * @example
+ * step([0, 1, 2, 3], 1.5, new Array(4)); // Returns: [1, 1, 0, 0]
+ */
+export declare function step<T extends VectorLike>(edges: T, x: number, target?: T): T;
+/**
+ * Mix (interpolate) vectors (similar to glsl implementation).
+ * @param a Vector to interpolate from
+ * @param b Vector to interpolate to
+ * @param t Interpolation parameter, 0 = a and 1 = b
+ * @param target Target for storing the results (Default: a)
+ * @return The interpolated vector
+ *
+ * @example
+ * mix([1, 3], [3, 5], 0.5, new Array(2)); // Returns: [2, 4]
+ */
+export declare function mix<T extends VectorLike>(a: T, b: VectorLike, t: number, target?: T): T;
+/**
+ * Modify each component of a vector with given function.
+ * @param a Vector to modify
+ * @param modifier Function used to modify component
+ * @param target Target for storing the results (Default: a)
+ * @return Vector with modified values
+ *
+ * @example
+ * modify([1.12, 1.55], Math.round, new Array(2)); // Returns: [1, 2]
+ */
+export declare function modify<T extends VectorLike>(a: T, modifier: (_arg0: number, _arg1: number) => number, target?: T): T;
+/**
+ * Returns true if all elements of a vector is zero, otherwise returns false.
+ * @param a Target vector
+ * @param epsilon Accepted deviation from 0.00 (Default: 0)
+ * @returns Is target zero vector?
+ *
+ * @example
+ * isZeroVector([0, 0.000023, 0], 0.001); // Returns: true
+ */
+export declare function isZeroVector(a: VectorLike, epsilon?: number): boolean;
+/**
+ * Reverses the components of a vector with an performance of O(n/2).
+ * @param vector The vector to reverse
+ * @returns Reversed vector
+ *
+ * @example
+ * reverse([1, 2, 3]); // Returns: [3, 2, 1]
+ */
+export declare function reverse<T extends VectorLike>(vector: T): T;
+/**
+ * Flatten a collection of vectors to a single array.
+ * @param vectors Array of vectors
+ * @return Single array with all values
+ *
+ * @example
+ * flatten([ [1, 2], [3, 4], [5, 6] ]); // Returns [1, 2, 3, 4, 5, 6]
+ */
+export declare function flatten(vectors: VectorLike[]): number[];
+/**
+ * Reshapes an array of values to a collection of vectors with given dimensions.
+ * @param array Single array with all values
+ * @param dimensions Dimensions per vector
+ * @return Array of vectors with given dimensions
+ *
+ * @example
+ * reshape([1, 2, 3, 4, 5, 6], 3); // Returns [ [1, 2, 3], [4, 5, 6] ]
+ */
+export declare function reshape(array: number[], dimensions: number): number[][];
+/**
+ * Determines if a point lies within a triangle in 2D space.
+ * Inspired by: https://stackoverflow.com/a/9755252/5946596
+ * @param {VectorLike} p - The point to check [x, y].
+ * @param {VectorLike} a - Vertex A of the triangle [x, y].
+ * @param {VectorLike} b - Vertex B of the triangle [x, y].
+ * @param {VectorLike} c - Vertex C of the triangle [x, y].
+ * @param {number} inwardAdjustment - Scales inward adjustment relative to distance for edge handling (default: 1e-6).
+ * @returns {boolean} True if the point is strictly inside the triangle; otherwise, false.
+ *
+ * @example
+ * isPointInTriangle([0.25, 0.25], [0, 0], [1, 0], [0, 1]); // Returns true
+ */
+export declare function isPointInTriangle(p: VectorLike, a: VectorLike, b: VectorLike, c: VectorLike, inwardAdjustment?: number): boolean;
+/**
+ * Wrapper function for isPointInTriangle which allows an array of vectors.
+ * @returns {boolean} True if the point is strictly inside the triangle; otherwise, false.
+ */
+export declare function isPointInTriangleArray(p: VectorLike, triangle: [VectorLike, VectorLike, VectorLike], tolerance?: number): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@equinor/videx-linear-algebra",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "description": "A library with linear algebra used by Videx.",
   "main": "dist/index.js",
   "module": "dist/index.esm.js",
@@ -40,25 +40,26 @@
   },
   "homepage": "https://github.com/equinor/videx-linear-algebra#readme",
   "devDependencies": {
-    "@equinor/videx-vector2": "^1.0.46",
-    "@types/jest": "^29.5.14",
-    "copyfiles": "^2.2.0",
-    "@rollup/plugin-node-resolve": "^15.2.3",
+    "@equinor/videx-vector2": "^1.0.47",
+    "@rollup/plugin-node-resolve": "^16.0.3",
     "@rollup/plugin-terser": "^0.4.4",
-    "@rollup/plugin-typescript": "^11.1.6",
-    "rollup": "^3.29.5",
-    "eslint": "^9.15.0",
-    "eslint-plugin-import": "^2.31.0",
-    "@typescript-eslint/eslint-plugin": "^8.13.0",
-    "@typescript-eslint/parser": "^8.13.0",
-    "jest": "^29.7.0",
-    "rimraf": "^3.0.1",
-    "ts-jest": "^29.1.0",
-    "typedoc": "^0.24.8",
-    "typescript": "^4.7.4"
+    "@rollup/plugin-typescript": "^12.3.0",
+    "@types/jest": "^30.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.46.3",
+    "@typescript-eslint/parser": "^8.46.3",
+    "copyfiles": "^2.2.0",
+    "eslint": "^9.39.1",
+    "eslint-plugin-import": "^2.32.0",
+    "jest": "^30.2.0",
+    "rimraf": "^6.1.0",
+    "rollup": "^4.52.5",
+    "ts-jest": "^29.4.5",
+    "tslib": "^2.8.1",
+    "typedoc": "^0.28.14",
+    "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@equinor/videx-math": "^1.0.12"
+    "@equinor/videx-math": "^1.1.3"
   },
   "jest": {
     "transform": {