mirror of
https://github.com/josdejong/mathjs.git
synced 2025-12-08 19:46:04 +00:00
708 lines
35 KiB
JavaScript
708 lines
35 KiB
JavaScript
// test OperatorNode
|
|
import assert from 'assert'
|
|
|
|
import math from '../../../../src/defaultInstance.js'
|
|
const Node = math.Node
|
|
const ConstantNode = math.ConstantNode
|
|
const SymbolNode = math.SymbolNode
|
|
const OperatorNode = math.OperatorNode
|
|
const ConditionalNode = math.ConditionalNode
|
|
// Set up a bunch of expression pieces that are used over and over:
|
|
const one = new ConstantNode(1)
|
|
const two = new ConstantNode(2)
|
|
const three = new ConstantNode(3)
|
|
const four = new ConstantNode(4)
|
|
const five = new ConstantNode(5)
|
|
const add23 = new OperatorNode('+', 'add', [two, three])
|
|
const sub23 = new OperatorNode('-', 'subtract', [two, three])
|
|
|
|
const asym = new SymbolNode('a')
|
|
const bsym = new SymbolNode('b')
|
|
const csym = new SymbolNode('c')
|
|
const dsym = new SymbolNode('d')
|
|
const xsym = new SymbolNode('x')
|
|
const ysym = new SymbolNode('y')
|
|
|
|
describe('OperatorNode', function () {
|
|
it('should create an OperatorNode', function () {
|
|
const n = new OperatorNode('op', 'fn', [])
|
|
assert(n instanceof OperatorNode)
|
|
assert(n instanceof Node)
|
|
assert.strictEqual(n.type, 'OperatorNode')
|
|
})
|
|
|
|
it('should have isOperatorNode', function () {
|
|
const node = new OperatorNode('op', 'fn', [])
|
|
assert(node.isOperatorNode)
|
|
})
|
|
|
|
it('should throw an error when calling without new operator', function () {
|
|
assert.throws(
|
|
function () { OperatorNode('+', 'add', [two, three]) }, TypeError)
|
|
})
|
|
|
|
it('should compile an OperatorNode', function () {
|
|
assert.strictEqual(add23.compile().evaluate(), 5)
|
|
})
|
|
|
|
it('should test whether a unary or binary operator', function () {
|
|
const n1 = new OperatorNode('-', 'unaryMinus', [two])
|
|
assert.strictEqual(n1.isUnary(), true)
|
|
assert.strictEqual(n1.isBinary(), false)
|
|
|
|
// change the args of an operator node (bad practice, but should keep working correctly)
|
|
n1.args.push(three)
|
|
assert.strictEqual(n1.isUnary(), false)
|
|
assert.strictEqual(n1.isBinary(), true)
|
|
|
|
const n2 = new OperatorNode('+', 'add', [two, three])
|
|
assert.strictEqual(n2.isUnary(), false)
|
|
assert.strictEqual(n2.isBinary(), true)
|
|
|
|
const n3 = new OperatorNode('+', 'add', [two, three, four])
|
|
assert.strictEqual(n3.isUnary(), false)
|
|
assert.strictEqual(n3.isBinary(), false)
|
|
|
|
// change the args of an operator node (bad practice, but should keep working correctly)
|
|
n3.args.splice(2, 1)
|
|
assert.strictEqual(n3.isUnary(), false)
|
|
assert.strictEqual(n3.isBinary(), true)
|
|
})
|
|
|
|
it('should throw an error in case of unresolved operator function', function () {
|
|
const n = new OperatorNode('***', 'foo', [two, three])
|
|
|
|
assert.throws(function () {
|
|
n.compile()
|
|
}, /Function foo missing in provided namespace/)
|
|
})
|
|
|
|
it('should filter an OperatorNode', function () {
|
|
assert.deepStrictEqual(add23.filter(function (node) { return node instanceof OperatorNode }), [add23])
|
|
assert.deepStrictEqual(add23.filter(function (node) { return node instanceof SymbolNode }), [])
|
|
assert.deepStrictEqual(add23.filter(function (node) { return node instanceof ConstantNode }), [two, three])
|
|
assert.deepStrictEqual(add23.filter(function (node) { return node instanceof ConstantNode && node.value === 2 }), [two])
|
|
assert.deepStrictEqual(add23.filter(function (node) { return node instanceof ConstantNode && node.value === 4 }), [])
|
|
})
|
|
|
|
it('should filter an OperatorNode without contents', function () {
|
|
const n = new OperatorNode('op', 'fn', [])
|
|
|
|
assert.deepStrictEqual(n.filter(function (node) { return node instanceof OperatorNode }), [n])
|
|
assert.deepStrictEqual(n.filter(function (node) { return node instanceof SymbolNode }), [])
|
|
})
|
|
|
|
it('should run forEach on an OperatorNode', function () {
|
|
// x^2-x
|
|
const c = new OperatorNode('^', 'pow', [xsym, two])
|
|
const d = new SymbolNode('x') // to make sure it's different from xsym
|
|
const e = new OperatorNode('-', 'subtract', [c, d])
|
|
|
|
const nodes = []
|
|
const paths = []
|
|
e.forEach(function (node, path, parent) {
|
|
nodes.push(node)
|
|
paths.push(path)
|
|
assert.strictEqual(parent, e)
|
|
})
|
|
|
|
assert.strictEqual(nodes.length, 2)
|
|
assert.strictEqual(nodes[0], c)
|
|
assert.strictEqual(nodes[1], d)
|
|
assert.deepStrictEqual(paths, ['args[0]', 'args[1]'])
|
|
})
|
|
|
|
it('should map an OperatorNode', function () {
|
|
// x^2-x
|
|
const c = new OperatorNode('^', 'pow', [xsym, two])
|
|
const d = new SymbolNode('x') // to make sure it's different from xsym
|
|
const e = new OperatorNode('-', 'subtract', [c, d])
|
|
|
|
const nodes = []
|
|
const paths = []
|
|
const g = e.map(function (node, path, parent) {
|
|
nodes.push(node)
|
|
paths.push(path)
|
|
assert.strictEqual(parent, e)
|
|
|
|
return node instanceof SymbolNode && node.name === 'x' ? three : node
|
|
})
|
|
|
|
assert.strictEqual(nodes.length, 2)
|
|
assert.strictEqual(nodes[0], c)
|
|
assert.strictEqual(nodes[1], d)
|
|
assert.deepStrictEqual(paths, ['args[0]', 'args[1]'])
|
|
|
|
assert.notStrictEqual(g, e)
|
|
assert.strictEqual(g.args[0], e.args[0])
|
|
assert.strictEqual(g.args[0].args[0], xsym) // nested x is not replaced
|
|
assert.deepStrictEqual(g.args[0].args[1], two)
|
|
assert.deepStrictEqual(g.args[1], three)
|
|
})
|
|
|
|
it('should map an implicit OperatorNode', function () {
|
|
const product = new OperatorNode('*', 'multiply', [xsym, ysym], true /* implicit */)
|
|
|
|
assert.deepStrictEqual(product.map(function (x) { return x }), product)
|
|
})
|
|
|
|
it('should throw an error when the map callback does not return a node', function () {
|
|
const c = new OperatorNode('^', 'pow', [xsym, two])
|
|
|
|
assert.throws(function () {
|
|
c.map(function () { return undefined })
|
|
}, /Callback function must return a Node/)
|
|
})
|
|
|
|
it('should transform an OperatorNodes parameters', function () {
|
|
// x^2-x
|
|
const c = new OperatorNode('^', 'pow', [xsym, two])
|
|
const d = new SymbolNode('x') // to make sure it's different from xsym
|
|
const e = new OperatorNode('-', 'subtract', [c, d])
|
|
|
|
const g = e.transform(function (node) {
|
|
return node instanceof SymbolNode && node.name === 'x' ? three : node
|
|
})
|
|
|
|
assert.deepStrictEqual(g.args[1], three)
|
|
})
|
|
|
|
it('should transform an OperatorNode itself', function () {
|
|
const c = new OperatorNode('+', 'add', [xsym, two])
|
|
|
|
const g = c.transform(function (node) {
|
|
return node instanceof OperatorNode ? three : node
|
|
})
|
|
|
|
assert.notStrictEqual(g, c)
|
|
assert.deepStrictEqual(g, three)
|
|
})
|
|
|
|
it('should clone an OperatorNode', function () {
|
|
const c = new OperatorNode('+', 'add', [xsym, two])
|
|
|
|
const d = c.clone()
|
|
assert(d instanceof OperatorNode)
|
|
assert.deepStrictEqual(d, c)
|
|
assert.notStrictEqual(d, c)
|
|
assert.notStrictEqual(d.args, c.args)
|
|
assert.strictEqual(d.args[0], c.args[0])
|
|
assert.strictEqual(d.args[1], c.args[1])
|
|
})
|
|
|
|
it('should clone implicit multiplications', function () {
|
|
const node = new OperatorNode('*', 'multiply', [two, xsym], true)
|
|
|
|
assert.strictEqual('2 x', node.toString())
|
|
assert.strictEqual(true, node.clone().implicit)
|
|
assert.strictEqual(node.toString(), node.clone().toString())
|
|
})
|
|
|
|
it('test equality another Node', function () {
|
|
// not using the standard instances to make sure everything is fresh
|
|
const a = new OperatorNode('+', 'add', [new SymbolNode('x'), new ConstantNode(2)])
|
|
const b = new OperatorNode('+', 'add', [new SymbolNode('x'), new ConstantNode(2)])
|
|
const c = new OperatorNode('*', 'multiply', [new SymbolNode('x'), new ConstantNode(2)])
|
|
const d = new OperatorNode('*', 'add', [new SymbolNode('x'), new ConstantNode(3)])
|
|
const e = new OperatorNode('*', 'add', [new SymbolNode('x'), new ConstantNode(2), new ConstantNode(4)])
|
|
|
|
assert.strictEqual(a.equals(null), false)
|
|
assert.strictEqual(a.equals(undefined), false)
|
|
assert.strictEqual(a.equals(b), true)
|
|
assert.strictEqual(a.equals(c), false)
|
|
assert.strictEqual(a.equals(d), false)
|
|
assert.strictEqual(a.equals(e), false)
|
|
})
|
|
|
|
// Put a given expression through formatting paces: test its consistency,
|
|
// and results under toString and toTex, with various options:
|
|
// example is a object with either a key 'i' for input, or 'n' for Node
|
|
// (in the former case the value of 'i' is parsed to get the Node to test)
|
|
// and keys 's' and 'l' for the string and LaTex output, respectively.
|
|
// If the output is expected to differ for paren values of 'keep' and 'auto',
|
|
// then the keys 'skeep', 'sauto', 'lkeep', and 'lauto' can be used instead
|
|
// Takes optional 2nd argument that gives the list of paren values to try,
|
|
// defaults to ['keep', 'auto']
|
|
function ex (example, parens = ['keep', 'auto']) {
|
|
const hasi = 'i' in example
|
|
const expr = hasi ? math.parse(example.i) : example.n
|
|
const orig = hasi
|
|
? example.i
|
|
: `${expr.getIdentifier()}${expr.args.map(arg => arg.getIdentifier())}`
|
|
for (const paren of parens) {
|
|
const prefix = `${orig},${paren}: ` // eases reading of failure output
|
|
const skey = 's' in example ? 's' : 's' + paren
|
|
const lkey = 'l' in example ? 'l' : 'l' + paren
|
|
assert.strictEqual(
|
|
prefix + expr.toString({ parenthesis: paren }), prefix + example[skey])
|
|
assert.strictEqual(
|
|
prefix + expr.toTex({ parenthesis: paren }), prefix + example[lkey])
|
|
}
|
|
}
|
|
|
|
describe('toString and toTex', function () {
|
|
it('on an OperatorNode', function () {
|
|
ex({ n: add23, s: '2 + 3', l: '2+3' })
|
|
})
|
|
|
|
it('on an OperatorNode with factorial', function () {
|
|
ex({ n: new OperatorNode('!', 'factorial', [two]), s: '2!', l: '2!' })
|
|
})
|
|
|
|
it('on an OperatorNode with unary minus', function () {
|
|
ex({ n: new OperatorNode('-', 'unaryMinus', [two]), s: '-2', l: '-2' })
|
|
})
|
|
|
|
it('on an OperatorNode with zero arguments', function () {
|
|
ex({ n: new OperatorNode('foo', 'foo', []), s: 'foo()', l: '\\mathrm{foo}\\left(\\right)' })
|
|
})
|
|
|
|
it('on an OperatorNode with more than two operators', function () {
|
|
ex({
|
|
n: new OperatorNode('foo', 'foo', [two, three, four]),
|
|
s: 'foo(2, 3, 4)',
|
|
l: '\\mathrm{foo}\\left(2,3,4\\right)'
|
|
})
|
|
})
|
|
|
|
it('on addition and multiplication with more than two operands', function () {
|
|
// This is slightly different than most of the tests, so not using `ex`
|
|
const add = new OperatorNode('+', 'add', [asym, bsym, csym])
|
|
const multiply = new OperatorNode('*', 'multiply', [asym, bsym, csym])
|
|
const implicitMultiply = new OperatorNode('*', 'multiply', [asym, bsym, csym], true)
|
|
assert.strictEqual(add.toString(), 'a + b + c')
|
|
assert.strictEqual(multiply.toString(), 'a * b * c')
|
|
// The first two verify that implicit: hide is indeed the default
|
|
assert.strictEqual(implicitMultiply.toString(), 'a b c')
|
|
assert.strictEqual(implicitMultiply.toString({ implicit: 'hide' }), 'a b c')
|
|
assert.strictEqual(implicitMultiply.toString({ implicit: 'show' }), 'a * b * c')
|
|
|
|
assert.strictEqual(add.toTex(), ' a+\\mathrm{b}+ c')
|
|
assert.strictEqual(multiply.toTex(), ' a\\cdot\\mathrm{b}\\cdot c')
|
|
// The first two verify that implicit: hide is indeed the default
|
|
assert.strictEqual(implicitMultiply.toTex(), ' a~\\mathrm{b}~ c')
|
|
assert.strictEqual(implicitMultiply.toTex({ implicit: 'hide' }), ' a~\\mathrm{b}~ c')
|
|
assert.strictEqual(implicitMultiply.toTex({ implicit: 'show' }), ' a\\cdot\\mathrm{b}\\cdot c')
|
|
})
|
|
|
|
it('on addition and multiplication with more than two operands including OperatorNode', function () {
|
|
const mult = new OperatorNode('*', 'multiply', [asym, bsym])
|
|
const add = new OperatorNode('+', 'add', [asym, bsym])
|
|
|
|
const multipleMultWithMult = new OperatorNode('*', 'multiply', [csym, mult, dsym])
|
|
const multipleMultWithAdd = new OperatorNode('*', 'multiply', [csym, add, dsym])
|
|
const multipleAddWithMult = new OperatorNode('+', 'add', [csym, mult, dsym])
|
|
const multipleAddWithAdd = new OperatorNode('+', 'add', [csym, add, dsym])
|
|
|
|
ex({ n: multipleMultWithMult, s: 'c * a * b * d', l: ' c\\cdot a\\cdot\\mathrm{b}\\cdot d' })
|
|
ex({ n: multipleMultWithAdd, s: 'c * (a + b) * d', l: ' c\\cdot\\left( a+\\mathrm{b}\\right)\\cdot d' })
|
|
ex({ n: multipleAddWithMult, s: 'c + a * b + d', l: ' c+ a\\cdot\\mathrm{b}+ d' })
|
|
ex({ n: multipleAddWithAdd, s: 'c + a + b + d', l: ' c+ a+\\mathrm{b}+ d' })
|
|
})
|
|
|
|
it('on an OperatorNode that contains an operatornode with more than two operands', function () {
|
|
const mult = new OperatorNode('*', 'multiply', [asym, bsym, csym])
|
|
const add = new OperatorNode('+', 'add', [asym, bsym, csym])
|
|
|
|
const addWithMult = new OperatorNode('+', 'add', [mult, dsym])
|
|
const addWithAdd = new OperatorNode('+', 'add', [add, dsym])
|
|
const multWithMult = new OperatorNode('*', 'multiply', [mult, dsym])
|
|
const multWithAdd = new OperatorNode('*', 'multiply', [add, dsym])
|
|
|
|
ex({ n: addWithMult, s: 'a * b * c + d', l: ' a\\cdot\\mathrm{b}\\cdot c+ d' })
|
|
ex({ n: addWithAdd, s: 'a + b + c + d', l: ' a+\\mathrm{b}+ c+ d' })
|
|
ex({ n: multWithMult, s: 'a * b * c * d', l: ' a\\cdot\\mathrm{b}\\cdot c\\cdot d' })
|
|
ex({ n: multWithAdd, s: '(a + b + c) * d', l: '\\left( a+\\mathrm{b}+ c\\right)\\cdot d' })
|
|
})
|
|
|
|
it('on an OperatorNode with nested operator nodes', function () {
|
|
const sub45 = new OperatorNode('-', 'subtract', [four, five])
|
|
const prod1 = new OperatorNode('*', 'multiply', [add23, sub45])
|
|
const prod2 = new OperatorNode('*', 'multiply', [add23, four])
|
|
const diff1 = new OperatorNode('-', 'subtract', [prod2, five])
|
|
|
|
ex({ n: sub45, s: '4 - 5', l: '4-5' })
|
|
ex({ n: prod1, s: '(2 + 3) * (4 - 5)', l: '\\left(2+3\\right)\\cdot\\left(4-5\\right)' })
|
|
ex({ n: diff1, s: '(2 + 3) * 4 - 5', l: '\\left(2+3\\right)\\cdot4-5' })
|
|
})
|
|
|
|
it('on left associative OperatorNodes that are associative with another Node', function () {
|
|
ex({ i: '(a+b)+c', skeep: '(a + b) + c', sauto: 'a + b + c', lkeep: '\\left( a+\\mathrm{b}\\right)+ c', lauto: ' a+\\mathrm{b}+ c' })
|
|
ex({ i: 'a+(b+c)', skeep: 'a + (b + c)', sauto: 'a + b + c', lkeep: ' a+\\left(\\mathrm{b}+ c\\right)', lauto: ' a+\\mathrm{b}+ c' })
|
|
ex({ i: '(a+b)-c', skeep: '(a + b) - c', sauto: 'a + b - c', lkeep: '\\left( a+\\mathrm{b}\\right)- c', lauto: ' a+\\mathrm{b}- c' })
|
|
ex({ i: 'a+(b-c)', skeep: 'a + (b - c)', sauto: 'a + b - c', lkeep: ' a+\\left(\\mathrm{b}- c\\right)', lauto: ' a+\\mathrm{b}- c' })
|
|
|
|
ex({ i: '(a*b)*c', skeep: '(a * b) * c', sauto: 'a * b * c', lkeep: '\\left( a\\cdot\\mathrm{b}\\right)\\cdot c', lauto: ' a\\cdot\\mathrm{b}\\cdot c' })
|
|
ex({ i: 'a*(b*c)', skeep: 'a * (b * c)', sauto: 'a * b * c', lkeep: ' a\\cdot\\left(\\mathrm{b}\\cdot c\\right)', lauto: ' a\\cdot\\mathrm{b}\\cdot c' })
|
|
ex({ i: '(a*b)/c', skeep: '(a * b) / c', sauto: 'a * b / c', lkeep: '\\frac{\\left( a\\cdot\\mathrm{b}\\right)}{ c}', lauto: '\\frac{ a\\cdot\\mathrm{b}}{ c}' })
|
|
ex({ i: 'a*(b/c)', skeep: 'a * (b / c)', sauto: 'a * b / c', lkeep: ' a\\cdot\\left(\\frac{\\mathrm{b}}{ c}\\right)', lauto: ' a\\cdot\\frac{\\mathrm{b}}{ c}' })
|
|
})
|
|
|
|
it('on left associative OperatorNodes that are not associative with another Node', function () {
|
|
ex({ i: '(a-b)-c', skeep: '(a - b) - c', sauto: 'a - b - c', lkeep: '\\left( a-\\mathrm{b}\\right)- c', lauto: ' a-\\mathrm{b}- c' })
|
|
ex({ i: 'a-(b-c)', s: 'a - (b - c)', l: ' a-\\left(\\mathrm{b}- c\\right)' })
|
|
ex({ i: '(a-b)+c', skeep: '(a - b) + c', sauto: 'a - b + c', lkeep: '\\left( a-\\mathrm{b}\\right)+ c', lauto: ' a-\\mathrm{b}+ c' })
|
|
ex({ i: 'a-(b+c)', s: 'a - (b + c)', l: ' a-\\left(\\mathrm{b}+ c\\right)' })
|
|
|
|
ex({ i: '(a/b)/c', skeep: '(a / b) / c', sauto: 'a / b / c', lkeep: '\\frac{\\left(\\frac{ a}{\\mathrm{b}}\\right)}{ c}', lauto: '\\frac{\\frac{ a}{\\mathrm{b}}}{ c}' })
|
|
ex({ i: 'a/(b/c)', s: 'a / (b / c)', lkeep: '\\frac{ a}{\\left(\\frac{\\mathrm{b}}{ c}\\right)}', lauto: '\\frac{ a}{\\frac{\\mathrm{b}}{ c}}' })
|
|
ex({ i: '(a/b)*c', skeep: '(a / b) * c', sauto: 'a / b * c', lkeep: '\\left(\\frac{ a}{\\mathrm{b}}\\right)\\cdot c', lauto: '\\frac{ a}{\\mathrm{b}}\\cdot c' })
|
|
ex({ i: 'a/(b*c)', s: 'a / (b * c)', lkeep: '\\frac{ a}{\\left(\\mathrm{b}\\cdot c\\right)}', lauto: '\\frac{ a}{\\mathrm{b}\\cdot c}' })
|
|
})
|
|
|
|
it('on right associative OperatorNodes that are not associative with another Node', function () {
|
|
ex({ i: '(a^b)^c', s: '(a ^ b) ^ c', l: '{\\left({ a}^{\\mathrm{b}}\\right)}^{ c}' })
|
|
ex({ i: 'a^(b^c)', skeep: 'a ^ (b ^ c)', sauto: 'a ^ b ^ c', lkeep: '{ a}^{\\left({\\mathrm{b}}^{ c}\\right)}', lauto: '{ a}^{{\\mathrm{b}}^{ c}}' })
|
|
})
|
|
|
|
it('on unary OperatorNodes containing a binary OperatorNode', function () {
|
|
ex({ i: '(a*b)!', s: '(a * b)!', l: '\\left( a\\cdot\\mathrm{b}\\right)!' })
|
|
ex({ i: '-(a*b)', s: '-(a * b)', l: '-\\left( a\\cdot\\mathrm{b}\\right)' })
|
|
ex({ i: '-(a+b)', s: '-(a + b)', l: '-\\left( a+\\mathrm{b}\\right)' })
|
|
})
|
|
|
|
it('on unary OperatorNodes containing a unary OperatorNode', function () {
|
|
ex({ i: '(-a)!', s: '(-a)!', l: '\\left(- a\\right)!' })
|
|
ex({ i: '-(a!)', skeep: '-(a!)', sauto: '-a!', lkeep: '-\\left( a!\\right)', lauto: '- a!' })
|
|
ex({ i: '-(-a)', s: '-(-a)', l: '-\\left(- a\\right)' })
|
|
})
|
|
})
|
|
|
|
it('should stringify an OperatorNode with custom toString', function () {
|
|
// Also checks if the custom functions get passed on to the children
|
|
const customFunction = function (node, options) {
|
|
if (node.type === 'OperatorNode') {
|
|
return node.op + node.fn + '(' +
|
|
node.args[0].toString(options) +
|
|
', ' + node.args[1].toString(options) + ')'
|
|
} else if (node.type === 'ConstantNode') {
|
|
return 'const(' + node.value + ', ' + math.typeOf(node.value) + ')'
|
|
}
|
|
}
|
|
|
|
const n2 = new OperatorNode('-', 'subtract', [one, two])
|
|
|
|
assert.strictEqual(add23.toString({ handler: customFunction }), '+add(const(2, number), const(3, number))')
|
|
assert.strictEqual(n2.toString({ handler: customFunction }), '-subtract(const(1, number), const(2, number))')
|
|
})
|
|
|
|
it('should stringify an OperatorNode with custom toString for a single operator', function () {
|
|
// Also checks if the custom functions get passed on to the children
|
|
const customFunction = function (node, options) {
|
|
if ((node.type === 'OperatorNode') && (node.fn === 'add')) {
|
|
return node.args[0].toString(options) +
|
|
node.op + node.fn + node.op +
|
|
node.args[1].toString(options)
|
|
} else if (node.type === 'ConstantNode') {
|
|
return 'const(' + node.value + ', ' + math.typeOf(node.value) + ')'
|
|
}
|
|
}
|
|
|
|
assert.strictEqual(add23.toString({ handler: customFunction }), 'const(2, number)+add+const(3, number)')
|
|
})
|
|
|
|
it('should respect the \'all\' parenthesis option', function () {
|
|
ex({ i: '1+1+1', s: '(1 + 1) + 1', l: '\\left(1+1\\right)+1' }, ['all'])
|
|
})
|
|
|
|
it('should correctly format fractions in \'all\' parenthesis mode', function () {
|
|
ex({ i: '1/2/3', s: '(1 / 2) / 3', l: '\\frac{\\left(\\frac{1}{2}\\right)}{3}' },
|
|
['all'])
|
|
})
|
|
|
|
it('should format an OperatorNode with factorial of an OperatorNode', function () {
|
|
const mult23 = new OperatorNode('*', 'multiply', [two, three])
|
|
const div23 = new OperatorNode('/', 'divide', [two, three])
|
|
|
|
const n1 = new OperatorNode('!', 'factorial', [sub23])
|
|
const n2 = new OperatorNode('!', 'factorial', [add23])
|
|
const n3 = new OperatorNode('!', 'factorial', [mult23])
|
|
const n4 = new OperatorNode('!', 'factorial', [div23])
|
|
ex({ n: n1, s: '(2 - 3)!', l: '\\left(2-3\\right)!' })
|
|
ex({ n: n2, s: '(2 + 3)!', l: '\\left(2+3\\right)!' })
|
|
ex({ n: n3, s: '(2 * 3)!', l: '\\left(2\\cdot3\\right)!' })
|
|
ex({ n: n4, s: '(2 / 3)!', l: '\\frac{2}{3}!' })
|
|
})
|
|
|
|
it('should format an OperatorNode with unary minus', function () {
|
|
const n2 = new OperatorNode('-', 'unaryMinus', [sub23])
|
|
const n3 = new OperatorNode('-', 'unaryMinus', [add23])
|
|
|
|
ex({ n: n2, s: '-(2 - 3)', l: '-\\left(2-3\\right)' })
|
|
ex({ n: n3, s: '-(2 + 3)', l: '-\\left(2+3\\right)' })
|
|
})
|
|
|
|
it('should format an OperatorNode that subtracts an OperatorNode', function () {
|
|
const n1 = new OperatorNode('-', 'subtract', [one, sub23])
|
|
const n2 = new OperatorNode('-', 'subtract', [one, add23])
|
|
|
|
ex({ n: n1, s: '1 - (2 - 3)', l: '1-\\left(2-3\\right)' })
|
|
ex({ n: n2, s: '1 - (2 + 3)', l: '1-\\left(2+3\\right)' })
|
|
})
|
|
|
|
it('should format fractions with operators that are enclosed in parenthesis', function () {
|
|
ex({ n: new OperatorNode('/', 'divide', [add23, four]), s: '(2 + 3) / 4', l: '\\frac{2+3}{4}' })
|
|
})
|
|
|
|
it('should have an identifier', function () {
|
|
assert.strictEqual(add23.getIdentifier(), 'OperatorNode:add')
|
|
})
|
|
|
|
it('should LaTeX an OperatorNode with custom toTex', function () {
|
|
// Also checks if the custom functions get passed on to the children
|
|
const customFunction = function (node, options) {
|
|
if (node.type === 'OperatorNode') {
|
|
return node.op + node.fn + '(' +
|
|
node.args[0].toTex(options) +
|
|
', ' + node.args[1].toTex(options) + ')'
|
|
} else if (node.type === 'ConstantNode') {
|
|
return 'const\\left(' + node.value + ', ' + math.typeOf(node.value) + '\\right)'
|
|
}
|
|
}
|
|
|
|
assert.strictEqual(add23.toTex({ handler: customFunction }), '+add(const\\left(2, number\\right), const\\left(3, number\\right))')
|
|
assert.strictEqual(sub23.toTex({ handler: customFunction }), '-subtract(const\\left(2, number\\right), const\\left(3, number\\right))')
|
|
})
|
|
|
|
it('should LaTeX an OperatorNode with custom toTex for a single operator', function () {
|
|
// Also checks if the custom functions get passed on to the children
|
|
const customFunction = function (node, options) {
|
|
if ((node.type === 'OperatorNode') && (node.fn === 'add')) {
|
|
return node.args[0].toTex(options) +
|
|
node.op + node.fn + node.op +
|
|
node.args[1].toTex(options)
|
|
} else if (node.type === 'ConstantNode') {
|
|
return 'const\\left(' + node.value + ', ' + math.typeOf(node.value) + '\\right)'
|
|
}
|
|
}
|
|
|
|
assert.strictEqual(add23.toTex({ handler: customFunction }), 'const\\left(2, number\\right)+add+const\\left(3, number\\right)')
|
|
})
|
|
|
|
it('should format powers of fractions with parentheses', function () {
|
|
const frac = new OperatorNode('/', 'divide', [one, one])
|
|
const pow = new OperatorNode('^', 'pow', [frac, one])
|
|
|
|
ex({ n: pow, s: '(1 / 1) ^ 1', l: '\\left({\\frac{1}{1}}\\right)^{1}' })
|
|
})
|
|
|
|
it('should format powers of conditions with parentheses', function () {
|
|
const cond = new ConditionalNode(one, one, one)
|
|
const pow = new OperatorNode('^', 'pow', [cond, one])
|
|
|
|
ex({ n: pow, s: '(1 ? 1 : 1) ^ 1', l: '\\left({\\begin{cases} {1}, &\\quad{\\text{if }\\;1}\\\\{1}, &\\quad{\\text{otherwise}}\\end{cases}}\\right)^{1}' })
|
|
})
|
|
|
|
it('should format simple expressions in \'auto\' mode', function () {
|
|
// this covers a bug that was triggered previously
|
|
ex({ i: '1+(1+1)', skeep: '1 + (1 + 1)', sauto: '1 + 1 + 1', lkeep: '1+\\left(1+1\\right)', lauto: '1+1+1' })
|
|
})
|
|
|
|
// Variant of the `ex` tester that also tests implicit hide and show
|
|
function exhs (example, parens = ['keep', 'auto']) {
|
|
const imps = ['hide', 'show']
|
|
const hasi = 'i' in example
|
|
const expr = hasi ? math.parse(example.i) : example.n
|
|
const orig = hasi
|
|
? example.i
|
|
: `${expr.getIdentifier()}${expr.args.map(arg => arg.getIdentifier())}`
|
|
for (const paren of parens) {
|
|
const skey = 's' in example ? 's' : 's' + paren
|
|
const lkey = 'l' in example ? 'l' : 'l' + paren
|
|
for (const i of [0, 1]) {
|
|
const prefix = `${orig},${paren},${imps[i]}: ` // eases reading of failure output
|
|
assert.strictEqual(
|
|
prefix + expr.toString({ parenthesis: paren, implicit: imps[i] }),
|
|
prefix + example[skey][i])
|
|
assert.strictEqual(
|
|
prefix + expr.toTex({ parenthesis: paren, implicit: imps[i] }),
|
|
prefix + example[lkey][i])
|
|
}
|
|
}
|
|
}
|
|
|
|
it('should format implicit multiplications', function () {
|
|
exhs({ i: '4a', s: ['4 a', '4 * a'], l: ['4~ a', '4\\cdot a'] })
|
|
exhs({ i: '4 a', s: ['4 a', '4 * a'], l: ['4~ a', '4\\cdot a'] })
|
|
exhs({ i: 'a b', s: ['a b', 'a * b'], l: [' a~\\mathrm{b}', ' a\\cdot\\mathrm{b}'] })
|
|
exhs({ i: '2a b', s: ['2 a b', '2 * a * b'], l: ['2~ a~\\mathrm{b}', '2\\cdot a\\cdot\\mathrm{b}'] })
|
|
exhs({ i: 'a b c', s: ['a b c', 'a * b * c'], l: [' a~\\mathrm{b}~ c', ' a\\cdot\\mathrm{b}\\cdot c'] })
|
|
exhs({ i: '(2+3)a', s: ['(2 + 3) a', '(2 + 3) * a'], l: ['\\left(2+3\\right)~ a', '\\left(2+3\\right)\\cdot a'] })
|
|
exhs({ i: '(2+3)2', s: ['(2 + 3) 2', '(2 + 3) * 2'], l: ['\\left(2+3\\right)~2', '\\left(2+3\\right)\\cdot2'] })
|
|
exhs({ i: '2(3+4)', s: ['2 (3 + 4)', '2 * (3 + 4)'], l: ['2~\\left(3+4\\right)', '2\\cdot\\left(3+4\\right)'] })
|
|
exhs({ i: 'a / b c', s: ['a / b c', 'a / (b * c)'], l: ['\\frac{ a}{\\mathrm{b}~ c}', '\\frac{ a}{\\mathrm{b}\\cdot c}'] })
|
|
exhs({ i: 'a / b c d', s: ['a / b c d', 'a / (b * c * d)'], l: ['\\frac{ a}{\\mathrm{b}~ c~ d}', '\\frac{ a}{\\mathrm{b}\\cdot c\\cdot d}'] })
|
|
exhs({ i: '1/2 a', s: ['1 / 2 a', '1 / 2 * a'], l: ['\\frac{1}{2}~ a', '\\frac{1}{2}\\cdot a'] })
|
|
exhs({ i: '-2/3 a', s: ['-2 / 3 a', '-2 / 3 * a'], l: ['\\frac{-2}{3}~ a', '\\frac{-2}{3}\\cdot a'] })
|
|
exhs({ i: '2!/3 a', s: ['2! / 3 a', '2! / (3 * a)'], l: ['\\frac{2!}{3~ a}', '\\frac{2!}{3\\cdot a}'] })
|
|
exhs({ i: '+2!/3 a', s: ['+2! / 3 a', '+2! / (3 * a)'], l: ['\\frac{+2!}{3~ a}', '\\frac{+2!}{3\\cdot a}'] })
|
|
exhs({ i: '2/3! a', s: ['2 / 3! a', '2 / (3! * a)'], l: ['\\frac{2}{3!~ a}', '\\frac{2}{3!\\cdot a}'] })
|
|
exhs({ i: '-2!/+3! a', s: ['-2! / +3! a', '-2! / (+3! * a)'], l: ['\\frac{-2!}{+3!~ a}', '\\frac{-2!}{+3!\\cdot a}'] })
|
|
exhs({ i: '2/-3 a', s: ['2 / -3 a', '2 / (-3 * a)'], l: ['\\frac{2}{-3~ a}', '\\frac{2}{-3\\cdot a}'] })
|
|
exhs({ i: '-(2+3)/3x', s: ['-(2 + 3) / 3 x', '-(2 + 3) / (3 * x)'], l: ['\\frac{-\\left(2+3\\right)}{3~ x}', '\\frac{-\\left(2+3\\right)}{3\\cdot x}'] })
|
|
exhs({ i: '-2/(3+4)x', s: ['-2 / (3 + 4) x', '-2 / ((3 + 4) * x)'], l: ['\\frac{-2}{\\left(3+4\\right)~ x}', '\\frac{-2}{\\left(3+4\\right)\\cdot x}'] })
|
|
exhs({
|
|
i: '(2)/3x',
|
|
skeep: ['(2) / 3 x', '(2) / (3 * x)'],
|
|
sauto: ['2 / (3 x)', '2 / (3 * x)'],
|
|
lkeep: ['\\frac{\\left(2\\right)}{3~ x}', '\\frac{\\left(2\\right)}{3\\cdot x}'],
|
|
lauto: ['\\frac{2}{3~ x}', '\\frac{2}{3\\cdot x}']
|
|
})
|
|
exhs({
|
|
i: '2/(3)x',
|
|
skeep: ['2 / (3) x', '2 / ((3) * x)'],
|
|
sauto: ['2 / (3 x)', '2 / (3 * x)'],
|
|
lkeep: ['\\frac{2}{\\left(3\\right)~ x}', '\\frac{2}{\\left(3\\right)\\cdot x}'],
|
|
lauto: ['\\frac{2}{3~ x}', '\\frac{2}{3\\cdot x}']
|
|
})
|
|
exhs({
|
|
i: '(2)/(3)x',
|
|
skeep: ['(2) / (3) x', '(2) / ((3) * x)'],
|
|
sauto: ['2 / (3 x)', '2 / (3 * x)'],
|
|
lkeep: ['\\frac{\\left(2\\right)}{\\left(3\\right)~ x}', '\\frac{\\left(2\\right)}{\\left(3\\right)\\cdot x}'],
|
|
lauto: ['\\frac{2}{3~ x}', '\\frac{2}{3\\cdot x}']
|
|
})
|
|
exhs({
|
|
i: '(2!)/(3)x',
|
|
skeep: ['(2!) / (3) x', '(2!) / ((3) * x)'],
|
|
sauto: ['2! / 3 x', '2! / (3 * x)'],
|
|
lkeep: ['\\frac{\\left(2!\\right)}{\\left(3\\right)~ x}', '\\frac{\\left(2!\\right)}{\\left(3\\right)\\cdot x}'],
|
|
lauto: ['\\frac{2!}{3~ x}', '\\frac{2!}{3\\cdot x}']
|
|
})
|
|
exhs({
|
|
i: '(2!)/3x',
|
|
skeep: ['(2!) / 3 x', '(2!) / (3 * x)'],
|
|
sauto: ['2! / 3 x', '2! / (3 * x)'],
|
|
lkeep: ['\\frac{\\left(2!\\right)}{3~ x}', '\\frac{\\left(2!\\right)}{3\\cdot x}'],
|
|
lauto: ['\\frac{2!}{3~ x}', '\\frac{2!}{3\\cdot x}']
|
|
})
|
|
})
|
|
|
|
it('toJSON and fromJSON', function () {
|
|
// There is no such thing as an implicit add node, really, but
|
|
// put toJSON really through its paces
|
|
const node = new OperatorNode('+', 'add', [one, two], true)
|
|
|
|
const json = node.toJSON()
|
|
|
|
assert.deepStrictEqual(json, {
|
|
mathjs: 'OperatorNode',
|
|
op: '+',
|
|
fn: 'add',
|
|
args: [one, two],
|
|
implicit: true,
|
|
isPercentage: false
|
|
})
|
|
|
|
const parsed = OperatorNode.fromJSON(json)
|
|
assert.deepStrictEqual(parsed, node)
|
|
})
|
|
|
|
it('should HTML operators', function () {
|
|
assert.strictEqual(math.parse('2 + 3').toHTML(),
|
|
'<span class="math-number">2</span>' +
|
|
'<span class="math-operator math-binary-operator math-explicit-binary-operator">+</span>' +
|
|
'<span class="math-number">3</span>'
|
|
)
|
|
|
|
assert.strictEqual(math.parse('not 5').toHTML(),
|
|
'<span class="math-operator math-unary-operator math-lefthand-unary-operator">not</span>' +
|
|
'<span class="math-number">5</span>'
|
|
)
|
|
|
|
assert.strictEqual(math.parse('5!').toHTML(),
|
|
'<span class="math-number">5</span>' +
|
|
'<span class="math-operator math-unary-operator math-righthand-unary-operator">!</span>'
|
|
)
|
|
|
|
assert.strictEqual(math.parse('5\'').toHTML(),
|
|
'<span class="math-number">5</span>' +
|
|
'<span class="math-operator math-unary-operator math-righthand-unary-operator">'</span>'
|
|
)
|
|
})
|
|
|
|
it('should HTML an OperatorNode with custom handler for a single operator', function () {
|
|
// Also checks if the custom functions get passed on to the children
|
|
const customFunction = function (node, options) {
|
|
if ((node.type === 'OperatorNode') && (node.fn === 'add')) {
|
|
return `${node.args[0].toHTML(options)} plus ${node.args[1].toHTML(options)}`
|
|
} else if (node.type === 'ConstantNode') {
|
|
return '<span class="my-number">' + node.value + '</span>'
|
|
}
|
|
}
|
|
|
|
assert.strictEqual(add23.toTex({ handler: customFunction }), '<span class="my-number">2</span> plus <span class="my-number">3</span>')
|
|
})
|
|
|
|
it('should format implicit multiplications between ConstantNodes with parentheses', function () {
|
|
ex({ i: '(3)x', skeep: '(3) x', sauto: '3 x', lkeep: '\\left(3\\right)~ x', lauto: '3~ x' })
|
|
ex({
|
|
i: '(4)(4)(4)(4)',
|
|
skeep: '(4) (4) (4) (4)',
|
|
sauto: '4 (4) (4) (4)',
|
|
lkeep: '\\left(4\\right)~\\left(4\\right)~\\left(4\\right)~\\left(4\\right)',
|
|
lauto: '4~\\left(4\\right)~\\left(4\\right)~\\left(4\\right)'
|
|
})
|
|
ex({ i: '4b*4(4)', s: '4 b * 4 (4)', l: '4~\\mathrm{b}\\cdot4~\\left(4\\right)' })
|
|
ex({
|
|
i: '(4(4(4)))',
|
|
skeep: '(4 (4 (4)))',
|
|
sauto: '4 (4 (4))',
|
|
lkeep: '\\left(4~\\left(4~\\left(4\\right)\\right)\\right)',
|
|
lauto: '4~\\left(4~\\left(4\\right)\\right)'
|
|
})
|
|
})
|
|
|
|
it('should stringify implicit multiplications recoverably and to preserve their values', function () {
|
|
const m1 = new OperatorNode('-', 'unaryMinus', [one])
|
|
const m2 = new OperatorNode('-', 'unaryMinus', [two])
|
|
const p1 = new OperatorNode('+', 'unaryPlus', [one])
|
|
const p2 = new OperatorNode('+', 'unaryPlus', [two])
|
|
const onetwo = new OperatorNode('/', 'divide', [one, two])
|
|
const m1two = new OperatorNode('/', 'divide', [m1, two])
|
|
const p1two = new OperatorNode('/', 'divide', [p1, two])
|
|
const onem2 = new OperatorNode('/', 'divide', [one, m2])
|
|
const onep2 = new OperatorNode('/', 'divide', [one, p2])
|
|
const onePlus2 = new OperatorNode('+', 'add', [one, two])
|
|
const onePlusm2 = new OperatorNode('+', 'add', [one, m2])
|
|
const onePlus2over2 = new OperatorNode('/', 'divide', [
|
|
new OperatorNode('+', 'add', [one, two]), two])
|
|
const twoOver1plus2 = new OperatorNode('/', 'divide', [
|
|
two, new OperatorNode('+', 'add', [one, two])])
|
|
const avar = new SymbolNode('a')
|
|
const ascope = { a: 2 }
|
|
const cs = [
|
|
onetwo, m1two, p1two, onem2, onep2,
|
|
onePlus2, onePlusm2, onePlus2over2, twoOver1plus2]
|
|
for (const paren of ['auto', 'keep']) {
|
|
for (const coeff of cs) {
|
|
let expr = new math.OperatorNode('*', 'multiply', [coeff, avar], true)
|
|
let estring = expr.toString({ parenthesis: paren, implicit: 'hide' })
|
|
const rexpr = math.parse(estring)
|
|
const rstring = rexpr.toString({ parenthesis: 'all' })
|
|
// Make sure parsing the string version gives back the same grouping as the
|
|
// original:
|
|
assert.strictEqual(rstring, expr.toString({ parenthesis: 'all' }))
|
|
// And make sure that it produces the same value
|
|
assert.strictEqual(rexpr.evaluate(ascope), expr.evaluate(ascope))
|
|
// And make sure that's the same value you get with a constant in the expression
|
|
expr = new math.OperatorNode('*', 'multiply', [coeff, two], true)
|
|
estring = expr.toString({ parenthesis: paren, implicit: 'hide' })
|
|
assert.strictEqual(math.evaluate(estring, {}), expr.evaluate(ascope))
|
|
}
|
|
}
|
|
})
|
|
|
|
it('should HTML implicit multiplications between ConstantNodes with parentheses', function () {
|
|
const z = math.parse('(3)x')
|
|
const a = math.parse('(4)(4)(4)(4)')
|
|
const b = math.parse('4b*4(4)')
|
|
const c = math.parse('(4(4(4)))')
|
|
|
|
assert.strictEqual(z.toHTML({ implicit: 'hide', parenthesis: 'auto' }), '<span class="math-number">3</span><span class="math-operator math-binary-operator math-implicit-binary-operator"></span><span class="math-symbol">x</span>')
|
|
assert.strictEqual(a.toHTML({ implicit: 'hide', parenthesis: 'auto' }), '<span class="math-number">4</span><span class="math-operator math-binary-operator math-implicit-binary-operator"></span><span class="math-parenthesis math-round-parenthesis">(</span><span class="math-number">4</span><span class="math-parenthesis math-round-parenthesis">)</span><span class="math-operator math-binary-operator math-implicit-binary-operator"></span><span class="math-parenthesis math-round-parenthesis">(</span><span class="math-number">4</span><span class="math-parenthesis math-round-parenthesis">)</span><span class="math-operator math-binary-operator math-implicit-binary-operator"></span><span class="math-parenthesis math-round-parenthesis">(</span><span class="math-number">4</span><span class="math-parenthesis math-round-parenthesis">)</span>')
|
|
assert.strictEqual(b.toHTML({ implicit: 'hide', parenthesis: 'auto' }), '<span class="math-number">4</span><span class="math-operator math-binary-operator math-implicit-binary-operator"></span><span class="math-symbol">b</span><span class="math-operator math-binary-operator math-explicit-binary-operator">*</span><span class="math-number">4</span><span class="math-operator math-binary-operator math-implicit-binary-operator"></span><span class="math-parenthesis math-round-parenthesis">(</span><span class="math-number">4</span><span class="math-parenthesis math-round-parenthesis">)</span>')
|
|
assert.strictEqual(c.toHTML({ implicit: 'hide', parenthesis: 'auto' }), '<span class="math-number">4</span><span class="math-operator math-binary-operator math-implicit-binary-operator"></span><span class="math-parenthesis math-round-parenthesis">(</span><span class="math-number">4</span><span class="math-operator math-binary-operator math-implicit-binary-operator"></span><span class="math-parenthesis math-round-parenthesis">(</span><span class="math-number">4</span><span class="math-parenthesis math-round-parenthesis">)</span><span class="math-parenthesis math-round-parenthesis">)</span>')
|
|
})
|
|
})
|