@danielsimonjr/mathts-functions 0.2.3 → 0.2.4

package/dist/algebra/solver/lsolveAll.d.ts

@@ -0,0 +1,53 @@
+type ScalarValue = number | bigint | {
+    re: number;
+    im: number;
+} | unknown;
+interface TypedFunction {
+    <T>(name: string, signatures: Record<string, (...args: unknown[]) => T>): T;
+}
+interface MatrixConstructor {
+    (data: ScalarValue[] | ScalarValue[][]): DenseMatrix | SparseMatrix;
+}
+export interface DenseMatrix {
+    type: 'DenseMatrix';
+    isDenseMatrix: true;
+    _data: ScalarValue[][];
+    _size: number[];
+    _datatype?: string;
+    valueOf(): ScalarValue[][];
+}
+interface SparseMatrix {
+    type: 'SparseMatrix';
+    isSparseMatrix: true;
+    _values?: ScalarValue[];
+    _index: number[];
+    _ptr: number[];
+    _size: number[];
+    _datatype?: string;
+    valueOf(): ScalarValue[][];
+}
+interface DenseMatrixConstructor {
+    new (data: {
+        data: ScalarValue[][];
+        size: number[];
+        datatype?: string;
+    }): DenseMatrix;
+}
+interface ScalarFunction {
+    (a: ScalarValue, b: ScalarValue): ScalarValue;
+}
+interface EqualScalarFunction {
+    (a: ScalarValue, b: ScalarValue): boolean;
+}
+interface Dependencies {
+    typed: TypedFunction;
+    matrix: MatrixConstructor;
+    divideScalar: ScalarFunction;
+    multiplyScalar: ScalarFunction;
+    subtractScalar: ScalarFunction;
+    equalScalar: EqualScalarFunction;
+    DenseMatrix: DenseMatrixConstructor;
+}
+export declare const createLsolveAll: import("../../utils/factory.js").FactoryFunction<Dependencies, DenseMatrix[]>;
+export {};
+//# sourceMappingURL=lsolveAll.d.ts.map

package/dist/algebra/solver/lsolveAll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lsolveAll.d.ts","sourceRoot":"","sources":["../../../src/algebra/solver/lsolveAll.ts"],"names":[],"mappings":"AAIA,KAAK,WAAW,GAAG,MAAM,GAAG,MAAM,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC;AAE1E,UAAU,aAAa;IACrB,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC;CAC7E;AAED,UAAU,iBAAiB;IACzB,CAAC,IAAI,EAAE,WAAW,EAAE,GAAG,WAAW,EAAE,EAAE,GAAG,WAAW,GAAG,YAAY,CAAC;CACrE;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,aAAa,CAAC;IACpB,aAAa,EAAE,IAAI,CAAC;IACpB,KAAK,EAAE,WAAW,EAAE,EAAE,CAAC;IACvB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,IAAI,WAAW,EAAE,EAAE,CAAC;CAC5B;AAED,UAAU,YAAY;IACpB,IAAI,EAAE,cAAc,CAAC;IACrB,cAAc,EAAE,IAAI,CAAC;IACrB,OAAO,CAAC,EAAE,WAAW,EAAE,CAAC;IACxB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,IAAI,WAAW,EAAE,EAAE,CAAC;CAC5B;AAED,UAAU,sBAAsB;IAC9B,KAAK,IAAI,EAAE;QAAE,IAAI,EAAE,WAAW,EAAE,EAAE,CAAC;QAAC,IAAI,EAAE,MAAM,EAAE,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,WAAW,CAAC;CACvF;AAED,UAAU,cAAc;IACtB,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,GAAG,WAAW,CAAC;CAC/C;AAED,UAAU,mBAAmB;IAC3B,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC;CAC3C;AAUD,UAAU,YAAY;IACpB,KAAK,EAAE,aAAa,CAAC;IACrB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,YAAY,EAAE,cAAc,CAAC;IAC7B,cAAc,EAAE,cAAc,CAAC;IAC/B,cAAc,EAAE,cAAc,CAAC;IAC/B,WAAW,EAAE,mBAAmB,CAAC;IACjC,WAAW,EAAE,sBAAsB,CAAC;CACrC;AAaD,eAAO,MAAM,eAAe,+EAkO3B,CAAC"}

package/dist/algebra/solver/lusolve.d.ts

@@ -0,0 +1,62 @@
+interface TypedFunction<T = any> {
+    (...args: any[]): T;
+}
+interface MatrixConstructor {
+    (data: any[] | any[][], storage?: 'dense' | 'sparse'): DenseMatrix | SparseMatrix;
+}
+interface DenseMatrix {
+    type: 'DenseMatrix';
+    isDenseMatrix: true;
+    _data: any[][];
+    _size: number[];
+    _datatype?: string;
+    valueOf(): any[][];
+}
+interface SparseMatrix {
+    type: 'SparseMatrix';
+    isSparseMatrix: true;
+    _values?: any[];
+    _index?: number[];
+    _ptr?: number[];
+    _size: number[];
+    _datatype?: string;
+    _data?: any;
+    valueOf(): any[][];
+}
+interface DenseMatrixConstructor {
+    new (data: {
+        data: any[][];
+        size: number[];
+        datatype?: string;
+    }): DenseMatrix;
+}
+interface LUPDecomposition {
+    L: DenseMatrix | SparseMatrix | any[][];
+    U: DenseMatrix | SparseMatrix | any[][];
+    p: number[] | null;
+    q?: number[] | null;
+}
+interface LupFunction {
+    (matrix: DenseMatrix | SparseMatrix | any[][]): LUPDecomposition;
+}
+interface SluFunction {
+    (matrix: SparseMatrix, order: number, threshold: number): LUPDecomposition;
+}
+interface LsolveFunction {
+    (L: DenseMatrix | SparseMatrix, b: DenseMatrix): DenseMatrix;
+}
+interface UsolveFunction {
+    (U: DenseMatrix | SparseMatrix, b: DenseMatrix): DenseMatrix;
+}
+interface Dependencies {
+    typed: TypedFunction;
+    matrix: MatrixConstructor;
+    lup: LupFunction;
+    slu: SluFunction;
+    usolve: UsolveFunction;
+    lsolve: LsolveFunction;
+    DenseMatrix: DenseMatrixConstructor;
+}
+export declare const createLusolve: import("../../utils/factory.js").FactoryFunction<Dependencies, any>;
+export {};
+//# sourceMappingURL=lusolve.d.ts.map

package/dist/algebra/solver/lusolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lusolve.d.ts","sourceRoot":"","sources":["../../../src/algebra/solver/lusolve.ts"],"names":[],"mappings":"AAYA,UAAU,aAAa,CAAC,CAAC,GAAG,GAAG;IAC7B,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;CACrB;AAED,UAAU,iBAAiB;IACzB,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,GAAG,EAAE,EAAE,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,QAAQ,GAAG,WAAW,GAAG,YAAY,CAAC;CACnF;AAED,UAAU,WAAW;IACnB,IAAI,EAAE,aAAa,CAAC;IACpB,aAAa,EAAE,IAAI,CAAC;IACpB,KAAK,EAAE,GAAG,EAAE,EAAE,CAAC;IACf,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,IAAI,GAAG,EAAE,EAAE,CAAC;CACpB;AAED,UAAU,YAAY;IACpB,IAAI,EAAE,cAAc,CAAC;IACrB,cAAc,EAAE,IAAI,CAAC;IACrB,OAAO,CAAC,EAAE,GAAG,EAAE,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,GAAG,CAAC;IACZ,OAAO,IAAI,GAAG,EAAE,EAAE,CAAC;CACpB;AAED,UAAU,sBAAsB;IAC9B,KAAK,IAAI,EAAE;QAAE,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC;QAAC,IAAI,EAAE,MAAM,EAAE,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,WAAW,CAAC;CAC/E;AAED,UAAU,gBAAgB;IACxB,CAAC,EAAE,WAAW,GAAG,YAAY,GAAG,GAAG,EAAE,EAAE,CAAC;IACxC,CAAC,EAAE,WAAW,GAAG,YAAY,GAAG,GAAG,EAAE,EAAE,CAAC;IACxC,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IACnB,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;CACrB;AAUD,UAAU,WAAW;IACnB,CAAC,MAAM,EAAE,WAAW,GAAG,YAAY,GAAG,GAAG,EAAE,EAAE,GAAG,gBAAgB,CAAC;CAClE;AAED,UAAU,WAAW;IACnB,CAAC,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,gBAAgB,CAAC;CAC5E;AAED,UAAU,cAAc;IACtB,CAAC,CAAC,EAAE,WAAW,GAAG,YAAY,EAAE,CAAC,EAAE,WAAW,GAAG,WAAW,CAAC;CAC9D;AAED,UAAU,cAAc;IACtB,CAAC,CAAC,EAAE,WAAW,GAAG,YAAY,EAAE,CAAC,EAAE,WAAW,GAAG,WAAW,CAAC;CAC9D;AAED,UAAU,YAAY;IACpB,KAAK,EAAE,aAAa,CAAC;IACrB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,GAAG,EAAE,WAAW,CAAC;IACjB,GAAG,EAAE,WAAW,CAAC;IACjB,MAAM,EAAE,cAAc,CAAC;IACvB,MAAM,EAAE,cAAc,CAAC;IACvB,WAAW,EAAE,sBAAsB,CAAC;CACrC;AAwDD,eAAO,MAAM,aAAa,qEA4PzB,CAAC"}

package/dist/algebra/solver/usolve.d.ts

@@ -0,0 +1,46 @@
+interface TypedFunction<T = any> {
+    (...args: any[]): T;
+}
+interface MatrixConstructor {
+    (data: any[] | any[][], storage?: 'dense' | 'sparse'): DenseMatrix | SparseMatrix;
+}
+interface DenseMatrix {
+    type: 'DenseMatrix';
+    isDenseMatrix: true;
+    _data: any[][];
+    _size: number[];
+    _datatype?: string;
+    valueOf(): any[][];
+}
+interface SparseMatrix {
+    type: 'SparseMatrix';
+    isSparseMatrix: true;
+    _values?: any[];
+    _index: number[];
+    _ptr: number[];
+    _size: number[];
+    _datatype?: string;
+    valueOf(): any[][];
+}
+interface DenseMatrixConstructor {
+    new (data: {
+        data: any[][];
+        size: number[];
+        datatype?: string;
+    }): DenseMatrix;
+}
+interface ScalarFunction {
+    (a: any, b: any): any;
+}
+interface Dependencies {
+    typed: TypedFunction;
+    matrix: MatrixConstructor;
+    divideScalar: ScalarFunction;
+    multiplyScalar: ScalarFunction;
+    subtractScalar: ScalarFunction;
+    equalScalar: ScalarFunction;
+    DenseMatrix: DenseMatrixConstructor;
+}
+export declare const createUsolve: import("../../utils/factory.js").FactoryFunction<Dependencies, any>;
+export {};
+//# sourceMappingURL=usolve.d.ts.map

package/dist/algebra/solver/usolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usolve.d.ts","sourceRoot":"","sources":["../../../src/algebra/solver/usolve.ts"],"names":[],"mappings":"AAQA,UAAU,aAAa,CAAC,CAAC,GAAG,GAAG;IAC7B,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;CACrB;AAED,UAAU,iBAAiB;IACzB,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,GAAG,EAAE,EAAE,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,QAAQ,GAAG,WAAW,GAAG,YAAY,CAAC;CACnF;AAED,UAAU,WAAW;IACnB,IAAI,EAAE,aAAa,CAAC;IACpB,aAAa,EAAE,IAAI,CAAC;IACpB,KAAK,EAAE,GAAG,EAAE,EAAE,CAAC;IACf,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,IAAI,GAAG,EAAE,EAAE,CAAC;CACpB;AAED,UAAU,YAAY;IACpB,IAAI,EAAE,cAAc,CAAC;IACrB,cAAc,EAAE,IAAI,CAAC;IACrB,OAAO,CAAC,EAAE,GAAG,EAAE,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,IAAI,GAAG,EAAE,EAAE,CAAC;CACpB;AAED,UAAU,sBAAsB;IAC9B,KAAK,IAAI,EAAE;QAAE,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC;QAAC,IAAI,EAAE,MAAM,EAAE,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,WAAW,CAAC;CAC/E;AAUD,UAAU,cAAc;IACtB,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG,GAAG,CAAC;CACvB;AAED,UAAU,YAAY;IACpB,KAAK,EAAE,aAAa,CAAC;IACrB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,YAAY,EAAE,cAAc,CAAC;IAC7B,cAAc,EAAE,cAAc,CAAC;IAC/B,cAAc,EAAE,cAAc,CAAC;IAC/B,WAAW,EAAE,cAAc,CAAC;IAC5B,WAAW,EAAE,sBAAsB,CAAC;CACrC;AAgED,eAAO,MAAM,YAAY,qEAgPxB,CAAC"}

package/dist/algebra/solver/usolveAll.d.ts

@@ -0,0 +1,53 @@
+type ScalarValue = number | bigint | {
+    re: number;
+    im: number;
+} | unknown;
+interface TypedFunction {
+    <T>(name: string, signatures: Record<string, (...args: unknown[]) => T>): T;
+}
+interface MatrixConstructor {
+    (data: ScalarValue[] | ScalarValue[][]): DenseMatrix | SparseMatrix;
+}
+export interface DenseMatrix {
+    type: 'DenseMatrix';
+    isDenseMatrix: true;
+    _data: ScalarValue[][];
+    _size: number[];
+    _datatype?: string;
+    valueOf(): ScalarValue[][];
+}
+interface SparseMatrix {
+    type: 'SparseMatrix';
+    isSparseMatrix: true;
+    _values?: ScalarValue[];
+    _index: number[];
+    _ptr: number[];
+    _size: number[];
+    _datatype?: string;
+    valueOf(): ScalarValue[][];
+}
+interface DenseMatrixConstructor {
+    new (data: {
+        data: ScalarValue[][];
+        size: number[];
+        datatype?: string;
+    }): DenseMatrix;
+}
+interface ScalarFunction {
+    (a: ScalarValue, b: ScalarValue): ScalarValue;
+}
+interface EqualScalarFunction {
+    (a: ScalarValue, b: ScalarValue): boolean;
+}
+interface Dependencies {
+    typed: TypedFunction;
+    matrix: MatrixConstructor;
+    divideScalar: ScalarFunction;
+    multiplyScalar: ScalarFunction;
+    subtractScalar: ScalarFunction;
+    equalScalar: EqualScalarFunction;
+    DenseMatrix: DenseMatrixConstructor;
+}
+export declare const createUsolveAll: import("../../utils/factory.js").FactoryFunction<Dependencies, DenseMatrix[]>;
+export {};
+//# sourceMappingURL=usolveAll.d.ts.map

package/dist/algebra/solver/usolveAll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usolveAll.d.ts","sourceRoot":"","sources":["../../../src/algebra/solver/usolveAll.ts"],"names":[],"mappings":"AAIA,KAAK,WAAW,GAAG,MAAM,GAAG,MAAM,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC;AAE1E,UAAU,aAAa;IACrB,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC;CAC7E;AAED,UAAU,iBAAiB;IACzB,CAAC,IAAI,EAAE,WAAW,EAAE,GAAG,WAAW,EAAE,EAAE,GAAG,WAAW,GAAG,YAAY,CAAC;CACrE;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,aAAa,CAAC;IACpB,aAAa,EAAE,IAAI,CAAC;IACpB,KAAK,EAAE,WAAW,EAAE,EAAE,CAAC;IACvB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,IAAI,WAAW,EAAE,EAAE,CAAC;CAC5B;AAED,UAAU,YAAY;IACpB,IAAI,EAAE,cAAc,CAAC;IACrB,cAAc,EAAE,IAAI,CAAC;IACrB,OAAO,CAAC,EAAE,WAAW,EAAE,CAAC;IACxB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,IAAI,WAAW,EAAE,EAAE,CAAC;CAC5B;AAED,UAAU,sBAAsB;IAC9B,KAAK,IAAI,EAAE;QAAE,IAAI,EAAE,WAAW,EAAE,EAAE,CAAC;QAAC,IAAI,EAAE,MAAM,EAAE,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,WAAW,CAAC;CACvF;AAED,UAAU,cAAc;IACtB,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,GAAG,WAAW,CAAC;CAC/C;AAED,UAAU,mBAAmB;IAC3B,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC;CAC3C;AAUD,UAAU,YAAY;IACpB,KAAK,EAAE,aAAa,CAAC;IACrB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,YAAY,EAAE,cAAc,CAAC;IAC7B,cAAc,EAAE,cAAc,CAAC;IAC/B,cAAc,EAAE,cAAc,CAAC;IAC/B,WAAW,EAAE,mBAAmB,CAAC;IACjC,WAAW,EAAE,sBAAsB,CAAC;CACrC;AAaD,eAAO,MAAM,eAAe,+EAoO3B,CAAC"}

package/dist/algebra/solver/utils/solveValidation.d.ts

@@ -0,0 +1,31 @@
+interface DenseMatrixType {
+    type: 'DenseMatrix';
+    isDenseMatrix: true;
+    _data: any[][];
+    _size: number[];
+    _datatype?: string;
+    size(): number[];
+}
+interface SparseMatrixType {
+    type: 'SparseMatrix';
+    isSparseMatrix: true;
+    _values?: any[];
+    _index?: number[];
+    _ptr?: number[];
+    _size: number[];
+    _datatype?: string;
+    size(): number[];
+}
+interface DenseMatrixConstructor {
+    new (data: {
+        data: any[][];
+        size: number[];
+        datatype?: string;
+    }): DenseMatrixType;
+}
+interface SolveValidationDependencies {
+    DenseMatrix: DenseMatrixConstructor;
+}
+export declare function createSolveValidation({ DenseMatrix }: SolveValidationDependencies): (m: DenseMatrixType | SparseMatrixType, b: any[][] | DenseMatrixType | SparseMatrixType, copy?: boolean) => DenseMatrixType;
+export {};
+//# sourceMappingURL=solveValidation.d.ts.map

package/dist/algebra/solver/utils/solveValidation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solveValidation.d.ts","sourceRoot":"","sources":["../../../../src/algebra/solver/utils/solveValidation.ts"],"names":[],"mappings":"AAKA,UAAU,eAAe;IACvB,IAAI,EAAE,aAAa,CAAC;IACpB,aAAa,EAAE,IAAI,CAAC;IACpB,KAAK,EAAE,GAAG,EAAE,EAAE,CAAC;IACf,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,IAAI,MAAM,EAAE,CAAC;CAClB;AAED,UAAU,gBAAgB;IACxB,IAAI,EAAE,cAAc,CAAC;IACrB,cAAc,EAAE,IAAI,CAAC;IACrB,OAAO,CAAC,EAAE,GAAG,EAAE,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,IAAI,MAAM,EAAE,CAAC;CAClB;AAED,UAAU,sBAAsB;IAC9B,KAAK,IAAI,EAAE;QAAE,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC;QAAC,IAAI,EAAE,MAAM,EAAE,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,eAAe,CAAC;CACnF;AAED,UAAU,2BAA2B;IACnC,WAAW,EAAE,sBAAsB,CAAC;CACrC;AAED,wBAAgB,qBAAqB,CAAC,EAAE,WAAW,EAAE,EAAE,2BAA2B,IAW9E,GAAG,eAAe,GAAG,gBAAgB,EACrC,GAAG,GAAG,EAAE,EAAE,GAAG,eAAe,GAAG,gBAAgB,EAC/C,OAAO,OAAO,KACb,eAAe,CA8HnB"}

package/dist/algebra/sparse/csAmd.d.ts

@@ -0,0 +1,15 @@
+import type { TypedFunction } from '../../core/function/typed.js';
+export interface SparseMatrixData {
+    _size: number[];
+    _values?: any[];
+    _index: number[];
+    _ptr: number[];
+}
+interface CsAmdDependencies {
+    add: TypedFunction;
+    multiply: TypedFunction;
+    transpose: TypedFunction;
+}
+export declare const createCsAmd: import("../../utils/factory.js").FactoryFunction<CsAmdDependencies, (order: number, a: SparseMatrixData | null) => number[] | null>;
+export {};
+//# sourceMappingURL=csAmd.d.ts.map

package/dist/algebra/sparse/csAmd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"csAmd.d.ts","sourceRoot":"","sources":["../../../src/algebra/sparse/csAmd.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAMlE,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,CAAC,EAAE,GAAG,EAAE,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAED,UAAU,iBAAiB;IACzB,GAAG,EAAE,aAAa,CAAC;IACnB,QAAQ,EAAE,aAAa,CAAC;IACxB,SAAS,EAAE,aAAa,CAAC;CAC1B;AAKD,eAAO,MAAM,WAAW,8EAoDS,MAAM,KAAK,gBAAgB,GAAG,IAAI,KAAG,MAAM,EAAE,GAAG,IAAI,CA8mBpF,CAAC"}

package/dist/algebra/sparse/csChol.d.ts

@@ -0,0 +1,39 @@
+import type { TypedFunction } from '../../core/function/typed.js';
+export interface SparseMatrixData {
+    _size: number[];
+    _values: any[];
+    _index: number[];
+    _ptr: number[];
+}
+interface SparseMatrixConstructor {
+    new (data: {
+        values: any[];
+        index: number[];
+        ptr: number[];
+        size: number[];
+    }): SparseMatrixData;
+}
+interface CsCholDependencies {
+    divideScalar: TypedFunction;
+    sqrt: TypedFunction;
+    subtract: TypedFunction;
+    multiply: TypedFunction;
+    im: TypedFunction;
+    re: TypedFunction;
+    conj: TypedFunction;
+    equal: TypedFunction;
+    smallerEq: TypedFunction;
+    SparseMatrix: SparseMatrixConstructor;
+}
+export interface SymbolicAnalysis {
+    parent: number[];
+    cp: number[];
+    pinv?: number[];
+}
+export interface CholResult {
+    L: SparseMatrixData;
+    P?: SparseMatrixData;
+}
+export declare const createCsChol: import("../../utils/factory.js").FactoryFunction<CsCholDependencies, (m: SparseMatrixData | null, s: SymbolicAnalysis) => CholResult | null>;
+export {};
+//# sourceMappingURL=csChol.d.ts.map

package/dist/algebra/sparse/csChol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"csChol.d.ts","sourceRoot":"","sources":["../../../src/algebra/sparse/csChol.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAGlE,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,GAAG,EAAE,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAED,UAAU,uBAAuB;IAC/B,KAAK,IAAI,EAAE;QAAE,MAAM,EAAE,GAAG,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,GAAG,EAAE,MAAM,EAAE,CAAC;QAAC,IAAI,EAAE,MAAM,EAAE,CAAA;KAAE,GAAG,gBAAgB,CAAC;CACjG;AAED,UAAU,kBAAkB;IAC1B,YAAY,EAAE,aAAa,CAAC;IAC5B,IAAI,EAAE,aAAa,CAAC;IACpB,QAAQ,EAAE,aAAa,CAAC;IACxB,QAAQ,EAAE,aAAa,CAAC;IACxB,EAAE,EAAE,aAAa,CAAC;IAClB,EAAE,EAAE,aAAa,CAAC;IAClB,IAAI,EAAE,aAAa,CAAC;IACpB,KAAK,EAAE,aAAa,CAAC;IACrB,SAAS,EAAE,aAAa,CAAC;IACzB,YAAY,EAAE,uBAAuB,CAAC;CACvC;AAGD,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,EAAE,EAAE,MAAM,EAAE,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;CACjB;AAGD,MAAM,WAAW,UAAU;IACzB,CAAC,EAAE,gBAAgB,CAAC;IACpB,CAAC,CAAC,EAAE,gBAAgB,CAAC;CACtB;AAgBD,eAAO,MAAM,YAAY,2EA0BK,gBAAgB,GAAG,IAAI,KAAK,gBAAgB,KAAG,UAAU,GAAG,IAAI,CAuH7F,CAAC"}

package/dist/algebra/sparse/csCounts.d.ts

@@ -0,0 +1,13 @@
+import type { TypedFunction } from '../../core/function/typed.js';
+export interface SparseMatrixData {
+    _size: number[];
+    _values?: any[];
+    _index: number[];
+    _ptr: number[];
+}
+interface CsCountsDependencies {
+    transpose: TypedFunction;
+}
+export declare const createCsCounts: import("../../utils/factory.js").FactoryFunction<CsCountsDependencies, (a: SparseMatrixData | null, parent: number[] | null, post: number[] | null, ata: boolean) => number[] | null>;
+export {};
+//# sourceMappingURL=csCounts.d.ts.map

package/dist/algebra/sparse/csCounts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"csCounts.d.ts","sourceRoot":"","sources":["../../../src/algebra/sparse/csCounts.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAMlE,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,CAAC,EAAE,GAAG,EAAE,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAED,UAAU,oBAAoB;IAC5B,SAAS,EAAE,aAAa,CAAC;CAC1B;AAKD,eAAO,MAAM,cAAc,6EAkElB,gBAAgB,GAAG,IAAI,UAClB,MAAM,EAAE,GAAG,IAAI,QACjB,MAAM,EAAE,GAAG,IAAI,OAChB,OAAO,KACX,MAAM,EAAE,GAAG,IAAI,CAgHrB,CAAC"}

package/dist/algebra/sparse/csCumsum.d.ts

@@ -0,0 +1,9 @@
+/**
+ * It sets the p[i] equal to the sum of c[0] through c[i-1].
+ *
+ * @param {Array}   ptr             The Sparse Matrix ptr array
+ * @param {Array}   c               The Sparse Matrix ptr array
+ * @param {Number}  n               The number of columns
+ */
+export declare function csCumsum(ptr: number[], c: number[], n: number): number;
+//# sourceMappingURL=csCumsum.d.ts.map

package/dist/algebra/sparse/csCumsum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"csCumsum.d.ts","sourceRoot":"","sources":["../../../src/algebra/sparse/csCumsum.ts"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAiBtE"}

package/dist/algebra/sparse/csDfs.d.ts

@@ -0,0 +1,23 @@
+interface SparseMatrixData {
+    _size: number[];
+    _values?: any[];
+    _index: number[];
+    _ptr: number[];
+}
+/**
+ * Depth-first search computes the nonzero pattern xi of the directed graph G (Matrix) starting
+ * at nodes in B (see csReach()).
+ *
+ * @param {Number}  j               The starting node for the DFS algorithm
+ * @param {Matrix}  g               The G matrix to search, ptr array modified, then restored
+ * @param {Number}  top             Start index in stack xi[top..n-1]
+ * @param {Number}  k               The kth column in B
+ * @param {Array}   xi              The nonzero pattern xi[top] .. xi[n - 1], an array of size = 2 * n
+ *                                  The first n entries is the nonzero pattern, the last n entries is the stack
+ * @param {Array}   pinv            The inverse row permutation vector, must be null for L * x = b
+ *
+ * @return {Number}                 New value of top
+ */
+export declare function csDfs(j: number, g: SparseMatrixData, top: number, xi: number[], pinv: number[] | null): number;
+export {};
+//# sourceMappingURL=csDfs.d.ts.map

package/dist/algebra/sparse/csDfs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"csDfs.d.ts","sourceRoot":"","sources":["../../../src/algebra/sparse/csDfs.ts"],"names":[],"mappings":"AAQA,UAAU,gBAAgB;IACxB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,CAAC,EAAE,GAAG,EAAE,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,KAAK,CACnB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,gBAAgB,EACnB,GAAG,EAAE,MAAM,EACX,EAAE,EAAE,MAAM,EAAE,EACZ,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,GACpB,MAAM,CAsDR"}

package/dist/algebra/sparse/csEreach.d.ts

@@ -0,0 +1,20 @@
+interface SparseMatrixData {
+    _size: number[];
+    _values?: any[];
+    _index: number[];
+    _ptr: number[];
+}
+/**
+ * Find nonzero pattern of Cholesky L(k,1:k-1) using etree and triu(A(:,k))
+ *
+ * @param {Matrix}  a               The A matrix
+ * @param {Number}  k               The kth column in A
+ * @param {Array}   parent          The parent vector from the symbolic analysis result
+ * @param {Array}   w               The nonzero pattern xi[top] .. xi[n - 1], an array of size = 2 * n
+ *                                  The first n entries is the nonzero pattern, the last n entries is the stack
+ *
+ * @return {Number}                 The index for the nonzero pattern
+ */
+export declare function csEreach(a: SparseMatrixData, k: number, parent: number[], w: number[]): number;
+export {};
+//# sourceMappingURL=csEreach.d.ts.map

package/dist/algebra/sparse/csEreach.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"csEreach.d.ts","sourceRoot":"","sources":["../../../src/algebra/sparse/csEreach.ts"],"names":[],"mappings":"AAOA,UAAU,gBAAgB;IACxB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,CAAC,EAAE,GAAG,EAAE,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,gBAAgB,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,CA6C9F"}

package/dist/algebra/sparse/csEtree.d.ts

@@ -0,0 +1,16 @@
+interface SparseMatrixData {
+    _size: number[];
+    _values?: any[];
+    _index: number[];
+    _ptr: number[];
+}
+/**
+ * Computes the elimination tree of Matrix A (using triu(A)) or the
+ * elimination tree of A'A without forming A'A.
+ *
+ * @param {Matrix}  a               The A Matrix
+ * @param {boolean} ata             A value of true the function computes the etree of A'A
+ */
+export declare function csEtree(a: SparseMatrixData | null, ata: boolean): number[] | null;
+export {};
+//# sourceMappingURL=csEtree.d.ts.map

package/dist/algebra/sparse/csEtree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"csEtree.d.ts","sourceRoot":"","sources":["../../../src/algebra/sparse/csEtree.ts"],"names":[],"mappings":"AAKA,UAAU,gBAAgB;IACxB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,CAAC,EAAE,GAAG,EAAE,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAED;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,gBAAgB,GAAG,IAAI,EAAE,GAAG,EAAE,OAAO,GAAG,MAAM,EAAE,GAAG,IAAI,CA2DjF"}

package/dist/algebra/sparse/csFkeep.d.ts

@@ -0,0 +1,22 @@
+interface SparseMatrixData {
+    _size: number[];
+    _values?: any[];
+    _index: number[];
+    _ptr: number[];
+}
+/**
+ * Keeps entries in the matrix when the callback function returns true, removes the entry otherwise
+ *
+ * @param {Matrix}   a              The sparse matrix
+ * @param {function} callback       The callback function, function will be invoked with the following args:
+ *                                    - The entry row
+ *                                    - The entry column
+ *                                    - The entry value
+ *                                    - The state parameter
+ * @param {any}      other          The state
+ *
+ * @return                          The number of nonzero elements in the matrix
+ */
+export declare function csFkeep<T, S = unknown>(a: SparseMatrixData, callback: (row: number, col: number, value: T, state: S) => boolean, other: S): number;
+export {};
+//# sourceMappingURL=csFkeep.d.ts.map

package/dist/algebra/sparse/csFkeep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"csFkeep.d.ts","sourceRoot":"","sources":["../../../src/algebra/sparse/csFkeep.ts"],"names":[],"mappings":"AAKA,UAAU,gBAAgB;IACxB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,CAAC,EAAE,GAAG,EAAE,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO,EACpC,CAAC,EAAE,gBAAgB,EACnB,QAAQ,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,OAAO,EACnE,KAAK,EAAE,CAAC,GACP,MAAM,CAwCR"}

package/dist/algebra/sparse/csFlip.d.ts

@@ -0,0 +1,7 @@
+/**
+ * This function "flips" its input about the integer -1.
+ *
+ * @param {Number}  i               The value to flip
+ */
+export declare function csFlip(i: number): number;
+//# sourceMappingURL=csFlip.d.ts.map

package/dist/algebra/sparse/csFlip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"csFlip.d.ts","sourceRoot":"","sources":["../../../src/algebra/sparse/csFlip.ts"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAGxC"}

package/dist/algebra/sparse/csIpvec.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Permutes a vector; x = P'b. In MATLAB notation, x(p)=b.
+ *
+ * @param {Array} p           The permutation vector of length n. null value denotes identity
+ * @param {Array} b           The input vector
+ *
+ * @return {Array}            The output vector x = P'b
+ */
+export declare function csIpvec<T>(p: number[] | null, b: T[]): T[];
+//# sourceMappingURL=csIpvec.d.ts.map

package/dist/algebra/sparse/csIpvec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"csIpvec.d.ts","sourceRoot":"","sources":["../../../src/algebra/sparse/csIpvec.ts"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAoB1D"}

package/dist/algebra/sparse/csLeaf.d.ts

@@ -0,0 +1,21 @@
+interface CsLeafResult {
+    jleaf: number;
+    q: number;
+}
+/**
+ * This function determines if j is a leaf of the ith row subtree.
+ * Consider A(i,j), node j in ith row subtree and return lca(jprev,j)
+ *
+ * @param {Number}  i               The ith row subtree
+ * @param {Number}  j               The node to test
+ * @param {Array}   w               The workspace array
+ * @param {Number}  first           The index offset within the workspace for the first array
+ * @param {Number}  maxfirst        The index offset within the workspace for the maxfirst array
+ * @param {Number}  prevleaf        The index offset within the workspace for the prevleaf array
+ * @param {Number}  ancestor        The index offset within the workspace for the ancestor array
+ *
+ * @return {Object}
+ */
+export declare function csLeaf(i: number, j: number, w: number[], first: number, maxfirst: number, prevleaf: number, ancestor: number): number | CsLeafResult;
+export {};
+//# sourceMappingURL=csLeaf.d.ts.map

package/dist/algebra/sparse/csLeaf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"csLeaf.d.ts","sourceRoot":"","sources":["../../../src/algebra/sparse/csLeaf.ts"],"names":[],"mappings":"AAIA,UAAU,YAAY;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,CAAC,EAAE,MAAM,CAAC;CACX;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,MAAM,CACpB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EAAE,EACX,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,GACf,MAAM,GAAG,YAAY,CAkCvB"}

package/dist/algebra/sparse/csLu.d.ts

@@ -0,0 +1,37 @@
+import type { TypedFunction } from '../../core/function/typed.js';
+export interface SparseMatrixData {
+    _size: number[];
+    _values: any[];
+    _index: number[];
+    _ptr: number[];
+}
+interface SparseMatrixConstructor {
+    new (data: {
+        values: any[];
+        index: number[];
+        ptr: number[];
+        size: number[];
+    }): SparseMatrixData;
+}
+interface CsLuDependencies {
+    abs: TypedFunction;
+    divideScalar: TypedFunction;
+    multiply: TypedFunction;
+    subtract: TypedFunction;
+    larger: TypedFunction;
+    largerEq: TypedFunction;
+    SparseMatrix: SparseMatrixConstructor;
+}
+export interface SymbolicAnalysis {
+    q?: number[];
+    lnz?: number;
+    unz?: number;
+}
+export interface LuResult {
+    L: SparseMatrixData;
+    U: SparseMatrixData;
+    pinv: number[];
+}
+export declare const createCsLu: import("../../utils/factory.js").FactoryFunction<CsLuDependencies, (m: SparseMatrixData | null, s: SymbolicAnalysis | null, tol: number) => LuResult | null>;
+export {};
+//# sourceMappingURL=csLu.d.ts.map

package/dist/algebra/sparse/csLu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"csLu.d.ts","sourceRoot":"","sources":["../../../src/algebra/sparse/csLu.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAGlE,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,GAAG,EAAE,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAED,UAAU,uBAAuB;IAC/B,KAAK,IAAI,EAAE;QAAE,MAAM,EAAE,GAAG,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,GAAG,EAAE,MAAM,EAAE,CAAC;QAAC,IAAI,EAAE,MAAM,EAAE,CAAA;KAAE,GAAG,gBAAgB,CAAC;CACjG;AAED,UAAU,gBAAgB;IACxB,GAAG,EAAE,aAAa,CAAC;IACnB,YAAY,EAAE,aAAa,CAAC;IAC5B,QAAQ,EAAE,aAAa,CAAC;IACxB,QAAQ,EAAE,aAAa,CAAC;IACxB,MAAM,EAAE,aAAa,CAAC;IACtB,QAAQ,EAAE,aAAa,CAAC;IACxB,YAAY,EAAE,uBAAuB,CAAC;CACvC;AAGD,MAAM,WAAW,gBAAgB;IAC/B,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAGD,MAAM,WAAW,QAAQ;IACvB,CAAC,EAAE,gBAAgB,CAAC;IACpB,CAAC,EAAE,gBAAgB,CAAC;IACpB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAaD,eAAO,MAAM,UAAU,yEAoBd,gBAAgB,GAAG,IAAI,KACvB,gBAAgB,GAAG,IAAI,OACrB,MAAM,KACV,QAAQ,GAAG,IAAI,CA6IrB,CAAC"}

package/dist/algebra/sparse/csMark.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Marks the node at w[j]
+ *
+ * @param {Array}   w               The array
+ * @param {Number}  j               The array index
+ */
+export declare function csMark(w: number[], j: number): void;
+//# sourceMappingURL=csMark.d.ts.map

package/dist/algebra/sparse/csMark.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"csMark.d.ts","sourceRoot":"","sources":["../../../src/algebra/sparse/csMark.ts"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAGnD"}

package/dist/algebra/sparse/csMarked.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Checks if the node at w[j] is marked
+ *
+ * @param {Array}   w               The array
+ * @param {Number}  j               The array index
+ */
+export declare function csMarked(w: number[], j: number): boolean;
+//# sourceMappingURL=csMarked.d.ts.map

package/dist/algebra/sparse/csMarked.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"csMarked.d.ts","sourceRoot":"","sources":["../../../src/algebra/sparse/csMarked.ts"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAGxD"}

package/dist/algebra/sparse/csPermute.d.ts

@@ -0,0 +1,27 @@
+interface SparseMatrixData {
+    _size: number[];
+    _values?: any[];
+    _index: number[];
+    _ptr: number[];
+    _datatype?: string;
+    createSparseMatrix(data: {
+        values: any[] | null;
+        index: number[];
+        ptr: number[];
+        size: number[];
+        datatype?: string;
+    }): SparseMatrixData;
+}
+/**
+ * Permutes a sparse matrix C = P * A * Q
+ *
+ * @param {SparseMatrix}  a         The Matrix A
+ * @param {Array}   pinv            The row permutation vector
+ * @param {Array}   q               The column permutation vector
+ * @param {boolean} values          Create a pattern matrix (false), values and pattern otherwise
+ *
+ * @return {Matrix}                 C = P * A * Q, null on error
+ */
+export declare function csPermute(a: SparseMatrixData, pinv: number[] | null, q: number[] | null, values: boolean): SparseMatrixData;
+export {};
+//# sourceMappingURL=csPermute.d.ts.map

package/dist/algebra/sparse/csPermute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"csPermute.d.ts","sourceRoot":"","sources":["../../../src/algebra/sparse/csPermute.ts"],"names":[],"mappings":"AAKA,UAAU,gBAAgB;IACxB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,CAAC,EAAE,GAAG,EAAE,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,kBAAkB,CAAC,IAAI,EAAE;QACvB,MAAM,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;QACrB,KAAK,EAAE,MAAM,EAAE,CAAC;QAChB,GAAG,EAAE,MAAM,EAAE,CAAC;QACd,IAAI,EAAE,MAAM,EAAE,CAAC;QACf,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,GAAG,gBAAgB,CAAC;CACtB;AAED;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CACvB,CAAC,EAAE,gBAAgB,EACnB,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,EACrB,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,EAClB,MAAM,EAAE,OAAO,GACd,gBAAgB,CA8ClB"}

package/dist/algebra/sparse/csPost.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Post order a tree of forest
+ *
+ * @param {Array}   parent          The tree or forest
+ * @param {Number}  n               Number of columns
+ */
+export declare function csPost(parent: number[] | null, n: number): number[] | null;
+//# sourceMappingURL=csPost.d.ts.map