numpy-ts 0.8.0 → 0.9.0

package/dist/types/ops/linalg.d.ts

@@ -143,4 +143,224 @@ export declare function einsum(subscripts: string, ...operands: ArrayStorage[]):
  * @returns Kronecker product of a and b
  */
 export declare function kron(a: ArrayStorage, b: ArrayStorage): ArrayStorage;
+/**
+ * Cross product of two vectors.
+ *
+ * For 3D vectors: returns the cross product vector
+ * For 2D vectors: returns the scalar z-component of the cross product
+ *
+ * @param a - First input array
+ * @param b - Second input array
+ * @param axisa - Axis of a that defines the vectors (default: -1)
+ * @param axisb - Axis of b that defines the vectors (default: -1)
+ * @param axisc - Axis of c containing the cross product vectors (default: -1)
+ * @param axis - If defined, the axis of a, b and c that defines the vectors
+ * @returns Cross product of a and b
+ */
+export declare function cross(a: ArrayStorage, b: ArrayStorage, axisa?: number, axisb?: number, axisc?: number, axis?: number): ArrayStorage | number;
+/**
+ * Vector norm.
+ *
+ * @param x - Input vector or array
+ * @param ord - Order of the norm (default: 2)
+ *              - Infinity: max(abs(x))
+ *              - -Infinity: min(abs(x))
+ *              - 0: sum(x != 0)
+ *              - Other: sum(abs(x)^ord)^(1/ord)
+ * @param axis - Axis along which to compute (flattened if not specified)
+ * @param keepdims - Keep reduced dimensions
+ * @returns Vector norm
+ */
+export declare function vector_norm(x: ArrayStorage, ord?: number | 'fro' | 'nuc', axis?: number | null, keepdims?: boolean): ArrayStorage | number;
+/**
+ * Matrix norm.
+ *
+ * @param x - Input 2D array
+ * @param ord - Order of the norm:
+ *              - 'fro': Frobenius norm (default)
+ *              - 'nuc': Nuclear norm (sum of singular values)
+ *              - 1: Max column sum (max(sum(abs(x), axis=0)))
+ *              - -1: Min column sum (min(sum(abs(x), axis=0)))
+ *              - 2: Largest singular value
+ *              - -2: Smallest singular value
+ *              - Infinity: Max row sum (max(sum(abs(x), axis=1)))
+ *              - -Infinity: Min row sum (min(sum(abs(x), axis=1)))
+ * @param keepdims - Keep reduced dimensions
+ * @returns Matrix norm
+ */
+export declare function matrix_norm(x: ArrayStorage, ord?: number | 'fro' | 'nuc', keepdims?: boolean): ArrayStorage | number;
+/**
+ * General norm function (for both vectors and matrices).
+ *
+ * @param x - Input array
+ * @param ord - Order of the norm (default: 'fro' for 2D, 2 for 1D)
+ * @param axis - Axis or axes along which to compute
+ * @param keepdims - Keep reduced dimensions
+ * @returns Norm
+ */
+export declare function norm(x: ArrayStorage, ord?: number | 'fro' | 'nuc' | null, axis?: number | [number, number] | null, keepdims?: boolean): ArrayStorage | number;
+/**
+ * QR decomposition using Householder reflections.
+ *
+ * @param a - Input matrix (m x n)
+ * @param mode - 'reduced' (default), 'complete', 'r', or 'raw'
+ * @returns { q, r } where A = Q @ R
+ */
+export declare function qr(a: ArrayStorage, mode?: 'reduced' | 'complete' | 'r' | 'raw'): {
+    q: ArrayStorage;
+    r: ArrayStorage;
+} | ArrayStorage | {
+    h: ArrayStorage;
+    tau: ArrayStorage;
+};
+/**
+ * Cholesky decomposition.
+ *
+ * Returns the lower triangular matrix L such that A = L @ L^T
+ * for a symmetric positive-definite matrix A.
+ *
+ * @param a - Symmetric positive-definite matrix
+ * @param upper - If true, return upper triangular U such that A = U^T @ U
+ * @returns Lower (or upper) triangular Cholesky factor
+ */
+export declare function cholesky(a: ArrayStorage, upper?: boolean): ArrayStorage;
+/**
+ * Singular Value Decomposition.
+ *
+ * @param a - Input matrix (m x n)
+ * @param full_matrices - If true, return full U and V^T, otherwise reduced
+ * @param compute_uv - If true, return U, S, V^T; if false, return only S
+ * @returns { u, s, vt } or just s depending on compute_uv
+ */
+export declare function svd(a: ArrayStorage, full_matrices?: boolean, compute_uv?: boolean): {
+    u: ArrayStorage;
+    s: ArrayStorage;
+    vt: ArrayStorage;
+} | ArrayStorage;
+/**
+ * Compute the determinant of a square matrix.
+ *
+ * Uses LU decomposition for numerical stability.
+ *
+ * @param a - Square matrix
+ * @returns Determinant
+ */
+export declare function det(a: ArrayStorage): number;
+/**
+ * Compute the matrix inverse - optimized to do LU decomposition once.
+ *
+ * @param a - Square matrix
+ * @returns Inverse matrix
+ */
+export declare function inv(a: ArrayStorage): ArrayStorage;
+/**
+ * Solve a linear system A @ x = b.
+ *
+ * @param a - Coefficient matrix (n x n)
+ * @param b - Right-hand side (n,) or (n, k)
+ * @returns Solution x with same shape as b
+ */
+export declare function solve(a: ArrayStorage, b: ArrayStorage): ArrayStorage;
+/**
+ * Compute the least-squares solution to a linear matrix equation.
+ *
+ * @param a - Coefficient matrix (m x n)
+ * @param b - Right-hand side (m,) or (m, k)
+ * @param rcond - Cutoff for small singular values (default: machine precision * max(m, n))
+ * @returns { x, residuals, rank, s } - Solution, residuals, effective rank, singular values
+ */
+export declare function lstsq(a: ArrayStorage, b: ArrayStorage, rcond?: number | null): {
+    x: ArrayStorage;
+    residuals: ArrayStorage;
+    rank: number;
+    s: ArrayStorage;
+};
+/**
+ * Compute the condition number of a matrix.
+ *
+ * @param a - Input matrix
+ * @param p - Order of the norm (default: 2, -2, 'fro', or inf)
+ * @returns Condition number
+ */
+export declare function cond(a: ArrayStorage, p?: number | 'fro' | 'nuc'): number;
+/**
+ * Compute the rank of a matrix using SVD.
+ *
+ * @param a - Input matrix
+ * @param tol - Threshold below which singular values are considered zero
+ * @returns Matrix rank
+ */
+export declare function matrix_rank(a: ArrayStorage, tol?: number): number;
+/**
+ * Raise a square matrix to an integer power.
+ *
+ * @param a - Input square matrix
+ * @param n - Integer power (can be negative)
+ * @returns Matrix raised to power n
+ */
+export declare function matrix_power(a: ArrayStorage, n: number): ArrayStorage;
+/**
+ * Compute the Moore-Penrose pseudo-inverse using SVD.
+ *
+ * @param a - Input matrix
+ * @param rcond - Cutoff for small singular values
+ * @returns Pseudo-inverse of a
+ */
+export declare function pinv(a: ArrayStorage, rcond?: number): ArrayStorage;
+/**
+ * Compute eigenvalues and right eigenvectors of a square matrix.
+ *
+ * For general matrices, uses iterative methods.
+ * For symmetric matrices, use eigh for better performance.
+ *
+ * **Limitation**: Complex eigenvalues are not supported. For non-symmetric matrices,
+ * this function returns only the real parts of eigenvalues. If your matrix has
+ * complex eigenvalues (e.g., rotation matrices), results will be incorrect.
+ * Use eigh() for symmetric matrices where eigenvalues are guaranteed to be real.
+ *
+ * @param a - Input square matrix
+ * @returns { w, v } - Eigenvalues (real only) and eigenvector matrix
+ */
+export declare function eig(a: ArrayStorage): {
+    w: ArrayStorage;
+    v: ArrayStorage;
+};
+/**
+ * Compute eigenvalues and eigenvectors of a real symmetric matrix.
+ *
+ * Note: Named "Hermitian" for NumPy compatibility, but only real symmetric
+ * matrices are supported (complex Hermitian matrices require complex dtype support).
+ * Symmetric matrices always have real eigenvalues, so results are exact.
+ *
+ * @param a - Real symmetric matrix
+ * @param UPLO - 'L' or 'U' to use lower or upper triangle (default: 'L')
+ * @returns { w, v } - Eigenvalues (sorted ascending) and eigenvector matrix
+ */
+export declare function eigh(a: ArrayStorage, UPLO?: 'L' | 'U'): {
+    w: ArrayStorage;
+    v: ArrayStorage;
+};
+/**
+ * Compute eigenvalues of a general square matrix.
+ *
+ * **Limitation**: Complex eigenvalues are not supported. For non-symmetric matrices,
+ * this function returns only real approximations. Use eigvalsh() for symmetric
+ * matrices where eigenvalues are guaranteed to be real.
+ *
+ * @param a - Input square matrix
+ * @returns Array of eigenvalues (real only)
+ */
+export declare function eigvals(a: ArrayStorage): ArrayStorage;
+/**
+ * Compute eigenvalues of a real symmetric matrix.
+ *
+ * Note: Named "Hermitian" for NumPy compatibility, but only real symmetric
+ * matrices are supported (complex Hermitian matrices require complex dtype support).
+ * Symmetric matrices always have real eigenvalues, so results are exact.
+ *
+ * @param a - Real symmetric matrix
+ * @param UPLO - 'L' or 'U' to use lower or upper triangle
+ * @returns Array of eigenvalues (sorted ascending)
+ */
+export declare function eigvalsh(a: ArrayStorage, UPLO?: 'L' | 'U'): ArrayStorage;
 //# sourceMappingURL=linalg.d.ts.map

package/dist/types/ops/rounding.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Rounding operations
+ *
+ * Pure functions for element-wise rounding operations:
+ * around, ceil, fix, floor, rint, round, trunc
+ */
+import { ArrayStorage } from '../core/storage';
+/**
+ * Round an array to the given number of decimals
+ */
+export declare function around(a: ArrayStorage, decimals?: number): ArrayStorage;
+/**
+ * Return the ceiling of the input, element-wise
+ */
+export declare function ceil(a: ArrayStorage): ArrayStorage;
+/**
+ * Round to nearest integer towards zero
+ */
+export declare function fix(a: ArrayStorage): ArrayStorage;
+/**
+ * Return the floor of the input, element-wise
+ */
+export declare function floor(a: ArrayStorage): ArrayStorage;
+/**
+ * Round elements of the array to the nearest integer (banker's rounding)
+ */
+export declare function rint(a: ArrayStorage): ArrayStorage;
+/**
+ * Alias for around
+ */
+export declare function round(a: ArrayStorage, decimals?: number): ArrayStorage;
+/**
+ * Return the truncated value of the input, element-wise
+ */
+export declare function trunc(a: ArrayStorage): ArrayStorage;
+//# sourceMappingURL=rounding.d.ts.map

package/dist/types/ops/sets.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Set operations
+ */
+import { ArrayStorage } from '../core/storage';
+/**
+ * Find the unique elements of an array
+ */
+export declare function unique(a: ArrayStorage, returnIndex?: boolean, returnInverse?: boolean, returnCounts?: boolean): ArrayStorage | {
+    values: ArrayStorage;
+    indices?: ArrayStorage;
+    inverse?: ArrayStorage;
+    counts?: ArrayStorage;
+};
+/**
+ * Test whether each element of a 1-D array is also present in a second array
+ */
+export declare function in1d(ar1: ArrayStorage, ar2: ArrayStorage): ArrayStorage;
+/**
+ * Find the intersection of two arrays
+ */
+export declare function intersect1d(ar1: ArrayStorage, ar2: ArrayStorage): ArrayStorage;
+/**
+ * Test whether each element of an ND array is also present in a second array
+ */
+export declare function isin(element: ArrayStorage, testElements: ArrayStorage): ArrayStorage;
+/**
+ * Find the set difference of two arrays
+ */
+export declare function setdiff1d(ar1: ArrayStorage, ar2: ArrayStorage): ArrayStorage;
+/**
+ * Find the set exclusive-or of two arrays
+ */
+export declare function setxor1d(ar1: ArrayStorage, ar2: ArrayStorage): ArrayStorage;
+/**
+ * Find the union of two arrays
+ */
+export declare function union1d(ar1: ArrayStorage, ar2: ArrayStorage): ArrayStorage;
+//# sourceMappingURL=sets.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "numpy-ts",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Complete NumPy implementation for TypeScript and JavaScript (under construction)",
   "main": "dist/numpy-ts.node.cjs",
   "browser": "dist/numpy-ts.browser.js",