mathjs 3.1.0 → 3.1.4

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/collection/containsCollections.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var isCollection = require('./isCollection');
+
+/**
+ * Test whether an array contains collections
+ * @param {Array} array
+ * @returns {boolean} Returns true when the array contains one or multiple
+ *                    collections (Arrays or Matrices). Returns false otherwise.
+ */
+module.exports = function containsCollections (array) {
+  for (var i = 0; i < array.length; i++) {
+    if (isCollection(array[i])) {
+      return true;
+    }
+  }
+  return false;
+};

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/utils/types.js

@@ -42,3 +42,13 @@ exports.type = function(x) {
 
   return type;
 };
+
+/**
+ * Test whether a value is a scalar
+ * @param x
+ * @return {boolean} Returns true when x is a scalar, returns false when
+ *                   x is a Matrix or Array.
+ */
+exports.isScalar = function (x) {
+  return !((x && x.isMatrix) || Array.isArray(x));
+};

package/lib/version.js

@@ -1,3 +1,3 @@
-module.exports = '3.1.0';
+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.0",
+  "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'));
     });
   });
 
@@ -1053,6 +1073,7 @@ describe('parse', function() {
 
       assert.equal(parseAndEval('(2+3)a', {a:2}), 10);
       assert.equal(parseAndEval('(2+3)2'), 10);
+      assert.equal(parseAndEval('(2)(3)+4'), 10);
       assert.equal(parseAndEval('2(3+4)'), 14);
       assert.equal(parseAndEval('(2+3)-2'), 3); // no implicit multiplication, just a unary minus
       assert.equal(parseAndEval('a(2+3)', {a: function() {return 42;}}), 42);        // function call

package/test/function/arithmetic/nthRoot.test.js

@@ -56,6 +56,11 @@ describe('nthRoot', function() {
     approx.equal(nthRoot(-64, -3), -0.25);
   });
 
+  it('should return the nthRoot for zero', function() {
+    assert.equal(nthRoot(0, 2), 0);
+    assert.equal(nthRoot(0, -2), Infinity);
+  });
+
   it('should return the nthRoot for infinity', function() {
     approx.equal(nthRoot(Infinity, 2), Infinity);
     approx.equal(nthRoot(-Infinity, 3), -Infinity);
@@ -94,6 +99,11 @@ describe('nthRoot', function() {
     assert.deepEqual(nthRoot(big(-64), big(-3)), big(-0.25));
   });
 
+  it('should return the nthRoot for bignumber zero', function() {
+    assert.deepEqual(nthRoot(big(0), big(2)).toString(), '0');
+    assert.deepEqual(nthRoot(big(0), big(-2)).toString(), 'Infinity');
+  });
+
   it('should return the nthRoot for bignumber infinity', function() {
     assert.deepEqual(nthRoot(big(Infinity), big(2)).toString(), 'Infinity');
     assert.deepEqual(nthRoot(big(-Infinity), big(3)).toString(), '-Infinity');

package/test/function/statistics/max.test.js

@@ -78,6 +78,11 @@ describe('max', function() {
     assert.throws(function () {max(new Complex(3,4), 6)}, TypeError);
   });
 
+  it('should throw an error when called multiple arrays or matrices', function() {
+    assert.throws(function () {max([1,2], [3,4])}, /Scalar values expected/);
+    assert.throws(function () {max(math.matrix([1,2]), math.matrix([3,4]))}, /Scalar values expected/);
+  });
+
   it('should throw an error if called a dimension out of range', function() {
     assert.throws(function() {max([1,2,3], -1)}, /IndexError: Index out of range \(-1 < 0\)/);
     assert.throws(function() {max([1,2,3], 1)}, /IndexError: Index out of range \(1 > 0\)/);

package/test/function/statistics/mean.test.js

@@ -78,6 +78,11 @@ describe('mean', function() {
     assert.throws(function() {mean([], 2, 3)});
   });
 
+  it('should throw an error when called multiple arrays or matrices', function() {
+    assert.throws(function () {mean([1,2], [3,4])}, /Scalar values expected/);
+    assert.throws(function () {mean(math.matrix([1,2]), math.matrix([3,4]))}, /Scalar values expected/);
+  });
+
   it('should throw an error if called a dimension out of range', function() {
     assert.throws(function() {mean([1,2,3], -1)}, /IndexError: Index out of range \(-1 < 0\)/);
     assert.throws(function() {mean([1,2,3], 1)}, /IndexError: Index out of range \(1 > 0\)/);

package/test/function/statistics/median.test.js

@@ -73,6 +73,11 @@ describe('median', function() {
     assert.throws(function() {median([], 2, 3)});
   });
 
+  it('should throw an error when called multiple arrays or matrices', function() {
+    assert.throws(function () {median([1,2], [3,4])}, /Scalar values expected/);
+    assert.throws(function () {median(math.matrix([1,2]), math.matrix([3,4]))}, /Scalar values expected/);
+  });
+
   it('should throw an error if called with not yet supported argument dim', function() {
     assert.throws(function() {median([], 2)}, /not yet supported/);
   });

package/test/function/statistics/min.test.js

@@ -87,6 +87,11 @@ describe('min', function() {
     assert.throws(function () {min(new Complex(3,4), 6)}, TypeError);
   });
 
+  it('should throw an error when called multiple arrays or matrices', function() {
+    assert.throws(function () {min([1,2], [3,4])}, /Scalar values expected/);
+    assert.throws(function () {min(math.matrix([1,2]), math.matrix([3,4]))}, /Scalar values expected/);
+  });
+
   it('should throw an error if called a dimension out of range', function() {
     assert.throws(function() {min([1,2,3], -1)}, /IndexError: Index out of range \(-1 < 0\)/);
     assert.throws(function() {min([1,2,3], 1)}, /IndexError: Index out of range \(1 > 0\)/);

package/test/function/trigonometry/sinh.test.js

@@ -1,35 +1,46 @@
-var assert = require('assert'),
-    error = require('../../../lib/error/index'),
-    math = require('../../../index'),
-    approx = require('../../../tools/approx'),
-    pi = math.pi,
-    complex = math.complex,
-    matrix = math.matrix,
-    unit = math.unit,
-    sinh = math.sinh,
-    bigmath = math.create({number: 'BigNumber', precision: 20});
+var assert = require('assert');
+var error = require('../../../lib/error/index');
+var math = require('../../../index');
+var approx = require('../../../tools/approx');
+var complex = math.complex;
+var matrix = math.matrix;
+var unit = math.unit;
+var sinh = math.sinh;
+var bigmath = math.create({number: 'BigNumber', precision: 20});
+
+var EPSILON = 1e-14;
+
 
 describe('sinh', function() {
   it('should return the sinh of a boolean', function () {
-    approx.equal(sinh(true), 1.1752011936438014);
-    approx.equal(sinh(false), 0);
+    assert.equal(sinh(true), 1.1752011936438014);
+    assert.equal(sinh(false), 0);
   });
 
   it('should return the sinh of a null', function () {
-    approx.equal(sinh(null), 0);
+    assert.equal(sinh(null), 0);
   });
 
   it('should return the sinh of a number', function() {
-    approx.equal(sinh(0), 0);
-    approx.equal(sinh(pi), 11.548739357257748);
-    approx.equal(sinh(1), 1.1752011936438014);
+    approx.equal(sinh(-2), -3.62686040784701876766821398280126170488634201232113572130, EPSILON);
+    approx.equal(sinh(-0.5), -0.52109530549374736162242562641149155910592898261148052794, EPSILON);
+    approx.equal(sinh(0), 0, EPSILON);
+    approx.equal(sinh(0.3), 0.304520293447142618958435267005095229098024232680179727377, EPSILON);
+    approx.equal(sinh(0.5), 0.521095305493747361622425626411491559105928982611480527946, EPSILON);
+    approx.equal(sinh(0.8), 0.888105982187623006574717573189756980559709596888150052610, EPSILON);
+    approx.equal(sinh(1), 1.175201193643801456882381850595600815155717981334095870229, EPSILON);
+    approx.equal(sinh(2), 3.626860407847018767668213982801261704886342012321135721309, EPSILON);
   });
 
-  it('should return the sinh of very small numbers (avoid returning zero)', function() {
-    // If sinh returns 0, that is bad, so we are using assert.equal, not approx.equal
-    assert.equal(sinh(-1e-10), -1e-10);
-    assert.equal(sinh(1e-50), 1e-50);
-  })
+  if (!/v0\.10|v0\.12/.test(process.version)) {
+    // skip this test on node v0.10 and v0.12, which have a numerical issue
+
+    it('should return the sinh of very small numbers (avoid returning zero)', function() {
+      // If sinh returns 0, that is bad, so we are using assert.equal, not approx.equal
+      assert.equal(sinh(-1e-10), -1e-10);
+      assert.equal(sinh(1e-50), 1e-50);
+    });
+  }
 
   it('should return the sinh of a bignumber', function() {
     var sinhBig = bigmath.sinh;
@@ -56,19 +67,19 @@ describe('sinh', function() {
   });
 
   it('should return the sinh of a complex number', function() {
-    approx.deepEqual(sinh(complex('1')), complex(1.1752011936438014, 0));
-    approx.deepEqual(sinh(complex('i')), complex(0, 0.8414709848079));
-    approx.deepEqual(sinh(complex('2 + i')), complex(1.9596010414216, 3.1657785132162));
+    approx.deepEqual(sinh(complex('1')), complex(1.1752011936438014, 0), EPSILON);
+    approx.deepEqual(sinh(complex('i')), complex(0, 0.8414709848079), EPSILON);
+    approx.deepEqual(sinh(complex('2 + i')), complex(1.9596010414216, 3.1657785132162), EPSILON);
   });
 
   it('should return the sinh of an angle', function() {
-    approx.equal(sinh(unit('90deg')), 2.3012989023073);
-    approx.equal(sinh(unit('-45deg')), -0.86867096148601);
+    approx.equal(sinh(unit('90deg')), 2.3012989023073, EPSILON);
+    approx.equal(sinh(unit('-45deg')), -0.86867096148601, EPSILON);
 
     assert(sinh(unit(math.bignumber(90), 'deg')).isBigNumber);
-    approx.equal(sinh(unit(math.bignumber(90), 'deg')).toNumber(), 2.3012989023073);
+    approx.equal(sinh(unit(math.bignumber(90), 'deg')).toNumber(), 2.3012989023073, EPSILON);
 
-    approx.deepEqual(sinh(unit(complex('2 + i'), 'rad')), complex(1.9596010414216, 3.1657785132162));
+    approx.deepEqual(sinh(unit(complex('2 + i'), 'rad')), complex(1.9596010414216, 3.1657785132162), EPSILON);
   });
 
   it('should throw an error if called with an invalid unit', function() {
@@ -82,11 +93,11 @@ describe('sinh', function() {
   var sinh123 = [1.1752011936438014, 3.626860407847, 10.01787492741];
 
   it('should return the sinh of each element of an array', function() {
-    approx.deepEqual(sinh([1,2,3]), sinh123);
+    approx.deepEqual(sinh([1,2,3]), sinh123, EPSILON);
   });
 
   it('should return the sinh of each element of a matrix', function() {
-    approx.deepEqual(sinh(matrix([1,2,3])), matrix(sinh123));
+    approx.deepEqual(sinh(matrix([1,2,3])), matrix(sinh123), EPSILON);
   });
 
   it('should throw an error in case of invalid number of arguments', function() {