mathjs 11.11.0 → 11.11.1

package/lib/esm/entry/pureFunctionsNumber.generated.js

@@ -5,7 +5,7 @@
 import { config } from './configReadonly.js';
 import { createE, createFalse, createIndex, createInfinity, createLN10, createLOG10E, createMatrix, createNaN, createNull, createPhi, createRangeClass, createReplacer, createResultSet, createSQRT1_2,
 // eslint-disable-line camelcase
-createSubset, createTau, createTyped, createUnaryPlus, createVersion, createXor, createAbs, createAcos, createAcot, createAcsc, createAdd, createAnd, createAsec, createAsin, createAtan, createAtanh, createBitAnd, createBitOr, createBoolean, createCbrt, createCombinations, createCompare, createCompareText, createCos, createCot, createCsc, createCube, createDivide, createEqualScalar, createErf, createExp, createFilter, createForEach, createFormat, createGamma, createIsInteger, createIsNegative, createIsPositive, createIsZero, createLOG2E, createLargerEq, createLeftShift, createLog, createLog1p, createMap, createMean, createMod, createMultiply, createNot, createNumber, createOr, createPi, createPow, createRandom, createRightLogShift, createSQRT2, createSech, createSin, createSize, createSmallerEq, createSquare, createString, createSubtract, createTanh, createTypeOf, createUnequal, createXgcd, createAcoth, createAddScalar, createAsech, createBitNot, createCombinationsWithRep, createCosh, createCsch, createDivideScalar, createEqualText, createExpm1, createIsNumeric, createLN2, createLcm, createLog10, createMultiplyScalar, createNthRoot, createPickRandom, createRandomInt, createRightArithShift, createSec, createSinh, createSqrt, createTan, createUnaryMinus, createAcosh, createApply, createAsinh, createBitXor, createClone, createCoth, createEqual, createFactorial, createHasNumericValue, createIsNaN, createLarger, createLog2, createMode, createNorm, createPartitionSelect, createPrint, createQuantileSeq, createRound, createSmaller, createStirlingS2, createTrue, createVariance, createZeta, createAcsch, createAtan2, createCatalan, createCompareNatural, createComposition, createCumSum, createFloor, createHypot, createLgamma, createMedian, createMultinomial, createPermutations, createRange, createSign, createStd, createCeil, createDeepEqual, createFix, createIsPrime, createNumeric, createProd, createBellNumbers, createGcd, createMad, createSum, createCorr, createMax, createMin } from '../factoriesNumber.js';
+createSubset, createTau, createTyped, createUnaryPlus, createVersion, createXor, createAbs, createAcos, createAcot, createAcsc, createAdd, createAnd, createAsec, createAsin, createAtan, createAtanh, createBitAnd, createBitOr, createBoolean, createCbrt, createCombinations, createCompare, createCompareText, createCos, createCot, createCsc, createCube, createDivide, createEqualScalar, createErf, createExp, createFilter, createForEach, createFormat, createGamma, createIsInteger, createIsNegative, createIsPositive, createIsZero, createLOG2E, createLargerEq, createLeftShift, createLog, createLog1p, createMap, createMean, createMod, createMultiply, createNot, createNumber, createOr, createPi, createPow, createRandom, createRightLogShift, createSQRT2, createSech, createSin, createSize, createSmallerEq, createSquare, createString, createSubtract, createTanh, createTypeOf, createUnequal, createXgcd, createAcoth, createAddScalar, createAsech, createBitNot, createCombinationsWithRep, createCosh, createCsch, createDivideScalar, createEqualText, createExpm1, createIsNumeric, createLN2, createLcm, createLog10, createMultiplyScalar, createNthRoot, createPickRandom, createRandomInt, createRightArithShift, createSec, createSinh, createSqrt, createTan, createUnaryMinus, createAcosh, createApply, createAsinh, createBitXor, createClone, createCoth, createEqual, createFactorial, createHasNumericValue, createIsNaN, createLarger, createLog2, createMode, createNorm, createPartitionSelect, createPrint, createRound, createSmaller, createStirlingS2, createTrue, createVariance, createZeta, createAcsch, createAtan2, createCatalan, createCompareNatural, createComposition, createCumSum, createFloor, createHypot, createLgamma, createMedian, createMultinomial, createPermutations, createQuantileSeq, createSign, createStd, createCeil, createDeepEqual, createFix, createIsPrime, createNumeric, createProd, createBellNumbers, createGcd, createMad, createRange, createSum, createCorr, createMax, createMin } from '../factoriesNumber.js';
 export var e = /* #__PURE__ */createE({
   config
 });
@@ -373,14 +373,6 @@ export var partitionSelect = /* #__PURE__ */createPartitionSelect({
 export var print = /* #__PURE__ */createPrint({
   typed
 });
-export var quantileSeq = /* #__PURE__ */createQuantileSeq({
-  add,
-  compare,
-  isInteger,
-  multiply,
-  partitionSelect,
-  typed
-});
 export var round = /* #__PURE__ */createRound({
   typed
 });
@@ -499,15 +491,17 @@ export var permutations = /* #__PURE__ */createPermutations({
   factorial,
   typed
 });
-export var range = /* #__PURE__ */createRange({
-  matrix,
+export var quantileSeq = /* #__PURE__ */createQuantileSeq({
   add,
-  config,
-  isPositive,
+  compare,
+  divide,
+  isInteger,
   larger,
-  largerEq,
+  multiply,
+  partitionSelect,
   smaller,
   smallerEq,
+  subtract,
   typed
 });
 export var sign = /* #__PURE__ */createSign({
@@ -562,6 +556,17 @@ export var mad = /* #__PURE__ */createMad({
   subtract,
   typed
 });
+export var range = /* #__PURE__ */createRange({
+  matrix,
+  add,
+  config,
+  isPositive,
+  larger,
+  largerEq,
+  smaller,
+  smallerEq,
+  typed
+});
 export var sum = /* #__PURE__ */createSum({
   add,
   config,

package/lib/esm/expression/embeddedDocs/function/utils/print.js

@@ -3,6 +3,6 @@ export var printDocs = {
   category: 'Utils',
   syntax: ['print(template, values)', 'print(template, values, precision)'],
   description: 'Interpolate values into a string template.',
-  examples: ['print("Lucy is $age years old", {age: 5})', 'print("The value of pi is $pi", {pi: pi}, 3)', 'print("Hello, $user.name!", {user: {name: "John"}})', 'print("Values: $0, $1, $2", [6, 9, 4])'],
+  examples: ['print("Lucy is $age years old", {age: 5})', 'print("The value of pi is $pi", {pi: pi}, 3)', 'print("Hello, $user.name!", {user: {name: "John"}})', 'print("Values: $1, $2, $3", [6, 9, 4])'],
   seealso: ['format']
 };

package/lib/esm/expression/node/FunctionNode.js

@@ -9,6 +9,7 @@ import { defaultTemplate, latexFunctions } from '../../utils/latex.js';
 var name = 'FunctionNode';
 var dependencies = ['math', 'Node', 'SymbolNode'];
 export var createFunctionNode = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var _class;
   var {
     math,
     Node,
@@ -455,12 +456,13 @@ export var createFunctionNode = /* #__PURE__ */factory(name, dependencies, _ref
       return this.type + ':' + this.name;
     }
   }
+  _class = FunctionNode;
   _defineProperty(FunctionNode, "name", name);
   _defineProperty(FunctionNode, "onUndefinedFunction", function (name) {
     throw new Error('Undefined function ' + name);
   });
   _defineProperty(FunctionNode, "fromJSON", function (json) {
-    return new FunctionNode(json.fn, json.args);
+    return new _class(json.fn, json.args);
   });
   return FunctionNode;
 }, {

package/lib/esm/expression/transform/print.transform.js

@@ -0,0 +1,42 @@
+import { createPrint } from '../../function/string/print.js';
+import { factory } from '../../utils/factory.js';
+import { printTemplate } from '../../utils/print.js';
+var name = 'print';
+var dependencies = ['typed', 'matrix', 'zeros', 'add'];
+export var createPrintTransform = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    matrix,
+    zeros,
+    add
+  } = _ref;
+  var print = createPrint({
+    typed,
+    matrix,
+    zeros,
+    add
+  });
+  return typed(name, {
+    'string, Object | Array': function stringObjectArray(template, values) {
+      return print(_convertTemplateToZeroBasedIndex(template), values);
+    },
+    'string, Object | Array, number | Object': function stringObjectArrayNumberObject(template, values, options) {
+      return print(_convertTemplateToZeroBasedIndex(template), values, options);
+    }
+  });
+  function _convertTemplateToZeroBasedIndex(template) {
+    return template.replace(printTemplate, x => {
+      var parts = x.slice(1).split('.');
+      var result = parts.map(function (part) {
+        if (!isNaN(part) && part.length > 0) {
+          return parseInt(part) - 1;
+        } else {
+          return part;
+        }
+      });
+      return '$' + result.join('.');
+    });
+  }
+}, {
+  isTransformFunction: true
+});

package/lib/esm/expression/transform/quantileSeq.transform.js

@@ -2,7 +2,7 @@ import { factory } from '../../utils/factory.js';
 import { createQuantileSeq } from '../../function/statistics/quantileSeq.js';
 import { lastDimToZeroBase } from './utils/lastDimToZeroBase.js';
 var name = 'quantileSeq';
-var dependencies = ['typed', 'add', 'multiply', 'partitionSelect', 'compare', 'isInteger'];
+var dependencies = ['typed', 'bignumber', 'add', 'subtract', 'divide', 'multiply', 'partitionSelect', 'compare', 'isInteger', 'smaller', 'smallerEq', 'larger'];
 
 /**
  * Attach a transform function to math.quantileSeq
@@ -14,23 +14,41 @@ var dependencies = ['typed', 'add', 'multiply', 'partitionSelect', 'compare', 'i
 export var createQuantileSeqTransform = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
+    bignumber,
     add,
+    subtract,
+    divide,
     multiply,
     partitionSelect,
     compare,
-    isInteger
+    isInteger,
+    smaller,
+    smallerEq,
+    larger
   } = _ref;
   var quantileSeq = createQuantileSeq({
     typed,
+    bignumber,
     add,
+    subtract,
+    divide,
     multiply,
     partitionSelect,
     compare,
-    isInteger
+    isInteger,
+    smaller,
+    smallerEq,
+    larger
   });
   return typed('quantileSeq', {
-    'Array|Matrix, number|BigNumber|Array, number': (arr, prob, dim) => quantileSeq(arr, prob, dimToZeroBase(dim)),
-    'Array|Matrix, number|BigNumber|Array, boolean, number': (arr, prob, sorted, dim) => quantileSeq(arr, prob, sorted, dimToZeroBase(dim))
+    'Array | Matrix, number | BigNumber': quantileSeq,
+    'Array | Matrix, number | BigNumber, number': (arr, prob, dim) => quantileSeq(arr, prob, dimToZeroBase(dim)),
+    'Array | Matrix, number | BigNumber, boolean': quantileSeq,
+    'Array | Matrix, number | BigNumber, boolean, number': (arr, prob, sorted, dim) => quantileSeq(arr, prob, sorted, dimToZeroBase(dim)),
+    'Array | Matrix, Array | Matrix': quantileSeq,
+    'Array | Matrix, Array | Matrix, number': (data, prob, dim) => quantileSeq(data, prob, dimToZeroBase(dim)),
+    'Array | Matrix, Array | Matrix, boolean': quantileSeq,
+    'Array | Matrix, Array | Matrix, boolean, number': (data, prob, sorted, dim) => quantileSeq(data, prob, sorted, dimToZeroBase(dim))
   });
   function dimToZeroBase(dim) {
     // TODO: find a better way, maybe lastDimToZeroBase could apply to more cases.

package/lib/esm/factoriesAny.js

@@ -287,4 +287,5 @@ export { createStdTransform } from './expression/transform/std.transform.js';
 export { createSumTransform } from './expression/transform/sum.transform.js';
 export { createQuantileSeqTransform } from './expression/transform/quantileSeq.transform.js';
 export { createCumSumTransform } from './expression/transform/cumsum.transform.js';
-export { createVarianceTransform } from './expression/transform/variance.transform.js';
+export { createVarianceTransform } from './expression/transform/variance.transform.js';
+export { createPrintTransform } from './expression/transform/print.transform.js';

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

@@ -1,6 +1,6 @@
 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; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 import { isFunctionNode, isOperatorNode, isParenthesisNode } from '../../../utils/is.js';
 import { factory } from '../../../utils/factory.js';
 import { hasOwnProperty } from '../../../utils/object.js';

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

@@ -1,12 +1,13 @@
+import { isInteger } from '../../utils/number.js';
 import { factory } from '../../utils/factory.js';
+import { createMod } from './mod.js';
 import { createMatAlgo01xDSid } from '../../type/matrix/utils/matAlgo01xDSid.js';
 import { createMatAlgo04xSidSid } from '../../type/matrix/utils/matAlgo04xSidSid.js';
 import { createMatAlgo10xSids } from '../../type/matrix/utils/matAlgo10xSids.js';
 import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
-import { gcdNumber } from '../../plain/number/index.js';
 import { ArgumentsError } from '../../error/ArgumentsError.js';
 var name = 'gcd';
-var dependencies = ['typed', 'matrix', 'equalScalar', 'BigNumber', 'DenseMatrix', 'concat'];
+var dependencies = ['typed', 'config', 'round', 'matrix', 'equalScalar', 'zeros', 'BigNumber', 'DenseMatrix', 'concat'];
 var gcdTypes = 'number | BigNumber | Fraction | Matrix | Array';
 var gcdManyTypesSignature = "".concat(gcdTypes, ", ").concat(gcdTypes, ", ...").concat(gcdTypes);
 function is1d(array) {
@@ -16,11 +17,24 @@ export var createGcd = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     matrix,
+    config,
+    round,
     equalScalar,
+    zeros,
     BigNumber,
     DenseMatrix,
     concat
   } = _ref;
+  var mod = createMod({
+    typed,
+    config,
+    round,
+    matrix,
+    equalScalar,
+    zeros,
+    DenseMatrix,
+    concat
+  });
   var matAlgo01xDSid = createMatAlgo01xDSid({
     typed
   });
@@ -64,7 +78,7 @@ export var createGcd = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @return {number | BigNumber | Fraction | Array | Matrix}                           The greatest common divisor
    */
   return typed(name, {
-    'number, number': gcdNumber,
+    'number, number': _gcdNumber,
     'BigNumber, BigNumber': _gcdBigNumber,
     'Fraction, Fraction': (x, y) => x.gcd(y)
   }, matrixAlgorithmSuite({
@@ -93,6 +107,28 @@ export var createGcd = /* #__PURE__ */factory(name, dependencies, _ref => {
     })
   });
 
+  /**
+  * Calculate gcd for numbers
+  * @param {number} a
+  * @param {number} b
+  * @returns {number} Returns the greatest common denominator of a and b
+  * @private
+  */
+  function _gcdNumber(a, b) {
+    if (!isInteger(a) || !isInteger(b)) {
+      throw new Error('Parameters in function gcd must be integer numbers');
+    }
+
+    // https://en.wikipedia.org/wiki/Euclidean_algorithm
+    var r;
+    while (b !== 0) {
+      r = mod(a, b);
+      a = b;
+      b = r;
+    }
+    return a < 0 ? -a : a;
+  }
+
   /**
    * Calculate gcd for BigNumbers
    * @param {BigNumber} a
@@ -108,7 +144,7 @@ export var createGcd = /* #__PURE__ */factory(name, dependencies, _ref => {
     // https://en.wikipedia.org/wiki/Euclidean_algorithm
     var zero = new BigNumber(0);
     while (!b.isZero()) {
-      var r = a.mod(b);
+      var r = mod(a, b);
       a = b;
       b = r;
     }

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

@@ -1,21 +1,33 @@
 import { factory } from '../../utils/factory.js';
+import { createFloor } from './floor.js';
 import { createMatAlgo02xDS0 } from '../../type/matrix/utils/matAlgo02xDS0.js';
 import { createMatAlgo03xDSf } from '../../type/matrix/utils/matAlgo03xDSf.js';
 import { createMatAlgo05xSfSf } from '../../type/matrix/utils/matAlgo05xSfSf.js';
 import { createMatAlgo11xS0s } from '../../type/matrix/utils/matAlgo11xS0s.js';
 import { createMatAlgo12xSfs } from '../../type/matrix/utils/matAlgo12xSfs.js';
-import { modNumber } from '../../plain/number/index.js';
 import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
 var name = 'mod';
-var dependencies = ['typed', 'matrix', 'equalScalar', 'DenseMatrix', 'concat'];
+var dependencies = ['typed', 'config', 'round', 'matrix', 'equalScalar', 'zeros', 'DenseMatrix', 'concat'];
 export var createMod = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
+    config,
+    round,
     matrix,
     equalScalar,
+    zeros,
     DenseMatrix,
     concat
   } = _ref;
+  var floor = createFloor({
+    typed,
+    config,
+    round,
+    matrix,
+    equalScalar,
+    zeros,
+    DenseMatrix
+  });
   var matAlgo02xDS0 = createMatAlgo02xDS0({
     typed,
     equalScalar
@@ -77,7 +89,7 @@ export var createMod = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @return {number | BigNumber | Fraction | Array | Matrix} Returns the remainder of `x` divided by `y`.
    */
   return typed(name, {
-    'number, number': modNumber,
+    'number, number': _modNumber,
     'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
       if (y.isNeg()) {
         throw new Error('Cannot calculate mod for a negative divisor');
@@ -98,4 +110,21 @@ export var createMod = /* #__PURE__ */factory(name, dependencies, _ref => {
     Ss: matAlgo11xS0s,
     sS: matAlgo12xSfs
   }));
+
+  /**
+  * Calculate the modulus of two numbers
+  * @param {number} x
+  * @param {number} y
+  * @returns {number} res
+  * @private
+  */
+  function _modNumber(x, y) {
+    // We don't use JavaScript's % operator here as this doesn't work
+    // correctly for x < 0 and x === 0
+    // see https://en.wikipedia.org/wiki/Modulo_operation
+
+    // We use mathjs floor to handle errors associated with
+    // precision float approximation
+    return y === 0 ? x : x - y * floor(x / y);
+  }
 });

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

@@ -1,6 +1,6 @@
 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; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 import { isUnit, isNumber, isBigNumber } from '../../utils/is.js';
 import { factory } from '../../utils/factory.js';
 var name = 'solveODE';