mathjs 11.8.1 → 11.9.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/version.js

@@ -1,3 +1,3 @@
-export var version = '11.8.1';
+export var version = '11.9.0';
 // 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.1",
+  "version": "11.9.0",
   "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",
@@ -43,17 +43,17 @@
     "@babel/register": "7.22.5",
     "@types/assert": "1.5.6",
     "@types/mocha": "10.0.1",
-    "@typescript-eslint/eslint-plugin": "5.59.11",
-    "@typescript-eslint/parser": "5.59.11",
+    "@typescript-eslint/eslint-plugin": "5.60.0",
+    "@typescript-eslint/parser": "5.60.0",
     "assert": "2.0.0",
     "babel-loader": "9.1.2",
     "benchmark": "2.1.4",
-    "c8": "7.14.0",
+    "c8": "8.0.0",
     "codecov": "3.8.3",
     "core-js": "3.31.0",
     "del": "6.1.1",
     "dtslint": "4.2.1",
-    "eslint": "8.42.0",
+    "eslint": "8.43.0",
     "eslint-config-prettier": "8.8.0",
     "eslint-config-standard": "17.1.0",
     "eslint-plugin-import": "2.27.5",
@@ -90,7 +90,7 @@
     "sylvester": "0.0.21",
     "ts-node": "10.9.1",
     "typescript": "5.1.3",
-    "webpack": "5.86.0",
+    "webpack": "5.87.0",
     "zeros": "1.0.0"
   },
   "type": "module",