simple-squiggle

A restricted subset of Squiggle
Log | Files | Refs | README

mean.js (2768B)

      1 import { containsCollections, deepForEach, reduce } from '../../utils/collection.js';
      2 import { arraySize } from '../../utils/array.js';
      3 import { factory } from '../../utils/factory.js';
      4 import { improveErrorMessage } from './utils/improveErrorMessage.js';
      5 var name = 'mean';
      6 var dependencies = ['typed', 'add', 'divide'];
      7 export var createMean = /* #__PURE__ */factory(name, dependencies, _ref => {
      8   var {
      9     typed,
     10     add,
     11     divide
     12   } = _ref;
     13 
     14   /**
     15    * Compute the mean value of matrix or a list with values.
     16    * In case of a multi dimensional array, the mean of the flattened array
     17    * will be calculated. When `dim` is provided, the maximum over the selected
     18    * dimension will be calculated. Parameter `dim` is zero-based.
     19    *
     20    * Syntax:
     21    *
     22    *     math.mean(a, b, c, ...)
     23    *     math.mean(A)
     24    *     math.mean(A, dim)
     25    *
     26    * Examples:
     27    *
     28    *     math.mean(2, 1, 4, 3)                     // returns 2.5
     29    *     math.mean([1, 2.7, 3.2, 4])               // returns 2.725
     30    *
     31    *     math.mean([[2, 5], [6, 3], [1, 7]], 0)    // returns [3, 5]
     32    *     math.mean([[2, 5], [6, 3], [1, 7]], 1)    // returns [3.5, 4.5, 4]
     33    *
     34    * See also:
     35    *
     36    *     median, min, max, sum, prod, std, variance
     37    *
     38    * @param {... *} args  A single matrix or or multiple scalar values
     39    * @return {*} The mean of all values
     40    */
     41   return typed(name, {
     42     // mean([a, b, c, d, ...])
     43     'Array | Matrix': _mean,
     44     // mean([a, b, c, d, ...], dim)
     45     'Array | Matrix, number | BigNumber': _nmeanDim,
     46     // mean(a, b, c, d, ...)
     47     '...': function _(args) {
     48       if (containsCollections(args)) {
     49         throw new TypeError('Scalar values expected in function mean');
     50       }
     51 
     52       return _mean(args);
     53     }
     54   });
     55   /**
     56    * Calculate the mean value in an n-dimensional array, returning a
     57    * n-1 dimensional array
     58    * @param {Array} array
     59    * @param {number} dim
     60    * @return {number} mean
     61    * @private
     62    */
     63 
     64   function _nmeanDim(array, dim) {
     65     try {
     66       var sum = reduce(array, dim, add);
     67       var s = Array.isArray(array) ? arraySize(array) : array.size();
     68       return divide(sum, s[dim]);
     69     } catch (err) {
     70       throw improveErrorMessage(err, 'mean');
     71     }
     72   }
     73   /**
     74    * Recursively calculate the mean value in an n-dimensional array
     75    * @param {Array} array
     76    * @return {number} mean
     77    * @private
     78    */
     79 
     80 
     81   function _mean(array) {
     82     var sum;
     83     var num = 0;
     84     deepForEach(array, function (value) {
     85       try {
     86         sum = sum === undefined ? value : add(sum, value);
     87         num++;
     88       } catch (err) {
     89         throw improveErrorMessage(err, 'mean', value);
     90       }
     91     });
     92 
     93     if (num === 0) {
     94       throw new Error('Cannot calculate the mean of an empty array');
     95     }
     96 
     97     return divide(sum, num);
     98   }
     99 });