mathjs 12.4.3 → 13.0.0

package/lib/cjs/function/algebra/derivative.js

@@ -6,21 +6,24 @@ Object.defineProperty(exports, "__esModule", {
 exports.createDerivative = void 0;
 var _is = require("../../utils/is.js");
 var _factory = require("../../utils/factory.js");
-var name = 'derivative';
-var dependencies = ['typed', 'config', 'parse', 'simplify', 'equal', 'isZero', 'numeric', 'ConstantNode', 'FunctionNode', 'OperatorNode', 'ParenthesisNode', 'SymbolNode'];
-var createDerivative = exports.createDerivative = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    config = _ref.config,
-    parse = _ref.parse,
-    simplify = _ref.simplify,
-    equal = _ref.equal,
-    isZero = _ref.isZero,
-    numeric = _ref.numeric,
-    ConstantNode = _ref.ConstantNode,
-    FunctionNode = _ref.FunctionNode,
-    OperatorNode = _ref.OperatorNode,
-    ParenthesisNode = _ref.ParenthesisNode,
-    SymbolNode = _ref.SymbolNode;
+var _number = require("../../utils/number.js");
+const name = 'derivative';
+const dependencies = ['typed', 'config', 'parse', 'simplify', 'equal', 'isZero', 'numeric', 'ConstantNode', 'FunctionNode', 'OperatorNode', 'ParenthesisNode', 'SymbolNode'];
+const createDerivative = exports.createDerivative = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    config,
+    parse,
+    simplify,
+    equal,
+    isZero,
+    numeric,
+    ConstantNode,
+    FunctionNode,
+    OperatorNode,
+    ParenthesisNode,
+    SymbolNode
+  } = _ref;
   /**
    * Takes the derivative of an expression expressed in parser Nodes.
    * The derivative will be taken over the supplied variable in the
@@ -60,12 +63,12 @@ var createDerivative = exports.createDerivative = /* #__PURE__ */(0, _factory.fa
    * @return {ConstantNode | SymbolNode | ParenthesisNode | FunctionNode | OperatorNode}    The derivative of `expr`
    */
   function plainDerivative(expr, variable) {
-    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
+    let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
       simplify: true
     };
-    var constNodes = {};
+    const constNodes = {};
     constTag(constNodes, expr, variable.name);
-    var res = _derivative(expr, constNodes);
+    const res = _derivative(expr, constNodes);
     return options.simplify ? simplify(res) : res;
   }
   typed.addConversion({
@@ -73,7 +76,7 @@ var createDerivative = exports.createDerivative = /* #__PURE__ */(0, _factory.fa
     to: 'SymbolNode',
     convert: parse
   });
-  var derivative = typed(name, {
+  const derivative = typed(name, {
     'Node, SymbolNode': plainDerivative,
     'Node, SymbolNode, Object': plainDerivative
 
@@ -101,32 +104,32 @@ var createDerivative = exports.createDerivative = /* #__PURE__ */(0, _factory.fa
 
   // FIXME: move the toTex method of derivative to latex.js. Difficulty is that it relies on parse.
   // NOTE: the optional "order" parameter here is currently unused
-  var _derivTex = typed('_derivTex', {
-    'Node, SymbolNode': function NodeSymbolNode(expr, x) {
+  const _derivTex = typed('_derivTex', {
+    'Node, SymbolNode': function (expr, x) {
       if ((0, _is.isConstantNode)(expr) && (0, _is.typeOf)(expr.value) === 'string') {
         return _derivTex(parse(expr.value).toString(), x.toString(), 1);
       } else {
         return _derivTex(expr.toTex(), x.toString(), 1);
       }
     },
-    'Node, ConstantNode': function NodeConstantNode(expr, x) {
+    'Node, ConstantNode': function (expr, x) {
       if ((0, _is.typeOf)(x.value) === 'string') {
         return _derivTex(expr, parse(x.value));
       } else {
         throw new Error("The second parameter to 'derivative' is a non-string constant");
       }
     },
-    'Node, SymbolNode, ConstantNode': function NodeSymbolNodeConstantNode(expr, x, order) {
+    'Node, SymbolNode, ConstantNode': function (expr, x, order) {
       return _derivTex(expr.toString(), x.name, order.value);
     },
-    'string, string, number': function stringStringNumber(expr, x, order) {
-      var d;
+    'string, string, number': function (expr, x, order) {
+      let d;
       if (order === 1) {
         d = '{d\\over d' + x + '}';
       } else {
         d = '{d^{' + order + '}\\over d' + x + '^{' + order + '}}';
       }
-      return d + "\\left[".concat(expr, "\\right]");
+      return d + `\\left[${expr}\\right]`;
     }
   });
 
@@ -145,12 +148,12 @@ var createDerivative = exports.createDerivative = /* #__PURE__ */(0, _factory.fa
    * @return {boolean}  if node is constant
    */
   // TODO: can we rewrite constTag into a pure function?
-  var constTag = typed('constTag', {
-    'Object, ConstantNode, string': function ObjectConstantNodeString(constNodes, node) {
+  const constTag = typed('constTag', {
+    'Object, ConstantNode, string': function (constNodes, node) {
       constNodes[node] = true;
       return true;
     },
-    'Object, SymbolNode, string': function ObjectSymbolNodeString(constNodes, node, varName) {
+    'Object, SymbolNode, string': function (constNodes, node, varName) {
       // Treat other variables like constants. For reasoning, see:
       //   https://en.wikipedia.org/wiki/Partial_derivative
       if (node.name !== varName) {
@@ -159,20 +162,20 @@ var createDerivative = exports.createDerivative = /* #__PURE__ */(0, _factory.fa
       }
       return false;
     },
-    'Object, ParenthesisNode, string': function ObjectParenthesisNodeString(constNodes, node, varName) {
+    'Object, ParenthesisNode, string': function (constNodes, node, varName) {
       return constTag(constNodes, node.content, varName);
     },
-    'Object, FunctionAssignmentNode, string': function ObjectFunctionAssignmentNodeString(constNodes, node, varName) {
+    'Object, FunctionAssignmentNode, string': function (constNodes, node, varName) {
       if (!node.params.includes(varName)) {
         constNodes[node] = true;
         return true;
       }
       return constTag(constNodes, node.expr, varName);
     },
-    'Object, FunctionNode | OperatorNode, string': function ObjectFunctionNodeOperatorNodeString(constNodes, node, varName) {
+    'Object, FunctionNode | OperatorNode, string': function (constNodes, node, varName) {
       if (node.args.length > 0) {
-        var isConst = constTag(constNodes, node.args[0], varName);
-        for (var i = 1; i < node.args.length; ++i) {
+        let isConst = constTag(constNodes, node.args[0], varName);
+        for (let i = 1; i < node.args.length; ++i) {
           isConst = constTag(constNodes, node.args[i], varName) && isConst;
         }
         if (isConst) {
@@ -191,35 +194,35 @@ var createDerivative = exports.createDerivative = /* #__PURE__ */(0, _factory.fa
    * @param  {Object} constNodes  Holds the nodes that are constant
    * @return {ConstantNode | SymbolNode | ParenthesisNode | FunctionNode | OperatorNode}    The derivative of `expr`
    */
-  var _derivative = typed('_derivative', {
-    'ConstantNode, Object': function ConstantNodeObject(node) {
+  const _derivative = typed('_derivative', {
+    'ConstantNode, Object': function (node) {
       return createConstantNode(0);
     },
-    'SymbolNode, Object': function SymbolNodeObject(node, constNodes) {
+    'SymbolNode, Object': function (node, constNodes) {
       if (constNodes[node] !== undefined) {
         return createConstantNode(0);
       }
       return createConstantNode(1);
     },
-    'ParenthesisNode, Object': function ParenthesisNodeObject(node, constNodes) {
+    'ParenthesisNode, Object': function (node, constNodes) {
       return new ParenthesisNode(_derivative(node.content, constNodes));
     },
-    'FunctionAssignmentNode, Object': function FunctionAssignmentNodeObject(node, constNodes) {
+    'FunctionAssignmentNode, Object': function (node, constNodes) {
       if (constNodes[node] !== undefined) {
         return createConstantNode(0);
       }
       return _derivative(node.expr, constNodes);
     },
-    'FunctionNode, Object': function FunctionNodeObject(node, constNodes) {
+    'FunctionNode, Object': function (node, constNodes) {
       if (constNodes[node] !== undefined) {
         return createConstantNode(0);
       }
-      var arg0 = node.args[0];
-      var arg1;
-      var div = false; // is output a fraction?
-      var negative = false; // is output negative?
+      const arg0 = node.args[0];
+      let arg1;
+      let div = false; // is output a fraction?
+      let negative = false; // is output negative?
 
-      var funcDerivative;
+      let funcDerivative;
       switch (node.name) {
         case 'cbrt':
           // d/dx(cbrt(x)) = 1 / (3x^(2/3))
@@ -396,7 +399,7 @@ var createDerivative = exports.createDerivative = /* #__PURE__ */(0, _factory.fa
         default:
           throw new Error('Cannot process function "' + node.name + '" in derivative: ' + 'the function is not supported, undefined, or the number of arguments passed to it are not supported');
       }
-      var op, func;
+      let op, func;
       if (div) {
         op = '/';
         func = 'divide';
@@ -408,13 +411,13 @@ var createDerivative = exports.createDerivative = /* #__PURE__ */(0, _factory.fa
       /* Apply chain rule to all functions:
          F(x)  = f(g(x))
          F'(x) = g'(x)*f'(g(x)) */
-      var chainDerivative = _derivative(arg0, constNodes);
+      let chainDerivative = _derivative(arg0, constNodes);
       if (negative) {
         chainDerivative = new OperatorNode('-', 'unaryMinus', [chainDerivative]);
       }
       return new OperatorNode(op, func, [chainDerivative, funcDerivative]);
     },
-    'OperatorNode, Object': function OperatorNodeObject(node, constNodes) {
+    'OperatorNode, Object': function (node, constNodes) {
       if (constNodes[node] !== undefined) {
         return createConstantNode(0);
       }
@@ -437,15 +440,15 @@ var createDerivative = exports.createDerivative = /* #__PURE__ */(0, _factory.fa
       }
       if (node.op === '*') {
         // d/dx(c*f(x)) = c*f'(x)
-        var constantTerms = node.args.filter(function (arg) {
+        const constantTerms = node.args.filter(function (arg) {
           return constNodes[arg] !== undefined;
         });
         if (constantTerms.length > 0) {
-          var nonConstantTerms = node.args.filter(function (arg) {
+          const nonConstantTerms = node.args.filter(function (arg) {
             return constNodes[arg] === undefined;
           });
-          var nonConstantNode = nonConstantTerms.length === 1 ? nonConstantTerms[0] : new OperatorNode('*', 'multiply', nonConstantTerms);
-          var newArgs = constantTerms.concat(_derivative(nonConstantNode, constNodes));
+          const nonConstantNode = nonConstantTerms.length === 1 ? nonConstantTerms[0] : new OperatorNode('*', 'multiply', nonConstantTerms);
+          const newArgs = constantTerms.concat(_derivative(nonConstantNode, constNodes));
           return new OperatorNode('*', 'multiply', newArgs);
         }
 
@@ -457,8 +460,8 @@ var createDerivative = exports.createDerivative = /* #__PURE__ */(0, _factory.fa
         }));
       }
       if (node.op === '/' && node.isBinary()) {
-        var arg0 = node.args[0];
-        var arg1 = node.args[1];
+        const arg0 = node.args[0];
+        const arg1 = node.args[1];
 
         // d/dx(f(x) / c) = f'(x) / c
         if (constNodes[arg1] !== undefined) {
@@ -474,36 +477,36 @@ var createDerivative = exports.createDerivative = /* #__PURE__ */(0, _factory.fa
         return new OperatorNode('/', 'divide', [new OperatorNode('-', 'subtract', [new OperatorNode('*', 'multiply', [_derivative(arg0, constNodes), arg1.clone()]), new OperatorNode('*', 'multiply', [arg0.clone(), _derivative(arg1, constNodes)])]), new OperatorNode('^', 'pow', [arg1.clone(), createConstantNode(2)])]);
       }
       if (node.op === '^' && node.isBinary()) {
-        var _arg = node.args[0];
-        var _arg2 = node.args[1];
-        if (constNodes[_arg] !== undefined) {
+        const arg0 = node.args[0];
+        const arg1 = node.args[1];
+        if (constNodes[arg0] !== undefined) {
           // If is secretly constant; 0^f(x) = 1 (in JS), 1^f(x) = 1
-          if ((0, _is.isConstantNode)(_arg) && (isZero(_arg.value) || equal(_arg.value, 1))) {
+          if ((0, _is.isConstantNode)(arg0) && (isZero(arg0.value) || equal(arg0.value, 1))) {
             return createConstantNode(0);
           }
 
           // d/dx(c^f(x)) = c^f(x)*ln(c)*f'(x)
-          return new OperatorNode('*', 'multiply', [node, new OperatorNode('*', 'multiply', [new FunctionNode('log', [_arg.clone()]), _derivative(_arg2.clone(), constNodes)])]);
+          return new OperatorNode('*', 'multiply', [node, new OperatorNode('*', 'multiply', [new FunctionNode('log', [arg0.clone()]), _derivative(arg1.clone(), constNodes)])]);
         }
-        if (constNodes[_arg2] !== undefined) {
-          if ((0, _is.isConstantNode)(_arg2)) {
+        if (constNodes[arg1] !== undefined) {
+          if ((0, _is.isConstantNode)(arg1)) {
             // If is secretly constant; f(x)^0 = 1 -> d/dx(1) = 0
-            if (isZero(_arg2.value)) {
+            if (isZero(arg1.value)) {
               return createConstantNode(0);
             }
             // Ignore exponent; f(x)^1 = f(x)
-            if (equal(_arg2.value, 1)) {
-              return _derivative(_arg, constNodes);
+            if (equal(arg1.value, 1)) {
+              return _derivative(arg0, constNodes);
             }
           }
 
           // Elementary Power Rule, d/dx(f(x)^c) = c*f'(x)*f(x)^(c-1)
-          var powMinusOne = new OperatorNode('^', 'pow', [_arg.clone(), new OperatorNode('-', 'subtract', [_arg2, createConstantNode(1)])]);
-          return new OperatorNode('*', 'multiply', [_arg2.clone(), new OperatorNode('*', 'multiply', [_derivative(_arg, constNodes), powMinusOne])]);
+          const powMinusOne = new OperatorNode('^', 'pow', [arg0.clone(), new OperatorNode('-', 'subtract', [arg1, createConstantNode(1)])]);
+          return new OperatorNode('*', 'multiply', [arg1.clone(), new OperatorNode('*', 'multiply', [_derivative(arg0, constNodes), powMinusOne])]);
         }
 
         // Functional Power Rule, d/dx(f^g) = f^g*[f'*(g/f) + g'ln(f)]
-        return new OperatorNode('*', 'multiply', [new OperatorNode('^', 'pow', [_arg.clone(), _arg2.clone()]), new OperatorNode('+', 'add', [new OperatorNode('*', 'multiply', [_derivative(_arg, constNodes), new OperatorNode('/', 'divide', [_arg2.clone(), _arg.clone()])]), new OperatorNode('*', 'multiply', [_derivative(_arg2, constNodes), new FunctionNode('log', [_arg.clone()])])])]);
+        return new OperatorNode('*', 'multiply', [new OperatorNode('^', 'pow', [arg0.clone(), arg1.clone()]), new OperatorNode('+', 'add', [new OperatorNode('*', 'multiply', [_derivative(arg0, constNodes), new OperatorNode('/', 'divide', [arg1.clone(), arg0.clone()])]), new OperatorNode('*', 'multiply', [_derivative(arg1, constNodes), new FunctionNode('log', [arg0.clone()])])])]);
       }
       throw new Error('Cannot process operator "' + node.op + '" in derivative: ' + 'the operator is not supported, undefined, or the number of arguments passed to it are not supported');
     }
@@ -517,7 +520,7 @@ var createDerivative = exports.createDerivative = /* #__PURE__ */(0, _factory.fa
    * @return {ConstantNode}
    */
   function createConstantNode(value, valueType) {
-    return new ConstantNode(numeric(value, valueType || config.number));
+    return new ConstantNode(numeric(value, valueType || (0, _number.safeNumberType)(String(value), config)));
   }
   return derivative;
 });

package/lib/cjs/function/algebra/leafCount.js

@@ -5,16 +5,18 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createLeafCount = void 0;
 var _factory = require("../../utils/factory.js");
-var name = 'leafCount';
-var dependencies = ['parse', 'typed'];
-var createLeafCount = exports.createLeafCount = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var parse = _ref.parse,
-    typed = _ref.typed;
+const name = 'leafCount';
+const dependencies = ['parse', 'typed'];
+const createLeafCount = exports.createLeafCount = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    parse,
+    typed
+  } = _ref;
   // This does the real work, but we don't have to recurse through
   // a typed call if we separate it out
   function countLeaves(node) {
-    var count = 0;
-    node.forEach(function (n) {
+    let count = 0;
+    node.forEach(n => {
       count += countLeaves(n);
     });
     return count || 1;
@@ -51,7 +53,7 @@ var createLeafCount = exports.createLeafCount = /* #__PURE__ */(0, _factory.fact
    *
    */
   return typed(name, {
-    Node: function Node(expr) {
+    Node: function (expr) {
       return countLeaves(expr);
     }
   });

package/lib/cjs/function/algebra/lyap.js

@@ -5,14 +5,16 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createLyap = void 0;
 var _factory = require("../../utils/factory.js");
-var name = 'lyap';
-var dependencies = ['typed', 'matrix', 'sylvester', 'multiply', 'transpose'];
-var createLyap = exports.createLyap = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    matrix = _ref.matrix,
-    sylvester = _ref.sylvester,
-    multiply = _ref.multiply,
-    transpose = _ref.transpose;
+const name = 'lyap';
+const dependencies = ['typed', 'matrix', 'sylvester', 'multiply', 'transpose'];
+const createLyap = exports.createLyap = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    matrix,
+    sylvester,
+    multiply,
+    transpose
+  } = _ref;
   /**
    *
    * Solves the Continuous-time Lyapunov equation AP+PA'+Q=0 for P, where
@@ -40,16 +42,16 @@ var createLyap = exports.createLyap = /* #__PURE__ */(0, _factory.factory)(name,
    * @return {Matrix | Array} Matrix P solution to the Continuous-time Lyapunov equation AP+PA'=Q
    */
   return typed(name, {
-    'Matrix, Matrix': function MatrixMatrix(A, Q) {
+    'Matrix, Matrix': function (A, Q) {
       return sylvester(A, transpose(A), multiply(-1, Q));
     },
-    'Array, Matrix': function ArrayMatrix(A, Q) {
+    'Array, Matrix': function (A, Q) {
       return sylvester(matrix(A), transpose(matrix(A)), multiply(-1, Q));
     },
-    'Matrix, Array': function MatrixArray(A, Q) {
+    'Matrix, Array': function (A, Q) {
       return sylvester(A, transpose(matrix(A)), matrix(multiply(-1, Q)));
     },
-    'Array, Array': function ArrayArray(A, Q) {
+    'Array, Array': function (A, Q) {
       return sylvester(matrix(A), transpose(matrix(A)), matrix(multiply(-1, Q))).toArray();
     }
   });

package/lib/cjs/function/algebra/polynomialRoot.js

@@ -1,29 +1,28 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createPolynomialRoot = void 0;
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _factory = require("../../utils/factory.js");
-var name = 'polynomialRoot';
-var dependencies = ['typed', 'isZero', 'equalScalar', 'add', 'subtract', 'multiply', 'divide', 'sqrt', 'unaryMinus', 'cbrt', 'typeOf', 'im', 're'];
-var createPolynomialRoot = exports.createPolynomialRoot = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    isZero = _ref.isZero,
-    equalScalar = _ref.equalScalar,
-    add = _ref.add,
-    subtract = _ref.subtract,
-    multiply = _ref.multiply,
-    divide = _ref.divide,
-    sqrt = _ref.sqrt,
-    unaryMinus = _ref.unaryMinus,
-    cbrt = _ref.cbrt,
-    typeOf = _ref.typeOf,
-    im = _ref.im,
-    re = _ref.re;
+const name = 'polynomialRoot';
+const dependencies = ['typed', 'isZero', 'equalScalar', 'add', 'subtract', 'multiply', 'divide', 'sqrt', 'unaryMinus', 'cbrt', 'typeOf', 'im', 're'];
+const createPolynomialRoot = exports.createPolynomialRoot = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    isZero,
+    equalScalar,
+    add,
+    subtract,
+    multiply,
+    divide,
+    sqrt,
+    unaryMinus,
+    cbrt,
+    typeOf,
+    im,
+    re
+  } = _ref;
   /**
    * Finds the numerical values of the distinct roots of a polynomial with real or complex coefficients.
    * Currently operates only on linear, quadratic, and cubic polynomials using the standard
@@ -60,13 +59,13 @@ var createPolynomialRoot = exports.createPolynomialRoot = /* #__PURE__ */(0, _fa
    */
 
   return typed(name, {
-    'number|Complex, ...number|Complex': function numberComplexNumberComplex(constant, restCoeffs) {
-      var coeffs = [constant].concat((0, _toConsumableArray2["default"])(restCoeffs));
+    'number|Complex, ...number|Complex': (constant, restCoeffs) => {
+      const coeffs = [constant, ...restCoeffs];
       while (coeffs.length > 0 && isZero(coeffs[coeffs.length - 1])) {
         coeffs.pop();
       }
       if (coeffs.length < 2) {
-        throw new RangeError("Polynomial [".concat(constant, ", ").concat(restCoeffs, "] must have a non-zero non-constant coefficient"));
+        throw new RangeError(`Polynomial [${constant}, ${restCoeffs}] must have a non-zero non-constant coefficient`);
       }
       switch (coeffs.length) {
         case 2:
@@ -75,55 +74,46 @@ var createPolynomialRoot = exports.createPolynomialRoot = /* #__PURE__ */(0, _fa
         case 3:
           {
             // quadratic
-            var _coeffs = (0, _slicedToArray2["default"])(coeffs, 3),
-              c = _coeffs[0],
-              b = _coeffs[1],
-              a = _coeffs[2];
-            var denom = multiply(2, a);
-            var d1 = multiply(b, b);
-            var d2 = multiply(4, a, c);
+            const [c, b, a] = coeffs;
+            const denom = multiply(2, a);
+            const d1 = multiply(b, b);
+            const d2 = multiply(4, a, c);
             if (equalScalar(d1, d2)) return [divide(unaryMinus(b), denom)];
-            var discriminant = sqrt(subtract(d1, d2));
+            const discriminant = sqrt(subtract(d1, d2));
             return [divide(subtract(discriminant, b), denom), divide(subtract(unaryMinus(discriminant), b), denom)];
           }
         case 4:
           {
             // cubic, cf. https://en.wikipedia.org/wiki/Cubic_equation
-            var _coeffs2 = (0, _slicedToArray2["default"])(coeffs, 4),
-              d = _coeffs2[0],
-              _c = _coeffs2[1],
-              _b = _coeffs2[2],
-              _a = _coeffs2[3];
-            var _denom = unaryMinus(multiply(3, _a));
-            var D0_1 = multiply(_b, _b);
-            var D0_2 = multiply(3, _a, _c);
-            var D1_1 = add(multiply(2, _b, _b, _b), multiply(27, _a, _a, d));
-            var D1_2 = multiply(9, _a, _b, _c);
+            const [d, c, b, a] = coeffs;
+            const denom = unaryMinus(multiply(3, a));
+            const D0_1 = multiply(b, b);
+            const D0_2 = multiply(3, a, c);
+            const D1_1 = add(multiply(2, b, b, b), multiply(27, a, a, d));
+            const D1_2 = multiply(9, a, b, c);
             if (equalScalar(D0_1, D0_2) && equalScalar(D1_1, D1_2)) {
-              return [divide(_b, _denom)];
+              return [divide(b, denom)];
             }
-            var Delta0 = subtract(D0_1, D0_2);
-            var Delta1 = subtract(D1_1, D1_2);
-            var discriminant1 = add(multiply(18, _a, _b, _c, d), multiply(_b, _b, _c, _c));
-            var discriminant2 = add(multiply(4, _b, _b, _b, d), multiply(4, _a, _c, _c, _c), multiply(27, _a, _a, d, d));
+            const Delta0 = subtract(D0_1, D0_2);
+            const Delta1 = subtract(D1_1, D1_2);
+            const discriminant1 = add(multiply(18, a, b, c, d), multiply(b, b, c, c));
+            const discriminant2 = add(multiply(4, b, b, b, d), multiply(4, a, c, c, c), multiply(27, a, a, d, d));
             if (equalScalar(discriminant1, discriminant2)) {
-              return [divide(subtract(multiply(4, _a, _b, _c), add(multiply(9, _a, _a, d), multiply(_b, _b, _b))), multiply(_a, Delta0)),
+              return [divide(subtract(multiply(4, a, b, c), add(multiply(9, a, a, d), multiply(b, b, b))), multiply(a, Delta0)),
               // simple root
-              divide(subtract(multiply(9, _a, d), multiply(_b, _c)), multiply(2, Delta0)) // double root
+              divide(subtract(multiply(9, a, d), multiply(b, c)), multiply(2, Delta0)) // double root
               ];
             }
             // OK, we have three distinct roots
-            var Ccubed;
+            let Ccubed;
             if (equalScalar(D0_1, D0_2)) {
               Ccubed = Delta1;
             } else {
               Ccubed = divide(add(Delta1, sqrt(subtract(multiply(Delta1, Delta1), multiply(4, Delta0, Delta0, Delta0)))), 2);
             }
-            var allRoots = true;
-            var rawRoots = cbrt(Ccubed, allRoots).toArray().map(function (C) {
-              return divide(add(_b, C, divide(Delta0, C)), _denom);
-            });
-            return rawRoots.map(function (r) {
+            const allRoots = true;
+            const rawRoots = cbrt(Ccubed, allRoots).toArray().map(C => divide(add(b, C, divide(Delta0, C)), denom));
+            return rawRoots.map(r => {
               if (typeOf(r) === 'Complex' && equalScalar(re(r), re(r) + im(r))) {
                 return re(r);
               }
@@ -131,7 +121,7 @@ var createPolynomialRoot = exports.createPolynomialRoot = /* #__PURE__ */(0, _fa
             });
           }
         default:
-          throw new RangeError("only implemented for cubic or lower-order polynomials, not ".concat(coeffs));
+          throw new RangeError(`only implemented for cubic or lower-order polynomials, not ${coeffs}`);
       }
     }
   });