@mojir/dvala 0.0.1 → 0.0.2

package/dist/modules/src/builtin/modules/grid/transpose.d.ts

@@ -0,0 +1,2 @@
+import type { Any } from '../../../interface';
+export declare function transpose<T extends Any>(grid: T[][]): T[][];

package/dist/modules/src/builtin/modules/interface.d.ts

@@ -0,0 +1,11 @@
+import type { BuiltinNormalExpressions } from '../../builtin/interface';
+/**
+ * Represents a Dvala module that can be imported dynamically.
+ * Modules contain a collection of functions that are not part of the core bundle.
+ */
+export interface DvalaModule {
+    /** The name of the module (e.g., 'grid', 'vec', 'mat') */
+    name: string;
+    /** The functions provided by this module, keyed by their short name (e.g., 'transpose') */
+    functions: BuiltinNormalExpressions;
+}

package/dist/modules/src/builtin/modules/linear-algebra/docs.d.ts

@@ -0,0 +1,2 @@
+import type { FunctionDocs } from '../../interface';
+export declare const moduleDocs: Record<string, FunctionDocs>;

package/dist/modules/src/builtin/modules/linear-algebra/helpers/calcFractionalRanks.d.ts

@@ -0,0 +1 @@
+export declare function calcFractionalRanks(vector: number[]): number[];

package/dist/modules/src/builtin/modules/linear-algebra/helpers/collinear.d.ts

@@ -0,0 +1,2 @@
+export declare function areVectorsCollinear(vectorA: number[], vectorB: number[]): boolean;
+export declare function areVectorsParallel(vectorA: number[], vectorB: number[]): boolean;

package/dist/modules/src/builtin/modules/linear-algebra/helpers/corrleation.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Calculate Pearson correlation between two segments
+ */
+export declare function calcCorrelation(segmentA: number[], segmentB: number[]): number;
+/**
+ * Extract overlapping segments from two vectors based on lag
+ */
+export declare function extractOverlappingSegments(vectorA: number[], vectorB: number[], lag: number): [number[], number[]];

package/dist/modules/src/builtin/modules/linear-algebra/helpers/covariance.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Calculate covariance between two segments
+ */
+export declare function calcCovariance(segmentA: number[], segmentB: number[]): number;

package/dist/modules/src/builtin/modules/linear-algebra/helpers/dot.d.ts

@@ -0,0 +1 @@
+export declare function dot(vector1: number[], vector2: number[]): number;

package/dist/modules/src/builtin/modules/linear-algebra/helpers/gaussJordanElimination.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Performs Gauss-Jordan elimination on a matrix, transforming it to reduced row echelon form
+ *
+ * @param matrix - The input matrix
+ * @returns A tuple containing the reduced row echelon form matrix and the rank
+ */
+export declare function gaussJordanElimination(matrix: number[][]): [number[][], number];

package/dist/modules/src/builtin/modules/linear-algebra/helpers/getUnit.d.ts

@@ -0,0 +1,2 @@
+import type { SourceCodeInfo } from '../../../../tokenizer/token';
+export declare function getUnit<T extends number[]>(value: T, sourceCodeInfo: SourceCodeInfo | undefined): T;

package/dist/modules/src/builtin/modules/linear-algebra/helpers/isZeroVector.d.ts

@@ -0,0 +1 @@
+export declare function isZeroVector(vector: number[]): boolean;

package/dist/modules/src/builtin/modules/linear-algebra/helpers/kendallTau.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Calculates Kendall's Tau-b rank correlation coefficient between two vectors
+ * This implementation handles ties and uses an epsilon value for floating-point comparisons
+ *
+ * @param vectorA - First vector of numbers
+ * @param vectorB - Second vector of numbers
+ * @param epsilon - Threshold for considering two values as equal (default: 1e-10)
+ * @returns The Kendall's Tau-b correlation coefficient
+ */
+export declare function kendallTau(vectorA: number[], vectorB: number[], epsilon?: number): number;

package/dist/modules/src/builtin/modules/linear-algebra/helpers/length.d.ts

@@ -0,0 +1 @@
+export declare function length(vector: number[]): number;

package/dist/modules/src/builtin/modules/linear-algebra/helpers/pearsonCorr.d.ts

@@ -0,0 +1 @@
+export declare function pearsonCorr(vectorA: number[], vectorB: number[]): number;

package/dist/modules/src/builtin/modules/linear-algebra/helpers/scale.d.ts

@@ -0,0 +1 @@
+export declare function scale<T extends number[]>(vector: T, scalar: number): T;

package/dist/modules/src/builtin/modules/linear-algebra/helpers/solve.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Solves a system of linear equations Ax = b
+ *
+ * @param A - The coefficient matrix
+ * @param b - The constant vector
+ * @returns The solution vector x, or null if no unique solution exists
+ */
+export declare function solve(A: number[][], b: number[]): number[] | null;

package/dist/modules/src/builtin/modules/linear-algebra/helpers/subtract.d.ts

@@ -0,0 +1 @@
+export declare function subtract<T extends number[]>(vector1: T, vector2: T): T;

package/dist/modules/src/builtin/modules/linear-algebra/index.d.ts

@@ -0,0 +1,4 @@
+import type { BuiltinNormalExpressions } from '../../../builtin/interface';
+import type { DvalaModule } from '../interface';
+export declare const linearAlgebraNormalExpression: BuiltinNormalExpressions;
+export declare const linearAlgebraModule: DvalaModule;

package/dist/modules/src/builtin/modules/math/index.d.ts

@@ -0,0 +1,2 @@
+import type { DvalaModule } from '../interface';
+export declare const mathUtilsModule: DvalaModule;

package/dist/modules/src/builtin/modules/matrix/docs.d.ts

@@ -0,0 +1,2 @@
+import type { FunctionDocs } from '../../interface';
+export declare const moduleDocs: Record<string, FunctionDocs>;

package/dist/modules/src/builtin/modules/matrix/helpers/adjugate.d.ts

@@ -0,0 +1 @@
+export declare function adjugate(matrix: number[][]): number[][];

package/dist/modules/src/builtin/modules/matrix/helpers/band.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Creates a band matrix with specified lower and upper bandwidths
+ *
+ * @param n Size of the square matrix
+ * @param lband Lower bandwidth (number of non-zero diagonals below main diagonal)
+ * @param uband Upper bandwidth (number of non-zero diagonals above main diagonal)
+ * @returns A 2D array representing the band matrix with 1s in the band and 0s elsewhere
+ */
+export declare function band(n: number, lband: number, uband: number): number[][];

package/dist/modules/src/builtin/modules/matrix/helpers/cofactor.d.ts

@@ -0,0 +1 @@
+export declare function cofactor(matrix: number[][]): number[][];

package/dist/modules/src/builtin/modules/matrix/helpers/determinant.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Calculates the determinant of a matrix using Gaussian Elimination
+ * @param matrix A square matrix represented as a 2D array
+ * @returns The determinant of the matrix
+ */
+export declare function determinant(matrix: number[][]): number;

package/dist/modules/src/builtin/modules/matrix/helpers/diagonal.d.ts

@@ -0,0 +1 @@
+export declare function diagonal(matrix: number[][]): number[];

package/dist/modules/src/builtin/modules/matrix/helpers/inverse.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Calculate the inverse of a matrix using the adjugate method
+ * @param matrix The input matrix
+ * @returns The inverse matrix or null if the matrix is not invertible
+ */
+export declare function inverse(matrix: number[][]): number[][] | null;

package/dist/modules/src/builtin/modules/matrix/helpers/isBanded.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Checks if a matrix is banded with the given lower and upper bandwidth.
+ * A matrix is banded if all non-zero elements are within 'lower' diagonals
+ * below the main diagonal and 'upper' diagonals above the main diagonal.
+ *
+ * @param matrix - The matrix to check, represented as a 2D array of numbers
+ * @param lower - Number of non-zero diagonals below the main diagonal
+ * @param upper - Number of non-zero diagonals above the main diagonal
+ * @returns true if the matrix is banded with the given parameters, false otherwise
+ */
+export declare function isBanded(matrix: number[][], lower: number, upper: number): boolean;

package/dist/modules/src/builtin/modules/matrix/helpers/isDiagonal.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Checks if a given matrix is diagonal.
+ *
+ * A matrix is considered diagonal if it is square (i.e., the number of rows equals the number of columns)
+ * and all elements outside the main diagonal are zero.
+ *
+ * @param matrix - A two-dimensional array of numbers representing the matrix to check.
+ * @returns `true` if the matrix is diagonal, otherwise `false`.
+ */
+export declare function isDiagonal(matrix: number[][]): boolean;

package/dist/modules/src/builtin/modules/matrix/helpers/isIdentity.d.ts

@@ -0,0 +1 @@
+export declare function isIdentity(matrix: number[][]): boolean;

package/dist/modules/src/builtin/modules/matrix/helpers/isOrthogonal.d.ts

@@ -0,0 +1 @@
+export declare function isOrthogonal(matrix: number[][]): boolean;

package/dist/modules/src/builtin/modules/matrix/helpers/isSquare.d.ts

@@ -0,0 +1 @@
+export declare function isSquare(matrix: number[][]): boolean;

package/dist/modules/src/builtin/modules/matrix/helpers/isSymetric.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Checks if a given matrix is symmetric.
+ * A matrix is symmetric if it is square and its transpose is equal to itself.
+ *
+ * @param matrix - A 2D array representing the matrix.
+ * @returns `true` if the matrix is symmetric, otherwise `false`.
+ */
+export declare function isSymetric(matrix: number[][]): boolean;

package/dist/modules/src/builtin/modules/matrix/helpers/isTriangular.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Determines whether a given matrix is triangular.
+ *
+ * A triangular matrix is a square matrix where all elements
+ * below or above the main diagonal are zero. This function
+ * checks if the matrix is square and symmetric.
+ *
+ * @param matrix - A two-dimensional array of numbers representing the matrix.
+ * @returns `true` if the matrix is triangular, otherwise `false`.
+ */
+export declare function isTriangular(matrix: number[][]): boolean;
+export declare function isTriangularUpper(matrix: number[][]): boolean;
+export declare function isTriangularLower(matrix: number[][]): boolean;

package/dist/modules/src/builtin/modules/matrix/helpers/matrixMultiply.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Performs cache-optimized matrix multiplication.
+ * @param A The first input matrix (m x n)
+ * @param B The second input matrix (n x p)
+ * @returns The result matrix C (m x p) where C = A × B
+ */
+export declare function matrixMultiply(A: number[][], B: number[][]): number[][];

package/dist/modules/src/builtin/modules/matrix/helpers/minor.d.ts

@@ -0,0 +1 @@
+export declare function minor(matrix: number[][], row: number, col: number): number[][];

package/dist/modules/src/builtin/modules/matrix/helpers/norm1.d.ts

@@ -0,0 +1 @@
+export declare function norm1(matrix: number[][]): number;

package/dist/modules/src/builtin/modules/matrix/helpers/trace.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Calculates the trace of a square matrix.
+ * The trace is defined as the sum of the elements on the main diagonal.
+ *
+ * @param matrix - A 2D array representing a square matrix.
+ * @returns The trace of the matrix.
+ */
+export declare function trace(matrix: number[][]): number;

package/dist/modules/src/builtin/modules/matrix/index.d.ts

@@ -0,0 +1,4 @@
+import type { BuiltinNormalExpressions } from '../../../builtin/interface';
+import type { DvalaModule } from '../interface';
+export declare const matrixNormalExpression: BuiltinNormalExpressions;
+export declare const matrixModule: DvalaModule;

package/dist/modules/src/builtin/modules/number-theory/binomialCefficient.d.ts

@@ -0,0 +1 @@
+export declare function binomialCoefficient(n: number, k: number): number;

package/dist/modules/src/builtin/modules/number-theory/combinations.d.ts

@@ -0,0 +1,2 @@
+import type { BuiltinNormalExpressions } from '../../../builtin/interface';
+export declare const combinationsNormalExpressions: BuiltinNormalExpressions;

package/dist/modules/src/builtin/modules/number-theory/derangements.d.ts

@@ -0,0 +1,2 @@
+import type { BuiltinNormalExpressions } from '../../../builtin/interface';
+export declare const derangementsNormalExpressions: BuiltinNormalExpressions;

package/dist/modules/src/builtin/modules/number-theory/divisors.d.ts

@@ -0,0 +1,4 @@
+import type { BuiltinNormalExpressions } from '../../../builtin/interface';
+export declare function getDivisors(n: number): number[];
+export declare function getProperDivisors(n: number): number[];
+export declare const divisorsNormalExpressions: BuiltinNormalExpressions;

package/dist/modules/src/builtin/modules/number-theory/docs.d.ts

@@ -0,0 +1,2 @@
+import type { FunctionDocs } from '../../interface';
+export declare const moduleDocs: Record<string, FunctionDocs>;

package/dist/modules/src/builtin/modules/number-theory/factorial.d.ts

@@ -0,0 +1,3 @@
+import type { BuiltinNormalExpressions } from '../../../builtin/interface';
+export declare function factorialOf(n: number): number;
+export declare const factorialNormalExpressions: BuiltinNormalExpressions;

package/dist/modules/src/builtin/modules/number-theory/index.d.ts

@@ -0,0 +1,4 @@
+import type { BuiltinNormalExpressions } from '../../../builtin/interface';
+import type { DvalaModule } from '../interface';
+export declare const combinatoricalNormalExpression: BuiltinNormalExpressions;
+export declare const numberTheoryModule: DvalaModule;

package/dist/modules/src/builtin/modules/number-theory/partitions.d.ts

@@ -0,0 +1,2 @@
+import type { BuiltinNormalExpressions } from '../../../builtin/interface';
+export declare const partitionsNormalExpressions: BuiltinNormalExpressions;

package/dist/modules/src/builtin/modules/number-theory/permutations.d.ts

@@ -0,0 +1,2 @@
+import type { BuiltinNormalExpressions } from '../../../builtin/interface';
+export declare const permutationsNormalExpressions: BuiltinNormalExpressions;

package/dist/modules/src/builtin/modules/number-theory/powerSet.d.ts

@@ -0,0 +1,2 @@
+import type { BuiltinNormalExpressions } from '../../../builtin/interface';
+export declare const powerSetNormalExpressions: BuiltinNormalExpressions;

package/dist/modules/src/builtin/modules/number-theory/primeFactors.d.ts

@@ -0,0 +1,11 @@
+import type { BuiltinNormalExpressions } from '../../../builtin/interface';
+/**
+ * Returns the prime factorization of a number as an array of its prime factors.
+ * For example, factors(12) returns [2, 2, 3].
+ * Special case: factors(1) returns an empty array [].
+ *
+ * @param n - A positive integer to factorize
+ * @returns An array of prime factors in ascending order
+ */
+export declare function primeFactors(n: number): number[];
+export declare const primeFactorsNormalExpressions: BuiltinNormalExpressions;

package/dist/modules/src/builtin/modules/number-theory/sequences/abundant.d.ts

@@ -0,0 +1,2 @@
+import type { SequenceDefinition } from '.';
+export declare const abundantSequence: SequenceDefinition<'abundant'>;

package/dist/modules/src/builtin/modules/number-theory/sequences/arithmetic.d.ts

@@ -0,0 +1,2 @@
+import type { SequenceNormalExpressions } from '.';
+export declare const arithmeticNormalExpressions: SequenceNormalExpressions<'arithmetic'>;

package/dist/modules/src/builtin/modules/number-theory/sequences/bell.d.ts

@@ -0,0 +1 @@
+export declare const bellNumbers: number[];

package/dist/modules/src/builtin/modules/number-theory/sequences/bernoulli.d.ts

@@ -0,0 +1,2 @@
+import type { SequenceNormalExpressions } from '.';
+export declare const bernoulliNormalExpressions: Omit<SequenceNormalExpressions<'bernoulli'>, 'bernoulli?'>;

package/dist/modules/src/builtin/modules/number-theory/sequences/catalan.d.ts

@@ -0,0 +1 @@
+export declare const catalanNumbers: number[];

package/dist/modules/src/builtin/modules/number-theory/sequences/collatz.d.ts

@@ -0,0 +1,2 @@
+import type { SequenceDefinition } from '.';
+export declare const collatzSequence: Omit<SequenceDefinition<'collatz'>, 'collatz-nth' | 'collatz-take-while' | 'collatz?'>;

package/dist/modules/src/builtin/modules/number-theory/sequences/composite.d.ts

@@ -0,0 +1,3 @@
+import type { SequenceDefinition } from '.';
+export declare function isComposite(num: number): boolean;
+export declare const compositeSequence: SequenceDefinition<'composite'>;

package/dist/modules/src/builtin/modules/number-theory/sequences/deficient.d.ts

@@ -0,0 +1,2 @@
+import type { SequenceDefinition } from '.';
+export declare const deficientSequence: SequenceDefinition<'deficient'>;

package/dist/modules/src/builtin/modules/number-theory/sequences/factorial.d.ts

@@ -0,0 +1 @@
+export declare const factorialNumbers: number[];

package/dist/modules/src/builtin/modules/number-theory/sequences/fibonacci.d.ts

@@ -0,0 +1 @@
+export declare const fibonacciNumbers: number[];

package/dist/modules/src/builtin/modules/number-theory/sequences/geometric.d.ts

@@ -0,0 +1,2 @@
+import type { SequenceNormalExpressions } from '.';
+export declare const geometricNormalExpressions: SequenceNormalExpressions<'geometric'>;

package/dist/modules/src/builtin/modules/number-theory/sequences/golomb.d.ts

@@ -0,0 +1,2 @@
+import type { SequenceDefinition } from '.';
+export declare const golombSequence: SequenceDefinition<'golomb'>;

package/dist/modules/src/builtin/modules/number-theory/sequences/happy.d.ts

@@ -0,0 +1,2 @@
+import type { SequenceDefinition } from '.';
+export declare const happySequence: SequenceDefinition<'happy'>;

package/dist/modules/src/builtin/modules/number-theory/sequences/index.d.ts

@@ -0,0 +1,27 @@
+import type { SourceCodeInfo } from '../../../../tokenizer/token';
+import type { MaybePromise } from '../../../../utils/maybePromise';
+import type { BuiltinNormalExpression, BuiltinNormalExpressions } from '../../../../builtin/interface';
+type SeqKey<T extends string> = `${T}-seq`;
+type TakeWhileKey<T extends string> = `${T}-take-while`;
+type NthKey<T extends string> = `${T}-nth`;
+type PredKey<T extends string> = `${T}?`;
+type SeqFunction<Type extends number | string> = (length: number, sourceCodeInfo: SourceCodeInfo | undefined) => Type[];
+type TakeWhileFunction<Type extends number | string> = (pred: (value: Type, index: number) => MaybePromise<boolean>, sourceCodeInfo: SourceCodeInfo | undefined) => MaybePromise<Type[]>;
+type PredFunction<Type extends number | string> = (n: Type, sourceCodeInfo: SourceCodeInfo | undefined) => boolean;
+export type SequenceKeys<T extends string> = SeqKey<T> | TakeWhileKey<T> | NthKey<T> | PredKey<T>;
+export type SequenceDefinition<T extends string, Type extends number | string = number> = {
+    [key in Exclude<SequenceKeys<T>, NthKey<T>>]: key extends SeqKey<T> ? SeqFunction<Type> : key extends TakeWhileKey<T> ? TakeWhileFunction<Type> : PredFunction<Type>;
+} & {
+    maxLength?: number;
+} & (Type extends string ? {
+    string: true;
+} : {
+    string?: never;
+}) & {
+    noNth?: true;
+};
+export type SequenceNormalExpressions<T extends string, Type extends string | number = number> = {
+    [key in SequenceKeys<T>]: key extends SeqKey<T> ? BuiltinNormalExpression<Type[]> : key extends TakeWhileKey<T> ? BuiltinNormalExpression<Type[]> : key extends NthKey<T> ? BuiltinNormalExpression<Type> : BuiltinNormalExpression<boolean>;
+};
+export declare const sequenceNormalExpressions: BuiltinNormalExpressions;
+export {};

package/dist/modules/src/builtin/modules/number-theory/sequences/juggler.d.ts

@@ -0,0 +1,2 @@
+import type { SequenceDefinition } from '.';
+export declare const jugglerSequence: Omit<SequenceDefinition<'juggler'>, 'juggler-nth' | 'juggler-take-while' | 'juggler?'>;

package/dist/modules/src/builtin/modules/number-theory/sequences/lookAndSay.d.ts

@@ -0,0 +1,2 @@
+import type { SequenceDefinition } from '.';
+export declare const lookAndSaySequence: SequenceDefinition<'look-and-say', string>;

package/dist/modules/src/builtin/modules/number-theory/sequences/lucas.d.ts

@@ -0,0 +1 @@
+export declare const lucasNumbers: number[];

package/dist/modules/src/builtin/modules/number-theory/sequences/lucky.d.ts

@@ -0,0 +1,2 @@
+import type { SequenceDefinition } from '.';
+export declare const luckySequence: SequenceDefinition<'lucky'>;

package/dist/modules/src/builtin/modules/number-theory/sequences/mersenne.d.ts

@@ -0,0 +1 @@
+export declare const mersenneNumbers: number[];

package/dist/modules/src/builtin/modules/number-theory/sequences/padovan.d.ts

@@ -0,0 +1,2 @@
+import type { SequenceDefinition } from '.';
+export declare const padovanSequence: SequenceDefinition<'padovan'>;

package/dist/modules/src/builtin/modules/number-theory/sequences/partition.d.ts

@@ -0,0 +1 @@
+export declare const partitionNumbers: number[];

package/dist/modules/src/builtin/modules/number-theory/sequences/pell.d.ts

@@ -0,0 +1 @@
+export declare const pellNumbers: number[];

package/dist/modules/src/builtin/modules/number-theory/sequences/perfect.d.ts

@@ -0,0 +1 @@
+export declare const perfectNumbers: number[];

package/dist/modules/src/builtin/modules/number-theory/sequences/perfectCube.d.ts

@@ -0,0 +1,2 @@
+import type { SequenceDefinition } from '.';
+export declare const perfectCubeSequence: SequenceDefinition<'perfect-cube'>;

package/dist/modules/src/builtin/modules/number-theory/sequences/perfectPower.d.ts

@@ -0,0 +1,10 @@
+import type { SequenceDefinition } from '.';
+/**
+ * Checks if a number is a perfect power and returns the base and exponent if it is.
+ * A perfect power is a number that can be expressed as an integer power of another integer.
+ *
+ * @param n - The number to check
+ * @returns [base, exponent] if n is a perfect power, null otherwise
+ */
+export declare function perfectPower(n: number): [number, number] | null;
+export declare const perfectPowerSequence: SequenceDefinition<'perfect-power'>;

package/dist/modules/src/builtin/modules/number-theory/sequences/perfectSquare.d.ts

@@ -0,0 +1,2 @@
+import type { SequenceDefinition } from '.';
+export declare const perfectSquareSequence: SequenceDefinition<'perfect-square'>;

package/dist/modules/src/builtin/modules/number-theory/sequences/poligonal.d.ts

@@ -0,0 +1,2 @@
+import type { SequenceNormalExpressions } from '.';
+export declare const poligonalNormalExpressions: SequenceNormalExpressions<'polygonal'>;

package/dist/modules/src/builtin/modules/number-theory/sequences/prime.d.ts

@@ -0,0 +1,3 @@
+import type { SequenceDefinition } from '.';
+export declare function isPrime(num: number): boolean;
+export declare const primeSequence: SequenceDefinition<'prime'>;

package/dist/modules/src/builtin/modules/number-theory/sequences/recaman.d.ts

@@ -0,0 +1,9 @@
+import type { SequenceDefinition } from '.';
+/**
+ * Generates the first 'n' terms of the Recamán sequence.
+ *
+ * @param n - Number of terms to generate
+ * @returns Array containing the first n terms of the Recamán sequence
+ */
+export declare function generateRecamanSequence(n: number): number[];
+export declare const recamanSequence: SequenceDefinition<'recaman'>;

package/dist/modules/src/builtin/modules/number-theory/sequences/sylvester.d.ts

@@ -0,0 +1 @@
+export declare const sylvesterNumbers: number[];

package/dist/modules/src/builtin/modules/number-theory/sequences/thueMorse.d.ts

@@ -0,0 +1,2 @@
+import type { SequenceDefinition } from '.';
+export declare const thueMorseSequence: SequenceDefinition<'thue-morse'>;

package/dist/modules/src/builtin/modules/number-theory/sequences/tribonacci.d.ts

@@ -0,0 +1 @@
+export declare const tribonacciNumbers: number[];

package/dist/modules/src/builtin/modules/random/docs.d.ts

@@ -0,0 +1,2 @@
+import type { FunctionDocs } from '../../interface';
+export declare const moduleDocs: Record<string, FunctionDocs>;

package/dist/modules/src/builtin/modules/random/index.d.ts

@@ -0,0 +1,2 @@
+import type { DvalaModule } from '../interface';
+export declare const randomModule: DvalaModule;

package/dist/modules/src/builtin/modules/sequence/index.d.ts

@@ -0,0 +1,2 @@
+import type { DvalaModule } from '../interface';
+export declare const sequenceUtilsModule: DvalaModule;

package/dist/modules/src/builtin/modules/string/index.d.ts

@@ -0,0 +1,2 @@
+import type { DvalaModule } from '../interface';
+export declare const stringUtilsModule: DvalaModule;

package/dist/modules/src/builtin/modules/vector/bincount.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Counts occurrences of each integer value in an array of non-negative integers.
+ *
+ * @param array - Array of non-negative integers to count
+ * @param minLength - Minimum length of the output array (default: 0)
+ * @param weights - Optional array of weights (same length as input array)
+ * @returns An array where index i contains the count of occurrences of i in the input array
+ */
+export declare function bincount(array: number[], minLength?: number, weights?: number[]): number[];

package/dist/modules/src/builtin/modules/vector/calcMad.d.ts

@@ -0,0 +1 @@
+export declare function calcMad(vector: number[]): number;

package/dist/modules/src/builtin/modules/vector/calcMean.d.ts

@@ -0,0 +1 @@
+export declare function calcMean(vector: number[]): number;

package/dist/modules/src/builtin/modules/vector/calcMedad.d.ts

@@ -0,0 +1 @@
+export declare function calcMedad(vector: number[]): number;

package/dist/modules/src/builtin/modules/vector/calcMedian.d.ts

@@ -0,0 +1 @@
+export declare function calcMedian(vector: number[]): number;

package/dist/modules/src/builtin/modules/vector/calcStdDev.d.ts

@@ -0,0 +1,2 @@
+export declare function calcStdDev(vector: number[], optionalMean?: number): number;
+export declare function calcSampleStdDev(vector: number[], optionalMean?: number): number;

package/dist/modules/src/builtin/modules/vector/calcVariance.d.ts

@@ -0,0 +1,2 @@
+export declare function calcVariance(vector: number[], optionalMean?: number): number;
+export declare function calcSampleVariance(vector: number[], optionalMean?: number): number;

package/dist/modules/src/builtin/modules/vector/docs.d.ts

@@ -0,0 +1,2 @@
+import type { FunctionDocs } from '../../interface';
+export declare const moduleDocs: Record<string, FunctionDocs>;

package/dist/modules/src/builtin/modules/vector/entropy.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Calculates the Shannon entropy of a vector.
+ * Entropy measures the amount of uncertainty or randomness in the data.
+ *
+ * @param vector - An array of values to calculate entropy for
+ * @returns The entropy value (in bits) or 0 for empty arrays
+ */
+export declare function calculateEntropy<T>(vector: T[]): number;

package/dist/modules/src/builtin/modules/vector/histogram.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Creates a histogram from an array of numbers, returning bin ranges and counts.
+ * Each bin is represented as a tuple of [minValue, maxValue, count].
+ *
+ * @param vector - Array of numeric values
+ * @param bins - Number of bins to divide the data into
+ * @returns Array of tuples, each containing [binStart, binEnd, count]
+ */
+export declare function calcHistogram(vector: number[], bins: number): [number, number, number][];

package/dist/modules/src/builtin/modules/vector/index.d.ts

@@ -0,0 +1,2 @@
+import type { DvalaModule } from '../interface';
+export declare const vectorModule: DvalaModule;

package/dist/modules/src/builtin/modules/vector/mode.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Calculates the mode (most frequent value(s)) of a dataset
+ * @param values An array of values of any type
+ * @returns An array containing the mode(s) of the dataset
+ */
+export declare function mode(values: number[]): number[];

package/dist/modules/src/builtin/modules/vector/outliers.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Checks if a vector has no extreme outliers using the IQR method
+ * @param vector An array of numbers to check for extreme outliers
+ * @returns true if there are no extreme outliers, false otherwise
+ */
+export declare function hasOutliers(vector: number[]): boolean;
+export declare function outliers(vector: number[]): number[];

package/dist/modules/src/builtin/modules/vector/percentile.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Calculate the percentile value from an array of numbers
+ * @param data Array of numbers to calculate percentile from
+ * @param percentile The percentile to calculate (0-100)
+ * @returns The value at the specified percentile
+ */
+export declare function calcPercentile(data: number[], percentile: number): number;

package/dist/modules/src/builtin/modules/vector/quartiles.d.ts

@@ -0,0 +1 @@
+export declare function quartiles(vector: number[]): [number, number, number];

package/dist/modules/src/builtin/modules/vector/reductionFunctions/entropy.d.ts

@@ -0,0 +1,2 @@
+import type { ReductionFunctionDefinition } from '.';
+export declare const entropyReductionFunction: ReductionFunctionDefinition<'entropy'>;

package/dist/modules/src/builtin/modules/vector/reductionFunctions/giniCoefficient.d.ts

@@ -0,0 +1,2 @@
+import type { ReductionFunctionDefinition } from '.';
+export declare const giniCoefficientReductionFunction: ReductionFunctionDefinition<'gini-coefficient'>;