mathjs 11.8.2 → 11.9.0

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

@@ -0,0 +1,315 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSolveODE = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _is = require("../../utils/is.js");
+var _factory = require("../../utils/factory.js");
+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) { (0, _defineProperty2["default"])(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; }
+var name = 'solveODE';
+var dependencies = ['typed', 'add', 'subtract', 'multiply', 'divide', 'max', 'map', 'abs', 'isPositive', 'isNegative', 'larger', 'smaller', 'matrix', 'bignumber', 'unaryMinus'];
+var createSolveODE = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    add = _ref.add,
+    subtract = _ref.subtract,
+    multiply = _ref.multiply,
+    divide = _ref.divide,
+    max = _ref.max,
+    map = _ref.map,
+    abs = _ref.abs,
+    isPositive = _ref.isPositive,
+    isNegative = _ref.isNegative,
+    larger = _ref.larger,
+    smaller = _ref.smaller,
+    matrix = _ref.matrix,
+    bignumber = _ref.bignumber,
+    unaryMinus = _ref.unaryMinus;
+  /**
+     * 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(_is.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(function (x) {
+        return x !== undefined;
+      });
+      if (!(timeVars.every(isNumOrBig) || timeVars.every(_is.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].concat((0, _toConsumableArray2["default"])(y0), [maxStep, minStep]).some(_is.isBigNumber);
+      var _ref2 = hasBigNumbers ? [bignumber(butcherTableau.a), bignumber(butcherTableau.c), bignumber(butcherTableau.b), bignumber(butcherTableau.bp)] : [butcherTableau.a, butcherTableau.c, butcherTableau.b, butcherTableau.bp],
+        _ref3 = (0, _slicedToArray2["default"])(_ref2, 4),
+        a = _ref3[0],
+        c = _ref3[1],
+        b = _ref3[2],
+        bp = _ref3[3];
+      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), function (X) {
+          return (0, _is.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 * Math.pow(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: t,
+        y: 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: a,
+      c: c,
+      b: b,
+      bp: 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: a,
+      c: c,
+      b: b,
+      bp: 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(function (x) {
+        return "\"".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 (0, _is.isBigNumber)(x) || (0, _is.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': function functionArrayArray(f, T, y0) {
+      return _solveODE(f, T, y0, {});
+    },
+    'function, Matrix, Matrix': function functionMatrixMatrix(f, T, y0) {
+      return _matrixSolveODE(f, T, y0, {});
+    },
+    'function, Array, number | BigNumber | Unit': function functionArrayNumberBigNumberUnit(f, T, y0) {
+      var sol = _solveODE(f, T, [y0], {});
+      return {
+        t: sol.t,
+        y: sol.y.map(function (Y) {
+          return Y[0];
+        })
+      };
+    },
+    'function, Matrix, number | BigNumber | Unit': function functionMatrixNumberBigNumberUnit(f, T, y0) {
+      var sol = _solveODE(f, T.toArray(), [y0], {});
+      return {
+        t: matrix(sol.t),
+        y: matrix(sol.y.map(function (Y) {
+          return Y[0];
+        }))
+      };
+    },
+    'function, Array, number | BigNumber | Unit, Object': function functionArrayNumberBigNumberUnitObject(f, T, y0, options) {
+      var sol = _solveODE(f, T, [y0], options);
+      return {
+        t: sol.t,
+        y: sol.y.map(function (Y) {
+          return Y[0];
+        })
+      };
+    },
+    'function, Matrix, number | BigNumber | Unit, Object': function functionMatrixNumberBigNumberUnitObject(f, T, y0, options) {
+      var sol = _solveODE(f, T.toArray(), [y0], options);
+      return {
+        t: matrix(sol.t),
+        y: matrix(sol.y.map(function (Y) {
+          return Y[0];
+        }))
+      };
+    }
+  });
+});
+exports.createSolveODE = createSolveODE;

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

@@ -0,0 +1,117 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createFreqz = void 0;
+var _factory = require("../../utils/factory.js");
+var name = 'freqz';
+var dependencies = ['typed', 'add', 'multiply', 'Complex', 'divide', 'matrix'];
+var createFreqz = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    add = _ref.add,
+    multiply = _ref.multiply,
+    Complex = _ref.Complex,
+    divide = _ref.divide,
+    matrix = _ref.matrix;
+  /**
+     * 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 _freqz2 = _freqz(b.valueOf(), a.valueOf(), _w),
+        w = _freqz2.w,
+        h = _freqz2.h;
+      return {
+        w: matrix(w),
+        h: matrix(h)
+      };
+    },
+    'Matrix, Matrix, Matrix': function MatrixMatrixMatrix(b, a, w) {
+      var _freqz3 = _freqz(b.valueOf(), a.valueOf(), w.valueOf()),
+        h = _freqz3.h;
+      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 _freqz4 = _freqz(b.valueOf(), a.valueOf(), _w),
+        h = _freqz4.h;
+      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: h,
+      w: w
+    };
+  }
+  function createBins(n) {
+    var bins = [];
+    for (var i = 0; i < n; i++) {
+      bins.push(i / n * Math.PI);
+    }
+    return bins;
+  }
+});
+exports.createFreqz = createFreqz;

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

@@ -0,0 +1,95 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createZpk2tf = void 0;
+var _factory = require("../../utils/factory.js");
+var name = 'zpk2tf';
+var dependencies = ['typed', 'add', 'multiply', 'Complex', 'number'];
+var createZpk2tf = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    add = _ref.add,
+    multiply = _ref.multiply,
+    Complex = _ref.Complex,
+    number = _ref.number;
+  /**
+     * 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(function (el) {
+      return el.type === 'BigNumber';
+    })) {
+      z = z.map(function (el) {
+        return number(el);
+      });
+    }
+    // if p is bignumber, convert it to number
+    if (p.some(function (el) {
+      return el.type === 'BigNumber';
+    })) {
+      p = p.map(function (el) {
+        return 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;
+  }
+});
+exports.createZpk2tf = createZpk2tf;

package/lib/cjs/header.js

@@ -6,8 +6,8 @@
  * It features real and complex numbers, units, matrices, a large set of
  * mathematical functions, and a flexible expression parser.
  *
- * @version 11.8.2
- * @date    2023-06-20
+ * @version 11.9.0
+ * @date    2023-07-19
  *
  * @license
  * Copyright (C) 2013-2023 Jos de Jong <wjosdejong@gmail.com>

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

@@ -32,11 +32,11 @@ var createUnitClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
     equal = _ref.equal,
     isNumeric = _ref.isNumeric,
     format = _ref.format,
-    number = _ref.number,
+    _number = _ref.number,
     Complex = _ref.Complex,
     _BigNumber = _ref.BigNumber,
     _Fraction = _ref.Fraction;
-  var toNumber = number;
+  var toNumber = _number;
   /**
    * A unit can be constructed in the following ways:
    *
@@ -792,13 +792,13 @@ var createUnitClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
       /* Need to adjust value by difference in offset to convert */
       var convert = Unit._getNumberConverter((0, _is.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;
@@ -2748,8 +2748,8 @@ var createUnitClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
     },
     // 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,
@@ -2768,14 +2768,14 @@ var createUnitClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
       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: {
@@ -2796,14 +2796,14 @@ var createUnitClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
       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
@@ -3524,6 +3524,7 @@ var createUnitClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
    */
   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
     },
 
@@ -3534,6 +3535,7 @@ var createUnitClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
       return x;
     },
     number: function number(x) {
+      if (x !== null && x !== void 0 && x.isFraction) return _number(x);
       return x;
     }
   };

package/lib/cjs/version.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.version = void 0;
-var version = '11.8.2';
+var version = '11.9.0';
 // Note: This file is automatically generated when building math.js.
 // Changes made in this file will be overwritten.
 exports.version = version;

package/lib/esm/entry/dependenciesAny/dependenciesFreqz.generated.js

@@ -0,0 +1,20 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { ComplexDependencies } from './dependenciesComplexClass.generated.js';
+import { addDependencies } from './dependenciesAdd.generated.js';
+import { divideDependencies } from './dependenciesDivide.generated.js';
+import { matrixDependencies } from './dependenciesMatrix.generated.js';
+import { multiplyDependencies } from './dependenciesMultiply.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createFreqz } from '../../factoriesAny.js';
+export var freqzDependencies = {
+  ComplexDependencies,
+  addDependencies,
+  divideDependencies,
+  matrixDependencies,
+  multiplyDependencies,
+  typedDependencies,
+  createFreqz
+};

package/lib/esm/entry/dependenciesAny/dependenciesRange.generated.js

@@ -4,6 +4,8 @@
  */
 import { bignumberDependencies } from './dependenciesBignumber.generated.js';
 import { matrixDependencies } from './dependenciesMatrix.generated.js';
+import { addDependencies } from './dependenciesAdd.generated.js';
+import { isPositiveDependencies } from './dependenciesIsPositive.generated.js';
 import { largerDependencies } from './dependenciesLarger.generated.js';
 import { largerEqDependencies } from './dependenciesLargerEq.generated.js';
 import { smallerDependencies } from './dependenciesSmaller.generated.js';
@@ -13,6 +15,8 @@ import { createRange } from '../../factoriesAny.js';
 export var rangeDependencies = {
   bignumberDependencies,
   matrixDependencies,
+  addDependencies,
+  isPositiveDependencies,
   largerDependencies,
   largerEqDependencies,
   smallerDependencies,