_toString (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].toString(options)
        if (parens[0]) {
          operand = '(' + operand + ')'
        }

        // for example for "not", we want a space between operand and argument
        const opIsNamed = /[a-zA-Z]+/.test(this.op)

        if (assoc === 'right') { // prefix operator
          return this.op + (opIsNamed ? ' ' : '') + operand
        } else if (assoc === 'left') { // postfix
          return operand + (opIsNamed ? ' ' : '') + this.op
        }

        // fall back to postfix
        return operand + this.op
      } else if (args.length === 2) {
        let lhs = args[0].toString(options) // left hand side
        let rhs = args[1].toString(options) // right hand side
        if (parens[0]) { // left hand side in parenthesis?
          lhs = '(' + lhs + ')'
        }
        if (parens[1]) { // right hand side in parenthesis?
          rhs = '(' + rhs + ')'
        }

        if (this.implicit &&
            (this.getIdentifier() === 'OperatorNode:multiply') &&
            (implicit === 'hide')) {
          return lhs + ' ' + rhs
        }

        return lhs + ' ' + this.op + ' ' + rhs
      } else if ((args.length > 2) &&
                 ((this.getIdentifier() === 'OperatorNode:add') ||
                     (this.getIdentifier() === 'OperatorNode:multiply'))) {
        const stringifiedArgs = args.map(function (arg, index) {
          arg = arg.toString(options)
          if (parens[index]) { // put in parenthesis?
            arg = '(' + arg + ')'
          }

          return arg
        })

        if (this.implicit &&
            (this.getIdentifier() === 'OperatorNode:multiply') &&
            (implicit === 'hide')) {
          return stringifiedArgs.join(' ')
        }

        return stringifiedArgs.join(' ' + this.op + ' ')
      } else {
        // fallback to formatting as a function call
        return this.fn + '(' + this.args.join(', ') + ')'
      }
    }
Get string representation.
@param {Object} options
@return {string} str