mathjs 10.2.0 → 10.4.1

package/types/index.d.ts

@@ -352,6 +352,8 @@ declare namespace math {
     RelationalNode: RelationalNodeCtor;
     SymbolNode: SymbolNodeCtor;
 
+    Matrix: MatrixCtor;
+
     /**
      * If null were to be included in this interface, it would be
      * auto-suggested as an import in VSCode. This causes issues because
@@ -365,7 +367,11 @@ declare namespace math {
     version: string;
 
     expression: MathNode;
-    json: MathJsJson;
+
+    /**
+     * Returns reviver function that can be used as reviver in JSON.parse function.
+     */
+     reviver(): (key: any, value: any) => any;
 
     /*************************************************************************
      * Core functions
@@ -570,6 +576,11 @@ declare namespace math {
      * @returns The created unit
      */
     unit(unit: string): Unit;
+    /**
+     * @param unit The unit to be created
+     * @returns The created unit
+     */
+    unit(unit: Unit): Unit;
     /**
      * @param value The value of the unit to be created
      * @param unit The unit to be created
@@ -767,6 +778,7 @@ declare namespace math {
      * @param y Second value to add
      * @returns Sum of x and y
      */
+    add<T extends MathType>(x: T, y: T): T;
     add(x: MathType, y: MathType): MathType;
 
     /**
@@ -1116,8 +1128,7 @@ declare namespace math {
      * @param y Value to subtract from x
      * @returns Subtraction of x and y
      */
-    subtract(x: number, y: number): number;
-    subtract(x: Unit, y: Unit): Unit;
+    subtract<T extends MathType>(x: T, y: T): T;
     subtract(x: MathType, y: MathType): MathType;
 
     /**
@@ -1723,7 +1734,7 @@ declare namespace math {
     /**
      * Get or set a subset of a matrix or string.
      * @param value An array, matrix, or string
-     * @param index An index containing ranges for each dimension
+     * @param index For each dimension, an index or list of indices to get or set.
      * @param replacement An array, matrix, or scalar. If provided, the
      * subset is replaced with replacement. If not provided, the subset is
      * returned
@@ -2223,6 +2234,38 @@ declare namespace math {
      */
     quantileSeq(A: MathArray | Matrix, prob: number | BigNumber | MathArray, sorted?: boolean): number | BigNumber | Unit | MathArray;
 
+    /**
+     * Compute the standard deviation of a matrix or a list with values. The
+     * standard deviations is defined as the square root of the variance:
+     * std(A) = sqrt(variance(A)). In case of a (multi dimensional) array or
+     * matrix, the standard deviation over all elements will be calculated.
+     * Optionally, the type of normalization can be specified as second
+     * parameter. The parameter normalization can be one of the following
+     * values: 'unbiased' (default) The sum of squared errors is divided by
+     * (n - 1) 'uncorrected' The sum of squared errors is divided by n
+     * 'biased' The sum of squared errors is divided by (n + 1)
+     * @param a variadic argument of number to calculate standard deviation
+     * @returns The standard deviation array
+     */
+    std(...values: number[]): number
+    /**
+     * Compute the standard deviation of a matrix or a list with values. The
+     * standard deviations is defined as the square root of the variance:
+     * std(A) = sqrt(variance(A)). In case of a (multi dimensional) array or
+     * matrix, the standard deviation over all elements will be calculated.
+     * Optionally, the type of normalization can be specified as second
+     * parameter. The parameter normalization can be one of the following
+     * values: 'unbiased' (default) The sum of squared errors is divided by
+     * (n - 1) 'uncorrected' The sum of squared errors is divided by n
+     * 'biased' The sum of squared errors is divided by (n + 1)
+     * @param array A single matrix to compute standard deviation.
+     * @param dimension A dimension to calculate standard deviation
+     * @param normalization Determines how to normalize the variance. Choose
+     * ‘unbiased’ (default), ‘uncorrected’, or ‘biased’. Default value:
+     * ‘unbiased’.
+     * @returns The standard deviation array
+     */
+    std(array: MathArray | Matrix, dimension?: number, normalization?: 'unbiased' | 'uncorrected' | 'biased'): number[]
     /**
      * Compute the standard deviation of a matrix or a list with values. The
      * standard deviations is defined as the square root of the variance:
@@ -2239,7 +2282,7 @@ declare namespace math {
      * ‘unbiased’.
      * @returns The standard deviation
      */
-    std(array: MathArray | Matrix, normalization?: 'unbiased' | 'uncorrected' | 'biased' | 'unbiased'): number;
+    std(array: MathArray | Matrix, normalization: 'unbiased' | 'uncorrected' | 'biased'): number
 
     /**
      * Compute the sum of a matrix or a list with values. In case of a
@@ -2255,6 +2298,21 @@ declare namespace math {
      */
     sum(array: MathArray | Matrix): any;
 
+    /**
+     * Compute the cumulative sum of a matrix or a list with values.
+     * In case of a (multi dimensional) array or matrix, the cumulative sums
+     * along a specified dimension (defaulting to the first) will be calculated.
+     * @param args A single matrix or multiple scalar values
+     * @returns The cumulative sums of the the values.
+     */
+    cumsum(...args: MathType[]): MathType[];
+    /**
+     * @param array A single matrix
+     * @param dim The dimension along which to sum (defaults to 0)
+     * @returns The cumulative sums along the given dimension
+     */
+    cumsum(array: MathArray | Matrix, dim?: number): MathArray | Matrix;
+
     /**
      * Compute the variance of a matrix or a list with values. In case of a
      * (multi dimensional) array or matrix, the variance over all elements
@@ -2269,7 +2327,26 @@ declare namespace math {
      * @param args A single matrix or multiple scalar values
      * @returns The variance
      */
-    variance(...args: Array<number | BigNumber | Fraction>): any;
+    variance(...args: Array<number | BigNumber | Fraction>): number;
+    /**
+     * Compute the variance of a matrix or a list with values. In case of a
+     * (multi dimensional) array or matrix, the variance over all elements
+     * will be calculated. Optionally, the type of normalization can be
+     * specified as second parameter. The parameter normalization can be one
+     * of the following values: 'unbiased' (default) The sum of squared
+     * errors is divided by (n - 1) 'uncorrected' The sum of squared errors
+     * is divided by n 'biased' The sum of squared errors is divided by (n +
+     * 1) Note that older browser may not like the variable name var. In
+     * that case, the function can be called as math['var'](...) instead of
+     * math.variance(...).
+     * @param array A matrix to compute variance.
+     * @param dimension A dimension to compute variance on
+     * @param normalization normalization Determines how to normalize the
+     * variance. Choose ‘unbiased’ (default), ‘uncorrected’, or ‘biased’.
+     * Default value: ‘unbiased’.
+     * @returns variance matrix.
+     */
+    variance(array: MathArray | Matrix, dimension?: number, normalization?: 'unbiased' | 'uncorrected' | 'biased'): number[];
     /**
      * @param array A single matrix
      * @param normalization normalization Determines how to normalize the
@@ -2277,7 +2354,7 @@ declare namespace math {
      * Default value: ‘unbiased’.
      * @returns The variance
      */
-    variance(array: MathArray | Matrix, normalization?: 'unbiased' | 'uncorrected' | 'biased' | 'unbiased'): any;
+    variance(array: MathArray | Matrix, normalization: 'unbiased' | 'uncorrected' | 'biased'): number;
 
     /*************************************************************************
      * String functions
@@ -2622,7 +2699,86 @@ declare namespace math {
     to(x: Unit | MathArray | Matrix, unit: Unit | string): Unit | MathArray | Matrix;
 
     /*************************************************************************
-     * Utils functions
+     * Utils
+     ************************************************************************/
+     isNumber(x: unknown): x is number;
+
+     isBigNumber(x: unknown): x is BigNumber;
+
+     isComplex(x: unknown): x is Complex;
+
+     isFraction(x: unknown): x is Fraction;
+
+     isUnit(x: unknown): x is Unit;
+
+     isString(x: unknown): x is string;
+
+     isArray: ArrayConstructor['isArray'];
+
+     isMatrix(x: unknown): x is Matrix;
+
+     isCollection(x: unknown): x is (Matrix | any[]);
+
+     isDenseMatrix(x: unknown): x is Matrix;
+
+     isSparseMatrix(x: unknown): x is Matrix;
+
+     isRange(x: unknown): boolean;
+
+     isIndex(x: unknown): x is Index;
+
+     isBoolean(x: unknown): x is boolean;
+
+     isResultSet(x: unknown): boolean;
+
+     isHelp(x: unknown): x is Help;
+
+     isFunction(x: unknown): boolean;
+
+     isDate(x: unknown): x is Date;
+
+     isRegExp(x: unknown): x is RegExp;
+
+     isObject(x: unknown): boolean;
+
+     isNull(x: unknown): x is null;
+
+     isUndefined(x: unknown): x is undefined;
+
+     isAccessorNode(x: unknown): x is AccessorNode;
+
+     isArrayNode(x: unknown): x is ArrayNode;
+
+     isAssignmentNode(x: unknown): x is AssignmentNode;
+
+     isBlockNode(x: unknown): x is BlockNode;
+
+     isConditionalNode(x: unknown): x is ConditionalNode;
+
+     isConstantNode(x: unknown): x is ConstantNode;
+
+     isFunctionAssignmentNode(x: unknown): x is FunctionAssignmentNode;
+
+     isFunctionNode(x: unknown): x is FunctionNode;
+
+     isIndexNode(x: unknown): x is IndexNode;
+
+     isNode(x: unknown): x is MathNodeCommon;
+
+     isObjectNode(x: unknown): x is ObjectNode;
+
+     isOperatorNode(x: unknown): x is OperatorNode;
+
+     isParenthesisNode(x: unknown): x is ParenthesisNode;
+
+     isRangeNode(x: unknown): x is RangeNode;
+
+     isSymbolNode(x: unknown): x is SymbolNode;
+
+     isChain(x: unknown): x is MathJsChain;
+
+    /*************************************************************************
+     * Functions -> Utils
      ************************************************************************/
 
     /**
@@ -3099,6 +3255,10 @@ declare namespace math {
     swapRows(i: number, j: number): Matrix;
   }
 
+  interface MatrixCtor {
+    new(): Matrix;
+  }
+
   interface BigNumber extends Decimal {} // tslint:disable-line no-empty-interface
 
   interface Fraction {
@@ -3218,8 +3378,6 @@ declare namespace math {
     ): MathNode;
 
     rules: SimplifyRule[];
-
-    simplifyCore(expr: MathNode): MathNode;
   }
 
   interface UnitDefinition {
@@ -3458,13 +3616,6 @@ declare namespace math {
     randomSeed?: string | null;
   }
 
-  interface MathJsJson {
-    /**
-     * Returns reviver function that can be used as reviver in JSON.parse function.
-     */
-    reviver(): (key: any, value: any) => any;
-  }
-
   interface MathJsChain {
     done(): any;
 
@@ -3682,6 +3833,8 @@ declare namespace math {
      */
     simplify(rules?: SimplifyRule[], scope?: object): MathJsChain;
 
+    simplifyCore(expr: MathNode): MathNode;
+
     /**
      * Calculate the Sparse Matrix LU decomposition with full pivoting.
      * Sparse Matrix A is decomposed in two matrices (L, U) and two
@@ -4319,7 +4472,7 @@ declare namespace math {
 
     /**
      * Get or set a subset of a matrix or string.
-     * @param index An index containing ranges for each dimension
+     * @param index For each dimension, an index or list of indices to get or set
      * @param replacement An array, matrix, or scalar. If provided, the
      * subset is replaced with replacement. If not provided, the subset is
      * returned
@@ -4706,7 +4859,6 @@ declare namespace math {
      * @param sorted =false is data sorted in ascending order
      */
     quantileSeq(prob: number | BigNumber | MathArray, sorted?: boolean): MathJsChain;
-
     /**
      * Compute the standard deviation of a matrix or a list with values. The
      * standard deviations is defined as the square root of the variance:
@@ -4717,13 +4869,29 @@ declare namespace math {
      * values: 'unbiased' (default) The sum of squared errors is divided by
      * (n - 1) 'uncorrected' The sum of squared errors is divided by n
      * 'biased' The sum of squared errors is divided by (n + 1)
-     * @param array A single matrix or multiple scalar values
+     * @param dim A dimension to compute standard deviation.
+     * @param normalization Determines how to normalize the variance. Choose
+     * ‘unbiased’ (default), ‘uncorrected’, or ‘biased’. Default value:
+     * ‘unbiased’.
+     * @returns The standard deviation
+     */
+    std(dim?: number, normalization?: 'unbiased' | 'uncorrected' | 'biased'): MathJsChain;
+    /**
+     * Compute the standard deviation of a matrix or a list with values. The
+     * standard deviations is defined as the square root of the variance:
+     * std(A) = sqrt(variance(A)). In case of a (multi dimensional) array or
+     * matrix, the standard deviation over all elements will be calculated.
+     * Optionally, the type of normalization can be specified as second
+     * parameter. The parameter normalization can be one of the following
+     * values: 'unbiased' (default) The sum of squared errors is divided by
+     * (n - 1) 'uncorrected' The sum of squared errors is divided by n
+     * 'biased' The sum of squared errors is divided by (n + 1)
      * @param normalization Determines how to normalize the variance. Choose
      * ‘unbiased’ (default), ‘uncorrected’, or ‘biased’. Default value:
      * ‘unbiased’.
      * @returns The standard deviation
      */
-    std(normalization?: 'unbiased' | 'uncorrected' | 'biased' | 'unbiased'): MathJsChain;
+    std(normalization: 'unbiased' | 'uncorrected' | 'biased'): MathJsChain;
 
     /**
      * Compute the sum of a matrix or a list with values. In case of a
@@ -4731,7 +4899,6 @@ declare namespace math {
      * calculated.
      */
     sum(): MathJsChain;
-
     /**
      * Compute the variance of a matrix or a list with values. In case of a
      * (multi dimensional) array or matrix, the variance over all elements
@@ -4743,12 +4910,30 @@ declare namespace math {
      * 1) Note that older browser may not like the variable name var. In
      * that case, the function can be called as math['var'](...) instead of
      * math.variance(...).
+     * @param dim a dimension to compute variance.
      * @param normalization normalization Determines how to normalize the
      * variance. Choose ‘unbiased’ (default), ‘uncorrected’, or ‘biased’.
      * Default value: ‘unbiased’.
      * @returns The variance
      */
-    variance(normalization?: 'unbiased' | 'uncorrected' | 'biased' | 'unbiased'): MathJsChain;
+    variance(dim?: number, normalization?: 'unbiased' | 'uncorrected' | 'biased'): MathJsChain;
+    /**
+     * Compute the variance of a matrix or a list with values. In case of a
+     * (multi dimensional) array or matrix, the variance over all elements
+     * will be calculated. Optionally, the type of normalization can be
+     * specified as second parameter. The parameter normalization can be one
+     * of the following values: 'unbiased' (default) The sum of squared
+     * errors is divided by (n - 1) 'uncorrected' The sum of squared errors
+     * is divided by n 'biased' The sum of squared errors is divided by (n +
+     * 1) Note that older browser may not like the variable name var. In
+     * that case, the function can be called as math['var'](...) instead of
+     * math.variance(...).
+     * @param normalization normalization Determines how to normalize the
+     * variance. Choose ‘unbiased’ (default), ‘uncorrected’, or ‘biased’.
+     * Default value: ‘unbiased’.
+     * @returns The variance
+     */
+    variance(normalization: 'unbiased' | 'uncorrected' | 'biased'): MathJsChain;
 
     /*************************************************************************
      * String functions
@@ -5026,4 +5211,5 @@ declare namespace math {
   interface ImportObject {
     [key: string]: any;
   }
+
 }