mathjs 5.0.0 → 5.0.4

package/docs/core/configuration.md

@@ -13,7 +13,7 @@ The following configuration options are available:
 
 - `epsilon`. The minimum relative difference used to test equality between two
   compared values. This value is used by all relational functions.
-  Default value is `1e-14`.
+  Default value is `1e-12`.
 
 - `matrix`. The default type of matrix output for functions.
   Available values are: `'Matrix'` (default) or `'Array'`.

package/docs/datatypes/numbers.md

@@ -82,7 +82,7 @@ option `epsilon`. In pseudo code (without exceptions for 0, Infinity and NaN):
 where:
 
  - `EPSILON` is the relative difference between x and y. Epsilon is configurable
-   and is `1e-14` by default. See [Configuration](../core/configuration.md).
+   and is `1e-12` by default. See [Configuration](../core/configuration.md).
  - `DBL_EPSILON` is the minimum positive floating point number such that
    `1.0 + DBL_EPSILON !== 1.0`. This is a constant with a value of approximately
    `2.2204460492503130808472633361816e-16`.

package/docs/datatypes/units.md

@@ -183,7 +183,7 @@ when they have the same base and same value when normalized to SI units.
 
 ### unit.format([options])
 Get a string representation of the unit. The function
-will determine the best fitting prefix for the unit. See the [Format](../functions/format.md)
+will determine the best fitting prefix for the unit. See the [Format](../reference/functions/format.md)
 page for available options.
 
 ### unit.fromJSON(json)

package/docs/expressions/algebra.md

@@ -17,7 +17,7 @@ console.log(math.simplify('x^2 + x + 3 + x^2').toString())      // '2 * x ^ 2 +
 console.log(math.simplify('x * y * -x / (x ^ 2)').toString())   // '-y'
 ```
 
-The function accepts either a string or an expression tree (`Node`) as input, and outputs a simplified expression tree (`Node`). This node tree can be transformed and evaluated as described in detail on the page [Expression trees]('./expression_trees.md').
+The function accepts either a string or an expression tree (`Node`) as input, and outputs a simplified expression tree (`Node`). This node tree can be transformed and evaluated as described in detail on the page [Expression trees](expression_trees.md).
 
 ```js
 // work with an expression tree, evaluate results
@@ -57,3 +57,27 @@ console.log(dh.eval({x: 3}))      // '7'
 The rules used by `math.derivative` can be found on Wikipedia:
 
 - [Differentiation rules (Wikipedia)](http://en.wikipedia.org/wiki/Differentiation_rules)
+
+
+## Rationalize
+
+The function [`math.transform`](../reference/functions/transform.md)  transforms a rationalizable expression in a rational fraction.
+If rational fraction is one variable polynomial then converts the numerator and denominator in canonical form, with decreasing exponents, returning the coefficients of numerator.
+
+```js
+
+math.rationalize('2x/y - y/(x+1)')
+              // (2*x^2-y^2+2*x)/(x*y+y)
+math.rationalize('(2x+1)^6')
+              // 64*x^6+192*x^5+240*x^4+160*x^3+60*x^2+12*x+1
+math.rationalize('2x/( (2x-1) / (3x+2) ) - 5x/ ( (3x+4) / (2x^2-5) ) + 3')
+              // -20*x^4+28*x^3+104*x^2+6*x-12)/(6*x^2+5*x-4)
+
+math.rationalize('x+x+x+y',{y:1}) // 3*x+1
+math.rationalize('x+x+x+y',{})    // 3*x+y
+
+const ret = math.rationalize('x+x+x+y',{},true)
+              // ret.expression=3*x+y, ret.variables = ["x","y"]
+const ret = math.rationalize('-2+5x^2',{},true)
+              // ret.expression=5*x^2-2, ret.variables = ["x"], ret.coefficients=[-2,0,5]
+```

package/docs/getting_started.md

@@ -19,7 +19,7 @@ Other ways to install math.js are described on the [website](http://mathjs.org/d
 Math.js can be used in node.js and in the browser. The library must be loaded
 and instantiated. When creating an instance, one can optionally provide
 configuration options as described in
-[Configuration](configuration.md).
+[Configuration](core/configuration.md).
 
 ### ES6 modules
 
@@ -91,7 +91,7 @@ require(['mathjs'], function (math) {
 
 Math.js can be used similar to JavaScript's built-in Math library. Besides that,
 math.js can evaluate expressions (see [Expressions](expressions/index.md)) and
-supports chaining (see [Chaining](chaining.md)).
+supports chaining (see [Chaining](core/chaining.md)).
 
 The example code below shows how to use math.js. More examples can be found in the
 section [Examples](http://mathjs.org/examples/index.html).

package/docs/reference/functions/format.md

@@ -38,8 +38,8 @@ math.format(value, callback)
        For example '123.4' and '1.4e7'.
    - `precision: number`
      A number between 0 and 16 to round the digits of the number. In case
-     of notations 'exponential' and 'auto', `precision` defines the total
-     number of significant digits returned.
+     of notations 'exponential', 'engineering', and 'auto', `precision`
+     defines the total number of significant digits returned.
      In case of notation 'fixed', `precision` defines the number of
      significant digits after the decimal point.
      `precision` is undefined by default.

package/docs/reference/functions/qr.md

@@ -55,4 +55,5 @@ const result = math.qr(m)
 
 ## See also
 
-[lu](lu.md)
+[lup](lup.md),
+[lusolve](lusolve.md)

package/docs/reference/functions/rationalize.md

@@ -35,22 +35,25 @@ Object | Expression Node | The rational polynomial of `expr` or na object {
 ## Examples
 
 ```js
-math.rationalize('sin(x)+y')  //  Error: There is an unsolved function call
-math.rationalize('2x/y - y/(x+1)')  // (2*x^2-y^2+2*x)/(x*y+y)
+math.rationalize('sin(x)+y')
+              //  Error: There is an unsolved function call
+math.rationalize('2x/y - y/(x+1)')
+              // (2*x^2-y^2+2*x)/(x*y+y)
 math.rationalize('(2x+1)^6')
-              //     64*x^6+192*x^5+240*x^4+160*x^3+60*x^2+12*x+1
+              // 64*x^6+192*x^5+240*x^4+160*x^3+60*x^2+12*x+1
 math.rationalize('2x/( (2x-1) / (3x+2) ) - 5x/ ( (3x+4) / (2x^2-5) ) + 3')
-              //    -20*x^4+28*x^3+104*x^2+6*x-12)/(6*x^2+5*x-4)
+              // -20*x^4+28*x^3+104*x^2+6*x-12)/(6*x^2+5*x-4)
 math.rationalize('x/(1-x)/(x-2)/(x-3)/(x-4) + 2x/ ( (1-2x)/(2-3x) )/ ((3-4x)/(4-5x) )') =
-              //  (-30*x^7+344*x^6-1506*x^5+3200*x^4-3472*x^3+1846*x^2-381*x)/
-              //   (-8*x^6+90*x^5-383*x^4+780*x^3-797*x^2+390*x-72)
+              // (-30*x^7+344*x^6-1506*x^5+3200*x^4-3472*x^3+1846*x^2-381*x)/
+              //     (-8*x^6+90*x^5-383*x^4+780*x^3-797*x^2+390*x-72)
 
 math.rationalize('x+x+x+y',{y:1}) // 3*x+1
 math.rationalize('x+x+x+y',{})    // 3*x+y
-ret = math.rationalize('x+x+x+y',{},true)
-                     // ret.expression=3*x+y,  ret.variables = ["x","y"]
-ret = math.rationalize('-2+5x^2',{},true)
-                     // ret.expression=5*x^2-2,  ret.variables = ["x"], ret.coefficients=[-2,0,5]
+
+const ret = math.rationalize('x+x+x+y',{},true)
+              // ret.expression=3*x+y, ret.variables = ["x","y"]
+const ret = math.rationalize('-2+5x^2',{},true)
+              // ret.expression=5*x^2-2, ret.variables = ["x"], ret.coefficients=[-2,0,5]
 ```
 
 

package/docs/reference/functions/stirlingS2.md

@@ -39,4 +39,4 @@ math.stirlingS2(5, 3) //returns 25
 
 ## See also
 
-[Bell numbers](Bell numbers.md)
+[bellNumbers](bellNumbers.md)

package/docs/reference/functions/typeof.md

@@ -29,19 +29,19 @@ math.type.Matrix       | `'Matrix'`    | `math.typeof(math.matrix([[1,2], [3, 4]
 math.type.Range        | `'Range'`     | `math.typeof(math.range(0, 10))`
 math.type.ResultSet    | `'ResultSet'` | `math.typeof(math.eval('a=2\nb=3'))`
 math.type.Unit         | `'Unit'`      | `math.typeof(math.unit('45 deg'))`
-math.expression.node.AccessorNode            | `'AccessorNode'`            | `math.typeof(math.parse('A[2]'))`
-math.expression.node.ArrayNode               | `'ArrayNode'`               | `math.typeof(math.parse('[1,2,3]'))`
-math.expression.node.AssignmentNode          | `'AssignmentNode'`          | `math.typeof(math.parse('x=2'))`
-math.expression.node.BlockNode               | `'BlockNode'`               | `math.typeof(math.parse('a=2; b=3'))`
-math.expression.node.ConditionalNode         | `'ConditionalNode'`         | `math.typeof(math.parse('x<0 ? -x : x'))`
-math.expression.node.ConstantNode            | `'ConstantNode'`            | `math.typeof(math.parse('2.3'))`
-math.expression.node.FunctionAssignmentNode  | `'FunctionAssignmentNode'`  | `math.typeof(math.parse('f(x)=x^2'))`
-math.expression.node.FunctionNode            | `'FunctionNode'`            | `math.typeof(math.parse('sqrt(4)'))`
-math.expression.node.IndexNode               | `'IndexNode'`               | `math.typeof(math.parse('A[2]').index)`
-math.expression.node.ObjectNode              | `'ObjectNode'`              | `math.typeof(math.parse('{a:2}'))`
-math.expression.node.ParenthesisNode         | `'ParenthesisNode'`         | `math.typeof(math.parse('(2+3)'))`
-math.expression.node.RangeNode               | `'RangeNode'`               | `math.typeof(math.parse('1:10'))`
-math.expression.node.SymbolNode              | `'SymbolNode'`              | `math.typeof(math.parse('x'))`
+math.expression.node&#8203;.AccessorNode            | `'AccessorNode'`            | `math.typeof(math.parse('A[2]'))`
+math.expression.node&#8203;.ArrayNode               | `'ArrayNode'`               | `math.typeof(math.parse('[1,2,3]'))`
+math.expression.node&#8203;.AssignmentNode          | `'AssignmentNode'`          | `math.typeof(math.parse('x=2'))`
+math.expression.node&#8203;.BlockNode               | `'BlockNode'`               | `math.typeof(math.parse('a=2; b=3'))`
+math.expression.node&#8203;.ConditionalNode         | `'ConditionalNode'`         | `math.typeof(math.parse('x<0 ? -x : x'))`
+math.expression.node&#8203;.ConstantNode            | `'ConstantNode'`            | `math.typeof(math.parse('2.3'))`
+math.expression.node&#8203;.FunctionAssignmentNode  | `'FunctionAssignmentNode'`  | `math.typeof(math.parse('f(x)=x^2'))`
+math.expression.node&#8203;.FunctionNode            | `'FunctionNode'`            | `math.typeof(math.parse('sqrt(4)'))`
+math.expression.node&#8203;.IndexNode               | `'IndexNode'`               | `math.typeof(math.parse('A[2]').index)`
+math.expression.node&#8203;.ObjectNode              | `'ObjectNode'`              | `math.typeof(math.parse('{a:2}'))`
+math.expression.node&#8203;.ParenthesisNode         | `'ParenthesisNode'`         | `math.typeof(math.parse('(2+3)'))`
+math.expression.node&#8203;.RangeNode               | `'RangeNode'`               | `math.typeof(math.parse('1:10'))`
+math.expression.node&#8203;.SymbolNode              | `'SymbolNode'`              | `math.typeof(math.parse('x'))`
 
 
 ## Syntax

package/examples/advanced/add_new_datatypes/MyType.js

@@ -20,16 +20,6 @@ function factory (type, config, load, typed) {
     }
   })
 
-  // define conversions if applicable
-  typed.addConversion({
-    from: 'number',
-    to: 'MyType',
-    convert: function (x) {
-      // convert a number to MyType
-      return new MyType(x)
-    }
-  })
-
   // return the construction function, this will
   // be added to math.type.MyType when imported
   return MyType

package/examples/advanced/add_new_datatypes/index.js

@@ -8,9 +8,5 @@ math.import(require('./myAdd'))
 const MyType = math.type.MyType
 
 // use the new type
-const ans1 = math.add(new MyType(2), new MyType(3)) // returns MyType(5)
-console.log(ans1.toString()) // outputs 'MyType:5'
-
-// numbers will be converted to MyType
-const ans2 = math.add(new MyType(4), 7) // returns MyType(11)
-console.log(ans2.toString()) // outputs 'MyType:11'
+const ans = math.add(new MyType(2), new MyType(3)) // returns MyType(5)
+console.log(ans.toString()) // outputs 'MyType:5'

package/examples/browser/rocket_trajectory_optimization.html

@@ -68,9 +68,9 @@
 
     // Define the equations of motion. It is important to maintain the same argument order for each of these functions.
     sim.eval("drdt(r, v, m, phi, gamma) = v sin(gamma)")
-    sim.eval("dvdt(r, v, m, phi, gamma) = -mu / r^2 sin(gamma) + T / m")
+    sim.eval("dvdt(r, v, m, phi, gamma) = -mu / r^2 * sin(gamma) + T / m")
     sim.eval("dmdt(r, v, m, phi, gamma) = -T/g0/isp")
-    sim.eval("dphidt(r, v, m, phi, gamma) = v/r cos(gamma) * rad")
+    sim.eval("dphidt(r, v, m, phi, gamma) = v/r * cos(gamma) * rad")
     sim.eval("dgammadt(r, v, m, phi, gamma) = (1/r * (v - mu / (r v)) * cos(gamma)) * rad")
 
     // Again, remember to maintain the same variable order in the call to ndsolve.

package/lib/constants.js

@@ -80,7 +80,9 @@ function factory(type, config, load, typed, math) {
   }
 
   // complex i
-  setConstant(math, 'i', type.Complex.I);
+  if (type.Complex) {
+    setConstant(math, 'i', type.Complex.I);
+  }
 
   // meta information
   setConstant(math, 'version', require('./version'));

package/lib/core/function/import.js

@@ -153,6 +153,15 @@ function factory(type, config, load, typed, math) {
     }
   }
 
+  function _deleteTransform(name) {
+    delete math.expression.transform[name];
+    if (allowedInExpressions(name)) {
+      math.expression.mathWithTransform[name] = math[name];
+    } else {
+      delete math.expression.mathWithTransform[name];
+    }
+  }
+
   /**
    * Create a wrapper a round an function which converts the arguments
    * to their primitive values (like convert a Matrix to Array)
@@ -219,7 +228,9 @@ function factory(type, config, load, typed, math) {
       if (factory.lazy !== false) {
         lazy(namespace, name, resolver);
 
-        if (!existingTransform) {
+        if (existingTransform) {
+          _deleteTransform(name);
+        } else {
           if (factory.path === 'expression.transform' || factoryAllowedInExpressions(factory)) {
             lazy(math.expression.mathWithTransform, name, resolver);
           }
@@ -227,7 +238,9 @@ function factory(type, config, load, typed, math) {
       } else {
         namespace[name] = resolver();
 
-        if (!existingTransform) {
+        if (existingTransform) {
+          _deleteTransform(name);
+        } else {
           if (factory.path === 'expression.transform' || factoryAllowedInExpressions(factory)) {
             math.expression.mathWithTransform[name] = resolver();
           }

package/lib/core/typed.js

@@ -150,7 +150,7 @@ exports.create = function create(type) {
   // define all types. The order of the types determines in which order function
   // arguments are type-checked (so for performance it's important to put the
   // most used types first).
-  typed.types = [{ name: 'number', test: type.isNumber }, { name: 'Complex', test: type.isComplex }, { name: 'BigNumber', test: type.isBigNumber }, { name: 'Fraction', test: type.isFraction }, { name: 'Unit', test: type.isUnit }, { name: 'string', test: type.isString }, { name: 'Array', test: type.isArray }, { name: 'Matrix', test: type.isMatrix }, { name: 'DenseMatrix', test: type.isDenseMatrix }, { name: 'SparseMatrix', test: type.isSparseMatrix }, { name: 'Range', test: type.isRange }, { name: 'Index', test: type.isIndex }, { name: 'boolean', test: type.isBoolean }, { name: 'ResultSet', test: type.isResultSet }, { name: 'Help', test: type.isHelp }, { name: 'function', test: type.isFunction }, { name: 'Date', test: type.isDate }, { name: 'RegExp', test: type.isRegExp }, { name: 'null', test: type.isNull }, { name: 'undefined', test: type.isUndefined }, { name: 'OperatorNode', test: type.isOperatorNode }, { name: 'ConstantNode', test: type.isConstantNode }, { name: 'SymbolNode', test: type.isSymbolNode }, { name: 'ParenthesisNode', test: type.isParenthesisNode }, { name: 'FunctionNode', test: type.isFunctionNode }, { name: 'FunctionAssignmentNode', test: type.isFunctionAssignmentNode }, { name: 'ArrayNode', test: type.isArrayNode }, { name: 'AssignmentNode', test: type.isAssignmentNode }, { name: 'BlockNode', test: type.isBlockNode }, { name: 'ConditionalNode', test: type.isConditionalNode }, { name: 'IndexNode', test: type.isIndexNode }, { name: 'RangeNode', test: type.isRangeNode }, { name: 'Node', test: type.isNode }, { name: 'Object', test: type.isObject // order 'Object' last, it's a tricky one
+  typed.types = [{ name: 'number', test: type.isNumber }, { name: 'Complex', test: type.isComplex }, { name: 'BigNumber', test: type.isBigNumber }, { name: 'Fraction', test: type.isFraction }, { name: 'Unit', test: type.isUnit }, { name: 'string', test: type.isString }, { name: 'Array', test: type.isArray }, { name: 'Matrix', test: type.isMatrix }, { name: 'DenseMatrix', test: type.isDenseMatrix }, { name: 'SparseMatrix', test: type.isSparseMatrix }, { name: 'Range', test: type.isRange }, { name: 'Index', test: type.isIndex }, { name: 'boolean', test: type.isBoolean }, { name: 'ResultSet', test: type.isResultSet }, { name: 'Help', test: type.isHelp }, { name: 'function', test: type.isFunction }, { name: 'Date', test: type.isDate }, { name: 'RegExp', test: type.isRegExp }, { name: 'null', test: type.isNull }, { name: 'undefined', test: type.isUndefined }, { name: 'OperatorNode', test: type.isOperatorNode }, { name: 'ConstantNode', test: type.isConstantNode }, { name: 'SymbolNode', test: type.isSymbolNode }, { name: 'ParenthesisNode', test: type.isParenthesisNode }, { name: 'FunctionNode', test: type.isFunctionNode }, { name: 'FunctionAssignmentNode', test: type.isFunctionAssignmentNode }, { name: 'ArrayNode', test: type.isArrayNode }, { name: 'AssignmentNode', test: type.isAssignmentNode }, { name: 'BlockNode', test: type.isBlockNode }, { name: 'ConditionalNode', test: type.isConditionalNode }, { name: 'IndexNode', test: type.isIndexNode }, { name: 'RangeNode', test: type.isRangeNode }, { name: 'Node', test: type.isNode }, { name: 'Object', test: type.isObject // order 'Object' last, it matches on other classes too
   }];
 
   // TODO: add conversion from BigNumber to number?

package/lib/expression/node/FunctionNode.js

@@ -2,6 +2,8 @@
 
 var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
 
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
 var latex = require('../../utils/latex');
 var escape = require('../../utils/string').escape;
 var hasOwnProperty = require('../../utils/object').hasOwnProperty;
@@ -84,7 +86,6 @@ function factory(type, config, load, typed, math) {
     var evalArgs = map(this.args, function (arg) {
       return arg._compile(math, argNames);
     });
-    // const jsScope = compileScope(defs, args) // TODO: jsScope
 
     if (type.isSymbolNode(this.fn)) {
       // we can statically determine whether the function has an rawArgs property
@@ -97,7 +98,7 @@ function factory(type, config, load, typed, math) {
         // "raw" evaluation
         var rawArgs = this.args;
         return function evalFunctionNode(scope, args, context) {
-          return (name in scope ? getSafeProperty(scope, name) : fn)(rawArgs, math, scope);
+          return (name in scope ? getSafeProperty(scope, name) : fn)(rawArgs, math, _extends({}, scope, args));
         };
       } else {
         // "regular" evaluation
@@ -132,7 +133,7 @@ function factory(type, config, load, typed, math) {
         validateSafeMethod(object, prop);
         var isRaw = object[prop] && object[prop].rawArgs;
 
-        return isRaw ? object[prop](_rawArgs, math, scope) // "raw" evaluation
+        return isRaw ? object[prop](_rawArgs, math, _extends({}, scope, args)) // "raw" evaluation
         : object[prop].apply(object, map(evalArgs, function (evalArg) {
           // "regular" evaluation
           return evalArg(scope, args, context);
@@ -148,7 +149,7 @@ function factory(type, config, load, typed, math) {
         var fn = evalFn(scope, args, context);
         var isRaw = fn && fn.rawArgs;
 
-        return isRaw ? fn(_rawArgs2, math, scope) // "raw" evaluation
+        return isRaw ? fn(_rawArgs2, math, _extends({}, scope, args)) // "raw" evaluation
         : fn.apply(fn, map(evalArgs, function (evalArg) {
           // "regular" evaluation
           return evalArg(scope, args, context);