mathjs 11.9.1 → 11.10.0

package/lib/esm/type/matrix/utils/broadcast.js

@@ -1,3 +1,4 @@
+import { checkBroadcastingRules } from '../../../utils/array.js';
 import { factory } from '../../../utils/factory.js';
 var name = 'broadcast';
 var dependancies = ['concat'];
@@ -32,10 +33,8 @@ export var createBroadcast = /* #__PURE__ */factory(name, dependancies, _ref =>
     }
 
     // check if the broadcasting rules applyes for both matrices
-    for (var _dim = 0; _dim < N; _dim++) {
-      _checkRules(sizeA, sizeMax, _dim);
-      _checkRules(sizeB, sizeMax, _dim);
-    }
+    checkBroadcastingRules(sizeA, sizeMax);
+    checkBroadcastingRules(sizeB, sizeMax);
 
     // reshape A or B if needed to make them ready for concat
     var AA = A.clone();
@@ -47,12 +46,12 @@ export var createBroadcast = /* #__PURE__ */factory(name, dependancies, _ref =>
     }
 
     // stretches the matrices on each dimension to make them the same size
-    for (var _dim2 = 0; _dim2 < N; _dim2++) {
-      if (AA._size[_dim2] < sizeMax[_dim2]) {
-        AA = _stretch(AA, sizeMax[_dim2], _dim2);
+    for (var _dim = 0; _dim < N; _dim++) {
+      if (AA._size[_dim] < sizeMax[_dim]) {
+        AA = _stretch(AA, sizeMax[_dim], _dim);
       }
-      if (BB._size[_dim2] < sizeMax[_dim2]) {
-        BB = _stretch(BB, sizeMax[_dim2], _dim2);
+      if (BB._size[_dim] < sizeMax[_dim]) {
+        BB = _stretch(BB, sizeMax[_dim], _dim);
       }
     }
 
@@ -67,9 +66,4 @@ export var createBroadcast = /* #__PURE__ */factory(name, dependancies, _ref =>
     // stretches a matrix up to a certain size in a certain dimension
     return concat(...Array(sizeToStretch).fill(arrayToStretch), dimToStretch);
   }
-  function _checkRules(shape, sizeMax, dim) {
-    if (shape[dim] < sizeMax[dim] & shape[dim] > 1) {
-      throw new Error("shape missmatch: missmatch is found in arg with shape (".concat(shape, ") not possible to broadcast dimension ").concat(dim, " with size ").concat(shape[dim], " to size ").concat(sizeMax[dim]));
-    }
-  }
 });

package/lib/esm/utils/array.js

@@ -1,8 +1,10 @@
+import _extends from "@babel/runtime/helpers/extends";
 import { isInteger } from './number.js';
-import { isNumber } from './is.js';
+import { isNumber, isBigNumber, isArray, isString } from './is.js';
 import { format } from './string.js';
 import { DimensionError } from '../error/DimensionError.js';
 import { IndexError } from '../error/IndexError.js';
+import { deepStrictEqual } from './object.js';
 
 /**
  * Calculate the size of a multi dimensional array.
@@ -75,6 +77,23 @@ export function validate(array, size) {
   }
 }
 
+/**
+ * Validate whether the source of the index matches the size of the Array
+ * @param {Array | Matrix} array    Array to be validated
+ * @param {Index} index  Index with the source information to validate
+ * @throws DimensionError
+ */
+export function validateIndexSourceSize(value, index) {
+  var valueSize = value.isMatrix ? value._size : arraySize(value);
+  var sourceSize = index._sourceSize;
+  // checks if the source size is not null and matches the valueSize
+  sourceSize.forEach((sourceDim, i) => {
+    if (sourceDim !== null && sourceDim !== valueSize[i]) {
+      throw new DimensionError(sourceDim, valueSize[i]);
+    }
+  });
+}
+
 /**
  * Test whether index is an integer number with index >= 0 and index < length
  * when length is provided
@@ -82,18 +101,44 @@ export function validate(array, size) {
  * @param {number} [length] Length of the array
  */
 export function validateIndex(index, length) {
-  if (!isNumber(index) || !isInteger(index)) {
-    throw new TypeError('Index must be an integer (value: ' + index + ')');
+  if (index !== undefined) {
+    if (!isNumber(index) || !isInteger(index)) {
+      throw new TypeError('Index must be an integer (value: ' + index + ')');
+    }
+    if (index < 0 || typeof length === 'number' && index >= length) {
+      throw new IndexError(index, length);
+    }
   }
-  if (index < 0 || typeof length === 'number' && index >= length) {
-    throw new IndexError(index, length);
+}
+
+/**
+ * Test if and index has empty values
+ * @param {number} index    Zero-based index
+ */
+export function isEmptyIndex(index) {
+  for (var i = 0; i < index._dimensions.length; ++i) {
+    var dimension = index._dimensions[i];
+    if (dimension._data && isArray(dimension._data)) {
+      if (dimension._size[0] === 0) {
+        return true;
+      }
+    } else if (dimension.isRange) {
+      if (dimension.start === dimension.end) {
+        return true;
+      }
+    } else if (isString(dimension)) {
+      if (dimension.length === 0) {
+        return true;
+      }
+    }
   }
+  return false;
 }
 
 /**
  * Resize a multi dimensional array. The resized array is returned.
- * @param {Array} array         Array to be resized
- * @param {Array.<number>} size Array with the size of each dimension
+ * @param {Array | number} array         Array to be resized
+ * @param {number[]} size Array with the size of each dimension
  * @param {*} [defaultValue=0]  Value to be filled in in new entries,
  *                              zero by default. Specify for example `null`,
  *                              to clearly see entries that are not explicitly
@@ -101,10 +146,8 @@ export function validateIndex(index, length) {
  * @return {Array} array         The resized array
  */
 export function resize(array, size, defaultValue) {
-  // TODO: add support for scalars, having size=[] ?
-
   // check the type of the arguments
-  if (!Array.isArray(array) || !Array.isArray(size)) {
+  if (!Array.isArray(size)) {
     throw new TypeError('Array expected');
   }
   if (size.length === 0) {
@@ -118,6 +161,11 @@ export function resize(array, size, defaultValue) {
     }
   });
 
+  // convert number to an array
+  if (isNumber(array) || isBigNumber(array)) {
+    array = [array];
+  }
+
   // recursively resize the array
   var _defaultValue = defaultValue !== undefined ? defaultValue : 0;
   _resize(array, size, 0, _defaultValue);
@@ -186,7 +234,7 @@ function _resize(array, size, dim, defaultValue) {
 /**
  * Re-shape a multi dimensional array to fit the specified dimensions
  * @param {Array} array           Array to be reshaped
- * @param {Array.<number>} sizes  List of sizes for each dimension
+ * @param {number[]} sizes        List of sizes for each dimension
  * @returns {Array}               Array whose data has been formatted to fit the
  *                                specified dimensions
  *
@@ -219,10 +267,10 @@ export function reshape(array, sizes) {
 
 /**
  * Replaces the wildcard -1 in the sizes array.
- * @param {Array.<number>} sizes  List of sizes for each dimension. At most on wildcard.
+ * @param {number[]} sizes  List of sizes for each dimension. At most on wildcard.
  * @param {number} currentLength  Number of elements in the array.
  * @throws {Error}                If more than one wildcard or unable to replace it.
- * @returns {Array.<number>}      The sizes array with wildcard replaced.
+ * @returns {number[]}      The sizes array with wildcard replaced.
  */
 export function processSizesWildcard(sizes, currentLength) {
   var newLength = product(sizes);
@@ -247,7 +295,7 @@ export function processSizesWildcard(sizes, currentLength) {
 
 /**
  * Computes the product of all array elements.
- * @param {Array<number>} array Array of factors
+ * @param {number[]} array Array of factors
  * @returns {number}            Product of all elements
  */
 function product(array) {
@@ -257,7 +305,7 @@ function product(array) {
 /**
  * Iteratively re-shape a multi dimensional array to fit the specified dimensions
  * @param {Array} array           Array to be reshaped
- * @param {Array.<number>} sizes  List of sizes for each dimension
+ * @param {number[]} sizes  List of sizes for each dimension
  * @returns {Array}               Array whose data has been formatted to fit the
  *                                specified dimensions
  */
@@ -528,18 +576,18 @@ export function getArrayDataType(array, typeOf) {
 
   for (var i = 0; i < array.length; i++) {
     var item = array[i];
-    var isArray = Array.isArray(item);
+    var _isArray = Array.isArray(item);
 
     // Saving the target matrix row size
-    if (i === 0 && isArray) {
+    if (i === 0 && _isArray) {
       length = item.length;
     }
 
     // If the current item is an array but the length does not equal the targetVectorSize
-    if (isArray && item.length !== length) {
+    if (_isArray && item.length !== length) {
       return undefined;
     }
-    var itemType = isArray ? getArrayDataType(item, typeOf) // recurse into a nested array
+    var itemType = _isArray ? getArrayDataType(item, typeOf) // recurse into a nested array
     : typeOf(item);
     if (type === undefined) {
       type = itemType; // first item
@@ -554,7 +602,7 @@ export function getArrayDataType(array, typeOf) {
 
 /**
  * Return the last item from an array
- * @param array
+ * @param {array}
  * @returns {*}
  */
 export function last(array) {
@@ -563,6 +611,8 @@ export function last(array) {
 
 /**
  * Get all but the last element of array.
+ * @param {array}
+ * @returns {*}
  */
 export function initial(array) {
   return array.slice(0, array.length - 1);
@@ -576,4 +626,175 @@ export function initial(array) {
  */
 export function contains(array, item) {
   return array.indexOf(item) !== -1;
+}
+
+/**
+ * Recursively concatenate two matrices.
+ * The contents of the matrices is not cloned.
+ * @param {Array} a             Multi dimensional array
+ * @param {Array} b             Multi dimensional array
+ * @param {number} concatDim    The dimension on which to concatenate (zero-based)
+ * @param {number} dim          The current dim (zero-based)
+ * @return {Array} c            The concatenated matrix
+ * @private
+ */
+function concatRecursive(a, b, concatDim, dim) {
+  if (dim < concatDim) {
+    // recurse into next dimension
+    if (a.length !== b.length) {
+      throw new DimensionError(a.length, b.length);
+    }
+    var c = [];
+    for (var i = 0; i < a.length; i++) {
+      c[i] = concatRecursive(a[i], b[i], concatDim, dim + 1);
+    }
+    return c;
+  } else {
+    // concatenate this dimension
+    return a.concat(b);
+  }
+}
+
+/**
+ * Concatenates many arrays in the specified direction
+ * @param {...Array} arrays All the arrays to concatenate
+ * @param {number} concatDim The dimension on which to concatenate (zero-based)
+ * @returns
+*/
+export function concat() {
+  var arrays = Array.prototype.slice.call(arguments, 0, -1);
+  var concatDim = Array.prototype.slice.call(arguments, -1);
+  if (arrays.length === 1) {
+    return arrays[0];
+  }
+  if (arrays.length > 1) {
+    return arrays.slice(1).reduce(function (A, B) {
+      return concatRecursive(A, B, concatDim, 0);
+    }, arrays[0]);
+  } else {
+    throw new Error('Wrong number of arguments in function concat');
+  }
+}
+
+/**
+ * Receives two or more sizes and get's the broadcasted size for both.
+ * @param  {...number[]} sizes Sizes to broadcast together
+ * @returns
+ */
+export function broadcastSizes() {
+  for (var _len = arguments.length, sizes = new Array(_len), _key = 0; _key < _len; _key++) {
+    sizes[_key] = arguments[_key];
+  }
+  var dimensions = sizes.map(s => s.length);
+  var N = Math.max(...dimensions);
+  var sizeMax = new Array(N).fill(null);
+  // check for every size
+  for (var i = 0; i < sizes.length; i++) {
+    var size = sizes[i];
+    var dim = dimensions[i];
+    for (var j = 0; j < dim; j++) {
+      var n = N - dim + j;
+      if (size[j] > sizeMax[n]) {
+        sizeMax[n] = size[j];
+      }
+    }
+  }
+  for (var _i = 0; _i < sizes.length; _i++) {
+    checkBroadcastingRules(sizes[_i], sizeMax);
+  }
+  return sizeMax;
+}
+
+/**
+ * Checks if it's possible to broadcast a size to another size
+ * @param {number[]} size The size of the array to check
+ * @param {number[]} toSize The size of the array to validate if it can be broadcasted to
+ */
+export function checkBroadcastingRules(size, toSize) {
+  var N = toSize.length;
+  var dim = size.length;
+  for (var j = 0; j < dim; j++) {
+    var n = N - dim + j;
+    if (size[j] < toSize[n] && size[j] > 1 || size[j] > toSize[n]) {
+      throw new Error("shape missmatch: missmatch is found in arg with shape (".concat(size, ") not possible to broadcast dimension ").concat(dim, " with size ").concat(size[j], " to size ").concat(toSize[n]));
+    }
+  }
+}
+
+/**
+ * Broadcasts a single array to a certain size
+ * @param {array} array Array to be broadcasted
+ * @param {number[]} toSize Size to broadcast the array
+ * @returns The broadcasted array
+ */
+export function broadcastTo(array, toSize) {
+  var Asize = arraySize(array);
+  if (deepStrictEqual(Asize, toSize)) {
+    return array;
+  }
+  checkBroadcastingRules(Asize, toSize);
+  var broadcastedSize = broadcastSizes(Asize, toSize);
+  var N = broadcastedSize.length;
+  var paddedSize = [...Array(N - Asize.length).fill(1), ...Asize];
+  var A = clone(array);
+  // reshape A if needed to make it ready for concat
+  if (Asize.length < N) {
+    A = reshape(A, paddedSize);
+    Asize = arraySize(A);
+  }
+
+  // stretches the array on each dimension to make it the same size as index
+  for (var dim = 0; dim < N; dim++) {
+    if (Asize[dim] < broadcastedSize[dim]) {
+      A = stretch(A, broadcastedSize[dim], dim);
+      Asize = arraySize(A);
+    }
+  }
+  return A;
+}
+
+/**
+ * Broadcasts arrays and returns the broadcasted arrays in an array
+ * @param  {...Array | any} arrays
+ * @returns
+ */
+export function broadcastArrays() {
+  for (var _len2 = arguments.length, arrays = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+    arrays[_key2] = arguments[_key2];
+  }
+  if (arrays.length === 0) {
+    throw new Error('Insuficient number of argumnets in function broadcastArrays');
+  }
+  if (arrays.length === 1) {
+    return arrays[0];
+  }
+  var sizes = arrays.map(function (array) {
+    return arraySize(array);
+  });
+  var broadcastedSize = broadcastSizes(...sizes);
+  var broadcastedArrays = [];
+  arrays.forEach(function (array) {
+    broadcastedArrays.push(broadcastTo(array, broadcastedSize));
+  });
+  return broadcastedArrays;
+}
+
+/**
+ * stretches a matrix up to a certain size in a certain dimension
+ * @param {Array} arrayToStretch
+ * @param {number[]} sizeToStretch
+ * @param {number} dimToStretch
+ * @returns
+ */
+export function stretch(arrayToStretch, sizeToStretch, dimToStretch) {
+  return concat(...Array(sizeToStretch).fill(arrayToStretch), dimToStretch);
+}
+
+/**
+ * Deep clones a multidimensional array
+ * @param {Array} array
+ * @returns cloned array
+ */
+export function clone(array) {
+  return _extends([], array);
 }

package/lib/esm/version.js

@@ -1,3 +1,3 @@
-export var version = '11.9.1';
+export var version = '11.10.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.9.1",
+  "version": "11.10.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",

package/types/index.d.ts

@@ -2600,6 +2600,14 @@ declare namespace math {
      */
     erf<T extends number | MathCollection>(x: T): NoLiteralType<T>
 
+    /**
+     * Compute the Riemann Zeta function of a value using an infinite series
+     * and Riemann's Functional equation.
+     * @param s A real, complex or BigNumber
+     * @returns The Riemann Zeta of s
+     */
+    zeta<T extends number | Complex | BigNumber>(s: T): T
+
     /*************************************************************************
      * Statistics functions
      ************************************************************************/
@@ -5977,6 +5985,14 @@ declare namespace math {
       this: MathJsChain<T>
     ): MathJsChain<NoLiteralType<T>>
 
+    /**
+     * Compute the Riemann Zeta function of a value using an infinite series
+     * and Riemann's Functional equation.
+     */
+    zeta<T extends number | Complex | BigNumber>(
+      this: MathJsChain<T>
+    ): MathJsChain<T>
+
     /*************************************************************************
      * Statistics functions
      ************************************************************************/