Return to Answer

Native parser took 26220 ms.

 

Custom parser took 6471 ms.

 

Performance gain was 305.19%

Native parser took 26220 ms.

Custom parser took 6471 ms.

Performance gain was 305.19%

public static bool FastTryParseDouble(string input, out double result)
{
    int length = input.Length;
    if (length <= 0)
    {
        result = Double.NaN;
        return false;
    }
    double sign = 1d;
    int currentIndex = 0;
    char nextChar = input[0];

    /**************** Sign (+/-) and Special Case String Representations *****************/
    // Handle all cases where the string does not start with a numeric character
    if (nextChar < '0' || nextChar > '9')
    {
        // Non-numeric 1-character strings must match one of the supported special cases.
        if (length == 1)
            return CheckForSpecialCaseDoubleStrings(input, out result);
        // For anything more than one character, this should be a sign character.
        if (nextChar == CharNegative)
            sign = -1d;
        // The very next character may also be the decimal separator.
        else if (nextChar == CharDecimalSeparator)
        {
            // In this case, we treat the integer part as 0 and skip to the fractional part.
            result = 0d;
            goto SkipIntegerPart;
        }
        // Finally, unless it was a '+' sign, input must match one of a set of special cases.
        else if (nextChar != CharPositive)
            return CheckForSpecialCaseDoubleStrings(input, out result);

        // Once the sign is consumed, advance to the next character for further parsing
        nextChar = input[unchecked(++currentIndex)];
        // We must once more check whether the character is numeric before proceeding.
        if (nextChar < '0' || nextChar > '9')
        {
            // If not numeric, at this point, the character can only be a decimal separator
            // (as in "-.123" or "+.123"), or else it must be part of a special case string
            // (as in "-∞"). So check for those.
            if (nextChar != CharDecimalSeparator)
                return CheckForSpecialCaseDoubleStrings(input, out result);
            result = 0d;
            goto SkipIntegerPart;
        }
    }

    /********************************** "Integer Part" ***********************************/
    // Treat all subsequent numeric characters as the "integer part" of the result.
    unchecked
    {
        // Since we've already checked that the next character is numeric,
        // We can save 2 ops by initializing the result directly.
        result = nextChar - '0';
        while(true)
        {
            // Return the "integer part" immediately if we encounter the end of the string
            if (++currentIndex >= length)
            {
                result *= sign;
                return true;
            }
            nextChar = input[currentIndex];
            if (nextChar < '0' || nextChar > '9') break;
            result = result * 10d + (nextChar - '0');
        }
    }

    // This label and corresponding goto statements is a performance optimization to
    // allow us to efficiently skip "integer part" parsing in cases like ".123456"
    // Please don't be mad.
    SkipIntegerPart:  
    
    // The expected case is that the next character is a decimal separator.
    if (nextChar != CharDecimalSeparator)
    {
        // If not this is only allowed to be the exponent character
        if (nextChar != 'e' && nextChar != 'E') return false;
        // Skip fractional parsing and jump to handling exponential notation.
        result = result * sign;
    }
    else
    {
        /******************************* "Fractional Part" *******************************/
        double fractionalPart = 0d;
        int fractionStart = ++currentIndex;
        // Perform a similar loop to construct the fractional part of the decimal
        unchecked
        {
            do
            {
                nextChar = input[currentIndex];
                if (nextChar < '0' || nextChar > '9') break;
                fractionalPart = fractionalPart * 10d + (nextChar - '0');
            } while (++currentIndex < length);

            // Adjust the magnitude of the fractional part and add it to the result
            int fractionLength = currentIndex - fractionStart;
            // Use our tiny array of negative powers of 10 if possible.
            if (fractionLength < NegPow10Length)
                result = sign * (result + fractionalPart * NegPow10[fractionLength]);
            // Fallback to our larger array (still fast), whose higher indices store negative powers
            else if (fractionLength < MaxDoubleExponent)
                result = sign * (result + fractionalPart * Pow10[MaxDoubleExponent + fractionLength]);
            // This would only happen for ridiculous strings (longer than 300 characters),
            // but technically we can still fall-back to using native Math.Pow to do the shift.
            else
                result = sign * (result + fractionalPart * Math.Pow(10, -fractionLength));
        }

        // If we've consumed every character, return now
        if (currentIndex >= length) return true;
        // If there are any more characters, the next character must be 'E' or 'e'
        if (nextChar != 'e' && nextChar != 'E') return false;
    }

    /**************************** "Scientific Notation Part" *****************************/
    // If we're at the end of the string (last character was 'e' or 'E'), that's an error
    if (unchecked(++currentIndex) >= length) return false;
    // Otherwise, advance the current character and begin parsing the exponent
    nextChar = input[currentIndex];
    bool exponentIsNegative = false;
    // The next character can only be a +/- sign, or a numeric character
    if (nextChar < '0' || nextChar > '9')
    {
        if (nextChar == CharNegative)
            exponentIsNegative = true;
        else if (nextChar != CharPositive)
            return false;
        // Again, require there to be at least one more character in the string after the sign
        if (unchecked(++currentIndex) >= length) return false;
        nextChar = input[currentIndex];
        // And verify that this next character is numeric
        if (nextChar < '0' || nextChar > '9') return false;
    }
    unchecked
    {
        // Since we know the next character is a digit, we can initialize the exponent int
        // directly and avoid 2 wasted ops (multiplying by and adding to zero).
        int exponent = nextChar - '0';
        // Shift and add any additional digit characters
        while (++currentIndex < length)
        {
            nextChar = input[currentIndex];
            // If we encounter any non-numeric characters now, it's definitely an error
            if (nextChar < '0' || nextChar > '9') return false;
            exponent = exponent * 10 + (nextChar - '0');
        }
        // Convert the exponent into index we can jump to in our powers-of-ten array
        if (exponentIsNegative)
            exponent += MaxDoubleExponent;
        else if (exponent > MaxDoubleExponent)
            return false;
        // Use our array of powers, unless the exponent is a very large negative number,
        // in which case we fall back to computing the power on-the-fly.
        result *= exponent < Pow10Length ? Pow10[exponent] :
            Math.Pow(10, MaxDoubleExponent - exponent);
    }
    return true;
}

/// <summary>Checks if the string matches one of a few supported special case
/// double strings. If so, assigns the result and returns true.</summary>
public static bool CheckForSpecialCaseDoubleStrings(string input, out double result)
{
    if (input == NumberFormat.PositiveInfinitySymbol)
        result = Double.PositiveInfinity;
    else if (input == NumberFormat.NegativeInfinitySymbol)
        result = Double.NegativeInfinity;
    else if (input == NumberFormat.NaNSymbol)
        result = Double.NaN;
    // Special Case: Excel has been known to format zero as "-".
    // We intentionally support it by returning zero now (most parsers would not)
    else if (input == NumberFormat.NegativeSign)
        result = 0d;
    // Special Case: Our organization treats the term "Unlimited" as referring
    // to Double.MaxValue (most parsers would not)
    else if (input.Equals("unlimited", StringComparison.OrdinalIgnoreCase))
        result = Double.MaxValue;
    // Anything else is not a valid input
    else
    {
        result = Double.NaN;
        return false;
    }
    return true;
}

/// <summary>The largest exponent (or smallest when negative) that can be given to a Double.</summary>
private const int MaxDoubleExponent = 308;

/// <summary>The number of elements that will be generated in the Pow10 array.</summary>
private const int Pow10Length = MaxDoubleExponent * 2 + 1;

/// <summary>A cache of all possible positive powers of 10 that might be required to
/// apply an exponent to a double (Indices 0-308), as well as the first 308 negative
/// exponents. (Indices 309-616)</summary>
private static readonly double[] Pow10 =
    Enumerable.Range(0, MaxDoubleExponent + 1).Select(i => Math.Pow(10, i))
        .Concat(Enumerable.Range(1, MaxDoubleExponent).Select(i => Math.Pow(10, -i)))
        .ToArray();

/// <summary>The number of negative powers to pre-compute and store in a small array.</summary>
private const int NegPow10Length = 16;

/// <summary>A cache of the first 15 negative powers of 10 for quick
/// magnitude adjustment of common parsed fractional parts of doubles.</summary>
/// <remarks>Even though this overlaps with the Pow10 array, it is kept separate so that
/// users that don't use scientific notation or extremely long fractional parts
/// might get a speedup by being able to reference the smaller array, which has a better
/// chance of being served out of L1/L2 cache.</remarks>
private static readonly double[] NegPow10 =
    Enumerable.Range(0, NegPow10Length).Select(i => Math.Pow(10, -i)).ToArray();

// Numbers without a fractional part
TestSuccess("0", 0d);
TestSuccess("1", 1d);
TestSuccess("-1", -1d);
TestSuccess("12345678901234", 12345678901234d);
TestSuccess("-12345678901234", -12345678901234d);
// Numbers with a fractional part
TestSuccess("123.45678", 123.45678);
TestSuccess("-123.45678", -123.45678);
// Numbers without an integer part
TestSuccess(".12345678901234", 0.12345678901234);
TestSuccess("-.12345678901234", -0.12345678901234);
// Various high-precision numbers
TestSuccess("0.12345678901234", 0.12345678901234);
TestSuccess("-0.12345678901234", -0.12345678901234);
TestSuccess("0.00000987654321", 0.00000987654321);
TestSuccess("-0.00000987654321", -0.00000987654321);
TestSuccess("1234567890123.0123456789", 1234567890123.0123456789);
TestSuccess("-1234567890123.0123456789", -1234567890123.0123456789);
// Numbers with very long fractional parts (more than 16 characters)
TestSuccess("0.00826499999979784", 0.00826499999979784);
TestSuccess("-0.00826499999979784", -0.00826499999979784);
TestSuccess("1.0123456789012345678901234567890", 1.0123456789012345678901234567890);
TestSuccess("-1.0123456789012345678901234567890", -1.0123456789012345678901234567890);
// Numbers with a leading positive sign
TestSuccess("+1", 1d);
TestSuccess("+12345678901234", 12345678901234d);
TestSuccess("+.12345678901234", 0.12345678901234);
TestSuccess("+0.00826499999979784", 0.00826499999979784);
// Very large numbers without scientific notation
TestSuccess("123456789000000000000000", 123456789000000000000000d);
TestSuccess("-123456789000000000000000", -123456789000000000000000d);
// Very small numbers without scientific notation
TestSuccess("0.00000000000000000123456789", 0.00000000000000000123456789);
TestSuccess("-0.00000000000000000123456789", -0.00000000000000000123456789);
// Scientific notation without a sign
TestSuccess("1.2345678e5", 1.2345678e5);
TestSuccess("1.2345678e5", 1.2345678e5);
TestSuccess("-1.2345678e5", -1.2345678e5);
// Scientific notation with a sign
TestSuccess("1.2345678e+25", 1.2345678e25);
TestSuccess("-1.2345678e+25", -1.2345678e25);
TestSuccess("1.2345678e-255", 1.2345678e-255);
TestSuccess("-1.2345678e-255", -1.2345678e-255);
// Boundary cases
TestSuccess("1e0", 1);
TestSuccess("1e1", 10);
TestSuccess("1e-1", 0.1);
TestSuccess("1e308", 1e308);
// Min and Max Double
TestSuccess("1.7976931348623157E+308", 1.7976931348623157E+308);
TestSuccess("-1.7976931348623157E+308", -1.7976931348623157E+308);
// Large Negative Exponents (Near-epsilon) doubles.
TestSuccess("1.23E-999", 1.23E-999);
TestSuccess("-1.23E-999", -1.23E-999);
// Special keywords
TestSuccess("∞", Double.PositiveInfinity);
TestSuccess("-∞", Double.NegativeInfinity);
TestSuccess("NaN", Double.NaN);
// Special case: "Unlimited" is used in our organization to refer to Double.MaxValue
TestSuccess("Unlimited", Double.MaxValue);
// Special case: "-" character only means zero in accounting formats.
TestSuccess("-", 0d);

Using a Stopwatch this time, just to quell any debate:

Native parser took 4583 ms.

Custom parser took 1162 ms.

Performance gain was 294.41%

/// <summary>High performance double parser with rudimentary flexibility.</summary>
/// <returns>Returns true only if we can be certain we parsed the string correctly.</returns>
/// <remarks>Does not support thousand separators or whitespace.</remarks>
/// <remarks>Supports all culture-specific symbols specified by the NumberFormatInfo of the
/// <see cref="CultureInfo.CurrentCulture"/> at the time this static class is instantiated.
/// So long as all culture symbols are a single character in length.
/// TODO: In theory, this class could be made instantiable, take the culture as an argument,
///       and support changing the culture at runtime in case the file the user is uploading
///       was generated on a machine with different culture settings.</remarks>
/// <remarks>Supports leading negative signs and positive signs, scientific notation,
/// as well as Infinity, Negative Infinity, and NaN, string representations.</remarks>
/// <remarks>A string containing only a negative sign (usually "-") intentionally returns a
/// value of zero. This is because it's a common representation of 0 in accounting.</remarks>
public static bool FastTryParseDouble(string input, out double result)
{
    int length = input.Length;
    if (length <= 0)
    {
        result = Double.NaN;
        return false;
    }
    double sign = 1d;
    int currentIndex = 0;
    char nextChar = input[0];

    /**************** Sign (+/-) and Special Case String Representations *****************/
    // Handle all cases where the string does not start with a numeric character
    if (nextChar < '0' || nextChar > '9')
    {
        // Non-numeric 1-character strings must match one of the supported special cases.
        if (length == 1)
            return CheckForSpecialCaseDoubleStrings(input, out result);
        // For anything more than one character, this should be a sign character.
        if (nextChar == CharNegative)
            sign = -1d;
        // The very next character may also be the decimal separator.
        else if (nextChar == CharDecimalSeparator)
        {
            // In this case, we treat the integer part as 0 and skip to the fractional part.
            result = 0d;
            goto SkipIntegerPart;
        }
        // Finally, unless it was a '+' sign, input must match one of a set of special cases.
        else if (nextChar != CharPositive)
            return CheckForSpecialCaseDoubleStrings(input, out result);

        // Once the sign is consumed, advance to the next character for further parsing
        nextChar = input[unchecked(++currentIndex)];
        // We must once more check whether the character is numeric before proceeding.
        if (nextChar < '0' || nextChar > '9')
        {
            // If not numeric, at this point, the character can only be a decimal separator
            // (as in "-.123" or "+.123"), or else it must be part of a special case string
            // (as in "-∞"). So check for those.
            if (nextChar != CharDecimalSeparator)
                return CheckForSpecialCaseDoubleStrings(input, out result);
            result = 0d;
            goto SkipIntegerPart;
        }
    }

    /********************************** "Integer Part" ***********************************/
    // Treat all subsequent numeric characters as the "integer part" of the result.
    // Since we've already checked that the next character is numeric,
    // We can save 2 ops by initializing the result directly.
    unchecked
    {
        result = nextChar - '0';
        while (++currentIndex < length)
        {
            nextChar = input[currentIndex];
            if (nextChar < '0' || nextChar > '9') break;
            result = result * 10d + (nextChar - '0');
        }
    }

    // This label and corresponding goto statements is a performance optimization to
    // allow us to efficiently skip "integer part" parsing in cases like ".123456"
    // Please don't be mad.
    SkipIntegerPart:

    // The expected case is that the next character is a decimal separator, however
    // this section might be skipped in normal use cases (e.g. as in "1e18")
    // TODO: If we broke out of the while loop above due to reaching the end of the
    //       string, this operation is superfluous. Is there a way to skip it?
    if (nextChar == CharDecimalSeparator)
    {
        /******************************* "Fractional Part" *******************************/
        // Track the index at the start of the fraction part.
        unchecked
        {
            int fractionPos = ++currentIndex;
            // Continue shifting and adding to the result as before
            do
            {
                nextChar = input[currentIndex];
                // Note that we flip the OR here, because it's now more likely that
                // nextChar > '9' ('e' or 'E'), leading to an early exit condition.
                if (nextChar > '9' || nextChar < '0') break;
                result = result * 10d + (nextChar - '0');
            } while (++currentIndex < length);

            // Update this to store the number of digits in the "fraction part".
            // We will use this to adjust down the magnitude of the double.
            fractionPos = currentIndex - fractionPos;
            // Use our tiny array of negative powers of 10 if possible, but fallback to
            // our larger array (still fast), whose higher indices store negative powers.
            // Finally, while practically unlikely, ridiculous strings (>300 characters)
            // can still be supported with a final fallback to native Math.Pow
            // TODO: Is it possible to combine this magnitude adjustment with any
            //       applicable adjustment due to scientific notation?
            result *= fractionPos < NegPow10Length ?
                NegPow10[fractionPos] : fractionPos < MaxDoubleExponent ?
                Pow10[MaxDoubleExponent + fractionPos] : Math.Pow(10, -fractionPos);
        }
    }

    // Apply the sign now that we've added all digits that belong to the significand
    result *= sign;
    // If we have consumed every character in the string, return now.
    if (currentIndex >= length) return true;

    // The next character encountered must be an exponent character
    if (nextChar != 'e' && nextChar != 'E')
        return false;

    /**************************** "Scientific Notation Part" *****************************/
    unchecked
    {
        // If we're at the end of the string (last character was 'e' or 'E'), that's an error
        if (++currentIndex >= length) return false;
        // Otherwise, advance the current character and begin parsing the exponent
        nextChar = input[currentIndex];
        bool exponentIsNegative = false;
        // The next character can only be a +/- sign, or a numeric character
        if (nextChar < '0' || nextChar > '9')
        {
            if (nextChar == CharNegative)
                exponentIsNegative = true;
            else if (nextChar != CharPositive)
                return false;
            // Again, require there to be at least one more character in the string after the sign
            if (++currentIndex >= length) return false;
            nextChar = input[currentIndex];
            // And verify that this next character is numeric
            if (nextChar < '0' || nextChar > '9') return false;
        }

        // Since we know the next character is a digit, we can initialize the exponent int
        // directly and avoid 2 wasted ops (multiplying by and adding to zero).
        int exponent = nextChar - '0';
        // Shift and add any additional digit characters
        while (++currentIndex < length)
        {
            nextChar = input[currentIndex];
            // If we encounter any non-numeric characters now, it's definitely an error
            if (nextChar < '0' || nextChar > '9') return false;
            exponent = exponent * 10 + nextChar - '0';
        }
        // Apply the exponent. If negative, our index jump is a little different.
        if (exponentIsNegative)
            result *= exponent < Pow10Length - MaxDoubleExponent ?
                // Fallback to Math.Pow if the lookup array doesn't cover it.
                Pow10[exponent + MaxDoubleExponent] : Math.Pow(10, -exponent);
        // If positive, our array covers all possible positive exponents - ensure its valid.
        else if (exponent > MaxDoubleExponent)
            return false;
        else
            result *= Pow10[exponent];
    }
    // Doubles that underwent scientific notation parsing should be checked for overflow
    // (Otherwise, this isn't really a risk we don't expect strings of >308 characters)
    return !Double.IsInfinity(result);
}

/// <summary>Checks if the string matches one of a few supported special case
/// double strings. If so, assigns the result and returns true.</summary>
public static bool CheckForSpecialCaseDoubleStrings(string input, out double result)
{
    if (input == NumberFormat.PositiveInfinitySymbol)
        result = Double.PositiveInfinity;
    else if (input == NumberFormat.NegativeInfinitySymbol)
        result = Double.NegativeInfinity;
    else if (input == NumberFormat.NaNSymbol)
        result = Double.NaN;
    // Special Case: Excel has been known to format zero as "-".
    // We intentionally support it by returning zero now (most parsers would not)
    else if (input == NumberFormat.NegativeSign)
        result = 0d;
    // Special Case: Our organization treats the term "Unlimited" as referring
    // to Double.MaxValue (most parsers would not)
    else if (input.Equals("unlimited", StringComparison.OrdinalIgnoreCase))
        result = Double.MaxValue;
    // Anything else is not a valid input
    else
    {
        result = Double.NaN;
        return false;
    }
    return true;
}

/// <summary>The largest exponent (or smallest when negative) that can be given to a Double.</summary>
private const int MaxDoubleExponent = 308;

/// <summary>The number of elements that will be generated in the Pow10 array.</summary>
private const int Pow10Length = MaxDoubleExponent * 2 + 1;

/// <summary>A cache of all possible positive powers of 10 that might be required to
/// apply an exponent to a double (Indices 0-308), as well as the first 308 negative
/// exponents. (Indices 309-616)</summary>
private static readonly double[] Pow10 =
    Enumerable.Range(0, MaxDoubleExponent + 1).Select(i => Math.Pow(10, i))
        .Concat(Enumerable.Range(1, MaxDoubleExponent).Select(i => Math.Pow(10, -i)))
        .ToArray();

/// <summary>The number of negative powers to pre-compute and store in a small array.</summary>
private const int NegPow10Length = 16;

/// <summary>A cache of the first 15 negative powers of 10 for quick
/// magnitude adjustment of common parsed fractional parts of doubles.</summary>
/// <remarks>Even though this overlaps with the Pow10 array, it is kept separate so that
/// users that don't use scientific notation or extremely long fractional parts
/// might get a speedup by being able to reference the smaller array, which has a better
/// chance of being served out of L1/L2 cache.</remarks>
private static readonly double[] NegPow10 =
    Enumerable.Range(0, NegPow10Length).Select(i => Math.Pow(10, -i)).ToArray();

// Numbers without a fractional part
TestSuccess("0", 0d);
TestSuccess("1", 1d);
TestSuccess("-1", -1d);
TestSuccess("12345678901234", 12345678901234d);
TestSuccess("-12345678901234", -12345678901234d);
// Numbers with a fractional part
TestSuccess("123.45678", 123.45678);
TestSuccess("-123.45678", -123.45678);
// Numbers without an integer part
TestSuccess(".12345678901234", 0.12345678901234);
TestSuccess("-.12345678901234", -0.12345678901234);
// Various high-precision numbers
TestSuccess("0.12345678901234", 0.12345678901234);
TestSuccess("-0.12345678901234", -0.12345678901234);
TestSuccess("0.00000987654321", 0.00000987654321);
TestSuccess("-0.00000987654321", -0.00000987654321);
TestSuccess("1234567890123.0123456789", 1234567890123.0123456789);
TestSuccess("-1234567890123.0123456789", -1234567890123.0123456789);
// Numbers with very long fractional parts (more than 16 characters)
TestSuccess("0.00826499999979784", 0.00826499999979784);
TestSuccess("-0.00826499999979784", -0.00826499999979784);
TestSuccess("1.0123456789012345678901234567890", 1.0123456789012345678901234567890);
TestSuccess("-1.0123456789012345678901234567890", -1.0123456789012345678901234567890);
// Numbers with a leading positive sign
TestSuccess("+1", 1d);
TestSuccess("+12345678901234", 12345678901234d);
TestSuccess("+.12345678901234", 0.12345678901234);
TestSuccess("+0.00826499999979784", 0.00826499999979784);
// Very large numbers without scientific notation
TestSuccess("123456789000000000000000", 123456789000000000000000d);
TestSuccess("-123456789000000000000000", -123456789000000000000000d);
// Very small numbers without scientific notation
TestSuccess("0.00000000000000000123456789", 0.00000000000000000123456789);
TestSuccess("-0.00000000000000000123456789", -0.00000000000000000123456789);
// Scientific notation without a sign
TestSuccess("1.2345678e5", 1.2345678e5);
TestSuccess("1.2345678e5", 1.2345678e5);
TestSuccess("-1.2345678e5", -1.2345678e5);
// Scientific notation with a sign
TestSuccess("1.2345678e+25", 1.2345678e25);
TestSuccess("-1.2345678e+25", -1.2345678e25);
TestSuccess("1.2345678e-255", 1.2345678e-255);
TestSuccess("-1.2345678e-255", -1.2345678e-255);
// Epsilon, and other tiny doubles
// TODO: Known "failure" scenarios. Our parsing logic results in a return value of 0
// for these, but the native parser returns Double.Epsilon (smallest number greater
// than zero). I think we can live with this shortcoming.
//TestSuccess("4.94065645841247e-324", 4.94065645841247e-324);
//TestSuccess("-4.94065645841247e-324", -4.94065645841247e-324);
TestSuccess("3.33E-333", 3.33E-333);
TestSuccess("-3.33E-333", -3.33E-333);
TestSuccess("1E-1022", 1E-1022);
TestSuccess("-1E-1022", -1E-1022);
// Boundary cases
TestSuccess("1e0", 1);
TestSuccess("1e1", 10);
TestSuccess("1e-1", 0.1);
TestSuccess("1e-308", 1e-308);
TestSuccess("1e308", 1e308);
// Min and Max Double
TestSuccess("1.7976931348623157E+308", 1.7976931348623157E+308);
TestSuccess("-1.7976931348623157E+308", -1.7976931348623157E+308);
// Large Negative Exponents (Near-epsilon) doubles.
TestSuccess("1.23E-999", 1.23E-999);
TestSuccess("-1.23E-999", -1.23E-999);
// Special keywords
TestSuccess("∞", Double.PositiveInfinity);
TestSuccess("-∞", Double.NegativeInfinity);
TestSuccess("NaN", Double.NaN);
// Special case: "Unlimited" is used in our organization to refer to Double.MaxValue
TestSuccess("Unlimited", Double.MaxValue);
// Special case: "-" character only means zero in accounting formats.
TestSuccess("-", 0d);

Using a Stopwatch this time, and ran with 1,000,000,000 (a billion) strings just to quell any debate about timing sensitivity:

Native parser took 26220 ms.

Custom parser took 6471 ms.

Performance gain was 305.19%

public static bool FastTryParseDouble(string input, out double result)
{
    int length = input.Length;
    if (length <= 0)
    {
    result = Double.NaN;
    return false;
    }
    double sign = 1d;
    int currentIndex = 0;
    char nextChar = input[0];

    /**************** Sign (+/-) and Special Case String Representations *****************/
    // Handle all cases where the string does not start with a numeric character
    if (nextChar < '0' || nextChar > '9')
    {
    // Non-numeric 1-character strings must match one of the supported special cases.
    if (length == 1)
        return CheckForSpecialCaseDoubleStrings(input, out result);
    // For anything more than one character, this should be a sign character.
    if (nextChar == CharNegative)
        sign = -1d;
    // The very next character may also be the decimal separator.
    else if (nextChar == CharDecimalSeparator)
    {
        // In this case, we treat the integer part as 0 and skip to the fractional part.
        result = 0d;
        goto SkipIntegerPart;
    }
    // Finally, unless it was a '+' sign, input must match one of a set of special cases.
    else if (nextChar != CharPositive)
        return CheckForSpecialCaseDoubleStrings(input, out result);

    // Once the sign is consumed, advance to the next character for further parsing
    nextChar = input[unchecked(++currentIndex)];
    // We must once more check whether the character is numeric before proceeding.
    if (nextChar < '0' || nextChar > '9')
    {
        // If not numeric, at this point, the character can only be a decimal separator
        // (as in "-.123" or "+.123"), or else it must be part of a special case string
        // (as in "-∞"). So check for those.
        if (nextChar != CharDecimalSeparator)
        return CheckForSpecialCaseDoubleStrings(input, out result);
        result = 0d;
        goto SkipIntegerPart;
    }
    }

    /********************************** "Integer Part" ***********************************/
    // Treat all subsequent numeric characters as the "integer part" of the result.
    unchecked
    {
    // Since we've already checked that the next character is numeric,
    // We can save 2 ops by initializing the result directly.
    result = nextChar - '0';
    while(true)
    {
        // Return the "integer part" immediately if we encounter the end of the string
        if (++currentIndex >= length)
        {
        result *= sign;
        return true;
        }
        nextChar = input[currentIndex];
        if (nextChar < '0' || nextChar > '9') break;
        result = result * 10d + (nextChar - '0');
    }
    }

    // This label and corresponding goto statements is a performance optimization to
    // allow us to efficiently skip "integer part" parsing in cases like ".123456"
    // Please don't be mad.
    SkipIntegerPart:  
    
    // The expected case is that the next character is a decimal separator.
    if (nextChar != CharDecimalSeparator)
    {
    // If not this is only allowed to be the exponent character
    if (nextChar != 'e' && nextChar != 'E') return false;
    // Skip fractional parsing and jump to handling exponential notation.
    result = result * sign;
    }
    else
    {
    /******************************* "Fractional Part" *******************************/
    double fractionalPart = 0d;
    int fractionStart = ++currentIndex;
    // Perform a similar loop to construct the fractional part of the decimal
    unchecked
    {
        do
        {
        nextChar = input[currentIndex];
        if (nextChar < '0' || nextChar > '9') break;
        fractionalPart = fractionalPart * 10d + (nextChar - '0');
        } while (++currentIndex < length);

        // Adjust the magnitude of the fractional part and add it to the result
        int fractionLength = currentIndex - fractionStart;
        // Use our tiny array of negative powers of 10 if possible.
        if (fractionLength < NegPow10Length)
        result = sign * (result + fractionalPart * NegPow10[fractionLength]);
        // Fallback to our larger array (still fast), whose higher indices store negative powers
        else if (fractionLength < MaxDoubleExponent)
        result = sign * (result + fractionalPart * Pow10[MaxDoubleExponent + fractionLength]);
        // This would only happen for ridiculous strings (longer than 300 characters),
        // but technically we can still fall-back to using native Math.Pow to do the shift.
        else
        result = sign * (result + fractionalPart * Math.Pow(10, -fractionLength));
    }

    // If we've consumed every character, return now
    if (currentIndex >= length) return true;
    // If there are any more characters, the next character must be 'E' or 'e'
    if (nextChar != 'e' && nextChar != 'E') return false;
    }

    /**************************** "Scientific Notation Part" *****************************/
    // If we're at the end of the string (last character was 'e' or 'E'), that's an error
    if (unchecked(++currentIndex) >= length) return false;
    // Otherwise, advance the current character and begin parsing the exponent
    nextChar = input[currentIndex];
    bool exponentIsNegative = false;
    // The next character can only be a +/- sign, or a numeric character
    if (nextChar < '0' || nextChar > '9')
    {
    if (nextChar == CharNegative)
        exponentIsNegative = true;
    else if (nextChar != CharPositive)
        return false;
    // Again, require there to be at least one more character in the string after the sign
    if (unchecked(++currentIndex) >= length) return false;
    nextChar = input[currentIndex];
    // And verify that this next character is numeric
    if (nextChar < '0' || nextChar > '9') return false;
    }
    unchecked
    {
    // Since we know the next character is a digit, we can initialize the exponent int
    // directly and avoid 2 wasted ops (multiplying by and adding to zero).
    int exponent = nextChar - '0';
    // Shift and add any additional digit characters
    while (++currentIndex < length)
    {
        nextChar = input[currentIndex];
        // If we encounter any non-numeric characters now, it's definitely an error
        if (nextChar < '0' || nextChar > '9') return false;
        exponent = exponent * 10 + (nextChar - '0');
    }
    // Convert the exponent into index we can jump to in our powers-of-ten array
    if (exponentIsNegative)
        exponent += MaxDoubleExponent;
    else if (exponent > MaxDoubleExponent)
        return false;
    // Use our array of powers, unless the exponent is a very large negative number,
    // in which case we fall back to computing the power on-the-fly.
    result *= exponent < Pow10Length ? Pow10[exponent] :
        Math.Pow(10, MaxDoubleExponent - exponent);
    }
    return true;
}

/// <summary>Checks if the string matches one of a few supported special case
/// double strings. If so, assigns the result and returns true.</summary>
public static bool CheckForSpecialCaseDoubleStrings(string input, out double result)
{
    if (input == NumberFormat.PositiveInfinitySymbol)
    result = Double.PositiveInfinity;
    else if (input == NumberFormat.NegativeInfinitySymbol)
    result = Double.NegativeInfinity;
    else if (input == NumberFormat.NaNSymbol)
    result = Double.NaN;
    // Special Case: Excel has been known to format zero as "-".
    // We intentionally support it by returning zero now (most parsers would not)
    else if (input == NumberFormat.NegativeSign)
    result = 0d;
    // Special Case: Our organization treats the term "Unlimited" as referring
    // to Double.MaxValue (most parsers would not)
    else if (input.Equals("unlimited", StringComparison.OrdinalIgnoreCase))
    result = Double.MaxValue;
    // Anything else is not a valid input
    else
    {
    result = Double.NaN;
    return false;
    }
    return true;
}

/// <summary>The largest exponent (or smallest when negative) that can be given to a Double.</summary>
private const int MaxDoubleExponent = 308;

/// <summary>The number of elements that will be generated in the Pow10 array.</summary>
private const int Pow10Length = MaxDoubleExponent * 2 + 1;

/// <summary>A cache of all possible positive powers of 10 that might be required to
/// apply an exponent to a double (Indices 0-308), as well as the first 308 negative
/// exponents. (Indices 309-616)</summary>
private static readonly double[] Pow10 =
    Enumerable.Range(0, MaxDoubleExponent + 1).Select(i => Math.Pow(10, i))
    .Concat(Enumerable.Range(1, MaxDoubleExponent).Select(i => Math.Pow(10, -i)))
    .ToArray();

/// <summary>The number of negative powers to pre-compute and store in a small array.</summary>
private const int NegPow10Length = 16;

/// <summary>A cache of the first 15 negative powers of 10 for quick
/// magnitude adjustment of common parsed fractional parts of doubles.</summary>
/// <remarks>Even though this overlaps with the Pow10 array, it is kept separate so that
/// users that don't use scientific notation or extremely long fractional parts
/// might get a speedup by being able to reference the smaller array, which has a better
/// chance of being served out of L1/L2 cache.</remarks>
private static readonly double[] NegPow10 =
    Enumerable.Range(0, NegPow10Length).Select(i => Math.Pow(10, -i)).ToArray();

public static bool FastTryParseDouble(string input, out double result)
{
    int length = input.Length;
    if (length <= 0)
    {
        result = Double.NaN;
        return false;
    }
    double sign = 1d;
    int currentIndex = 0;
    char nextChar = input[0];

    /**************** Sign (+/-) and Special Case String Representations *****************/
    // Handle all cases where the string does not start with a numeric character
    if (nextChar < '0' || nextChar > '9')
    {
        // Non-numeric 1-character strings must match one of the supported special cases.
        if (length == 1)
            return CheckForSpecialCaseDoubleStrings(input, out result);
        // For anything more than one character, this should be a sign character.
        if (nextChar == CharNegative)
            sign = -1d;
        // The very next character may also be the decimal separator.
        else if (nextChar == CharDecimalSeparator)
        {
            // In this case, we treat the integer part as 0 and skip to the fractional part.
            result = 0d;
            goto SkipIntegerPart;
        }
        // Finally, unless it was a '+' sign, input must match one of a set of special cases.
        else if (nextChar != CharPositive)
            return CheckForSpecialCaseDoubleStrings(input, out result);

        // Once the sign is consumed, advance to the next character for further parsing
        nextChar = input[unchecked(++currentIndex)];
        // We must once more check whether the character is numeric before proceeding.
        if (nextChar < '0' || nextChar > '9')
        {
            // If not numeric, at this point, the character can only be a decimal separator
            // (as in "-.123" or "+.123"), or else it must be part of a special case string
            // (as in "-∞"). So check for those.
            if (nextChar != CharDecimalSeparator)
                return CheckForSpecialCaseDoubleStrings(input, out result);
            result = 0d;
            goto SkipIntegerPart;
        }
    }

    /********************************** "Integer Part" ***********************************/
    // Treat all subsequent numeric characters as the "integer part" of the result.
    unchecked
    {
        // Since we've already checked that the next character is numeric,
        // We can save 2 ops by initializing the result directly.
        result = nextChar - '0';
        while(true)
        {
            // Return the "integer part" immediately if we encounter the end of the string
            if (++currentIndex >= length)
            {
                result *= sign;
                return true;
            }
            nextChar = input[currentIndex];
            if (nextChar < '0' || nextChar > '9') break;
            result = result * 10d + (nextChar - '0');
        }
    }

    // This label and corresponding goto statements is a performance optimization to
    // allow us to efficiently skip "integer part" parsing in cases like ".123456"
    // Please don't be mad.
    SkipIntegerPart:  
    
    // The expected case is that the next character is a decimal separator.
    if (nextChar != CharDecimalSeparator)
    {
        // If not this is only allowed to be the exponent character
        if (nextChar != 'e' && nextChar != 'E') return false;
        // Skip fractional parsing and jump to handling exponential notation.
        result = result * sign;
    }
    else
    {
        /******************************* "Fractional Part" *******************************/
        double fractionalPart = 0d;
        int fractionStart = ++currentIndex;
        // Perform a similar loop to construct the fractional part of the decimal
        unchecked
        {
            do
            {
                nextChar = input[currentIndex];
                if (nextChar < '0' || nextChar > '9') break;
                fractionalPart = fractionalPart * 10d + (nextChar - '0');
            } while (++currentIndex < length);

            // Adjust the magnitude of the fractional part and add it to the result
            int fractionLength = currentIndex - fractionStart;
            // Use our tiny array of negative powers of 10 if possible.
            if (fractionLength < NegPow10Length)
                result = sign * (result + fractionalPart * NegPow10[fractionLength]);
            // Fallback to our larger array (still fast), whose higher indices store negative powers
            else if (fractionLength < MaxDoubleExponent)
                result = sign * (result + fractionalPart * Pow10[MaxDoubleExponent + fractionLength]);
            // This would only happen for ridiculous strings (longer than 300 characters),
            // but technically we can still fall-back to using native Math.Pow to do the shift.
            else
                result = sign * (result + fractionalPart * Math.Pow(10, -fractionLength));
        }

        // If we've consumed every character, return now
        if (currentIndex >= length) return true;
        // If there are any more characters, the next character must be 'E' or 'e'
        if (nextChar != 'e' && nextChar != 'E') return false;
    }

    /**************************** "Scientific Notation Part" *****************************/
    // If we're at the end of the string (last character was 'e' or 'E'), that's an error
    if (unchecked(++currentIndex) >= length) return false;
    // Otherwise, advance the current character and begin parsing the exponent
    nextChar = input[currentIndex];
    bool exponentIsNegative = false;
    // The next character can only be a +/- sign, or a numeric character
    if (nextChar < '0' || nextChar > '9')
    {
        if (nextChar == CharNegative)
            exponentIsNegative = true;
        else if (nextChar != CharPositive)
            return false;
        // Again, require there to be at least one more character in the string after the sign
        if (unchecked(++currentIndex) >= length) return false;
        nextChar = input[currentIndex];
        // And verify that this next character is numeric
        if (nextChar < '0' || nextChar > '9') return false;
    }
    unchecked
    {
        // Since we know the next character is a digit, we can initialize the exponent int
        // directly and avoid 2 wasted ops (multiplying by and adding to zero).
        int exponent = nextChar - '0';
        // Shift and add any additional digit characters
        while (++currentIndex < length)
        {
            nextChar = input[currentIndex];
            // If we encounter any non-numeric characters now, it's definitely an error
            if (nextChar < '0' || nextChar > '9') return false;
            exponent = exponent * 10 + (nextChar - '0');
        }
        // Convert the exponent into index we can jump to in our powers-of-ten array
        if (exponentIsNegative)
            exponent += MaxDoubleExponent;
        else if (exponent > MaxDoubleExponent)
            return false;
        // Use our array of powers, unless the exponent is a very large negative number,
        // in which case we fall back to computing the power on-the-fly.
        result *= exponent < Pow10Length ? Pow10[exponent] :
            Math.Pow(10, MaxDoubleExponent - exponent);
    }
    return true;
}

/// <summary>Checks if the string matches one of a few supported special case
/// double strings. If so, assigns the result and returns true.</summary>
public static bool CheckForSpecialCaseDoubleStrings(string input, out double result)
{
    if (input == NumberFormat.PositiveInfinitySymbol)
        result = Double.PositiveInfinity;
    else if (input == NumberFormat.NegativeInfinitySymbol)
        result = Double.NegativeInfinity;
    else if (input == NumberFormat.NaNSymbol)
        result = Double.NaN;
    // Special Case: Excel has been known to format zero as "-".
    // We intentionally support it by returning zero now (most parsers would not)
    else if (input == NumberFormat.NegativeSign)
        result = 0d;
    // Special Case: Our organization treats the term "Unlimited" as referring
    // to Double.MaxValue (most parsers would not)
    else if (input.Equals("unlimited", StringComparison.OrdinalIgnoreCase))
        result = Double.MaxValue;
    // Anything else is not a valid input
    else
    {
        result = Double.NaN;
        return false;
    }
    return true;
}

/// <summary>The largest exponent (or smallest when negative) that can be given to a Double.</summary>
private const int MaxDoubleExponent = 308;

/// <summary>The number of elements that will be generated in the Pow10 array.</summary>
private const int Pow10Length = MaxDoubleExponent * 2 + 1;

/// <summary>A cache of all possible positive powers of 10 that might be required to
/// apply an exponent to a double (Indices 0-308), as well as the first 308 negative
/// exponents. (Indices 309-616)</summary>
private static readonly double[] Pow10 =
    Enumerable.Range(0, MaxDoubleExponent + 1).Select(i => Math.Pow(10, i))
        .Concat(Enumerable.Range(1, MaxDoubleExponent).Select(i => Math.Pow(10, -i)))
        .ToArray();

/// <summary>The number of negative powers to pre-compute and store in a small array.</summary>
private const int NegPow10Length = 16;

/// <summary>A cache of the first 15 negative powers of 10 for quick
/// magnitude adjustment of common parsed fractional parts of doubles.</summary>
/// <remarks>Even though this overlaps with the Pow10 array, it is kept separate so that
/// users that don't use scientific notation or extremely long fractional parts
/// might get a speedup by being able to reference the smaller array, which has a better
/// chance of being served out of L1/L2 cache.</remarks>
private static readonly double[] NegPow10 =
    Enumerable.Range(0, NegPow10Length).Select(i => Math.Pow(10, -i)).ToArray();

Benchmark Results

Using a Stopwatch this time, just to quell any debate:

Native parser took 4583 ms.

Custom parser took 1162 ms.

Performance gain was 294.41%