mathjs-min 11.7.2

package/lib/cjs/function/set/setMultiplicity.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSetMultiplicity = void 0;
+var _array = require("../../utils/array.js");
+var _factory = require("../../utils/factory.js");
+var name = 'setMultiplicity';
+var dependencies = ['typed', 'size', 'subset', 'compareNatural', 'Index'];
+var createSetMultiplicity = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    size = _ref.size,
+    subset = _ref.subset,
+    compareNatural = _ref.compareNatural,
+    Index = _ref.Index;
+  /**
+   * Count the multiplicity of an element in a multiset.
+   * A multi-dimension array will be converted to a single-dimension array before the operation.
+   *
+   * Syntax:
+   *
+   *    math.setMultiplicity(element, set)
+   *
+   * Examples:
+   *
+   *    math.setMultiplicity(1, [1, 2, 2, 4])    // returns 1
+   *    math.setMultiplicity(2, [1, 2, 2, 4])    // returns 2
+   *
+   * See also:
+   *
+   *    setDistinct, setSize
+   *
+   * @param {number | BigNumber | Fraction | Complex} e  An element in the multiset
+   * @param {Array | Matrix}     a  A multiset
+   * @return {number}            The number of how many times the multiset contains the element
+   */
+  return typed(name, {
+    'number | BigNumber | Fraction | Complex, Array | Matrix': function numberBigNumberFractionComplexArrayMatrix(e, a) {
+      if (subset(size(a), new Index(0)) === 0) {
+        // if empty, return 0
+        return 0;
+      }
+      var b = (0, _array.flatten)(Array.isArray(a) ? a : a.toArray());
+      var count = 0;
+      for (var i = 0; i < b.length; i++) {
+        if (compareNatural(b[i], e) === 0) {
+          count++;
+        }
+      }
+      return count;
+    }
+  });
+});
+exports.createSetMultiplicity = createSetMultiplicity;

package/lib/cjs/function/set/setPowerset.js

@@ -0,0 +1,80 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSetPowerset = void 0;
+var _array = require("../../utils/array.js");
+var _factory = require("../../utils/factory.js");
+var name = 'setPowerset';
+var dependencies = ['typed', 'size', 'subset', 'compareNatural', 'Index'];
+var createSetPowerset = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    size = _ref.size,
+    subset = _ref.subset,
+    compareNatural = _ref.compareNatural,
+    Index = _ref.Index;
+  /**
+   * Create the powerset of a (multi)set. (The powerset contains very possible subsets of a (multi)set.)
+   * A multi-dimension array will be converted to a single-dimension array before the operation.
+   *
+   * Syntax:
+   *
+   *    math.setPowerset(set)
+   *
+   * Examples:
+   *
+   *    math.setPowerset([1, 2, 3])        // returns [[], [1], [2], [3], [1, 2], [1, 3], [2, 3], [1, 2, 3]]
+   *
+   * See also:
+   *
+   *    setCartesian
+   *
+   * @param {Array | Matrix}    a  A (multi)set
+   * @return {Array}    The powerset of the (multi)set
+   */
+  return typed(name, {
+    'Array | Matrix': function ArrayMatrix(a) {
+      if (subset(size(a), new Index(0)) === 0) {
+        // if empty, return empty
+        return [];
+      }
+      var b = (0, _array.flatten)(Array.isArray(a) ? a : a.toArray()).sort(compareNatural);
+      var result = [];
+      var number = 0;
+      while (number.toString(2).length <= b.length) {
+        result.push(_subset(b, number.toString(2).split('').reverse()));
+        number++;
+      }
+      // can not return a matrix, because of the different size of the subarrays
+      return _sort(result);
+    }
+  });
+
+  // create subset
+  function _subset(array, bitarray) {
+    var result = [];
+    for (var i = 0; i < bitarray.length; i++) {
+      if (bitarray[i] === '1') {
+        result.push(array[i]);
+      }
+    }
+    return result;
+  }
+
+  // sort subsests by length
+  function _sort(array) {
+    var temp = [];
+    for (var i = array.length - 1; i > 0; i--) {
+      for (var j = 0; j < i; j++) {
+        if (array[j].length > array[j + 1].length) {
+          temp = array[j];
+          array[j] = array[j + 1];
+          array[j + 1] = temp;
+        }
+      }
+    }
+    return array;
+  }
+});
+exports.createSetPowerset = createSetPowerset;

package/lib/cjs/function/set/setSize.js

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSetSize = void 0;
+var _array = require("../../utils/array.js");
+var _factory = require("../../utils/factory.js");
+var name = 'setSize';
+var dependencies = ['typed', 'compareNatural'];
+var createSetSize = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    compareNatural = _ref.compareNatural;
+  /**
+   * Count the number of elements of a (multi)set. When a second parameter is 'true', count only the unique values.
+   * A multi-dimension array will be converted to a single-dimension array before the operation.
+   *
+   * Syntax:
+   *
+   *    math.setSize(set)
+   *    math.setSize(set, unique)
+   *
+   * Examples:
+   *
+   *    math.setSize([1, 2, 2, 4])          // returns 4
+   *    math.setSize([1, 2, 2, 4], true)    // returns 3
+   *
+   * See also:
+   *
+   *    setUnion, setIntersect, setDifference
+   *
+   * @param {Array | Matrix} a  A multiset
+   * @param {boolean} [unique]  If true, only the unique values are counted. False by default
+   * @return {number}           The number of elements of the (multi)set
+   */
+  return typed(name, {
+    'Array | Matrix': function ArrayMatrix(a) {
+      return Array.isArray(a) ? (0, _array.flatten)(a).length : (0, _array.flatten)(a.toArray()).length;
+    },
+    'Array | Matrix, boolean': function ArrayMatrixBoolean(a, unique) {
+      if (unique === false || a.length === 0) {
+        return Array.isArray(a) ? (0, _array.flatten)(a).length : (0, _array.flatten)(a.toArray()).length;
+      } else {
+        var b = (0, _array.flatten)(Array.isArray(a) ? a : a.toArray()).sort(compareNatural);
+        var count = 1;
+        for (var i = 1; i < b.length; i++) {
+          if (compareNatural(b[i], b[i - 1]) !== 0) {
+            count++;
+          }
+        }
+        return count;
+      }
+    }
+  });
+});
+exports.createSetSize = createSetSize;

package/lib/cjs/function/set/setSymDifference.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSetSymDifference = void 0;
+var _array = require("../../utils/array.js");
+var _factory = require("../../utils/factory.js");
+var name = 'setSymDifference';
+var dependencies = ['typed', 'size', 'concat', 'subset', 'setDifference', 'Index'];
+var createSetSymDifference = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    size = _ref.size,
+    concat = _ref.concat,
+    subset = _ref.subset,
+    setDifference = _ref.setDifference,
+    Index = _ref.Index;
+  /**
+   * Create the symmetric difference of two (multi)sets.
+   * Multi-dimension arrays will be converted to single-dimension arrays before the operation.
+   *
+   * Syntax:
+   *
+   *    math.setSymDifference(set1, set2)
+   *
+   * Examples:
+   *
+   *    math.setSymDifference([1, 2, 3, 4], [3, 4, 5, 6])            // returns [1, 2, 5, 6]
+   *    math.setSymDifference([[1, 2], [3, 4]], [[3, 4], [5, 6]])    // returns [1, 2, 5, 6]
+   *
+   * See also:
+   *
+   *    setUnion, setIntersect, setDifference
+   *
+   * @param {Array | Matrix}    a1  A (multi)set
+   * @param {Array | Matrix}    a2  A (multi)set
+   * @return {Array | Matrix}    The symmetric difference of two (multi)sets
+   */
+  return typed(name, {
+    'Array | Matrix, Array | Matrix': function ArrayMatrixArrayMatrix(a1, a2) {
+      if (subset(size(a1), new Index(0)) === 0) {
+        // if any of them is empty, return the other one
+        return (0, _array.flatten)(a2);
+      } else if (subset(size(a2), new Index(0)) === 0) {
+        return (0, _array.flatten)(a1);
+      }
+      var b1 = (0, _array.flatten)(a1);
+      var b2 = (0, _array.flatten)(a2);
+      return concat(setDifference(b1, b2), setDifference(b2, b1));
+    }
+  });
+});
+exports.createSetSymDifference = createSetSymDifference;

package/lib/cjs/function/set/setUnion.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSetUnion = void 0;
+var _array = require("../../utils/array.js");
+var _factory = require("../../utils/factory.js");
+var name = 'setUnion';
+var dependencies = ['typed', 'size', 'concat', 'subset', 'setIntersect', 'setSymDifference', 'Index'];
+var createSetUnion = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    size = _ref.size,
+    concat = _ref.concat,
+    subset = _ref.subset,
+    setIntersect = _ref.setIntersect,
+    setSymDifference = _ref.setSymDifference,
+    Index = _ref.Index;
+  /**
+   * Create the union of two (multi)sets.
+   * Multi-dimension arrays will be converted to single-dimension arrays before the operation.
+   *
+   * Syntax:
+   *
+   *    math.setUnion(set1, set2)
+   *
+   * Examples:
+   *
+   *    math.setUnion([1, 2, 3, 4], [3, 4, 5, 6])            // returns [1, 2, 3, 4, 5, 6]
+   *    math.setUnion([[1, 2], [3, 4]], [[3, 4], [5, 6]])    // returns [1, 2, 3, 4, 5, 6]
+   *
+   * See also:
+   *
+   *    setIntersect, setDifference
+   *
+   * @param {Array | Matrix}    a1  A (multi)set
+   * @param {Array | Matrix}    a2  A (multi)set
+   * @return {Array | Matrix}    The union of two (multi)sets
+   */
+  return typed(name, {
+    'Array | Matrix, Array | Matrix': function ArrayMatrixArrayMatrix(a1, a2) {
+      if (subset(size(a1), new Index(0)) === 0) {
+        // if any of them is empty, return the other one
+        return (0, _array.flatten)(a2);
+      } else if (subset(size(a2), new Index(0)) === 0) {
+        return (0, _array.flatten)(a1);
+      }
+      var b1 = (0, _array.flatten)(a1);
+      var b2 = (0, _array.flatten)(a2);
+      return concat(setSymDifference(b1, b2), setIntersect(b1, b2));
+    }
+  });
+});
+exports.createSetUnion = createSetUnion;

package/lib/cjs/function/special/erf.js

@@ -0,0 +1,161 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createErf = void 0;
+var _collection = require("../../utils/collection.js");
+var _number = require("../../utils/number.js");
+var _factory = require("../../utils/factory.js");
+/* eslint-disable no-loss-of-precision */
+
+var name = 'erf';
+var dependencies = ['typed'];
+var createErf = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed;
+  /**
+   * Compute the erf function of a value using a rational Chebyshev
+   * approximations for different intervals of x.
+   *
+   * This is a translation of W. J. Cody's Fortran implementation from 1987
+   * ( https://www.netlib.org/specfun/erf ). See the AMS publication
+   * "Rational Chebyshev Approximations for the Error Function" by W. J. Cody
+   * for an explanation of this process.
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * Syntax:
+   *
+   *    math.erf(x)
+   *
+   * Examples:
+   *
+   *    math.erf(0.2)    // returns 0.22270258921047847
+   *    math.erf(-0.5)   // returns -0.5204998778130465
+   *    math.erf(4)      // returns 0.9999999845827421
+   *
+   * @param {number | Array | Matrix} x   A real number
+   * @return {number | Array | Matrix}    The erf of `x`
+   */
+  return typed('name', {
+    number: function number(x) {
+      var y = Math.abs(x);
+      if (y >= MAX_NUM) {
+        return (0, _number.sign)(x);
+      }
+      if (y <= THRESH) {
+        return (0, _number.sign)(x) * erf1(y);
+      }
+      if (y <= 4.0) {
+        return (0, _number.sign)(x) * (1 - erfc2(y));
+      }
+      return (0, _number.sign)(x) * (1 - erfc3(y));
+    },
+    'Array | Matrix': typed.referToSelf(function (self) {
+      return function (n) {
+        return (0, _collection.deepMap)(n, self);
+      };
+    })
+
+    // TODO: For complex numbers, use the approximation for the Faddeeva function
+    //  from "More Efficient Computation of the Complex Error Function" (AMS)
+  });
+
+  /**
+   * Approximates the error function erf() for x <= 0.46875 using this function:
+   *               n
+   * erf(x) = x * sum (p_j * x^(2j)) / (q_j * x^(2j))
+   *              j=0
+   */
+  function erf1(y) {
+    var ysq = y * y;
+    var xnum = P[0][4] * ysq;
+    var xden = ysq;
+    var i;
+    for (i = 0; i < 3; i += 1) {
+      xnum = (xnum + P[0][i]) * ysq;
+      xden = (xden + Q[0][i]) * ysq;
+    }
+    return y * (xnum + P[0][3]) / (xden + Q[0][3]);
+  }
+
+  /**
+   * Approximates the complement of the error function erfc() for
+   * 0.46875 <= x <= 4.0 using this function:
+   *                       n
+   * erfc(x) = e^(-x^2) * sum (p_j * x^j) / (q_j * x^j)
+   *                      j=0
+   */
+  function erfc2(y) {
+    var xnum = P[1][8] * y;
+    var xden = y;
+    var i;
+    for (i = 0; i < 7; i += 1) {
+      xnum = (xnum + P[1][i]) * y;
+      xden = (xden + Q[1][i]) * y;
+    }
+    var result = (xnum + P[1][7]) / (xden + Q[1][7]);
+    var ysq = parseInt(y * 16) / 16;
+    var del = (y - ysq) * (y + ysq);
+    return Math.exp(-ysq * ysq) * Math.exp(-del) * result;
+  }
+
+  /**
+   * Approximates the complement of the error function erfc() for x > 4.0 using
+   * this function:
+   *
+   * erfc(x) = (e^(-x^2) / x) * [ 1/sqrt(pi) +
+   *               n
+   *    1/(x^2) * sum (p_j * x^(-2j)) / (q_j * x^(-2j)) ]
+   *              j=0
+   */
+  function erfc3(y) {
+    var ysq = 1 / (y * y);
+    var xnum = P[2][5] * ysq;
+    var xden = ysq;
+    var i;
+    for (i = 0; i < 4; i += 1) {
+      xnum = (xnum + P[2][i]) * ysq;
+      xden = (xden + Q[2][i]) * ysq;
+    }
+    var result = ysq * (xnum + P[2][4]) / (xden + Q[2][4]);
+    result = (SQRPI - result) / y;
+    ysq = parseInt(y * 16) / 16;
+    var del = (y - ysq) * (y + ysq);
+    return Math.exp(-ysq * ysq) * Math.exp(-del) * result;
+  }
+});
+
+/**
+ * Upper bound for the first approximation interval, 0 <= x <= THRESH
+ * @constant
+ */
+exports.createErf = createErf;
+var THRESH = 0.46875;
+
+/**
+ * Constant used by W. J. Cody's Fortran77 implementation to denote sqrt(pi)
+ * @constant
+ */
+var SQRPI = 5.6418958354775628695e-1;
+
+/**
+ * Coefficients for each term of the numerator sum (p_j) for each approximation
+ * interval (see W. J. Cody's paper for more details)
+ * @constant
+ */
+var P = [[3.16112374387056560e00, 1.13864154151050156e02, 3.77485237685302021e02, 3.20937758913846947e03, 1.85777706184603153e-1], [5.64188496988670089e-1, 8.88314979438837594e00, 6.61191906371416295e01, 2.98635138197400131e02, 8.81952221241769090e02, 1.71204761263407058e03, 2.05107837782607147e03, 1.23033935479799725e03, 2.15311535474403846e-8], [3.05326634961232344e-1, 3.60344899949804439e-1, 1.25781726111229246e-1, 1.60837851487422766e-2, 6.58749161529837803e-4, 1.63153871373020978e-2]];
+
+/**
+ * Coefficients for each term of the denominator sum (q_j) for each approximation
+ * interval (see W. J. Cody's paper for more details)
+ * @constant
+ */
+var Q = [[2.36012909523441209e01, 2.44024637934444173e02, 1.28261652607737228e03, 2.84423683343917062e03], [1.57449261107098347e01, 1.17693950891312499e02, 5.37181101862009858e02, 1.62138957456669019e03, 3.29079923573345963e03, 4.36261909014324716e03, 3.43936767414372164e03, 1.23033935480374942e03], [2.56852019228982242e00, 1.87295284992346047e00, 5.27905102951428412e-1, 6.05183413124413191e-2, 2.33520497626869185e-3]];
+
+/**
+ * Maximum/minimum safe numbers to input to erf() (in ES6+, this number is
+ * Number.[MAX|MIN]_SAFE_INTEGER). erf() for all numbers beyond this limit will
+ * return 1
+ */
+var MAX_NUM = Math.pow(2, 53);

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

@@ -0,0 +1,128 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCumSum = void 0;
+var _collection = require("../../utils/collection.js");
+var _factory = require("../../utils/factory.js");
+var _switch2 = require("../../utils/switch.js");
+var _improveErrorMessage = require("./utils/improveErrorMessage.js");
+var _array = require("../../utils/array.js");
+var _IndexError = require("../../error/IndexError.js");
+var name = 'cumsum';
+var dependencies = ['typed', 'add', 'unaryPlus'];
+var createCumSum = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    add = _ref.add,
+    unaryPlus = _ref.unaryPlus;
+  /**
+   * 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 ((0, _collection.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 (0, _improveErrorMessage.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 = (0, _array.arraySize)(array);
+    if (dim < 0 || dim >= size.length) {
+      // TODO: would be more clear when throwing a DimensionError here
+      throw new _IndexError.IndexError(dim, size.length);
+    }
+    try {
+      return _cumsumDimensional(array, dim);
+    } catch (err) {
+      throw (0, _improveErrorMessage.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 = (0, _switch2._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;
+    }
+  }
+});
+exports.createCumSum = createCumSum;

package/lib/cjs/function/statistics/mad.js

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMad = void 0;
+var _array = require("../../utils/array.js");
+var _factory = require("../../utils/factory.js");
+var _improveErrorMessage = require("./utils/improveErrorMessage.js");
+var name = 'mad';
+var dependencies = ['typed', 'abs', 'map', 'median', 'subtract'];
+var createMad = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    abs = _ref.abs,
+    map = _ref.map,
+    median = _ref.median,
+    subtract = _ref.subtract;
+  /**
+   * Compute the median absolute deviation of a matrix or a list with values.
+   * The median absolute deviation is defined as the median of the absolute
+   * deviations from the median.
+   *
+   * Syntax:
+   *
+   *     math.mad(a, b, c, ...)
+   *     math.mad(A)
+   *
+   * Examples:
+   *
+   *     math.mad(10, 20, 30)             // returns 10
+   *     math.mad([1, 2, 3])              // returns 1
+   *     math.mad([[1, 2, 3], [4, 5, 6]]) // returns 1.5
+   *
+   * See also:
+   *
+   *     median, mean, std, abs
+   *
+   * @param {Array | Matrix} array
+   *                        A single matrix or multiple scalar values.
+   * @return {*} The median absolute deviation.
+   */
+  return typed(name, {
+    // mad([a, b, c, d, ...])
+    'Array | Matrix': _mad,
+    // mad(a, b, c, d, ...)
+    '...': function _(args) {
+      return _mad(args);
+    }
+  });
+  function _mad(array) {
+    array = (0, _array.flatten)(array.valueOf());
+    if (array.length === 0) {
+      throw new Error('Cannot calculate median absolute deviation (mad) of an empty array');
+    }
+    try {
+      var med = median(array);
+      return median(map(array, function (value) {
+        return abs(subtract(value, med));
+      }));
+    } catch (err) {
+      if (err instanceof TypeError && err.message.indexOf('median') !== -1) {
+        throw new TypeError(err.message.replace('median', 'mad'));
+      } else {
+        throw (0, _improveErrorMessage.improveErrorMessage)(err, 'mad');
+      }
+    }
+  }
+});
+exports.createMad = createMad;