mathjs 14.0.1 → 14.2.0

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

@@ -1,6 +1,7 @@
-import { factory } from '../../utils/factory.js';
-import { deepMap } from '../../utils/collection.js';
 import { log2Number } from '../../plain/number/index.js';
+import { promoteLogarithm } from '../../utils/bigint.js';
+import { deepMap } from '../../utils/collection.js';
+import { factory } from '../../utils/factory.js';
 var name = 'log2';
 var dependencies = ['typed', 'config', 'Complex'];
 export var createLog2 = /* #__PURE__ */factory(name, dependencies, _ref => {
@@ -34,22 +35,26 @@ export var createLog2 = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @return {number | BigNumber | Complex | Array | Matrix}
    *            Returns the 2-base logarithm of `x`
    */
+  function complexLog2Number(x) {
+    return _log2Complex(new Complex(x, 0));
+  }
   return typed(name, {
     number: function number(x) {
       if (x >= 0 || config.predictable) {
         return log2Number(x);
       } else {
         // negative value -> complex value computation
-        return _log2Complex(new Complex(x, 0));
+        return complexLog2Number(x);
       }
     },
+    bigint: promoteLogarithm(4, log2Number, config, complexLog2Number),
     Complex: _log2Complex,
     BigNumber: function BigNumber(x) {
       if (!x.isNegative() || config.predictable) {
         return x.log(2);
       } else {
         // downgrade to number, return Complex valued result
-        return _log2Complex(new Complex(x.toNumber(), 0));
+        return complexLog2Number(x.toNumber());
       }
     },
     'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))

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

@@ -137,6 +137,10 @@ export var createRound = /* #__PURE__ */factory(name, dependencies, _ref => {
       var xSelected = bigNearlyEqual(x, xEpsilon, config.relTol, config.absTol) ? xEpsilon : x;
       return xSelected.toDecimalPlaces(n.toNumber());
     },
+    // bigints can't be rounded
+    bigint: b => b,
+    'bigint, number': (b, _dummy) => b,
+    'bigint, BigNumber': (b, _dummy) => b,
     Fraction: function Fraction(x) {
       return x.round();
     },

package/lib/esm/function/matrix/ctranspose.js

@@ -20,7 +20,7 @@ export var createCtranspose = /* #__PURE__ */factory(name, dependencies, _ref =>
    * Examples:
    *
    *     const A = [[1, 2, 3], [4, 5, math.complex(6,7)]]
-   *     math.ctranspose(A)               // returns [[1, 4], [2, 5], [3, {re:6,im:7}]]
+   *     math.ctranspose(A)      // returns [[1, 4], [2, 5], [3, {re:6,im:-7}]]
    *
    * See also:
    *

package/lib/esm/function/matrix/{apply.js → mapSlices.js}

@@ -2,9 +2,9 @@ import { factory } from '../../utils/factory.js';
 import { arraySize } from '../../utils/array.js';
 import { isMatrix } from '../../utils/is.js';
 import { IndexError } from '../../error/IndexError.js';
-var name = 'apply';
+var name = 'mapSlices';
 var dependencies = ['typed', 'isInteger'];
-export var createApply = /* #__PURE__ */factory(name, dependencies, _ref => {
+export var createMapSlices = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     isInteger
@@ -16,7 +16,7 @@ export var createApply = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    * Syntax:
    *
-   *     math.apply(A, dim, callback)
+   *     math.mapSlices(A, dim, callback)
    *
    * Where:
    *
@@ -27,19 +27,24 @@ export var createApply = /* #__PURE__ */factory(name, dependencies, _ref => {
    *    const A = [[1, 2], [3, 4]]
    *    const sum = math.sum
    *
-   *    math.apply(A, 0, sum)             // returns [4, 6]
-   *    math.apply(A, 1, sum)             // returns [3, 7]
+   *    math.mapSlices(A, 0, sum)             // returns [4, 6]
+   *    math.mapSlices(A, 1, sum)             // returns [3, 7]
    *
    * See also:
    *
    *    map, filter, forEach
    *
+   * Note:
+   *
+   *    `mapSlices()` is also currently available via its deprecated
+   *    synonym `apply()`.
+   *
    * @param {Array | Matrix} array   The input Matrix
    * @param {number} dim             The dimension along which the callback is applied
    * @param {Function} callback      The callback function that is applied. This Function
    *                                 should take an array or 1-d matrix as an input and
    *                                 return a number.
-   * @return {Array | Matrix} res    The residual matrix with the function applied over some dimension.
+   * @return {Array | Matrix} res    The residual matrix with the function mapped on the slices over some dimension.
    */
   return typed(name, {
     'Array | Matrix, number | BigNumber, function': function Array__Matrix_number__BigNumber_function(mat, dim, callback) {
@@ -51,12 +56,14 @@ export var createApply = /* #__PURE__ */factory(name, dependencies, _ref => {
         throw new IndexError(dim, size.length);
       }
       if (isMatrix(mat)) {
-        return mat.create(_apply(mat.valueOf(), dim, callback), mat.datatype());
+        return mat.create(_mapSlices(mat.valueOf(), dim, callback), mat.datatype());
       } else {
-        return _apply(mat, dim, callback);
+        return _mapSlices(mat, dim, callback);
       }
     }
   });
+}, {
+  formerly: 'apply'
 });
 
 /**
@@ -67,7 +74,7 @@ export var createApply = /* #__PURE__ */factory(name, dependencies, _ref => {
  * @returns {Array} ret
  * @private
  */
-function _apply(mat, dim, callback) {
+function _mapSlices(mat, dim, callback) {
   var i, ret, tran;
   if (dim <= 0) {
     if (!Array.isArray(mat[0])) {
@@ -76,14 +83,14 @@ function _apply(mat, dim, callback) {
       tran = _switch(mat);
       ret = [];
       for (i = 0; i < tran.length; i++) {
-        ret[i] = _apply(tran[i], dim - 1, callback);
+        ret[i] = _mapSlices(tran[i], dim - 1, callback);
       }
       return ret;
     }
   } else {
     ret = [];
     for (i = 0; i < mat.length; i++) {
-      ret[i] = _apply(mat[i], dim - 1, callback);
+      ret[i] = _mapSlices(mat[i], dim - 1, callback);
     }
     return ret;
   }

package/lib/esm/function/matrix/matrixFromFunction.js

@@ -9,8 +9,10 @@ export var createMatrixFromFunction = /* #__PURE__ */factory(name, dependencies,
   } = _ref;
   /**
    * Create a matrix by evaluating a generating function at each index.
-   * The simplest overload returns a multi-dimensional array as long as `size` is an array.
-   * Passing `size` as a Matrix or specifying a `format` will result in returning a Matrix.
+   * The simplest overload returns a multi-dimensional array as long as `size`
+   * is an array.
+   * Passing `size` as a Matrix or specifying a `format` will result in
+   * returning a Matrix.
    *
    * Syntax:
    *
@@ -20,6 +22,37 @@ export var createMatrixFromFunction = /* #__PURE__ */factory(name, dependencies,
    *    math.matrixFromFunction(size, format, fn)
    *    math.matrixFromFunction(size, format, datatype, fn)
    *
+   * Where:
+   *
+   *    - `size: (number[] | Matrix)`
+   *      A vector giving the extent of the array to be created in each
+   *      dimension. If size has one entry, a vector is created; if it
+   *      has two, a rectangular array/Matrix is created; if three, a
+   *      three-dimensional array/Matrix is created; and so on.
+   *    - `fn: (index: number[]) => MathType`
+   *      The callback function that will generate the entries of the
+   *      matrix. It is called in turn with the index of each entry of
+   *      the matrix. The index is always an ordinary array of numbers
+   *      with the same length as _size_. So for vectors, you will get
+   *      indices like `[0]` or `[1]`, whereas for matrices, you will
+   *      get indices like `[2, 0]` or `[1,3]`. The return value may
+   *      be any type that can go in an array or Matrix entry, although
+   *      if you supply the _datatype_ argument, you must yourself ensure
+   *      the type of the return value matches. Note that currently,
+   *      your callback _fn_ will receive 0-based indices for the matrix
+   *      entries, regardless of whether matrixFromFunction is invoked
+   *      directly from JavaScript or via the mathjs expression language.
+   *    - `format: 'dense'|'sparse'`
+   *      Specifies the storage format for the resulting Matrix. Note that
+   *      if this argument is given, the return value will always be a
+   *      Matrix (rather than possibly an Array).
+   *    - `datatype: string`
+   *      Specifies the data type of entries of the new matrix. If given,
+   *      it should be the name of a data type that mathjs supports, as
+   *      returned by the math.typeOf function. It is up to the caller
+   *      to make certain that all values returned by _fn_ are consistent
+   *      with this datatype if specified.
+   *
    * Examples:
    *
    *    math.matrixFromFunction([3,3], i => i[0] - i[1]) // an antisymmetric matrix
@@ -28,7 +61,7 @@ export var createMatrixFromFunction = /* #__PURE__ */factory(name, dependencies,
    *
    * See also:
    *
-   *    matrix, zeros
+   *    matrix, typeOf, zeros
    *
    * @param {Array | Matrix} size   The size of the matrix to be created
    * @param {function} fn           Callback function invoked for every entry in the matrix

package/lib/esm/function/matrix/range.js

@@ -35,36 +35,48 @@ export var createRange = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    * - `str: string`
    *   A string 'start:end' or 'start:step:end'
-   * - `start: {number | BigNumber | Unit}`
+   * - `start: {number | bigint | BigNumber | Fraction | Unit}`
    *   Start of the range
-   * - `end: number | BigNumber | Unit`
+   * - `end: number | bigint | BigNumber | Fraction | Unit`
    *   End of the range, excluded by default, included when parameter includeEnd=true
-   * - `step: number | BigNumber | Unit`
+   * - `step: number | bigint | BigNumber | Fraction | Unit`
    *   Step size. Default value is 1.
    * - `includeEnd: boolean`
    *   Option to specify whether to include the end or not. False by default.
    *
+   * Note that the return type of the range is taken from the type of
+   * the start/end. If only one these is a built-in `number` type, it will
+   * be promoted to the type of the other endpoint. However, in the case of
+   * Unit values, both endpoints must have compatible units, and the return
+   * value will have compatible units as well.
+   *
    * Examples:
    *
    *     math.range(2, 6)        // [2, 3, 4, 5]
    *     math.range(2, -3, -1)   // [2, 1, 0, -1, -2]
    *     math.range('2:1:6')     // [2, 3, 4, 5]
    *     math.range(2, 6, true)  // [2, 3, 4, 5, 6]
+   *     math.range(2, math.fraction(8,3), math.fraction(1,3)) // [fraction(2), fraction(7,3)]
    *     math.range(math.unit(2, 'm'), math.unit(-3, 'm'), math.unit(-1, 'm')) // [2 m, 1 m, 0 m , -1 m, -2 m]
    *
    * See also:
    *
    *     ones, zeros, size, subset
    *
-   * @param {*} args   Parameters describing the ranges `start`, `end`, and optional `step`.
+   * @param {*} args   Parameters describing the range's `start`, `end`, and optional `step`.
    * @return {Array | Matrix} range
    */
   return typed(name, {
     // TODO: simplify signatures when typed-function supports default values and optional arguments
 
-    // TODO: a number or boolean should not be converted to string here
     string: _strRange,
     'string, boolean': _strRange,
+    number: function number(oops) {
+      throw new TypeError("Too few arguments to function range(): ".concat(oops));
+    },
+    boolean: function boolean(oops) {
+      throw new TypeError("Unexpected type of argument 1 to function range(): ".concat(oops, ", number|bigint|BigNumber|Fraction"));
+    },
     'number, number': function number_number(start, end) {
       return _out(_range(start, end, 1, false));
     },
@@ -77,6 +89,31 @@ export var createRange = /* #__PURE__ */factory(name, dependencies, _ref => {
     'number, number, number, boolean': function number_number_number_boolean(start, end, step, includeEnd) {
       return _out(_range(start, end, step, includeEnd));
     },
+    // Handle bigints; if either limit is bigint, range should be too
+    'bigint, bigint|number': function bigint_bigintNumber(start, end) {
+      return _out(_range(start, end, 1n, false));
+    },
+    'number, bigint': function number_bigint(start, end) {
+      return _out(_range(BigInt(start), end, 1n, false));
+    },
+    'bigint, bigint|number, bigint|number': function bigint_bigintNumber_bigintNumber(start, end, step) {
+      return _out(_range(start, end, BigInt(step), false));
+    },
+    'number, bigint, bigint|number': function number_bigint_bigintNumber(start, end, step) {
+      return _out(_range(BigInt(start), end, BigInt(step), false));
+    },
+    'bigint, bigint|number, boolean': function bigint_bigintNumber_boolean(start, end, includeEnd) {
+      return _out(_range(start, end, 1n, includeEnd));
+    },
+    'number, bigint, boolean': function number_bigint_boolean(start, end, includeEnd) {
+      return _out(_range(BigInt(start), end, 1n, includeEnd));
+    },
+    'bigint, bigint|number, bigint|number, boolean': function bigint_bigintNumber_bigintNumber_boolean(start, end, step, includeEnd) {
+      return _out(_range(start, end, BigInt(step), includeEnd));
+    },
+    'number, bigint, bigint|number, boolean': function number_bigint_bigintNumber_boolean(start, end, step, includeEnd) {
+      return _out(_range(BigInt(start), end, BigInt(step), includeEnd));
+    },
     'BigNumber, BigNumber': function BigNumber_BigNumber(start, end) {
       var BigNumber = start.constructor;
       return _out(_range(start, end, new BigNumber(1), false));
@@ -91,6 +128,18 @@ export var createRange = /* #__PURE__ */factory(name, dependencies, _ref => {
     'BigNumber, BigNumber, BigNumber, boolean': function BigNumber_BigNumber_BigNumber_boolean(start, end, step, includeEnd) {
       return _out(_range(start, end, step, includeEnd));
     },
+    'Fraction, Fraction': function Fraction_Fraction(start, end) {
+      return _out(_range(start, end, 1, false));
+    },
+    'Fraction, Fraction, Fraction': function Fraction_Fraction_Fraction(start, end, step) {
+      return _out(_range(start, end, step, false));
+    },
+    'Fraction, Fraction, boolean': function Fraction_Fraction_boolean(start, end, includeEnd) {
+      return _out(_range(start, end, 1, includeEnd));
+    },
+    'Fraction, Fraction, Fraction, boolean': function Fraction_Fraction_Fraction_boolean(start, end, step, includeEnd) {
+      return _out(_range(start, end, step, includeEnd));
+    },
     'Unit, Unit, Unit': function Unit_Unit_Unit(start, end, step) {
       return _out(_range(start, end, step, false));
     },

package/lib/esm/function/probability/randomInt.js

@@ -3,11 +3,13 @@ import { randomMatrix } from './util/randomMatrix.js';
 import { createRng } from './util/seededRNG.js';
 import { isMatrix } from '../../utils/is.js';
 var name = 'randomInt';
-var dependencies = ['typed', 'config', '?on'];
+var dependencies = ['typed', 'config', 'log2', '?on'];
+var simpleCutoff = 2n ** 30n;
 export var createRandomInt = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     config,
+    log2,
     on
   } = _ref;
   // seeded pseudo random number generator
@@ -26,7 +28,7 @@ export var createRandomInt = /* #__PURE__ */factory(name, dependencies, _ref =>
    *
    * Syntax:
    *
-   *     math.randomInt()                // generate a random integer between 0 and 1
+   *     math.randomInt()                // generate either 0 or 1, randomly
    *     math.randomInt(max)             // generate a random integer between 0 and max
    *     math.randomInt(min, max)        // generate a random integer between min and max
    *     math.randomInt(size)            // generate a matrix with random integer between 0 and 1
@@ -50,9 +52,11 @@ export var createRandomInt = /* #__PURE__ */factory(name, dependencies, _ref =>
    * @return {number | Array | Matrix} A random integer value
    */
   return typed(name, {
-    '': () => _randomInt(0, 1),
+    '': () => _randomInt(0, 2),
     number: max => _randomInt(0, max),
     'number, number': (min, max) => _randomInt(min, max),
+    bigint: max => _randomBigint(0n, max),
+    'bigint, bigint': _randomBigint,
     'Array | Matrix': size => _randomIntMatrix(size, 0, 1),
     'Array | Matrix, number': (size, max) => _randomIntMatrix(size, 0, max),
     'Array | Matrix, number, number': (size, min, max) => _randomIntMatrix(size, min, max)
@@ -64,4 +68,23 @@ export var createRandomInt = /* #__PURE__ */factory(name, dependencies, _ref =>
   function _randomInt(min, max) {
     return Math.floor(min + rng() * (max - min));
   }
+  function _randomBigint(min, max) {
+    var width = max - min; // number of choices
+    if (width <= simpleCutoff) {
+      // do it with number type
+      return min + BigInt(_randomInt(0, Number(width)));
+    }
+    // Too big to choose accurately that way. Instead, choose the correct
+    // number of random bits to cover the width, and repeat until the
+    // resulting number falls within the width
+    var bits = log2(width);
+    var picked = width;
+    while (picked >= width) {
+      picked = 0n;
+      for (var i = 0; i < bits; ++i) {
+        picked = 2n * picked + (rng() < 0.5 ? 0n : 1n);
+      }
+    }
+    return min + picked;
+  }
 });

package/lib/esm/function/relational/larger.js

@@ -7,11 +7,12 @@ import { createMatAlgo12xSfs } from '../../type/matrix/utils/matAlgo12xSfs.js';
 import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
 import { createCompareUnits } from './compareUnits.js';
 var name = 'larger';
-var dependencies = ['typed', 'config', 'matrix', 'DenseMatrix', 'concat', 'SparseMatrix'];
+var dependencies = ['typed', 'config', 'bignumber', 'matrix', 'DenseMatrix', 'concat', 'SparseMatrix'];
 export var createLarger = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     config,
+    bignumber,
     matrix,
     DenseMatrix,
     concat,
@@ -68,16 +69,23 @@ export var createLarger = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @param  {number | BigNumber | bigint | Fraction | boolean | Unit | string | Array | Matrix} y Second value to compare
    * @return {boolean | Array | Matrix} Returns true when the x is larger than y, else returns false
    */
+  function bignumLarger(x, y) {
+    return x.gt(y) && !bigNearlyEqual(x, y, config.relTol, config.absTol);
+  }
   return typed(name, createLargerNumber({
     typed,
     config
   }), {
     'boolean, boolean': (x, y) => x > y,
-    'BigNumber, BigNumber': function BigNumber_BigNumber(x, y) {
-      return x.gt(y) && !bigNearlyEqual(x, y, config.relTol, config.absTol);
-    },
+    'BigNumber, BigNumber': bignumLarger,
     'bigint, bigint': (x, y) => x > y,
     'Fraction, Fraction': (x, y) => x.compare(y) === 1,
+    'Fraction, BigNumber': function Fraction_BigNumber(x, y) {
+      return bignumLarger(bignumber(x), y);
+    },
+    'BigNumber, Fraction': function BigNumber_Fraction(x, y) {
+      return bignumLarger(x, bignumber(y));
+    },
     'Complex, Complex': function Complex_Complex() {
       throw new TypeError('No ordering relation is defined for complex numbers');
     }

package/lib/esm/function/relational/smaller.js

@@ -7,11 +7,12 @@ import { createMatAlgo12xSfs } from '../../type/matrix/utils/matAlgo12xSfs.js';
 import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
 import { createCompareUnits } from './compareUnits.js';
 var name = 'smaller';
-var dependencies = ['typed', 'config', 'matrix', 'DenseMatrix', 'concat', 'SparseMatrix'];
+var dependencies = ['typed', 'config', 'bignumber', 'matrix', 'DenseMatrix', 'concat', 'SparseMatrix'];
 export var createSmaller = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     config,
+    bignumber,
     matrix,
     DenseMatrix,
     concat,
@@ -68,16 +69,23 @@ export var createSmaller = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @param  {number | BigNumber | bigint | Fraction | boolean | Unit | string | Array | Matrix} y Second value to compare
    * @return {boolean | Array | Matrix} Returns true when the x is smaller than y, else returns false
    */
+  function bignumSmaller(x, y) {
+    return x.lt(y) && !bigNearlyEqual(x, y, config.relTol, config.absTol);
+  }
   return typed(name, createSmallerNumber({
     typed,
     config
   }), {
     'boolean, boolean': (x, y) => x < y,
-    'BigNumber, BigNumber': function BigNumber_BigNumber(x, y) {
-      return x.lt(y) && !bigNearlyEqual(x, y, config.relTol, config.absTol);
-    },
+    'BigNumber, BigNumber': bignumSmaller,
     'bigint, bigint': (x, y) => x < y,
     'Fraction, Fraction': (x, y) => x.compare(y) === -1,
+    'Fraction, BigNumber': function Fraction_BigNumber(x, y) {
+      return bignumSmaller(bignumber(x), y);
+    },
+    'BigNumber, Fraction': function BigNumber_Fraction(x, y) {
+      return bignumSmaller(x, bignumber(y));
+    },
     'Complex, Complex': function Complex_Complex(x, y) {
       throw new TypeError('No ordering relation is defined for complex numbers');
     }

package/lib/esm/function/statistics/max.js

@@ -83,7 +83,7 @@ export var createMax = /* #__PURE__ */factory(name, dependencies, _ref => {
     var res;
     deepForEach(array, function (value) {
       try {
-        if (isNaN(value) && typeof value === 'number') {
+        if (typeof value === 'number' && isNaN(value)) {
           res = NaN;
         } else if (res === undefined || larger(value, res)) {
           res = value;

package/lib/esm/function/statistics/min.js

@@ -83,7 +83,7 @@ export var createMin = /* #__PURE__ */factory(name, dependencies, _ref => {
     var min;
     deepForEach(array, function (value) {
       try {
-        if (isNaN(value) && typeof value === 'number') {
+        if (typeof value === 'number' && isNaN(value)) {
           min = NaN;
         } else if (min === undefined || smaller(value, min)) {
           min = value;

package/lib/esm/function/statistics/quantileSeq.js

@@ -1,9 +1,8 @@
 import { isNumber } from '../../utils/is.js';
 import { flatten } from '../../utils/array.js';
 import { factory } from '../../utils/factory.js';
-import { createApply } from '../matrix/apply.js';
 var name = 'quantileSeq';
-var dependencies = ['typed', '?bignumber', 'add', 'subtract', 'divide', 'multiply', 'partitionSelect', 'compare', 'isInteger', 'smaller', 'smallerEq', 'larger'];
+var dependencies = ['typed', '?bignumber', 'add', 'subtract', 'divide', 'multiply', 'partitionSelect', 'compare', 'isInteger', 'smaller', 'smallerEq', 'larger', 'mapSlices'];
 export var createQuantileSeq = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
@@ -17,13 +16,9 @@ export var createQuantileSeq = /* #__PURE__ */factory(name, dependencies, _ref =
     isInteger,
     smaller,
     smallerEq,
-    larger
+    larger,
+    mapSlices
   } = _ref;
-  var apply = createApply({
-    typed,
-    isInteger
-  });
-
   /**
    * Compute the prob order quantile of a matrix or a list with values.
    * The sequence is sorted and the middle value is returned.
@@ -69,7 +64,7 @@ export var createQuantileSeq = /* #__PURE__ */factory(name, dependencies, _ref =
     'Array | Matrix, Array | Matrix, boolean, number': (data, prob, sorted, dim) => _quantileSeqDim(data, prob, sorted, dim, _quantileSeqProbCollection)
   });
   function _quantileSeqDim(data, prob, sorted, dim, fn) {
-    return apply(data, dim, x => fn(x, prob, sorted));
+    return mapSlices(data, dim, x => fn(x, prob, sorted));
   }
   function _quantileSeqProbNumber(data, probOrN, sorted) {
     var probArr;

package/lib/esm/function/statistics/variance.js

@@ -4,7 +4,7 @@ import { factory } from '../../utils/factory.js';
 import { improveErrorMessage } from './utils/improveErrorMessage.js';
 var DEFAULT_NORMALIZATION = 'unbiased';
 var name = 'variance';
-var dependencies = ['typed', 'add', 'subtract', 'multiply', 'divide', 'apply', 'isNaN'];
+var dependencies = ['typed', 'add', 'subtract', 'multiply', 'divide', 'mapSlices', 'isNaN'];
 export var createVariance = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
@@ -12,7 +12,7 @@ export var createVariance = /* #__PURE__ */factory(name, dependencies, _ref => {
     subtract,
     multiply,
     divide,
-    apply,
+    mapSlices,
     isNaN
   } = _ref;
   /**
@@ -145,7 +145,7 @@ export var createVariance = /* #__PURE__ */factory(name, dependencies, _ref => {
       if (array.length === 0) {
         throw new SyntaxError('Function variance requires one or more parameters (0 provided)');
       }
-      return apply(array, dim, x => _var(x, normalization));
+      return mapSlices(array, dim, x => _var(x, normalization));
     } catch (err) {
       throw improveErrorMessage(err, 'variance');
     }

package/lib/esm/function/string/hex.js

@@ -11,7 +11,7 @@ var dependencies = ['typed', 'format'];
  *
  * Examples:
  *
- *    math.hex(240) // returns "0xF0"
+ *    math.hex(240) // returns "0xf0"
  *
  * See also:
  *

package/lib/esm/function/string/print.js

@@ -25,12 +25,12 @@ export var createPrint = /* #__PURE__ */factory(name, dependencies, _ref => {
    *     // the following outputs: 'The value of pi is 3.141592654'
    *     math.print('The value of pi is $pi', {pi: math.pi}, 10)
    *
-   *     // the following outputs: 'hello Mary! The date is 2013-03-23'
+   *     // the following outputs: 'Hello Mary! The date is 2013-03-23'
    *     math.print('Hello $user.name! The date is $date', {
    *       user: {
    *         name: 'Mary',
    *       },
-   *       date: new Date(2013, 2, 23).toISOString().substring(0, 10)
+   *       date: '2013-03-23'
    *     })
    *
    *     // the following outputs: 'My favorite fruits are apples and bananas !'

package/lib/esm/function/trigonometry/acoth.js

@@ -22,7 +22,7 @@ export var createAcoth = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    * Examples:
    *
-   *    math.acoth(0.5)       // returns 0.8047189562170503
+   *    math.acoth(0.5)     // returns 0.5493061443340548 - 1.5707963267948966i
    *
    * See also:
    *

package/lib/esm/function/trigonometry/acsc.js

@@ -23,7 +23,7 @@ export var createAcsc = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *    math.acsc(2)             // returns 0.5235987755982989
    *    math.acsc(0.5)           // returns Complex 1.5707963267948966 -1.3169578969248166i
-   *    math.acsc(math.csc(1.5)) // returns number ~1.5
+   *    math.acsc(math.csc(1.5)) // returns number 1.5
    *
    * See also:
    *

package/lib/esm/function/trigonometry/asin.js

@@ -20,7 +20,7 @@ export var createAsin = /* #__PURE__ */factory(name, dependencies, _ref => {
    * Examples:
    *
    *    math.asin(0.5)           // returns number 0.5235987755982989
-   *    math.asin(math.sin(1.5)) // returns number ~1.5
+   *    math.asin(math.sin(1.5)) // returns number 1.5
    *
    *    math.asin(2)             // returns Complex 1.5707963267948966 -1.3169578969248166i
    *

package/lib/esm/function/trigonometry/atan2.js

@@ -56,9 +56,10 @@ export var createAtan2 = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *    math.atan2(2, 2) / math.pi       // returns number 0.25
    *
-   *    const angle = math.unit(60, 'deg') // returns Unit 60 deg
+   *    const angle = math.unit(60, 'deg')
    *    const x = math.cos(angle)
    *    const y = math.sin(angle)
+   *    math.atan2(y, x) * 180 / math.pi  // returns 60
    *
    *    math.atan(2)             // returns number 1.1071487177940904
    *

package/lib/esm/function/trigonometry/cos.js

@@ -28,7 +28,7 @@ export var createCos = /* #__PURE__ */factory(name, dependencies, _ref => {
    *    math.cos(math.unit(60, 'deg'))   // returns number  0.5
    *
    *    const angle = 0.2
-   *    math.pow(math.sin(angle), 2) + math.pow(math.cos(angle), 2) // returns number ~1
+   *    math.pow(math.sin(angle), 2) + math.pow(math.cos(angle), 2) // returns number 1
    *
    * See also:
    *

package/lib/esm/function/trigonometry/sin.js

@@ -28,7 +28,7 @@ export var createSin = /* #__PURE__ */factory(name, dependencies, _ref => {
    *    math.sin(math.unit(30, 'deg'))   // returns number 0.5
    *
    *    const angle = 0.2
-   *    math.pow(math.sin(angle), 2) + math.pow(math.cos(angle), 2) // returns number ~1
+   *    math.pow(math.sin(angle), 2) + math.pow(math.cos(angle), 2) // returns number 1
    *
    * See also:
    *

package/lib/esm/function/utils/isInteger.js

@@ -26,7 +26,7 @@ export var createIsInteger = /* #__PURE__ */factory(name, dependencies, _ref =>
    *    math.isInteger(math.fraction(4))      // returns true
    *    math.isInteger('3')                   // returns true
    *    math.isInteger([3, 0.5, -2])          // returns [true, false, true]
-   *    math.isInteger(math.complex('2-4i'))  // throws an error
+   *    math.isInteger(math.complex('2-4i'))  // throws TypeError
    *
    * See also:
    *

package/lib/esm/header.js

@@ -10,7 +10,7 @@
  * @date    @@date
  *
  * @license
- * Copyright (C) 2013-2024 Jos de Jong <wjosdejong@gmail.com>
+ * Copyright (C) 2013-2025 Jos de Jong <wjosdejong@gmail.com>
  *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy