Function calculate

src/math/math.js:23–99

(expression: string, additionalSymbols?: Object)

}

function calculate(expression: string, additionalSymbols?: Object): number {
  const symbolMap = mergeSymbolMaps(additionalSymbols)

  let match
  const operators = [symbolMap.symbols['('].prefix]
  const values = []

  const pattern = new RegExp( // Pattern for numbers
    `\\d+(?:\\.\\d+)?|${
      // ...and patterns for individual operators/function names
      Object.keys(symbolMap.symbols)
        .map(key => symbolMap.symbols[key])
        // longer symbols should be listed first
        // $FlowFixMe
        .sort((a, b) => b.symbol.length - a.symbol.length)
        // $FlowFixMe
        .map(val => val.regSymbol)
        .join('|')
    }|(\\S)`,
    'g',
  )
  pattern.lastIndex = 0 // Reset regular expression object

  let afterValue = false

  do {
    match = pattern.exec(expression)

    const [token, bad] = match || [')', undefined]
    const notNumber = symbolMap.symbols[token]
    const notNewValue = notNumber && !notNumber.prefix && !notNumber.func
    const notAfterValue = !notNumber || (!notNumber.postfix && !notNumber.infix)

    // Check for syntax errors:
    if (bad || (afterValue ? notAfterValue : notNewValue)) {
      throw new PolishedError(37, match ? match.index : expression.length, expression)
    }

    if (afterValue) {
      // We either have an infix or postfix operator (they should be mutually exclusive)
      const curr = notNumber.postfix || notNumber.infix
      do {
        const prev = operators[operators.length - 1]
        if ((curr.precedence - prev.precedence || prev.rightToLeft) > 0) break
        // Apply previous operator, since it has precedence over current one
      } while (exec(operators, values)) // Exit loop after executing an opening parenthesis or function
      afterValue = curr.notation === 'postfix'
      if (curr.symbol !== ')') {
        operators.push(curr)
        // Postfix always has precedence over any operator that follows after it
        if (afterValue) exec(operators, values)
      }
    } else if (notNumber) {
      // prefix operator or function
      operators.push(notNumber.prefix || notNumber.func)
      if (notNumber.func) {
        // Require an opening parenthesis
        match = pattern.exec(expression)