mathjs 11.8.2 → 11.9.1

package/lib/esm/function/numeric/solveODE.js

@@ -0,0 +1,284 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+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 = 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 { isUnit, isNumber, isBigNumber } from '../../utils/is.js';
+import { factory } from '../../utils/factory.js';
+var name = 'solveODE';
+var dependencies = ['typed', 'add', 'subtract', 'multiply', 'divide', 'max', 'map', 'abs', 'isPositive', 'isNegative', 'larger', 'smaller', 'matrix', 'bignumber', 'unaryMinus'];
+export var createSolveODE = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    add,
+    subtract,
+    multiply,
+    divide,
+    max,
+    map,
+    abs,
+    isPositive,
+    isNegative,
+    larger,
+    smaller,
+    matrix,
+    bignumber,
+    unaryMinus
+  } = _ref;
+  /**
+     * Numerical Integration of Ordinary Differential Equations
+     *
+     * Two variable step methods are provided:
+     * - "RK23": Bogacki–Shampine method
+     * - "RK45": Dormand-Prince method RK5(4)7M (default)
+     *
+     * The arguments are expected as follows.
+     *
+     * - `func` should be the forcing function `f(t, y)`
+     * - `tspan` should be a vector of two numbers or units `[tStart, tEnd]`
+     * - `y0` the initial state values, should be a scalar or a flat array
+     * - `options` should be an object with the following information:
+     *   - `method` ('RK45'): ['RK23', 'RK45']
+     *   - `tol` (1e-3): Numeric tolerance of the method, the solver keeps the error estimates less than this value
+     *   - `firstStep`: Initial step size
+     *   - `minStep`: minimum step size of the method
+     *   - `maxStep`: maximum step size of the method
+     *   - `minDelta` (0.2): minimum ratio of change for the step
+     *   - `maxDelta` (5): maximum ratio of change for the step
+     *   - `maxIter` (1e4): maximum number of iterations
+     *
+     * The returned value is an object with `{t, y}` please note that even though `t` means time, it can represent any other independant variable like `x`:
+     * - `t` an array of size `[n]`
+     * - `y` the states array can be in two ways
+     *   - **if `y0` is a scalar:** returns an array-like of size `[n]`
+     *   - **if `y0` is a flat array-like of size [m]:** returns an array like of size `[n, m]`
+     *
+     * Syntax:
+     *
+     *     math.solveODE(func, tspan, y0)
+     *     math.solveODE(func, tspan, y0, options)
+     *
+     * Examples:
+     *
+     *     function func(t, y) {return y}
+     *     const tspan = [0, 4]
+     *     const y0 = 1
+     *     math.solveODE(func, tspan, y0)
+     *     math.solveODE(func, tspan, [1, 2])
+     *     math.solveODE(func, tspan, y0, { method:"RK23", maxStep:0.1 })
+     *
+     * See also:
+     *
+     *     derivative, simplifyCore
+     *
+     * @param {function} func The forcing function f(t,y)
+     * @param {Array | Matrix} tspan The time span
+     * @param {number | BigNumber | Unit | Array | Matrix} y0 The initial value
+     * @param {Object} [options] Optional configuration options
+     * @return {Object} Return an object with t and y values as arrays
+     */
+
+  function _rk(butcherTableau) {
+    // generates an adaptive runge kutta method from it's butcher tableau
+
+    return function (f, tspan, y0, options) {
+      // adaptive runge kutta methods
+      var wrongTSpan = !(tspan.length === 2 && (tspan.every(isNumOrBig) || tspan.every(isUnit)));
+      if (wrongTSpan) {
+        throw new Error('"tspan" must be an Array of two numeric values or two units [tStart, tEnd]');
+      }
+      var t0 = tspan[0]; // initial time
+      var tf = tspan[1]; // final time
+      var isForwards = larger(tf, t0);
+      var firstStep = options.firstStep;
+      if (firstStep !== undefined && !isPositive(firstStep)) {
+        throw new Error('"firstStep" must be positive');
+      }
+      var maxStep = options.maxStep;
+      if (maxStep !== undefined && !isPositive(maxStep)) {
+        throw new Error('"maxStep" must be positive');
+      }
+      var minStep = options.minStep;
+      if (minStep && isNegative(minStep)) {
+        throw new Error('"minStep" must be positive or zero');
+      }
+      var timeVars = [t0, tf, firstStep, minStep, maxStep].filter(x => x !== undefined);
+      if (!(timeVars.every(isNumOrBig) || timeVars.every(isUnit))) {
+        throw new Error('Inconsistent type of "t" dependant variables');
+      }
+      var steps = 1; // divide time in this number of steps
+      var tol = options.tol ? options.tol : 1e-4; // define a tolerance (must be an option)
+      var minDelta = options.minDelta ? options.minDelta : 0.2;
+      var maxDelta = options.maxDelta ? options.maxDelta : 5;
+      var maxIter = options.maxIter ? options.maxIter : 10000; // stop inifite evaluation if something goes wrong
+      var hasBigNumbers = [t0, tf, ...y0, maxStep, minStep].some(isBigNumber);
+      var [a, c, b, bp] = hasBigNumbers ? [bignumber(butcherTableau.a), bignumber(butcherTableau.c), bignumber(butcherTableau.b), bignumber(butcherTableau.bp)] : [butcherTableau.a, butcherTableau.c, butcherTableau.b, butcherTableau.bp];
+      var h = firstStep ? isForwards ? firstStep : unaryMinus(firstStep) : divide(subtract(tf, t0), steps); // define the first step size
+      var t = [t0]; // start the time array
+      var y = [y0]; // start the solution array
+
+      var deltaB = subtract(b, bp); // b - bp
+
+      var n = 0;
+      var iter = 0;
+      var ongoing = _createOngoing(isForwards);
+      var trimStep = _createTrimStep(isForwards);
+      // iterate unitil it reaches either the final time or maximum iterations
+      while (ongoing(t[n], tf)) {
+        var k = [];
+
+        // trim the time step so that it doesn't overshoot
+        h = trimStep(t[n], tf, h);
+
+        // calculate the first value of k
+        k.push(f(t[n], y[n]));
+
+        // calculate the rest of the values of k
+        for (var i = 1; i < c.length; ++i) {
+          k.push(f(add(t[n], multiply(c[i], h)), add(y[n], multiply(h, a[i], k))));
+        }
+
+        // estimate the error by comparing solutions of different orders
+        var TE = max(abs(map(multiply(deltaB, k), X => isUnit(X) ? X.value : X)));
+        if (TE < tol && tol / TE > 1 / 4) {
+          // push solution if within tol
+          t.push(add(t[n], h));
+          y.push(add(y[n], multiply(h, b, k)));
+          n++;
+        }
+
+        // estimate the delta value that will affect the step size
+        var delta = 0.84 * (tol / TE) ** (1 / 5);
+        if (smaller(delta, minDelta)) {
+          delta = minDelta;
+        } else if (larger(delta, maxDelta)) {
+          delta = maxDelta;
+        }
+        delta = hasBigNumbers ? bignumber(delta) : delta;
+        h = multiply(h, delta);
+        if (maxStep && larger(abs(h), maxStep)) {
+          h = isForwards ? maxStep : unaryMinus(maxStep);
+        } else if (minStep && smaller(abs(h), minStep)) {
+          h = isForwards ? minStep : unaryMinus(minStep);
+        }
+        iter++;
+        if (iter > maxIter) {
+          throw new Error('Maximum number of iterations reached, try changing options');
+        }
+      }
+      return {
+        t,
+        y
+      };
+    };
+  }
+  function _rk23(f, tspan, y0, options) {
+    // Bogacki–Shampine method
+
+    // Define the butcher table
+    var a = [[], [1 / 2], [0, 3 / 4], [2 / 9, 1 / 3, 4 / 9]];
+    var c = [null, 1 / 2, 3 / 4, 1];
+    var b = [2 / 9, 1 / 3, 4 / 9, 0];
+    var bp = [7 / 24, 1 / 4, 1 / 3, 1 / 8];
+    var butcherTableau = {
+      a,
+      c,
+      b,
+      bp
+    };
+
+    // Solve an adaptive step size rk method
+    return _rk(butcherTableau)(f, tspan, y0, options);
+  }
+  function _rk45(f, tspan, y0, options) {
+    // Dormand Prince method
+
+    // Define the butcher tableau
+    var a = [[], [1 / 5], [3 / 40, 9 / 40], [44 / 45, -56 / 15, 32 / 9], [19372 / 6561, -25360 / 2187, 64448 / 6561, -212 / 729], [9017 / 3168, -355 / 33, 46732 / 5247, 49 / 176, -5103 / 18656], [35 / 384, 0, 500 / 1113, 125 / 192, -2187 / 6784, 11 / 84]];
+    var c = [null, 1 / 5, 3 / 10, 4 / 5, 8 / 9, 1, 1];
+    var b = [35 / 384, 0, 500 / 1113, 125 / 192, -2187 / 6784, 11 / 84, 0];
+    var bp = [5179 / 57600, 0, 7571 / 16695, 393 / 640, -92097 / 339200, 187 / 2100, 1 / 40];
+    var butcherTableau = {
+      a,
+      c,
+      b,
+      bp
+    };
+
+    // Solve an adaptive step size rk method
+    return _rk(butcherTableau)(f, tspan, y0, options);
+  }
+  function _solveODE(f, tspan, y0, opt) {
+    var method = opt.method ? opt.method : 'RK45';
+    var methods = {
+      RK23: _rk23,
+      RK45: _rk45
+    };
+    if (method.toUpperCase() in methods) {
+      var methodOptions = _objectSpread({}, opt); // clone the options object
+      delete methodOptions.method; // delete the method as it won't be needed
+      return methods[method.toUpperCase()](f, tspan, y0, methodOptions);
+    } else {
+      // throw an error indicating there is no such method
+      var methodsWithQuotes = Object.keys(methods).map(x => "\"".concat(x, "\""));
+      // generates a string of methods like: "BDF", "RK23" and "RK45"
+      var availableMethodsString = "".concat(methodsWithQuotes.slice(0, -1).join(', '), " and ").concat(methodsWithQuotes.slice(-1));
+      throw new Error("Unavailable method \"".concat(method, "\". Available methods are ").concat(availableMethodsString));
+    }
+  }
+  function _createOngoing(isForwards) {
+    // returns the correct function to test if it's still iterating
+    return isForwards ? smaller : larger;
+  }
+  function _createTrimStep(isForwards) {
+    var outOfBounds = isForwards ? larger : smaller;
+    return function (t, tf, h) {
+      var next = add(t, h);
+      return outOfBounds(next, tf) ? subtract(tf, t) : h;
+    };
+  }
+  function isNumOrBig(x) {
+    // checks if it's a number or bignumber
+    return isBigNumber(x) || isNumber(x);
+  }
+  function _matrixSolveODE(f, T, y0, options) {
+    // receives matrices and returns matrices
+    var sol = _solveODE(f, T.toArray(), y0.toArray(), options);
+    return {
+      t: matrix(sol.t),
+      y: matrix(sol.y)
+    };
+  }
+  return typed('solveODE', {
+    'function, Array, Array, Object': _solveODE,
+    'function, Matrix, Matrix, Object': _matrixSolveODE,
+    'function, Array, Array': (f, T, y0) => _solveODE(f, T, y0, {}),
+    'function, Matrix, Matrix': (f, T, y0) => _matrixSolveODE(f, T, y0, {}),
+    'function, Array, number | BigNumber | Unit': (f, T, y0) => {
+      var sol = _solveODE(f, T, [y0], {});
+      return {
+        t: sol.t,
+        y: sol.y.map(Y => Y[0])
+      };
+    },
+    'function, Matrix, number | BigNumber | Unit': (f, T, y0) => {
+      var sol = _solveODE(f, T.toArray(), [y0], {});
+      return {
+        t: matrix(sol.t),
+        y: matrix(sol.y.map(Y => Y[0]))
+      };
+    },
+    'function, Array, number | BigNumber | Unit, Object': (f, T, y0, options) => {
+      var sol = _solveODE(f, T, [y0], options);
+      return {
+        t: sol.t,
+        y: sol.y.map(Y => Y[0])
+      };
+    },
+    'function, Matrix, number | BigNumber | Unit, Object': (f, T, y0, options) => {
+      var sol = _solveODE(f, T.toArray(), [y0], options);
+      return {
+        t: matrix(sol.t),
+        y: matrix(sol.y.map(Y => Y[0]))
+      };
+    }
+  });
+});

package/lib/esm/function/signal/freqz.js

@@ -0,0 +1,115 @@
+import { factory } from '../../utils/factory.js';
+var name = 'freqz';
+var dependencies = ['typed', 'add', 'multiply', 'Complex', 'divide', 'matrix'];
+export var createFreqz = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    add,
+    multiply,
+    Complex,
+    divide,
+    matrix
+  } = _ref;
+  /**
+     * Calculates the frequency response of a filter given its numerator and denominator coefficients.
+     *
+     * Syntax:
+     *    math.freqz(b, a)
+     *    math.freqz(b, a, w)
+     *
+     * Examples:
+     *   math.freqz([1, 2], [1, 2, 3], 4) // returns { h: [0.5 + 0i, 0.4768589245763655 + 0.2861153547458193i, 0.25000000000000006 + 0.75i, -0.770976571635189 + 0.4625859429811135i], w: [0, 0.7853981633974483, 1.5707963267948966, 2.356194490192345 ] }
+     *   math.freqz([1, 2], [1, 2, 3], [0, 1]) // returns { h: [0.5 + 0i, 0.45436781 + 0.38598051i], w: [0, 1] }
+     *
+     * See also:
+     *  zpk2tf
+     *
+     * @param {Array.<number>} b The numerator coefficients of the filter.
+     * @param {Array.<number>} a The denominator coefficients of the filter.
+     * @param {Array.<number>} [w] A vector of frequencies (in radians/sample) at which the frequency response is to be computed or the number of points to compute (if a number is not provided, the default is 512 points)
+     * @returns {Object} An object with two properties: h, a vector containing the complex frequency response, and w, a vector containing the normalized frequencies (in radians/sample) at which the response was computed.
+     *
+     *
+     */
+  return typed(name, {
+    'Array, Array': function ArrayArray(b, a) {
+      var w = createBins(512);
+      return _freqz(b, a, w);
+    },
+    'Array, Array, Array': function ArrayArrayArray(b, a, w) {
+      return _freqz(b, a, w);
+    },
+    'Array, Array, number': function ArrayArrayNumber(b, a, w) {
+      if (w < 0) {
+        throw new Error('w must be a positive number');
+      }
+      var w2 = createBins(w);
+      return _freqz(b, a, w2);
+    },
+    'Matrix, Matrix': function MatrixMatrix(b, a) {
+      // console.log('here')
+      var _w = createBins(512);
+      var {
+        w,
+        h
+      } = _freqz(b.valueOf(), a.valueOf(), _w);
+      return {
+        w: matrix(w),
+        h: matrix(h)
+      };
+    },
+    'Matrix, Matrix, Matrix': function MatrixMatrixMatrix(b, a, w) {
+      var {
+        h
+      } = _freqz(b.valueOf(), a.valueOf(), w.valueOf());
+      return {
+        h: matrix(h),
+        w: matrix(w)
+      };
+    },
+    'Matrix, Matrix, number': function MatrixMatrixNumber(b, a, w) {
+      if (w < 0) {
+        throw new Error('w must be a positive number');
+      }
+      var _w = createBins(w);
+      var {
+        h
+      } = _freqz(b.valueOf(), a.valueOf(), _w);
+      return {
+        h: matrix(h),
+        w: matrix(_w)
+      };
+    }
+  });
+  function _freqz(b, a, w) {
+    var num = [];
+    var den = [];
+    for (var i = 0; i < w.length; i++) {
+      var sumNum = Complex(0, 0);
+      var sumDen = Complex(0, 0);
+      for (var j = 0; j < b.length; j++) {
+        sumNum = add(sumNum, multiply(b[j], Complex(Math.cos(-j * w[i]), Math.sin(-j * w[i]))));
+      }
+      for (var _j = 0; _j < a.length; _j++) {
+        sumDen = add(sumDen, multiply(a[_j], Complex(Math.cos(-_j * w[i]), Math.sin(-_j * w[i]))));
+      }
+      num.push(sumNum);
+      den.push(sumDen);
+    }
+    var h = [];
+    for (var _i = 0; _i < num.length; _i++) {
+      h.push(divide(num[_i], den[_i]));
+    }
+    return {
+      h,
+      w
+    };
+  }
+  function createBins(n) {
+    var bins = [];
+    for (var i = 0; i < n; i++) {
+      bins.push(i / n * Math.PI);
+    }
+    return bins;
+  }
+});

package/lib/esm/function/signal/zpk2tf.js

@@ -0,0 +1,82 @@
+import { factory } from '../../utils/factory.js';
+var name = 'zpk2tf';
+var dependencies = ['typed', 'add', 'multiply', 'Complex', 'number'];
+export var createZpk2tf = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    add,
+    multiply,
+    Complex,
+    number
+  } = _ref;
+  /**
+     * Compute the transfer function of a zero-pole-gain model.
+     *
+     * Syntax:
+     *      math.zpk2tf(z, p, k)
+     *
+     * Examples:
+     *    math.zpk2tf([1, 2], [-1, -2], 1)    // returns [[1, -3, 2], [1, 3, 2]]
+     *
+     * See also:
+     *   freqz
+     *
+     * @param {Array} z Array of zeros values
+     * @param {Array} p Array of poles values
+     * @param {number} k Gain value
+     * @return {Array} Two dimensional array containing the numerator (first row) and denominator (second row) polynomials
+     *
+     */
+  return typed(name, {
+    'Array,Array,number': function ArrayArrayNumber(z, p, k) {
+      return _zpk2tf(z, p, k);
+    },
+    'Array,Array': function ArrayArray(z, p) {
+      return _zpk2tf(z, p, 1);
+    },
+    'Matrix,Matrix,number': function MatrixMatrixNumber(z, p, k) {
+      return _zpk2tf(z.valueOf(), p.valueOf(), k);
+    },
+    'Matrix,Matrix': function MatrixMatrix(z, p) {
+      return _zpk2tf(z.valueOf(), p.valueOf(), 1);
+    }
+  });
+  function _zpk2tf(z, p, k) {
+    // if z is bignumber, convert it to number
+    if (z.some(el => el.type === 'BigNumber')) {
+      z = z.map(el => number(el));
+    }
+    // if p is bignumber, convert it to number
+    if (p.some(el => el.type === 'BigNumber')) {
+      p = p.map(el => number(el));
+    }
+    var num = [Complex(1, 0)];
+    var den = [Complex(1, 0)];
+    for (var i = 0; i < z.length; i++) {
+      var zero = z[i];
+      if (typeof zero === 'number') zero = Complex(zero, 0);
+      num = _multiply(num, [Complex(1, 0), Complex(-zero.re, -zero.im)]);
+    }
+    for (var _i = 0; _i < p.length; _i++) {
+      var pole = p[_i];
+      if (typeof pole === 'number') pole = Complex(pole, 0);
+      den = _multiply(den, [Complex(1, 0), Complex(-pole.re, -pole.im)]);
+    }
+    for (var _i2 = 0; _i2 < num.length; _i2++) {
+      num[_i2] = multiply(num[_i2], k);
+    }
+    return [num, den];
+  }
+  function _multiply(a, b) {
+    var c = [];
+    for (var i = 0; i < a.length + b.length - 1; i++) {
+      c[i] = Complex(0, 0);
+      for (var j = 0; j < a.length; j++) {
+        if (i - j >= 0 && i - j < b.length) {
+          c[i] = add(c[i], multiply(a[j], b[i - j]));
+        }
+      }
+    }
+    return c;
+  }
+});

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

@@ -25,12 +25,12 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref =>
     equal,
     isNumeric,
     format,
-    number,
+    number: _number,
     Complex,
     BigNumber: _BigNumber,
     Fraction: _Fraction
   } = _ref;
-  var toNumber = number;
+  var toNumber = _number;
   /**
    * A unit can be constructed in the following ways:
    *
@@ -780,13 +780,13 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref =>
       /* Need to adjust value by difference in offset to convert */
       var convert = Unit._getNumberConverter(typeOf(value)); // convert to Fraction or BigNumber if needed
 
-      var thisUnitValue = convert(this.units[0].unit.value);
-      var thisNominalOffset = convert(this.units[0].unit.offset);
+      var thisUnitValue = this.units[0].unit.value;
+      var thisNominalOffset = this.units[0].unit.offset;
       var thisUnitOffset = multiplyScalar(thisUnitValue, thisNominalOffset);
-      var otherUnitValue = convert(other.units[0].unit.value);
-      var otherNominalOffset = convert(other.units[0].unit.offset);
+      var otherUnitValue = other.units[0].unit.value;
+      var otherNominalOffset = other.units[0].unit.offset;
       var otherUnitOffset = multiplyScalar(otherUnitValue, otherNominalOffset);
-      other.value = subtract(addScalar(value, thisUnitOffset), otherUnitOffset);
+      other.value = addScalar(value, convert(subtract(thisUnitOffset, otherUnitOffset)));
     }
     other.fixPrefix = true;
     other.skipAutomaticSimplification = true;
@@ -2734,8 +2734,8 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref =>
     },
     // Temperature
     // K(C) = °C + 273.15
-    // K(F) = (°F + 459.67) / 1.8
-    // K(R) = °R / 1.8
+    // K(F) = (°F + 459.67) * (5 / 9)
+    // K(R) = °R * (5 / 9)
     K: {
       name: 'K',
       base: BASE_UNITS.TEMPERATURE,
@@ -2754,14 +2754,14 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref =>
       name: 'degF',
       base: BASE_UNITS.TEMPERATURE,
       prefixes: PREFIXES.SHORT,
-      value: 1 / 1.8,
+      value: new _Fraction(5, 9),
       offset: 459.67
     },
     degR: {
       name: 'degR',
       base: BASE_UNITS.TEMPERATURE,
       prefixes: PREFIXES.SHORT,
-      value: 1 / 1.8,
+      value: new _Fraction(5, 9),
       offset: 0
     },
     kelvin: {
@@ -2782,14 +2782,14 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref =>
       name: 'fahrenheit',
       base: BASE_UNITS.TEMPERATURE,
       prefixes: PREFIXES.LONG,
-      value: 1 / 1.8,
+      value: new _Fraction(5, 9),
       offset: 459.67
     },
     rankine: {
       name: 'rankine',
       base: BASE_UNITS.TEMPERATURE,
       prefixes: PREFIXES.LONG,
-      value: 1 / 1.8,
+      value: new _Fraction(5, 9),
       offset: 0
     },
     // amount of substance
@@ -3510,6 +3510,7 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref =>
    */
   Unit.typeConverters = {
     BigNumber: function BigNumber(x) {
+      if (x !== null && x !== void 0 && x.isFraction) return new _BigNumber(x.n).div(x.d).times(x.s);
       return new _BigNumber(x + ''); // stringify to prevent constructor error
     },
 
@@ -3520,6 +3521,7 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref =>
       return x;
     },
     number: function number(x) {
+      if (x !== null && x !== void 0 && x.isFraction) return _number(x);
       return x;
     }
   };

package/lib/esm/utils/customs.js

@@ -83,12 +83,13 @@ function isSafeProperty(object, prop) {
  * Throws an error when that's not the case.
  * @param {Object} object
  * @param {string} method
+ * @return {function} Returns the method when valid
  */
-// TODO: merge this function into assign.js?
-function validateSafeMethod(object, method) {
+function getSafeMethod(object, method) {
   if (!isSafeMethod(object, method)) {
     throw new Error('No access to method "' + method + '"');
   }
+  return object[method];
 }
 
 /**
@@ -148,6 +149,6 @@ export { setSafeProperty };
 export { isSafeProperty };
 export { hasSafeProperty };
 export { getSafeProperties };
-export { validateSafeMethod };
+export { getSafeMethod };
 export { isSafeMethod };
 export { isPlainObject };

package/lib/esm/version.js

@@ -1,3 +1,3 @@
-export var version = '11.8.2';
+export var version = '11.9.1';
 // 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": "11.8.2",
+  "version": "11.9.1",
   "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,7 +25,7 @@
     "unit"
   ],
   "dependencies": {
-    "@babel/runtime": "^7.22.5",
+    "@babel/runtime": "^7.22.6",
     "complex.js": "^2.1.1",
     "decimal.js": "^10.4.3",
     "escape-latex": "^1.2.0",
@@ -36,29 +36,29 @@
     "typed-function": "^4.1.0"
   },
   "devDependencies": {
-    "@babel/core": "7.22.5",
+    "@babel/core": "7.22.9",
     "@babel/plugin-transform-object-assign": "7.22.5",
-    "@babel/plugin-transform-runtime": "7.22.5",
-    "@babel/preset-env": "7.22.5",
+    "@babel/plugin-transform-runtime": "7.22.9",
+    "@babel/preset-env": "7.22.9",
     "@babel/register": "7.22.5",
     "@types/assert": "1.5.6",
     "@types/mocha": "10.0.1",
-    "@typescript-eslint/eslint-plugin": "5.60.0",
-    "@typescript-eslint/parser": "5.60.0",
+    "@typescript-eslint/eslint-plugin": "6.1.0",
+    "@typescript-eslint/parser": "6.1.0",
     "assert": "2.0.0",
-    "babel-loader": "9.1.2",
+    "babel-loader": "9.1.3",
     "benchmark": "2.1.4",
     "c8": "8.0.0",
     "codecov": "3.8.3",
-    "core-js": "3.31.0",
+    "core-js": "3.31.1",
     "del": "6.1.1",
     "dtslint": "4.2.1",
-    "eslint": "8.43.0",
+    "eslint": "8.45.0",
     "eslint-config-prettier": "8.8.0",
     "eslint-config-standard": "17.1.0",
     "eslint-plugin-import": "2.27.5",
     "eslint-plugin-mocha": "10.1.0",
-    "eslint-plugin-n": "16.0.0",
+    "eslint-plugin-n": "16.0.1",
     "eslint-plugin-prettier": "4.2.1",
     "eslint-plugin-promise": "6.1.1",
     "expect-type": "0.16.0",
@@ -75,9 +75,9 @@
     "karma-mocha": "2.0.1",
     "karma-mocha-reporter": "2.2.5",
     "karma-webpack": "5.0.0",
-    "mkdirp": "2.1.6",
+    "mkdirp": "3.0.1",
     "mocha": "10.2.0",
-    "mocha-junit-reporter": "2.2.0",
+    "mocha-junit-reporter": "2.2.1",
     "ndarray": "1.0.19",
     "ndarray-determinant": "1.0.0",
     "ndarray-gemm": "1.0.0",
@@ -89,8 +89,8 @@
     "process": "0.11.10",
     "sylvester": "0.0.21",
     "ts-node": "10.9.1",
-    "typescript": "5.1.3",
-    "webpack": "5.87.0",
+    "typescript": "5.1.6",
+    "webpack": "5.88.2",
     "zeros": "1.0.0"
   },
   "type": "module",