mathjs 9.5.1 → 10.0.2

package/lib/esm/expression/Parser.js

@@ -37,7 +37,7 @@ export var createParserClass = /* #__PURE__ */factory(name, dependencies, _ref =
    *    // define variables and functions
    *    parser.evaluate('x = 7 / 2')              // 3.5
    *    parser.evaluate('x + 3')                  // 6.5
-   *    parser.evaluate('function f(x, y) = x^y') // f(x, y)
+   *    parser.evaluate('f(x, y) = x^y')          // f(x, y)
    *    parser.evaluate('f(2, 3)')                // 8
    *
    *    // get and set variables and functions

package/lib/esm/expression/function/parser.js

@@ -25,10 +25,10 @@ export var createParser = /* #__PURE__ */factory(name, dependencies, _ref => {
    *     const d = parser.evaluate('cos(45 deg)')     // 0.7071067811865476
    *
    *     // define variables and functions
-   *     parser.evaluate('x = 7 / 2')                 // 3.5
-   *     parser.evaluate('x + 3')                     // 6.5
-   *     parser.evaluate('function f(x, y) = x^y')    // f(x, y)
-   *     parser.evaluate('f(2, 3)')                   // 8
+   *     parser.evaluate('x = 7 / 2')             // 3.5
+   *     parser.evaluate('x + 3')                 // 6.5
+   *     parser.evaluate('f(x, y) = x^y')         // f(x, y)
+   *     parser.evaluate('f(2, 3)')               // 8
    *
    *     // get and set variables and functions
    *     const x = parser.get('x')                // 7

package/lib/esm/function/algebra/simplify.js

@@ -365,6 +365,9 @@ export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
   {
     l: 'n1/(n2/n3)',
     r: '(n1*n3)/n2'
+  }, {
+    l: 'n1/(-n2)',
+    r: '-n1/n2'
   }];
   /**
    * Parse the string array of rules into nodes

package/lib/esm/function/arithmetic/round.js

@@ -1,8 +1,8 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
 import { factory } from '../../utils/factory.js';
 import { deepMap } from '../../utils/collection.js';

package/lib/esm/function/geometry/intersect.js

@@ -1,7 +1,6 @@
-import { isBigNumber } from '../../utils/is.js';
 import { factory } from '../../utils/factory.js';
 var name = 'intersect';
-var dependencies = ['typed', 'config', 'abs', 'add', 'addScalar', 'matrix', 'multiply', 'multiplyScalar', 'divideScalar', 'subtract', 'smaller', 'equalScalar', 'flatten'];
+var dependencies = ['typed', 'config', 'abs', 'add', 'addScalar', 'matrix', 'multiply', 'multiplyScalar', 'divideScalar', 'subtract', 'smaller', 'equalScalar', 'flatten', 'isZero', 'isNumeric'];
 export var createIntersect = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
@@ -16,7 +15,9 @@ export var createIntersect = /* #__PURE__ */factory(name, dependencies, _ref =>
     subtract,
     smaller,
     equalScalar,
-    flatten
+    flatten,
+    isZero,
+    isNumeric
   } = _ref;
 
   /**
@@ -142,21 +143,16 @@ export var createIntersect = /* #__PURE__ */factory(name, dependencies, _ref =>
     return arr;
   }
 
-  function _isNumeric(a) {
-    // intersect supports numbers and bignumbers
-    return typeof a === 'number' || isBigNumber(a);
-  }
-
   function _2d(x) {
-    return x.length === 2 && _isNumeric(x[0]) && _isNumeric(x[1]);
+    return x.length === 2 && isNumeric(x[0]) && isNumeric(x[1]);
   }
 
   function _3d(x) {
-    return x.length === 3 && _isNumeric(x[0]) && _isNumeric(x[1]) && _isNumeric(x[2]);
+    return x.length === 3 && isNumeric(x[0]) && isNumeric(x[1]) && isNumeric(x[2]);
   }
 
   function _4d(x) {
-    return x.length === 4 && _isNumeric(x[0]) && _isNumeric(x[1]) && _isNumeric(x[2]) && _isNumeric(x[3]);
+    return x.length === 4 && isNumeric(x[0]) && isNumeric(x[1]) && isNumeric(x[2]) && isNumeric(x[3]);
   }
 
   function _intersect2d(p1a, p1b, p2a, p2b) {
@@ -165,6 +161,7 @@ export var createIntersect = /* #__PURE__ */factory(name, dependencies, _ref =>
     var d1 = subtract(o1, p1b);
     var d2 = subtract(o2, p2b);
     var det = subtract(multiplyScalar(d1[0], d2[1]), multiplyScalar(d2[0], d1[1]));
+    if (isZero(det)) return null;
 
     if (smaller(abs(det), config.epsilon)) {
       return null;
@@ -197,7 +194,10 @@ export var createIntersect = /* #__PURE__ */factory(name, dependencies, _ref =>
 
     var d2121 = _intersect3dHelper(x2, x1, x2, x1, y2, y1, y2, y1, z2, z1, z2, z1);
 
-    var ta = divideScalar(subtract(multiplyScalar(d1343, d4321), multiplyScalar(d1321, d4343)), subtract(multiplyScalar(d2121, d4343), multiplyScalar(d4321, d4321)));
+    var numerator = subtract(multiplyScalar(d1343, d4321), multiplyScalar(d1321, d4343));
+    var denominator = subtract(multiplyScalar(d2121, d4343), multiplyScalar(d4321, d4321));
+    if (isZero(denominator)) return null;
+    var ta = divideScalar(numerator, denominator);
     var tb = divideScalar(addScalar(d1343, multiplyScalar(ta, d4321)), d4343);
     var pax = addScalar(x1, multiplyScalar(ta, subtract(x2, x1)));
     var pay = addScalar(y1, multiplyScalar(ta, subtract(y2, y1)));

package/lib/esm/function/probability/gamma.js

@@ -41,44 +41,42 @@ export var createGamma = /* #__PURE__ */factory(name, dependencies, _ref => {
     Complex: function Complex(n) {
       if (n.im === 0) {
         return this(n.re);
-      }
+      } // Lanczos approximation doesn't work well with real part lower than 0.5
+      // So reflection formula is required
+
+
+      if (n.re < 0.5) {
+        // Euler's reflection formula
+        // gamma(1-z) * gamma(z) = PI / sin(PI * z)
+        // real part of Z should not be integer [sin(PI) == 0 -> 1/0 - undefined]
+        // thanks to imperfect sin implementation sin(PI * n) != 0
+        // we can safely use it anyway
+        var _t = new _Complex(1 - n.re, -n.im);
+
+        var r = new _Complex(Math.PI * n.re, Math.PI * n.im);
+        return new _Complex(Math.PI).div(r.sin()).div(this(_t));
+      } // Lanczos approximation
+      // z -= 1
+
 
-      n = new _Complex(n.re - 1, n.im);
-      var x = new _Complex(gammaP[0], 0);
+      n = new _Complex(n.re - 1, n.im); // x = gammaPval[0]
+
+      var x = new _Complex(gammaP[0], 0); // for (i, gammaPval) in enumerate(gammaP):
 
       for (var i = 1; i < gammaP.length; ++i) {
-        var real = n.re + i; // x += p[i]/(n+i)
+        // x += gammaPval / (z + i)
+        var gammaPval = new _Complex(gammaP[i], 0);
+        x = x.add(gammaPval.div(n.add(i)));
+      } // t = z + gammaG + 0.5
 
-        var den = real * real + n.im * n.im;
 
-        if (den !== 0) {
-          x.re += gammaP[i] * real / den;
-          x.im += -(gammaP[i] * n.im) / den;
-        } else {
-          x.re = gammaP[i] < 0 ? -Infinity : Infinity;
-        }
-      }
+      var t = new _Complex(n.re + gammaG + 0.5, n.im); // y = sqrt(2 * pi) * t ** (z + 0.5) * exp(-t) * x
 
-      var t = new _Complex(n.re + gammaG + 0.5, n.im);
       var twoPiSqrt = Math.sqrt(2 * Math.PI);
-      n.re += 0.5;
-      var result = pow(t, n);
-
-      if (result.im === 0) {
-        // sqrt(2*PI)*result
-        result.re *= twoPiSqrt;
-      } else if (result.re === 0) {
-        result.im *= twoPiSqrt;
-      } else {
-        result.re *= twoPiSqrt;
-        result.im *= twoPiSqrt;
-      }
-
-      var r = Math.exp(-t.re); // exp(-t)
+      var tpow = t.pow(n.add(0.5));
+      var expt = t.neg().exp(); // y = [x] * [sqrt(2 * pi)] * [t ** (z + 0.5)] * [exp(-t)]
 
-      t.re = r * Math.cos(-t.im);
-      t.im = r * Math.sin(-t.im);
-      return multiplyScalar(multiplyScalar(result, t), x);
+      return x.mul(twoPiSqrt).mul(tpow).mul(expt);
     },
     BigNumber: function BigNumber(n) {
       if (n.isInteger()) {

package/lib/esm/type/matrix/SparseMatrix.js

@@ -417,23 +417,27 @@ export var createSparseMatrixClass = /* #__PURE__ */factory(name, dependencies,
 
       if (!deepStrictEqual(iSize, sSize)) {
         throw new DimensionError(iSize, sSize, '>');
-      } // offsets
+      } // insert the sub matrix
 
 
-      var x0 = index.min()[0];
-      var y0 = index.min()[1]; // submatrix rows and columns
-
-      var m = sSize[0];
-      var n = sSize[1]; // loop submatrix
-
-      for (var x = 0; x < m; x++) {
-        // loop columns
-        for (var y = 0; y < n; y++) {
-          // value at i, j
-          var v = submatrix[x][y]; // invoke set (zero value will remove entry from matrix)
-
-          matrix.set([x + x0, y + y0], v, defaultValue);
-        }
+      if (iSize.length === 1) {
+        // if the replacement index only has 1 dimension, go trough each one and set its value
+        var range = index.dimension(0);
+        range.forEach(function (dataIndex, subIndex) {
+          validateIndex(dataIndex);
+          matrix.set([dataIndex, 0], submatrix[subIndex[0]], defaultValue);
+        });
+      } else {
+        // if the replacement index has 2 dimensions, go through each one and set the value in the correct index
+        var firstDimensionRange = index.dimension(0);
+        var secondDimensionRange = index.dimension(1);
+        firstDimensionRange.forEach(function (firstDataIndex, firstSubIndex) {
+          validateIndex(firstDataIndex);
+          secondDimensionRange.forEach(function (secondDataIndex, secondSubIndex) {
+            validateIndex(secondDataIndex);
+            matrix.set([firstDataIndex, secondDataIndex], submatrix[firstSubIndex[0]][secondSubIndex[0]], defaultValue);
+          });
+        });
       }
     }
 

package/lib/esm/type/unit/Unit.js

@@ -1,9 +1,9 @@
 import _extends from "@babel/runtime/helpers/extends";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
 import { isComplex, isUnit, typeOf } from '../../utils/is.js';
 import { factory } from '../../utils/factory.js';

package/lib/esm/utils/number.js

@@ -318,7 +318,7 @@ export function format(value, options) {
 
 export function splitNumber(value) {
   // parse the input value
-  var match = String(value).toLowerCase().match(/^0*?(-?)(\d+\.?\d*)(e([+-]?\d+))?$/);
+  var match = String(value).toLowerCase().match(/^(-?)(\d+\.?\d*)(e([+-]?\d+))?$/);
 
   if (!match) {
     throw new SyntaxError('Invalid number ' + value);

package/lib/esm/utils/snapshot.js

@@ -1,9 +1,9 @@
 import _extends from "@babel/runtime/helpers/extends";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
 /**
  * This file contains helper methods to create expected snapshot structures

package/lib/esm/version.js

@@ -1,2 +1,2 @@
-export var version = '9.5.1'; // Note: This file is automatically generated when building math.js.
+export var version = '10.0.2'; // Note: This file is automatically generated when building math.js.
 // Changes made in this file will be overwritten.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mathjs",
-  "version": "9.5.1",
+  "version": "10.0.2",
   "description": "Math.js is an extensive math library for JavaScript and Node.js. It features a flexible expression parser with support for symbolic computation, comes with a large set of built-in functions and constants, and offers an integrated solution to work with different data types like numbers, big numbers, complex numbers, fractions, units, and matrices.",
   "author": "Jos de Jong <wjosdejong@gmail.com> (https://github.com/josdejong)",
   "homepage": "https://mathjs.org",
@@ -25,39 +25,39 @@
     "unit"
   ],
   "dependencies": {
-    "@babel/runtime": "^7.15.4",
+    "@babel/runtime": "^7.16.5",
     "complex.js": "^2.0.15",
     "decimal.js": "^10.3.1",
     "escape-latex": "^1.2.0",
-    "fraction.js": "^4.1.1",
+    "fraction.js": "^4.1.2",
     "javascript-natural-sort": "^0.7.1",
     "seedrandom": "^3.0.5",
     "tiny-emitter": "^2.1.0",
     "typed-function": "^2.0.0"
   },
   "devDependencies": {
-    "@babel/core": "7.15.5",
-    "@babel/plugin-transform-object-assign": "7.14.5",
-    "@babel/plugin-transform-runtime": "7.15.0",
-    "@babel/preset-env": "7.15.6",
-    "@babel/register": "7.15.3",
-    "babel-loader": "8.2.2",
+    "@babel/core": "7.16.5",
+    "@babel/plugin-transform-object-assign": "7.16.5",
+    "@babel/plugin-transform-runtime": "7.16.5",
+    "@babel/preset-env": "7.16.5",
+    "@babel/register": "7.16.5",
+    "babel-loader": "8.2.3",
     "benchmark": "2.1.4",
     "codecov": "3.8.3",
-    "core-js": "3.17.3",
+    "core-js": "3.20.1",
     "del": "6.0.0",
-    "dtslint": "4.1.6",
+    "dtslint": "4.2.1",
     "expr-eval": "2.0.2",
     "fancy-log": "1.3.3",
-    "glob": "7.1.7",
+    "glob": "7.2.0",
     "gulp": "4.0.2",
     "gulp-babel": "8.0.0",
     "handlebars": "4.7.7",
     "istanbul": "0.4.5",
-    "jsep": "1.0.3",
-    "karma": "6.3.4",
+    "jsep": "1.2.0",
+    "karma": "6.3.9",
     "karma-browserstack-launcher": "1.6.0",
-    "karma-firefox-launcher": "2.1.1",
+    "karma-firefox-launcher": "2.1.2",
     "karma-mocha": "2.0.1",
     "karma-mocha-reporter": "2.2.5",
     "karma-webpack": "4.0.2",
@@ -72,9 +72,9 @@
     "numericjs": "1.2.6",
     "nyc": "15.1.0",
     "pad-right": "0.2.2",
-    "standard": "16.0.3",
+    "standard": "16.0.4",
     "sylvester": "0.0.21",
-    "typescript": "4.4.3",
+    "typescript": "4.5.4",
     "webpack": "4.46.0",
     "zeros": "1.0.0"
   },

package/types/index.d.ts

@@ -5,10 +5,10 @@ export as namespace math;
 export = math;
 
 type NoLiteralType<T> =
-  T extends number ? number :
-  T extends string ? string :
-  T extends boolean ? boolean :
-  T;
+    T extends number ? number :
+        T extends string ? string :
+            T extends boolean ? boolean :
+                T;
 
 declare namespace math {
   type MathArray = number[] | number[][];
@@ -273,7 +273,7 @@ declare namespace math {
   interface OperatorNodeCtor {
     new(op: string, fn: string, args: MathNode[], implicit?: boolean): OperatorNode;
   }
-  
+
   interface ParenthesisNode extends MathNodeCommon {
     type: 'ParenthesisNode';
     isParenthesisNode: true;
@@ -314,8 +314,8 @@ declare namespace math {
   }
 
   type MathNode = AccessorNode | ArrayNode | AssignmentNode | BlockNode | ConditionalNode | ConstantNode |
-    FunctionAssignmentNode | FunctionNode | IndexNode | ObjectNode | OperatorNode | ParenthesisNode | RangeNode |
-    RelationalNode | SymbolNode;
+      FunctionAssignmentNode | FunctionNode | IndexNode | ObjectNode | OperatorNode | ParenthesisNode | RangeNode |
+      RelationalNode | SymbolNode;
 
 
   type MathJsFunctionName = keyof MathJsStatic;
@@ -489,8 +489,8 @@ declare namespace math {
      * @returns Returns a fraction
      */
     fraction(
-      numerator: number | string | MathArray | Matrix,
-      denominator?: number | string | MathArray | Matrix
+        numerator: number | string | MathArray | Matrix,
+        denominator?: number | string | MathArray | Matrix
     ): Fraction | MathArray | Matrix;
 
     /**
@@ -693,11 +693,11 @@ declare namespace math {
      * @returns The rational polynomial of expr
      */
     rationalize(
-      expr: MathNode | string,
-      optional?: object | boolean,
-      detailed?: true
+        expr: MathNode | string,
+        optional?: object | boolean,
+        detailed?: true
     ): { expression: MathNode | string; variables: string[]; coefficients: MathType[] };
-    
+
 
     /**
      * Simplify an expression tree.
@@ -903,17 +903,17 @@ declare namespace math {
     floor(x: MathArray): MathArray;
     floor(x: Matrix): Matrix;
 
-      /**
+    /**
      * Round a value towards minus infinity. For matrices, the function is
      * evaluated element wise.
      * @param x Number to be rounded
      * @param n Number of decimals Default value: 0.
      * @returns Rounded value
      */
-       floor(
+    floor(
         x: number | BigNumber | Fraction | Complex | MathArray | Matrix,
         n: number | BigNumber | MathArray
-      ): number | BigNumber | Fraction | Complex | MathArray | Matrix;
+    ): number | BigNumber | Fraction | Complex | MathArray | Matrix;
 
     /**
      * Calculate the greatest common divisor for two or more values or
@@ -1009,8 +1009,8 @@ declare namespace math {
      * @returns Returns the remainder of x divided by y
      */
     mod<T extends number | BigNumber | Fraction | MathArray | Matrix>(
-      x: T,
-      y: number | BigNumber | Fraction | MathArray | Matrix
+        x: T,
+        y: number | BigNumber | Fraction | MathArray | Matrix
     ): NoLiteralType<T>;
 
     /**
@@ -1063,8 +1063,8 @@ declare namespace math {
      * @returns Rounded value of x
      */
     round<T extends number | BigNumber | Fraction | Complex | MathArray | Matrix>(
-      x: T,
-      n?: number | BigNumber | MathArray
+        x: T,
+        n?: number | BigNumber | MathArray
     ): NoLiteralType<T>;
 
     /**
@@ -1378,8 +1378,8 @@ declare namespace math {
      * nonzero/nonempty value.
      */
     and(
-      x: number | BigNumber | Complex | Unit | MathArray | Matrix,
-      y: number | BigNumber | Complex | Unit | MathArray | Matrix
+        x: number | BigNumber | Complex | Unit | MathArray | Matrix,
+        y: number | BigNumber | Complex | Unit | MathArray | Matrix
     ): boolean | MathArray | Matrix;
 
     /**
@@ -1400,8 +1400,8 @@ declare namespace math {
      * nonzero/nonempty value.
      */
     or(
-      x: number | BigNumber | Complex | Unit | MathArray | Matrix,
-      y: number | BigNumber | Complex | Unit | MathArray | Matrix
+        x: number | BigNumber | Complex | Unit | MathArray | Matrix,
+        y: number | BigNumber | Complex | Unit | MathArray | Matrix
     ): boolean | MathArray | Matrix;
 
     /**
@@ -1414,8 +1414,8 @@ declare namespace math {
      * nonzero/nonempty value.
      */
     xor(
-      x: number | BigNumber | Complex | Unit | MathArray | Matrix,
-      y: number | BigNumber | Complex | Unit | MathArray | Matrix
+        x: number | BigNumber | Complex | Unit | MathArray | Matrix,
+        y: number | BigNumber | Complex | Unit | MathArray | Matrix
     ): boolean | MathArray | Matrix;
 
     /*************************************************************************
@@ -1432,7 +1432,7 @@ declare namespace math {
      * array or 1-d matrix as an input and return a number.
      * @returns The residual matrix with the function applied over some dimension.
      */
-     apply<T extends MathArray | Matrix>(array: T, dim: number, callback: (array: MathArray | Matrix) => number): T
+    apply<T extends MathArray | Matrix>(array: T, dim: number, callback: (array: MathArray | Matrix) => number): T
 
 
     /**
@@ -1502,7 +1502,7 @@ declare namespace math {
      * @param prec Precision, default value: 1e-15
      * @returns Object containing an array of eigenvalues and a matrix with eigenvectors as columns.
      */
-     eigs(x: MathArray | Matrix, prec?:number|BigNumber): {values: MathArray | Matrix, vectors: MathArray | Matrix}
+    eigs(x: MathArray | Matrix, prec?:number|BigNumber): {values: MathArray | Matrix, vectors: MathArray | Matrix}
 
     /**
      * Compute the matrix exponential, expm(A) = e^A. The matrix must be
@@ -1541,8 +1541,8 @@ declare namespace math {
      * traversed. The function must return a boolean.
      */
     filter(
-      x: Matrix | MathArray | string[],
-      test: ((value: any, index: any, matrix: Matrix | MathArray | string[]) => boolean) | RegExp
+        x: Matrix | MathArray | string[],
+        test: ((value: any, index: any, matrix: Matrix | MathArray | string[]) => boolean) | RegExp
     ): Matrix | MathArray;
 
     /**
@@ -2619,7 +2619,7 @@ declare namespace math {
      */
     clone(x: any): any;
 
-       /**
+    /**
      * Test whether a value is an numeric value. In case of a string,
      *  true is returned if the string contains a numeric value.
      * @param x Value to be tested
@@ -2627,7 +2627,7 @@ declare namespace math {
      * Returns false for other types.
      * Throws an error in case of unknown types.
      */
-     hasNumericValue(x: any ): boolean| boolean[];
+    hasNumericValue(x: any ): boolean| boolean[];
 
     /**
      * Test whether a value is an integer number. The function supports
@@ -2732,10 +2732,10 @@ declare namespace math {
   interface FactoryDependencies {
     create: (factories: FactoryFunctionMap, config?: ConfigOptions) => MathJsStatic;
     factory: <T>(
-      name: string,
-      dependencies: MathJsFunctionName[],
-      create: (injected: Partial<MathJsStatic>) => T,
-      meta?: any
+        name: string,
+        dependencies: MathJsFunctionName[],
+        create: (injected: Partial<MathJsStatic>) => T,
+        meta?: any
     ) => FactoryFunction<T>;
     all: FactoryFunctionMap;
 
@@ -3164,15 +3164,15 @@ declare namespace math {
 
   interface Simplify {
     (
-      expr: MathNode | string,
-      rules?: SimplifyRule[],
-      scope?: object,
-      options?: SimplifyOptions,
+        expr: MathNode | string,
+        rules?: SimplifyRule[],
+        scope?: object,
+        options?: SimplifyOptions,
     ): MathNode;
     (
-      expr: MathNode | string,
-      scope?: object,
-      options?: SimplifyOptions,
+        expr: MathNode | string,
+        scope?: object,
+        options?: SimplifyOptions,
     ): MathNode;
 
     rules: SimplifyRule[];
@@ -3197,8 +3197,8 @@ declare namespace math {
     isNode: true;
     comment: string;
     type: 'AccessorNode' | 'ArrayNode' | 'AssignmentNode' | 'BlockNode' | 'ConditionalNode' | 'ConstantNode' |
-          'FunctionAssignmentNode' | 'FunctionNode' | 'IndexNode' | 'ObjectNode' | 'OperatorNode' | 'ParenthesisNode' |
-          'RangeNode' | 'RelationalNode' | 'SymbolNode';
+        'FunctionAssignmentNode' | 'FunctionNode' | 'IndexNode' | 'ObjectNode' | 'OperatorNode' | 'ParenthesisNode' |
+        'RangeNode' | 'RelationalNode' | 'SymbolNode';
 
     isUpdateNode?: boolean;
 
@@ -3275,7 +3275,7 @@ declare namespace math {
     /**
      * Get a HTML representation of the parsed expression.
      */
-    toHtml(options?: object): string;
+    toHTML(options?: object): string;
 
     /**
      * Get a string representation of the parsed expression. This is not
@@ -3690,7 +3690,7 @@ declare namespace math {
      * array or 1-d matrix as an input and return a number.
      * @returns The residual matrix with the function applied over some dimension.
      */
-     apply(dim: number, callback: (array: Array<MathType> | Matrix) => number): MathJsChain;
+    apply(dim: number, callback: (array: Array<MathType> | Matrix) => number): MathJsChain;
 
     /**
      * Calculate the cubic root of a value. For matrices, the function is