mathjs/test/expression/node/IndexNode.test.js

// test IndexNode
var assert = require('assert')
var approx = require('../../../tools/approx')
var math = require('../../../src/index')
var Node = math.expression.node.Node
var ConstantNode = math.expression.node.ConstantNode
var SymbolNode = math.expression.node.SymbolNode
var IndexNode = math.expression.node.IndexNode
var RangeNode = math.expression.node.RangeNode

describe('IndexNode', function () {
  it('should create a IndexNode', function () {
    var n = new IndexNode([])
    assert(n instanceof IndexNode)
    assert(n instanceof Node)
    assert.equal(n.type, 'IndexNode')
  })

  it('should have isIndexNode', function () {
    var node = new IndexNode([])
    assert(node.isIndexNode)
  })

  it('should throw an error when calling with wrong arguments', function () {
    assert.throws(function () { new IndexNode() }, TypeError)
    assert.throws(function () { new IndexNode('a') }, TypeError)
    assert.throws(function () { new IndexNode(new Node()) }, TypeError)
    assert.throws(function () { new IndexNode([new Node(), 3]) }, TypeError)
  })

  it('should throw an error when calling without new operator', function () {
    assert.throws(function () { IndexNode([]) }, SyntaxError)
  })

  it('should filter an IndexNode', function () {
    var b = new ConstantNode(2)
    var c = new ConstantNode(1)
    var n = new IndexNode([b, c])

    assert.deepEqual(n.filter(function (node) { return node instanceof IndexNode }), [n])
    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 filter an empty IndexNode', function () {
    var n = new IndexNode([])

    assert.deepEqual(n.filter(function (node) { return node instanceof IndexNode }), [n])
    assert.deepEqual(n.filter(function (node) { return node instanceof ConstantNode }), [])
  })

  it('should run forEach on an IndexNode', function () {
    var b = new ConstantNode(2)
    var c = new ConstantNode(1)
    var n = new IndexNode([b, c])

    var nodes = []
    var paths = []
    n.forEach(function (node, path, parent) {
      nodes.push(node)
      paths.push(path)
      assert.strictEqual(parent, n)
    })

    assert.equal(nodes.length, 2)
    assert.strictEqual(nodes[0], b)
    assert.strictEqual(nodes[1], c)
    assert.deepEqual(paths, ['dimensions[0]', 'dimensions[1]'])
  })

  it('should map an IndexNode', function () {
    var b = new ConstantNode(2)
    var c = new ConstantNode(1)
    var n = new IndexNode([b, c])

    var nodes = []
    var paths = []
    var e = new ConstantNode(-1)
    var f = n.map(function (node, path, parent) {
      nodes.push(node)
      paths.push(path)
      assert.strictEqual(parent, n)

      return node.isConstantNode && node.value === 1 ? e : node
    })

    assert.equal(nodes.length, 2)
    assert.strictEqual(nodes[0], b)
    assert.strictEqual(nodes[1], c)
    assert.deepEqual(paths, ['dimensions[0]', 'dimensions[1]'])

    assert.notStrictEqual(f, n)
    assert.deepEqual(f.dimensions[0], b)
    assert.deepEqual(f.dimensions[1], e)
  })

  it('should throw an error when the map callback does not return a node', function () {
    var b = new ConstantNode(2)
    var c = new ConstantNode(1)
    var n = new IndexNode([b, c])

    assert.throws(function () {
      n.map(function () {})
    }, /Callback function must return a Node/)
  })

  it('should transform an IndexNodes (nested) parameters', function () {
    var b = new ConstantNode(2)
    var c = new ConstantNode(1)
    var n = new IndexNode([b, c])

    var e = new SymbolNode('c')
    var f = n.transform(function (node) {
      return node.isConstantNode && node.value === 1 ? e : node
    })

    assert.notStrictEqual(f, n)
    assert.deepEqual(f.dimensions[0], b)
    assert.deepEqual(f.dimensions[1], e)
  })

  it('should transform an IndexNode itself', function () {
    var b = new ConstantNode(2)
    var c = new ConstantNode(1)
    var n = new IndexNode([b, c])

    var e = new ConstantNode(5)
    var f = n.transform(function (node) {
      return node.isIndexNode ? e : node
    })

    assert.notStrictEqual(f, n)
    assert.deepEqual(f, e)
  })

  it('should clone an IndexNode', function () {
    var b = new ConstantNode(2)
    var c = new ConstantNode(1)
    var n = new IndexNode([b, c])

    var d = n.clone()
    assert(d.isIndexNode)
    assert.deepEqual(d, n)
    assert.notStrictEqual(d, n)
    assert.notStrictEqual(d.dimensions, n.dimensions)
    assert.strictEqual(d.dimensions[0], n.dimensions[0])
    assert.strictEqual(d.dimensions[1], n.dimensions[1])
  })

  it('test equality another Node', function () {
    var a = new IndexNode([new ConstantNode(2), new ConstantNode(1)])
    var b = new IndexNode([new ConstantNode(2), new ConstantNode(1)])
    var c = new IndexNode([new ConstantNode(2)])
    var d = new IndexNode([new ConstantNode(2), new ConstantNode(1), new ConstantNode(3)])
    var e = new IndexNode([new ConstantNode(2), new ConstantNode(4)])
    var f = new SymbolNode('x')

    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)
    assert.strictEqual(a.equals(f), false)
  })

  it('should stringify an IndexNode', function () {
    var dimensions = [
      new ConstantNode(2),
      new ConstantNode(1)
    ]

    var n = new IndexNode(dimensions)
    assert.equal(n.toString(), '[2, 1]')

    var n2 = new IndexNode([])
    assert.equal(n2.toString(), '[]')
  })

  it('should stringify an IndexNode with dot notation', function () {
    var dimensions = [new ConstantNode('a')]

    var n = new IndexNode(dimensions, true)
    assert.equal(n.toString(), '.a')
  })

  it('should stringify an IndexNode with custom toString', function () {
    // Also checks if the custom functions get passed on to the children
    var customFunction = function (node, options) {
      if (node.type === 'IndexNode') {
        return node.dimensions.map(function (range) {
          return range.toString(options)
        }).join(', ')
      } else if (node.type === 'ConstantNode') {
        return 'const(' + node.value + ', ' + math.typeof(node.value) + ')'
      }
    }

    var b = new ConstantNode(1)
    var c = new ConstantNode(2)

    var n = new IndexNode([b, c])

    assert.equal(n.toString({handler: customFunction}), 'const(1, number), const(2, number)')
  })

  it('toJSON and fromJSON', function () {
    var prop = new ConstantNode('prop')
    var node = new IndexNode([prop], true)

    var json = node.toJSON()

    assert.deepEqual(json, {
      mathjs: 'IndexNode',
      dimensions: [ prop ],
      dotNotation: true
    })

    var parsed = IndexNode.fromJSON(json)
    assert.deepEqual(parsed, node)
  })

  it('should LaTeX an IndexNode', function () {
    var dimensions = [
      new ConstantNode(2),
      new ConstantNode(1)
    ]

    var n = new IndexNode(dimensions)
    assert.equal(n.toTex(), '_{2,1}')

    var n2 = new IndexNode([])
    assert.equal(n2.toTex(), '_{}')
  })

  it('should LaTeX an IndexNode with dot notation', function () {
    var dimensions = [new ConstantNode('a')]

    var n = new IndexNode(dimensions, true)
    assert.equal(n.toString(), '.a')
  })

  it('should LaTeX an IndexNode with custom toTex', function () {
    // Also checks if the custom functions get passed on to the children
    var customFunction = function (node, options) {
      if (node.type === 'IndexNode') {
        return node.dimensions.map(function (range) {
          return range.toTex(options)
        }).join(', ')

        return latex
      } else if (node.type === 'ConstantNode') {
        return 'const\\left(' + node.value + ', ' + math.typeof(node.value) + '\\right)'
      }
    }

    var b = new ConstantNode(1)
    var c = new ConstantNode(2)
    var n = new IndexNode([b, c])

    assert.equal(n.toTex({handler: customFunction}), 'const\\left(1, number\\right), const\\left(2, number\\right)')
  })
})