from fractions import Fraction


def eval_expr(s):
    if not isinstance(s, str):
        raise ValueError("expression must be a string")

    n = len(s)
    i = 0

    def is_digit(ch):
        return "0" <= ch <= "9"

    def skip_ws():
        nonlocal i
        while i < n and s[i].isspace():
            i += 1

    def parse_number():
        nonlocal i
        skip_ws()

        before_start = i
        while i < n and is_digit(s[i]):
            i += 1
        before = s[before_start:i]

        after = ""
        has_dot = False
        if i < n and s[i] == ".":
            has_dot = True
            i += 1
            after_start = i
            while i < n and is_digit(s[i]):
                i += 1
            after = s[after_start:i]

        if not before and not after:
            raise ValueError("malformed number")

        if not has_dot:
            return Fraction(int(before), 1)

        scale = 10 ** len(after)
        whole = int(before) if before else 0
        frac = int(after) if after else 0
        return Fraction(whole * scale + frac, scale)

    def parse_primary():
        nonlocal i
        skip_ws()

        if i >= n:
            raise ValueError("unexpected end of expression")

        ch = s[i]

        if ch == "(":
            i += 1
            value = parse_expression()
            skip_ws()
            if i >= n or s[i] != ")":
                raise ValueError("mismatched parentheses")
            i += 1
            return value

        if is_digit(ch) or ch == ".":
            return parse_number()

        raise ValueError("unknown token")

    def parse_unary():
        nonlocal i
        skip_ws()

        sign = 1
        while i < n and s[i] in "+-":
            if s[i] == "-":
                sign = -sign
            i += 1
            skip_ws()

        value = parse_primary()
        return value if sign == 1 else -value

    def parse_term():
        nonlocal i
        value = parse_unary()

        while True:
            skip_ws()
            if i >= n or s[i] not in "*/":
                break

            op = s[i]
            i += 1
            rhs = parse_unary()

            if op == "*":
                value *= rhs
            else:
                if rhs == 0:
                    raise ValueError("division by zero")
                value /= rhs

        return value

    def parse_expression():
        nonlocal i
        value = parse_term()

        while True:
            skip_ws()
            if i >= n or s[i] not in "+-":
                break

            op = s[i]
            i += 1
            rhs = parse_term()

            if op == "+":
                value += rhs
            else:
                value -= rhs

        return value

    skip_ws()
    if i >= n:
        raise ValueError("empty expression")

    result = parse_expression()
    skip_ws()

    if i != n:
        raise ValueError("malformed expression")

    if result.denominator == 1:
        return result.numerator
    return float(result)