mathjs-min 11.7.2

package/lib/cjs/type/chain/Chain.js

@@ -0,0 +1,220 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createChainClass = void 0;
+var _is = require("../../utils/is.js");
+var _string = require("../../utils/string.js");
+var _object = require("../../utils/object.js");
+var _factory = require("../../utils/factory.js");
+var name = 'Chain';
+var dependencies = ['?on', 'math', 'typed'];
+var createChainClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var on = _ref.on,
+    math = _ref.math,
+    typed = _ref.typed;
+  /**
+   * @constructor Chain
+   * Wrap any value in a chain, allowing to perform chained operations on
+   * the value.
+   *
+   * All methods available in the math.js library can be called upon the chain,
+   * and then will be evaluated with the value itself as first argument.
+   * The chain can be closed by executing chain.done(), which will return
+   * the final value.
+   *
+   * The Chain has a number of special functions:
+   * - done()             Finalize the chained operation and return the
+   *                      chain's value.
+   * - valueOf()          The same as done()
+   * - toString()         Returns a string representation of the chain's value.
+   *
+   * @param {*} [value]
+   */
+  function Chain(value) {
+    if (!(this instanceof Chain)) {
+      throw new SyntaxError('Constructor must be called with the new operator');
+    }
+    if ((0, _is.isChain)(value)) {
+      this.value = value.value;
+    } else {
+      this.value = value;
+    }
+  }
+
+  /**
+   * Attach type information
+   */
+  Chain.prototype.type = 'Chain';
+  Chain.prototype.isChain = true;
+
+  /**
+   * Close the chain. Returns the final value.
+   * Does the same as method valueOf()
+   * @returns {*} value
+   */
+  Chain.prototype.done = function () {
+    return this.value;
+  };
+
+  /**
+   * Close the chain. Returns the final value.
+   * Does the same as method done()
+   * @returns {*} value
+   */
+  Chain.prototype.valueOf = function () {
+    return this.value;
+  };
+
+  /**
+   * Get a string representation of the value in the chain
+   * @returns {string}
+   */
+  Chain.prototype.toString = function () {
+    return (0, _string.format)(this.value);
+  };
+
+  /**
+   * Get a JSON representation of the chain
+   * @returns {Object}
+   */
+  Chain.prototype.toJSON = function () {
+    return {
+      mathjs: 'Chain',
+      value: this.value
+    };
+  };
+
+  /**
+   * Instantiate a Chain from its JSON representation
+   * @param {Object} json  An object structured like
+   *                       `{"mathjs": "Chain", value: ...}`,
+   *                       where mathjs is optional
+   * @returns {Chain}
+   */
+  Chain.fromJSON = function (json) {
+    return new Chain(json.value);
+  };
+
+  /**
+   * Create a proxy method for the chain
+   * @param {string} name
+   * @param {Function} fn      The function to be proxied
+   *                           If fn is no function, it is silently ignored.
+   * @private
+   */
+  function createProxy(name, fn) {
+    if (typeof fn === 'function') {
+      Chain.prototype[name] = chainify(fn);
+    }
+  }
+
+  /**
+   * Create a proxy method for the chain
+   * @param {string} name
+   * @param {function} resolver   The function resolving with the
+   *                              function to be proxied
+   * @private
+   */
+  function createLazyProxy(name, resolver) {
+    (0, _object.lazy)(Chain.prototype, name, function outerResolver() {
+      var fn = resolver();
+      if (typeof fn === 'function') {
+        return chainify(fn);
+      }
+      return undefined; // if not a function, ignore
+    });
+  }
+
+  /**
+   * Make a function chainable
+   * @param {function} fn
+   * @return {Function} chain function
+   * @private
+   */
+  function chainify(fn) {
+    return function () {
+      // Here, `this` will be the context of a Chain instance
+      if (arguments.length === 0) {
+        return new Chain(fn(this.value));
+      }
+      var args = [this.value];
+      for (var i = 0; i < arguments.length; i++) {
+        args[i + 1] = arguments[i];
+      }
+      if (typed.isTypedFunction(fn)) {
+        var sigObject = typed.resolve(fn, args);
+        // We want to detect if a rest parameter has matched across the
+        // value in the chain and the current arguments of this call.
+        // That is the case if and only if the matching signature has
+        // exactly one parameter (which then must be a rest parameter
+        // as it is matching at least two actual arguments).
+        if (sigObject.params.length === 1) {
+          throw new Error('chain function ' + fn.name + ' cannot match rest parameter between chain value and additional arguments.');
+        }
+        return new Chain(sigObject.implementation.apply(fn, args));
+      }
+      return new Chain(fn.apply(fn, args));
+    };
+  }
+
+  /**
+   * Create a proxy for a single method, or an object with multiple methods.
+   * Example usage:
+   *
+   *   Chain.createProxy('add', function add (x, y) {...})
+   *   Chain.createProxy({
+   *     add:      function add (x, y) {...},
+   *     subtract: function subtract (x, y) {...}
+   *   }
+   *
+   * @param {string | Object} arg0   A name (string), or an object with
+   *                                 functions
+   * @param {*} [arg1]               A function, when arg0 is a name
+   */
+  Chain.createProxy = function (arg0, arg1) {
+    if (typeof arg0 === 'string') {
+      // createProxy(name, value)
+      createProxy(arg0, arg1);
+    } else {
+      var _loop = function _loop(_name) {
+        if ((0, _object.hasOwnProperty)(arg0, _name) && excludedNames[_name] === undefined) {
+          createLazyProxy(_name, function () {
+            return arg0[_name];
+          });
+        }
+      };
+      // createProxy(values)
+      for (var _name in arg0) {
+        _loop(_name);
+      }
+    }
+  };
+  var excludedNames = {
+    expression: true,
+    docs: true,
+    type: true,
+    classes: true,
+    json: true,
+    error: true,
+    isChain: true // conflicts with the property isChain of a Chain instance
+  };
+
+  // create proxy for everything that is in math.js
+  Chain.createProxy(math);
+
+  // register on the import event, automatically add a proxy for every imported function.
+  if (on) {
+    on('import', function (name, resolver, path) {
+      if (!path) {
+        // an imported function (not a data type or something special)
+        createLazyProxy(name, resolver);
+      }
+    });
+  }
+  return Chain;
+}, {
+  isClass: true
+});
+exports.createChainClass = createChainClass;

package/lib/cjs/type/chain/function/chain.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createChain = void 0;
+var _factory = require("../../../utils/factory.js");
+var name = 'chain';
+var dependencies = ['typed', 'Chain'];
+var createChain = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    Chain = _ref.Chain;
+  /**
+   * Wrap any value in a chain, allowing to perform chained operations on
+   * the value.
+   *
+   * All methods available in the math.js library can be called upon the chain,
+   * and then will be evaluated with the value itself as first argument.
+   * The chain can be closed by executing `chain.done()`, which returns
+   * the final value.
+   *
+   * The chain has a number of special functions:
+   *
+   * - `done()`     Finalize the chain and return the chain's value.
+   * - `valueOf()`  The same as `done()`
+   * - `toString()` Executes `math.format()` onto the chain's value, returning
+   *                a string representation of the value.
+   *
+   * Syntax:
+   *
+   *    math.chain(value)
+   *
+   * Examples:
+   *
+   *     math.chain(3)
+   *         .add(4)
+   *         .subtract(2)
+   *         .done()     // 5
+   *
+   *     math.chain( [[1, 2], [3, 4]] )
+   *         .subset(math.index(0, 0), 8)
+   *         .multiply(3)
+   *         .done()     // [[24, 6], [9, 12]]
+   *
+   * @param {*} [value]   A value of any type on which to start a chained operation.
+   * @return {math.Chain} The created chain
+   */
+  return typed(name, {
+    '': function _() {
+      return new Chain();
+    },
+    any: function any(value) {
+      return new Chain(value);
+    }
+  });
+});
+exports.createChain = createChain;

package/lib/cjs/type/complex/Complex.js

@@ -0,0 +1,203 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createComplexClass = void 0;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _complex = _interopRequireDefault(require("complex.js"));
+var _number = require("../../utils/number.js");
+var _is = require("../../utils/is.js");
+var _factory = require("../../utils/factory.js");
+var name = 'Complex';
+var dependencies = [];
+var createComplexClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function () {
+  /**
+   * Attach type information
+   */
+  Object.defineProperty(_complex["default"], 'name', {
+    value: 'Complex'
+  });
+  _complex["default"].prototype.constructor = _complex["default"];
+  _complex["default"].prototype.type = 'Complex';
+  _complex["default"].prototype.isComplex = true;
+
+  /**
+   * Get a JSON representation of the complex number
+   * @returns {Object} Returns a JSON object structured as:
+   *                   `{"mathjs": "Complex", "re": 2, "im": 3}`
+   */
+  _complex["default"].prototype.toJSON = function () {
+    return {
+      mathjs: 'Complex',
+      re: this.re,
+      im: this.im
+    };
+  };
+
+  /*
+   * Return the value of the complex number in polar notation
+   * The angle phi will be set in the interval of [-pi, pi].
+   * @return {{r: number, phi: number}} Returns and object with properties r and phi.
+   */
+  _complex["default"].prototype.toPolar = function () {
+    return {
+      r: this.abs(),
+      phi: this.arg()
+    };
+  };
+
+  /**
+   * Get a string representation of the complex number,
+   * with optional formatting options.
+   * @param {Object | number | Function} [options]  Formatting options. See
+   *                                                lib/utils/number:format for a
+   *                                                description of the available
+   *                                                options.
+   * @return {string} str
+   */
+  _complex["default"].prototype.format = function (options) {
+    var str = '';
+    var im = this.im;
+    var re = this.re;
+    var strRe = (0, _number.format)(this.re, options);
+    var strIm = (0, _number.format)(this.im, options);
+
+    // round either re or im when smaller than the configured precision
+    var precision = (0, _is.isNumber)(options) ? options : options ? options.precision : null;
+    if (precision !== null) {
+      var epsilon = Math.pow(10, -precision);
+      if (Math.abs(re / im) < epsilon) {
+        re = 0;
+      }
+      if (Math.abs(im / re) < epsilon) {
+        im = 0;
+      }
+    }
+    if (im === 0) {
+      // real value
+      str = strRe;
+    } else if (re === 0) {
+      // purely complex value
+      if (im === 1) {
+        str = 'i';
+      } else if (im === -1) {
+        str = '-i';
+      } else {
+        str = strIm + 'i';
+      }
+    } else {
+      // complex value
+      if (im < 0) {
+        if (im === -1) {
+          str = strRe + ' - i';
+        } else {
+          str = strRe + ' - ' + strIm.substring(1) + 'i';
+        }
+      } else {
+        if (im === 1) {
+          str = strRe + ' + i';
+        } else {
+          str = strRe + ' + ' + strIm + 'i';
+        }
+      }
+    }
+    return str;
+  };
+
+  /**
+   * Create a complex number from polar coordinates
+   *
+   * Usage:
+   *
+   *     Complex.fromPolar(r: number, phi: number) : Complex
+   *     Complex.fromPolar({r: number, phi: number}) : Complex
+   *
+   * @param {*} args...
+   * @return {Complex}
+   */
+  _complex["default"].fromPolar = function (args) {
+    switch (arguments.length) {
+      case 1:
+        {
+          var arg = arguments[0];
+          if ((0, _typeof2["default"])(arg) === 'object') {
+            return (0, _complex["default"])(arg);
+          } else {
+            throw new TypeError('Input has to be an object with r and phi keys.');
+          }
+        }
+      case 2:
+        {
+          var r = arguments[0];
+          var phi = arguments[1];
+          if ((0, _is.isNumber)(r)) {
+            if ((0, _is.isUnit)(phi) && phi.hasBase('ANGLE')) {
+              // convert unit to a number in radians
+              phi = phi.toNumber('rad');
+            }
+            if ((0, _is.isNumber)(phi)) {
+              return new _complex["default"]({
+                r: r,
+                phi: phi
+              });
+            }
+            throw new TypeError('Phi is not a number nor an angle unit.');
+          } else {
+            throw new TypeError('Radius r is not a number.');
+          }
+        }
+      default:
+        throw new SyntaxError('Wrong number of arguments in function fromPolar');
+    }
+  };
+  _complex["default"].prototype.valueOf = _complex["default"].prototype.toString;
+
+  /**
+   * Create a Complex number from a JSON object
+   * @param {Object} json  A JSON Object structured as
+   *                       {"mathjs": "Complex", "re": 2, "im": 3}
+   *                       All properties are optional, default values
+   *                       for `re` and `im` are 0.
+   * @return {Complex} Returns a new Complex number
+   */
+  _complex["default"].fromJSON = function (json) {
+    return new _complex["default"](json);
+  };
+
+  /**
+   * Compare two complex numbers, `a` and `b`:
+   *
+   * - Returns 1 when the real part of `a` is larger than the real part of `b`
+   * - Returns -1 when the real part of `a` is smaller than the real part of `b`
+   * - Returns 1 when the real parts are equal
+   *   and the imaginary part of `a` is larger than the imaginary part of `b`
+   * - Returns -1 when the real parts are equal
+   *   and the imaginary part of `a` is smaller than the imaginary part of `b`
+   * - Returns 0 when both real and imaginary parts are equal.
+   *
+   * @params {Complex} a
+   * @params {Complex} b
+   * @returns {number} Returns the comparison result: -1, 0, or 1
+   */
+  _complex["default"].compare = function (a, b) {
+    if (a.re > b.re) {
+      return 1;
+    }
+    if (a.re < b.re) {
+      return -1;
+    }
+    if (a.im > b.im) {
+      return 1;
+    }
+    if (a.im < b.im) {
+      return -1;
+    }
+    return 0;
+  };
+  return _complex["default"];
+}, {
+  isClass: true
+});
+exports.createComplexClass = createComplexClass;

package/lib/cjs/type/complex/function/complex.js

@@ -0,0 +1,95 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createComplex = void 0;
+var _factory = require("../../../utils/factory.js");
+var _collection = require("../../../utils/collection.js");
+var name = 'complex';
+var dependencies = ['typed', 'Complex'];
+var createComplex = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    Complex = _ref.Complex;
+  /**
+   * Create a complex value or convert a value to a complex value.
+   *
+   * Syntax:
+   *
+   *     math.complex()                           // creates a complex value with zero
+   *                                              // as real and imaginary part.
+   *     math.complex(re : number, im : string)   // creates a complex value with provided
+   *                                              // values for real and imaginary part.
+   *     math.complex(re : number)                // creates a complex value with provided
+   *                                              // real value and zero imaginary part.
+   *     math.complex(complex : Complex)          // clones the provided complex value.
+   *     math.complex(arg : string)               // parses a string into a complex value.
+   *     math.complex(array : Array)              // converts the elements of the array
+   *                                              // or matrix element wise into a
+   *                                              // complex value.
+   *     math.complex({re: number, im: number})   // creates a complex value with provided
+   *                                              // values for real an imaginary part.
+   *     math.complex({r: number, phi: number})   // creates a complex value with provided
+   *                                              // polar coordinates
+   *
+   * Examples:
+   *
+   *    const a = math.complex(3, -4)     // a = Complex 3 - 4i
+   *    a.re = 5                          // a = Complex 5 - 4i
+   *    const i = a.im                    // Number -4
+   *    const b = math.complex('2 + 6i')  // Complex 2 + 6i
+   *    const c = math.complex()          // Complex 0 + 0i
+   *    const d = math.add(a, b)          // Complex 5 + 2i
+   *
+   * See also:
+   *
+   *    bignumber, boolean, index, matrix, number, string, unit
+   *
+   * @param {* | Array | Matrix} [args]
+   *            Arguments specifying the real and imaginary part of the complex number
+   * @return {Complex | Array | Matrix} Returns a complex value
+   */
+  return typed('complex', {
+    '': function _() {
+      return Complex.ZERO;
+    },
+    number: function number(x) {
+      return new Complex(x, 0);
+    },
+    'number, number': function numberNumber(re, im) {
+      return new Complex(re, im);
+    },
+    // TODO: this signature should be redundant
+    'BigNumber, BigNumber': function BigNumberBigNumber(re, im) {
+      return new Complex(re.toNumber(), im.toNumber());
+    },
+    Fraction: function Fraction(x) {
+      return new Complex(x.valueOf(), 0);
+    },
+    Complex: function Complex(x) {
+      return x.clone();
+    },
+    string: function string(x) {
+      return Complex(x); // for example '2 + 3i'
+    },
+
+    "null": function _null(x) {
+      return Complex(0);
+    },
+    Object: function Object(x) {
+      if ('re' in x && 'im' in x) {
+        return new Complex(x.re, x.im);
+      }
+      if ('r' in x && 'phi' in x || 'abs' in x && 'arg' in x) {
+        return new Complex(x);
+      }
+      throw new Error('Expected object with properties (re and im) or (r and phi) or (abs and arg)');
+    },
+    'Array | Matrix': typed.referToSelf(function (self) {
+      return function (x) {
+        return (0, _collection.deepMap)(x, self);
+      };
+    })
+  });
+});
+exports.createComplex = createComplex;

package/lib/cjs/type/fraction/Fraction.js

@@ -0,0 +1,49 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createFractionClass = void 0;
+var _fraction = _interopRequireDefault(require("fraction.js"));
+var _factory = require("../../utils/factory.js");
+var name = 'Fraction';
+var dependencies = [];
+var createFractionClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function () {
+  /**
+   * Attach type information
+   */
+  Object.defineProperty(_fraction["default"], 'name', {
+    value: 'Fraction'
+  });
+  _fraction["default"].prototype.constructor = _fraction["default"];
+  _fraction["default"].prototype.type = 'Fraction';
+  _fraction["default"].prototype.isFraction = true;
+
+  /**
+   * Get a JSON representation of a Fraction containing type information
+   * @returns {Object} Returns a JSON object structured as:
+   *                   `{"mathjs": "Fraction", "n": 3, "d": 8}`
+   */
+  _fraction["default"].prototype.toJSON = function () {
+    return {
+      mathjs: 'Fraction',
+      n: this.s * this.n,
+      d: this.d
+    };
+  };
+
+  /**
+   * Instantiate a Fraction from a JSON object
+   * @param {Object} json  a JSON object structured as:
+   *                       `{"mathjs": "Fraction", "n": 3, "d": 8}`
+   * @return {BigNumber}
+   */
+  _fraction["default"].fromJSON = function (json) {
+    return new _fraction["default"](json);
+  };
+  return _fraction["default"];
+}, {
+  isClass: true
+});
+exports.createFractionClass = createFractionClass;