@danielsimonjr/mathts-functions 0.2.3 → 0.2.5

package/dist/typed/distributions.d.ts

@@ -0,0 +1,247 @@
+/**
+ * Typed Probability Distribution Functions
+ *
+ * Probability density/mass functions and information-theoretic measures
+ * using typed-function for runtime dispatch.
+ *
+ * Each PDF/PMF/CDF has a `Float64Array` overload that evaluates the
+ * distribution across a whole sample array, parallelizing large inputs via
+ * the worker pool.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Normal (Gaussian) probability density function.
+ *
+ * PDF(x; mu, sigma) = (1 / (sigma * sqrt(2*pi))) * exp(-(x - mu)^2 / (2*sigma^2))
+ *
+ * @param x - Value (or Float64Array of values) at which to evaluate
+ * @param mu - Mean (default 0)
+ * @param sigma - Standard deviation (default 1, must be positive)
+ * @returns Probability density at x
+ *
+ * @example
+ * normalPDF(0)       // ~0.3989 (standard normal)
+ * normalPDF(1, 0, 2) // ~0.1760
+ * normalPDF(new Float64Array([0, 1, 2])) // densities for each sample
+ */
+export declare const normalPDF: import("typed-function").TypedFunction;
+/**
+ * Normal (Gaussian) cumulative distribution function.
+ *
+ * CDF(x; mu, sigma) = 0.5 * (1 + erf((x - mu) / (sigma * sqrt(2))))
+ *
+ * @param x - Value (or Float64Array of values) at which to evaluate
+ * @param mu - Mean (default 0)
+ * @param sigma - Standard deviation (default 1, must be positive)
+ * @returns Cumulative probability P(X <= x)
+ *
+ * @example
+ * normalCDF(0)    // 0.5 (standard normal)
+ * normalCDF(1.96) // ~0.975
+ */
+export declare const normalCDF: import("typed-function").TypedFunction;
+/**
+ * Exponential probability density function.
+ *
+ * PDF(x; lambda) = lambda * exp(-lambda * x) for x >= 0.
+ *
+ * @param x - Value (or Float64Array of values) at which to evaluate
+ * @param lambda - Rate parameter (positive)
+ * @returns Probability density at x
+ *
+ * @example
+ * exponentialPDF(1, 1) // ~0.3679
+ */
+export declare const exponentialPDF: import("typed-function").TypedFunction;
+/**
+ * Exponential cumulative distribution function.
+ *
+ * CDF(x; lambda) = 1 - exp(-lambda * x) for x >= 0.
+ *
+ * @param x - Value (or Float64Array of values) at which to evaluate
+ * @param lambda - Rate parameter (positive)
+ * @returns Cumulative probability P(X <= x)
+ *
+ * @example
+ * exponentialCDF(1, 1) // ~0.6321
+ */
+export declare const exponentialCDF: import("typed-function").TypedFunction;
+/**
+ * Poisson probability mass function.
+ *
+ * PMF(k; lambda) = e^(-lambda) * lambda^k / k!
+ *
+ * Computed in log-space to avoid overflow for large k or lambda.
+ *
+ * @param k - Number of events (or Float64Array of counts)
+ * @param lambda - Expected number of events (positive)
+ * @returns Probability of exactly k events
+ *
+ * @example
+ * poissonPMF(3, 2.5) // ~0.2138
+ */
+export declare const poissonPMF: import("typed-function").TypedFunction;
+/**
+ * Binomial probability mass function.
+ *
+ * PMF(k; n, p) = C(n, k) * p^k * (1-p)^(n-k)
+ *
+ * Computed in log-space to avoid overflow.
+ *
+ * @param k - Number of successes (or Float64Array of counts)
+ * @param n - Number of trials (positive integer)
+ * @param p - Probability of success (0 <= p <= 1)
+ * @returns Probability of exactly k successes
+ *
+ * @example
+ * binomialPMF(3, 10, 0.5) // ~0.1172
+ */
+export declare const binomialPMF: import("typed-function").TypedFunction;
+/**
+ * Geometric probability mass function.
+ *
+ * PMF(k; p) = (1-p)^(k-1) * p for k = 1, 2, 3, ...
+ *
+ * @param k - Trial number of first success (or Float64Array of counts)
+ * @param p - Probability of success (0 < p <= 1)
+ * @returns Probability that first success occurs on trial k
+ *
+ * @example
+ * geometricPMF(3, 0.5) // 0.125
+ */
+export declare const geometricPMF: import("typed-function").TypedFunction;
+/**
+ * Bernoulli probability mass function.
+ *
+ * PMF(k; p) = p if k = 1, (1 - p) if k = 0.
+ *
+ * @param k - Outcome (0 or 1, or Float64Array of outcomes)
+ * @param p - Probability of success (0 <= p <= 1)
+ * @returns Probability of outcome k
+ *
+ * @example
+ * bernoulliPMF(1, 0.7) // 0.7
+ */
+export declare const bernoulliPMF: import("typed-function").TypedFunction;
+/**
+ * Shannon entropy of a discrete probability distribution.
+ *
+ * H(P) = -sum(p_i * log2(p_i)) for all p_i > 0.
+ *
+ * @param probs - Array of probabilities (should sum to 1)
+ * @returns Entropy in bits
+ *
+ * @example
+ * entropy([0.5, 0.5])               // 1.0 (maximum for 2 outcomes)
+ * entropy([0.25, 0.25, 0.25, 0.25]) // 2.0
+ */
+export declare const entropy: import("typed-function").TypedFunction;
+/**
+ * Jensen-Shannon divergence between two probability distributions.
+ *
+ * JSD(P || Q) = 0.5 * KL(P || M) + 0.5 * KL(Q || M) where M = 0.5*(P + Q).
+ *
+ * Always non-negative and symmetric. Returns value in bits (base 2).
+ *
+ * @param p - First probability distribution
+ * @param q - Second probability distribution (same length as p)
+ * @returns Jensen-Shannon divergence in bits
+ *
+ * @example
+ * jsDivergence([0.5, 0.5], [0.5, 0.5]) // 0 (identical)
+ * jsDivergence([1, 0], [0, 1])         // 1.0 (maximum for 2 bins)
+ */
+export declare const jsDivergence: import("typed-function").TypedFunction;
+/**
+ * Beta probability density function.
+ *
+ * f(x; α, β) = x^(α-1) · (1-x)^(β-1) / B(α, β),  x ∈ (0, 1).
+ *
+ * When x is a Float64Array of length ≥ WASM_SPECIAL_THRESHOLD (1024),
+ * lgamma is computed in a single vectorised WASM dispatch over the array
+ * instead of per-element scalar calls.
+ *
+ * @param x      - Sample value(s) in (0, 1)
+ * @param alpha  - Shape parameter α > 0
+ * @param beta_  - Shape parameter β > 0
+ * @returns PDF value(s)
+ *
+ * @example
+ * betaPDF(0.5, 2, 2) // 1.5
+ */
+export declare const betaPDF: import("typed-function").TypedFunction;
+/**
+ * Gamma probability density function.
+ *
+ * f(x; k, θ) = x^(k-1) · exp(−x/θ) / (Γ(k) · θ^k),  x > 0.
+ *
+ * When x is a Float64Array of length ≥ WASM_SPECIAL_THRESHOLD (1024),
+ * lgamma(shape) is pre-computed once (scalar), sparing per-element Γ calls.
+ *
+ * @param x     - Sample value(s)
+ * @param shape - Shape parameter k > 0
+ * @param scale - Scale parameter θ > 0
+ * @returns PDF value(s)
+ *
+ * @example
+ * gammaPDF(1, 1, 1) // ~0.3679 (Exponential(1) at x=1)
+ */
+export declare const gammaPDF: import("typed-function").TypedFunction;
+/**
+ * Student-t probability density function.
+ *
+ * f(x; ν) = Γ((ν+1)/2) / (√(νπ)·Γ(ν/2)) · (1 + x²/ν)^(−(ν+1)/2).
+ *
+ * When x is a Float64Array of length ≥ WASM_SPECIAL_THRESHOLD (1024),
+ * the two lgamma calls for the normalisation constant are performed once
+ * on the main thread; only the per-element `(1 + x²/ν)` power is looped.
+ *
+ * @param x  - Sample value(s)
+ * @param df - Degrees of freedom ν > 0
+ * @returns PDF value(s)
+ *
+ * @example
+ * studentTPDF(0, 5) // ~0.3796 (peak of t(5))
+ */
+export declare const studentTPDF: import("typed-function").TypedFunction;
+/**
+ * Noncentral chi-squared probability density function.
+ *
+ * f(x; k, λ) via Poisson-mixture of central chi-squared densities.
+ *
+ * When x is a Float64Array of length ≥ WASM_SPECIAL_THRESHOLD (1024),
+ * lgamma in the inner Bessel sum is vectorised via `lgammaDispatch` over
+ * the unique m values needed; for the outer product loop each element is
+ * still evaluated independently (the lgamma argument depends on both j and
+ * the fixed df, not on x[i], so the per-element work remains O(terms)).
+ *
+ * @param x   - Sample value(s)
+ * @param df  - Degrees of freedom k > 0
+ * @param ncp - Non-centrality parameter λ ≥ 0
+ * @returns PDF value(s)
+ *
+ * @example
+ * noncentralChi2PDF(1, 2, 1) // ~0.2220
+ */
+export declare const noncentralChi2PDF: import("typed-function").TypedFunction;
+/**
+ * All typed probability distribution functions.
+ */
+export declare const typedDistributions: {
+    normalPDF: import("typed-function").TypedFunction;
+    normalCDF: import("typed-function").TypedFunction;
+    exponentialPDF: import("typed-function").TypedFunction;
+    exponentialCDF: import("typed-function").TypedFunction;
+    poissonPMF: import("typed-function").TypedFunction;
+    binomialPMF: import("typed-function").TypedFunction;
+    geometricPMF: import("typed-function").TypedFunction;
+    bernoulliPMF: import("typed-function").TypedFunction;
+    entropy: import("typed-function").TypedFunction;
+    jsDivergence: import("typed-function").TypedFunction;
+    betaPDF: import("typed-function").TypedFunction;
+    gammaPDF: import("typed-function").TypedFunction;
+    studentTPDF: import("typed-function").TypedFunction;
+    noncentralChi2PDF: import("typed-function").TypedFunction;
+};
+//# sourceMappingURL=distributions.d.ts.map

package/dist/typed/distributions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"distributions.d.ts","sourceRoot":"","sources":["../../src/typed/distributions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AA+LH;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,SAAS,wCAepB,CAAC;AAEH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,SAAS,wCAepB,CAAC;AAMH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,cAAc,wCAQzB,CAAC;AAEH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,cAAc,wCAQzB,CAAC;AAMH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,UAAU,wCAQrB,CAAC;AAMH;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,WAAW,wCAYtB,CAAC;AAMH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,YAAY,wCAQvB,CAAC;AAMH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,YAAY,wCAQvB,CAAC;AAMH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,OAAO,wCAWlB,CAAC;AAMH;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,YAAY,wCAcvB,CAAC;AAmBH;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,OAAO,wCAkClB,CAAC;AAmBH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,QAAQ,wCAwBnB,CAAC;AAkBH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,WAAW,wCAatB,CAAC;AAyCH;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,iBAAiB,wCA4C5B,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;CAe9B,CAAC"}

package/dist/typed/geometry.d.ts

@@ -0,0 +1,329 @@
+/**
+ * Typed Geometry Functions
+ *
+ * Pure TypeScript implementations of geometric operations including
+ * angles, products, areas, spatial queries, transforms, distances,
+ * and intersections. Includes optional WASM acceleration for
+ * Delaunay triangulation, Voronoi diagrams, and k-d tree operations.
+ *
+ * @packageDocumentation
+ */
+type f64 = number;
+type i32 = number;
+/**
+ * Compute the angle (in radians) between two 2D vectors.
+ *
+ * @param v1 - First 2D vector
+ * @param v2 - Second 2D vector
+ * @returns Angle in radians [0, pi]
+ */
+export declare function angle2D(v1: number[], v2: number[]): f64;
+/**
+ * Compute the angle (in radians) between two 3D vectors.
+ *
+ * @param v1 - First 3D vector
+ * @param v2 - Second 3D vector
+ * @returns Angle in radians [0, pi]
+ */
+export declare function angle3D(v1: number[], v2: number[]): f64;
+/**
+ * Compute the cross product of two 3D vectors.
+ *
+ * @param a - First 3D vector
+ * @param b - Second 3D vector
+ * @returns Cross product vector
+ */
+export declare function cross3D(a: number[], b: number[]): number[];
+/**
+ * Compute the dot product of two 3D vectors.
+ *
+ * @param a - First 3D vector
+ * @param b - Second 3D vector
+ * @returns Dot product scalar
+ */
+export declare function dot3D(a: number[], b: number[]): f64;
+/**
+ * Compute the area of a triangle given three 2D vertices using the shoelace formula.
+ *
+ * @param a - First vertex [x, y]
+ * @param b - Second vertex [x, y]
+ * @param c - Third vertex [x, y]
+ * @returns Unsigned area of the triangle
+ */
+export declare function triangleArea(a: number[], b: number[], c: number[]): f64;
+/**
+ * Compute the area of a simple polygon given its vertices (2D) using the shoelace formula.
+ * Vertices should be ordered (clockwise or counter-clockwise).
+ *
+ * @param vertices - Array of [x, y] vertices
+ * @returns Unsigned area of the polygon
+ */
+export declare function polygonArea(vertices: number[][]): f64;
+/**
+ * Compute the convex hull of a set of 2D points using Andrew's monotone chain algorithm.
+ * Returns vertices in counter-clockwise order.
+ *
+ * @param points - Array of [x, y] points
+ * @returns Convex hull vertices in CCW order
+ */
+export declare function convexHull(points: number[][]): number[][];
+/**
+ * Determine if a 2D point lies inside a polygon using the ray casting algorithm.
+ *
+ * @param point - The test point [x, y]
+ * @param polygon - Array of polygon vertices [x, y]
+ * @returns true if point is inside the polygon
+ */
+export declare function pointInPolygon(point: number[], polygon: number[][]): boolean;
+/**
+ * Rotate a 2D vector by a given angle (radians).
+ *
+ * @param v - The 2D vector [x, y]
+ * @param angle - Rotation angle in radians
+ * @returns Rotated vector
+ */
+export declare function rotateVector2D(v: number[], angle: f64): number[];
+/**
+ * Rotate a 3D vector around an arbitrary axis by a given angle (Rodrigues' formula).
+ *
+ * @param v - The 3D vector
+ * @param axis - The rotation axis (will be normalized)
+ * @param angle - Rotation angle in radians
+ * @returns Rotated vector
+ */
+export declare function rotateVector3D(v: number[], axis: number[], angle: f64): number[];
+/**
+ * Reflect a vector across a plane defined by its normal.
+ *
+ * @param v - The vector to reflect
+ * @param normal - The normal of the reflection plane (will be normalized)
+ * @returns Reflected vector
+ */
+export declare function reflectVector(v: number[], normal: number[]): number[];
+/**
+ * Project vector v onto vector onto.
+ *
+ * @param v - The vector to project
+ * @param onto - The vector to project onto
+ * @returns Projected vector
+ */
+export declare function projectVector(v: number[], onto: number[]): number[];
+/**
+ * Euclidean distance between two 2D points.
+ */
+export declare function distance2D(a: number[], b: number[]): f64;
+/**
+ * Euclidean distance between two 3D points.
+ */
+export declare function distance3D(a: number[], b: number[]): f64;
+/**
+ * Euclidean distance between two N-dimensional points.
+ */
+export declare function distanceND(a: number[], b: number[]): f64;
+/**
+ * Shortest distance from a point to a line segment in 2D.
+ *
+ * @param point - The point [x, y]
+ * @param lineStart - Start of the line segment [x, y]
+ * @param lineEnd - End of the line segment [x, y]
+ * @returns Distance from point to the line segment
+ */
+export declare function distancePointToLine2D(point: number[], lineStart: number[], lineEnd: number[]): f64;
+/**
+ * Find the intersection point of two infinite 2D lines.
+ * Each line is defined by a point and a direction vector.
+ *
+ * @param p1 - Point on line 1
+ * @param d1 - Direction of line 1
+ * @param p2 - Point on line 2
+ * @param d2 - Direction of line 2
+ * @returns Intersection point [x, y] or null if parallel
+ */
+export declare function intersectLines2D(p1: number[], d1: number[], p2: number[], d2: number[]): number[] | null;
+/**
+ * Find the intersection point of two 2D line segments.
+ *
+ * @param a1 - Start of segment A
+ * @param a2 - End of segment A
+ * @param b1 - Start of segment B
+ * @param b2 - End of segment B
+ * @returns Intersection point [x, y] or null if segments do not intersect
+ */
+export declare function intersectSegments2D(a1: number[], a2: number[], b1: number[], b2: number[]): number[] | null;
+/**
+ * Shape type for area calculation.
+ */
+export type Shape = {
+    type: 'circle';
+    radius: f64;
+} | {
+    type: 'triangle';
+    vertices: [number[], number[], number[]];
+} | {
+    type: 'polygon';
+    vertices: number[][];
+} | {
+    type: 'rectangle';
+    width: f64;
+    height: f64;
+};
+/**
+ * Compute the area of a shape.
+ *
+ * @param shape - Shape descriptor
+ * @returns Area
+ *
+ * @example
+ * area({ type: 'circle', radius: 1 }) // => pi
+ * area({ type: 'rectangle', width: 3, height: 4 }) // => 12
+ */
+export declare function area(shape: Shape): f64;
+/**
+ * Compute the centroid of a polygon.
+ *
+ * @param vertices - Array of [x, y] vertices in order
+ * @returns Centroid [x, y]
+ *
+ * @example
+ * centroid([[0,0], [4,0], [4,3], [0,3]]) // => [2, 1.5]
+ */
+export declare function centroid(vertices: number[][]): number[];
+/**
+ * Convert between coordinate systems.
+ *
+ * @param point - Input coordinates
+ * @param from - Source system: 'cartesian' | 'polar' | 'spherical' | 'cylindrical'
+ * @param to - Target system
+ * @returns Converted coordinates
+ */
+export declare function coordinateTransform(point: number[], from: 'cartesian' | 'polar' | 'spherical' | 'cylindrical', to: 'cartesian' | 'polar' | 'spherical' | 'cylindrical'): number[];
+/**
+ * Perimeter of a polygon.
+ *
+ * @param vertices - Array of [x, y] vertices in order
+ * @returns Perimeter length
+ */
+export declare function polygonPerimeter(vertices: number[][]): f64;
+/**
+ * Manhattan (L1) distance between two points.
+ *
+ * @param a - First point
+ * @param b - Second point
+ * @returns L1 distance
+ */
+export declare function manhattanDistance(a: number[], b: number[]): f64;
+/**
+ * Chebyshev (L-infinity) distance between two points.
+ *
+ * @param a - First point
+ * @param b - Second point
+ * @returns L-infinity distance
+ */
+export declare function chebyshevDistance(a: number[], b: number[]): f64;
+/**
+ * Minkowski (Lp) distance between two points.
+ *
+ * @param a - First point
+ * @param b - Second point
+ * @param p - Distance order (p >= 1)
+ * @returns Lp distance
+ */
+export declare function minkowskiDistance(a: number[], b: number[], p: f64): f64;
+/**
+ * Delaunay triangulation using Bowyer-Watson algorithm.
+ *
+ * @param points - Array of [x, y] points
+ * @returns Array of triangles, each an array of 3 point indices
+ */
+export declare function delaunayTriangulation(points: number[][]): number[][];
+/**
+ * Voronoi diagram from Delaunay triangulation (dual graph).
+ * Returns Voronoi vertices and regions.
+ *
+ * @param points - Array of [x, y] points
+ * @param bounds - Clipping bounds [minX, minY, maxX, maxY]
+ * @returns { vertices: number[][], regions: number[][] }
+ */
+export declare function voronoiDiagram(points: number[][], bounds: [f64, f64, f64, f64]): {
+    vertices: number[][];
+    regions: number[][];
+};
+/**
+ * K-d tree node.
+ */
+export interface KDTreeNode {
+    point: number[];
+    index: i32;
+    left: KDTreeNode | null;
+    right: KDTreeNode | null;
+    axis: i32;
+}
+/**
+ * Build a k-d tree for spatial queries.
+ *
+ * @param points - Array of points (each same dimensionality)
+ * @returns Root node of the k-d tree
+ */
+export declare function kdTree(points: number[][]): KDTreeNode | null;
+/**
+ * Find the nearest neighbor in a k-d tree.
+ *
+ * @param root - K-d tree root
+ * @param target - Query point
+ * @returns { point, index, distance }
+ */
+export declare function kdTreeNearest(root: KDTreeNode | null, target: number[]): {
+    point: number[];
+    index: i32;
+    distance: f64;
+} | null;
+/**
+ * One-shot nearest-neighbor search: builds a k-d tree and queries it.
+ * Uses WASM acceleration for large point sets.
+ *
+ * @param points - Array of points (each same dimensionality)
+ * @param query - Query point
+ * @returns { point, index, distance } of the nearest neighbor, or null
+ */
+export declare function nearestNeighbor(points: number[][], query: number[]): {
+    point: number[];
+    index: i32;
+    distance: f64;
+} | null;
+/**
+ * Represents a triangular face of a 3-D convex hull as three vertex indices
+ * into the input point array.  The vertices are in counter-clockwise order
+ * when viewed from outside the hull.
+ */
+export type HullFace3D = [i32, i32, i32];
+/**
+ * Compute the 3-D convex hull of a set of points using QuickHull (incremental
+ * variant — Barber, Dobkin, Huhdanpaa 1996).
+ *
+ * Point sets with ≥ 1024 points are dispatched to the Rust WASM kernel;
+ * smaller sets use a pure-TypeScript fallback with the same algorithm.
+ *
+ * @param points - Array of 3-D points, each `[x, y, z]`.
+ * @returns Array of triangular faces.  Each face is `[i, j, k]` where i/j/k
+ *          are indices into `points`, oriented CCW from outside.
+ * @throws {Error} When the input is degenerate (fewer than 4 non-coplanar points).
+ */
+export declare function convexHull3D(points: number[][]): HullFace3D[];
+/**
+ * Compute the all-pairs Euclidean distance matrix for a set of points.
+ *
+ * Returns the symmetric `n x n` matrix whose entry `(i, j)` is the Euclidean
+ * distance between point `i` and point `j`. Every output row is independent, so
+ * large point sets are computed across the worker pool; small sets — or an
+ * uninitialized pool — fall back to a sequential computation.
+ *
+ * @param points - Array of `n` points, each a coordinate array of equal length
+ * @returns `n x n` distance matrix
+ *
+ * @example
+ * await distanceMatrix([[0, 0], [3, 0], [0, 4]])
+ * // [[0, 3, 4], [3, 0, 5], [4, 5, 0]]
+ */
+export declare function distanceMatrix(points: number[][]): Promise<number[][]>;
+export {};
+//# sourceMappingURL=geometry.d.ts.map

package/dist/typed/geometry.d.ts.map

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

package/dist/typed/gpu.d.ts

@@ -0,0 +1,62 @@
+/**
+ * WebGPU-Accelerated Matrix Operations
+ *
+ * Thin wrappers over the matrix package's WebGPU backend. Each function runs
+ * its core operation on the GPU via compute shaders when a WebGPU device is
+ * available and the matrix is large enough to amortize the dispatch cost;
+ * otherwise it transparently falls back to the sequential CPU implementation.
+ *
+ * Precision note: WebGPU shaders operate in 32-bit float (WGSL has no f64), so
+ * results carry f32 precision (~7 significant digits) — unlike the f64 CPU
+ * path. Use these functions when throughput on large matrices matters more
+ * than precision; use the standard `multiply` / `transpose` for full f64
+ * accuracy.
+ *
+ * @packageDocumentation
+ */
+import type { DenseMatrix } from '@danielsimonjr/mathts-matrix';
+/**
+ * Matrix multiplication on the WebGPU backend.
+ *
+ * Runs a WGSL compute shader when a WebGPU device is available and the product
+ * is large enough to be worth the dispatch; otherwise falls back to the CPU
+ * matrix product.
+ *
+ * @param a - Left matrix (m × k)
+ * @param b - Right matrix (k × n)
+ * @returns Product matrix (m × n); f32 precision on the GPU path
+ */
+export declare function gpuMatmul(a: DenseMatrix, b: DenseMatrix): Promise<DenseMatrix>;
+/**
+ * Matrix addition on the WebGPU backend.
+ *
+ * Runs a WGSL compute shader when a WebGPU device is available and the matrix
+ * is large enough; otherwise falls back to the CPU element-wise sum.
+ *
+ * @param a - First matrix
+ * @param b - Second matrix (same shape as `a`)
+ * @returns Element-wise sum; f32 precision on the GPU path
+ */
+export declare function gpuAdd(a: DenseMatrix, b: DenseMatrix): Promise<DenseMatrix>;
+/**
+ * Matrix transpose on the WebGPU backend.
+ *
+ * Runs a WGSL compute shader when a WebGPU device is available and the matrix
+ * is large enough; otherwise falls back to the CPU transpose.
+ *
+ * @param a - Matrix to transpose
+ * @returns Transposed matrix; f32 precision on the GPU path
+ */
+export declare function gpuTranspose(a: DenseMatrix): Promise<DenseMatrix>;
+/**
+ * Scalar multiplication on the WebGPU backend.
+ *
+ * Runs a WGSL compute shader when a WebGPU device is available and the matrix
+ * is large enough; otherwise falls back to the CPU scale.
+ *
+ * @param a - Matrix to scale
+ * @param scalar - Scalar multiplier
+ * @returns Scaled matrix; f32 precision on the GPU path
+ */
+export declare function gpuScale(a: DenseMatrix, scalar: number): Promise<DenseMatrix>;
+//# sourceMappingURL=gpu.d.ts.map

package/dist/typed/gpu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpu.d.ts","sourceRoot":"","sources":["../../src/typed/gpu.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAShE;;;;;;;;;;GAUG;AACH,wBAAsB,SAAS,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAGpF;AAED;;;;;;;;;GASG;AACH,wBAAsB,MAAM,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAGjF;AAED;;;;;;;;GAQG;AACH,wBAAsB,YAAY,CAAC,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAGvE;AAED;;;;;;;;;GASG;AACH,wBAAsB,QAAQ,CAAC,CAAC,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAGnF"}