@mojir/dvala 0.0.1 → 0.0.2

package/dist/src/AutoCompleter/AutoCompleter.d.ts

@@ -0,0 +1,25 @@
+import type { ContextParams, Dvala } from '../Dvala/Dvala';
+type AutoCompleteSuggestion = {
+    program: string;
+    position: number;
+};
+export declare class AutoCompleter {
+    readonly originalProgram: string;
+    readonly originalPosition: number;
+    private prefixProgram;
+    private suffixProgram;
+    private searchString;
+    private suggestions;
+    private suggestionIndex;
+    constructor(originalProgram: string, originalPosition: number, dvala: Dvala, params: ContextParams);
+    getNextSuggestion(): AutoCompleteSuggestion | null;
+    getPreviousSuggestion(): AutoCompleteSuggestion | null;
+    private getAutoCompleteSuggestionResult;
+    private getNextSuggestionSymbol;
+    private getPreviousSuggestionSymbol;
+    getSuggestions(): string[];
+    getSearchString(): string;
+    private generateSuggestions;
+    private generateWithPredicate;
+}
+export {};

package/dist/src/Dvala/Cache.d.ts

@@ -0,0 +1,16 @@
+import type { Ast } from '../parser/types';
+export declare class Cache {
+    private cache;
+    private firstEntry;
+    private lastEntry;
+    private _size;
+    private maxSize;
+    constructor(maxSize: number | null);
+    getContent(): Record<string, Ast>;
+    get size(): number;
+    get(key: string): Ast | undefined;
+    clear(): void;
+    has(key: string): boolean;
+    set(key: string, value: Ast): void;
+    private dropFirstEntry;
+}

package/dist/src/Dvala/Dvala.d.ts

@@ -0,0 +1,68 @@
+import type { Context } from '../evaluator/interface';
+import type { Any } from '../interface';
+import type { Ast, DvalaFunction } from '../parser/types';
+import type { TokenStream } from '../tokenizer/tokenize';
+import { AutoCompleter } from '../AutoCompleter/AutoCompleter';
+import type { Arity } from '../builtin/interface';
+import type { DvalaModule } from '../builtin/modules/interface';
+import type { DvalaBundle } from '../bundler/interface';
+import type { MaybePromise } from '../utils/maybePromise';
+import { Cache } from './Cache';
+export interface DvalaRuntimeInfo {
+    astCache: Cache | null;
+    astCacheSize: number | null;
+    debug: boolean;
+}
+export interface JsFunction {
+    fn: (...args: any[]) => unknown;
+    arity?: Arity;
+    pure?: boolean;
+    docString?: string;
+}
+export interface ContextParams {
+    globalContext?: Context;
+    contexts?: Context[];
+    bindings?: Record<string, unknown>;
+    globalModuleScope?: boolean;
+}
+export interface MinifyParams {
+    minify?: boolean;
+}
+export interface FilePathParams {
+    filePath?: string;
+}
+export interface PureParams {
+    pure?: boolean;
+}
+interface DvalaConfig {
+    initialCache?: Record<string, Ast>;
+    astCacheSize?: number | null;
+    debug?: boolean;
+    modules?: DvalaModule[];
+}
+export declare class Dvala {
+    private astCache;
+    private astCacheSize;
+    private debug;
+    private modules;
+    constructor(config?: DvalaConfig);
+    getRuntimeInfo(): DvalaRuntimeInfo;
+    readonly async: {
+        run: (programOrBundle: string | DvalaBundle, params?: ContextParams & FilePathParams & PureParams) => Promise<unknown>;
+        apply: (fn: DvalaFunction, fnParams: unknown[], params?: ContextParams & PureParams) => Promise<unknown>;
+    };
+    run(programOrBundle: string | DvalaBundle, params?: ContextParams & FilePathParams & PureParams): unknown;
+    private runBundle;
+    getUndefinedSymbols(programOrAst: string | Ast, params?: ContextParams): Set<string>;
+    tokenize(program: string, tokenizeParams?: FilePathParams & MinifyParams): TokenStream;
+    parse(tokenStream: TokenStream): Ast;
+    private evaluate;
+    private evaluateAsync;
+    transformSymbols(tokenStream: TokenStream, transformer: (symbol: string) => string): TokenStream;
+    untokenize(tokenStream: TokenStream): string;
+    apply(fn: DvalaFunction, fnParams: unknown[], params?: ContextParams & PureParams): MaybePromise<Any>;
+    private generateApplyFunctionCall;
+    private generateAst;
+    getAutoCompleter(program: string, position: number, params?: ContextParams): AutoCompleter;
+}
+export {};

package/dist/src/allModules.d.ts

@@ -0,0 +1,2 @@
+import type { DvalaModule } from './builtin/modules/interface';
+export declare const allBuiltinModules: DvalaModule[];

package/dist/src/builtin/bindingNode.d.ts

@@ -0,0 +1,11 @@
+import type { Any } from '../interface';
+import { type AstNode, type BindingTarget } from '../parser/types';
+import type { MaybePromise } from '../utils/maybePromise';
+export declare function walkDefaults(bindingTarget: BindingTarget, onDefault: (Node: AstNode) => void): void;
+export declare function evaluateBindingNodeValues(target: BindingTarget, value: Any, evaluate: (Node: AstNode) => MaybePromise<Any>): MaybePromise<Record<string, Any>>;
+export declare function getAllBindingTargetNames(bindingTarget: BindingTarget): Record<string, true>;
+/**
+ * Non-throwing pattern matching. Returns bindings on match, null on mismatch.
+ * Used by `switch` pattern matching.
+ */
+export declare function tryMatch(target: BindingTarget, value: Any, evaluate: (Node: AstNode) => MaybePromise<Any>): MaybePromise<Record<string, Any> | null>;

package/dist/src/builtin/core/array.d.ts

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

package/dist/src/builtin/core/assertion.d.ts

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

package/dist/src/builtin/core/bitwise.d.ts

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

package/dist/src/builtin/core/collection.d.ts

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

package/dist/src/builtin/core/functional.d.ts

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

package/dist/src/builtin/core/math.d.ts

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

package/dist/src/builtin/core/meta.d.ts

@@ -0,0 +1,3 @@
+import type { FunctionReference } from '../../../reference';
+import type { BuiltinNormalExpressions } from '../interface';
+export declare function getMetaNormalExpression(normalExpressionReference: Record<string, FunctionReference>): BuiltinNormalExpressions;

package/dist/src/builtin/core/misc.d.ts

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

package/dist/src/builtin/core/object.d.ts

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

package/dist/src/builtin/core/predicates.d.ts

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

package/dist/src/builtin/core/regexp.d.ts

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

package/dist/src/builtin/core/sequence.d.ts

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

package/dist/src/builtin/core/string.d.ts

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

package/dist/src/builtin/core/vector.d.ts

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

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

@@ -0,0 +1,13 @@
+import type { Builtin } from './interface';
+import { specialExpressionTypes } from './specialExpressionTypes';
+export declare const specialExpressions: readonly [import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/qq").QqNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/and").AndNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/or").OrNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/array").ArrayNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/cond").CondNode>, import("./interface").BuiltinSpecialExpression<boolean, import("./specialExpressions/defined").DefinedNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/block").DoNode>, import("./interface").BuiltinSpecialExpression<null, import("./specialExpressions/loops").DoSeqNode>, import("./interface").BuiltinSpecialExpression<import("..").DvalaFunction, import("./specialExpressions/functions").LambdaNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/loops").ForNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/if").IfNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/let").LetNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/loop").LoopNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/object").ObjectNode>, import("./interface").BuiltinSpecialExpression<null, import("./specialExpressions/recur").RecurNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/match").MatchNode>, import("./interface").BuiltinSpecialExpression<null, import("./specialExpressions/throw").ThrowNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/try").TryNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/unless").UnlessNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/import").ImportNode>, import("./interface").BuiltinSpecialExpression<import("../parser/types").EffectRef, import("./specialExpressions/effect").EffectNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/perform").PerformNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Arr, import("./specialExpressions/parallel").ParallelNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/race").RaceNode>];
+export type SpecialExpressions = typeof specialExpressions;
+export type SpecialExpression = SpecialExpressions[number];
+export type SpecialExpressionName = keyof typeof specialExpressionTypes;
+export type CommonSpecialExpressionType = [
+    typeof specialExpressionTypes['??'] | typeof specialExpressionTypes['&&'] | typeof specialExpressionTypes['cond'] | typeof specialExpressionTypes['match'] | typeof specialExpressionTypes['defined?'] | typeof specialExpressionTypes['block'] | typeof specialExpressionTypes['if'] | typeof specialExpressionTypes['unless'] | typeof specialExpressionTypes['||'] | typeof specialExpressionTypes['throw'] | typeof specialExpressionTypes['array'] | typeof specialExpressionTypes['object'] | typeof specialExpressionTypes['effect'] | typeof specialExpressionTypes['perform'] | typeof specialExpressionTypes['parallel'] | typeof specialExpressionTypes['race']
+];
+export type SpecialExpressionType = typeof specialExpressionTypes[SpecialExpressionName];
+export declare const builtin: Builtin;
+export declare const normalExpressionKeys: string[];
+export declare const specialExpressionKeys: string[];

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

@@ -0,0 +1,113 @@
+import type { ContextStack } from '../evaluator/ContextStack';
+import type { EvaluateNode, ExecuteFunction } from '../evaluator/interface';
+import type { GetUndefinedSymbols, UndefinedSymbols } from '../getUndefinedSymbols';
+import type { Any, Arr } from '../interface';
+import type { SpecialExpressionNode } from '../parser/types';
+import type { SourceCodeInfo } from '../tokenizer/token';
+import type { MaybePromise } from '../utils/maybePromise';
+import type { SpecialExpressions } from '.';
+export type Arity = {
+    min?: number;
+    max?: number;
+};
+declare const dataTypes: readonly ["number", "string", "object", "array", "vector", "matrix", "grid", "boolean", "function", "integer", "any", "null", "collection", "sequence", "regexp", "never"];
+export type DataType = typeof dataTypes[number];
+export declare function isDataType(arg: string): arg is DataType;
+export declare const categoryRecord: {
+    readonly 'special-expression': true;
+    readonly predicate: true;
+    readonly sequence: true;
+    readonly collection: true;
+    readonly array: true;
+    readonly object: true;
+    readonly string: true;
+    readonly math: true;
+    readonly functional: true;
+    readonly 'regular-expression': true;
+    readonly bitwise: true;
+    readonly misc: true;
+    readonly meta: true;
+    readonly assertion: true;
+    readonly vector: true;
+    readonly 'linear-algebra': true;
+    readonly matrix: true;
+    readonly grid: true;
+    readonly 'number-theory': true;
+    readonly random: true;
+    readonly convert: true;
+    readonly shorthand: true;
+    readonly datatype: true;
+    readonly effect: true;
+};
+export type Category = keyof typeof categoryRecord;
+export declare const categories: Category[];
+export declare const moduleCategories: Category[];
+export declare const coreCategories: Category[];
+export interface TypedValue {
+    type: DataType[] | DataType;
+    rest?: true;
+    array?: true;
+}
+export type Argument = TypedValue & {
+    description?: string;
+};
+export interface Variant {
+    argumentNames: string[];
+}
+export interface FunctionDocs {
+    category: Category;
+    description: string;
+    returns: TypedValue;
+    args: Record<string, Argument>;
+    variants: Variant[];
+    examples: string[];
+    seeAlso?: string[];
+    hideOperatorForm?: true;
+    tags?: string[];
+}
+export interface CustomDocs {
+    category: Category;
+    description: string;
+    customVariants: string[];
+    details?: [string, string, string | undefined][];
+    returns?: TypedValue;
+    examples: string[];
+    seeAlso?: string[];
+    tags?: string[];
+}
+export type SpecialExpressionDocs = FunctionDocs | CustomDocs;
+export declare function isFunctionDocs(docs: SpecialExpressionDocs): docs is FunctionDocs;
+type NormalExpressionEvaluator<T> = (params: Arr, sourceCodeInfo: SourceCodeInfo | undefined, contextStack: ContextStack, { executeFunction }: {
+    executeFunction: ExecuteFunction;
+}) => MaybePromise<T>;
+export interface BuiltinNormalExpression<T> {
+    evaluate: NormalExpressionEvaluator<T>;
+    pure?: boolean;
+    name?: string;
+    arity: Arity;
+    docs?: FunctionDocs;
+}
+export type BuiltinNormalExpressions = Record<string, BuiltinNormalExpression<Any>>;
+type BuiltinAllNormalExpressions = BuiltinNormalExpression<Any>[];
+interface EvaluateHelpers {
+    evaluateNode: EvaluateNode;
+    builtin: Builtin;
+    getUndefinedSymbols: GetUndefinedSymbols;
+}
+export interface BuiltinSpecialExpression<T, N extends SpecialExpressionNode> {
+    evaluate?: (node: N, contextStack: ContextStack, helpers: EvaluateHelpers) => MaybePromise<T>;
+    evaluateAsNormalExpression?: NormalExpressionEvaluator<T>;
+    arity: Arity;
+    docs?: SpecialExpressionDocs;
+    getUndefinedSymbols: (node: N, contextStack: ContextStack, params: {
+        getUndefinedSymbols: GetUndefinedSymbols;
+        builtin: Builtin;
+        evaluateNode: EvaluateNode;
+    }) => UndefinedSymbols;
+}
+export interface Builtin {
+    normalExpressions: BuiltinNormalExpressions;
+    allNormalExpressions: BuiltinAllNormalExpressions;
+    specialExpressions: SpecialExpressions;
+}
+export {};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,8 @@
+/**
+ * Creates a grid from a flat array with specified dimensions
+ *
+ * @param flatArray The flat array of values
+ * @param rows Number of rows in the resulting grid
+ * @returns A 2D array representing the grid
+ */
+export declare function fromArray(flatArray: unknown[], rows: number): unknown[][];

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

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

package/dist/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/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/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/src/builtin/modules/linear-algebra/helpers/calcFractionalRanks.d.ts

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

package/dist/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/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/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/src/builtin/modules/linear-algebra/helpers/dot.d.ts

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

package/dist/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/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/src/builtin/modules/linear-algebra/helpers/isZeroVector.d.ts

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

package/dist/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/src/builtin/modules/linear-algebra/helpers/length.d.ts

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

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

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

package/dist/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/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/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/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/src/builtin/modules/math/index.d.ts

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

package/dist/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/src/builtin/modules/matrix/helpers/adjugate.d.ts

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

package/dist/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/src/builtin/modules/matrix/helpers/cofactor.d.ts

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

package/dist/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/src/builtin/modules/matrix/helpers/diagonal.d.ts

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

package/dist/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/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/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/src/builtin/modules/matrix/helpers/isIdentity.d.ts

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

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

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

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

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

package/dist/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/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/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/src/builtin/modules/matrix/helpers/minor.d.ts

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

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

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

package/dist/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/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/src/builtin/modules/number-theory/binomialCefficient.d.ts

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

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

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