mathjs-min 11.7.2

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

@@ -0,0 +1,76 @@
+import { factory } from '../../../utils/factory.js';
+import { clone } from '../../../utils/object.js';
+var name = 'matAlgo14xDs';
+var dependencies = ['typed'];
+export var createMatAlgo14xDs = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed
+  } = _ref;
+  /**
+   * 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: 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;
+  }
+});

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

@@ -0,0 +1,156 @@
+import { factory } from '../../../utils/factory.js';
+import { extend } from '../../../utils/object.js';
+import { createMatAlgo13xDD } from './matAlgo13xDD.js';
+import { createMatAlgo14xDs } from './matAlgo14xDs.js';
+import { createBroadcast } from './broadcast.js';
+var name = 'matrixAlgorithmSuite';
+var dependencies = ['typed', 'matrix', 'concat'];
+export var createMatrixAlgorithmSuite = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    matrix,
+    concat
+  } = _ref;
+  var matAlgo13xDD = createMatAlgo13xDD({
+    typed
+  });
+  var matAlgo14xDs = createMatAlgo14xDs({
+    typed
+  });
+  var broadcast = createBroadcast({
+    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': (x, y) => matAlgo13xDD(...broadcast(x, y), elop),
+        'Array, Array': (x, y) => matAlgo13xDD(...broadcast(matrix(x), matrix(y)), elop).valueOf(),
+        'Array, DenseMatrix': (x, y) => matAlgo13xDD(...broadcast(matrix(x), y), elop),
+        'DenseMatrix, Array': (x, y) => matAlgo13xDD(...broadcast(x, matrix(y)), elop)
+      };
+      // Now incorporate sparse matrices
+      if (options.SS) {
+        matrixSignatures['SparseMatrix, SparseMatrix'] = (x, y) => options.SS(...broadcast(x, y), elop, false);
+      }
+      if (options.DS) {
+        matrixSignatures['DenseMatrix, SparseMatrix'] = (x, y) => options.DS(...broadcast(x, y), elop, false);
+        matrixSignatures['Array, SparseMatrix'] = (x, y) => options.DS(...broadcast(matrix(x), y), elop, false);
+      }
+      if (SD) {
+        matrixSignatures['SparseMatrix, DenseMatrix'] = (x, y) => SD(...broadcast(y, x), elop, true);
+        matrixSignatures['SparseMatrix, Array'] = (x, y) => SD(...broadcast(matrix(y), x), elop, true);
+      }
+    } else {
+      // No elop, use this
+      // First the dense ones
+      matrixSignatures = {
+        'DenseMatrix, DenseMatrix': typed.referToSelf(self => (x, y) => {
+          return matAlgo13xDD(...broadcast(x, y), self);
+        }),
+        'Array, Array': typed.referToSelf(self => (x, y) => {
+          return matAlgo13xDD(...broadcast(matrix(x), matrix(y)), self).valueOf();
+        }),
+        'Array, DenseMatrix': typed.referToSelf(self => (x, y) => {
+          return matAlgo13xDD(...broadcast(matrix(x), y), self);
+        }),
+        'DenseMatrix, Array': typed.referToSelf(self => (x, y) => {
+          return matAlgo13xDD(...broadcast(x, matrix(y)), self);
+        })
+      };
+      // Now incorporate sparse matrices
+      if (options.SS) {
+        matrixSignatures['SparseMatrix, SparseMatrix'] = typed.referToSelf(self => (x, y) => {
+          return options.SS(...broadcast(x, y), self, false);
+        });
+      }
+      if (options.DS) {
+        matrixSignatures['DenseMatrix, SparseMatrix'] = typed.referToSelf(self => (x, y) => {
+          return options.DS(...broadcast(x, y), self, false);
+        });
+        matrixSignatures['Array, SparseMatrix'] = typed.referToSelf(self => (x, y) => {
+          return options.DS(...broadcast(matrix(x), y), self, false);
+        });
+      }
+      if (SD) {
+        matrixSignatures['SparseMatrix, DenseMatrix'] = typed.referToSelf(self => (x, y) => {
+          return SD(...broadcast(y, x), self, true);
+        });
+        matrixSignatures['SparseMatrix, Array'] = typed.referToSelf(self => (x, y) => {
+          return SD(...broadcast(matrix(y), x), self, true);
+        });
+      }
+    }
+
+    // Now add the scalars
+    var scalar = options.scalar || 'any';
+    var Ds = options.Ds || options.Ss;
+    if (Ds) {
+      if (elop) {
+        matrixSignatures['DenseMatrix,' + scalar] = (x, y) => matAlgo14xDs(x, y, elop, false);
+        matrixSignatures[scalar + ', DenseMatrix'] = (x, y) => matAlgo14xDs(y, x, elop, true);
+        matrixSignatures['Array,' + scalar] = (x, y) => matAlgo14xDs(matrix(x), y, elop, false).valueOf();
+        matrixSignatures[scalar + ', Array'] = (x, y) => matAlgo14xDs(matrix(y), x, elop, true).valueOf();
+      } else {
+        matrixSignatures['DenseMatrix,' + scalar] = typed.referToSelf(self => (x, y) => {
+          return matAlgo14xDs(x, y, self, false);
+        });
+        matrixSignatures[scalar + ', DenseMatrix'] = typed.referToSelf(self => (x, y) => {
+          return matAlgo14xDs(y, x, self, true);
+        });
+        matrixSignatures['Array,' + scalar] = typed.referToSelf(self => (x, y) => {
+          return matAlgo14xDs(matrix(x), y, self, false).valueOf();
+        });
+        matrixSignatures[scalar + ', Array'] = typed.referToSelf(self => (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] = (x, y) => options.Ss(x, y, elop, false);
+      }
+      if (sS) {
+        matrixSignatures[scalar + ', SparseMatrix'] = (x, y) => sS(y, x, elop, true);
+      }
+    } else {
+      if (options.Ss) {
+        matrixSignatures['SparseMatrix,' + scalar] = typed.referToSelf(self => (x, y) => {
+          return options.Ss(x, y, self, false);
+        });
+      }
+      if (sS) {
+        matrixSignatures[scalar + ', SparseMatrix'] = typed.referToSelf(self => (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) {
+      extend(matrixSignatures, elop.signatures);
+    }
+    return matrixSignatures;
+  };
+});

package/lib/esm/type/number.js

@@ -0,0 +1,145 @@
+import { factory } from '../utils/factory.js';
+import { deepMap } from '../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,
+      radix,
+      integerPart,
+      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;
+}
+export var createNumber = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed
+  } = _ref;
+  /**
+   * 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 > 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 >= 2 ** (size - 1)) {
+          num = num - 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(self => x => 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;
+});

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

@@ -0,0 +1,68 @@
+import { factory } from '../../utils/factory.js';
+var name = 'ResultSet';
+var dependencies = [];
+export var createResultSet = /* #__PURE__ */factory(name, dependencies, () => {
+  /**
+   * 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
+});

package/lib/esm/type/string.js

@@ -0,0 +1,54 @@
+import { factory } from '../utils/factory.js';
+import { deepMap } from '../utils/collection.js';
+import { format } from '../utils/number.js';
+var name = 'string';
+var dependencies = ['typed'];
+export var createString = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed
+  } = _ref;
+  /**
+   * 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: format,
+    null: function _null(x) {
+      return 'null';
+    },
+    boolean: function boolean(x) {
+      return x + '';
+    },
+    string: function string(x) {
+      return x;
+    },
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self)),
+    any: function any(x) {
+      return String(x);
+    }
+  });
+});