Function foldFraction

src/function/algebra/simplifyConstant.js:355–494

(node, options)

  // destroys the original node and returns a folded one
  function foldFraction (node, options) {
    switch (node.type) {
      case 'SymbolNode':
        return node
      case 'ConstantNode':
        switch (typeof node.value) {
          case 'number': return _toNumber(node.value, options)
          case 'bigint': return _toNumber(node.value, options)
          case 'string': return node.value
          default:
            if (!isNaN(node.value)) return _toNumber(node.value, options)
        }
        return node
      case 'FunctionNode':
        if (mathWithTransform[node.name] && mathWithTransform[node.name].rawArgs) {
          return node
        }
        {
          // Process operators as OperatorNode
          const operatorFunctions = ['add', 'multiply']
          if (!operatorFunctions.includes(node.name)) {
            const args = node.args.map(arg => foldFraction(arg, options))

            // If all args are numbers
            if (!args.some(isNode)) {
              try {
                return _eval(node.name, args, options)
              } catch (ignoreandcontinue) { }
            }

            // Size of a matrix does not depend on entries
            if (node.name === 'size' &&
                args.length === 1 &&
                isArrayNode(args[0])) {
              const sz = []
              let section = args[0]
              while (isArrayNode(section)) {
                sz.push(section.items.length)
                section = section.items[0]
              }
              return matrix(sz)
            }

            // Convert all args to nodes and construct a symbolic function call
            return new FunctionNode(node.name, args.map(_ensureNode))
          } else {
            // treat as operator
          }
        }
        /* falls through */
      case 'OperatorNode':
      {
        const fn = node.fn.toString()
        let args
        let res
        const makeNode = createMakeNodeFunction(node)
        if (isOperatorNode(node) && node.isUnary()) {
          args = [foldFraction(node.args[0], options)]