mathjs-min 11.7.2

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

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

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

@@ -0,0 +1,194 @@
+import Complex from 'complex.js';
+import { format } from '../../utils/number.js';
+import { isNumber, isUnit } from '../../utils/is.js';
+import { factory } from '../../utils/factory.js';
+var name = 'Complex';
+var dependencies = [];
+export var createComplexClass = /* #__PURE__ */factory(name, dependencies, () => {
+  /**
+   * Attach type information
+   */
+  Object.defineProperty(Complex, 'name', {
+    value: 'Complex'
+  });
+  Complex.prototype.constructor = Complex;
+  Complex.prototype.type = 'Complex';
+  Complex.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.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.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.prototype.format = function (options) {
+    var str = '';
+    var im = this.im;
+    var re = this.re;
+    var strRe = format(this.re, options);
+    var strIm = format(this.im, options);
+
+    // round either re or im when smaller than the configured precision
+    var precision = 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.fromPolar = function (args) {
+    switch (arguments.length) {
+      case 1:
+        {
+          var arg = arguments[0];
+          if (typeof arg === 'object') {
+            return Complex(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 (isNumber(r)) {
+            if (isUnit(phi) && phi.hasBase('ANGLE')) {
+              // convert unit to a number in radians
+              phi = phi.toNumber('rad');
+            }
+            if (isNumber(phi)) {
+              return new Complex({
+                r,
+                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.prototype.valueOf = Complex.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.fromJSON = function (json) {
+    return new Complex(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.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;
+}, {
+  isClass: true
+});

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

@@ -0,0 +1,86 @@
+import { factory } from '../../../utils/factory.js';
+import { deepMap } from '../../../utils/collection.js';
+var name = 'complex';
+var dependencies = ['typed', 'Complex'];
+export var createComplex = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    Complex
+  } = _ref;
+  /**
+   * 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(self => x => deepMap(x, self))
+  });
+});

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

@@ -0,0 +1,41 @@
+import Fraction from 'fraction.js';
+import { factory } from '../../utils/factory.js';
+var name = 'Fraction';
+var dependencies = [];
+export var createFractionClass = /* #__PURE__ */factory(name, dependencies, () => {
+  /**
+   * Attach type information
+   */
+  Object.defineProperty(Fraction, 'name', {
+    value: 'Fraction'
+  });
+  Fraction.prototype.constructor = Fraction;
+  Fraction.prototype.type = 'Fraction';
+  Fraction.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.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.fromJSON = function (json) {
+    return new Fraction(json);
+  };
+  return Fraction;
+}, {
+  isClass: true
+});

package/lib/esm/type/fraction/function/fraction.js

@@ -0,0 +1,75 @@
+import { factory } from '../../../utils/factory.js';
+import { deepMap } from '../../../utils/collection.js';
+var name = 'fraction';
+var dependencies = ['typed', 'Fraction'];
+export var createFraction = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    Fraction
+  } = _ref;
+  /**
+   * Create a fraction or convert a value to a fraction.
+   *
+   * With one numeric argument, produces the closest rational approximation to the
+   * input.
+   * With two arguments, the first is the numerator and the second is the denominator,
+   * and creates the corresponding fraction. Both numerator and denominator must be
+   * integers.
+   * With one object argument, looks for the integer numerator as the value of property
+   * 'n' and the integer denominator as the value of property 'd'.
+   * With a matrix argument, creates a matrix of the same shape with entries
+   * converted into fractions.
+   *
+   * Syntax:
+   *     math.fraction(value)
+   *     math.fraction(numerator, denominator)
+   *     math.fraction({n: numerator, d: denominator})
+   *     math.fraction(matrix: Array | Matrix)
+   *
+   * Examples:
+   *
+   *     math.fraction(6.283)             // returns Fraction 6283/1000
+   *     math.fraction(1, 3)              // returns Fraction 1/3
+   *     math.fraction('2/3')             // returns Fraction 2/3
+   *     math.fraction({n: 2, d: 3})      // returns Fraction 2/3
+   *     math.fraction([0.2, 0.25, 1.25]) // returns Array [1/5, 1/4, 5/4]
+   *     math.fraction(4, 5.1)            // throws Error: Parameters must be integer
+   *
+   * See also:
+   *
+   *    bignumber, number, string, unit
+   *
+   * @param {number | string | Fraction | BigNumber | Array | Matrix} [args]
+   *            Arguments specifying the value, or numerator and denominator of
+   *            the fraction
+   * @return {Fraction | Array | Matrix} Returns a fraction
+   */
+  return typed('fraction', {
+    number: function number(x) {
+      if (!isFinite(x) || isNaN(x)) {
+        throw new Error(x + ' cannot be represented as a fraction');
+      }
+      return new Fraction(x);
+    },
+    string: function string(x) {
+      return new Fraction(x);
+    },
+    'number, number': function numberNumber(numerator, denominator) {
+      return new Fraction(numerator, denominator);
+    },
+    null: function _null(x) {
+      return new Fraction(0);
+    },
+    BigNumber: function BigNumber(x) {
+      return new Fraction(x.toString());
+    },
+    Fraction: function Fraction(x) {
+      return x; // fractions are immutable
+    },
+
+    Object: function Object(x) {
+      return new Fraction(x);
+    },
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
+  });
+});