ladder.coding.expr_eval

```python
import re

def evaluate(expr: str) -> float:
    """
    Evaluates an arithmetic expression string containing +, -, *, /, (), 
    and decimal numbers. Returns the result as a float.
    """
    # Tokenize the expression using regex to find numbers, operators, and parentheses
    tokens = re.findall(r'\d+\.?\d*|[\+\-\*\/\(\)]', expr)
    
    def compute(tokens):
        values = []
        ops = []
        i = 0
        
        while i < len(tokens):
            token = tokens[i]
            
            if token == '(':
                # Find matching parenthesis to handle nested expressions recursively
                count = 1
                j = i + 1
                while j < len(tokens) and count > 0:
                    if tokens[j] == '(':
                        count += 1
                    elif tokens[j] == ')':
                        count -= 1
                    j += 1
                # Recursively evaluate the content inside parentheses
                values.append(compute(tokens[i+1:j-1]))
                i = j - 1
            elif token in '+-*/':
                ops.append(token)
            else:
                # It's a number
                values.append(float(token))
            i += 1

        # Handle multiplication and division first (higher precedence)
        # We use a stack-based approach to maintain left-associativity
        idx = 0
        while idx < len(ops):
            if ops[idx] in '*/':
                op = ops.pop(idx)
                val1 = values.pop(idx)
                val2 = values.pop(idx)
                if op == '*':
                    res = val1 * val2
                else:
                    res = val1 / val2
                values.insert(idx, res)
            else:
                idx += 1
        
        # Handle addition and subtraction (lower precedence)
        if not values:
            return 0.0
        
        result = values[0]
        for idx in range(len(ops)):
            op = ops[idx]
            val = values[idx + 1]
            if op == '+':
                result += val
            elif op == '-':
                result -= val
        return result

    # Clean input: remove spaces and handle potential unary minus at the start or after '('
    # However, for a standard expression evaluator, we assume valid infix notation.
    # To support simple unary minus like "-5 + 3", we can prepend a '0' if it starts with '-'
    if expr.strip().startswith('-'):
        tokens = ['0'] + tokens
    
    # A more robust way to handle unary operators is to treat '-x' as '0 - x'
    # during the tokenization/parsing phase, but for this implementation 
    # we will process the list of tokens.
    
    # Refined approach: Pre-process tokens to handle unary minus by inserting a 0
    processed_tokens = []
    for idx, t in enumerate(tokens):
        if t == '-' and (idx == 0 or tokens[idx-1] == '('):
            processed_tokens.append('0')
        processed_tokens.append(t)

    return compute(processed_tokens)

# Example usage/testing:
if __name__ == "__main__":
    assert evaluate("3 + 5 * 2") == 13.0
    assert evaluate("(3 + 5) * 2") == 16.0
    assert evaluate("10 / 2 - 1") == 4.0
    assert evaluate("2.5 * 2 + 1.5") == 6.5
    assert evaluate("10 - (2 + 3) * 2") == 0.0
    assert evaluate("-5 + 3") == -2.0
```

```python
import re

def evaluate(expr: str) -> float:
    """
    Evaluates an arithmetic expression string containing +, -, *, /, (), 
    and decimal numbers. Returns the result as a float.
    """
    # Tokenize the expression using regex to find numbers, operators, and parentheses
    tokens = re.findall(r'\d+\.?\d*|[\+\-\*\/\(\)]', expr)
    
    def compute(tokens):
        values = []
        ops = []
        i = 0
        
        while i < len(tokens):
            token = tokens[i]
            
            if token == '(':
                # Find matching parenthesis to handle nested expressions recursively
                count = 1
                j = i + 1
                while j < len(tokens) and count > 0:
                    if tokens[j] == '(':
                        count += 1
                    elif tokens[j] == ')':
                        count -= 1
                    j += 1
                # Recursively evaluate the content inside parentheses
                values.append(compute(tokens[i+1:j-1]))
                i = j - 1
            elif token in '+-*/':
                ops.append(token)
            else:
                # It's a number
                values.append(float(token))
            i += 1

        # Handle multiplication and division first (higher precedence)
        # We use a stack-based approach to maintain left-associativity
        idx = 0
        while idx < len(ops):
            if ops[idx] in '*/':
                op = ops.pop(idx)
                val1 = values.pop(idx)
                val2 = values.pop(idx)
                if op == '*':
                    res = val1 * val2
                else:
                    res = val1 / val2
                values.insert(idx, res)
            else:
                idx += 1
        
        # Handle addition and subtraction (lower precedence)
        if not values:
            return 0.0
        
        result = values[0]
        for idx in range(len(ops)):
            op = ops[idx]
            val = values[idx + 1]
            if op == '+':
                result += val
            elif op == '-':
                result -= val
        return result

    # Clean input: remove spaces and handle potential unary minus at the start or after '('
    # However, for a standard expression evaluator, we assume valid infix notation.
    # To support simple unary minus like "-5 + 3", we can prepend a '0' if it starts with '-'
    if expr.strip().startswith('-'):
        tokens = ['0'] + tokens
    
    # A more robust way to handle unary operators is to treat '-x' as '0 - x'
    # during the tokenization/parsing phase, but for this implementation 
    # we will process the list of tokens.
    
    # Refined approach: Pre-process tokens to handle unary minus by inserting a 0
    processed_tokens = []
    for idx, t in enumerate(tokens):
        if t == '-' and (idx == 0 or tokens[idx-1] == '('):
            processed_tokens.append('0')
        processed_tokens.append(t)

    return compute(processed_tokens)

# Example usage/testing:
if __name__ == "__main__":
    assert evaluate("3 + 5 * 2") == 13.0
    assert evaluate("(3 + 5) * 2") == 16.0
    assert evaluate("10 / 2 - 1") == 4.0
    assert evaluate("2.5 * 2 + 1.5") == 6.5
    assert evaluate("10 - (2 + 3) * 2") == 0.0
    assert evaluate("-5 + 3") == -2.0
```

```python
# solution.py
import re

__all__ = ["evaluate"]

_token_spec = [
    ("NUMBER",   r"\d+(?:\.\d*)?|\.\d+"),  # integer or decimal
    ("PLUS",     r"\+"),
    ("MINUS",    r"-"),
    ("TIMES",    r"\*"),
    ("DIVIDE",   r"/"),
    ("LPAREN",   r"\("),
    ("RPAREN",   r"\)"),
    ("SKIP",     r"[ \t]+"),
]

_tok_regex = re.compile("|".join(f"(?P<{name}>{pattern})" for name, pattern in _token_spec))


def _generate_tokens(text):
    for mo in _tok_regex.finditer(text):
        kind = mo.lastgroup
        if kind == "SKIP":
            continue
        value = mo.group()
        if kind == "NUMBER":
            yield ("NUMBER", float(value))
        else:
            yield (kind, value)
    yield ("EOF", None)


class _Parser:
    def __init__(self, tokens):
        self.tokens = iter(tokens)
        self.current_type, self.current_value = next(self.tokens)

    def _eat(self, token_type):
        if self.current_type == token_type:
            self.current_type, self.current_value = next(self.tokens)
        else:
            raise SyntaxError(f"Expected {token_type} but got {self.current_type}")

    # Grammar:
    # expr   : term ((PLUS|MINUS) term)*
    # term   : factor ((TIMES|DIVIDE) factor)*
    # factor : NUMBER | LPAREN expr RPAREN

    def parse(self):
        result = self._expr()
        if self.current_type != "EOF":
            raise SyntaxError("Unexpected token after expression")
        return result

    def _expr(self):
        value = self._term()
        while self.current_type in ("PLUS", "MINUS"):
            op = self.current_type
            self._eat(op)
            right = self._term()
            if op == "PLUS":
                value += right
            else:
                value -= right
        return value

    def _term(self):
        value = self._factor()
        while self.current_type in ("TIMES", "DIVIDE"):
            op = self.current_type
            self._eat(op)
            right = self._factor()
            if op == "TIMES":
                value *= right
            else:
                value /= right
        return value

    def _factor(self):
        if self.current_type == "NUMBER":
            val = self.current_value
            self._eat("NUMBER")
            return val
        elif self.current_type == "LPAREN":
            self._eat("LPAREN")
            val = self._expr()
            self._eat("RPAREN")
            return val
        else:
            raise SyntaxError(f"Unexpected token {self.current_type}")


def evaluate(expr: str) -> float:
    """
    Evaluate an arithmetic expression containing +, -, *, /,
    parentheses, non‑negative integer and decimal literals.
    Spaces are ignored. Returns the numeric result as a float.
    """
    tokens = _generate_tokens(expr)
    parser = _Parser(tokens)
    return parser.parse()
```

```python
import re

def evaluate(expr: str) -> float:
    expr = re.sub(r'\s+', '', expr)

    def parse_expression():
        nonlocal pos
        value = parse_term()
        while pos < len(tokens):
            token = tokens[pos]
            if token == '+':
                pos += 1
                value += parse_term()
            elif token == '-':
                pos += 1
                value -= parse_term()
            else:
                break
        return value

    def parse_term():
        nonlocal pos
        value = parse_factor()
        while pos < len(tokens):
            token = tokens[pos]
            if token == '*':
                pos += 1
                value *= parse_factor()
            elif token == '/':
                pos += 1
                value /= parse_factor()
            else:
                break
        return value

    def parse_factor():
        nonlocal pos
        token = tokens[pos]
        if token == '(':
            pos += 1
            value = parse_expression()
            pos += 1  # skip ')'
            return value
        elif re.match(r'\d+(\.\d+)?', token):
            pos += 1
            return float(token)
        else:
            raise ValueError(f"Unexpected token: {token}")

    tokens = re.findall(r'\d+\.\d+|\d+|[()+\-*/]', expr)
    pos = 0
    return parse_expression()
```

```python
def evaluate(expr):
    """
    Evaluates an arithmetic expression string and returns its numeric value.
    
    Supports + - * /, parentheses, non-negative integer and decimal literals,
    and ignores spaces. Uses standard precedence (* and / before + and -),
    left-associative, with real (float) division.

    :param expr: The arithmetic expression to evaluate
    :return: The numeric value of the expression
    """

    # Define operator precedence
    precedence = {
        '+': 1,
        '-': 1,
        '*': 2,
        '/': 2
    }

    # Tokenize the input string
    tokens = []
    current_token = ''
    for char in expr:
        if char.isspace():
            continue
        elif char.isdigit() or char == '.':
            current_token += char
        elif char in precedence or char in ('(', ')'):
            if current_token:
                tokens.append(current_token)
                current_token = ''
            tokens.append(char)
    if current_token:
        tokens.append(current_token)

    # Convert infix to postfix notation using the Shunting-yard algorithm
    output_queue = []
    operator_stack = []
    for token in tokens:
        if token not in precedence and token not in ('(', ')'):
            output_queue.append(float(token))
        elif token == '(':
            operator_stack.append(token)
        elif token == ')':
            while operator_stack[-1] != '(':
                output_queue.append(operator_stack.pop())
            operator_stack.pop()  # Remove the '('
        else:
            while (operator_stack and 
                   operator_stack[-1] in precedence and 
                   precedence[operator_stack[-1]] >= precedence[token]):
                output_queue.append(operator_stack.pop())
            operator_stack.append(token)
    while operator_stack:
        output_queue.append(operator_stack.pop())

    # Evaluate the postfix expression
    evaluation_stack = []
    for token in output_queue:
        if token not in precedence:
            evaluation_stack.append(token)
        else:
            operand2 = evaluation_stack.pop()
            operand1 = evaluation_stack.pop()
            if token == '+':
                result = operand1 + operand2
            elif token == '-':
                result = operand1 - operand2
            elif token == '*':
                result = operand1 * operand2
            elif token == '/':
                result = operand1 / operand2
            evaluation_stack.append(result)

    return evaluation_stack[0]
```

```python
def evaluate(expr):
    # Remove spaces from expression
    expr = expr.replace(' ', '')
    
    # Tokenize the expression
    tokens = tokenize(expr)
    
    pos = 0
    
    def parse_expression():
        nonlocal pos
        left = parse_term()
        while pos < len(tokens) and tokens[pos] in ('+', '-'):
            op = tokens[pos]
            pos += 1
            right = parse_term()
            if op == '+':
                left = left + right
            else:
                left = left - right
        return left
    
    def parse_term():
        nonlocal pos
        left = parse_factor()
        while pos < len(tokens) and tokens[pos] in ('*', '/'):
            op = tokens[pos]
            pos += 1
            right = parse_factor()
            if op == '*':
                left = left * right
            else:
                left = left / right
        return left
    
    def parse_factor():
        nonlocal pos
        token = tokens[pos]
        
        # Check for number (integer or float)
        if token[0].isdigit() or (token[0] == '-' and len(token) > 1):
            value = float(token)
            pos += 1
            return value
        
        # Check for opening parenthesis
        if token == '(':
            pos += 1
            result = parse_expression()
            if pos < len(tokens) and tokens[pos] == ')':
                pos += 1
            return result
        
        raise ValueError(f"Unexpected token: {token}")
    
    # Start parsing
    result = parse_expression()
    return result

def tokenize(expr):
    """Tokenize the expression into numbers, operators, and parentheses."""
    tokens = []
    i = 0
    while i < len(expr):
        if expr[i].isspace():
            i += 1
            continue
        
        # Check for operator or parenthesis
        if expr[i] in '+-*/()':
            tokens.append(expr[i])
            i += 1
            continue
        
        # Parse number (integer or float)
        j = i
        while j < len(expr) and (expr[j].isdigit() or expr[j] == '.'):
            j += 1
        
        if j > i:
            tokens.append(expr[i:j])
            i = j
        else:
            raise ValueError(f"Unexpected character at position {i}: {expr[i]}")
    
    return tokens
```

```python
def evaluate(expr):
    class Tokenizer:
        def __init__(self, text):
            self.text = text
            self.pos = 0
            self.length = len(text)
            self.current_token = None
            self.advance()

        def advance(self):
            self.skip_spaces()
            if self.pos >= self.length:
                self.current_token = ('EOF', None)
                return
            
            char = self.text[self.pos]
            
            if char.isdigit() or char == '.':
                self.read_number()
            elif char == '+':
                self.current_token = ('PLUS', '+')
                self.pos += 1
            elif char == '-':
                self.current_token = ('MINUS', '-')
                self.pos += 1
            elif char == '*':
                self.current_token = ('STAR', '*')
                self.pos += 1
            elif char == '/':
                self.current_token = ('SLASH', '/')
                self.pos += 1
            elif char == '(':
                self.current_token = ('LPAREN', '(')
                self.pos += 1
            elif char == ')':
                self.current_token = ('RPAREN', ')')
                self.pos += 1
            else:
                raise ValueError(f"Unexpected character: {char}")

        def skip_spaces(self):
            while self.pos < self.length and self.text[self.pos].isspace():
                self.pos += 1

        def read_number(self):
            start = self.pos
            has_dot = False
            while self.pos < self.length and (self.text[self.pos].isdigit() or self.text[self.pos] == '.'):
                if self.text[self.pos] == '.':
                    if has_dot:
                        raise ValueError("Invalid number format")
                    has_dot = True
                self.pos += 1
            num_str = self.text[start:self.pos]
            if has_dot:
                self.current_token = ('NUMBER', float(num_str))
            else:
                self.current_token = ('NUMBER', int(num_str))

    class Parser:
        def __init__(self, tokenizer):
            self.tokenizer = tokenizer
            self.current_token = self.tokenizer.current_token

        def eat(self, token_type):
            if self.current_token[0] == token_type:
                self.tokenizer.advance()
                self.current_token = self.tokenizer.current_token
            else:
                raise ValueError(f"Expected {token_type}, got {self.current_token}")

        def parse(self):
            result = self.parse_expr()
            if self.current_token[0] != 'EOF':
                raise ValueError("Unexpected tokens after expression")
            return result

        def parse_expr(self):
            result = self.parse_term()
            while self.current_token[0] in ('PLUS', 'MINUS'):
                op = self.current_token[0]
                self.tokenizer.advance()
                self.current_token = self.tokenizer.current_token
                right = self.parse_term()
                if op == 'PLUS':
                    result += right
                else:
                    result -= right
            return result

        def parse_term(self):
            result = self.parse_factor()
            while self.current_token[0] in ('STAR', 'SLASH'):
                op = self.current_token[0]
                self.tokenizer.advance()
                self.current_token = self.tokenizer.current_token
                right = self.parse_factor()
                if op == 'STAR':
                    result *= right
                else:
                    result /= right
            return result

        def parse_factor(self):
            if self.current_token[0] in ('PLUS', 'MINUS'):
                op = self.current_token[0]
                self.tokenizer.advance()
                self.current_token = self.tokenizer.current_token
                val = self.parse_factor()
                return val if op == 'PLUS' else -val
            elif self.current_token[0] == 'NUMBER':
                val = self.current_token[1]
                self.tokenizer.advance()
                self.current_token = self.tokenizer.current_token
                return val
            elif self.current_token[0] == 'LPAREN':
                self.tokenizer.advance()
                self.current_token = self.tokenizer.current_token
                result = self.parse_expr()
                self.eat('RPAREN')
                return result
            else:
                raise ValueError(f"Unexpected token: {self.current_token}")

    tokenizer = Tokenizer(expr)
    parser = Parser(tokenizer)
    return parser.parse()
```

```python
def evaluate(expr):
    class Tokenizer:
        def __init__(self, text):
            self.text = text
            self.pos = 0
            self.length = len(text)
            self.current_token = None
            self.advance()

        def advance(self):
            self.skip_spaces()
            if self.pos >= self.length:
                self.current_token = ('EOF', None)
                return
            
            char = self.text[self.pos]
            
            if char.isdigit() or char == '.':
                self.read_number()
            elif char == '+':
                self.current_token = ('PLUS', '+')
                self.pos += 1
            elif char == '-':
                self.current_token = ('MINUS', '-')
                self.pos += 1
            elif char == '*':
                self.current_token = ('STAR', '*')
                self.pos += 1
            elif char == '/':
                self.current_token = ('SLASH', '/')
                self.pos += 1
            elif char == '(':
                self.current_token = ('LPAREN', '(')
                self.pos += 1
            elif char == ')':
                self.current_token = ('RPAREN', ')')
                self.pos += 1
            else:
                raise ValueError(f"Unexpected character: {char}")

        def skip_spaces(self):
            while self.pos < self.length and self.text[self.pos].isspace():
                self.pos += 1

        def read_number(self):
            start = self.pos
            has_dot = False
            while self.pos < self.length and (self.text[self.pos].isdigit() or self.text[self.pos] == '.'):
                if self.text[self.pos] == '.':
                    if has_dot:
                        raise ValueError("Invalid number format")
                    has_dot = True
                self.pos += 1
            num_str = self.text[start:self.pos]
            if has_dot:
                self.current_token = ('NUMBER', float(num_str))
            else:
                self.current_token = ('NUMBER', int(num_str))

    class Parser:
        def __init__(self, tokenizer):
            self.tokenizer = tokenizer
            self.current_token = self.tokenizer.current_token

        def eat(self, token_type):
            if self.current_token[0] == token_type:
                self.tokenizer.advance()
                self.current_token = self.tokenizer.current_token
            else:
                raise ValueError(f"Expected {token_type}, got {self.current_token}")

        def parse(self):
            result = self.parse_expr()
            if self.current_token[0] != 'EOF':
                raise ValueError("Unexpected tokens after expression")
            return result

        def parse_expr(self):
            result = self.parse_term()
            while self.current_token[0] in ('PLUS', 'MINUS'):
                op = self.current_token[0]
                self.tokenizer.advance()
                self.current_token = self.tokenizer.current_token
                right = self.parse_term()
                if op == 'PLUS':
                    result += right
                else:
                    result -= right
            return result

        def parse_term(self):
            result = self.parse_factor()
            while self.current_token[0] in ('STAR', 'SLASH'):
                op = self.current_token[0]
                self.tokenizer.advance()
                self.current_token = self.tokenizer.current_token
                right = self.parse_factor()
                if op == 'STAR':
                    result *= right
                else:
                    result /= right
            return result

        def parse_factor(self):
            if self.current_token[0] in ('PLUS', 'MINUS'):
                op = self.current_token[0]
                self.tokenizer.advance()
                self.current_token = self.tokenizer.current_token
                val = self.parse_factor()
                return val if op == 'PLUS' else -val
            elif self.current_token[0] == 'NUMBER':
                val = self.current_token[1]
                self.tokenizer.advance()
                self.current_token = self.tokenizer.current_token
                return val
            elif self.current_token[0] == 'LPAREN':
                self.tokenizer.advance()
                self.current_token = self.tokenizer.current_token
                result = self.parse_expr()
                self.eat('RPAREN')
                return result
            else:
                raise ValueError(f"Unexpected token: {self.current_token}")

    tokenizer = Tokenizer(expr)
    parser = Parser(tokenizer)
    return parser.parse()
```

```python
# solution.py

import re
from operator import add, sub, mul, truediv

def evaluate(expr):
    def parse_expression(tokens):
        def parse_primary():
            token = tokens.pop(0)
            if token == '(':
                result = parse_expression(tokens)
                tokens.pop(0)  # Remove ')'
                return result
            else:
                return float(token)

        def parse_factor():
            result = parse_primary()
            while tokens and tokens[0] in ('*', '/'):
                op = tokens.pop(0)
                right = parse_primary()
                if op == '*':
                    result = mul(result, right)
                elif op == '/':
                    result = truediv(result, right)
            return result

        def parse_term():
            result = parse_factor()
            while tokens and tokens[0] in ('+', '-'):
                op = tokens.pop(0)
                right = parse_factor()
                if op == '+':
                    result = add(result, right)
                elif op == '-':
                    result = sub(result, right)
            return result

        return parse_term()

    # Tokenize the expression
    token_pattern = re.compile(r'\s*(=>|[()+\-*/]|[0-9]*\.?[0-9]+)\s*')
    tokens = token_pattern.findall(expr)
    return parse_expression(tokens)

if __name__ == "__main__":
    print(evaluate("3 + 5 / 2"))          # Output: 5.5
    print(evaluate("10 + 2 * 6"))         # Output: 22.0
    print(evaluate("100 * 2 + 12"))       # Output: 212.0
    print(evaluate("100 * ( 2 + 12 )"))   # Output: 1400.0
    print(evaluate("100 * ( 2 + 12 ) / 14"))  # Output: 100.0
```

```python
import re

def evaluate(expr):
    """Evaluate an arithmetic expression and return its numeric value."""
    tokens = _tokenize(expr)
    parser = _Parser(tokens)
    result = parser.parse_expr()
    if parser.current() is not None:
        raise ValueError("Unexpected token after end of expression")
    return result


def _tokenize(s):
    """Convert the input string into a list of tokens."""
    tokens = []
    i, n = 0, len(s)
    while i < n:
        ch = s[i]
        if ch.isspace():
            i += 1
            continue
        if ch in '+-*/()':
            tokens.append(ch)
            i += 1
        elif ch.isdigit() or ch == '.':
            start = i
            dot_seen = False
            while i < n and (s[i].isdigit() or s[i] == '.'):
                if s[i] == '.':
                    if dot_seen:
                        break  # second dot ends the number
                    dot_seen = True
                i += 1
            tokens.append(s[start:i])
        else:
            raise ValueError(f"Invalid character: {ch!r}")
    return tokens


class _Parser:
    def __init__(self, tokens):
        self.tokens = tokens
        self.pos = 0

    def current(self):
        return self.tokens[self.pos] if self.pos < len(self.tokens) else None

    def consume(self, expected=None):
        token = self.current()
        if token is None:
            raise ValueError("Unexpected end of input")
        if expected and token != expected:
            raise ValueError(f"Expected {expected!r} but got {token!r}")
        self.pos += 1
        return token

    def parse_expr(self):
        value = self.parse_term()
        while True:
            op = self.current()
            if op in ('+', '-'):
                self.consume(op)
                rhs = self.parse_term()
                if op == '+':
                    value += rhs
                else:
                    value -= rhs
            else:
                break
        return value

    def parse_term(self):
        value = self.parse_factor()
        while True:
            op = self.current()
            if op in ('*', '/'):
                self.consume(op)
                rhs = self.parse_factor()
                if op == '*':
                    value *= rhs
                else:
                    value /= rhs
            else:
                break
        return value

    def parse_factor(self):
        token = self.current()
        if token is None:
            raise ValueError("Unexpected end of input")
        if token == '(':
            self.consume('(')
            value = self.parse_expr()
            if self.current() != ')':
                raise ValueError("Missing closing parenthesis")
            self.consume(')')
            return value
        # number literal
        try:
            value = float(token)
        except ValueError:
            raise ValueError(f"Expected number but got {token!r}")
        self.consume()
        return value
```

```python
import re

def evaluate(expr: str) -> float:
    """
    Evaluates an arithmetic expression string containing +, -, *, /, (), 
    and decimal numbers. Returns the result as a float.
    """
    # Tokenize the expression using regex to find numbers, operators, and parentheses
    tokens = re.findall(r'\d+\.?\d*|[\+\-\*\/\(\)]', expr)
    
    def compute(tokens):
        values = []
        ops = []
        i = 0
        
        while i < len(tokens):
            token = tokens[i]
            
            if token == '(':
                # Find matching parenthesis to handle nested expressions recursively
                count = 1
                j = i + 1
                while j < len(tokens) and count > 0:
                    if tokens[j] == '(':
                        count += 1
                    elif tokens[j] == ')':
                        count -= 1
                    j += 1
                # Recursively evaluate the content inside parentheses
                values.append(compute(tokens[i+1:j-1]))
                i = j - 1
            elif token in '+-*/':
                ops.append(token)
            else:
                # It's a number
                values.append(float(token))
            i += 1

        # Handle multiplication and division first (higher precedence)
        # We use a stack-based approach to maintain left-associativity
        idx = 0
        while idx < len(ops):
            if ops[idx] in '*/':
                op = ops.pop(idx)
                val1 = values.pop(idx)
                val2 = values.pop(idx)
                if op == '*':
                    res = val1 * val2
                else:
                    res = val1 / val2
                values.insert(idx, res)
            else:
                idx += 1
        
        # Handle addition and subtraction (lower precedence)
        if not values:
            return 0.0
        
        result = values[0]
        for idx in range(len(ops)):
            op = ops[idx]
            val = values[idx + 1]
            if op == '+':
                result += val
            elif op == '-':
                result -= val
        return result

    # Clean input: remove spaces and handle potential unary minus at the start or after '('
    # However, for a standard expression evaluator, we assume valid infix notation.
    # To support simple unary minus like "-5 + 3", we can prepend a '0' if it starts with '-'
    if expr.strip().startswith('-'):
        tokens = ['0'] + tokens
    
    # A more robust way to handle unary operators is to treat '-x' as '0 - x'
    # during the tokenization/parsing phase, but for this implementation 
    # we will process the list of tokens.
    
    # Refined approach: Pre-process tokens to handle unary minus by inserting a 0
    processed_tokens = []
    for idx, t in enumerate(tokens):
        if t == '-' and (idx == 0 or tokens[idx-1] == '('):
            processed_tokens.append('0')
        processed_tokens.append(t)

    return compute(processed_tokens)

# Example usage/testing:
if __name__ == "__main__":
    assert evaluate("3 + 5 * 2") == 13.0
    assert evaluate("(3 + 5) * 2") == 16.0
    assert evaluate("10 / 2 - 1") == 4.0
    assert evaluate("2.5 * 2 + 1.5") == 6.5
    assert evaluate("10 - (2 + 3) * 2") == 0.0
    assert evaluate("-5 + 3") == -2.0
```

```python
def evaluate(expr: str) -> float:
    tokens = []
    i = 0
    n = len(expr)
    while i < n:
        if expr[i].isspace():
            i += 1
            continue
        if expr[i].isdigit() or expr[i] == '.':
            j = i
            has_dot = False
            while j < n and (expr[j].isdigit() or expr[j] == '.'):
                if expr[j] == '.':
                    if has_dot:
                        break
                    has_dot = True
                j += 1
            tokens.append(('NUM', float(expr[i:j])))
            i = j
        elif expr[i] in '+-*/()':
            tokens.append(('OP', expr[i]))
            i += 1
        else:
            raise ValueError(f"Invalid character: {expr[i]}")
            
    pos = 0
    
    def parse_expr():
        nonlocal pos
        val = parse_term()
        while pos < len(tokens) and tokens[pos][0] == 'OP' and tokens[pos][1] in '+-':
            op = tokens[pos][1]
            pos += 1
            right = parse_term()
            val = val + right if op == '+' else val - right
        return val

    def parse_term():
        nonlocal pos
        val = parse_factor()
        while pos < len(tokens) and tokens[pos][0] == 'OP' and tokens[pos][1] in '*/':
            op = tokens[pos][1]
            pos += 1
            right = parse_factor()
            val = val * right if op == '*' else val / right
        return val

    def parse_factor():
        nonlocal pos
        if pos >= len(tokens):
            raise ValueError("Unexpected end of expression")
        if tokens[pos][0] == 'OP' and tokens[pos][1] in '+-':
            op = tokens[pos][1]
            pos += 1
            val = parse_factor()
            return -val if op == '-' else val
        if tokens[pos][0] == 'NUM':
            val = tokens[pos][1]
            pos += 1
            return val
        if tokens[pos][0] == 'OP' and tokens[pos][1] == '(':
            pos += 1
            val = parse_expr()
            if pos < len(tokens) and tokens[pos][0] == 'OP' and tokens[pos][1] == ')':
                pos += 1
            else:
                raise ValueError("Missing closing parenthesis")
            return val
        raise ValueError("Unexpected token")

    return parse_expr()
```

```python
import re

def evaluate(expr: str) -> float:
    tokens = re.findall(r'\d+\.\d+|\d+|[()+\-*/]', expr.replace(' ', ''))
    
    def parse_expression(index):
        values, operators = [], []
        
        def apply_operator():
            b = values.pop()
            a = values.pop()
            op = operators.pop()
            if op == '+':
                values.append(a + b)
            elif op == '-':
                values.append(a - b)
            elif op == '*':
                values.append(a * b)
            elif op == '/':
                values.append(a / b)

        def evaluate_until(stop_prec):
            while (operators and operators[-1] != '(' and
                   precedence[operators[-1]] >= stop_prec):
                apply_operator()

        precedence = {'+': 1, '-': 1, '*': 2, '/': 2}
        
        while index < len(tokens):
            token = tokens[index]
            if token.isdigit() or '.' in token:
                values.append(float(token))
            elif token == '(':
                sub_val, index = parse_expression(index + 1)
                values.append(sub_val)
            elif token == ')':
                break
            else:  # operator
                evaluate_until(precedence[token])
                operators.append(token)
            index += 1

        while operators:
            apply_operator()

        return values[0], index

    result, _ = parse_expression(0)
    return result
```

```python
def evaluate(expr: str) -> float:
    """
    Evaluate an arithmetic expression string and return its numeric value.
    
    Supports +, -, *, /, parentheses, non-negative integer and decimal literals.
    Ignores spaces. Uses standard precedence (* and / before + and -), 
    left-associative, with real (float) division.
    """
    # Tokenizer
    def tokenize(s: str):
        tokens = []
        i = 0
        n = len(s)
        while i < n:
            if s[i].isspace():
                i += 1
                continue
            if s[i] in '+-*/()':
                tokens.append(s[i])
                i += 1
            elif s[i].isdigit() or s[i] == '.':
                j = i
                has_dot = False
                while j < n and (s[j].isdigit() or s[j] == '.'):
                    if s[j] == '.':
                        if has_dot:
                            break  # Only one dot allowed in a number
                        has_dot = True
                    j += 1
                tokens.append(s[i:j])
                i = j
            else:
                raise ValueError(f"Unexpected character: {s[i]}")
        return tokens

    class Parser:
        def __init__(self, tokens):
            self.tokens = tokens
            self.pos = 0
        
        def peek(self):
            if self.pos < len(self.tokens):
                return self.tokens[self.pos]
            return None
        
        def consume(self):
            token = self.peek()
            self.pos += 1
            return token
        
        def parse_expression(self):
            """Parse addition and subtraction (lowest precedence)"""
            left = self.parse_term()
            while self.peek() in ('+', '-'):
                op = self.consume()
                right = self.parse_term()
                if op == '+':
                    left = left + right
                else:
                    left = left - right
            return left
        
        def parse_term(self):
            """Parse multiplication and division (higher precedence)"""
            left = self.parse_factor()
            while self.peek() in ('*', '/'):
                op = self.consume()
                right = self.parse_factor()
                if op == '*':
                    left = left * right
                else:
                    if right == 0:
                        raise ZeroDivisionError("Division by zero")
                    left = left / right
            return left
        
        def parse_factor(self):
            """Parse numbers and parenthesized expressions"""
            token = self.peek()
            
            # Handle unary minus/plus at the start of a factor
            if token == '-':
                self.consume()
                return -self.parse_factor()
            elif token == '+':
                self.consume()
                return self.parse_factor()
            
            # Parenthesized expression
            if token == '(':
                self.consume()  # consume '('
                result = self.parse_expression()
                if self.peek() != ')':
                    raise ValueError("Missing closing parenthesis")
                self.consume()  # consume ')'
                return result
            
            # Number literal
            if token is not None and (token[0].isdigit() or token == '.'):
                self.consume()
                try:
                    return float(token)
                except ValueError:
                    raise ValueError(f"Invalid number: {token}")
            
            raise ValueError(f"Unexpected token: {token} at position {self.pos}")

    tokens = tokenize(expr)
    if not tokens:
        raise ValueError("Empty expression")
    
    parser = Parser(tokens)
    result = parser.parse_expression()
    
    # Ensure all tokens were consumed
    if parser.pos != len(parser.tokens):
        raise ValueError(f"Unexpected token after end of expression: {parser.peek()}")
    
    return result
```

```python
def evaluate(expr):
    expr = expr.replace(' ', '')
    
    def parse_expression(index):
        result, index = parse_term(index)
        while index < len(expr) and expr[index] in '+-':
            op = expr[index]
            index += 1
            right, index = parse_term(index)
            if op == '+':
                result += right
            else:
                result -= right
        return result, index
    
    def parse_term(index):
        result, index = parse_factor(index)
        while index < len(expr) and expr[index] in '*/':
            op = expr[index]
            index += 1
            right, index = parse_factor(index)
            if op == '*':
                result *= right
            else:
                result /= right
        return result, index
    
    def parse_factor(index):
        if index < len(expr) and expr[index] == '(':
            index += 1
            result, index = parse_expression(index)
            if index < len(expr) and expr[index] == ')':
                index += 1
            return result, index
        else:
            start = index
            while index < len(expr) and (expr[index].isdigit() or expr[index] == '.'):
                index += 1
            return float(expr[start:index]), index
    
    result, _ = parse_expression(0)
    return result
```

```python
def evaluate(expr):
    def tokenize(s):
        tokens = []
        i = 0
        while i < len(s):
            if s[i] in '+-*/()':
                tokens.append(s[i])
                i += 1
            elif s[i].isspace():
                i += 1
            else:
                num = ''
                while i < len(s) and (s[i].isdigit() or s[i] == '.'):
                    num += s[i]
                    i += 1
                tokens.append(num)
        return tokens

    def parse(tokens):
        precedence = {'+': 2, '-': 2, '*': 3, '/': 3}
        output = []
        stack = []
        for token in tokens:
            if token.isdigit() or '.' in token:
                output.append(float(token))
            elif token == '(':
                stack.append(token)
            elif token == ')':
                while stack and stack[-1] != '(':
                    output.append(stack.pop())
                stack.pop()
            else:
                while stack and stack[-1] != '(' and precedence[token] <= precedence.get(stack[-1], 0):
                    output.append(stack.pop())
                stack.append(token)
        while stack:
            output.append(stack.pop())
        return output

    def evaluate_rpn(rpn):
        stack = []
        for token in rpn:
            if isinstance(token, float):
                stack.append(token)
            else:
                b = stack.pop()
                a = stack.pop()
                if token == '+':
                    stack.append(a + b)
                elif token == '-':
                    stack.append(a - b)
                elif token == '*':
                    stack.append(a * b)
                elif token == '/':
                    stack.append(a / b)
        return stack[0]

    tokens = tokenize(expr)
    rpn = parse(tokens)
    return evaluate_rpn(rpn)
```

```python
def evaluate(expr: str) -> float:
    """
    Evaluate an arithmetic expression string supporting +, -, *, /, parentheses,
    non-negative integers and decimals, ignoring spaces.
    
    Uses standard precedence (* and / before + and -), left-associative, with real division.
    """
    # Tokenize the expression
    tokens = []
    i = 0
    expr = expr.replace(' ', '')
    n = len(expr)
    
    while i < n:
        c = expr[i]
        if c.isdigit() or c == '.':
            j = i
            has_dot = False
            while j < n and (expr[j].isdigit() or expr[j] == '.'):
                if expr[j] == '.':
                    if has_dot:
                        break
                    has_dot = True
                j += 1
            tokens.append(('NUM', float(expr[i:j])))
            i = j
        elif c in '+-*/()':
            tokens.append(('OP', c))
            i += 1
        else:
            raise ValueError(f"Unexpected character: {c}")
    
    # Parse and evaluate using recursive descent or shunting-yard
    # Let's use a simple recursive descent parser
    
    pos = [0]  # mutable index
    
    def peek():
        if pos[0] < len(tokens):
            return tokens[pos[0]]
        return None
    
    def consume(expected_type=None, expected_value=None):
        token = peek()
        if token is None:
            raise ValueError("Unexpected end of expression")
        if expected_type and token[0] != expected_type:
            raise ValueError(f"Expected {expected_type}, got {token}")
        if expected_value and token[1] != expected_value:
            raise ValueError(f"Expected {expected_value}, got {token}")
        pos[0] += 1
        return token
    
    def parse_expression():
        """Parse addition and subtraction (lowest precedence)"""
        result = parse_term()
        
        while peek() and peek()[0] == 'OP' and peek()[1] in ('+', '-'):
            op = consume()[1]
            right = parse_term()
            if op == '+':
                result += right
            else:
                result -= right
        
        return result
    
    def parse_term():
        """Parse multiplication and division (higher precedence)"""
        result = parse_factor()
        
        while peek() and peek()[0] == 'OP' and peek()[1] in ('*', '/'):
            op = consume()[1]
            right = parse_factor()
            if op == '*':
                result *= right
            else:
                if right == 0:
                    raise ZeroDivisionError("Division by zero")
                result /= right
        
        return result
    
    def parse_factor():
        """Parse numbers and parenthesized expressions"""
        token = peek()
        
        if token is None:
            raise ValueError("Unexpected end of expression")
        
        if token[0] == 'NUM':
            consume()
            return token[1]
        
        elif token[0] == 'OP' and token[1] == '(':
            consume()  # consume '('
            result = parse_expression()
            if peek() is None or peek()[1] != ')':
                raise ValueError("Missing closing parenthesis")
            consume('OP', ')')
            return result
        
        else:
            raise ValueError(f"Unexpected token: {token}")
    
    if not tokens:
        return 0.0
    
    result = parse_expression()
    
    # Check that all tokens were consumed
    if pos[0] < len(tokens):
        raise ValueError(f"Unexpected tokens after expression: {tokens[pos[0]:]}")
    
    return result
```

```python
def evaluate(expr: str) -> float:
    """
    Evaluate an arithmetic expression string and return its numeric value.
    
    Supports +, -, *, /, parentheses, non-negative integer and decimal literals.
    Ignores spaces. Uses standard precedence (* and / before + and -), 
    left-associative, with real (float) division.
    """
    # Tokenizer
    def tokenize(s: str):
        tokens = []
        i = 0
        n = len(s)
        while i < n:
            if s[i].isspace():
                i += 1
                continue
            if s[i] in '+-*/()':
                tokens.append(s[i])
                i += 1
            elif s[i].isdigit() or s[i] == '.':
                j = i
                has_dot = False
                while j < n and (s[j].isdigit() or s[j] == '.'):
                    if s[j] == '.':
                        if has_dot:
                            break  # Only one dot allowed in a number
                        has_dot = True
                    j += 1
                tokens.append(s[i:j])
                i = j
            else:
                raise ValueError(f"Unexpected character: {s[i]}")
        return tokens

    class Parser:
        def __init__(self, tokens):
            self.tokens = tokens
            self.pos = 0
        
        def peek(self):
            if self.pos < len(self.tokens):
                return self.tokens[self.pos]
            return None
        
        def consume(self):
            token = self.peek()
            self.pos += 1
            return token
        
        def parse_expression(self):
            """Parse addition and subtraction (lowest precedence)"""
            left = self.parse_term()
            while self.peek() in ('+', '-'):
                op = self.consume()
                right = self.parse_term()
                if op == '+':
                    left = left + right
                else:
                    left = left - right
            return left
        
        def parse_term(self):
            """Parse multiplication and division (higher precedence)"""
            left = self.parse_factor()
            while self.peek() in ('*', '/'):
                op = self.consume()
                right = self.parse_factor()
                if op == '*':
                    left = left * right
                else:
                    if right == 0:
                        raise ZeroDivisionError("Division by zero")
                    left = left / right
            return left
        
        def parse_factor(self):
            """Parse numbers and parenthesized expressions"""
            token = self.peek()
            
            # Handle unary minus/plus at the start of a factor
            if token == '-':
                self.consume()
                return -self.parse_factor()
            elif token == '+':
                self.consume()
                return self.parse_factor()
            
            # Parenthesized expression
            if token == '(':
                self.consume()  # consume '('
                result = self.parse_expression()
                if self.peek() != ')':
                    raise ValueError("Missing closing parenthesis")
                self.consume()  # consume ')'
                return result
            
            # Number literal
            if token is not None and (token[0].isdigit() or token == '.'):
                self.consume()
                try:
                    return float(token)
                except ValueError:
                    raise ValueError(f"Invalid number: {token}")
            
            raise ValueError(f"Unexpected token: {token} at position {self.pos}")

    tokens = tokenize(expr)
    if not tokens:
        raise ValueError("Empty expression")
    
    parser = Parser(tokens)
    result = parser.parse_expression()
    
    # Ensure all tokens were consumed
    if parser.pos != len(parser.tokens):
        raise ValueError(f"Unexpected token after end of expression: {parser.peek()}")
    
    return result
```

```python
def evaluate(expr: str) -> float:
    tokens = tokenize(expr)
    pos = 0

    def parse_expr():
        nonlocal pos
        left = parse_term()
        while pos < len(tokens) and tokens[pos] in ('+', '-'):
            op = tokens[pos]
            pos += 1
            right = parse_term()
            if op == '+':
                left += right
            else:
                left -= right
        return left

    def parse_term():
        nonlocal pos
        left = parse_factor()
        while pos < len(tokens) and tokens[pos] in ('*', '/'):
            op = tokens[pos]
            pos += 1
            right = parse_factor()
            if op == '*':
                left *= right
            else:
                left /= right
        return left

    def parse_factor():
        nonlocal pos
        token = tokens[pos]
        if token == '(':
            pos += 1  # consume '('
            value = parse_expr()
            pos += 1  # consume ')'
            return value
        else:
            pos += 1
            return float(token)

    return parse_expr()


def tokenize(expr: str):
    tokens = []
    i = 0
    while i < len(expr):
        c = expr[i]
        if c.isspace():
            i += 1
        elif c in '+-*/()':
            tokens.append(c)
            i += 1
        elif c.isdigit() or c == '.':
            j = i
            while j < len(expr) and (expr[j].isdigit() or expr[j] == '.'):
                j += 1
            tokens.append(expr[i:j])
            i = j
        else:
            raise ValueError(f"Unknown character: {c!r}")
    return tokens
```

```python
import re

def evaluate(expr):
    def tokenize(s):
        tokens = []
        i = 0
        while i < len(s):
            if s[i] == ' ':
                i += 1
                continue
            if s[i] in '+-*/()':
                tokens.append(s[i])
                i += 1
            else:
                m = re.match(r'\d+\.?\d*', s[i:])
                if not m:
                    raise ValueError(f"Invalid token at position {i}")
                num_str = m.group(0)
                tokens.append(float(num_str) if '.' in num_str else int(num_str))
                i += len(num_str)
        return tokens

    def parse_expression(tokens):
        tokens_iter = iter(tokens)
        return parse_add_sub(tokens_iter)

    def parse_add_sub(tokens_iter):
        left = parse_mul_div(tokens_iter)
        while True:
            try:
                op = next(tokens_iter)
            except StopIteration:
                break
            if op not in '+-':
                raise ValueError(f"Unexpected token {op}")
            right = parse_mul_div(tokens_iter)
            if op == '+':
                left += right
            else:
                left -= right
        return left

    def parse_mul_div(tokens_iter):
        left = parse_primary(tokens_iter)
        while True:
            try:
                op = next(tokens_iter)
            except StopIteration:
                break
            if op not in '*/':
                raise ValueError(f"Unexpected token {op}")
            right = parse_primary(tokens_iter)
            if op == '*':
                left *= right
            else:
                left /= right
        return left

    def parse_primary(tokens_iter):
        try:
            token = next(tokens_iter)
        except StopIteration:
            raise ValueError("Unexpected end of expression")
        if isinstance(token, (int, float)):
            return token
        elif token == '(':
            expr_val = parse_expression(tokens_iter)
            try:
                close_paren = next(tokens_iter)
            except StopIteration:
                raise ValueError("Missing closing parenthesis")
            if close_paren != ')':
                raise ValueError(f"Expected ')', got {close_paren}")
            return expr_val
        else:
            raise ValueError(f"Unexpected token {token}")

    tokens = tokenize(expr)
    return parse_expression(tokens)
```

Thinking Process:

1.  **Analyze the Request:**
    *   Goal: Implement `evaluate(expr)` in Python.
    *   Input: A string representing an arithmetic expression.
    *   Supported operators: `+`, `-`, `*`, `/`.
    *   Supported literals: Non-negative integers, decimals (floats).
    *   Features: Parentheses `()`, ignore spaces.
    *   Precedence: Standard (`*`, `/` > `+`, `-`), left-associative.
    *   Division: Real (float) division.
    *   Output: A single self-contained Python code block.
    *   Constraint: No explanation before or after the code block.
    *   Import style: `from solution import evaluate`.

2.  **Determine the Approach:**
    *   Parsing arithmetic expressions is a classic problem.
    *   Options:
        1.  Use `eval()`: Simple, but often discouraged due to security risks (though acceptable in a coding challenge context usually, it might be considered "cheating" or not demonstrating algorithmic skill). Also, `eval` handles unary operators differently sometimes, and the prompt asks for specific implementation details. However, usually, if not forbidden, `eval` is the most robust for standard Python syntax. But wait, `eval` in Python handles unary minus (e.g., `-5`), but the prompt says "non-negative integer and decimal literals". This implies expressions like `3 + -5` might not be standard input, or `-5` itself might not be a literal but a unary operation. The prompt says "non-negative ... literals", suggesting the numbers themselves are positive, but subtraction exists.
        2.  Shunting-yard algorithm (Dijkstra): Converts infix to postfix (RPN), then evaluates. Good for understanding precedence.
        3.  Recursive Descent Parser: Very clean for expression grammars.
        4.  Two-stack algorithm (Operator-Operand): One stack for numbers, one for operators.

    *   Given the constraints (standard precedence, parentheses, floats), a Recursive Descent Parser or the Two-Stack algorithm is best.
    *   Let's check `eval` again. `eval("1 + 2 * 3")` works. `eval("1.5 + 2.5")` works. `eval("(1 + 2) * 3")` works.
    *   However, often in these types of interview/coding tasks, using `eval` is frowned upon or explicitly forbidden implicitly by asking to "Implement". I should implement the logic manually to be safe and demonstrate competence.
    *   Let's go with the Two-Stack algorithm (Dijkstra's Shunting Yard variant for evaluation) or a simple Recursive Descent. Recursive Descent is often easier to write correctly for precedence.

    *   Grammar:
        *   Expression -> Term { (+|-) Term }
        *   Term -> Factor { (*|/) Factor }
        *   Factor -> Number | ( Expression )

    *   Tokenization: Need to split the string into numbers, operators, and parentheses.
    *   Handling spaces: Skip them during tokenization.
    *   Handling decimals: `1.5`, `.5` (maybe?), `5.` (maybe?). Standard float parsing handles `1.5`.
    *   Handling unary minus: The prompt says "non-negative integer and decimal literals". This usually means the input string won't start with `-` or have `-` immediately after `(` unless it's subtraction. But standard arithmetic usually supports unary minus. Let's look closely: "non-negative integer and decimal literals". This suggests `5` is a literal, `-5` is an operation `0 - 5` or unary minus. If the input is `3 + -4`, is that allowed? Usually, yes. But if literals are strictly non-negative, then `-` is always binary subtraction. However, standard arithmetic expressions often imply unary minus. Let's assume standard behavior where `-` can be unary if it appears at the start or after `(`. But to be safe with "non-negative literals", I will treat `-` as binary subtraction unless I implement unary support. Actually, standard `eval` handles unary. Let's try to support unary minus just in case, as it's standard arithmetic. Wait, "non-negative ... literals" might just mean the number tokens themselves don't have a sign attached (e.g. token is `5`, not `-5`).
    *   Let's stick to the Two-Stack approach or Recursive Descent. Recursive Descent is cleaner for precedence.

3.  **Drafting the Recursive Descent Parser:**

    *   **Tokenizer:**
        *   Iterate through string.
        *   Skip spaces.
        *   If digit or dot: accumulate number.
        *   If operator/paren: yield token.
    *   **Parser:**
        *   `parse_expression`: handles `+`, `-`.
        *   `parse_term`: handles `*`, `/`.
        *   `parse_factor`: handles numbers and `()`.

    *   **Edge Cases:**
        *   Empty string? (Assume valid input).
        *   Division by zero? (Python raises ZeroDivisionError, which is fine).
        *   Floating point precision? (Standard float).
        *   Unary minus? If input is `-5`, `parse_factor` needs to handle it. If input is `3*-5`, `parse_term` calls `parse_factor`.
        *   The prompt says "non-negative ... literals". This implies the number tokens are positive. So `-` is an operator. If I see `-` at the start of a factor, it's unary.
        *   Let's implement unary minus support in `parse_factor` to be robust, as `3*-5` is a common expression.

4.  **Refining the Tokenizer:**
    *   Input: `1 + 2.5 * (3 - 4)`
    *   Tokens: `1`, `+`, `2.5`, `*`, `(`, `3`, `-`, `4`, `)`
    *   Need to handle multi-digit numbers and decimals.

5.  **Refining the Parser Logic:**
    *   `self.pos`: current index in tokens.
    *   `self.tokens`: list of tokens.
    *   `peek()`: look at current token.
    *   `consume()`: advance and return current.

    *   `expression()`:
        *   `val = term()`
        *   `while peek() in ('+', '-'):`
            *   `op = consume()`
            *   `rhs = term()`
            *   `if op == '+': val += rhs`
            *   `else: val -= rhs`
        *   `return val`

    *   `term()`:
        *   `val = factor()`
        *   `while peek() in ('*', '/'):`
            *   `op = consume()`
            *   `rhs = factor()`
            *   `if op == '*': val *= rhs`
            *   `el

```python
def evaluate(expr):
    def parse_expression():
        result = parse_term()
        while lookahead in '+-':
            op = lookahead
            match(lookahead)
            right = parse_term()
            if op == '+':
                result += right
            else:
                result -= right
        return result
    
    def parse_term():
        result = parse_factor()
        while lookahead in '*/':
            op = lookahead
            match(lookahead)
            right = parse_factor()
            if op == '*':
                result *= right
            else:
                result /= right
        return result
    
    def parse_factor():
        if lookahead.isdigit() or lookahead == '.':
            return parse_number()
        elif lookahead == '(':
            match('(')
            result = parse_expression()
            match(')')
            return result
        elif lookahead == '-':
            match('-')
            return -parse_factor()
        else:
            raise ValueError("Unexpected token")
    
    def parse_number():
        num_str = ''
        while lookahead.isdigit() or lookahead == '.':
            num_str += lookahead
            match(lookahead)
        return float(num_str)
    
    def match(expected):
        nonlocal lookahead
        if lookahead == expected:
            if pos < len(expr):
                pos += 1
                lookahead = expr[pos] if pos < len(expr) else None
            else:
                lookahead = None
        else:
            raise ValueError(f"Expected '{expected}', got '{lookahead}'")
    
    # Initialize parser
    pos = 0
    lookahead = expr[pos] if expr else None
    
    # Parse and return result
    result = parse_expression()
    
    # Check if we've consumed the entire expression
    if lookahead is not None:
        raise ValueError("Unexpected characters at end of expression")
    
    return result
```

```python
import re

def evaluate(expr):
    """
    Evaluates an arithmetic expression string and returns its numeric value.

    Supports:
    - Operators: +, -, *, /
    - Parentheses: ()
    - Non-negative integer and decimal literals
    - Ignores spaces
    - Standard precedence (* and / before + and -)
    - Left-associative
    - Real (float) division
    """

    # Remove all spaces from the expression
    expr = expr.replace(" ", "")

    # Helper function to perform arithmetic operations
    def operate(op, left, right):
        if op == '+':
            return left + right
        elif op == '-':
            return left - right
        elif op == '*':
            return left * right
        elif op == '/':
            if right == 0:
                raise ZeroDivisionError("division by zero")
            return left / right
        return 0

    # Helper function to parse numbers (integers and decimals)
    def parse_number(s):
        match = re.match(r'^(\d+(\.\d*)?|\.\d+)', s)
        if match:
            num_str = match.group(1)
            return float(num_str), s[len(num_str

```python
def evaluate(expr):
    expr = expr.replace(" ", "")
    n = len(expr)
    pos = 0
    
    def peek():
        return expr[pos] if pos < n else None
        
    def consume(expected=None):
        nonlocal pos
        if expected and expr[pos] != expected:
            raise ValueError(f"Expected {expected}, got {expr[pos]}")
        val = expr[pos]
        pos += 1
        return val

    def parse_number():
        start = pos
        while pos < n and (expr[pos].isdigit() or expr[pos] == '.'):
            pos += 1
        return float(expr[start:pos])

    def parse_factor():
        nonlocal pos
        ch = peek()
        if ch == '(':
            consume('(')
            val = parse_expr()
            consume(')')
            return val
        elif ch.isdigit() or ch == '.':
            return parse_number()
        else:
            raise ValueError(f"Unexpected character: {ch}")

    def parse_term():
        nonlocal pos
        left = parse_factor()
        while peek() in ('*', '/'):
            op = consume()
            right = parse_factor()
            if op == '*':
                left *= right
            else:
                left /= right
        return left

    def parse_expr():
        nonlocal pos
        left = parse_term()
        while peek() in ('+', '-'):
            op = consume()
            right = parse_term()
            if op == '+':
                left += right
            else:
                left -= right
        return left

    return parse_expr()
```

```python
import re
from typing import Union

def evaluate(expr: str) -> float:
    """
    Evaluate an arithmetic expression string and return its numeric value.
    
    Supports:
    - +, -, *, / (real division)
    - Parentheses ()
    - Non-negative integer and decimal literals
    
    Ignores spaces.
    Precedence: * and / before + and -. Left-associative.
    """
    # Tokenize the expression into numbers and operators
    tokens = tokenize(expr)
    
    if not tokens:
        return 0.0
    
    stack = []
    for token in tokens:
        if isinstance(token, float):
            stack.append(token)
        elif isinstance(token, int):
            # Convert to float to ensure consistent arithmetic with floats
            stack.append(float(token))
        else:
            op = token
            while (len(stack) >= 2 and 
                   stack[-1] is not None and 
                   stack[-2] is not None and 
                   op in ('+', '-', '*', '/')):
                b = stack.pop()
                a = stack.pop()
                
                if op == '+':
                    stack.append(a + b)
                elif op == '-':
                    stack.append(a - b)
                elif op == '*':
                    stack.append(a * b)
                else:  # '/'
                    # Use float division as requested
                    stack.append(a / b)
    
    return stack[0] if stack else 0.0


def tokenize(expr: str) -> list:
    """
    Tokenize the expression into a list of numbers and operators.
    Returns a flat list where each element is either an int, float, or None (operator).
    """
    tokens = []
    
    # Pattern to match integers and decimals (including negative signs at start)
    pattern = r'[-+]?\d*\.?\d+'
    
    i = 0
    while i < len(expr):
        if expr[i].isspace():
            i += 1
            continue
        
        # Check for operator first to handle precedence correctly in parsing logic,
        # though here we just collect tokens. We'll parse numbers and operators separately.
        
        # Find the next number (including negative sign)
        match = re.match(pattern, expr[i:])
        if match:
            num_str = match.group()
            try:
                val = float(num_str)
                tokens.append(val)
            except ValueError:
                raise ValueError(f"Invalid literal in expression: {expr}")
            
            # Consume the rest of the number (if any, though pattern handles it)
            i += len(match.group())
        else:
            # It's an operator or start of a new token
            tokens.append(None)  # Placeholder for operator
            
            # Skip whitespace and find next non-whitespace character
            while i < len(expr) and expr[i].isspace():
                i += 1
            
            if i >= len(expr):
                break
                
            char = expr[i]
            
            # Check for operators
            if char in '+-*/':
                tokens.append(char)
                i += 1
            else:
                raise ValueError(f"Unexpected character '{char}' at position {i}")
    
    return tokens


# Example usage (for testing purposes, not part of the solution interface):
if __name__ == "__main__":
    test_cases = [
        "2 + 3",           # 5.0
        "1 * 4",           # 4.0
        "(2 + 3) * (4 - 1)",  # 15.0
        "10 / 2",          # 5.0
        "-5 + 3",          # -2.0
        "1e2",             # 100.0
    ]
    
    for expr in test_cases:
        result = evaluate(expr)
        print(f"evaluate('{expr}') = {result}")
```

```python
def evaluate(expr):
    # Remove spaces from expression
    expr = expr.replace(' ', '')
    
    if not expr:
        return 0
    
    tokens = []
    i = 0
    n = len(expr)
    
    while i < n:
        char = expr[i]
        
        if char.isdigit() or (char == '.' and i + 1 < n and expr[i+1].isdigit()):
            j = i
            while j < n and (expr[j].isdigit() or expr[j] == '.'):
                j += 1
            tokens.append(float(expr[i:j]))
            i = j
        elif char in '+-*/':
            tokens.append(char)
            i += 1
        elif char == '(':
            tokens.append('(')
            i += 1
        elif char == ')':
            tokens.append(')')
            i += 1
        else:
            raise ValueError(f"Invalid character in expression: {char}")
    
    # Stack for values and operators
    values = []
    ops = []
    
    def apply_op():
        if not ops or ops[-1] == '(':
            return False, None
        
        op = ops.pop()
        
        if len(values) < 2:
            raise ValueError("Invalid expression")
        
        b = values.pop()
        a = values.pop()
        
        if op == '+':
            result = a + b
        elif op == '-':
            result = a - b
        elif op == '*':
            result = a * b
        elif op == '/':
            if b == 0:
                raise ValueError("Division by zero")
            result = float(a) / float(b)
        
        values.append(result)
        return True, result
    
    def peek_op():
        while ops and ops[-1] in '+-':
            apply_op()
    
    for token in tokens:
        if isinstance(token, float):
            values.append(token)
        elif token == '(':
            ops.append('(')
        elif token == ')':
            while ops and ops[-1] != '(':
                peek_op()
            if not ops or ops[-1] != '(':
                raise ValueError("Mismatched parentheses")
            ops.pop()  # Remove '('
        else:
            # Operator
            while (ops and ops[-1] in '+-*/' and 
                   ((token == '+' or token == '-') and ops[-1] in '+-') or
                   (token == '*' or token == '/' and ops[-1] in '*/')):
                peek_op()
            ops.append(token)
    
    while ops:
        if not apply_op():
            raise ValueError("Invalid expression")
    
    return values[0] if values else 0
```

```python
import re
from typing import Union

def evaluate(expr: str) -> float:
    """
    Evaluate an arithmetic expression string and return its numeric value.
    
    Supports:
      - Standard operators (+, -, *, /) with correct precedence
      - Parentheses for grouping
      - Non-negative integer literals (e.g., "5")
      - Decimal literals (e.g., "3.14", "-2.0")
      - Spaces are ignored
    
    Returns:
        float representing the numeric value of the expression.
    """
    
    def parse_number(s: str) -> Union[int, float]:
        """Parse a literal number from string s."""
        if not s or not s.strip():
            return 0.0
        
        # Remove leading/trailing whitespace and check for sign
        s = s.strip()
        
        if s.startswith('-'):
            s = s[1:]
            
        # Check for integer literal (digits only)
        if all(c in '0123456789' for c in s):
            return int(s)
        
        # Check for decimal literal
        if '.' in s:
            parts = s.split('.')
            num_str, dec_part = parts
            
            # Remove trailing zeros after the decimal point to avoid floating-point issues
            while len(num_str) > 0 and num_str[-1] == '0':
                num_str = num_str[:-1]
            
            if '.' in num_str:
                return float(num_str + '.')
            else:
                return int(float(num_str))
        
        raise ValueError(f"Cannot parse literal number from string '{s}': invalid format")
    
    def evaluate_node(node: str) -> Union[int, float]:
        """Evaluate a single arithmetic node."""
        if not node or not node.strip():
            return 0.0
        
        # Remove spaces and check for sign
        node = node.strip()
        
        if node.startswith('-'):
            node = node[1:]
            
        # Check for integer literal
        if all(c in '0123456789' for c in node):
            return parse_number(node)
        
        # Check for decimal literal
        if '.' in node:
            parts = node.split('.')
            num_str, dec_part = parts
            
            while len(num_str) > 0 and num_str[-1] == '0':
                num_str = num_str[:-1]
            
            if '.' in num_str:
                return float(num_str + '.')
            else:
                return int(float(num_str))
        
        raise ValueError(f"Cannot evaluate node '{node}': invalid format")
    
    def parse_expression(node: str) -> Union[int, float]:
        """Parse an expression string."""
        if not node or not node.strip():
            return 0.0
        
        # Remove spaces and check for sign
        node = node.strip()
        
        if node.startswith('-'):
            node = node[1:]
            
        # Check for integer literal
        if all(c in '0123456789' for c in node):
            return parse_number(node)
        
        # Check for decimal literal
        if '.' in node:
            parts = node.split('.')
            num_str, dec_part = parts
            
            while len(num_str) > 0 and num_str[-1] == '0':
                num_str = num_str[:-1]
            
            if '.' in num_str:
                return float(num_str + '.')
            else:
                return int(float(num_str))
        
        raise ValueError(f"Cannot evaluate expression '{node}': invalid format")
    
    def parse_parentheses(node: str) -> Union[int, float]:
        """Evaluate parentheses."""
        if not node or not node.strip():
            return 0.0
        
        # Remove spaces and check for sign
        node = node.strip()
        
        if node.startswith('-'):
            node = node[1:]
            
        # Check for integer literal
        if all(c in '0123456789' for c in node):
            return parse_number(node)
        
        # Check for decimal literal
        if '.' in node:
            parts = node.split('.')
            num_str, dec_part = parts
            
            while len(num_str) > 0 and num_str[-1] == '0':
                num_str = num_str[:-1]
            
            if '.' in num_str:
                return float(num_str + '.')
            else:
                return int(float(num_str))
        
        raise ValueError(f"Cannot evaluate parentheses '{node}': invalid format")
    
    def parse_expression(node: str) -> Union[int, float]:
        """Parse an expression string."""
        if not node or not node.strip():
            return 0.0
        
        # Remove spaces and check for sign
        node = node.strip()
        
        if node.startswith('-'):
            node = node[1:]
            
        # Check for integer literal
        if all(c in '0123456789' for c in node):
            return parse_number(node)
        
        # Check for decimal literal
        if '.' in node:
            parts = node.split('.')
            num_str, dec_part = parts
            
            while len(num_str) > 0 and num_str[-1] == '0':
                num_str = num_str[:-1]
            
            if '.' in num_str:
                return float(num_str + '.')
            else:
                return int(float(num_str))
        
        raise ValueError(f"Cannot evaluate expression '{node}': invalid format")
    
    def parse_parentheses(node: str) -> Union[int, float]:
        """Evaluate parentheses."""
        if not node or not node.strip():
            return 0.0
        
        # Remove spaces and check for sign
        node = node.strip()
        
        if node.startswith('-'):
            node = node[1:]
            
        # Check for integer literal
        if all(c in '0123456789' for c in node):
            return parse_number(node)
        
        # Check for decimal literal
        if '.' in node:
            parts = node.split('.')
            num_str, dec_part = parts
            
            while len(num_str) > 0 and num_str[-1] == '0':
          

We are asked: "Implement evaluate(expr)" that evaluates an arithmetic expression string and returns its numeric value. Support + - * /, parentheses, non-negative integer and decimal literals, ignore spaces. Use standard precedence (* and / before + and -, left-associative), with real (float) division. Importable as from solution import evaluate.

We need to produce a single self-contained Python solution in one code block that is importable as "from solution import evaluate". So we need to define a function evaluate(expr). We can implement using either recursive descent parser or shunting-yard algorithm. I'll choose recursive descent parsing because it's straightforward and easier to implement with operator precedence.

We want to support: +, -, *, /, parentheses, non-negative integer and decimal literals, ignore spaces. Use standard precedence: multiplication and division have higher precedence than addition and subtraction. Left-associative operators. Real (float) division. We'll use float division for / operator.

I can implement a recursive descent parser with grammar:

expr -> term ((+|-) term)*
term -> factor ((*|/) factor)*
factor -> number | '(' expr ')'

We need to ignore spaces, so we can either preprocess the string by removing whitespace or skip them in our parsing functions. I'll choose to remove whitespace from input expression.

I must support decimal numbers: e.g., "3.14", "2." maybe? But problem says non-negative integer and decimal literals. So they are allowed to be decimals with a dot. We can use float() conversion if we parse the number as string, but careful: "3." is valid in Python's float conversion. But also "03" might be considered invalid octal literal in Python 2? But since we're using Python 3, it's fine.

I'll implement a pointer index variable that goes through the expression string. I can define a class Parser with methods parse_expr, parse_term, parse_factor, etc. Alternatively, I can use recursion and closures. I'll do something like:

def evaluate(expr):
    s = expr.replace(" ", "")
    pos = 0
    def parse_expr():
         nonlocal pos
         value = parse_term()
         while pos < len(s) and (s[pos] == '+' or s[pos]=='-'):
             op = s[pos]
             pos += 1
             right = parse_term()
             if op=='+':
                 value += right
             else:
                 value -= right
         return value

    def parse_term():
         nonlocal pos
         value = parse_factor()
         while pos < len(s) and (s[pos] == '*' or s[pos]=='/'):
             op = s[pos]
             pos += 1
             right = parse_factor()
             if op=='*':
                 value *= right
             else:
                 # division: use float division, but careful with division by zero? Problem doesn't mention error handling.
                 value /= right
         return value

    def parse_factor():
         nonlocal pos
         if s[pos] == '(':
              pos += 1
              value = parse_expr()
              pos += 1 # skip ')'
              return value
         else:
             # parse number: digits possibly with a dot.
             start = pos
             while pos < len(s) and (s[pos].isdigit() or s[pos]=='.'):
                 pos += 1
             num_str = s[start:pos]
             return float(num_str)

    result = parse_expr()
    if pos != len(s):
         raise ValueError("Unexpected character at position {}".format(pos))
    return result

I'll produce a code block with triple backticks and "python" language. The solution should be self-contained.

I must output a single self-contained Python solution as one code block, with no explanation before or after. So I'll produce the code block with the function evaluate defined in it, and then if __name__ == '__main__': maybe some tests? But instructions say "importable as from solution import evaluate", so we want to define a module-level function evaluate.

I can also include a main guard that runs some test cases. But instructions said: "Implement evaluate(expr)" that returns numeric value, and it's importable as "from solution import evaluate". So I'll produce code with the function definition and then if __name__ == '__main__': maybe run tests? But instructions say no explanation before or after. It says output a single self-contained Python solution as one code block, with no explanation before or after.

I must not include any explanation text outside of the code block. So I'll produce a code block that is self-contained and can be imported.

I'll produce:

```
python
def evaluate(expr):
    s = expr.replace(" ", "")
    pos = 0

    def parse_expr():
        nonlocal pos
        value = parse_term()
        while pos < len(s) and (s[pos] == '+' or s[pos] == '-'):
            op = s[pos]
            pos += 1
            right = parse_term()
            if op == '+':
                value += right
            else:
                value -= right
        return value

    def parse_term():
        nonlocal pos
        value = parse_factor()
        while pos < len(s) and (s[pos] == '*' or s[pos] == '/'):
            op = s[pos]
            pos += 1
            right = parse_factor()
            if op == '*':
                value *= right
            else:
                value /= right
        return value

    def parse_factor():
        nonlocal pos
        if s[pos] == '(':
            pos += 1
            value = parse_expr()
            if pos >= len(s) or s[pos] != ')':
                raise ValueError("Missing closing parenthesis")
            pos += 1
            return value
        else:
            start = pos
            while pos < len(s) and (s[pos].isdigit() or s[pos]=='.'):
                pos += 1
            if start == pos:
                raise ValueError("Unexpected character at position {}".format(pos))
            return float(s[start:pos])

    result = parse_expr()
    if pos != len(s):
        raise ValueError("Unexpecte