mathjs 10.3.0 → 10.4.0

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

@@ -6,7 +6,7 @@ import { lastDimToZeroBase } from './utils/lastDimToZeroBase.js';
  * Attach a transform function to math.sum
  * Adds a property transform containing the transform function.
  *
- * This transform changed the last `dim` parameter of function mean
+ * This transform changed the last `dim` parameter of function sum
  * from one-based to zero based
  */
 

package/lib/esm/factoriesAny.js

@@ -221,6 +221,7 @@ export { createDivide } from './function/arithmetic/divide.js';
 export { createDistance } from './function/geometry/distance.js';
 export { createIntersect } from './function/geometry/intersect.js';
 export { createSum } from './function/statistics/sum.js';
+export { createCumSum } from './function/statistics/cumsum.js';
 export { createMean } from './function/statistics/mean.js';
 export { createMedian } from './function/statistics/median.js';
 export { createMad } from './function/statistics/mad.js';
@@ -269,4 +270,5 @@ export { createConcatTransform } from './expression/transform/concat.transform.j
 export { createDiffTransform } from './expression/transform/diff.transform.js';
 export { createStdTransform } from './expression/transform/std.transform.js';
 export { createSumTransform } from './expression/transform/sum.transform.js';
+export { createCumSumTransform } from './expression/transform/cumsum.transform.js';
 export { createVarianceTransform } from './expression/transform/variance.transform.js';

package/lib/esm/factoriesNumber.js

@@ -146,6 +146,7 @@ export { createProd } from './function/statistics/prod.js';
 export { createMax } from './function/statistics/max.js';
 export { createMin } from './function/statistics/min.js';
 export { createSum } from './function/statistics/sum.js';
+export { createCumSum } from './function/statistics/cumsum.js';
 export { createMean } from './function/statistics/mean.js';
 export { createMedian } from './function/statistics/median.js';
 export { createMad } from './function/statistics/mad.js';
@@ -195,6 +196,7 @@ export var createSubsetTransform = /* #__PURE__ */factory('subset', [], () => no
 });
 export { createStdTransform } from './expression/transform/std.transform.js';
 export { createSumTransform } from './expression/transform/sum.transform.js';
+export { createCumSumTransform } from './expression/transform/cumsum.transform.js';
 export { createVarianceTransform } from './expression/transform/variance.transform.js'; // utils
 
 export { createClone } from './function/utils/clone.js';

package/lib/esm/function/algebra/simplifyCore.js

@@ -206,9 +206,9 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
             }
           }
         }
-
-        return new OperatorNode(node.op, node.fn, [_a, a1]);
       }
+
+      return new OperatorNode(node.op, node.fn, [_a, a1]);
     } else if (isFunctionNode(node)) {
       return new FunctionNode(simplifyCore(node.fn), node.args.map(n => simplifyCore(n, options)));
     } else if (isArrayNode(node)) {

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

@@ -0,0 +1,139 @@
+import { containsCollections } from '../../utils/collection.js';
+import { factory } from '../../utils/factory.js';
+import { _switch } from '../../utils/switch.js';
+import { improveErrorMessage } from './utils/improveErrorMessage.js';
+import { arraySize } from '../../utils/array.js';
+import { IndexError } from '../../error/IndexError.js';
+var name = 'cumsum';
+var dependencies = ['typed', 'add', 'unaryPlus'];
+export var createCumSum = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    add,
+    unaryPlus
+  } = _ref;
+
+  /**
+   * Compute the cumulative sum of a matrix or a list with values.
+   * In case of a (multi dimensional) array or matrix, the cumulative sums
+   * along a specified dimension (defaulting to the first) will be calculated.
+   *
+   * Syntax:
+   *
+   *     math.cumsum(a, b, c, ...)
+   *     math.cumsum(A)
+   *
+   * Examples:
+   *
+   *     math.cumsum(2, 1, 4, 3)               // returns [2, 3, 7, 10]
+   *     math.cumsum([2, 1, 4, 3])             // returns [2, 3, 7, 10]
+   *     math.cumsum([[1, 2], [3, 4]])         // returns [[1, 2], [4, 6]]
+   *     math.cumsum([[1, 2], [3, 4]], 0)      // returns [[1, 2], [4, 6]]
+   *     math.cumsum([[1, 2], [3, 4]], 1)      // returns [[1, 3], [3, 7]]
+   *     math.cumsum([[2, 5], [4, 3], [1, 7]]) // returns [[2, 5], [6, 8], [7, 15]]
+   *
+   * See also:
+   *
+   *    mean, median, min, max, prod, std, variance, sum
+   *
+   * @param {... *} args  A single matrix or or multiple scalar values
+   * @return {*} The cumulative sum of all values
+   */
+  return typed(name, {
+    // sum([a, b, c, d, ...])
+    Array: _cumsum,
+    Matrix: function Matrix(matrix) {
+      return matrix.create(_cumsum(matrix.valueOf()));
+    },
+    // sum([a, b, c, d, ...], dim)
+    'Array, number | BigNumber': _ncumSumDim,
+    'Matrix, number | BigNumber': function MatrixNumberBigNumber(matrix, dim) {
+      return matrix.create(_ncumSumDim(matrix.valueOf(), dim));
+    },
+    // cumsum(a, b, c, d, ...)
+    '...': function _(args) {
+      if (containsCollections(args)) {
+        throw new TypeError('All values expected to be scalar in function cumsum');
+      }
+
+      return _cumsum(args);
+    }
+  });
+  /**
+     * Recursively calculate the cumulative sum of an n-dimensional array
+     * @param {Array} array
+     * @return {number} cumsum
+     * @private
+     */
+
+  function _cumsum(array) {
+    try {
+      return _cumsummap(array);
+    } catch (err) {
+      throw improveErrorMessage(err, name);
+    }
+  }
+
+  function _cumsummap(array) {
+    if (array.length === 0) {
+      return [];
+    }
+
+    var sums = [unaryPlus(array[0])]; // unaryPlus converts to number if need be
+
+    for (var i = 1; i < array.length; ++i) {
+      // Must use add below and not addScalar for the case of summing a
+      // 2+-dimensional array along the 0th dimension (the row vectors,
+      // or higher-d analogues, are literally added to each other).
+      sums.push(add(sums[i - 1], array[i]));
+    }
+
+    return sums;
+  }
+
+  function _ncumSumDim(array, dim) {
+    var size = arraySize(array);
+
+    if (dim < 0 || dim >= size.length) {
+      // TODO: would be more clear when throwing a DimensionError here
+      throw new IndexError(dim, size.length);
+    }
+
+    try {
+      return _cumsumDimensional(array, dim);
+    } catch (err) {
+      throw improveErrorMessage(err, name);
+    }
+  }
+  /* Possible TODO: Refactor _reduce in collection.js to be able to work here as well */
+
+
+  function _cumsumDimensional(mat, dim) {
+    var i, ret, tran;
+
+    if (dim <= 0) {
+      var initialValue = mat[0][0];
+
+      if (!Array.isArray(initialValue)) {
+        return _cumsummap(mat);
+      } else {
+        tran = _switch(mat);
+        ret = [];
+
+        for (i = 0; i < tran.length; i++) {
+          ret[i] = _cumsumDimensional(tran[i], dim - 1);
+        }
+
+        return ret;
+      }
+    } else {
+      ret = [];
+
+      for (i = 0; i < mat.length; i++) {
+        ret[i] = _cumsumDimensional(mat[i], dim - 1);
+      }
+
+      return ret;
+    }
+  }
+});

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

@@ -29,7 +29,7 @@ export var createSum = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    * See also:
    *
-   *    mean, median, min, max, prod, std, variance
+   *    mean, median, min, max, prod, std, variance, cumsum
    *
    * @param {... *} args  A single matrix or or multiple scalar values
    * @return {*} The sum of all values

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

@@ -112,7 +112,7 @@ export var createFormat = /* #__PURE__ */factory(name, dependencies, _ref => {
    *      // you could also use math.format inside the callback:
    *      // return '$' + math.format(value, {notation: 'fixed', precision: 2})
    *    }
-   *    math.format([2.1, 3, 0.016], formatCurrency}            // returns '[$2.10, $3.00, $0.02]'
+   *    math.format([2.1, 3, 0.016], formatCurrency)            // returns '[$2.10, $3.00, $0.02]'
    *
    * See also:
    *

package/lib/esm/type/fraction/function/fraction.js

@@ -9,27 +9,39 @@ export var createFraction = /* #__PURE__ */factory(name, dependencies, _ref => {
   } = _ref;
 
   /**
-   * Create a fraction convert a value to a fraction.
+   * Create a fraction or convert a value to a fraction.
+   *
+   * With one numeric argument, produces the closest rational approximation to the
+   * input.
+   * With two arguments, the first is the numerator and the second is the denominator,
+   * and creates the corresponding fraction. Both numerator and denominator must be
+   * integers.
+   * With one object argument, looks for the integer numerator as the value of property
+   * 'n' and the integer denominator as the value of property 'd'.
+   * With a matrix argument, creates a matrix of the same shape with entries
+   * converted into fractions.
    *
    * Syntax:
+   *     math.fraction(value)
    *     math.fraction(numerator, denominator)
    *     math.fraction({n: numerator, d: denominator})
-   *     math.fraction(matrix: Array | Matrix)         Turn all matrix entries
-   *                                                   into fractions
+   *     math.fraction(matrix: Array | Matrix)
    *
    * Examples:
    *
-   *     math.fraction(1, 3)
-   *     math.fraction('2/3')
-   *     math.fraction({n: 2, d: 3})
-   *     math.fraction([0.2, 0.25, 1.25])
+   *     math.fraction(6.283)             // returns Fraction 6283/1000
+   *     math.fraction(1, 3)              // returns Fraction 1/3
+   *     math.fraction('2/3')             // returns Fraction 2/3
+   *     math.fraction({n: 2, d: 3})      // returns Fraction 2/3
+   *     math.fraction([0.2, 0.25, 1.25]) // returns Array [1/5, 1/4, 5/4]
+   *     math.fraction(4, 5.1)            // throws Error: Parameters must be integer
    *
    * See also:
    *
    *    bignumber, number, string, unit
    *
    * @param {number | string | Fraction | BigNumber | Array | Matrix} [args]
-   *            Arguments specifying the numerator and denominator of
+   *            Arguments specifying the value, or numerator and denominator of
    *            the fraction
    * @return {Fraction | Array | Matrix} Returns a fraction
    */

package/lib/esm/utils/collection.js

@@ -1,6 +1,7 @@
 import { isCollection, isMatrix } from './is.js';
 import { IndexError } from '../error/IndexError.js';
 import { arraySize } from './array.js';
+import { _switch } from './switch.js';
 /**
  * Test whether an array contains collections
  * @param {Array} array
@@ -127,32 +128,6 @@ function _reduce(mat, dim, callback) {
 
     return ret;
   }
-}
-/**
- * Transpose a matrix
- * @param {Array} mat
- * @returns {Array} ret
- * @private
- */
-
-
-function _switch(mat) {
-  var I = mat.length;
-  var J = mat[0].length;
-  var i, j;
-  var ret = [];
-
-  for (j = 0; j < J; j++) {
-    var tmp = [];
-
-    for (i = 0; i < I; i++) {
-      tmp.push(mat[i][j]);
-    }
-
-    ret.push(tmp);
-  }
-
-  return ret;
 } // TODO: document function scatter
 
 

package/lib/esm/utils/switch.js

@@ -0,0 +1,24 @@
+/**
+ * Transpose a matrix
+ * @param {Array} mat
+ * @returns {Array} ret
+ * @private
+ */
+export function _switch(mat) {
+  var I = mat.length;
+  var J = mat[0].length;
+  var i, j;
+  var ret = [];
+
+  for (j = 0; j < J; j++) {
+    var tmp = [];
+
+    for (i = 0; i < I; i++) {
+      tmp.push(mat[i][j]);
+    }
+
+    ret.push(tmp);
+  }
+
+  return ret;
+}

package/lib/esm/version.js

@@ -1,2 +1,2 @@
-export var version = '10.3.0'; // Note: This file is automatically generated when building math.js.
+export var version = '10.4.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": "10.3.0",
+  "version": "10.4.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",
@@ -29,7 +29,7 @@
     "complex.js": "^2.0.15",
     "decimal.js": "^10.3.1",
     "escape-latex": "^1.2.0",
-    "fraction.js": "^4.1.3",
+    "fraction.js": "^4.2.0",
     "javascript-natural-sort": "^0.7.1",
     "seedrandom": "^3.0.5",
     "tiny-emitter": "^2.1.0",

package/types/index.d.ts

@@ -2223,6 +2223,38 @@ declare namespace math {
      */
     quantileSeq(A: MathArray | Matrix, prob: number | BigNumber | MathArray, sorted?: boolean): number | BigNumber | Unit | MathArray;
 
+    /**
+     * Compute the standard deviation of a matrix or a list with values. The
+     * standard deviations is defined as the square root of the variance:
+     * std(A) = sqrt(variance(A)). In case of a (multi dimensional) array or
+     * matrix, the standard deviation over all elements will be calculated.
+     * Optionally, the type of normalization can be specified as second
+     * parameter. The parameter normalization can be one of the following
+     * values: 'unbiased' (default) The sum of squared errors is divided by
+     * (n - 1) 'uncorrected' The sum of squared errors is divided by n
+     * 'biased' The sum of squared errors is divided by (n + 1)
+     * @param a variadic argument of number to calculate standard deviation
+     * @returns The standard deviation array
+     */
+    std(...values: number[]): number
+    /**
+     * Compute the standard deviation of a matrix or a list with values. The
+     * standard deviations is defined as the square root of the variance:
+     * std(A) = sqrt(variance(A)). In case of a (multi dimensional) array or
+     * matrix, the standard deviation over all elements will be calculated.
+     * Optionally, the type of normalization can be specified as second
+     * parameter. The parameter normalization can be one of the following
+     * values: 'unbiased' (default) The sum of squared errors is divided by
+     * (n - 1) 'uncorrected' The sum of squared errors is divided by n
+     * 'biased' The sum of squared errors is divided by (n + 1)
+     * @param array A single matrix to compute standard deviation.
+     * @param dimension A dimension to calculate standard deviation
+     * @param normalization Determines how to normalize the variance. Choose
+     * ‘unbiased’ (default), ‘uncorrected’, or ‘biased’. Default value:
+     * ‘unbiased’.
+     * @returns The standard deviation array
+     */
+    std(array: MathArray | Matrix, dimension: number, normalization?: 'unbiased' | 'uncorrected' | 'biased'): number[]
     /**
      * Compute the standard deviation of a matrix or a list with values. The
      * standard deviations is defined as the square root of the variance:
@@ -2239,7 +2271,7 @@ declare namespace math {
      * ‘unbiased’.
      * @returns The standard deviation
      */
-    std(array: MathArray | Matrix, normalization?: 'unbiased' | 'uncorrected' | 'biased' | 'unbiased'): number;
+    std(array: MathArray | Matrix, normalization: 'unbiased' | 'uncorrected' | 'biased'): number
 
     /**
      * Compute the sum of a matrix or a list with values. In case of a
@@ -2255,6 +2287,21 @@ declare namespace math {
      */
     sum(array: MathArray | Matrix): any;
 
+    /**
+     * Compute the cumulative sum of a matrix or a list with values.
+     * In case of a (multi dimensional) array or matrix, the cumulative sums
+     * along a specified dimension (defaulting to the first) will be calculated.
+     * @param args A single matrix or multiple scalar values
+     * @returns The cumulative sums of the the values.
+     */
+    cumsum(...args: MathType[]): MathType[];
+    /**
+     * @param array A single matrix
+     * @param dim The dimension along which to sum (defaults to 0)
+     * @returns The cumulative sums along the given dimension
+     */
+    cumsum(array: MathArray | Matrix, dim?: number): MathArray | Matrix;
+
     /**
      * Compute the variance of a matrix or a list with values. In case of a
      * (multi dimensional) array or matrix, the variance over all elements
@@ -2269,7 +2316,26 @@ declare namespace math {
      * @param args A single matrix or multiple scalar values
      * @returns The variance
      */
-    variance(...args: Array<number | BigNumber | Fraction>): any;
+    variance(...args: Array<number | BigNumber | Fraction>): number;
+    /**
+     * Compute the variance of a matrix or a list with values. In case of a
+     * (multi dimensional) array or matrix, the variance over all elements
+     * will be calculated. Optionally, the type of normalization can be
+     * specified as second parameter. The parameter normalization can be one
+     * of the following values: 'unbiased' (default) The sum of squared
+     * errors is divided by (n - 1) 'uncorrected' The sum of squared errors
+     * is divided by n 'biased' The sum of squared errors is divided by (n +
+     * 1) Note that older browser may not like the variable name var. In
+     * that case, the function can be called as math['var'](...) instead of
+     * math.variance(...).
+     * @param array A matrix to compute variance.
+     * @param dimension A dimension to compute variance on
+     * @param normalization normalization Determines how to normalize the
+     * variance. Choose ‘unbiased’ (default), ‘uncorrected’, or ‘biased’.
+     * Default value: ‘unbiased’.
+     * @returns variance matrix.
+     */
+    variance(array: MathArray | Matrix, dimension: number, normalization?: 'unbiased' | 'uncorrected' | 'biased'): number[];
     /**
      * @param array A single matrix
      * @param normalization normalization Determines how to normalize the
@@ -2277,7 +2343,7 @@ declare namespace math {
      * Default value: ‘unbiased’.
      * @returns The variance
      */
-    variance(array: MathArray | Matrix, normalization?: 'unbiased' | 'uncorrected' | 'biased' | 'unbiased'): any;
+    variance(array: MathArray | Matrix, normalization?: 'unbiased' | 'uncorrected' | 'biased'): number;
 
     /*************************************************************************
      * String functions
@@ -4706,7 +4772,24 @@ declare namespace math {
      * @param sorted =false is data sorted in ascending order
      */
     quantileSeq(prob: number | BigNumber | MathArray, sorted?: boolean): MathJsChain;
-
+    /**
+     * Compute the standard deviation of a matrix or a list with values. The
+     * standard deviations is defined as the square root of the variance:
+     * std(A) = sqrt(variance(A)). In case of a (multi dimensional) array or
+     * matrix, the standard deviation over all elements will be calculated.
+     * Optionally, the type of normalization can be specified as second
+     * parameter. The parameter normalization can be one of the following
+     * values: 'unbiased' (default) The sum of squared errors is divided by
+     * (n - 1) 'uncorrected' The sum of squared errors is divided by n
+     * 'biased' The sum of squared errors is divided by (n + 1)
+     * @param array A single matrix or multiple scalar values
+     * @param dim A dimension to compute standard deviation.
+     * @param normalization Determines how to normalize the variance. Choose
+     * ‘unbiased’ (default), ‘uncorrected’, or ‘biased’. Default value:
+     * ‘unbiased’.
+     * @returns The standard deviation
+     */
+    std(dim: number, normalization?: 'unbiased' | 'uncorrected' | 'biased'): MathJsChain;
     /**
      * Compute the standard deviation of a matrix or a list with values. The
      * standard deviations is defined as the square root of the variance:
@@ -4723,7 +4806,7 @@ declare namespace math {
      * ‘unbiased’.
      * @returns The standard deviation
      */
-    std(normalization?: 'unbiased' | 'uncorrected' | 'biased' | 'unbiased'): MathJsChain;
+    std(normalization?: 'unbiased' | 'uncorrected' | 'biased'): MathJsChain;
 
     /**
      * Compute the sum of a matrix or a list with values. In case of a
@@ -4731,7 +4814,24 @@ declare namespace math {
      * calculated.
      */
     sum(): MathJsChain;
-
+    /**
+     * Compute the variance of a matrix or a list with values. In case of a
+     * (multi dimensional) array or matrix, the variance over all elements
+     * will be calculated. Optionally, the type of normalization can be
+     * specified as second parameter. The parameter normalization can be one
+     * of the following values: 'unbiased' (default) The sum of squared
+     * errors is divided by (n - 1) 'uncorrected' The sum of squared errors
+     * is divided by n 'biased' The sum of squared errors is divided by (n +
+     * 1) Note that older browser may not like the variable name var. In
+     * that case, the function can be called as math['var'](...) instead of
+     * math.variance(...).
+     * @param dim a dimension to compute variance.
+     * @param normalization normalization Determines how to normalize the
+     * variance. Choose ‘unbiased’ (default), ‘uncorrected’, or ‘biased’.
+     * Default value: ‘unbiased’.
+     * @returns The variance
+     */
+    variance(dim: number, normalization?: 'unbiased' | 'uncorrected' | 'biased'): MathJsChain;
     /**
      * Compute the variance of a matrix or a list with values. In case of a
      * (multi dimensional) array or matrix, the variance over all elements
@@ -4748,7 +4848,7 @@ declare namespace math {
      * Default value: ‘unbiased’.
      * @returns The variance
      */
-    variance(normalization?: 'unbiased' | 'uncorrected' | 'biased' | 'unbiased'): MathJsChain;
+    variance(normalization?: 'unbiased' | 'uncorrected' | 'biased'): MathJsChain;
 
     /*************************************************************************
      * String functions