192 lines
6.6 KiB
JavaScript
192 lines
6.6 KiB
JavaScript
/**
|
|
* Expressions can be evaluated in various ways:
|
|
*
|
|
* 1. using the function math.eval
|
|
* 2. using the function math.parse
|
|
* 3. using a parser. A parser contains functions eval and parse,
|
|
* and keeps a scope with assigned variables in memory
|
|
*/
|
|
|
|
// load math.js (using node.js)
|
|
var math = require('../index');
|
|
|
|
// 1. using the function math.eval
|
|
//
|
|
// Function `eval` accepts a single expression or an array with
|
|
// expressions as first argument, and has an optional second argument
|
|
// containing a scope with variables and functions. The scope is a regular
|
|
// JavaScript Object. The scope will be used to resolve symbols, and to write
|
|
// assigned variables or function.
|
|
console.log('1. USING FUNCTION MATH.EVAL');
|
|
|
|
// evaluate expressions
|
|
console.log('\nevaluate expressions');
|
|
print(math.eval('sqrt(3^2 + 4^2)')); // 5
|
|
print(math.eval('sqrt(-4)')); // 2i
|
|
print(math.eval('2 inch to cm')); // 5.08 cm
|
|
print(math.eval('cos(45 deg)')); // 0.70711
|
|
|
|
// evaluate multiple expressions at once
|
|
console.log('\nevaluate multiple expressions at once');
|
|
print(math.eval([
|
|
'f = 3',
|
|
'g = 4',
|
|
'f * g'
|
|
])); // [3, 4, 12]
|
|
|
|
// provide a scope (just a regular JavaScript Object)
|
|
console.log('\nevaluate expressions providing a scope with variables and functions');
|
|
var scope = {
|
|
a: 3,
|
|
b: 4
|
|
};
|
|
|
|
// variables can be read from the scope
|
|
print(math.eval('a * b', scope)); // 12
|
|
|
|
// variable assignments are written to the scope
|
|
print(math.eval('c = 2.3 + 4.5', scope)); // 6.8
|
|
print(scope.c); // 6.8
|
|
|
|
// scope can contain both variables and functions
|
|
scope.hello = function (name) {
|
|
return 'hello, ' + name + '!';
|
|
};
|
|
print(math.eval('hello("hero")', scope)); // "hello, hero!"
|
|
|
|
// define a function as an expression
|
|
var f = math.eval('f(x) = x ^ a', scope);
|
|
print(f(2)); // 8
|
|
print(scope.f(2)); // 8
|
|
|
|
|
|
|
|
// 2. using function math.parse
|
|
//
|
|
// Function `math.parse` parses expressions into a node tree. The syntax is
|
|
// similar to function `math.eval`.
|
|
// Function `parse` accepts a single expression or an array with
|
|
// expressions as first argument. The function returns a node tree, which
|
|
// then can be compiled against math, and then evaluated against an (optional
|
|
// scope. This scope is a regular JavaScript Object. The scope will be used
|
|
// to resolve symbols, and to write assigned variables or function.
|
|
console.log('\n2. USING FUNCTION MATH.PARSE');
|
|
|
|
// parse an expression
|
|
console.log('\nparse an expression into a node tree');
|
|
var node1 = math.parse('sqrt(3^2 + 4^2)');
|
|
print(node1.toString()); // "sqrt((3 ^ 2) + (4 ^ 2))"
|
|
|
|
// compile and evaluate the compiled code
|
|
// you could also do this in two steps: node1.compile().eval()
|
|
print(node1.eval()); // 5
|
|
|
|
// provide a scope
|
|
console.log('\nprovide a scope');
|
|
var node2 = math.parse('x^a');
|
|
var code2 = node2.compile();
|
|
print(node2.toString()); // "x ^ a"
|
|
var scope = {
|
|
x: 3,
|
|
a: 2
|
|
};
|
|
print(code2.eval(scope)); // 9
|
|
|
|
// change a value in the scope and re-evaluate the node
|
|
scope.a = 3;
|
|
print(code2.eval(scope)); // 27
|
|
|
|
|
|
// 3. using function math.compile
|
|
//
|
|
// Function `math.compile` compiles expressions into a node tree. The syntax is
|
|
// similar to function `math.eval`.
|
|
// Function `compile` accepts a single expression or an array with
|
|
// expressions as first argument, and returns an object with a function eval
|
|
// to evaluate the compiled expression. On evaluation, an optional scope can
|
|
// be provided. This scope will be used to resolve symbols, and to write
|
|
// assigned variables or function.
|
|
console.log('\n3. USING FUNCTION MATH.COMPILE');
|
|
|
|
// parse an expression
|
|
console.log('\ncompile an expression');
|
|
var code3 = math.compile('sqrt(3^2 + 4^2)');
|
|
|
|
// evaluate the compiled code
|
|
print(code3.eval()); // 5
|
|
|
|
// provide a scope for the variable assignment
|
|
console.log('\nprovide a scope');
|
|
var code2 = math.compile('a = a + 3');
|
|
var scope = {
|
|
a: 7
|
|
};
|
|
code2.eval(scope);
|
|
print(scope.a); // 10
|
|
|
|
|
|
// 4. using a parser
|
|
//
|
|
// In addition to the static functions `math.eval` and `math.parse`, math.js
|
|
// contains a parser with functions `eval` and `parse`, which automatically
|
|
// keeps a scope with assigned variables in memory. The parser also contains
|
|
// some convenience methods to get, set, and remove variables from memory.
|
|
console.log('\n4. USING A PARSER');
|
|
var parser = math.parser();
|
|
|
|
// evaluate with parser
|
|
console.log('\nevaluate expressions');
|
|
print(parser.eval('sqrt(3^2 + 4^2)')); // 5
|
|
print(parser.eval('sqrt(-4)')); // 2i
|
|
print(parser.eval('2 inch to cm')); // 5.08 cm
|
|
print(parser.eval('cos(45 deg)')); // 0.70711
|
|
|
|
// define variables and functions
|
|
console.log('\ndefine variables and functions');
|
|
print(parser.eval('x = 7 / 2')); // 3.5
|
|
print(parser.eval('x + 3')); // 6.5
|
|
print(parser.eval('f(x, y) = x^y')); // f(x, y)
|
|
print(parser.eval('f(2, 3)')); // 8
|
|
|
|
// manipulate matrices
|
|
// Note that matrix indexes in the expression parser are one-based with the
|
|
// upper-bound included. On a JavaScript level however, math.js uses zero-based
|
|
// indexes with an excluded upper-bound.
|
|
console.log('\nmanipulate matrices');
|
|
print(parser.eval('k = [1, 2; 3, 4]')); // [[1, 2], [3, 4]]
|
|
print(parser.eval('l = zeros(2, 2)')); // [[0, 0], [0, 0]]
|
|
print(parser.eval('l[1, 1:2] = [5, 6]')); // [[5, 6], [0, 0]]
|
|
print(parser.eval('l[2, :] = [7, 8]')); // [[5, 6], [7, 8]]
|
|
print(parser.eval('m = k * l')); // [[19, 22], [43, 50]]
|
|
print(parser.eval('n = m[2, 1]')); // 43
|
|
print(parser.eval('n = m[:, 1]')); // [[19], [43]]
|
|
|
|
// get and set variables and functions
|
|
console.log('\nget and set variables and function in the scope of the parser');
|
|
var x = parser.get('x');
|
|
console.log('x =', x); // x = 7
|
|
var f = parser.get('f');
|
|
console.log('f =', math.format(f)); // f = f(x, y)
|
|
var g = f(3, 3);
|
|
console.log('g =', g); // g = 27
|
|
|
|
parser.set('h', 500);
|
|
print(parser.eval('h / 2')); // 250
|
|
parser.set('hello', function (name) {
|
|
return 'hello, ' + name + '!';
|
|
});
|
|
print(parser.eval('hello("hero")')); // "hello, hero!"
|
|
|
|
// clear defined functions and variables
|
|
parser.clear();
|
|
|
|
|
|
/**
|
|
* Helper function to output a value in the console. Value will be formatted.
|
|
* @param {*} value
|
|
*/
|
|
function print (value) {
|
|
var precision = 14;
|
|
console.log(math.format(value, precision));
|
|
}
|