mathjs 3.1.3 → 3.1.4

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;
@@ -1196,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/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/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;

package/lib/function/trigonometry/tanh.js

@@ -62,10 +62,10 @@ function factory (type, config, load, typed) {
  * @returns {number}
  * @private
  */
-function _tanh (x) {
+var _tanh = Math.tanh || function (x) {
   var e = Math.exp(2 * x);
   return (e - 1) / (e + 1);
-}
+};
 
 exports.name = 'tanh';
 exports.factory = factory;

package/lib/type/unit/Unit.js

@@ -2633,6 +2633,9 @@ function factory (type, config, load, typed, math) {
     hr: 'hour',
     hrs: 'hour',
     days: 'day',
+    weeks: 'week',
+    months: 'month',
+    years: 'year',
 
     hertz: 'hertz',
 

package/lib/utils/number.js

@@ -28,7 +28,7 @@ exports.isInteger = function(value) {
  * @param {number} x
  * @returns {*}
  */
-exports.sign = function(x) {
+exports.sign = Math.sign || function(x) {
   if (x > 0) {
     return 1;
   }

package/lib/version.js

@@ -1,3 +1,3 @@
-module.exports = '3.1.3';
+module.exports = '3.1.4';
 // Note: This file is automatically generated when building math.js.
 // Changes made in this file will be overwritten.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mathjs",
-  "version": "3.1.3",
+  "version": "3.1.4",
   "description": "Math.js is an extensive math library for JavaScript and Node.js. It features a flexible expression parser and offers an integrated solution to work with numbers, big numbers, complex numbers, units, and matrices.",
   "author": "Jos de Jong <wjosdejong@gmail.com> (https://github.com/josdejong)",
   "contributors": [

package/test/expression/node/FunctionNode.test.js

@@ -362,6 +362,18 @@ describe('FunctionNode', function() {
     assert.equal(n.toString(), 'sqrt(4)');
   });
 
+  it ('should pass options when stringifying a FunctionNode', function () {
+    var s = new SymbolNode('sqrt');
+    var a = new ConstantNode(2);
+    var b = new SymbolNode('x');
+    var c = new OperatorNode('*', 'multiply', [a, b], true); // implicit
+    var n = new FunctionNode(s, [c]);
+
+    assert.equal(n.toString(), 'sqrt(2 x)');
+    var options = {implicit: 'show'};
+    assert.equal(n.toString(options), 'sqrt(2 * x)');
+  });
+
   it ('should stringify a FunctionNode with custom toString', function () {
     //Also checks if the custom functions get passed on to the children
     var customFunction = function (node, options) {

package/test/expression/parse.test.js

@@ -231,6 +231,17 @@ describe('parse', function() {
       assert.throws(function () {parseAndEval('.'); }, SyntaxError);
       assert.throws(function () {parseAndEval('3.2.2'); }, SyntaxError);
       assert.throws(function () {parseAndEval('3.2e2.2'); }, SyntaxError);
+      
+      assert.throws(function () {parseAndEval('3e0.5'); }, /Digit expected, got "."/);
+      assert.throws(function () {parseAndEval('3e.5'); }, /Digit expected, got "."/);
+      assert.throws(function () {parseAndEval('-3e0.5'); }, /Digit expected, got "."/);
+      assert.throws(function () {parseAndEval('-3e.5'); }, /Digit expected, got "."/);
+      assert.throws(function () {parseAndEval('3e-0.5'); }, /Digit expected, got "."/);
+      assert.throws(function () {parseAndEval('3e-.5'); }, /Digit expected, got "."/);
+      assert.throws(function () {parseAndEval('-3e-0.5'); }, /Digit expected, got "."/);
+      assert.throws(function () {parseAndEval('-3e-.5'); }, /Digit expected, got "."/);
+
+      assert.throws(function () {parseAndEval('2e+a'); }, /Digit expected, got "a"/);
     });
 
   });
@@ -274,6 +285,15 @@ describe('parse', function() {
       assert.deepEqual(parseAndEval('   "hi" '), "hi");
     });
 
+    it('should parse a with escaped characters', function() {
+      assert.deepEqual(parseAndEval('"line end\\nnext"'), 'line end\nnext');
+      assert.deepEqual(parseAndEval('"line end\\n"'), 'line end\n');
+      assert.deepEqual(parseAndEval('"tab\\tnext"'), 'tab\tnext');
+      assert.deepEqual(parseAndEval('"tab\\t"'), 'tab\t');
+      assert.deepEqual(parseAndEval('"escaped backslash\\\\next"'), 'escaped backslash\\next');
+      assert.deepEqual(parseAndEval('"escaped backslash\\\\"'), 'escaped backslash\\');
+    });
+
     it('should throw an error with invalid strings', function() {
       assert.throws(function () {parseAndEval('"hi'); }, SyntaxError);
       assert.throws(function () {parseAndEval(' hi" '); }, Error);
@@ -364,9 +384,9 @@ describe('parse', function() {
       approx.deepEqual(parseAndEval('2 in to meter'), new Unit(2, 'inch').to('meter'));
       approx.deepEqual(parseAndEval('2 in in meter'), new Unit(2, 'inch').to('meter'));
       approx.deepEqual(parseAndEval('a in inch', {a: new Unit(5.08, 'cm')}), new Unit(2, 'inch').to('inch'));
-      // Note: the following is not supported (due to conflicts):
-      //approx.deepEqual(parseAndEval('(2+3) in'), new Unit(5, 'inch'));
-      //approx.deepEqual(parseAndEval('a in', {a: 5}), new Unit(5, 'inch'));
+      approx.deepEqual(parseAndEval('(2+3) in'), new Unit(5, 'in'));
+      approx.deepEqual(parseAndEval('a in', {a: 5}), new Unit(5, 'in'));
+      approx.deepEqual(parseAndEval('0.5in + 1.5in to cm'), new Unit(5.08, 'cm').to('cm'));
     });
   });