Justin Rogers

Performance: Different methods for testing string input for numeric values...

So there was a blog entry about the VB .NET IsNumeric function today.  The question was in regards to a C# equivalent.  I have two things to say really.  First, if you really want the IsNumeric function from VB you can always grab it out of Microsoft.VisualBasic.dll.  Everything from VB .NET is in that library and you can use any of it that you want.  I made explicit use of their array redimensioning code a while back until I found out that I could write faster code in C#.  In some cases I just assumed the VB team wrote performant methods to back all of their functions, but in some cases the performance is lacking.

So how many different ways can you test for a number?  Well, I've picked 5 methods.  4 are available through the CLR.  The 5th is a hand-made algorithm that is meant for high speed ASCII only processing.  So here are the 5 methods and their functions:

• IntParse - This method uses the int.Parse and traps the exception.  This is the slowest method of all 5 because int.Parse throws and we know that exceptions are costly.  In this case they are so costly, that the method is several orders of magnitude slower than the other routines.
• HandCodeSwitch - This is a method that I created using my own performance knowledge.  For instance, I made use of a switch statement to mask out digits since I know this is extremely fast when working over character data.  I know that behind the scenes the switch statement is causing a single subtraction and then either a jump into the digits portion of the case statements, or is jumping directly to the default clause and exiting the method.
• HandCodeIf - Now, since we are doing the sub, it might be faster to do an if statement.  I've ordered the if to check > '9' first, since in most cases we'll see characters above 0x39 rather than characters below 0x30, followed by < '0'.  This performs a bit faster than the switch statement because we know the ordering of things.  However, the switch statement will be much faster if we add more characters that aren't sequentially ordered (perhaps the decimal point, or if we use a culture comparer to build things, any number of other *numeric* characters).
• IsNumber - This uses the CLR char.IsNumber method.  This checks for digits and hex digits.  Have to be careful with this.
• IsDigit - This is more like what the rest of the tests.  This uses the CLR char.IsDigit and only pulls through on digit characters.
• RegexDigit - This uses a regular expression.  If anyone wants to come up with something faster than what I've created then so be it.  I'll insert it into the test.  As it stands a Regex is 6x slower than the CLR methods and over 13x slower than my hand generated methods.

Okay, so the tests aren't 100% fair since all of the CLR versions are using culture comparers and all sorts of other things, but I'm trying to show you how to write the faster integer routine in the West (as in US!).  The HandCodeIf and HandCodeSwitch win hands down.  If you need to create a method for a culture comparer that took into account things like decimal points, group separators, or any number of other issues, I would highly recommend using the switch model, and dynamically generating the method using what I've written as a template.  If there is any interest I'll show you how you can write such a model in another entry.  It would be just as fast as the current HandCode'ed methods, only it would take into account the additional characters when determining if something was a number or not.  Below is the code.  Enjoy!

using System;
using System.Text.RegularExpressions;

public class IsNumeric {
    private static void Main(string[] args) {
        int iterations = 10000000;
        bool makeSureTheJitDoesNotOptimizeMeOut = false;
        string[] testStrings = new string[] { "1234M", "12345" };
       
        Console.WriteLine("IsNumber String 1: {0}", IsNumber(testStrings[0]));
        Console.WriteLine("IsNumber String 2: {0}", IsNumber(testStrings[1]));
        Console.WriteLine("IsDigit String 1: {0}", IsDigit(testStrings[0]));
        Console.WriteLine("IsDigit String 2: {0}", IsDigit(testStrings[1]));
        Console.WriteLine("HandCodeSwitch String 1: {0}", HandCodeSwitch(testStrings[0]));
        Console.WriteLine("HandCodeSwitch String 2: {0}", HandCodeSwitch(testStrings[1]));
        Console.WriteLine("HandCodeIf String 1: {0}", HandCodeIf(testStrings[0]));
        Console.WriteLine("HandCodeIf String 2: {0}", HandCodeIf(testStrings[1]));
        Console.WriteLine("RegexDigit String 1: {0}", RegexDigit(testStrings[0]));
        Console.WriteLine("RegexDigit String 2: {0}", RegexDigit(testStrings[1]));
        Console.WriteLine("IntParse String 1: {0}", IntParse(testStrings[0]));
        Console.WriteLine("IntParse String 2: {0}", IntParse(testStrings[1]));
       
        DateTime start, end;
        start = DateTime.Now;
        for(int i = 0; i < iterations; i++) {
            makeSureTheJitDoesNotOptimizeMeOut = IsNumber(testStrings[i%2]);
        }
        end = DateTime.Now;
        Console.WriteLine("IsNumber {0}", end - start);

        start = DateTime.Now;
        for(int i = 0; i < iterations; i++) {
            makeSureTheJitDoesNotOptimizeMeOut = IsDigit(testStrings[i%2]);
        }
        end = DateTime.Now;
        Console.WriteLine("IsDigit {0}", end - start);

        start = DateTime.Now;
        for(int i = 0; i < iterations; i++) {
            makeSureTheJitDoesNotOptimizeMeOut = HandCodeIf(testStrings[i%2]);
        }
        end = DateTime.Now;
        Console.WriteLine("HandCodeIf {0}", end - start);

        start = DateTime.Now;
        for(int i = 0; i < iterations; i++) {
            makeSureTheJitDoesNotOptimizeMeOut = HandCodeSwitch(testStrings[i%2]);
        }
        end = DateTime.Now;
        Console.WriteLine("HandCodeSwitch {0}", end - start);

        start = DateTime.Now;
        for(int i = 0; i < iterations; i++) {
            makeSureTheJitDoesNotOptimizeMeOut = RegexDigit(testStrings[i%2]);
        }
        end = DateTime.Now;
        Console.WriteLine("RegexDigit {0}", end - start);

        start = DateTime.Now;
        for(int i = 0; i < iterations; i++) {
            makeSureTheJitDoesNotOptimizeMeOut = IntParse(testStrings[i%2]);
        }
        end = DateTime.Now;
        Console.WriteLine("IntParse {0}", end - start);
        Console.WriteLine(makeSureTheJitDoesNotOptimizeMeOut);
    }
   
    public static bool IntParse(string test) {
        try {
            int.Parse(test);
            return true;
        } catch { return false; }
    }
   
    public static bool HandCodeSwitch(string test) {
        for(int i = 0; i < test.Length; i++) {
            switch(test[i]) {
                case '0':
                case '1':
                case '2':
                case '3':
                case '4':
                case '5':
                case '6':
                case '7':
                case '8':
                case '9':
                    continue;
                default:
                    return false;
            }
        }
       
        return true;
    }

    public static bool HandCodeIf(string test) {
        for(int i = 0; i < test.Length; i++) {
            if ( test[i] > '9' || test[i] < '0' ) {
                return false;
            }
        }
       
        return true;
    }
   
    public static bool IsNumber(string test) {
        for(int i = 0; i < test.Length; i++) {
            if ( !char.IsNumber(test[i]) ) {
                return false;
            }
        }
       
        return true;
    }
   
    public static bool IsDigit(string test) {
        for(int i = 0; i < test.Length; i++) {
            if ( !char.IsDigit(test[i]) ) {
                return false;
            }
        }
       
        return true;
    }
   
    private static Regex matchString = new Regex("^[0-9]+$", RegexOptions.Compiled);
    public static bool RegexDigit(string test) {
        return matchString.IsMatch(test);
    }
}