mathjs-min 11.7.2

package/lib/cjs/utils/string.js

@@ -0,0 +1,209 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.compareText = compareText;
+exports.endsWith = endsWith;
+exports.escape = escape;
+exports.format = format;
+exports.stringify = stringify;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _is = require("./is.js");
+var _number = require("./number.js");
+var _formatter = require("./bignumber/formatter.js");
+/**
+ * Check if a text ends with a certain string.
+ * @param {string} text
+ * @param {string} search
+ */
+function endsWith(text, search) {
+  var start = text.length - search.length;
+  var end = text.length;
+  return text.substring(start, end) === search;
+}
+
+/**
+ * Format a value of any type into a string.
+ *
+ * Usage:
+ *     math.format(value)
+ *     math.format(value, precision)
+ *     math.format(value, options)
+ *
+ * When value is a function:
+ *
+ * - When the function has a property `syntax`, it returns this
+ *   syntax description.
+ * - In other cases, a string `'function'` is returned.
+ *
+ * When `value` is an Object:
+ *
+ * - When the object contains a property `format` being a function, this
+ *   function is invoked as `value.format(options)` and the result is returned.
+ * - When the object has its own `toString` method, this method is invoked
+ *   and the result is returned.
+ * - In other cases the function will loop over all object properties and
+ *   return JSON object notation like '{"a": 2, "b": 3}'.
+ *
+ * Example usage:
+ *     math.format(2/7)                // '0.2857142857142857'
+ *     math.format(math.pi, 3)         // '3.14'
+ *     math.format(new Complex(2, 3))  // '2 + 3i'
+ *     math.format('hello')            // '"hello"'
+ *
+ * @param {*} value             Value to be stringified
+ * @param {Object | number | Function} [options]
+ *     Formatting options. See src/utils/number.js:format for a
+ *     description of the available options controlling number output.
+ *     This generic "format" also supports the option property `truncate: NN`
+ *     giving the maximum number NN of characters to return (if there would
+ *     have been more, they are deleted and replaced by an ellipsis).
+ * @return {string} str
+ */
+function format(value, options) {
+  var result = _format(value, options);
+  if (options && (0, _typeof2["default"])(options) === 'object' && 'truncate' in options && result.length > options.truncate) {
+    return result.substring(0, options.truncate - 3) + '...';
+  }
+  return result;
+}
+function _format(value, options) {
+  if (typeof value === 'number') {
+    return (0, _number.format)(value, options);
+  }
+  if ((0, _is.isBigNumber)(value)) {
+    return (0, _formatter.format)(value, options);
+  }
+
+  // note: we use unsafe duck-typing here to check for Fractions, this is
+  // ok here since we're only invoking toString or concatenating its values
+  if (looksLikeFraction(value)) {
+    if (!options || options.fraction !== 'decimal') {
+      // output as ratio, like '1/3'
+      return value.s * value.n + '/' + value.d;
+    } else {
+      // output as decimal, like '0.(3)'
+      return value.toString();
+    }
+  }
+  if (Array.isArray(value)) {
+    return formatArray(value, options);
+  }
+  if ((0, _is.isString)(value)) {
+    return '"' + value + '"';
+  }
+  if (typeof value === 'function') {
+    return value.syntax ? String(value.syntax) : 'function';
+  }
+  if (value && (0, _typeof2["default"])(value) === 'object') {
+    if (typeof value.format === 'function') {
+      return value.format(options);
+    } else if (value && value.toString(options) !== {}.toString()) {
+      // this object has a non-native toString method, use that one
+      return value.toString(options);
+    } else {
+      var entries = Object.keys(value).map(function (key) {
+        return '"' + key + '": ' + format(value[key], options);
+      });
+      return '{' + entries.join(', ') + '}';
+    }
+  }
+  return String(value);
+}
+
+/**
+ * Stringify a value into a string enclosed in double quotes.
+ * Unescaped double quotes and backslashes inside the value are escaped.
+ * @param {*} value
+ * @return {string}
+ */
+function stringify(value) {
+  var text = String(value);
+  var escaped = '';
+  var i = 0;
+  while (i < text.length) {
+    var c = text.charAt(i);
+    if (c === '\\') {
+      escaped += c;
+      i++;
+      c = text.charAt(i);
+      if (c === '' || '"\\/bfnrtu'.indexOf(c) === -1) {
+        escaped += '\\'; // no valid escape character -> escape it
+      }
+
+      escaped += c;
+    } else if (c === '"') {
+      escaped += '\\"';
+    } else {
+      escaped += c;
+    }
+    i++;
+  }
+  return '"' + escaped + '"';
+}
+
+/**
+ * Escape special HTML characters
+ * @param {*} value
+ * @return {string}
+ */
+function escape(value) {
+  var text = String(value);
+  text = text.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/'/g, '&#39;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+  return text;
+}
+
+/**
+ * Recursively format an n-dimensional matrix
+ * Example output: "[[1, 2], [3, 4]]"
+ * @param {Array} array
+ * @param {Object | number | Function} [options]  Formatting options. See
+ *                                                lib/utils/number:format for a
+ *                                                description of the available
+ *                                                options.
+ * @returns {string} str
+ */
+function formatArray(array, options) {
+  if (Array.isArray(array)) {
+    var str = '[';
+    var len = array.length;
+    for (var i = 0; i < len; i++) {
+      if (i !== 0) {
+        str += ', ';
+      }
+      str += formatArray(array[i], options);
+    }
+    str += ']';
+    return str;
+  } else {
+    return format(array, options);
+  }
+}
+
+/**
+ * Check whether a value looks like a Fraction (unsafe duck-type check)
+ * @param {*} value
+ * @return {boolean}
+ */
+function looksLikeFraction(value) {
+  return value && (0, _typeof2["default"])(value) === 'object' && typeof value.s === 'number' && typeof value.n === 'number' && typeof value.d === 'number' || false;
+}
+
+/**
+ * Compare two strings
+ * @param {string} x
+ * @param {string} y
+ * @returns {number}
+ */
+function compareText(x, y) {
+  // we don't want to convert numbers to string, only accept string input
+  if (!(0, _is.isString)(x)) {
+    throw new TypeError('Unexpected type of argument in function compareText ' + '(expected: string or Array or Matrix, actual: ' + (0, _is.typeOf)(x) + ', index: 0)');
+  }
+  if (!(0, _is.isString)(y)) {
+    throw new TypeError('Unexpected type of argument in function compareText ' + '(expected: string or Array or Matrix, actual: ' + (0, _is.typeOf)(y) + ', index: 1)');
+  }
+  return x === y ? 0 : x > y ? 1 : -1;
+}

package/lib/cjs/utils/switch.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._switch = _switch;
+/**
+ * Transpose a matrix
+ * @param {Array} mat
+ * @returns {Array} ret
+ * @private
+ */
+function _switch(mat) {
+  var I = mat.length;
+  var J = mat[0].length;
+  var i, j;
+  var ret = [];
+  for (j = 0; j < J; j++) {
+    var tmp = [];
+    for (i = 0; i < I; i++) {
+      tmp.push(mat[i][j]);
+    }
+    ret.push(tmp);
+  }
+  return ret;
+}

package/lib/cjs/version.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.version = void 0;
+var version = '11.7.1';
+// Note: This file is automatically generated when building math.js.
+// Changes made in this file will be overwritten.
+exports.version = version;

package/lib/esm/constants.js

@@ -0,0 +1,124 @@
+import { factory } from './utils/factory.js';
+import { version } from './version.js';
+import { createBigNumberE, createBigNumberPhi, createBigNumberPi, createBigNumberTau } from './utils/bignumber/constants.js';
+import { pi, tau, e, phi } from './plain/number/index.js';
+export var createTrue = /* #__PURE__ */factory('true', [], () => true);
+export var createFalse = /* #__PURE__ */factory('false', [], () => false);
+export var createNull = /* #__PURE__ */factory('null', [], () => null);
+export var createInfinity = /* #__PURE__ */recreateFactory('Infinity', ['config', '?BigNumber'], _ref => {
+  var {
+    config,
+    BigNumber
+  } = _ref;
+  return config.number === 'BigNumber' ? new BigNumber(Infinity) : Infinity;
+});
+export var createNaN = /* #__PURE__ */recreateFactory('NaN', ['config', '?BigNumber'], _ref2 => {
+  var {
+    config,
+    BigNumber
+  } = _ref2;
+  return config.number === 'BigNumber' ? new BigNumber(NaN) : NaN;
+});
+export var createPi = /* #__PURE__ */recreateFactory('pi', ['config', '?BigNumber'], _ref3 => {
+  var {
+    config,
+    BigNumber
+  } = _ref3;
+  return config.number === 'BigNumber' ? createBigNumberPi(BigNumber) : pi;
+});
+export var createTau = /* #__PURE__ */recreateFactory('tau', ['config', '?BigNumber'], _ref4 => {
+  var {
+    config,
+    BigNumber
+  } = _ref4;
+  return config.number === 'BigNumber' ? createBigNumberTau(BigNumber) : tau;
+});
+export var createE = /* #__PURE__ */recreateFactory('e', ['config', '?BigNumber'], _ref5 => {
+  var {
+    config,
+    BigNumber
+  } = _ref5;
+  return config.number === 'BigNumber' ? createBigNumberE(BigNumber) : e;
+});
+
+// golden ratio, (1+sqrt(5))/2
+export var createPhi = /* #__PURE__ */recreateFactory('phi', ['config', '?BigNumber'], _ref6 => {
+  var {
+    config,
+    BigNumber
+  } = _ref6;
+  return config.number === 'BigNumber' ? createBigNumberPhi(BigNumber) : phi;
+});
+export var createLN2 = /* #__PURE__ */recreateFactory('LN2', ['config', '?BigNumber'], _ref7 => {
+  var {
+    config,
+    BigNumber
+  } = _ref7;
+  return config.number === 'BigNumber' ? new BigNumber(2).ln() : Math.LN2;
+});
+export var createLN10 = /* #__PURE__ */recreateFactory('LN10', ['config', '?BigNumber'], _ref8 => {
+  var {
+    config,
+    BigNumber
+  } = _ref8;
+  return config.number === 'BigNumber' ? new BigNumber(10).ln() : Math.LN10;
+});
+export var createLOG2E = /* #__PURE__ */recreateFactory('LOG2E', ['config', '?BigNumber'], _ref9 => {
+  var {
+    config,
+    BigNumber
+  } = _ref9;
+  return config.number === 'BigNumber' ? new BigNumber(1).div(new BigNumber(2).ln()) : Math.LOG2E;
+});
+export var createLOG10E = /* #__PURE__ */recreateFactory('LOG10E', ['config', '?BigNumber'], _ref10 => {
+  var {
+    config,
+    BigNumber
+  } = _ref10;
+  return config.number === 'BigNumber' ? new BigNumber(1).div(new BigNumber(10).ln()) : Math.LOG10E;
+});
+export var createSQRT1_2 = /* #__PURE__ */recreateFactory(
+// eslint-disable-line camelcase
+'SQRT1_2', ['config', '?BigNumber'], _ref11 => {
+  var {
+    config,
+    BigNumber
+  } = _ref11;
+  return config.number === 'BigNumber' ? new BigNumber('0.5').sqrt() : Math.SQRT1_2;
+});
+export var createSQRT2 = /* #__PURE__ */recreateFactory('SQRT2', ['config', '?BigNumber'], _ref12 => {
+  var {
+    config,
+    BigNumber
+  } = _ref12;
+  return config.number === 'BigNumber' ? new BigNumber(2).sqrt() : Math.SQRT2;
+});
+export var createI = /* #__PURE__ */recreateFactory('i', ['Complex'], _ref13 => {
+  var {
+    Complex
+  } = _ref13;
+  return Complex.I;
+});
+
+// for backward compatibility with v5
+export var createUppercasePi = /* #__PURE__ */factory('PI', ['pi'], _ref14 => {
+  var {
+    pi
+  } = _ref14;
+  return pi;
+});
+export var createUppercaseE = /* #__PURE__ */factory('E', ['e'], _ref15 => {
+  var {
+    e
+  } = _ref15;
+  return e;
+});
+export var createVersion = /* #__PURE__ */factory('version', [], () => version);
+
+// helper function to create a factory with a flag recreateOnConfigChange
+// idea: allow passing optional properties to be attached to the factory function as 4th argument?
+function recreateFactory(name, dependencies, create) {
+  return factory(name, dependencies, create, {
+    recreateOnConfigChange: true
+  });
+}

package/lib/esm/core/config.js

@@ -0,0 +1,19 @@
+export var DEFAULT_CONFIG = {
+  // minimum relative difference between two compared values,
+  // used by all comparison functions
+  epsilon: 1e-12,
+  // type of default matrix output. Choose 'matrix' (default) or 'array'
+  matrix: 'Matrix',
+  // type of default number output. Choose 'number' (default) 'BigNumber', or 'Fraction
+  number: 'number',
+  // number of significant digits in BigNumbers
+  precision: 64,
+  // predictable output type of functions. When true, output type depends only
+  // on the input types. When false (default), output type can vary depending
+  // on input values. For example `math.sqrt(-4)` returns `complex('2i')` when
+  // predictable is false, and returns `NaN` when true.
+  predictable: false,
+  // random seed for seeded pseudo random number generation
+  // null = randomly seed
+  randomSeed: null
+};

package/lib/esm/core/create.js

@@ -0,0 +1,198 @@
+import _extends from "@babel/runtime/helpers/extends";
+import typedFunction from 'typed-function';
+import { deepFlatten, isLegacyFactory, values } from '../utils/object.js';
+import * as emitter from './../utils/emitter.js';
+import { importFactory } from './function/import.js';
+import { configFactory } from './function/config.js';
+import { factory, isFactory } from '../utils/factory.js';
+import { isAccessorNode, isArray, isArrayNode, isAssignmentNode, isBigNumber, isBlockNode, isBoolean, isChain, isCollection, isComplex, isConditionalNode, isConstantNode, isDate, isDenseMatrix, isFraction, isFunction, isFunctionAssignmentNode, isFunctionNode, isHelp, isIndex, isIndexNode, isMatrix, isNode, isNull, isNumber, isObject, isObjectNode, isOperatorNode, isParenthesisNode, isRange, isRangeNode, isRelationalNode, isRegExp, isResultSet, isSparseMatrix, isString, isSymbolNode, isUndefined, isUnit } from '../utils/is.js';
+import { ArgumentsError } from '../error/ArgumentsError.js';
+import { DimensionError } from '../error/DimensionError.js';
+import { IndexError } from '../error/IndexError.js';
+import { DEFAULT_CONFIG } from './config.js';
+
+/**
+ * Create a mathjs instance from given factory functions and optionally config
+ *
+ * Usage:
+ *
+ *     const mathjs1 = create({ createAdd, createMultiply, ...})
+ *     const config = { number: 'BigNumber' }
+ *     const mathjs2 = create(all, config)
+ *
+ * @param {Object} [factories] An object with factory functions
+ *                             The object can contain nested objects,
+ *                             all nested objects will be flattened.
+ * @param {Object} [config]    Available options:
+ *                            {number} epsilon
+ *                              Minimum relative difference between two
+ *                              compared values, used by all comparison functions.
+ *                            {string} matrix
+ *                              A string 'Matrix' (default) or 'Array'.
+ *                            {string} number
+ *                              A string 'number' (default), 'BigNumber', or 'Fraction'
+ *                            {number} precision
+ *                              The number of significant digits for BigNumbers.
+ *                              Not applicable for Numbers.
+ *                            {boolean} predictable
+ *                              Predictable output type of functions. When true,
+ *                              output type depends only on the input types. When
+ *                              false (default), output type can vary depending
+ *                              on input values. For example `math.sqrt(-4)`
+ *                              returns `complex('2i')` when predictable is false, and
+ *                              returns `NaN` when true.
+ *                            {string} randomSeed
+ *                              Random seed for seeded pseudo random number generator.
+ *                              Set to null to randomly seed.
+ * @returns {Object} Returns a bare-bone math.js instance containing
+ *                   functions:
+ *                   - `import` to add new functions
+ *                   - `config` to change configuration
+ *                   - `on`, `off`, `once`, `emit` for events
+ */
+export function create(factories, config) {
+  var configInternal = _extends({}, DEFAULT_CONFIG, config);
+
+  // simple test for ES5 support
+  if (typeof Object.create !== 'function') {
+    throw new Error('ES5 not supported by this JavaScript engine. ' + 'Please load the es5-shim and es5-sham library for compatibility.');
+  }
+
+  // create the mathjs instance
+  var math = emitter.mixin({
+    // only here for backward compatibility for legacy factory functions
+    isNumber,
+    isComplex,
+    isBigNumber,
+    isFraction,
+    isUnit,
+    isString,
+    isArray,
+    isMatrix,
+    isCollection,
+    isDenseMatrix,
+    isSparseMatrix,
+    isRange,
+    isIndex,
+    isBoolean,
+    isResultSet,
+    isHelp,
+    isFunction,
+    isDate,
+    isRegExp,
+    isObject,
+    isNull,
+    isUndefined,
+    isAccessorNode,
+    isArrayNode,
+    isAssignmentNode,
+    isBlockNode,
+    isConditionalNode,
+    isConstantNode,
+    isFunctionAssignmentNode,
+    isFunctionNode,
+    isIndexNode,
+    isNode,
+    isObjectNode,
+    isOperatorNode,
+    isParenthesisNode,
+    isRangeNode,
+    isRelationalNode,
+    isSymbolNode,
+    isChain
+  });
+
+  // load config function and apply provided config
+  math.config = configFactory(configInternal, math.emit);
+  math.expression = {
+    transform: {},
+    mathWithTransform: {
+      config: math.config
+    }
+  };
+
+  // cached factories and instances used by function load
+  var legacyFactories = [];
+  var legacyInstances = [];
+
+  /**
+   * Load a function or data type from a factory.
+   * If the function or data type already exists, the existing instance is
+   * returned.
+   * @param {Function} factory
+   * @returns {*}
+   */
+  function load(factory) {
+    if (isFactory(factory)) {
+      return factory(math);
+    }
+    var firstProperty = factory[Object.keys(factory)[0]];
+    if (isFactory(firstProperty)) {
+      return firstProperty(math);
+    }
+    if (!isLegacyFactory(factory)) {
+      console.warn('Factory object with properties `type`, `name`, and `factory` expected', factory);
+      throw new Error('Factory object with properties `type`, `name`, and `factory` expected');
+    }
+    var index = legacyFactories.indexOf(factory);
+    var instance;
+    if (index === -1) {
+      // doesn't yet exist
+      if (factory.math === true) {
+        // pass with math namespace
+        instance = factory.factory(math.type, configInternal, load, math.typed, math);
+      } else {
+        instance = factory.factory(math.type, configInternal, load, math.typed);
+      }
+
+      // append to the cache
+      legacyFactories.push(factory);
+      legacyInstances.push(instance);
+    } else {
+      // already existing function, return the cached instance
+      instance = legacyInstances[index];
+    }
+    return instance;
+  }
+  var importedFactories = {};
+
+  // load the import function
+  function lazyTyped() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return math.typed.apply(math.typed, args);
+  }
+  lazyTyped.isTypedFunction = typedFunction.isTypedFunction;
+  var internalImport = importFactory(lazyTyped, load, math, importedFactories);
+  math.import = internalImport;
+
+  // listen for changes in config, import all functions again when changed
+  // TODO: move this listener into the import function?
+  math.on('config', () => {
+    values(importedFactories).forEach(factory => {
+      if (factory && factory.meta && factory.meta.recreateOnConfigChange) {
+        // FIXME: only re-create when the current instance is the same as was initially created
+        // FIXME: delete the functions/constants before importing them again?
+        internalImport(factory, {
+          override: true
+        });
+      }
+    });
+  });
+
+  // the create function exposed on the mathjs instance is bound to
+  // the factory functions passed before
+  math.create = create.bind(null, factories);
+
+  // export factory function
+  math.factory = factory;
+
+  // import the factory functions like createAdd as an array instead of object,
+  // else they will get a different naming (`createAdd` instead of `add`).
+  math.import(values(deepFlatten(factories)));
+  math.ArgumentsError = ArgumentsError;
+  math.DimensionError = DimensionError;
+  math.IndexError = IndexError;
+  return math;
+}

package/lib/esm/core/function/config.js

@@ -0,0 +1,106 @@
+import { clone, mapObject, deepExtend } from '../../utils/object.js';
+import { DEFAULT_CONFIG } from '../config.js';
+export var MATRIX_OPTIONS = ['Matrix', 'Array']; // valid values for option matrix
+export var NUMBER_OPTIONS = ['number', 'BigNumber', 'Fraction']; // valid values for option number
+
+export function configFactory(config, emit) {
+  /**
+   * Set configuration options for math.js, and get current options.
+   * Will emit a 'config' event, with arguments (curr, prev, changes).
+   *
+   * This function is only available on a mathjs instance created using `create`.
+   *
+   * Syntax:
+   *
+   *     math.config(config: Object): Object
+   *
+   * Examples:
+   *
+   *
+   *     import { create, all } from 'mathjs'
+   *
+   *     // create a mathjs instance
+   *     const math = create(all)
+   *
+   *     math.config().number                // outputs 'number'
+   *     math.evaluate('0.4')                // outputs number 0.4
+   *     math.config({number: 'Fraction'})
+   *     math.evaluate('0.4')                // outputs Fraction 2/5
+   *
+   * @param {Object} [options] Available options:
+   *                            {number} epsilon
+   *                              Minimum relative difference between two
+   *                              compared values, used by all comparison functions.
+   *                            {string} matrix
+   *                              A string 'Matrix' (default) or 'Array'.
+   *                            {string} number
+   *                              A string 'number' (default), 'BigNumber', or 'Fraction'
+   *                            {number} precision
+   *                              The number of significant digits for BigNumbers.
+   *                              Not applicable for Numbers.
+   *                            {string} parenthesis
+   *                              How to display parentheses in LaTeX and string
+   *                              output.
+   *                            {string} randomSeed
+   *                              Random seed for seeded pseudo random number generator.
+   *                              Set to null to randomly seed.
+   * @return {Object} Returns the current configuration
+   */
+  function _config(options) {
+    if (options) {
+      var prev = mapObject(config, clone);
+
+      // validate some of the options
+      validateOption(options, 'matrix', MATRIX_OPTIONS);
+      validateOption(options, 'number', NUMBER_OPTIONS);
+
+      // merge options
+      deepExtend(config, options);
+      var curr = mapObject(config, clone);
+      var changes = mapObject(options, clone);
+
+      // emit 'config' event
+      emit('config', curr, prev, changes);
+      return curr;
+    } else {
+      return mapObject(config, clone);
+    }
+  }
+
+  // attach the valid options to the function so they can be extended
+  _config.MATRIX_OPTIONS = MATRIX_OPTIONS;
+  _config.NUMBER_OPTIONS = NUMBER_OPTIONS;
+
+  // attach the config properties as readonly properties to the config function
+  Object.keys(DEFAULT_CONFIG).forEach(key => {
+    Object.defineProperty(_config, key, {
+      get: () => config[key],
+      enumerable: true,
+      configurable: true
+    });
+  });
+  return _config;
+}
+
+/**
+ * Test whether an Array contains a specific item.
+ * @param {Array.<string>} array
+ * @param {string} item
+ * @return {boolean}
+ */
+function contains(array, item) {
+  return array.indexOf(item) !== -1;
+}
+
+/**
+ * Validate an option
+ * @param {Object} options         Object with options
+ * @param {string} name            Name of the option to validate
+ * @param {Array.<string>} values  Array with valid values for this option
+ */
+function validateOption(options, name, values) {
+  if (options[name] !== undefined && !contains(values, options[name])) {
+    // unknown value
+    console.warn('Warning: Unknown value "' + options[name] + '" for configuration option "' + name + '". ' + 'Available options: ' + values.map(value => JSON.stringify(value)).join(', ') + '.');
+  }
+}