C# - Math Evaluator

using System;
using System.Collections.Generic;
using System.Globalization;

public static class MathEvaluator
{
    public static double Calculate(string expression)
    {
        if (expression is null) throw new ArgumentNullException(nameof(expression));

        var values = new Stack<double>();
        var ops = new Stack<char>();

        int i = 0;
        while (i < expression.Length)
        {
            char c = expression[i];

            if (char.IsWhiteSpace(c)) { i++; continue; }

            if (c == '(') { ops.Push(c); i++; continue; }

            if (c == ')')
            {
                while (ops.Count > 0 && ops.Peek() != '(') ApplyOp(values, ops.Pop());
                if (ops.Count == 0 || ops.Pop() != '(') throw new FormatException("Mismatched parentheses.");
                i++;
                continue;
            }

            if (IsOp(c))
            {
                while (ops.Count > 0 && IsOp(ops.Peek()) && Precedence(ops.Peek()) >= Precedence(c)) ApplyOp(values, ops.Pop());
                ops.Push(c);
                i++;
                continue;
            }

            int start = i;
            bool hasDot = false;

            if (c == '+' || c == '-')
            {
                bool unary = start == 0 || PrevNonWs(expression, start) is '(' or '+' or '-' or '*' or '/';
                if (!unary) throw new FormatException("Unexpected operator position.");
                i++;
            }

            while (i < expression.Length)
            {
                char d = expression[i];
                if (char.IsDigit(d)) { i++; continue; }
                if (d == '.')
                {
                    if (hasDot) break;
                    hasDot = true;
                    i++;
                    continue;
                }
                break;
            }

            string token = expression.Substring(start, i - start);
            if (!double.TryParse(token, NumberStyles.Float, CultureInfo.InvariantCulture, out double number))
                throw new FormatException("Invalid number token.");

            values.Push(number);
        }

        while (ops.Count > 0)
        {
            char op = ops.Pop();
            if (op == '(') throw new FormatException("Mismatched parentheses.");
            ApplyOp(values, op);
        }

        if (values.Count != 1) throw new FormatException("Invalid expression.");
        return values.Pop();
    }

    private static bool IsOp(char c) => c == '+' || c == '-' || c == '*' || c == '/';

    private static int Precedence(char op) => op == '+' || op == '-' ? 1 : 2;

    private static void ApplyOp(Stack<double> values, char op)
    {
        if (values.Count < 2) throw new FormatException("Invalid expression.");
        double b = values.Pop();
        double a = values.Pop();

        values.Push(op switch
        {
            '+' => a + b,
            '-' => a - b,
            '*' => a * b,
            '/' => a / b,
            _ => throw new FormatException("Unknown operator.")
        });
    }

    private static char PrevNonWs(string s, int index)
    {
        for (int j = index - 1; j >= 0; j--) if (!char.IsWhiteSpace(s[j])) return s[j];
        return '\0';
    }
}