mathjs 8.1.0 → 12.2.1

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

@@ -3,13 +3,13 @@ import { format } from '../../utils/string.js';
 import { hasOwnProperty, lazy } from '../../utils/object.js';
 import { factory } from '../../utils/factory.js';
 var name = 'Chain';
-var dependencies = ['?on', 'math'];
-export var createChainClass = /* #__PURE__ */factory(name, dependencies, (_ref) => {
+var dependencies = ['?on', 'math', 'typed'];
+export var createChainClass = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     on,
-    math
+    math,
+    typed
   } = _ref;
-
   /**
    * @constructor Chain
    * Wrap any value in a chain, allowing to perform chained operations on
@@ -32,60 +32,56 @@ export var createChainClass = /* #__PURE__ */factory(name, dependencies, (_ref)
     if (!(this instanceof Chain)) {
       throw new SyntaxError('Constructor must be called with the new operator');
     }
-
     if (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 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
@@ -93,11 +89,10 @@ export var createChainClass = /* #__PURE__ */factory(name, dependencies, (_ref)
    *                       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
@@ -105,13 +100,12 @@ export var createChainClass = /* #__PURE__ */factory(name, dependencies, (_ref)
    *                           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
@@ -119,38 +113,48 @@ export var createChainClass = /* #__PURE__ */factory(name, dependencies, (_ref)
    *                              function to be proxied
    * @private
    */
-
-
   function createLazyProxy(name, resolver) {
     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 () {
-      var args = [this.value]; // `this` will be the context of a Chain instance
-
+      // 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:
@@ -165,8 +169,6 @@ export var createChainClass = /* #__PURE__ */factory(name, dependencies, (_ref)
    *                                 functions
    * @param {*} [arg1]               A function, when arg0 is a name
    */
-
-
   Chain.createProxy = function (arg0, arg1) {
     if (typeof arg0 === 'string') {
       // createProxy(name, value)
@@ -177,14 +179,12 @@ export var createChainClass = /* #__PURE__ */factory(name, dependencies, (_ref)
           createLazyProxy(_name, () => arg0[_name]);
         }
       };
-
       // createProxy(values)
       for (var _name in arg0) {
         _loop(_name);
       }
     }
   };
-
   var excludedNames = {
     expression: true,
     docs: true,
@@ -193,11 +193,12 @@ export var createChainClass = /* #__PURE__ */factory(name, dependencies, (_ref)
     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.
+  // 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) {
@@ -206,7 +207,6 @@ export var createChainClass = /* #__PURE__ */factory(name, dependencies, (_ref)
       }
     });
   }
-
   return Chain;
 }, {
   isClass: true

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

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

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

@@ -8,14 +8,18 @@ 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',
@@ -23,19 +27,19 @@ export var createComplexClass = /* #__PURE__ */factory(name, dependencies, () =>
       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.
@@ -45,29 +49,24 @@ export var createComplexClass = /* #__PURE__ */factory(name, dependencies, () =>
    *                                                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 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;
@@ -96,9 +95,9 @@ export var createComplexClass = /* #__PURE__ */factory(name, dependencies, () =>
         }
       }
     }
-
     return str;
   };
+
   /**
    * Create a complex number from polar coordinates
    *
@@ -110,51 +109,43 @@ export var createComplexClass = /* #__PURE__ */factory(name, dependencies, () =>
    * @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: r,
-                phi: phi
+                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
@@ -163,10 +154,10 @@ export var createComplexClass = /* #__PURE__ */factory(name, dependencies, () =>
    *                       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`:
    *
@@ -182,28 +173,21 @@ export var createComplexClass = /* #__PURE__ */factory(name, dependencies, () =>
    * @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

@@ -2,12 +2,11 @@ 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) => {
+export var createComplex = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     Complex
   } = _ref;
-
   /**
    * Create a complex value or convert a value to a complex value.
    *
@@ -76,15 +75,11 @@ export var createComplex = /* #__PURE__ */factory(name, dependencies, (_ref) =>
       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': function ArrayMatrix(x) {
-      return deepMap(x, this);
-    }
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
   });
 });

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

@@ -6,14 +6,18 @@ 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',
@@ -21,18 +25,16 @@ export var createFractionClass = /* #__PURE__ */factory(name, dependencies, () =
       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

@@ -2,34 +2,45 @@ 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) => {
+export var createFraction = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     Fraction
   } = _ref;
-
   /**
-   * Create a fraction convert a value to a fraction.
+   * 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)         Turn all matrix entries
-   *                                                   into fractions
+   *     math.fraction(matrix: Array | Matrix)
    *
    * Examples:
    *
-   *     math.fraction(1, 3)
-   *     math.fraction('2/3')
-   *     math.fraction({n: 2, d: 3})
-   *     math.fraction([0.2, 0.25, 1.25])
+   *     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 numerator and denominator of
+   * @param {number | string | Fraction | BigNumber | Unit | Array | Matrix} [args]
+   *            Arguments specifying the value, or numerator and denominator of
    *            the fraction
    * @return {Fraction | Array | Matrix} Returns a fraction
    */
@@ -38,7 +49,6 @@ export var createFraction = /* #__PURE__ */factory(name, dependencies, (_ref) =>
       if (!isFinite(x) || isNaN(x)) {
         throw new Error(x + ' cannot be represented as a fraction');
       }
-
       return new Fraction(x);
     },
     string: function string(x) {
@@ -56,11 +66,14 @@ export var createFraction = /* #__PURE__ */factory(name, dependencies, (_ref) =>
     Fraction: function Fraction(x) {
       return x; // fractions are immutable
     },
+    Unit: typed.referToSelf(self => x => {
+      var clone = x.clone();
+      clone.value = self(x.value);
+      return clone;
+    }),
     Object: function Object(x) {
       return new Fraction(x);
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return deepMap(x, this);
-    }
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
   });
 });