_toHTML (options) {
      const parenthesis =
          (options && options.parenthesis) ? options.parenthesis : 'keep'
      const implicit = (options && options.implicit) ? options.implicit : 'hide'
      const args = this.args
      const parens =
          calculateNecessaryParentheses(this, parenthesis, implicit, args, false)

      if (args.length === 1) { // unary operators
        const assoc = getAssociativity(this, parenthesis)

        let operand = args[0].toHTML(options)
        if (parens[0]) {
          operand =
            '<span class="math-parenthesis math-round-parenthesis">(</span>' +
            operand +
            '<span class="math-parenthesis math-round-parenthesis">)</span>'
        }

        if (assoc === 'right') { // prefix operator
          return '<span class="math-operator math-unary-operator ' +
            'math-lefthand-unary-operator">' + escape(this.op) + '</span>' +
            operand
        } else { // postfix when assoc === 'left' or undefined
          return operand +
            '<span class="math-operator math-unary-operator ' +
            'math-righthand-unary-operator">' + escape(this.op) + '</span>'
        }
      } else if (args.length === 2) { // binary operatoes
        let lhs = args[0].toHTML(options) // left hand side
        let rhs = args[1].toHTML(options) // right hand side
        if (parens[0]) { // left hand side in parenthesis?
          lhs = '<span class="math-parenthesis math-round-parenthesis">(</span>' +
            lhs +
            '<span class="math-parenthesis math-round-parenthesis">)</span>'
        }
        if (parens[1]) { // right hand side in parenthesis?
          rhs = '<span class="math-parenthesis math-round-parenthesis">(</span>' +
            rhs +
            '<span class="math-parenthesis math-round-parenthesis">)</span>'
        }

        if (this.implicit &&
            (this.getIdentifier() === 'OperatorNode:multiply') &&
            (implicit === 'hide')) {
          return lhs +
            '<span class="math-operator math-binary-operator ' +
            'math-implicit-binary-operator"></span>' + rhs
        }

        return lhs +
          '<span class="math-operator math-binary-operator ' +
          'math-explicit-binary-operator">' + escape(this.op) + '</span>' +
          rhs
      } else {
        const stringifiedArgs = args.map(function (arg, index) {
          arg = arg.toHTML(options)
          if (parens[index]) { // put in parenthesis?
            arg =
              '<span class="math-parenthesis math-round-parenthesis">(</span>' +
              arg +
              '<span class="math-parenthesis math-round-parenthesis">)</span>'
          }

          return arg
        })

        if ((args.length > 2) &&
            ((this.getIdentifier() === 'OperatorNode:add') ||
                (this.getIdentifier() === 'OperatorNode:multiply'))) {
          if (this.implicit &&
              (this.getIdentifier() === 'OperatorNode:multiply') &&
              (implicit === 'hide')) {
            return stringifiedArgs.join(
              '<span class="math-operator math-binary-operator ' +
                'math-implicit-binary-operator"></span>')
          }

          return stringifiedArgs.join(
            '<span class="math-operator math-binary-operator ' +
              'math-explicit-binary-operator">' + escape(this.op) + '</span>')
        } else {
          // fallback to formatting as a function call
          return '<span class="math-function">' + escape(this.fn) +
            '</span><span class="math-paranthesis math-round-parenthesis">' +
            '(</span>' +
            stringifiedArgs.join('<span class="math-separator">,</span>') +
            '<span class="math-paranthesis math-round-parenthesis">)</span>'
        }
      }
    }
Get HTML representation.
@param {Object} options
@return {string} str