mathjs 10.6.2 → 11.0.0

package/types/index.d.ts

@@ -162,7 +162,7 @@ declare namespace math {
   }
 
   interface NodeCtor {
-    new (): Node
+    new (): MathNodeCommon
   }
 
   interface AccessorNode extends MathNodeCommon {
@@ -589,7 +589,7 @@ declare namespace math {
      */
     createUnit(
       name: string,
-      definition?: string | UnitDefinition,
+      definition?: string | UnitDefinition | Unit,
       options?: CreateUnitOptions
     ): Unit
     /**
@@ -599,7 +599,7 @@ declare namespace math {
      * @returns The new unit
      */
     createUnit(
-      units: Record<string, string | UnitDefinition>,
+      units: Record<string, string | UnitDefinition | Unit>,
       options?: CreateUnitOptions
     ): Unit
 
@@ -647,7 +647,7 @@ declare namespace math {
      * @returns The created Matrix
      */
     matrix(
-      data: MathCollection,
+      data: MathCollection | string[],
       format?: 'sparse' | 'dense',
       dataType?: string
     ): Matrix
@@ -890,15 +890,23 @@ declare namespace math {
      */
     simplify: Simplify
 
+    simplifyConstant(expr: MathNode | string, options?: SimplifyOptions)
+    simplifyCore(expr: MathNode | string, options?: SimplifyOptions)
+
     /**
      *  Replaces variable nodes with their scoped values
      * @param node Tree to replace variable nodes in
      * @param scope Scope to read/write variables
      */
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    resolve(node: MathNode, scope?: Record<string, any>): MathNode
+    resolve(node: MathNode | string, scope?: Record<string, any>): MathNode
+    resolve(
+      node: (MathNode | string)[],
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      scope?: Record<string, any>
+    ): MathNode[]
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    resolve(node: MathNode[], scope?: Record<string, any>): MathNode[]
+    resolve(node: Matrix, scope?: Record<string, any>): Matrix
 
     /**
      * Calculate the Sparse Matrix LU decomposition with full pivoting.
@@ -960,8 +968,7 @@ declare namespace math {
     add(x: MathType, y: MathType): MathType
 
     /**
-     * Calculate the cubic root of a value. For matrices, the function is
-     * evaluated element wise.
+     * Calculate the cubic root of a value.
      * @param x Value for which to calculate the cubic root.
      * @param allRoots Optional, false by default. Only applicable when x is
      * a number or complex number. If true, all complex roots are returned,
@@ -969,10 +976,9 @@ declare namespace math {
      * @returns Returns the cubic root of x
      */
     cbrt(x: number, allRoots?: boolean): number
-    cbrt(x: BigNumber, allRoots?: boolean): BigNumber
+    cbrt(x: BigNumber): BigNumber
     cbrt(x: Complex, allRoots?: boolean): Complex
-    cbrt(x: MathArray, allRoots?: boolean): MathArray
-    cbrt(x: Matrix, allRoots?: boolean): Matrix
+    cbrt(x: Unit): Unit
 
     // Rounding functions, grouped for similarity, even though it breaks
     // the alphabetic order among arithmetic functions.
@@ -1042,8 +1048,6 @@ declare namespace math {
     cube(x: BigNumber): BigNumber
     cube(x: Fraction): Fraction
     cube(x: Complex): Complex
-    cube(x: MathArray): MathArray
-    cube(x: Matrix): Matrix
     cube(x: Unit): Unit
 
     /**
@@ -1093,8 +1097,6 @@ declare namespace math {
     exp(x: number): number
     exp(x: BigNumber): BigNumber
     exp(x: Complex): Complex
-    exp(x: MathArray): MathArray
-    exp(x: Matrix): Matrix
 
     /**
      * Calculate the value of subtracting 1 from the exponential value. For
@@ -1105,8 +1107,6 @@ declare namespace math {
     expm1(x: number): number
     expm1(x: BigNumber): BigNumber
     expm1(x: Complex): Complex
-    expm1(x: MathArray): MathArray
-    expm1(x: Matrix): Matrix
 
     /**
      * Calculate the greatest common divisor for two or more values or
@@ -1147,14 +1147,13 @@ declare namespace math {
     lcm(a: Matrix, b: Matrix): Matrix
 
     /**
-     * Calculate the logarithm of a value. For matrices, the function is
-     * evaluated element wise.
+     * Calculate the logarithm of a value.
      * @param x Value for which to calculate the logarithm.
      * @param base Optional base for the logarithm. If not provided, the
      * natural logarithm of x is calculated. Default value: e.
      * @returns Returns the logarithm of x
      */
-    log<T extends number | BigNumber | Complex | MathCollection>(
+    log<T extends number | BigNumber | Complex>(
       x: T,
       base?: number | BigNumber | Complex
     ): NoLiteralType<T>
@@ -1216,9 +1215,13 @@ declare namespace math {
      * @param y The second value to multiply
      * @returns Multiplication of x and y
      */
-    multiply<T extends Matrix | MathArray>(x: T, y: MathType): T
+
+    multiply<T extends Matrix>(x: T, y: MathType): Matrix
+    multiply<T extends Matrix>(x: MathType, y: T): Matrix
+
     multiply(x: Unit, y: Unit): Unit
     multiply(x: number, y: number): number
+    multiply(x: MathArray, y: MathArray): MathArray
     multiply(x: MathType, y: MathType): MathType
 
     /**
@@ -1273,21 +1276,19 @@ declare namespace math {
     sign(x: Unit): Unit
 
     /**
-     * Calculate the square root of a value. For matrices, the function is
-     * evaluated element wise.
+     * Calculate the square root of a value. For matrices, use either
+     * sqrtm for the matrix square root, or map(M, sqrt) to take the
+     * square root element wise.
      * @param x Value for which to calculate the square root
      * @returns Returns the square root of x
      */
-    sqrt(x: number): number
+    sqrt(x: number): number | Complex
     sqrt(x: BigNumber): BigNumber
     sqrt(x: Complex): Complex
-    sqrt(x: MathArray): MathArray
-    sqrt(x: Matrix): Matrix
     sqrt(x: Unit): Unit
 
     /**
-     * Compute the square of a value, x * x. For matrices, the function is
-     * evaluated element wise.
+     * Compute the square of a value, x * x.
      * @param x Number for which to calculate the square
      * @returns Squared value
      */
@@ -1295,8 +1296,6 @@ declare namespace math {
     square(x: BigNumber): BigNumber
     square(x: Fraction): Fraction
     square(x: Complex): Complex
-    square(x: MathArray): MathArray
-    square(x: Matrix): Matrix
     square(x: Unit): Unit
 
     /**
@@ -1850,14 +1849,37 @@ declare namespace math {
      * @param format The matrix storage format
      * @returns A matrix filled with ones
      */
-    ones(size: number | number[], format?: string): MathCollection
+    ones(
+      size?: number | number[] | BigNumber | BigNumber[],
+      format?: string
+    ): MathCollection
     /**
      * @param m The x dimension of the matrix
-     * @param n The y dimension of the amtrix
+     * @param n The y dimension of the matrix
+     * @param format The matrix storage format
+     * @returns A matrix filled with ones
+     */
+    ones(
+      m: number | BigNumber,
+      n: number | BigNumber,
+      format?: string
+    ): MathCollection
+    /**
+     * @param m The x dimension of the matrix
+     * @param n The y dimension of the matrix
+     * @param p The z dimension of the matrix
      * @param format The matrix storage format
      * @returns A matrix filled with ones
      */
-    ones(m: number, n: number, format?: string): MathCollection
+    ones(
+      m: number | BigNumber,
+      n: number | BigNumber,
+      p: number | BigNumber,
+      format?: string
+    ): MathCollection
+    /** Actually ones can take an arbitrary number of dimensions before the
+     ** optional format, not sure how to write that in TypeScript
+     **/
 
     /**
      * Partition-based selection of an array or 1D matrix. Will find the kth
@@ -2038,14 +2060,37 @@ declare namespace math {
      * @param format The matrix storage format
      * @returns A matrix filled with zeros
      */
-    zeros(size: number | number[], format?: string): MathCollection
+    zeros(
+      size?: number | number[] | BigNumber | BigNumber[],
+      format?: string
+    ): MathCollection
     /**
      * @param m The x dimension of the matrix
      * @param n The y dimension of the matrix
      * @param format The matrix storage format
      * @returns A matrix filled with zeros
      */
-    zeros(m: number, n: number, format?: string): MathCollection
+    zeros(
+      m: number | BigNumber,
+      n: number | BigNumber,
+      format?: string
+    ): MathCollection
+    /**
+     * @param m The x dimension of the matrix
+     * @param n The y dimension of the matrix
+     * @param p The z dimension of the matrix
+     * @param format The matrix storage format
+     * @returns A matrix filled with zeros
+     */
+    zeros(
+      m: number | BigNumber,
+      n: number | BigNumber,
+      p: number | BigNumber,
+      format?: string
+    ): MathCollection
+    /** Actually zeros can take any number of dimensions before the
+     ** optional format, not sure how to write that in TypeScript
+     **/
 
     /**
      * Calculate N-dimensional fourier transform
@@ -2092,13 +2137,11 @@ declare namespace math {
     /**
      * Compute the gamma function of a value using Lanczos approximation for
      * small values, and an extended Stirling approximation for large
-     * values. For matrices, the function is evaluated element wise.
+     * values.
      * @param n A real or complex number
      * @returns The gamma of n
      */
-    gamma<T extends number | BigNumber | Complex | MathCollection>(
-      n: T
-    ): NoLiteralType<T>
+    gamma<T extends number | BigNumber | Complex>(n: T): NoLiteralType<T>
 
     /**
      * Calculate the Kullback-Leibler (KL) divergence between two
@@ -2654,6 +2697,13 @@ declare namespace math {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     sum(array: MathCollection): any
 
+    /**
+     * Count the number of elements of a matrix, array or string.
+     * @param x A matrix, array or string.
+     * @returns The number of members passed in parameters
+     */
+    count(x: MathCollection | string): number
+
     /**
      * Compute the cumulative sum of a matrix or a list with values.
      * In case of a (multi dimensional) array or matrix, the cumulative sums
@@ -2770,133 +2820,108 @@ declare namespace math {
      ************************************************************************/
 
     /**
-     * Calculate the inverse cosine of a value. For matrices, the function
-     * is evaluated element wise.
+     * Calculate the inverse cosine of a value.
      * @param x Function input
      * @returns The arc cosine of x
      */
-    acos(x: number): number
+    acos(x: number): number | Complex
     acos(x: BigNumber): BigNumber
     acos(x: Complex): Complex
-    acos(x: MathArray): MathArray
-    acos(x: Matrix): Matrix
 
     /**
      * Calculate the hyperbolic arccos of a value, defined as acosh(x) =
-     * ln(sqrt(x^2 - 1) + x). For matrices, the function is evaluated
-     * element wise.
+     * ln(sqrt(x^2 - 1) + x).
      * @param x Function input
      * @returns The hyperbolic arccosine of x
      */
-    acosh(x: number): number
+    acosh(x: number): number | Complex
     acosh(x: BigNumber): BigNumber
     acosh(x: Complex): Complex
-    acosh(x: MathArray): MathArray
-    acosh(x: Matrix): Matrix
 
     /**
-     * Calculate the inverse cotangent of a value. For matrices, the
-     * function is evaluated element wise.
+     * Calculate the inverse cotangent of a value.
      * @param x Function input
      * @returns The arc cotangent of x
      */
     acot(x: number): number
     acot(x: BigNumber): BigNumber
-    acot(x: MathArray): MathArray
-    acot(x: Matrix): Matrix
+    acot(x: Complex): Complex
 
     /**
      * Calculate the hyperbolic arccotangent of a value, defined as acoth(x)
-     * = (ln((x+1)/x) + ln(x/(x-1))) / 2. For matrices, the function is
-     * evaluated element wise.
+     * = (ln((x+1)/x) + ln(x/(x-1))) / 2.
      * @param x Function input
      * @returns The hyperbolic arccotangent of x
      */
     acoth(x: number): number
     acoth(x: BigNumber): BigNumber
-    acoth(x: MathArray): MathArray
-    acoth(x: Matrix): Matrix
+    acoth(x: Complex): Complex
 
     /**
-     * Calculate the inverse cosecant of a value. For matrices, the function
-     * is evaluated element wise.
+     * Calculate the inverse cosecant of a value.
      * @param x Function input
      * @returns The arc cosecant of x
      */
-    acsc(x: number): number
+    acsc(x: number): number | Complex
     acsc(x: BigNumber): BigNumber
-    acsc(x: MathArray): MathArray
-    acsc(x: Matrix): Matrix
+    acsc(x: Complex): Complex
 
     /**
      * Calculate the hyperbolic arccosecant of a value, defined as acsch(x)
-     * = ln(1/x + sqrt(1/x^2 + 1)). For matrices, the function is evaluated
-     * element wise.
+     * = ln(1/x + sqrt(1/x^2 + 1)).
      * @param x Function input
      * @returns The hyperbolic arccosecant of x
      */
     acsch(x: number): number
     acsch(x: BigNumber): BigNumber
-    acsch(x: MathArray): MathArray
-    acsch(x: Matrix): Matrix
+    acsch(x: Complex): Complex
 
     /**
-     * Calculate the inverse secant of a value. For matrices, the function
-     * is evaluated element wise.
+     * Calculate the inverse secant of a value.
      * @param x Function input
      * @returns The arc secant of x
      */
-    asec(x: number): number
+    asec(x: number): number | Complex
     asec(x: BigNumber): BigNumber
-    asec(x: MathArray): MathArray
-    asec(x: Matrix): Matrix
+    asec(x: Complex): Complex
 
     /**
      * Calculate the hyperbolic arcsecant of a value, defined as asech(x) =
-     * ln(sqrt(1/x^2 - 1) + 1/x). For matrices, the function is evaluated
-     * element wise.
+     * ln(sqrt(1/x^2 - 1) + 1/x).
      * @param x Function input
      * @returns The hyperbolic arcsecant of x
      */
-    asech(x: number): number
+    asech(x: number): number | Complex
     asech(x: BigNumber): BigNumber
-    asech(x: MathArray): MathArray
-    asech(x: Matrix): Matrix
+    asech(x: Complex): Complex
 
     /**
-     * Calculate the inverse sine of a value. For matrices, the function is
-     * evaluated element wise.
+     * Calculate the inverse sine of a value.
      * @param x Function input
      * @returns The arc sine of x
      */
-    asin(x: number): number
+    asin(x: number): number | Complex
     asin(x: BigNumber): BigNumber
     asin(x: Complex): Complex
-    asin(x: MathArray): MathArray
-    asin(x: Matrix): Matrix
 
     /**
      * Calculate the hyperbolic arcsine of a value, defined as asinh(x) =
-     * ln(x + sqrt(x^2 + 1)). For matrices, the function is evaluated
-     * element wise.
+     * ln(x + sqrt(x^2 + 1)).
      * @param x Function input
      * @returns The hyperbolic arcsine of x
      */
     asinh(x: number): number
     asinh(x: BigNumber): BigNumber
-    asinh(x: MathArray): MathArray
-    asinh(x: Matrix): Matrix
+    asinh(x: Complex): Complex
 
     /**
-     * Calculate the inverse tangent of a value. For matrices, the function
-     * is evaluated element wise.
+     * Calculate the inverse tangent of a value.
      * @param x Function input
      * @returns The arc tangent of x
      */
     atan(x: number): number
     atan(x: BigNumber): BigNumber
-    atan(x: MathArray): MathArray
-    atan(x: Matrix): Matrix
+    atan(x: Complex): Complex
 
     /**
      * Calculate the inverse tangent function with two arguments, y/x. By
@@ -2910,156 +2935,127 @@ declare namespace math {
 
     /**
      * Calculate the hyperbolic arctangent of a value, defined as atanh(x) =
-     * ln((1 + x)/(1 - x)) / 2. For matrices, the function is evaluated
-     * element wise.
+     * ln((1 + x)/(1 - x)) / 2.
      * @param x Function input
      * @returns The hyperbolic arctangent of x
      */
-    atanh(x: number): number
+    atanh(x: number): number | Complex
     atanh(x: BigNumber): BigNumber
-    atanh(x: MathArray): MathArray
-    atanh(x: Matrix): Matrix
+    atanh(x: Complex): Complex
 
     /**
-     * Calculate the cosine of a value. For matrices, the function is
-     * evaluated element wise.
+     * Calculate the cosine of a value.
      * @param x Function input
      * @returns The cosine of x
      */
     cos(x: number | Unit): number
     cos(x: BigNumber): BigNumber
     cos(x: Complex): Complex
-    cos(x: MathArray): MathArray
-    cos(x: Matrix): Matrix
 
     /**
      * Calculate the hyperbolic cosine of a value, defined as cosh(x) = 1/2
-     * * (exp(x) + exp(-x)). For matrices, the function is evaluated element
-     * wise.
+     * * (exp(x) + exp(-x)).
      * @param x Function input
      * @returns The hyperbolic cosine of x
      */
     cosh(x: number | Unit): number
     cosh(x: BigNumber): BigNumber
     cosh(x: Complex): Complex
-    cosh(x: MathArray): MathArray
-    cosh(x: Matrix): Matrix
 
     /**
      * Calculate the cotangent of a value. cot(x) is defined as 1 / tan(x).
-     * For matrices, the function is evaluated element wise.
      * @param x Function input
      * @returns The cotangent of x
      */
     cot(x: number | Unit): number
+    cot(x: BigNumber): BigNumber
     cot(x: Complex): Complex
-    cot(x: MathArray): MathArray
-    cot(x: Matrix): Matrix
 
     /**
      * Calculate the hyperbolic cotangent of a value, defined as coth(x) = 1
-     * / tanh(x). For matrices, the function is evaluated element wise.
+     * / tanh(x).
      * @param x Function input
      * @returns The hyperbolic cotangent of x
      */
     coth(x: number | Unit): number
+    coth(x: BigNumber): BigNumber
     coth(x: Complex): Complex
-    coth(x: MathArray): MathArray
-    coth(x: Matrix): Matrix
 
     /**
-     * Calculate the cosecant of a value, defined as csc(x) = 1/sin(x). For
-     * matrices, the function is evaluated element wise.
+     * Calculate the cosecant of a value, defined as csc(x) = 1/sin(x).
      * @param x Function input
      * @returns The cosecant hof x
      */
     csc(x: number | Unit): number
+    csc(x: BigNumber): BigNumber
     csc(x: Complex): Complex
-    csc(x: MathArray): MathArray
-    csc(x: Matrix): Matrix
 
     /**
      * Calculate the hyperbolic cosecant of a value, defined as csch(x) = 1
-     * / sinh(x). For matrices, the function is evaluated element wise.
+     * / sinh(x).
      * @param x Function input
      * @returns The hyperbolic cosecant of x
      */
     csch(x: number | Unit): number
+    csch(x: BigNumber): BigNumber
     csch(x: Complex): Complex
-    csch(x: MathArray): MathArray
-    csch(x: Matrix): Matrix
 
     /**
-     * Calculate the secant of a value, defined as sec(x) = 1/cos(x). For
-     * matrices, the function is evaluated element wise.
+     * Calculate the secant of a value, defined as sec(x) = 1/cos(x).
      * @param x Function input
      * @returns The secant of x
      */
     sec(x: number | Unit): number
+    sec(x: BigNumber): BigNumber
     sec(x: Complex): Complex
-    sec(x: MathArray): MathArray
-    sec(x: Matrix): Matrix
 
     /**
      * Calculate the hyperbolic secant of a value, defined as sech(x) = 1 /
-     * cosh(x). For matrices, the function is evaluated element wise.
+     * cosh(x).
      * @param x Function input
      * @returns The hyperbolic secant of x
      */
     sech(x: number | Unit): number
+    sech(x: BigNumber): BigNumber
     sech(x: Complex): Complex
-    sech(x: MathArray): MathArray
-    sech(x: Matrix): Matrix
 
     /**
-     * Calculate the sine of a value. For matrices, the function is
-     * evaluated element wise.
+     * Calculate the sine of a value.
      * @param x Function input
      * @returns The sine of x
      */
     sin(x: number | Unit): number
     sin(x: BigNumber): BigNumber
     sin(x: Complex): Complex
-    sin(x: MathArray): MathArray
-    sin(x: Matrix): Matrix
 
     /**
      * Calculate the hyperbolic sine of a value, defined as sinh(x) = 1/2 *
-     * (exp(x) - exp(-x)). For matrices, the function is evaluated element
-     * wise.
+     * (exp(x) - exp(-x)).
      * @param x Function input
      * @returns The hyperbolic sine of x
      */
     sinh(x: number | Unit): number
     sinh(x: BigNumber): BigNumber
     sinh(x: Complex): Complex
-    sinh(x: MathArray): MathArray
-    sinh(x: Matrix): Matrix
 
     /**
      * Calculate the tangent of a value. tan(x) is equal to sin(x) / cos(x).
-     * For matrices, the function is evaluated element wise.
      * @param x Function input
      * @returns The tangent of x
      */
     tan(x: number | Unit): number
     tan(x: BigNumber): BigNumber
     tan(x: Complex): Complex
-    tan(x: MathArray): MathArray
-    tan(x: Matrix): Matrix
 
     /**
      * Calculate the hyperbolic tangent of a value, defined as tanh(x) =
-     * (exp(2 * x) - 1) / (exp(2 * x) + 1). For matrices, the function is
-     * evaluated element wise.
+     * (exp(2 * x) - 1) / (exp(2 * x) + 1).
      * @param x Function input
      * @returns The hyperbolic tangent of x
      */
     tanh(x: number | Unit): number
     tanh(x: BigNumber): BigNumber
     tanh(x: Complex): Complex
-    tanh(x: MathArray): MathArray
-    tanh(x: Matrix): Matrix
 
     /*************************************************************************
      * Unit functions
@@ -3766,6 +3762,18 @@ declare namespace math {
     override?: boolean
   }
 
+  type SimplifyContext = Partial<
+    Record<
+      OperatorNodeFn,
+      {
+        trivial: boolean
+        total: boolean
+        commutative: boolean
+        associative: boolean
+      }
+    >
+  >
+
   interface SimplifyOptions {
     /** A boolean which is `true` by default. */
     exactFractions?: boolean
@@ -3775,23 +3783,46 @@ declare namespace math {
      * Default value is 10000.
      */
     fractionsLimit?: number
+    /** A boolean which is `false` by default. */
+    consoleDebug?: boolean
+    /**
+     * gives properties of each operator, which determine what simplifications
+     * are allowed. Properties are commutative, associative, total (whether
+     * the operation is defined for all arguments), and trivial (whether
+     * the operation applied to a single argument leaves that argument
+     * unchanged).
+     */
+    context?: SimplifyContext
   }
 
   type SimplifyRule =
-    | { l: string; r: string }
+    | {
+        l: string
+        r: string
+        repeat?: boolean
+        assuming?: SimplifyContext
+        imposeContext?: SimplifyContext
+      }
+    | {
+        s: string
+        repeat?: boolean
+        assuming?: SimplifyContext
+        imposeContext?: SimplifyContext
+      }
     | string
     | ((node: MathNode) => MathNode)
 
   interface Simplify {
+    (expr: MathNode | string): MathNode
     (
       expr: MathNode | string,
-      rules?: SimplifyRule[],
+      rules: SimplifyRule[],
       scope?: object,
       options?: SimplifyOptions
     ): MathNode
     (
       expr: MathNode | string,
-      scope?: object,
+      scope: object,
       options?: SimplifyOptions
     ): MathNode
 
@@ -4111,7 +4142,7 @@ declare namespace math {
      */
     createUnit(
       this: MathJsChain<string>,
-      definition?: string | UnitDefinition,
+      definition?: string | UnitDefinition | Unit,
       options?: CreateUnitOptions
     ): MathJsChain<Unit>
     /**
@@ -4125,7 +4156,7 @@ declare namespace math {
      * 0.
      */
     createUnit(
-      this: MathJsChain<Record<string, string | UnitDefinition>>,
+      this: MathJsChain<Record<string, string | UnitDefinition | Unit>>,
       options?: CreateUnitOptions
     ): MathJsChain<Unit>
 
@@ -4380,11 +4411,18 @@ declare namespace math {
     simplify(
       this: MathJsChain<MathNode | string>,
       rules?: SimplifyRule[],
-      scope?: object
+      scope?: Map | object,
+      options?: SimplifyOptions
     ): MathJsChain<MathNode>
 
-    // TODO check that this should even be here...
-    simplifyCore(expr: MathNode): MathNode
+    simplifyConstant(
+      this: MathJsChain<MathNode | string>,
+      options?: SimplifyOptions
+    ): MathJsChain<MathNode>
+    simplifyCore(
+      this: MathJsChain<MathNode | string>,
+      options?: SimplifyOptions
+    ): MathJsChain<MathNode>
 
     /**
      * Calculate the Sparse Matrix LU decomposition with full pivoting.
@@ -4468,16 +4506,9 @@ declare namespace math {
      * if false (default) the principal root is returned.
      */
     cbrt(this: MathJsChain<number>, allRoots?: boolean): MathJsChain<number>
-    cbrt(
-      this: MathJsChain<BigNumber>,
-      allRoots?: boolean
-    ): MathJsChain<BigNumber>
+    cbrt(this: MathJsChain<BigNumber>): MathJsChain<BigNumber>
     cbrt(this: MathJsChain<Complex>, allRoots?: boolean): MathJsChain<Complex>
-    cbrt(
-      this: MathJsChain<MathArray>,
-      allRoots?: boolean
-    ): MathJsChain<MathArray>
-    cbrt(this: MathJsChain<Matrix>, allRoots?: boolean): MathJsChain<Matrix>
+    cbrt(this: MathJsChain<Unit>, allRoots?: boolean): MathJsChain<Unit>
 
     // Rounding functions grouped for similarity
 
@@ -4548,8 +4579,6 @@ declare namespace math {
     cube(this: MathJsChain<BigNumber>): MathJsChain<BigNumber>
     cube(this: MathJsChain<Fraction>): MathJsChain<Fraction>
     cube(this: MathJsChain<Complex>): MathJsChain<Complex>
-    cube(this: MathJsChain<MathArray>): MathJsChain<MathArray>
-    cube(this: MathJsChain<Matrix>): MathJsChain<Matrix>
     cube(this: MathJsChain<Unit>): MathJsChain<Unit>
 
     /**
@@ -4589,8 +4618,6 @@ declare namespace math {
     exp(this: MathJsChain<number>): MathJsChain<number>
     exp(this: MathJsChain<BigNumber>): MathJsChain<BigNumber>
     exp(this: MathJsChain<Complex>): MathJsChain<Complex>
-    exp(this: MathJsChain<MathArray>): MathJsChain<MathArray>
-    exp(this: MathJsChain<Matrix>): MathJsChain<Matrix>
 
     /**
      * Calculate the value of subtracting 1 from the exponential value. For
@@ -4599,8 +4626,6 @@ declare namespace math {
     expm1(this: MathJsChain<number>): MathJsChain<number>
     expm1(this: MathJsChain<BigNumber>): MathJsChain<BigNumber>
     expm1(this: MathJsChain<Complex>): MathJsChain<Complex>
-    expm1(this: MathJsChain<MathArray>): MathJsChain<MathArray>
-    expm1(this: MathJsChain<Matrix>): MathJsChain<Matrix>
 
     /**
      * Calculate the greatest common divisor for two or more values or
@@ -4842,6 +4867,21 @@ declare namespace math {
       b: number | BigNumber
     ): MathJsChain<MathArray>
 
+    /**
+     * Count the number of elements of a matrix, array or string.
+     */
+    count(this: MathJsChain<MathCollection>): MathJsChain<number>
+    count(this: MathJsChain<string>): MathJsChain<number>
+
+    /**
+     * Compute the sum of a matrix or a list with values. In case of a
+     * (multi dimensional) array or matrix, the sum of all elements will be
+     * calculated.
+     */
+    sum(
+      this: MathJsChain<Array<number | BigNumber | Fraction>>
+    ): MathJsChain<number>
+    sum(this: MathJsChain<MathCollection>): MathJsChain<number>
     /*************************************************************************
      * Bitwise functions
      ************************************************************************/
@@ -5255,16 +5295,7 @@ declare namespace math {
      * @param format The matrix storage format
      */
     ones(
-      this: MathJsChain<number | number[]>,
-      format?: string
-    ): MathJsChain<MathCollection>
-
-    /**
-     * @param format The matrix storage format
-     */
-    ones(
-      this: MathJsChain<number>,
-      n: number,
+      this: MathJsChain<number | number[] | BigNumber | BigNumber[]>,
       format?: string
     ): MathJsChain<MathCollection>
 
@@ -5403,17 +5434,7 @@ declare namespace math {
      * @returns A matrix filled with zeros
      */
     zeros(
-      this: MathJsChain<number | number[]>,
-      format?: string
-    ): MathJsChain<MathCollection>
-
-    /**
-     * @param n The y dimension of the matrix
-     * @param format The matrix storage format
-     */
-    zeros(
-      this: MathJsChain<number>,
-      n: number,
+      this: MathJsChain<number | number[] | BigNumber | BigNumber[]>,
       format?: string
     ): MathJsChain<MathCollection>