mathjs-min 11.7.2

package/lib/cjs/type/matrix/utils/matAlgo13xDD.js

@@ -0,0 +1,99 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMatAlgo13xDD = void 0;
+var _factory = require("../../../utils/factory.js");
+var _DimensionError = require("../../../error/DimensionError.js");
+var name = 'matAlgo13xDD';
+var dependencies = ['typed'];
+var createMatAlgo13xDD = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed;
+  /**
+   * Iterates over DenseMatrix items and invokes the callback function f(Aij..z, Bij..z).
+   * Callback function invoked MxN times.
+   *
+   * C(i,j,...z) = f(Aij..z, Bij..z)
+   *
+   * @param {Matrix}   a                 The DenseMatrix instance (A)
+   * @param {Matrix}   b                 The DenseMatrix instance (B)
+   * @param {Function} callback          The f(Aij..z,Bij..z) operation to invoke
+   *
+   * @return {Matrix}                    DenseMatrix (C)
+   *
+   * https://github.com/josdejong/mathjs/pull/346#issuecomment-97658658
+   */
+  return function matAlgo13xDD(a, b, callback) {
+    // a arrays
+    var adata = a._data;
+    var asize = a._size;
+    var adt = a._datatype;
+    // b arrays
+    var bdata = b._data;
+    var bsize = b._size;
+    var bdt = b._datatype;
+    // c arrays
+    var csize = [];
+
+    // validate dimensions
+    if (asize.length !== bsize.length) {
+      throw new _DimensionError.DimensionError(asize.length, bsize.length);
+    }
+
+    // validate each one of the dimension sizes
+    for (var s = 0; s < asize.length; s++) {
+      // must match
+      if (asize[s] !== bsize[s]) {
+        throw new RangeError('Dimension mismatch. Matrix A (' + asize + ') must match Matrix B (' + bsize + ')');
+      }
+      // update dimension in c
+      csize[s] = asize[s];
+    }
+
+    // datatype
+    var dt;
+    // callback signature to use
+    var cf = callback;
+
+    // process data types
+    if (typeof adt === 'string' && adt === bdt) {
+      // datatype
+      dt = adt;
+      // callback
+      cf = typed.find(callback, [dt, dt]);
+    }
+
+    // populate cdata, iterate through dimensions
+    var cdata = csize.length > 0 ? _iterate(cf, 0, csize, csize[0], adata, bdata) : [];
+
+    // c matrix
+    return a.createDenseMatrix({
+      data: cdata,
+      size: csize,
+      datatype: dt
+    });
+  };
+
+  // recursive function
+  function _iterate(f, level, s, n, av, bv) {
+    // initialize array for this level
+    var cv = [];
+    // check we reach the last level
+    if (level === s.length - 1) {
+      // loop arrays in last level
+      for (var i = 0; i < n; i++) {
+        // invoke callback and store value
+        cv[i] = f(av[i], bv[i]);
+      }
+    } else {
+      // iterate current level
+      for (var j = 0; j < n; j++) {
+        // iterate next level
+        cv[j] = _iterate(f, level + 1, s, s[level + 1], av[j], bv[j]);
+      }
+    }
+    return cv;
+  }
+});
+exports.createMatAlgo13xDD = createMatAlgo13xDD;

package/lib/cjs/type/matrix/utils/matAlgo14xDs.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMatAlgo14xDs = void 0;
+var _factory = require("../../../utils/factory.js");
+var _object = require("../../../utils/object.js");
+var name = 'matAlgo14xDs';
+var dependencies = ['typed'];
+var createMatAlgo14xDs = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed;
+  /**
+   * Iterates over DenseMatrix items and invokes the callback function f(Aij..z, b).
+   * Callback function invoked MxN times.
+   *
+   * C(i,j,...z) = f(Aij..z, b)
+   *
+   * @param {Matrix}   a                 The DenseMatrix instance (A)
+   * @param {Scalar}   b                 The Scalar value
+   * @param {Function} callback          The f(Aij..z,b) operation to invoke
+   * @param {boolean}  inverse           A true value indicates callback should be invoked f(b,Aij..z)
+   *
+   * @return {Matrix}                    DenseMatrix (C)
+   *
+   * https://github.com/josdejong/mathjs/pull/346#issuecomment-97659042
+   */
+  return function matAlgo14xDs(a, b, callback, inverse) {
+    // a arrays
+    var adata = a._data;
+    var asize = a._size;
+    var adt = a._datatype;
+
+    // datatype
+    var dt;
+    // callback signature to use
+    var cf = callback;
+
+    // process data types
+    if (typeof adt === 'string') {
+      // datatype
+      dt = adt;
+      // convert b to the same datatype
+      b = typed.convert(b, dt);
+      // callback
+      cf = typed.find(callback, [dt, dt]);
+    }
+
+    // populate cdata, iterate through dimensions
+    var cdata = asize.length > 0 ? _iterate(cf, 0, asize, asize[0], adata, b, inverse) : [];
+
+    // c matrix
+    return a.createDenseMatrix({
+      data: cdata,
+      size: (0, _object.clone)(asize),
+      datatype: dt
+    });
+  };
+
+  // recursive function
+  function _iterate(f, level, s, n, av, bv, inverse) {
+    // initialize array for this level
+    var cv = [];
+    // check we reach the last level
+    if (level === s.length - 1) {
+      // loop arrays in last level
+      for (var i = 0; i < n; i++) {
+        // invoke callback and store value
+        cv[i] = inverse ? f(bv, av[i]) : f(av[i], bv);
+      }
+    } else {
+      // iterate current level
+      for (var j = 0; j < n; j++) {
+        // iterate next level
+        cv[j] = _iterate(f, level + 1, s, s[level + 1], av[j], bv, inverse);
+      }
+    }
+    return cv;
+  }
+});
+exports.createMatAlgo14xDs = createMatAlgo14xDs;

package/lib/cjs/type/matrix/utils/matrixAlgorithmSuite.js

@@ -0,0 +1,223 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMatrixAlgorithmSuite = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _factory = require("../../../utils/factory.js");
+var _object = require("../../../utils/object.js");
+var _matAlgo13xDD = require("./matAlgo13xDD.js");
+var _matAlgo14xDs = require("./matAlgo14xDs.js");
+var _broadcast = require("./broadcast.js");
+var name = 'matrixAlgorithmSuite';
+var dependencies = ['typed', 'matrix', 'concat'];
+var createMatrixAlgorithmSuite = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    matrix = _ref.matrix,
+    concat = _ref.concat;
+  var matAlgo13xDD = (0, _matAlgo13xDD.createMatAlgo13xDD)({
+    typed: typed
+  });
+  var matAlgo14xDs = (0, _matAlgo14xDs.createMatAlgo14xDs)({
+    typed: typed
+  });
+  var broadcast = (0, _broadcast.createBroadcast)({
+    concat: concat
+  });
+
+  /**
+   * Return a signatures object with the usual boilerplate of
+   * matrix algorithms, based on a plain options object with the
+   * following properties:
+   *   elop: function -- the elementwise operation to use, defaults to self
+   *   SS: function -- the algorithm to apply for two sparse matrices
+   *   DS: function -- the algorithm to apply for a dense and a sparse matrix
+   *   SD: function -- algo for a sparse and a dense; defaults to SD flipped
+   *   Ss: function -- the algorithm to apply for a sparse matrix and scalar
+   *   sS: function -- algo for scalar and sparse; defaults to Ss flipped
+   *   scalar: string -- typed-function type for scalars, defaults to 'any'
+   *
+   * If Ss is not specified, no matrix-scalar signatures are generated.
+   *
+   * @param {object} options
+   * @return {Object<string, function>} signatures
+   */
+  return function matrixAlgorithmSuite(options) {
+    var elop = options.elop;
+    var SD = options.SD || options.DS;
+    var matrixSignatures;
+    if (elop) {
+      // First the dense ones
+      matrixSignatures = {
+        'DenseMatrix, DenseMatrix': function DenseMatrixDenseMatrix(x, y) {
+          return matAlgo13xDD.apply(void 0, (0, _toConsumableArray2["default"])(broadcast(x, y)).concat([elop]));
+        },
+        'Array, Array': function ArrayArray(x, y) {
+          return matAlgo13xDD.apply(void 0, (0, _toConsumableArray2["default"])(broadcast(matrix(x), matrix(y))).concat([elop])).valueOf();
+        },
+        'Array, DenseMatrix': function ArrayDenseMatrix(x, y) {
+          return matAlgo13xDD.apply(void 0, (0, _toConsumableArray2["default"])(broadcast(matrix(x), y)).concat([elop]));
+        },
+        'DenseMatrix, Array': function DenseMatrixArray(x, y) {
+          return matAlgo13xDD.apply(void 0, (0, _toConsumableArray2["default"])(broadcast(x, matrix(y))).concat([elop]));
+        }
+      };
+      // Now incorporate sparse matrices
+      if (options.SS) {
+        matrixSignatures['SparseMatrix, SparseMatrix'] = function (x, y) {
+          return options.SS.apply(options, (0, _toConsumableArray2["default"])(broadcast(x, y)).concat([elop, false]));
+        };
+      }
+      if (options.DS) {
+        matrixSignatures['DenseMatrix, SparseMatrix'] = function (x, y) {
+          return options.DS.apply(options, (0, _toConsumableArray2["default"])(broadcast(x, y)).concat([elop, false]));
+        };
+        matrixSignatures['Array, SparseMatrix'] = function (x, y) {
+          return options.DS.apply(options, (0, _toConsumableArray2["default"])(broadcast(matrix(x), y)).concat([elop, false]));
+        };
+      }
+      if (SD) {
+        matrixSignatures['SparseMatrix, DenseMatrix'] = function (x, y) {
+          return SD.apply(void 0, (0, _toConsumableArray2["default"])(broadcast(y, x)).concat([elop, true]));
+        };
+        matrixSignatures['SparseMatrix, Array'] = function (x, y) {
+          return SD.apply(void 0, (0, _toConsumableArray2["default"])(broadcast(matrix(y), x)).concat([elop, true]));
+        };
+      }
+    } else {
+      // No elop, use this
+      // First the dense ones
+      matrixSignatures = {
+        'DenseMatrix, DenseMatrix': typed.referToSelf(function (self) {
+          return function (x, y) {
+            return matAlgo13xDD.apply(void 0, (0, _toConsumableArray2["default"])(broadcast(x, y)).concat([self]));
+          };
+        }),
+        'Array, Array': typed.referToSelf(function (self) {
+          return function (x, y) {
+            return matAlgo13xDD.apply(void 0, (0, _toConsumableArray2["default"])(broadcast(matrix(x), matrix(y))).concat([self])).valueOf();
+          };
+        }),
+        'Array, DenseMatrix': typed.referToSelf(function (self) {
+          return function (x, y) {
+            return matAlgo13xDD.apply(void 0, (0, _toConsumableArray2["default"])(broadcast(matrix(x), y)).concat([self]));
+          };
+        }),
+        'DenseMatrix, Array': typed.referToSelf(function (self) {
+          return function (x, y) {
+            return matAlgo13xDD.apply(void 0, (0, _toConsumableArray2["default"])(broadcast(x, matrix(y))).concat([self]));
+          };
+        })
+      };
+      // Now incorporate sparse matrices
+      if (options.SS) {
+        matrixSignatures['SparseMatrix, SparseMatrix'] = typed.referToSelf(function (self) {
+          return function (x, y) {
+            return options.SS.apply(options, (0, _toConsumableArray2["default"])(broadcast(x, y)).concat([self, false]));
+          };
+        });
+      }
+      if (options.DS) {
+        matrixSignatures['DenseMatrix, SparseMatrix'] = typed.referToSelf(function (self) {
+          return function (x, y) {
+            return options.DS.apply(options, (0, _toConsumableArray2["default"])(broadcast(x, y)).concat([self, false]));
+          };
+        });
+        matrixSignatures['Array, SparseMatrix'] = typed.referToSelf(function (self) {
+          return function (x, y) {
+            return options.DS.apply(options, (0, _toConsumableArray2["default"])(broadcast(matrix(x), y)).concat([self, false]));
+          };
+        });
+      }
+      if (SD) {
+        matrixSignatures['SparseMatrix, DenseMatrix'] = typed.referToSelf(function (self) {
+          return function (x, y) {
+            return SD.apply(void 0, (0, _toConsumableArray2["default"])(broadcast(y, x)).concat([self, true]));
+          };
+        });
+        matrixSignatures['SparseMatrix, Array'] = typed.referToSelf(function (self) {
+          return function (x, y) {
+            return SD.apply(void 0, (0, _toConsumableArray2["default"])(broadcast(matrix(y), x)).concat([self, true]));
+          };
+        });
+      }
+    }
+
+    // Now add the scalars
+    var scalar = options.scalar || 'any';
+    var Ds = options.Ds || options.Ss;
+    if (Ds) {
+      if (elop) {
+        matrixSignatures['DenseMatrix,' + scalar] = function (x, y) {
+          return matAlgo14xDs(x, y, elop, false);
+        };
+        matrixSignatures[scalar + ', DenseMatrix'] = function (x, y) {
+          return matAlgo14xDs(y, x, elop, true);
+        };
+        matrixSignatures['Array,' + scalar] = function (x, y) {
+          return matAlgo14xDs(matrix(x), y, elop, false).valueOf();
+        };
+        matrixSignatures[scalar + ', Array'] = function (x, y) {
+          return matAlgo14xDs(matrix(y), x, elop, true).valueOf();
+        };
+      } else {
+        matrixSignatures['DenseMatrix,' + scalar] = typed.referToSelf(function (self) {
+          return function (x, y) {
+            return matAlgo14xDs(x, y, self, false);
+          };
+        });
+        matrixSignatures[scalar + ', DenseMatrix'] = typed.referToSelf(function (self) {
+          return function (x, y) {
+            return matAlgo14xDs(y, x, self, true);
+          };
+        });
+        matrixSignatures['Array,' + scalar] = typed.referToSelf(function (self) {
+          return function (x, y) {
+            return matAlgo14xDs(matrix(x), y, self, false).valueOf();
+          };
+        });
+        matrixSignatures[scalar + ', Array'] = typed.referToSelf(function (self) {
+          return function (x, y) {
+            return matAlgo14xDs(matrix(y), x, self, true).valueOf();
+          };
+        });
+      }
+    }
+    var sS = options.sS !== undefined ? options.sS : options.Ss;
+    if (elop) {
+      if (options.Ss) {
+        matrixSignatures['SparseMatrix,' + scalar] = function (x, y) {
+          return options.Ss(x, y, elop, false);
+        };
+      }
+      if (sS) {
+        matrixSignatures[scalar + ', SparseMatrix'] = function (x, y) {
+          return sS(y, x, elop, true);
+        };
+      }
+    } else {
+      if (options.Ss) {
+        matrixSignatures['SparseMatrix,' + scalar] = typed.referToSelf(function (self) {
+          return function (x, y) {
+            return options.Ss(x, y, self, false);
+          };
+        });
+      }
+      if (sS) {
+        matrixSignatures[scalar + ', SparseMatrix'] = typed.referToSelf(function (self) {
+          return function (x, y) {
+            return sS(y, x, self, true);
+          };
+        });
+      }
+    }
+    // Also pull in the scalar signatures if the operator is a typed function
+    if (elop && elop.signatures) {
+      (0, _object.extend)(matrixSignatures, elop.signatures);
+    }
+    return matrixSignatures;
+  };
+});
+exports.createMatrixAlgorithmSuite = createMatrixAlgorithmSuite;

package/lib/cjs/type/number.js

@@ -0,0 +1,154 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createNumber = void 0;
+var _factory = require("../utils/factory.js");
+var _collection = require("../utils/collection.js");
+var name = 'number';
+var dependencies = ['typed'];
+
+/**
+ * Separates the radix, integer part, and fractional part of a non decimal number string
+ * @param {string} input string to parse
+ * @returns {object} the parts of the string or null if not a valid input
+ */
+function getNonDecimalNumberParts(input) {
+  var nonDecimalWithRadixMatch = input.match(/(0[box])([0-9a-fA-F]*)\.([0-9a-fA-F]*)/);
+  if (nonDecimalWithRadixMatch) {
+    var radix = {
+      '0b': 2,
+      '0o': 8,
+      '0x': 16
+    }[nonDecimalWithRadixMatch[1]];
+    var integerPart = nonDecimalWithRadixMatch[2];
+    var fractionalPart = nonDecimalWithRadixMatch[3];
+    return {
+      input: input,
+      radix: radix,
+      integerPart: integerPart,
+      fractionalPart: fractionalPart
+    };
+  } else {
+    return null;
+  }
+}
+
+/**
+ * Makes a number from a radix, and integer part, and a fractional part
+ * @param {parts} [x] parts of the number string (from getNonDecimalNumberParts)
+ * @returns {number} the number
+ */
+function makeNumberFromNonDecimalParts(parts) {
+  var n = parseInt(parts.integerPart, parts.radix);
+  var f = 0;
+  for (var i = 0; i < parts.fractionalPart.length; i++) {
+    var digitValue = parseInt(parts.fractionalPart[i], parts.radix);
+    f += digitValue / Math.pow(parts.radix, i + 1);
+  }
+  var result = n + f;
+  if (isNaN(result)) {
+    throw new SyntaxError('String "' + parts.input + '" is no valid number');
+  }
+  return result;
+}
+var createNumber = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed;
+  /**
+   * Create a number or convert a string, boolean, or unit to a number.
+   * When value is a matrix, all elements will be converted to number.
+   *
+   * Syntax:
+   *
+   *    math.number(value)
+   *    math.number(unit, valuelessUnit)
+   *
+   * Examples:
+   *
+   *    math.number(2)                         // returns number 2
+   *    math.number('7.2')                     // returns number 7.2
+   *    math.number(true)                      // returns number 1
+   *    math.number([true, false, true, true]) // returns [1, 0, 1, 1]
+   *    math.number(math.unit('52cm'), 'm')    // returns 0.52
+   *
+   * See also:
+   *
+   *    bignumber, boolean, complex, index, matrix, string, unit
+   *
+   * @param {string | number | BigNumber | Fraction | boolean | Array | Matrix | Unit | null} [value]  Value to be converted
+   * @param {Unit | string} [valuelessUnit] A valueless unit, used to convert a unit to a number
+   * @return {number | Array | Matrix} The created number
+   */
+  var number = typed('number', {
+    '': function _() {
+      return 0;
+    },
+    number: function number(x) {
+      return x;
+    },
+    string: function string(x) {
+      if (x === 'NaN') return NaN;
+      var nonDecimalNumberParts = getNonDecimalNumberParts(x);
+      if (nonDecimalNumberParts) {
+        return makeNumberFromNonDecimalParts(nonDecimalNumberParts);
+      }
+      var size = 0;
+      var wordSizeSuffixMatch = x.match(/(0[box][0-9a-fA-F]*)i([0-9]*)/);
+      if (wordSizeSuffixMatch) {
+        // x includes a size suffix like 0xffffi32, so we extract
+        // the suffix and remove it from x
+        size = Number(wordSizeSuffixMatch[2]);
+        x = wordSizeSuffixMatch[1];
+      }
+      var num = Number(x);
+      if (isNaN(num)) {
+        throw new SyntaxError('String "' + x + '" is no valid number');
+      }
+      if (wordSizeSuffixMatch) {
+        // x is a signed bin, oct, or hex literal
+        // num is the value of string x if x is interpreted as unsigned
+        if (num > Math.pow(2, size) - 1) {
+          // literal is too large for size suffix
+          throw new SyntaxError("String \"".concat(x, "\" is out of range"));
+        }
+        // check if the bit at index size - 1 is set and if so do the twos complement
+        if (num >= Math.pow(2, size - 1)) {
+          num = num - Math.pow(2, size);
+        }
+      }
+      return num;
+    },
+    BigNumber: function BigNumber(x) {
+      return x.toNumber();
+    },
+    Fraction: function Fraction(x) {
+      return x.valueOf();
+    },
+    Unit: function Unit(x) {
+      throw new Error('Second argument with valueless unit expected');
+    },
+    "null": function _null(x) {
+      return 0;
+    },
+    'Unit, string | Unit': function UnitStringUnit(unit, valuelessUnit) {
+      return unit.toNumber(valuelessUnit);
+    },
+    'Array | Matrix': typed.referToSelf(function (self) {
+      return function (x) {
+        return (0, _collection.deepMap)(x, self);
+      };
+    })
+  });
+
+  // reviver function to parse a JSON object like:
+  //
+  //     {"mathjs":"number","value":"2.3"}
+  //
+  // into a number 2.3
+  number.fromJSON = function (json) {
+    return parseFloat(json.value);
+  };
+  return number;
+});
+exports.createNumber = createNumber;

package/lib/cjs/type/resultset/ResultSet.js

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createResultSet = void 0;
+var _factory = require("../../utils/factory.js");
+var name = 'ResultSet';
+var dependencies = [];
+var createResultSet = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function () {
+  /**
+   * A ResultSet contains a list or results
+   * @class ResultSet
+   * @param {Array} entries
+   * @constructor ResultSet
+   */
+  function ResultSet(entries) {
+    if (!(this instanceof ResultSet)) {
+      throw new SyntaxError('Constructor must be called with the new operator');
+    }
+    this.entries = entries || [];
+  }
+
+  /**
+   * Attach type information
+   */
+  ResultSet.prototype.type = 'ResultSet';
+  ResultSet.prototype.isResultSet = true;
+
+  /**
+   * Returns the array with results hold by this ResultSet
+   * @memberof ResultSet
+   * @returns {Array} entries
+   */
+  ResultSet.prototype.valueOf = function () {
+    return this.entries;
+  };
+
+  /**
+   * Returns the stringified results of the ResultSet
+   * @memberof ResultSet
+   * @returns {string} string
+   */
+  ResultSet.prototype.toString = function () {
+    return '[' + this.entries.join(', ') + ']';
+  };
+
+  /**
+   * Get a JSON representation of the ResultSet
+   * @memberof ResultSet
+   * @returns {Object} Returns a JSON object structured as:
+   *                   `{"mathjs": "ResultSet", "entries": [...]}`
+   */
+  ResultSet.prototype.toJSON = function () {
+    return {
+      mathjs: 'ResultSet',
+      entries: this.entries
+    };
+  };
+
+  /**
+   * Instantiate a ResultSet from a JSON object
+   * @memberof ResultSet
+   * @param {Object} json  A JSON object structured as:
+   *                       `{"mathjs": "ResultSet", "entries": [...]}`
+   * @return {ResultSet}
+   */
+  ResultSet.fromJSON = function (json) {
+    return new ResultSet(json.entries);
+  };
+  return ResultSet;
+}, {
+  isClass: true
+});
+exports.createResultSet = createResultSet;

package/lib/cjs/type/string.js

@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createString = void 0;
+var _factory = require("../utils/factory.js");
+var _collection = require("../utils/collection.js");
+var _number = require("../utils/number.js");
+var name = 'string';
+var dependencies = ['typed'];
+var createString = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed;
+  /**
+   * Create a string or convert any object into a string.
+   * Elements of Arrays and Matrices are processed element wise.
+   *
+   * Syntax:
+   *
+   *    math.string(value)
+   *
+   * Examples:
+   *
+   *    math.string(4.2)               // returns string '4.2'
+   *    math.string(math.complex(3, 2) // returns string '3 + 2i'
+   *
+   *    const u = math.unit(5, 'km')
+   *    math.string(u.to('m'))         // returns string '5000 m'
+   *
+   *    math.string([true, false])     // returns ['true', 'false']
+   *
+   * See also:
+   *
+   *    bignumber, boolean, complex, index, matrix, number, unit
+   *
+   * @param {* | Array | Matrix | null} [value]  A value to convert to a string
+   * @return {string | Array | Matrix} The created string
+   */
+  return typed(name, {
+    '': function _() {
+      return '';
+    },
+    number: _number.format,
+    "null": function _null(x) {
+      return 'null';
+    },
+    "boolean": function boolean(x) {
+      return x + '';
+    },
+    string: function string(x) {
+      return x;
+    },
+    'Array | Matrix': typed.referToSelf(function (self) {
+      return function (x) {
+        return (0, _collection.deepMap)(x, self);
+      };
+    }),
+    any: function any(x) {
+      return String(x);
+    }
+  });
+});
+exports.createString = createString;