mathjs 3.1.0 → 3.1.4

package/docs/expressions/customization.md

@@ -332,6 +332,7 @@ var latex = expression.toTex({handler: customLaTeX});
 You can change the way that implicit multiplication is converted to a string or LaTeX. The two options are `hide`, to not show a multiplication operator for implicit multiplication and `show` to show it.
 
 Example:
+
 ```js
 var node = math.parse('2a');
 

package/docs/reference/functions/format.md

@@ -11,7 +11,7 @@ Format a value of any type into a string.
 math.format(value)
 math.format(value, options)
 math.format(value, precision)
-math.format(value, fn)
+math.format(value, callback)
 ```
 
 ### Where
@@ -47,10 +47,12 @@ math.format(value, fn)
    - `fraction: string`. Available values: 'ratio' (default) or 'decimal'.
      For example `format(fraction(1, 3))` will output '1/3' when 'ratio' is
      configured, and will output `0.(3)` when 'decimal' is configured.
-- `fn: Function`
-  A custom formatting function. Can be used to override the built-in notations.
-  Function `fn` is called with `value` as parameter and must return a string.
-  Is useful for example to format all values inside a matrix in a particular way.
+- `callback: function`
+  A custom formatting function, invoked for all numeric elements in `value`,
+  for example all elements of a matrix, or the real and imaginary
+  parts of a complex number. This callback can be used to override the
+  built-in numeric notation with any type of formatting. Function `callback`
+  is called with `value` as parameter and must return a string.
 
 ### Parameters
 
@@ -77,6 +79,11 @@ math.format(21385, 2);                                   // returns '21000'
 math.format(12.071, {notation: 'fixed'});                // returns '12'
 math.format(2.3,    {notation: 'fixed', precision: 2});  // returns '2.30'
 math.format(52.8,   {notation: 'exponential'});          // returns '5.28e+1'
+
+function formatCurrency(value) {
+  return '$' + value.toFixed(2);
+}
+math.format([2.1, 3, 0.016], formatCurrency};            // returns '[$2.10, $3.00, $0.02]'
 ```
 
 

package/docs/reference/functions/log10.md

@@ -2,7 +2,7 @@
 
 # Function log10
 
-Calculate the 10-base of a value. This is the same as calculating `log(x, 10)`.
+Calculate the 10-base logarithm of a value. This is the same as calculating `log(x, 10)`.
 
 For matrices, the function is evaluated element wise.
 

package/docs/reference/functions.md

@@ -64,7 +64,7 @@ Function | Description
 [math.hypot(a, b, ...)](functions/hypot.md) | Calculate the hypotenusa of a list with values.
 [math.lcm(a, b)](functions/lcm.md) | Calculate the least common multiple for two or more values or arrays.
 [math.log(x [, base])](functions/log.md) | Calculate the logarithm of a value.
-[math.log10(x)](functions/log10.md) | Calculate the 10-base of a value.
+[math.log10(x)](functions/log10.md) | Calculate the 10-base logarithm of a value.
 [math.mod(x, y)](functions/mod.md) | Calculates the modulus, the remainder of an integer division.
 [math.multiply(x, y)](functions/multiply.md) | Multiply two values, `x * y`.
 [math.norm(x [, p])](functions/norm.md) | Calculate the norm of a number, vector or matrix.

package/lib/expression/node/FunctionNode.js

@@ -195,7 +195,7 @@ function factory (type, config, load, typed, math) {
    */
   FunctionNode.prototype.toString = function (options) {
     var customString;
-    var name = this.fn.toString();
+    var name = this.fn.toString(options);
     if (options && (typeof options.handler === 'object') && options.handler.hasOwnProperty(name)) {
       //callback is a map of callback functions
       customString = options.handler[name](this, options);
@@ -215,8 +215,12 @@ function factory (type, config, load, typed, math) {
    * @return {string} str
    */
   FunctionNode.prototype._toString = function (options) {
-    // format the parameters like "add(2, 4.2)"
-    return this.fn.toString() + '(' + this.args.join(', ') + ')';
+    var args = this.args.map(function (arg) {
+      return arg.toString(options);
+    });
+
+    // format the arguments like "add(2, 4.2)"
+    return this.fn.toString(options) + '(' + args.join(', ') + ')';
   };
 
   /*
@@ -328,9 +332,6 @@ function factory (type, config, load, typed, math) {
    * @return {string} str
    */
   FunctionNode.prototype._toTex = function (options) {
-    var parenthesis = (options && options.parenthesis) ? options.parenthesis : 'keep';
-
-
     var args = this.args.map(function (arg) { //get LaTeX of the arguments
       return arg.toTex(options);
     });

package/lib/expression/node/OperatorNode.js

@@ -14,10 +14,10 @@ function factory (type, config, load, typed, math) {
    * @extends {Node}
    * An operator with two arguments, like 2+3
    *
-   * @param {string} op       Operator name, for example '+'
-   * @param {string} fn       Function name, for example 'add'
-   * @param {Node[]} args     Operator arguments
-   * @param {boolean} implicit Is this an implicit multiplication?
+   * @param {string} op           Operator name, for example '+'
+   * @param {string} fn           Function name, for example 'add'
+   * @param {Node[]} args         Operator arguments
+   * @param {boolean} [implicit]  Is this an implicit multiplication?
    */
   function OperatorNode(op, fn, args, implicit) {
     if (!(this instanceof OperatorNode)) {

package/lib/expression/parse.js

@@ -271,7 +271,7 @@ function factory (type, config, load, typed) {
         next();
 
         if (!isDigit(c)) {
-          // this is no legal number, it is just a dot
+          // this is no legal number, it is just a dot (can be dot notation)
           token_type = TOKENTYPE.UNKNOWN;
         }
       }
@@ -292,24 +292,33 @@ function factory (type, config, load, typed) {
 
       // check for exponential notation like "2.3e-4", "1.23e50" or "2e+4"
       c2 = nextPreview();
-      if ((c == 'E' || c == 'e') && (isDigit(c2) || c2 == '-' || c2 == '+')) {
-        token += c;
-        next();
-
-        if (c == '+' || c == '-') {
+      if (c == 'E' || c == 'e') {
+        if (isDigit(c2) || c2 == '-' || c2 == '+') {
           token += c;
           next();
-        }
 
-        // Scientific notation MUST be followed by an exponent
-        if (!isDigit(c)) {
-          // this is no legal number, exponent is missing.
-          token_type = TOKENTYPE.UNKNOWN;
-        }
+          if (c == '+' || c == '-') {
+            token += c;
+            next();
+          }
 
-        while (isDigit(c)) {
-          token += c;
+          // Scientific notation MUST be followed by an exponent
+          if (!isDigit(c)) {
+            throw createSyntaxError('Digit expected, got "' + c + '"');
+          }
+
+          while (isDigit(c)) {
+            token += c;
+            next();
+          }
+
+          if (c == '.') {
+            throw createSyntaxError('Digit expected, got "' + c + '"');
+          }
+        }
+        else if (c2 == '.') {
           next();
+          throw createSyntaxError('Digit expected, got "' + c + '"');
         }
       }
 
@@ -774,8 +783,16 @@ function factory (type, config, load, typed) {
       fn = operators[name];
 
       getTokenSkipNewline();
-      params = [node, parseRange()];
-      node = new OperatorNode(name, fn, params);
+      
+      if (name === 'in' && token === '') {
+        // end of expression -> this is the unit 'in' ('inch')
+        node = new OperatorNode('*', 'multiply', [node, new SymbolNode('in')], true);
+      }
+      else {
+        // operator 'a to b' or 'a in b'
+        params = [node, parseRange()];
+        node = new OperatorNode(name, fn, params);
+      }
     }
 
     return node;
@@ -1121,7 +1138,8 @@ function factory (type, config, load, typed) {
         }
         else {
           // implicit multiplication like (2+3)(4+5)
-          node = new OperatorNode('*', 'multiply', [node, parseAssignment()], true /*implicit*/);
+          // next parse operation is parseUnary, the one after parseMultiplyDivide
+          node = new OperatorNode('*', 'multiply', [node, parseUnary()], true /*implicit*/);
         }
       }
       else if (token == '[') {
@@ -1195,11 +1213,15 @@ function factory (type, config, load, typed) {
    */
   function parseStringToken () {
     var str = '';
-    var tPrev = '';
 
-    while (c != '' && (c != '\"' || tPrev == '\\')) { // also handle escape character
+    while (c != '' && c != '\"') {
+      if (c == '\\') {
+        // escape character
+        str += c;
+        next();
+      }
+
       str += c;
-      tPrev = c;
       next();
     }
 

package/lib/function/arithmetic/cbrt.js

@@ -67,38 +67,6 @@ function factory (type, config, load, typed) {
     }
   });
 
-  /**
-   * Calculate cbrt for a number
-   *
-   * Code from es6-shim.js:
-   *   https://github.com/paulmillr/es6-shim/blob/master/es6-shim.js#L1564-L1577
-   *
-   * @param {number} x
-   * @returns {number | Complex} Returns the cubic root of x
-   * @private
-   */
-  function _cbrtNumber(x) {
-    if (x === 0) {
-      return x;
-    }
-
-    var negate = x < 0;
-    var result;
-    if (negate) {
-      x = -x;
-    }
-
-    if (isFinite(x)) {
-      result = Math.exp(Math.log(x) / 3);
-      // from http://en.wikipedia.org/wiki/Cube_root#Numerical_methods
-      result = (x / (result * result) + (2 * result)) / 3;
-    } else {
-      result = x;
-    }
-
-    return negate ? -result : result;
-  }
-
   /**
    * Calculate the cubic root for a complex number
    * @param {Complex} x
@@ -181,5 +149,37 @@ function factory (type, config, load, typed) {
   return cbrt;
 }
 
+/**
+ * Calculate cbrt for a number
+ *
+ * Code from es6-shim.js:
+ *   https://github.com/paulmillr/es6-shim/blob/master/es6-shim.js#L1564-L1577
+ *
+ * @param {number} x
+ * @returns {number | Complex} Returns the cubic root of x
+ * @private
+ */
+var _cbrtNumber = Math.cbrt || function (x) {
+  if (x === 0) {
+    return x;
+  }
+
+  var negate = x < 0;
+  var result;
+  if (negate) {
+    x = -x;
+  }
+
+  if (isFinite(x)) {
+    result = Math.exp(Math.log(x) / 3);
+    // from http://en.wikipedia.org/wiki/Cube_root#Numerical_methods
+    result = (x / (result * result) + (2 * result)) / 3;
+  } else {
+    result = x;
+  }
+
+  return negate ? -result : result;
+};
+
 exports.name = 'cbrt';
 exports.factory = factory;

package/lib/function/arithmetic/log10.js

@@ -4,7 +4,7 @@ var deepMap = require('../../utils/collection/deepMap');
 
 function factory (type, config, load, typed) {
   /**
-   * Calculate the 10-base of a value. This is the same as calculating `log(x, 10)`.
+   * Calculate the 10-base logarithm of a value. This is the same as calculating `log(x, 10)`.
    *
    * For matrices, the function is evaluated element wise.
    *
@@ -31,7 +31,7 @@ function factory (type, config, load, typed) {
   var log10 = typed('log10', {
     'number': function (x) {
       if (x >= 0 || config.predictable) {
-        return Math.log(x) / Math.LN10;
+        return _log10(x);
       }
       else {
         // negative value -> complex value computation
@@ -63,6 +63,16 @@ function factory (type, config, load, typed) {
   return log10;
 }
 
+/**
+ * Calculate the 10-base logarithm of a number
+ * @param {number} x
+ * @return {number}
+ * @private
+ */
+var _log10 = Math.log10 || function (x) {
+  return Math.log(x) / Math.LN10;
+};
+
 exports.name = 'log10';
 exports.factory = factory;
 

package/lib/function/arithmetic/nthRoot.js

@@ -203,7 +203,7 @@ function factory (type, config, load, typed) {
 
     // edge cases zero and infinity
     if (a.isZero()) {
-      return zero;
+      return inv ? new Big(Infinity) : 0;
     }
     if (!a.isFinite()) {
       return inv ? zero : a;
@@ -239,7 +239,7 @@ function _nthRoot(a, root) {
 
   // edge cases zero and infinity
   if (a == 0) {
-    return 0;
+    return inv ? Infinity : 0;
   }
   if (!isFinite(a)) {
     return inv ? 0 : a;

package/lib/function/statistics/max.js

@@ -2,6 +2,7 @@
 
 var deepForEach = require('../../utils/collection/deepForEach');
 var reduce = require('../../utils/collection/reduce');
+var containsCollections = require('../../utils/collection/containsCollections');
 
 function factory (type, config, load, typed) {
   var larger = load(require('../relational/larger'));
@@ -47,8 +48,12 @@ function factory (type, config, load, typed) {
     },
 
     // max(a, b, c, d, ...)
-    '...': function () {
-      return _max(arguments);
+    '...': function (args) {
+      if (containsCollections(args)) {
+        throw new TypeError('Scalar values expected in function max');
+      }
+
+      return _max(args);
     }
   });
 

package/lib/function/statistics/mean.js

@@ -3,6 +3,7 @@
 var size = require('../../utils/array').size;
 var deepForEach = require('../../utils/collection/deepForEach');
 var reduce = require('../../utils/collection/reduce');
+var containsCollections = require('../../utils/collection/containsCollections');
 
 function factory (type, config, load, typed) {
   var add = load(require('../arithmetic/add'));
@@ -43,8 +44,12 @@ function factory (type, config, load, typed) {
     'Array | Matrix, number | BigNumber': _nmean,
 
     // mean(a, b, c, d, ...)
-    '...': function () {
-      return _mean(arguments);
+    '...': function (args) {
+      if (containsCollections(args)) {
+        throw new TypeError('Scalar values expected in function mean');
+      }
+
+      return _mean(args);
     }
   });
 

package/lib/function/statistics/median.js

@@ -1,6 +1,8 @@
 'use strict';
 
 var flatten = require('../../utils/array').flatten;
+var reduce = require('../../utils/collection/reduce');
+var containsCollections = require('../../utils/collection/containsCollections');
 
 function factory (type, config, load, typed) {
   var add = load(require('../arithmetic/addScalar'));
@@ -46,8 +48,12 @@ function factory (type, config, load, typed) {
     },
 
     // median(a, b, c, d, ...)
-    '...': function () {
-      return _median(Array.prototype.slice.call(arguments));
+    '...': function (args) {
+      if (containsCollections(args)) {
+          throw new TypeError('Scalar values expected in function median');
+      }
+
+      return _median(args);
     }
   });
 

package/lib/function/statistics/min.js

@@ -2,6 +2,7 @@
 
 var deepForEach = require('../../utils/collection/deepForEach');
 var reduce = require('../../utils/collection/reduce');
+var containsCollections = require('../../utils/collection/containsCollections');
 
 function factory (type, config, load, typed) {
   var smaller = load(require('../relational/smaller'));
@@ -47,8 +48,12 @@ function factory (type, config, load, typed) {
     },
 
     // min(a, b, c, d, ...)
-    '...': function () {
-      return _min(arguments);
+    '...': function (args) {
+      if (containsCollections(args)) {
+        throw new TypeError('Scalar values expected in function min');
+      }
+
+      return _min(args);
     }
   });
 

package/lib/function/statistics/mode.js

@@ -33,8 +33,8 @@ function factory (type, config, load, typed) {
   var mode = typed('mode', {
     'Array | Matrix' : _mode,
     
-    '...': function () {
-      return _mode(Array.prototype.slice.call(arguments));
+    '...': function (args) {
+      return _mode(args);
     }
   });
   
@@ -42,7 +42,7 @@ function factory (type, config, load, typed) {
 
   /**
    * Calculates the mode in an 1-dimensional array
-   * @param {Array} array
+   * @param {Array} values
    * @return {number} mode
    * @private
    */

package/lib/function/statistics/prod.js

@@ -42,8 +42,8 @@ function factory (type, config, load, typed) {
     },
 
     // prod(a, b, c, d, ...)
-    '...': function () {
-      return _prod(arguments);
+    '...': function (args) {
+      return _prod(args);
     }
   });
 

package/lib/function/statistics/std.js

@@ -52,8 +52,8 @@ function factory (type, config, load, typed) {
     'Array | Matrix, string': _std,
 
     // std(a, b, c, d, ...)
-    '...': function () {
-      return _std(Array.prototype.slice.call(arguments));
+    '...': function (args) {
+      return _std(args);
     }
   });
   

package/lib/function/statistics/sum.js

@@ -40,9 +40,9 @@ function factory (type, config, load, typed) {
       throw new Error('sum(A, dim) is not yet supported');
     },
 
-    '...': function () {
+    '...': function (args) {
       // sum(a, b, c, d, ...)
-      return _sum(arguments);
+      return _sum(args);
     }
   });
 

package/lib/function/statistics/var.js

@@ -62,8 +62,8 @@ function factory (type, config, load, typed) {
     'Array | Matrix, string': _var,
 
     // var(a, b, c, d, ...)
-    '...': function () {
-      return _var(arguments, DEFAULT_NORMALIZATION);
+    '...': function (args) {
+      return _var(args, DEFAULT_NORMALIZATION);
     }
   });
 

package/lib/function/string/format.js

@@ -11,7 +11,7 @@ function factory (type, config, load, typed) {
    *    math.format(value)
    *    math.format(value, options)
    *    math.format(value, precision)
-   *    math.format(value, fn)
+   *    math.format(value, callback)
    *
    * Where:
    *
@@ -46,10 +46,12 @@ function factory (type, config, load, typed) {
    *    - `fraction: string`. Available values: 'ratio' (default) or 'decimal'.
    *      For example `format(fraction(1, 3))` will output '1/3' when 'ratio' is
    *      configured, and will output `0.(3)` when 'decimal' is configured.
-   * - `fn: Function`
-   *   A custom formatting function. Can be used to override the built-in notations.
-   *   Function `fn` is called with `value` as parameter and must return a string.
-   *   Is useful for example to format all values inside a matrix in a particular way.
+   * - `callback: function`
+   *   A custom formatting function, invoked for all numeric elements in `value`,
+   *   for example all elements of a matrix, or the real and imaginary
+   *   parts of a complex number. This callback can be used to override the
+   *   built-in numeric notation with any type of formatting. Function `callback`
+   *   is called with `value` as parameter and must return a string.
    *
    * When `value` is an Object:
    *
@@ -77,6 +79,11 @@ function factory (type, config, load, typed) {
    *    math.format(2.3,    {notation: 'fixed', precision: 2});  // returns '2.30'
    *    math.format(52.8,   {notation: 'exponential'});          // returns '5.28e+1'
    *
+   *    function formatCurrency(value) {
+   *      return '$' + value.toFixed(2);
+   *    }
+   *    math.format([2.1, 3, 0.016], formatCurrency};            // returns '[$2.10, $3.00, $0.02]'
+   *
    * See also:
    *
    *    print

package/lib/function/trigonometry/acosh.js

@@ -28,7 +28,7 @@ function factory (type, config, load, typed) {
   var acosh = typed('acosh', {
     'number': function (x) {
       if (x >= 1 || config.predictable) {
-        return Math.log(Math.sqrt(x*x - 1) + x);
+        return _acosh(x);
       }
       if (x <= -1) {
         return new type.Complex(Math.log(Math.sqrt(x*x - 1) - x), Math.PI);
@@ -54,5 +54,15 @@ function factory (type, config, load, typed) {
   return acosh;
 }
 
+/**
+ * Calculate the hyperbolic arccos of a number
+ * @param {number} x
+ * @return {number}
+ * @private
+ */
+var _acosh = Math.acosh || function (x) {
+  return Math.log(Math.sqrt(x*x - 1) + x)
+};
+
 exports.name = 'acosh';
 exports.factory = factory;

package/lib/function/trigonometry/asec.js

@@ -35,7 +35,7 @@ function factory (type, config, load, typed) {
       return new type.Complex(x, 0).asec();
     },
 
-    'Complex': function (x) {
+    'Complex': function (x) {
       return x.asec();
     },
 

package/lib/function/trigonometry/asinh.js

@@ -26,7 +26,7 @@ function factory (type, config, load, typed) {
    * @return {number | Complex | Array | Matrix} Hyperbolic arcsine of x
    */
   var asinh = typed('asinh', {
-    'number': function (x) {
+    'number': Math.asinh || function (x) {
       return Math.log(Math.sqrt(x*x + 1) + x);
     },
 

package/lib/function/trigonometry/atanh.js

@@ -27,7 +27,7 @@ function factory (type, config, load, typed) {
   var atanh = typed('atanh', {
     'number': function (x) {
       if ((x <= 1 && x >= -1) || config.predictable) {
-        return Math.log((1 + x)/(1 - x)) / 2;
+        return _atanh(x);
       }
       return new type.Complex(x, 0).atanh();
     },
@@ -51,5 +51,15 @@ function factory (type, config, load, typed) {
   return atanh;
 }
 
+/**
+ * Calculate the hyperbolic arctangent of a number
+ * @param {number} x
+ * @return {number}
+ * @private
+ */
+var _atanh = Math.atanh || function (x) {
+  return Math.log((1 + x)/(1 - x)) / 2
+};
+
 exports.name = 'atanh';
 exports.factory = factory;

package/lib/function/trigonometry/cosh.js

@@ -58,9 +58,9 @@ function factory (type, config, load, typed) {
  * @returns {number}
  * @private
  */
-function _cosh(x) {
+var _cosh = Math.cosh || function (x) {
   return (Math.exp(x) + Math.exp(-x)) / 2;
-}
+};
 
 exports.name = 'cosh';
 exports.factory = factory;

package/lib/function/trigonometry/sinh.js

@@ -59,13 +59,9 @@ function factory (type, config, load, typed) {
  * @returns {number}
  * @private
  */
-function _sinh (x) {
-  if (Math.abs(x) < 1) {
-    return x + (x * x * x) / 6 + (x * x * x * x * x) / 120;
-  } else {
-    return (Math.exp(x) - Math.exp(-x)) / 2;
-  }
-}
+var _sinh = Math.sinh || function (x) {
+  return (Math.exp(x) - Math.exp(-x)) / 2;
+};
 
 exports.name = 'sinh';
 exports.factory = factory;