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

    tokens = []
    i = 0
    n = len(s)

    while i < n:
        c = s[i]

        if c.isspace():
            i += 1
            continue

        if ("0" <= c <= "9") or c == ".":
            start = i

            if c == ".":
                if i + 1 >= n or not ("0" <= s[i + 1] <= "9"):
                    raise ValueError("invalid token")
                i += 1
                while i < n and "0" <= s[i] <= "9":
                    i += 1
            else:
                while i < n and "0" <= s[i] <= "9":
                    i += 1
                if i < n and s[i] == ".":
                    i += 1
                    while i < n and "0" <= s[i] <= "9":
                        i += 1

            text = s[start:i]
            try:
                value = float(text) if "." in text else int(text)
            except (ValueError, OverflowError):
                raise ValueError("invalid number")
            tokens.append(("number", value))
            continue

        if c in "+-*/()":
            tokens.append((c, c))
            i += 1
            continue

        raise ValueError("unknown token")

    position = 0

    def parse_primary():
        nonlocal position

        if position >= len(tokens):
            raise ValueError("expected operand")

        kind, value = tokens[position]

        if kind == "number":
            position += 1
            return value

        if kind == "(":
            position += 1
            result = parse_expression()
            if position >= len(tokens) or tokens[position][0] != ")":
                raise ValueError("mismatched parentheses")
            position += 1
            return result

        raise ValueError("expected operand")

    def parse_factor():
        nonlocal position

        if position < len(tokens) and tokens[position][0] in ("+", "-"):
            operator = tokens[position][0]
            position += 1
            value = parse_factor()
            return value if operator == "+" else -value

        return parse_primary()

    def parse_term():
        nonlocal position

        result = parse_factor()

        while position < len(tokens) and tokens[position][0] in ("*", "/"):
            operator = tokens[position][0]
            position += 1
            right = parse_factor()

            if operator == "*":
                result = result * right
            else:
                if right == 0:
                    raise ValueError("division by zero")
                result = result / right

        return result

    def parse_expression():
        nonlocal position

        result = parse_term()

        while position < len(tokens) and tokens[position][0] in ("+", "-"):
            operator = tokens[position][0]
            position += 1
            right = parse_term()

            if operator == "+":
                result = result + right
            else:
                result = result - right

        return result

    if not tokens:
        raise ValueError("empty expression")

    result = parse_expression()

    if position != len(tokens):
        raise ValueError("malformed expression")

    if isinstance(result, float) and result.is_integer():
        return int(result)
    return result