from math import sin, cos

def evaluate(expression):
    """
    Evaluates the given mathematical expression.

    Args:
        expression (str): The mathematical expression to evaluate.

    Returns:
        float: The result of the evaluation.
    """

    # Split the expression into tokens.
    tokens = expression.split()

    # Create a stack to store the operands and operators.
    stack = []

    # Iterate over the tokens.
    for token in tokens:
        # If the token is a number, push it onto the stack.
        if token.isdigit():
            stack.append(float(token))
        # If the token is an operator, pop the top two operands from the stack,
        # apply the operator to them, and push the result onto the stack.
        elif token in ['+', '-', '*', '/']:
            operand2 = stack.pop()
            operand1 = stack.pop()
            if token == '+':
                stack.append(operand1 + operand2)
            elif token == '-':
                stack.append(operand1 - operand2)
            elif token == '*':
                stack.append(operand1 * operand2)
            elif token == '/':
                stack.append(operand1 / operand2)
        # If the token is a prefix operator, pop the top operand from the stack,
        # apply the operator to it, and push the result onto the stack.
        elif token in ['sin', 'cos']:
            operand = stack.pop()
            if token == 'sin':
                stack.append(sin(operand))
            elif token == 'cos':
                stack.append(cos(operand))
        # If the token is an opening parenthesis, push it onto the stack.
        elif token == '(':
            stack.append('(')
        # If the token is a closing parenthesis, pop all operands and operators
        # from the stack until an opening parenthesis is encountered, then evaluate
        # the expression and push the result onto the stack.
        elif token == ')':
            sub_expression = []
            while stack[-1] != '(':
                sub_expression.append(stack.pop())
            stack.pop()  # Remove the opening parenthesis.
            stack.append(evaluate(' '.join(sub_expression[::-1])))

    # The final result is the top element of the stack.
    return stack.pop()

from math import sin, cos

def evaluate(expression):
    """
    Evaluates the given mathematical expression.

    Args:
        expression (str): The mathematical expression to evaluate.

    Returns:
        float: The result of the evaluation.
    """

    # Split the expression into tokens.
    tokens = expression.split()

    # Create a stack to store the operands and operators.
    stack = []

    # Iterate over the tokens.
    for token in tokens:
        # If the token is a number, push it onto the stack.
        if token.isdigit():
            stack.append(float(token))
        # If the token is an operator, pop the top two operands from the stack,
        # apply the operator to them, and push the result onto the stack.
        elif token in ['+', '-', '*', '/']:
            operand2 = stack.pop()
            operand1 = stack.pop()
            if token == '+':
                stack.append(operand1 + operand2)
            elif token == '-':
                stack.append(operand1 - operand2)
            elif token == '*':
                stack.append(operand1 * operand2)
            elif token == '/':
                stack.append(operand1 / operand2)
        # If the token is a prefix operator, pop the top operand from the stack,
        # apply the operator to it, and push the result onto the stack.
        elif token in ['sin', 'cos']:
            operand = stack.pop()
            if token == 'sin':
                stack.append(sin(operand))
            elif token == 'cos':
                stack.append(cos(operand))
        # If the token is an opening parenthesis, push it onto the stack.
        elif token == '(':
            stack.append('(')
        # If the token is a closing parenthesis, pop all operands and operators
        # from the stack until an opening parenthesis is encountered, then evaluate
        # the expression and push the result onto the stack.
        elif token == ')':
            sub_expression = []
            while stack[-1] != '(':
                sub_expression.append(stack.pop())
            stack.pop()  # Remove the opening parenthesis.
            stack.append(evaluate(' '.join(sub_expression[::-1])))

    # The final result is the top element of the stack.
    return stack.pop()

from math import sin, cos

def evaluate(expression):
    """
    Evaluates the given mathematical expression.

    Args:
        expression (str): The mathematical expression to evaluate.

    Returns:
        float: The result of the evaluation.
    """

    # Split the expression into tokens.
    tokens = expression.split()

    # Create a stack to store the operands and operators.
    stack = []

    # Iterate over the tokens.
    for token in tokens:
        # If the token is a number, push it onto the stack.
        if token.isdigit():
            stack.append(float(token))
        # If the token is an operator, pop the top two operands from the stack,
        # apply the operator to them, and push the result onto the stack.
        elif token in ['+', '-', '*', '/']:
            operand2 = stack.pop()
            operand1 = stack.pop()
            if token == '+':
                stack.append(operand1 + operand2)
            elif token == '-':
                stack.append(operand1 - operand2)
            elif token == '*':
                stack.append(operand1 * operand2)
            elif token == '/':
                stack.append(operand1 / operand2)
        # If the token is a prefix operator, pop the top operand from the stack,
        # apply the operator to it, and push the result onto the stack.
        elif token in ['sin', 'cos']:
            operand = stack.pop()
            if token == 'sin':
                stack.append(sin(operand))
            elif token == 'cos':
                stack.append(cos(operand))
        # If the token is an opening parenthesis, push it onto the stack.
        elif token == '(':
            stack.append('(')
        # If the token is a closing parenthesis, pop all operands and operators
        # from the stack until an opening parenthesis is encountered, then evaluate
        # the expression and push the result onto the stack.
        elif token == ')':
            sub_expression = []
            while stack[-1] != '(':
                sub_expression.append(stack.pop())
            stack.pop()  # Remove the opening parenthesis.
            stack.append(evaluate(' '.join(sub_expression[::-1])))

    # The final result is the top element of the stack.
    return stack.pop()





answer = round(evaluate('sin(35+2*4)-cos(15)'), 5)
expected = -0.07209
assert answer == expected, f'Wrong answer; got {answer} instead of {expected}'
print('All tests passed')

def evaluate(expression):
    """Evaluate an arithmetic expression represented as a string.

    The expression can contain the following operators: +, -, *, /, sin, cos.
    Parentheses are also supported.

    Args:
        expression: The expression to evaluate.

    Returns:
        The value of the expression.
    """

    # Tokenize the expression.
    tokens = tokenize(expression)

    # Parse the tokens into an abstract syntax tree (AST).
    ast = parse(tokens)

    # Evaluate the AST.
    return evaluate_ast(ast)


def tokenize(expression):
    """Tokenize an arithmetic expression.

    Args:
        expression: The expression to tokenize.

    Returns:
        A list of tokens.
    """

    tokens = []
    i = 0
    while i < len(expression):
        c = expression[i]
        if c.isdigit():
            # Number.
            number = c
            i += 1
            while i < len(expression) and expression[i].isdigit():
                number += expression[i]
                i += 1
            tokens.append(('NUMBER', number))
        elif c in '+-*/()':
            # Operator or parenthesis.
            tokens.append((c, c))
            i += 1
        elif c in 'sincos':
            # Prefix operator.
            prefix_op = c
            i += 1
            while i < len(expression) and expression[i].isalpha():
                prefix_op += expression[i]
                i += 1
            tokens.append(('PREFIX_OP', prefix_op))
        else:
            # Invalid character.
            raise ValueError("Invalid character: {}".format(c))
    return tokens


def parse(tokens):
    """Parse a list of tokens into an abstract syntax tree (AST).

    Args:
        tokens: A list of tokens.

    Returns:
        An AST.
    """

    ast = []
    i = 0
    while i < len(tokens):
        token = tokens[i]
        if token[0] == 'NUMBER':
            # Number.
            ast.append(('NUMBER', int(token[1])))
        elif token[0] in '+-*/()':
            # Operator or parenthesis.
            ast.append(token)
        elif token[0] == 'PREFIX_OP':
            # Prefix operator.
            ast.append(('PREFIX_OP', token[1]))
            i += 1
            ast.append(parse(tokens))
        else:
            # Invalid token.
            raise ValueError("Invalid token: {}".format(token))
        i += 1
    return ast


def evaluate_ast(ast):
    """Evaluate an abstract syntax tree (AST).

    Args:
        ast: An AST.

    Returns:
        The value of the AST.
    """

    if ast[0] == 'NUMBER':
        # Number.
        return ast[1]
    elif ast[0] in '+-*/':
        # Operator.
        left = evaluate_ast(ast[1])
        right = evaluate_ast(ast[3])
        if ast[0] == '+':
            return left + right
        elif ast[0] == '-':
            return left - right
        elif ast[0] == '*':
            return left * right
        elif ast[0] == '/':
            return left / right
    elif ast[0] == 'PREFIX_OP':
        # Prefix operator.
        operand = evaluate_ast(ast[2])
        if ast[1] == 'sin':
            return math.sin(operand)
        elif ast[1] == 'cos':
            return math.cos(operand)
    else:
        # Invalid AST.
        raise ValueError("Invalid AST: {}".format(ast))

def evaluate(expression):
    """Evaluate an arithmetic expression represented as a string.

    The expression can contain the following operators: +, -, *, /, sin, cos.
    Parentheses are also supported.

    Args:
        expression: The expression to evaluate.

    Returns:
        The value of the expression.
    """

    # Tokenize the expression.
    tokens = tokenize(expression)

    # Parse the tokens into an abstract syntax tree (AST).
    ast = parse(tokens)

    # Evaluate the AST.
    return evaluate_ast(ast)


def tokenize(expression):
    """Tokenize an arithmetic expression.

    Args:
        expression: The expression to tokenize.

    Returns:
        A list of tokens.
    """

    tokens = []
    i = 0
    while i < len(expression):
        c = expression[i]
        if c.isdigit():
            # Number.
            number = c
            i += 1
            while i < len(expression) and expression[i].isdigit():
                number += expression[i]
                i += 1
            tokens.append(('NUMBER', number))
        elif c in '+-*/()':
            # Operator or parenthesis.
            tokens.append((c, c))
            i += 1
        elif c in 'sincos':
            # Prefix operator.
            prefix_op = c
            i += 1
            while i < len(expression) and expression[i].isalpha():
                prefix_op += expression[i]
                i += 1
            tokens.append(('PREFIX_OP', prefix_op))
        else:
            # Invalid character.
            raise ValueError("Invalid character: {}".format(c))
    return tokens


def parse(tokens):
    """Parse a list of tokens into an abstract syntax tree (AST).

    Args:
        tokens: A list of tokens.

    Returns:
        An AST.
    """

    ast = []
    i = 0
    while i < len(tokens):
        token = tokens[i]
        if token[0] == 'NUMBER':
            # Number.
            ast.append(('NUMBER', int(token[1])))
        elif token[0] in '+-*/()':
            # Operator or parenthesis.
            ast.append(token)
        elif token[0] == 'PREFIX_OP':
            # Prefix operator.
            ast.append(('PREFIX_OP', token[1]))
            i += 1
            ast.append(parse(tokens))
        else:
            # Invalid token.
            raise ValueError("Invalid token: {}".format(token))
        i += 1
    return ast


def evaluate_ast(ast):
    """Evaluate an abstract syntax tree (AST).

    Args:
        ast: An AST.

    Returns:
        The value of the AST.
    """

    if ast[0] == 'NUMBER':
        # Number.
        return ast[1]
    elif ast[0] in '+-*/':
        # Operator.
        left = evaluate_ast(ast[1])
        right = evaluate_ast(ast[3])
        if ast[0] == '+':
            return left + right
        elif ast[0] == '-':
            return left - right
        elif ast[0] == '*':
            return left * right
        elif ast[0] == '/':
            return left / right
    elif ast[0] == 'PREFIX_OP':
        # Prefix operator.
        operand = evaluate_ast(ast[2])
        if ast[1] == 'sin':
            return math.sin(operand)
        elif ast[1] == 'cos':
            return math.cos(operand)
    else:
        # Invalid AST.
        raise ValueError("Invalid AST: {}".format(ast))

def evaluate(expression):
    """Evaluate an arithmetic expression represented as a string.

    The expression can contain the following operators: +, -, *, /, sin, cos.
    Parentheses are also supported.

    Args:
        expression: The expression to evaluate.

    Returns:
        The value of the expression.
    """

    # Tokenize the expression.
    tokens = tokenize(expression)

    # Parse the tokens into an abstract syntax tree (AST).
    ast = parse(tokens)

    # Evaluate the AST.
    return evaluate_ast(ast)


def tokenize(expression):
    """Tokenize an arithmetic expression.

    Args:
        expression: The expression to tokenize.

    Returns:
        A list of tokens.
    """

    tokens = []
    i = 0
    while i < len(expression):
        c = expression[i]
        if c.isdigit():
            # Number.
            number = c
            i += 1
            while i < len(expression) and expression[i].isdigit():
                number += expression[i]
                i += 1
            tokens.append(('NUMBER', number))
        elif c in '+-*/()':
            # Operator or parenthesis.
            tokens.append((c, c))
            i += 1
        elif c in 'sincos':
            # Prefix operator.
            prefix_op = c
            i += 1
            while i < len(expression) and expression[i].isalpha():
                prefix_op += expression[i]
                i += 1
            tokens.append(('PREFIX_OP', prefix_op))
        else:
            # Invalid character.
            raise ValueError("Invalid character: {}".format(c))
    return tokens


def parse(tokens):
    """Parse a list of tokens into an abstract syntax tree (AST).

    Args:
        tokens: A list of tokens.

    Returns:
        An AST.
    """

    ast = []
    i = 0
    while i < len(tokens):
        token = tokens[i]
        if token[0] == 'NUMBER':
            # Number.
            ast.append(('NUMBER', int(token[1])))
        elif token[0] in '+-*/()':
            # Operator or parenthesis.
            ast.append(token)
        elif token[0] == 'PREFIX_OP':
            # Prefix operator.
            ast.append(('PREFIX_OP', token[1]))
            i += 1
            ast.append(parse(tokens))
        else:
            # Invalid token.
            raise ValueError("Invalid token: {}".format(token))
        i += 1
    return ast


def evaluate_ast(ast):
    """Evaluate an abstract syntax tree (AST).

    Args:
        ast: An AST.

    Returns:
        The value of the AST.
    """

    if ast[0] == 'NUMBER':
        # Number.
        return ast[1]
    elif ast[0] in '+-*/':
        # Operator.
        left = evaluate_ast(ast[1])
        right = evaluate_ast(ast[3])
        if ast[0] == '+':
            return left + right
        elif ast[0] == '-':
            return left - right
        elif ast[0] == '*':
            return left * right
        elif ast[0] == '/':
            return left / right
    elif ast[0] == 'PREFIX_OP':
        # Prefix operator.
        operand = evaluate_ast(ast[2])
        if ast[1] == 'sin':
            return math.sin(operand)
        elif ast[1] == 'cos':
            return math.cos(operand)
    else:
        # Invalid AST.
        raise ValueError("Invalid AST: {}".format(ast))





answer = round(evaluate('sin(35+2*4)-cos(15)'), 5)
expected = -0.07209
assert answer == expected, f'Wrong answer; got {answer} instead of {expected}'
print('All tests passed')

import math

def evaluate(expr):
    """
    Evaluate a mathematical expression.

    The expression can be a simple number, a parenthesized expression,
    or a binary operation (+, -, *, /) of two expressions.

    Args:
        expr: The expression to evaluate.

    Returns:
        The value of the expression.
    """

    # Check if the expression is a number.
    if expr.isdigit():
        return int(expr)

    # Check if the expression is a parenthesized expression.
    if expr[0] == '(' and expr[-1] == ')':
        return evaluate(expr[1:-1])

    # Check if the expression is a binary operation.
    for op in ('+', '-', '*', '/'):
        if op in expr:
            parts = expr.split(op)
            left = evaluate(parts[0])
            right = evaluate(parts[1])
            if op == '+':
                return left + right
            elif op == '-':
                return left - right
            elif op == '*':
                return left * right
            elif op == '/':
                return left / right

    # Check if the expression is a prefix operation.
    for op in ('sin', 'cos'):
        if expr.startswith(op):
            arg = evaluate(expr[len(op):])
            if op == 'sin':
                return math.sin(arg)
            elif op == 'cos':
                return math.cos(arg)

    # The expression is invalid.
    raise ValueError("Invalid expression: {}".format(expr))

import math

def evaluate(expr):
    """
    Evaluate a mathematical expression.

    The expression can be a simple number, a parenthesized expression,
    or a binary operation (+, -, *, /) of two expressions.

    Args:
        expr: The expression to evaluate.

    Returns:
        The value of the expression.
    """

    # Check if the expression is a number.
    if expr.isdigit():
        return int(expr)

    # Check if the expression is a parenthesized expression.
    if expr[0] == '(' and expr[-1] == ')':
        return evaluate(expr[1:-1])

    # Check if the expression is a binary operation.
    for op in ('+', '-', '*', '/'):
        if op in expr:
            parts = expr.split(op)
            left = evaluate(parts[0])
            right = evaluate(parts[1])
            if op == '+':
                return left + right
            elif op == '-':
                return left - right
            elif op == '*':
                return left * right
            elif op == '/':
                return left / right

    # Check if the expression is a prefix operation.
    for op in ('sin', 'cos'):
        if expr.startswith(op):
            arg = evaluate(expr[len(op):])
            if op == 'sin':
                return math.sin(arg)
            elif op == 'cos':
                return math.cos(arg)

    # The expression is invalid.
    raise ValueError("Invalid expression: {}".format(expr))

import math

def evaluate(expr):
    """
    Evaluate a mathematical expression.

    The expression can be a simple number, a parenthesized expression,
    or a binary operation (+, -, *, /) of two expressions.

    Args:
        expr: The expression to evaluate.

    Returns:
        The value of the expression.
    """

    # Check if the expression is a number.
    if expr.isdigit():
        return int(expr)

    # Check if the expression is a parenthesized expression.
    if expr[0] == '(' and expr[-1] == ')':
        return evaluate(expr[1:-1])

    # Check if the expression is a binary operation.
    for op in ('+', '-', '*', '/'):
        if op in expr:
            parts = expr.split(op)
            left = evaluate(parts[0])
            right = evaluate(parts[1])
            if op == '+':
                return left + right
            elif op == '-':
                return left - right
            elif op == '*':
                return left * right
            elif op == '/':
                return left / right

    # Check if the expression is a prefix operation.
    for op in ('sin', 'cos'):
        if expr.startswith(op):
            arg = evaluate(expr[len(op):])
            if op == 'sin':
                return math.sin(arg)
            elif op == 'cos':
                return math.cos(arg)

    # The expression is invalid.
    raise ValueError("Invalid expression: {}".format(expr))





answer = round(evaluate('sin(35+2*4)-cos(15)'), 5)
expected = -0.07209
assert answer == expected, f'Wrong answer; got {answer} instead of {expected}'
print('All tests passed')

import math

def evaluate(expression):
    """
    Evaluate an expression in the given BNF-style grammar.

    Args:
        expression (str): The expression to evaluate.

    Returns:
        float: The result of the evaluation.
    """

    # Tokenize the expression
    tokens = expression.split()

    # Evaluate the expression
    result = _evaluate_expression(tokens)

    # Return the result
    return result

def _evaluate_expression(tokens):
    """
    Evaluate an expression.

    Args:
        tokens (list of str): The tokens of the expression.

    Returns:
        float: The result of the evaluation.
    """

    # Get the first token
    token = tokens[0]

    # If the token is a number, return the number
    if token.isdigit():
        return float(token)

    # If the token is a left parenthesis, evaluate the expression inside the parentheses
    elif token == '(':
        return _evaluate_expression(tokens[1:-1])

    # If the token is a prefix operator, evaluate the operator and the factor
    elif token in {'sin', 'cos'}:
        operator = token
        factor = _evaluate_factor(tokens[1:])
        return _evaluate_prefix_op(operator, factor)

    # If the token is an infix operator, evaluate the left and right operands and the operator
    else:
        operator = token
        left_operand = _evaluate_expression(tokens[:2])
        right_operand = _evaluate_expression(tokens[2:])
        return _evaluate_infix_op(operator, left_operand, right_operand)

def _evaluate_factor(tokens):
    """
    Evaluate a factor.

    Args:
        tokens (list of str): The tokens of the factor.

    Returns:
        float: The result of the evaluation.
    """

    # Get the first token
    token = tokens[0]

    # If the token is a number, return the number
    if token.isdigit():
        return float(token)

    # If the token is a left parenthesis, evaluate the expression inside the parentheses
    elif token == '(':
        return _evaluate_expression(tokens[1:-1])

    # If the token is a prefix operator, evaluate the operator and the factor
    elif token in {'sin', 'cos'}:
        operator = token
        factor = _evaluate_factor(tokens[1:])
        return _evaluate_prefix_op(operator, factor)

    # Otherwise, raise an error
    else:
        raise ValueError(f"Invalid token: {token}")

def _evaluate_prefix_op(operator, factor):
    """
    Evaluate a prefix operator.

    Args:
        operator (str): The operator.
        factor (float): The factor.

    Returns:
        float: The result of the evaluation.
    """

    # If the operator is 'sin', return the sine of the factor
    if operator == 'sin':
        return math.sin(factor)

    # If the operator is 'cos', return the cosine of the factor
    elif operator == 'cos':
        return math.cos(factor)

    # Otherwise, raise an error
    else:
        raise ValueError(f"Invalid operator: {operator}")

def _evaluate_infix_op(operator, left_operand, right_operand):
    """
    Evaluate an infix operator.

    Args:
        operator (str): The operator.
        left_operand (float): The left operand.
        right_operand (float): The right operand.

    Returns:
        float: The result of the evaluation.
    """

    # If the operator is '+', return the sum of the operands
    if operator == '+':
        return left_operand + right_operand

    # If the operator is '-', return the difference of the operands
    elif operator == '-':
        return left_operand - right_operand

    # If the operator is '*', return the product of the operands
    elif operator == '*':
        return left_operand * right_operand

    # If the operator is '/', return the quotient of the operands
    elif operator == '/':
        return left_operand / right_operand

    # Otherwise, raise an error
    else:
        raise ValueError(f"Invalid operator: {operator}")

import math

def evaluate(expression):
    """
    Evaluate an expression in the given BNF-style grammar.

    Args:
        expression (str): The expression to evaluate.

    Returns:
        float: The result of the evaluation.
    """

    # Tokenize the expression
    tokens = expression.split()

    # Evaluate the expression
    result = _evaluate_expression(tokens)

    # Return the result
    return result

def _evaluate_expression(tokens):
    """
    Evaluate an expression.

    Args:
        tokens (list of str): The tokens of the expression.

    Returns:
        float: The result of the evaluation.
    """

    # Get the first token
    token = tokens[0]

    # If the token is a number, return the number
    if token.isdigit():
        return float(token)

    # If the token is a left parenthesis, evaluate the expression inside the parentheses
    elif token == '(':
        return _evaluate_expression(tokens[1:-1])

    # If the token is a prefix operator, evaluate the operator and the factor
    elif token in {'sin', 'cos'}:
        operator = token
        factor = _evaluate_factor(tokens[1:])
        return _evaluate_prefix_op(operator, factor)

    # If the token is an infix operator, evaluate the left and right operands and the operator
    else:
        operator = token
        left_operand = _evaluate_expression(tokens[:2])
        right_operand = _evaluate_expression(tokens[2:])
        return _evaluate_infix_op(operator, left_operand, right_operand)

def _evaluate_factor(tokens):
    """
    Evaluate a factor.

    Args:
        tokens (list of str): The tokens of the factor.

    Returns:
        float: The result of the evaluation.
    """

    # Get the first token
    token = tokens[0]

    # If the token is a number, return the number
    if token.isdigit():
        return float(token)

    # If the token is a left parenthesis, evaluate the expression inside the parentheses
    elif token == '(':
        return _evaluate_expression(tokens[1:-1])

    # If the token is a prefix operator, evaluate the operator and the factor
    elif token in {'sin', 'cos'}:
        operator = token
        factor = _evaluate_factor(tokens[1:])
        return _evaluate_prefix_op(operator, factor)

    # Otherwise, raise an error
    else:
        raise ValueError(f"Invalid token: {token}")

def _evaluate_prefix_op(operator, factor):
    """
    Evaluate a prefix operator.

    Args:
        operator (str): The operator.
        factor (float): The factor.

    Returns:
        float: The result of the evaluation.
    """

    # If the operator is 'sin', return the sine of the factor
    if operator == 'sin':
        return math.sin(factor)

    # If the operator is 'cos', return the cosine of the factor
    elif operator == 'cos':
        return math.cos(factor)

    # Otherwise, raise an error
    else:
        raise ValueError(f"Invalid operator: {operator}")

def _evaluate_infix_op(operator, left_operand, right_operand):
    """
    Evaluate an infix operator.

    Args:
        operator (str): The operator.
        left_operand (float): The left operand.
        right_operand (float): The right operand.

    Returns:
        float: The result of the evaluation.
    """

    # If the operator is '+', return the sum of the operands
    if operator == '+':
        return left_operand + right_operand

    # If the operator is '-', return the difference of the operands
    elif operator == '-':
        return left_operand - right_operand

    # If the operator is '*', return the product of the operands
    elif operator == '*':
        return left_operand * right_operand

    # If the operator is '/', return the quotient of the operands
    elif operator == '/':
        return left_operand / right_operand

    # Otherwise, raise an error
    else:
        raise ValueError(f"Invalid operator: {operator}")

import math

def evaluate(expression):
    """
    Evaluate an expression in the given BNF-style grammar.

    Args:
        expression (str): The expression to evaluate.

    Returns:
        float: The result of the evaluation.
    """

    # Tokenize the expression
    tokens = expression.split()

    # Evaluate the expression
    result = _evaluate_expression(tokens)

    # Return the result
    return result

def _evaluate_expression(tokens):
    """
    Evaluate an expression.

    Args:
        tokens (list of str): The tokens of the expression.

    Returns:
        float: The result of the evaluation.
    """

    # Get the first token
    token = tokens[0]

    # If the token is a number, return the number
    if token.isdigit():
        return float(token)

    # If the token is a left parenthesis, evaluate the expression inside the parentheses
    elif token == '(':
        return _evaluate_expression(tokens[1:-1])

    # If the token is a prefix operator, evaluate the operator and the factor
    elif token in {'sin', 'cos'}:
        operator = token
        factor = _evaluate_factor(tokens[1:])
        return _evaluate_prefix_op(operator, factor)

    # If the token is an infix operator, evaluate the left and right operands and the operator
    else:
        operator = token
        left_operand = _evaluate_expression(tokens[:2])
        right_operand = _evaluate_expression(tokens[2:])
        return _evaluate_infix_op(operator, left_operand, right_operand)

def _evaluate_factor(tokens):
    """
    Evaluate a factor.

    Args:
        tokens (list of str): The tokens of the factor.

    Returns:
        float: The result of the evaluation.
    """

    # Get the first token
    token = tokens[0]

    # If the token is a number, return the number
    if token.isdigit():
        return float(token)

    # If the token is a left parenthesis, evaluate the expression inside the parentheses
    elif token == '(':
        return _evaluate_expression(tokens[1:-1])

    # If the token is a prefix operator, evaluate the operator and the factor
    elif token in {'sin', 'cos'}:
        operator = token
        factor = _evaluate_factor(tokens[1:])
        return _evaluate_prefix_op(operator, factor)

    # Otherwise, raise an error
    else:
        raise ValueError(f"Invalid token: {token}")

def _evaluate_prefix_op(operator, factor):
    """
    Evaluate a prefix operator.

    Args:
        operator (str): The operator.
        factor (float): The factor.

    Returns:
        float: The result of the evaluation.
    """

    # If the operator is 'sin', return the sine of the factor
    if operator == 'sin':
        return math.sin(factor)

    # If the operator is 'cos', return the cosine of the factor
    elif operator == 'cos':
        return math.cos(factor)

    # Otherwise, raise an error
    else:
        raise ValueError(f"Invalid operator: {operator}")

def _evaluate_infix_op(operator, left_operand, right_operand):
    """
    Evaluate an infix operator.

    Args:
        operator (str): The operator.
        left_operand (float): The left operand.
        right_operand (float): The right operand.

    Returns:
        float: The result of the evaluation.
    """

    # If the operator is '+', return the sum of the operands
    if operator == '+':
        return left_operand + right_operand

    # If the operator is '-', return the difference of the operands
    elif operator == '-':
        return left_operand - right_operand

    # If the operator is '*', return the product of the operands
    elif operator == '*':
        return left_operand * right_operand

    # If the operator is '/', return the quotient of the operands
    elif operator == '/':
        return left_operand / right_operand

    # Otherwise, raise an error
    else:
        raise ValueError(f"Invalid operator: {operator}")





answer = round(evaluate('sin(35+2*4)-cos(15)'), 5)
expected = -0.07209
assert answer == expected, f'Wrong answer; got {answer} instead of {expected}'
print('All tests passed')

import math

def evaluate(expr):
    """
    Evaluates a mathematical expression given in a BNF-style grammar.

    <expression> ::= <term> | <expression> '+' <term> | <expression> '-' <term>

    <term> ::= <factor> | <term> '*' <factor> | <term> '/' <factor>

    <factor> ::= <number> | '(' <expression> ')' | <prefix-op> <factor>

    <prefix-op> ::= 'sin' | 'cos'

    <number> ::= <digit> | <number> <digit>

    <digit> ::= '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
    """
    tokens = expr.split()
    return _evaluate(tokens)

def _evaluate(tokens):
    """
    Helper function for evaluate().
    """
    if len(tokens) == 1:
        return _evaluate_factor(tokens[0])
    elif tokens[1] in ['+', '-']:
        return _evaluate_expression(tokens[0], tokens[1], tokens[2:])
    elif tokens[1] in ['*', '/']:
        return _evaluate_term(tokens[0], tokens[1], tokens[2:])
    else:
        raise ValueError("Invalid expression: {}".format(expr))

def _evaluate_expression(left, op, right):
    """
    Helper function for evaluate().
    """
    left_value = _evaluate(left)
    right_value = _evaluate(right)
    if op == '+':
        return left_value + right_value
    elif op == '-':
        return left_value - right_value
    else:
        raise ValueError("Invalid operator: {}".format(op))

def _evaluate_term(left, op, right):
    """
    Helper function for evaluate().
    """
    left_value = _evaluate(left)
    right_value = _evaluate(right)
    if op == '*':
        return left_value * right_value
    elif op == '/':
        return left_value / right_value
    else:
        raise ValueError("Invalid operator: {}".format(op))

def _evaluate_factor(token):
    """
    Helper function for evaluate().
    """
    if token.isdigit():
        return int(token)
    elif token[0] == '(' and token[-1] == ')':
        return _evaluate(token[1:-1])
    elif token in ['sin', 'cos']:
        return math.sin(math.radians(_evaluate(token[3:]))) if token == 'sin' else math.cos(math.radians(_evaluate(token[3:])))
    else:
        raise ValueError("Invalid factor: {}".format(token))

import math

def evaluate(expr):
    """
    Evaluates a mathematical expression given in a BNF-style grammar.

    <expression> ::= <term> | <expression> '+' <term> | <expression> '-' <term>

    <term> ::= <factor> | <term> '*' <factor> | <term> '/' <factor>

    <factor> ::= <number> | '(' <expression> ')' | <prefix-op> <factor>

    <prefix-op> ::= 'sin' | 'cos'

    <number> ::= <digit> | <number> <digit>

    <digit> ::= '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
    """
    tokens = expr.split()
    return _evaluate(tokens)

def _evaluate(tokens):
    """
    Helper function for evaluate().
    """
    if len(tokens) == 1:
        return _evaluate_factor(tokens[0])
    elif tokens[1] in ['+', '-']:
        return _evaluate_expression(tokens[0], tokens[1], tokens[2:])
    elif tokens[1] in ['*', '/']:
        return _evaluate_term(tokens[0], tokens[1], tokens[2:])
    else:
        raise ValueError("Invalid expression: {}".format(expr))

def _evaluate_expression(left, op, right):
    """
    Helper function for evaluate().
    """
    left_value = _evaluate(left)
    right_value = _evaluate(right)
    if op == '+':
        return left_value + right_value
    elif op == '-':
        return left_value - right_value
    else:
        raise ValueError("Invalid operator: {}".format(op))

def _evaluate_term(left, op, right):
    """
    Helper function for evaluate().
    """
    left_value = _evaluate(left)
    right_value = _evaluate(right)
    if op == '*':
        return left_value * right_value
    elif op == '/':
        return left_value / right_value
    else:
        raise ValueError("Invalid operator: {}".format(op))

def _evaluate_factor(token):
    """
    Helper function for evaluate().
    """
    if token.isdigit():
        return int(token)
    elif token[0] == '(' and token[-1] == ')':
        return _evaluate(token[1:-1])
    elif token in ['sin', 'cos']:
        return math.sin(math.radians(_evaluate(token[3:]))) if token == 'sin' else math.cos(math.radians(_evaluate(token[3:])))
    else:
        raise ValueError("Invalid factor: {}".format(token))

import math

def evaluate(expr):
    """
    Evaluates a mathematical expression given in a BNF-style grammar.

    <expression> ::= <term> | <expression> '+' <term> | <expression> '-' <term>

    <term> ::= <factor> | <term> '*' <factor> | <term> '/' <factor>

    <factor> ::= <number> | '(' <expression> ')' | <prefix-op> <factor>

    <prefix-op> ::= 'sin' | 'cos'

    <number> ::= <digit> | <number> <digit>

    <digit> ::= '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
    """
    tokens = expr.split()
    return _evaluate(tokens)

def _evaluate(tokens):
    """
    Helper function for evaluate().
    """
    if len(tokens) == 1:
        return _evaluate_factor(tokens[0])
    elif tokens[1] in ['+', '-']:
        return _evaluate_expression(tokens[0], tokens[1], tokens[2:])
    elif tokens[1] in ['*', '/']:
        return _evaluate_term(tokens[0], tokens[1], tokens[2:])
    else:
        raise ValueError("Invalid expression: {}".format(expr))

def _evaluate_expression(left, op, right):
    """
    Helper function for evaluate().
    """
    left_value = _evaluate(left)
    right_value = _evaluate(right)
    if op == '+':
        return left_value + right_value
    elif op == '-':
        return left_value - right_value
    else:
        raise ValueError("Invalid operator: {}".format(op))

def _evaluate_term(left, op, right):
    """
    Helper function for evaluate().
    """
    left_value = _evaluate(left)
    right_value = _evaluate(right)
    if op == '*':
        return left_value * right_value
    elif op == '/':
        return left_value / right_value
    else:
        raise ValueError("Invalid operator: {}".format(op))

def _evaluate_factor(token):
    """
    Helper function for evaluate().
    """
    if token.isdigit():
        return int(token)
    elif token[0] == '(' and token[-1] == ')':
        return _evaluate(token[1:-1])
    elif token in ['sin', 'cos']:
        return math.sin(math.radians(_evaluate(token[3:]))) if token == 'sin' else math.cos(math.radians(_evaluate(token[3:])))
    else:
        raise ValueError("Invalid factor: {}".format(token))





answer = round(evaluate('sin(35+2*4)-cos(15)'), 5)
expected = -0.07209
assert answer == expected, f'Wrong answer; got {answer} instead of {expected}'
print('All tests passed')