@cortex-js/compute-engine 0.20.2 → 0.22.0

package/dist/types/compute-engine/symbolic/tensor-fields.d.ts

@@ -0,0 +1,168 @@
+/* 0.22.0 */
+import { BoxedExpression, IComputeEngine } from '../public';
+export type DataTypeMap = {
+    float64: number;
+    float32: number;
+    int32: number;
+    uint8: number;
+    complex128: Complex;
+    complex64: Complex;
+    bool: boolean;
+    string: string;
+    expression: BoxedExpression;
+};
+export type TensorDataType = keyof DataTypeMap;
+export declare function makeTensorField<DT extends keyof DataTypeMap>(ce: IComputeEngine, dtype: DT): TensorField<DataTypeMap[DT]>;
+export interface TensorField<T extends number | Complex | BoxedExpression | boolean | string = number> {
+    readonly one: T;
+    readonly zero: T;
+    readonly nan: T;
+    cast(x: T, dtype: 'float64'): undefined | number;
+    cast(x: T, dtype: 'float32'): undefined | number;
+    cast(x: T, dtype: 'int32'): undefined | number;
+    cast(x: T, dtype: 'uint8'): undefined | number;
+    cast(x: T, dtype: 'complex128'): undefined | Complex;
+    cast(x: T, dtype: 'complex64'): undefined | Complex;
+    cast(x: T, dtype: 'bool'): undefined | boolean;
+    cast(x: T, dtype: 'string'): undefined | string;
+    cast(x: T, dtype: 'expression'): undefined | BoxedExpression;
+    cast(x: T[], dtype: 'float64'): undefined | number[];
+    cast(x: T[], dtype: 'float32'): undefined | number[];
+    cast(x: T[], dtype: 'int32'): undefined | number[];
+    cast(x: T[], dtype: 'uint8'): undefined | number[];
+    cast(x: T[], dtype: 'complex128'): undefined | Complex[];
+    cast(x: T[], dtype: 'complex64'): undefined | Complex[];
+    cast(x: T[], dtype: 'bool'): undefined | boolean[];
+    cast(x: T[], dtype: 'string'): undefined | string[];
+    cast(x: T[], dtype: 'expression'): undefined | BoxedExpression[];
+    cast(x: T | T[], dtype: TensorDataType): undefined | Complex | number | boolean | string | BoxedExpression | Complex[] | number[] | boolean[] | string[] | BoxedExpression[];
+    expression(x: T): BoxedExpression;
+    isZero(x: T): boolean;
+    isOne(x: T): boolean;
+    equals(lhs: T, rhs: T): boolean;
+    add(lhs: T, rhs: T): T;
+    addn(...xs: T[]): T;
+    neg(x: T): T;
+    sub(lhs: T, rhs: T): T;
+    mul(lhs: T, rhs: T): T;
+    muln(...xs: T[]): T;
+    div(lhs: T, rhs: T): T;
+    pow(rhs: T, n: number): T;
+    conjugate(x: T): T;
+}
+export declare class TensorFieldNumber implements TensorField<number> {
+    private ce;
+    one: number;
+    zero: number;
+    nan: number;
+    constructor(ce: IComputeEngine);
+    cast(x: number, dtype: 'float64'): undefined | number;
+    cast(x: number, dtype: 'float32'): undefined | number;
+    cast(x: number, dtype: 'int32'): undefined | number;
+    cast(x: number, dtype: 'uint8'): undefined | number;
+    cast(x: number, dtype: 'complex128'): undefined | Complex;
+    cast(x: number, dtype: 'complex64'): undefined | Complex;
+    cast(x: number, dtype: 'bool'): undefined | boolean;
+    cast(x: number, dtype: 'string'): undefined | string;
+    cast(x: number, dtype: 'expression'): undefined | BoxedExpression;
+    cast(x: number[], dtype: 'float64'): undefined | number[];
+    cast(x: number[], dtype: 'float32'): undefined | number[];
+    cast(x: number[], dtype: 'int32'): undefined | number[];
+    cast(x: number[], dtype: 'uint8'): undefined | number[];
+    cast(x: number[], dtype: 'complex128'): undefined | Complex[];
+    cast(x: number[], dtype: 'complex64'): undefined | Complex[];
+    cast(x: number[], dtype: 'bool'): undefined | boolean[];
+    cast(x: number[], dtype: 'string'): undefined | string[];
+    cast(x: number[], dtype: 'expression'): undefined | BoxedExpression[];
+    expression(x: number): BoxedExpression;
+    isZero(x: number): boolean;
+    isOne(x: number): boolean;
+    equals(lhs: number, rhs: number): boolean;
+    add(lhs: number, rhs: number): number;
+    addn(...xs: number[]): number;
+    neg(x: number): number;
+    sub(lhs: number, rhs: number): number;
+    mul(lhs: number, rhs: number): number;
+    muln(...xs: number[]): number;
+    div(lhs: number, rhs: number): number;
+    pow(lhs: number, rhs: number): number;
+    conjugate(x: number): number;
+}
+export declare class TensorFieldExpression implements TensorField<BoxedExpression> {
+    one: BoxedExpression;
+    zero: BoxedExpression;
+    nan: BoxedExpression;
+    private ce;
+    constructor(ce: IComputeEngine);
+    cast(x: BoxedExpression, dtype: 'float64'): undefined | number;
+    cast(x: BoxedExpression, dtype: 'float32'): undefined | number;
+    cast(x: BoxedExpression, dtype: 'int32'): undefined | number;
+    cast(x: BoxedExpression, dtype: 'uint8'): undefined | number;
+    cast(x: BoxedExpression, dtype: 'complex128'): undefined | Complex;
+    cast(x: BoxedExpression, dtype: 'complex64'): undefined | Complex;
+    cast(x: BoxedExpression, dtype: 'bool'): undefined | boolean;
+    cast(x: BoxedExpression, dtype: 'string'): undefined | string;
+    cast(x: BoxedExpression, dtype: 'expression'): undefined | BoxedExpression;
+    cast(x: BoxedExpression[], dtype: 'float64'): undefined | number[];
+    cast(x: BoxedExpression[], dtype: 'float32'): undefined | number[];
+    cast(x: BoxedExpression[], dtype: 'int32'): undefined | number[];
+    cast(x: BoxedExpression[], dtype: 'uint8'): undefined | number[];
+    cast(x: BoxedExpression[], dtype: 'complex128'): undefined | Complex[];
+    cast(x: BoxedExpression[], dtype: 'complex64'): undefined | Complex[];
+    cast(x: BoxedExpression[], dtype: 'bool'): undefined | boolean[];
+    cast(x: BoxedExpression[], dtype: 'string'): undefined | string[];
+    cast(x: BoxedExpression[], dtype: 'expression'): undefined | BoxedExpression[];
+    expression(x: BoxedExpression): BoxedExpression;
+    isZero(x: BoxedExpression): boolean;
+    isOne(x: BoxedExpression): boolean;
+    equals(lhs: BoxedExpression, rhs: BoxedExpression): boolean;
+    add(lhs: BoxedExpression, rhs: BoxedExpression): BoxedExpression;
+    addn(...xs: BoxedExpression[]): BoxedExpression;
+    neg(x: BoxedExpression): BoxedExpression;
+    sub(lhs: BoxedExpression, rhs: BoxedExpression): BoxedExpression;
+    mul(lhs: BoxedExpression, rhs: BoxedExpression): BoxedExpression;
+    muln(...xs: BoxedExpression[]): BoxedExpression;
+    div(lhs: BoxedExpression, rhs: BoxedExpression): BoxedExpression;
+    pow(lhs: BoxedExpression, rhs: number): BoxedExpression;
+    conjugate(x: BoxedExpression): BoxedExpression;
+}
+export declare class TensorFieldComplex implements TensorField<Complex> {
+    one: Complex;
+    zero: Complex;
+    nan: Complex;
+    private ce;
+    constructor(ce: IComputeEngine);
+    cast(x: Complex, dtype: 'float64'): undefined | number;
+    cast(x: Complex, dtype: 'float32'): undefined | number;
+    cast(x: Complex, dtype: 'int32'): undefined | number;
+    cast(x: Complex, dtype: 'uint8'): undefined | number;
+    cast(x: Complex, dtype: 'complex128'): undefined | Complex;
+    cast(x: Complex, dtype: 'complex64'): undefined | Complex;
+    cast(x: Complex, dtype: 'bool'): undefined | boolean;
+    cast(x: Complex, dtype: 'string'): undefined | string;
+    cast(x: Complex, dtype: 'expression'): undefined | BoxedExpression;
+    cast(x: Complex[], dtype: 'float64'): undefined | number[];
+    cast(x: Complex[], dtype: 'float32'): undefined | number[];
+    cast(x: Complex[], dtype: 'int32'): undefined | number[];
+    cast(x: Complex[], dtype: 'uint8'): undefined | number[];
+    cast(x: Complex[], dtype: 'complex128'): undefined | Complex[];
+    cast(x: Complex[], dtype: 'complex64'): undefined | Complex[];
+    cast(x: Complex[], dtype: 'bool'): undefined | boolean[];
+    cast(x: Complex[], dtype: 'string'): undefined | string[];
+    cast(x: Complex[], dtype: 'expression'): undefined | BoxedExpression[];
+    expression(z: Complex): BoxedExpression;
+    isZero(z: Complex): boolean;
+    isOne(z: Complex): boolean;
+    equals(lhs: Complex, rhs: Complex): boolean;
+    add(lhs: Complex, rhs: Complex): Complex;
+    addn(...xs: Complex[]): Complex;
+    neg(z: Complex): Complex;
+    sub(lhs: Complex, rhs: Complex): Complex;
+    mul(lhs: Complex, rhs: Complex): Complex;
+    muln(...xs: Complex[]): Complex;
+    div(lhs: Complex, rhs: Complex): Complex;
+    pow(lhs: Complex, rhs: number): Complex;
+    conjugate(z: Complex): Complex;
+}
+export declare function getSupertype(t1: TensorDataType, t2: TensorDataType): TensorDataType;
+export declare function getExpressionDatatype(expr: BoxedExpression): TensorDataType;

package/dist/types/compute-engine/symbolic/tensors.d.ts

@@ -0,0 +1,103 @@
+/* 0.22.0 */
+import { DataTypeMap, TensorDataType, TensorField } from './tensor-fields';
+export interface TensorData<DT extends keyof DataTypeMap = 'float64'> {
+    dtype: DT;
+    shape: number[];
+    data: DataTypeMap[DT][];
+}
+export type NestedArray<T> = NestedArray_<T>[];
+export type NestedArray_<T> = T | NestedArray_<T>[];
+export declare abstract class AbstractTensor<DT extends keyof DataTypeMap> implements TensorData<DT> {
+    private ce;
+    /**
+     * Return a tuple of tensors that have the same dtype.
+     * If necessary, one of the two input tensors is upcast.
+     *
+     * The shape of the tensors is reshape to a compatible
+     * shape. If the shape is not compatible, `undefined` is returned.
+     *
+     * @param lhs
+     * @param rhs
+     */
+    static align<T1 extends TensorDataType, T2 extends TensorDataType>(lhs: AbstractTensor<T1>, rhs: AbstractTensor<T2>): [AbstractTensor<T1>, AbstractTensor<T1>];
+    static align<T1 extends TensorDataType, T2 extends TensorDataType>(lhs: AbstractTensor<T1>, rhs: AbstractTensor<T2>): [AbstractTensor<T2>, AbstractTensor<T2>];
+    /**
+     * Apply a function to the elements of two tensors, or to a tensor
+     * and a scalar.
+     *
+     * The tensors are aligned and broadcasted if necessary.
+     *
+     * @param fn
+     * @param lhs
+     * @param rhs
+     * @returns
+     */
+    static broadcast<T extends TensorDataType>(fn: (lhs: DataTypeMap[T], rhs: DataTypeMap[T]) => DataTypeMap[T], lhs: AbstractTensor<T>, rhs: AbstractTensor<T> | DataTypeMap[T]): AbstractTensor<T>;
+    readonly field: TensorField<DataTypeMap[DT]>;
+    readonly shape: number[];
+    readonly rank: number;
+    private readonly _strides;
+    constructor(ce: IComputeEngine, tensorData: TensorData<DT>);
+    abstract get dtype(): DT;
+    abstract get data(): DataTypeMap[DT][];
+    get expression(): BoxedExpression;
+    /**
+     * Like expression(), but return a nested JS array instead
+     * of a BoxedExpression
+     */
+    get array(): NestedArray<DataTypeMap[DT]>;
+    /** Indices are 1-based, return a 0-based index in the data */
+    private _index;
+    get isSquare(): boolean;
+    get isSymmetric(): boolean;
+    get isSkewSymmetric(): boolean;
+    get isUpperTriangular(): boolean;
+    get isLowerTriangular(): boolean;
+    get isTriangular(): boolean;
+    get isDiagonal(): boolean;
+    get isIdentity(): boolean;
+    get isZero(): boolean;
+    /**
+     *  The number of indices should match the rank of the tensor.
+     *
+     * Note: the indices are 1-based
+     * Note: the data is broadcast (wraps around) if the indices are out of bounds
+     *
+     * LaTeX notation `A\lbracki, j\rbrack` or `A_{i, j}`
+     */
+    at(...indices: number[]): DataTypeMap[DT];
+    diagonal(axis1?: number, axis2?: number): undefined | DataTypeMap[DT][];
+    trace(axis1?: number, axis2?: number): undefined | DataTypeMap[DT];
+    /**
+     * Change the shape of the tensor
+     *
+     * The data is reused (and shared) between the two tensors.
+     */
+    reshape(...shape: number[]): AbstractTensor<DT>;
+    flatten(): DataTypeMap[DT][];
+    upcast<DT extends keyof DataTypeMap>(dtype: DT): AbstractTensor<DT>;
+    /** Transpose the first and second axis */
+    transpose(): undefined | AbstractTensor<DT>;
+    /** Transpose two axes. */
+    transpose(axis1: number, axis2: number, fn?: (v: DataTypeMap[DT]) => DataTypeMap[DT]): undefined | AbstractTensor<DT>;
+    conjugateTranspose(axis1: number, axis2: number): undefined | AbstractTensor<DT>;
+    determinant(): undefined | DataTypeMap[DT];
+    inverse(): undefined | AbstractTensor<DT>;
+    pseudoInverse(): undefined | AbstractTensor<DT>;
+    adjugateMatrix(): undefined | AbstractTensor<DT>;
+    minor(i: number, j: number): undefined | DataTypeMap[DT];
+    map1(fn: (lhs: DataTypeMap[DT], rhs: DataTypeMap[DT]) => DataTypeMap[DT], scalar: DataTypeMap[DT]): AbstractTensor<DT>;
+    map2(fn: (lhs: DataTypeMap[DT], rhs: DataTypeMap[DT]) => DataTypeMap[DT], rhs: AbstractTensor<DT>): AbstractTensor<DT>;
+    add(rhs: AbstractTensor<DT> | DataTypeMap[DT]): AbstractTensor<DT>;
+    subtract(rhs: AbstractTensor<DT> | DataTypeMap[DT]): AbstractTensor<DT>;
+    multiply(rhs: AbstractTensor<DT> | DataTypeMap[DT]): AbstractTensor<DT>;
+    divide(rhs: AbstractTensor<DT> | DataTypeMap[DT]): AbstractTensor<DT>;
+    power(rhs: AbstractTensor<DT> | DataTypeMap[DT]): AbstractTensor<DT>;
+    equals(rhs: AbstractTensor<DT>): boolean;
+}
+export declare function makeTensor<T extends TensorDataType>(ce: IComputeEngine, data: TensorData<T> | {
+    head: string;
+    ops: BoxedExpression[];
+    dtype: T;
+    shape: number[];
+}): AbstractTensor<T>;

package/dist/types/compute-engine/symbolic/utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.20.2 */
+/* 0.22.0 */
 import { Decimal } from 'decimal.js';
 import { BoxedExpression, Hold, Rational } from '../public';
 /**

package/dist/types/compute-engine.d.ts

@@ -1,3 +1,3 @@
-/* 0.20.2 */
-export declare const version = "0.20.2";
+/* 0.22.0 */
+export declare const version = "0.22.0";
 export { ComputeEngine } from './compute-engine/compute-engine';

package/dist/types/math-json/math-json-format.d.ts

@@ -1,4 +1,4 @@
-/* 0.20.2 */
+/* 0.22.0 */
     /** A human readable string to annotate this expression, since JSON does not
      * allow comments in its encoding */
     comment?: string;

package/dist/types/math-json/utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.20.2 */
+/* 0.22.0 */
 export declare const MISSING: Expression;
 export declare function isNumberExpression(expr: Expression | null): expr is number | string | MathJsonNumber;
 export declare function isNumberObject(expr: Expression | null): expr is MathJsonNumber;

package/dist/types/math-json.d.ts

@@ -1,3 +1,3 @@
-/* 0.20.2 */
+/* 0.22.0 */
 export { isSymbolObject, isStringObject, isFunctionObject, isDictionaryObject, stringValue as getStringValue, head, headName, symbol, applyRecursively, mapArgs, op, nops, dictionary as getDictionary, } from './math-json/utils';
-export declare const version = "0.20.2";
+export declare const version = "0.22.0";

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.20.2",
+  "version": "0.22.0",
   "scripts": {
     "build": "bash ./scripts/build.sh",
     "clean": "bash ./scripts/clean.sh",
@@ -38,6 +38,7 @@
   "files": [
     "/dist"
   ],
+  "type": "module",
   "exports": {
     ".": {
       "types": "./dist/types/compute-engine.d.ts",