mathjs/test/expression/node/FunctionNode.test.js

// test FunctionNode
var assert = require('assert');
var approx = require('../../../tools/approx');
var math = require('../../../index');
var Node = require('../../../lib/expression/node/Node');
var ConstantNode = require('../../../lib/expression/node/ConstantNode');
var SymbolNode = require('../../../lib/expression/node/SymbolNode');
var RangeNode = require('../../../lib/expression/node/RangeNode');
var FunctionNode = require('../../../lib/expression/node/FunctionNode');
var OperatorNode = require('../../../lib/expression/node/OperatorNode');

describe('FunctionNode', function() {

  it ('should create a FunctionNode', function () {
    var s = new SymbolNode('sqrt');
    var c = new ConstantNode(4);
    var n = new FunctionNode(s, [c]);
    assert(n instanceof FunctionNode);
    assert(n instanceof Node);
    assert.equal(n.type, 'FunctionNode');
  });

  it ('should throw an error when calling without new operator', function () {
    var s = new SymbolNode('sqrt');
    var c = new ConstantNode(4);
    assert.throws(function () {FunctionNode(s, [c])}, SyntaxError);
  });

  it ('should throw an error when calling with wrong arguments', function () {
    var s = new SymbolNode('sqrt');
    var c = new ConstantNode(4);
    assert.throws(function () {new FunctionNode('sqrt', [])}, TypeError);
    assert.throws(function () {new FunctionNode(s, [2, 3])}, TypeError);
    assert.throws(function () {new FunctionNode(s, [c, 3])}, TypeError);
  });

  it ('should compile a FunctionNode', function () {
    var s = new SymbolNode('sqrt');
    var c = new ConstantNode(4);
    var n = new FunctionNode(s, [c]);

    var scope = {};
    assert.equal(n.compile(math).eval(scope), 2);
  });

  it ('should compile a FunctionNode with a raw function', function () {
    var mymath = math.create();
    function myFunction (args, _math, _scope) {
      assert.equal(args.length, 2);
      assert(args[0] instanceof Node);
      assert(args[1] instanceof Node);
      assert.deepEqual(_math.__proto__, mymath);
      assert.strictEqual(_scope, scope);
      return 'myFunction(' + args.join(', ') + ')';
    }
    myFunction.rawArgs = true;
    mymath.import({myFunction: myFunction});

    var s = new SymbolNode('myFunction');
    var a = new ConstantNode(4);
    var b = new ConstantNode(5);
    var n = new FunctionNode(s, [a, b]);

    var scope = {};
    assert.equal(n.compile(mymath).eval(scope), 'myFunction(4, 5)');
  });

  it ('should compile a FunctionNode with overloaded a raw function', function () {
    var mymath = math.create();
    function myFunction (args, _math, _scope) {
      assert.ok(false, 'should not be executed');
    }
    myFunction.rawArgs = true;
    mymath.import({myFunction: myFunction});

    var s = new SymbolNode('myFunction');
    var a = new ConstantNode(4);
    var b = new ConstantNode(5);
    var n = new FunctionNode(s, [a, b]);

    var scope = {
      myFunction: function () {
        return 42;
      }
    };
    assert.equal(n.compile(mymath).eval(scope), 42);
  });

  it ('should filter a FunctionNode', function () {
    var a = new SymbolNode('a'),
        b = new ConstantNode(2),
        c = new ConstantNode(1);
    var n = new FunctionNode(a, [b, c]);

    assert.deepEqual(n.filter(function (node) {return node instanceof FunctionNode}),  [n]);
    assert.deepEqual(n.filter(function (node) {return node instanceof SymbolNode}),    [a]);
    assert.deepEqual(n.filter(function (node) {return node instanceof RangeNode}),     []);
    assert.deepEqual(n.filter(function (node) {return node instanceof ConstantNode}),  [b, c]);
    assert.deepEqual(n.filter(function (node) {return node instanceof ConstantNode && node.value == '2'}),  [b]);
    assert.deepEqual(n.filter(function (node) {return node instanceof ConstantNode && node.value == '4'}),  []);
  });

  it ('should transform a FunctionNodes (nested) parameters', function () {
    // multiply(x + 2, x)
    var a = new SymbolNode('x');
    var b = new ConstantNode(2);
    var c = new OperatorNode('+', 'add', [a, b]);
    var d = new SymbolNode('x');
    var e = new SymbolNode('multiply');
    var f = new FunctionNode(e, [c, d]);

    var g = new ConstantNode(3);
    var h = f.transform(function (node) {
      return node instanceof SymbolNode && node.name == 'x' ? g : node;
    });

    assert.notStrictEqual(h, f);
    assert.deepEqual(h.params[0].params[0],  g);
    assert.deepEqual(h.params[0].params[1],  b);
    assert.deepEqual(h.symbol, e);
    assert.deepEqual(h.params[1],  g);
  });

  it ('should transform a FunctionNodes symbol', function () {
    // add(2, 3)
    var a = new SymbolNode('add');
    var b = new ConstantNode(2);
    var c = new ConstantNode(3);
    var d = new FunctionNode(a, [b, c]);

    var e = new SymbolNode('subtract');
    var f = d.transform(function (node) {
      return node instanceof SymbolNode ? e : node;
    });

    assert.notStrictEqual(f, d);
    assert.deepEqual(f.symbol, e);
  });

  it ('should transform a FunctionNode itself', function () {
    // add(2, 3)
    var a = new SymbolNode('add');
    var b = new ConstantNode(2);
    var c = new ConstantNode(3);
    var d = new FunctionNode(a, [b, c]);

    var e = new ConstantNode(5);
    var f = d.transform(function (node) {
      return node instanceof FunctionNode ? e : node;
    });

    assert.strictEqual(f, e);
  });

  it ('should traverse a FunctionNode', function () {
    // add(2, 3)
    var a = new SymbolNode('add');
    var b = new ConstantNode(2);
    var c = new ConstantNode(3);
    var d = new FunctionNode(a, [b, c]);

    var count = 0;
    d.traverse(function (node, index, parent) {
      count++;

      switch(count) {
        case 1:
          assert.strictEqual(node, d);
          assert.strictEqual(index, null);
          assert.strictEqual(parent, null);
          break;

        case 2:
          assert.strictEqual(node, a);
          assert.strictEqual(index, 'symbol');
          assert.strictEqual(parent, d);
          break;

        case 3:
          assert.strictEqual(node, b);
          assert.strictEqual(index, 'params.0');
          assert.strictEqual(parent, d);
          break;

        case 4:
          assert.strictEqual(node, c);
          assert.strictEqual(index, 'params.1');
          assert.strictEqual(parent, d);
          break;
      }
    });

    assert.equal(count, 4);
  });

  it ('should clone a FunctionNode', function () {
    // add(2, 3)
    var a = new SymbolNode('add');
    var b = new ConstantNode(2);
    var c = new ConstantNode(3);
    var d = new FunctionNode(a, [b, c]);

    var e = d.clone();
    assert(e instanceof FunctionNode);
    assert.deepEqual(e, d);
    assert.notStrictEqual(e, d);
    assert.notStrictEqual(e.symbol, d.symbol);
    assert.notStrictEqual(e.params[0], d.params[0]);
    assert.notStrictEqual(e.params[1], d.params[1]);
  });

  it ('should stringify a FunctionNode', function () {
    var s = new SymbolNode('sqrt');
    var c = new ConstantNode(4);
    var n = new FunctionNode(s, [c]);

    assert.equal(n.toString(), 'sqrt(4)');
  });

  it ('should LaTeX a FunctionNode', function () {
    var s = new SymbolNode('sqrt');
    var c = new ConstantNode(4);
    var n = new FunctionNode(s, [c]);

    assert.equal(n.toTex(), '\\sqrt{4}');
  });

});