How to validate a International Securities Identification Number (ISIN) number

Based on the examples published in Wikipedia, the method is:

1. Replace each letter by its ordinal (A=1, B=2 and so on) plus 9 ->
2. For each digit at an even position starting from the rightmost position (), replace it by the digits of its double (two digits in two vector entries) -> ;
3. Verification code:

A possible implementation in JavaScript is:

function getVerificationCode(isin)
{
 if(isin.length != 12) return null;
 var v = []; 
 for(var i = isin.length-2; i >= 0; i--)
 {
    var c = isin.charAt(i);
    if(isNaN(c)) //Not a digit
    {
        var letterCode = isin.charCodeAt(i)-55; //Char ordinal + 9
        v.push(letterCode % 10);
        if(letterCode > 9)
          v.push(Math.floor(letterCode/10));
    }
    else
      v.push(Number(c));
 }
 var sum = 0;
 var l = v.length;
 for(var i = 0; i < l; i++)
     if(i % 2 == 0)
 {
    var d = v[i]*2;
    sum += Math.floor(d/10);
    sum += d % 10;
 }
 else
    sum += v[i];
 return 10 - (sum  % 10);
}

EDIT: To include @queso updates:

function getVerificationCode(isin) {
    if (isin.length != 12) return false;
    var v = [];
    for (var i = isin.length - 2; i >= 0; i--) {
        var c = isin.charAt(i);
        if (isNaN(c)) { //not a digit
            var letterCode = isin.charCodeAt(i) - 55; //Char ordinal + 9
            v.push(letterCode % 10);
            if (letterCode > 9) {
                v.push(Math.floor(letterCode / 10));
            }
        } else {
            v.push(Number(c));
        }
    }
    var sum = 0;
    var l = v.length;
    for (var i = 0; i < l; i++) {
        if (i % 2 == 0) {
            var d = v[i] * 2;
            sum += Math.floor(d / 10);
            sum += d % 10;
        } else {
            sum += v[i];
        }
    }
    return (10 - (sum % 10)) % 10
}

http://en.wikipedia.org/wiki/International_Securities_Identification_Number

The procedure for calculating ISIN check digits is similar to the "Modulus 10 Double Add Double" technique used in CUSIPs. To calculate the check digit, first convert any letters to numbers by adding their ordinal position in the alphabet to 9, such that A = 10 and M = 22. Starting with the right most digit, every other digit is multiplied by two. (For CUSIP check digits, these two steps are reversed.) The resulting string of digits (numbers greater than 9 becoming two separate digits) are added up. Subtract this sum from the smallest number ending with zero that is greater than or equal to it: this gives the check digit, which is also known as the ten's complement of the sum modulo 10. That is, the resulting sum, including the check-digit, is a multiple of 10.

They have a good example too.

Building on the examples of others, here is a C# implementation which will validate both ISINs and CUSIPs (and maybe some other Luhn variations).

Usage:

foreach (var isin in ValidIsins)
{
    var calculatedChecksum = SecuritiesValidation.CalculateChecksum(isin.Substring(0, 11));
    var actualChecksum = (isin.Last() - '0');
    Assert.AreEqual(calculatedChecksum, actualChecksum);
}
foreach (var cusip in ValidCusips)
{
    var calculatedChecksum = SecuritiesValidation.CalculateChecksum(cusip.Substring(0, 8), true, true);
    var actualChecksum = (cusip.Last() - '0');
    Assert.AreEqual(calculatedChecksum, actualChecksum);
}

Implementation:

public static class SecuritiesValidation
{
    public static int CalculateChecksum(IEnumerable<char> codeWithoutChecksum, bool reverseLuhn = false, bool allowSymbols = false)
    {
        return reverseLuhn
            ? codeWithoutChecksum
                .Select((c, i) => c.OrdinalPosition(allowSymbols).ConditionalMultiplyByTwo(i.IsOdd()).SumDigits())
                .Sum()
                .TensComplement()
            : codeWithoutChecksum
                .ToArray()
                .ToDigits(allowSymbols)
                .Select((d, i) => d.ConditionalMultiplyByTwo(i.IsEven()).SumDigits())
                .Sum()
                .TensComplement();
    }

    public static bool IsChecksumCorrect(string code, bool reverseLuhn = false, bool allowSymbols = false)
    {
        try
        {
            var checksum = code.Last().ToInt();
            return checksum == CalculateChecksum(code.Take(code.Length - 1), reverseLuhn, allowSymbols);
        }
        catch
        {
            return false;
        }
    }

    /* Be careful here. This method is probably inapropriate for anything other than its designed purpose of Luhn-algorithm based validation.
     * Specifically:
     * - numbers are assigned a value equal to the number ('0' == 0, '1' == 1).
     * - letters are assigned a value indicating the number 9 plus the letters ordinal position in the English alphabet ('A' == 10, 'B' == 11).
     * - if symbols are allowed (eg: for CUSIP validation), they are assigned values beginning from 36 ('*' == 36, '@' == 37).
     */
    private static int OrdinalPosition(this char c, bool allowSymbols = false)
    {
        if (char.IsLower(c))
            return char.ToUpper(c) - 'A' + 10;

        if (char.IsUpper(c))
            return c - 'A' + 10;

        if (char.IsDigit(c))
            return c.ToInt();

        if (allowSymbols)
            switch (c)
            {
                case '*':
                    return 36;
                case '@':
                    return 37;
                case '#':
                    return 38;
            }
        throw new ArgumentOutOfRangeException("Specified character is not a letter, digit or allowed symbol.");
    }

    private static bool IsEven(this int x)
    {
        return (x % 2 == 0);
    }

    private static bool IsOdd(this int x)
    {
        return !IsEven(x);
    }

    private static int ToInt(this char digit)
    {
        if (char.IsDigit(digit))
            return digit - '0';
        throw new ArgumentOutOfRangeException("Specified character is not a digit.");
    }

    private static IEnumerable<int> ToDigits(this char[] s, bool allowSymbols = false)
    {
        var digits = new List<int>();
        for (var i = s.Length - 1; i >= 0; i--)
        {
            var ordinalPosition = s[i].OrdinalPosition(allowSymbols);
            digits.Add(ordinalPosition % 10);
            if (ordinalPosition > 9)
                digits.Add(ordinalPosition / 10);
        }
        return digits;
    }

    private static int SumDigits(this int value)
    {
        //return value > 9 ? ((value / 10) + (value % 10)) : value;
        return ((value / 10) + (value % 10));
    }

    private static int ConditionalMultiplyByTwo(this int value, bool condition)
    {
        return condition ? value * 2 : value;
    }

    private static int TensComplement(this int value)
    {
        return (10 - (value % 10)) % 10;
    }
}

It will likely make sense to use checksum validation in conjunction with a regular expression pattern match. These are the regex I use:

ISIN: ^(XS|AD|AE|AF|AG|AI|AL|AM|AO|AQ|AR|AS|AT|AU|AW|AX|AZ|BA|BB|BD|BE|BF|BG|BH|BI|BJ|BL|BM|BN|BO|BQ|BR|BS|BT|BV|BW|BY|BZ|CA|CC|CD|CF|CG|CH|CI|CK|CL|CM|CN|CO|CR|CU|CV|CW|CX|CY|CZ|DE|DJ|DK|DM|DO|DZ|EC|EE|EG|EH|ER|ES|ET|FI|FJ|FK|FM|FO|FR|GA|GB|GD|GE|GF|GG|GH|GI|GL|GM|GN|GP|GQ|GR|GS|GT|GU|GW|GY|HK|HM|HN|HR|HT|HU|ID|IE|IL|IM|IN|IO|IQ|IR|IS|IT|JE|JM|JO|JP|KE|KG|KH|KI|KM|KN|KP|KR|KW|KY|KZ|LA|LB|LC|LI|LK|LR|LS|LT|LU|LV|LY|MA|MC|MD|ME|MF|MG|MH|MK|ML|MM|MN|MO|MP|MQ|MR|MS|MT|MU|MV|MW|MX|MY|MZ|NA|NC|NE|NF|NG|NI|NL|NO|NP|NR|NU|NZ|OM|PA|PE|PF|PG|PH|PK|PL|PM|PN|PR|PS|PT|PW|PY|QA|RE|RO|RS|RU|RW|SA|SB|SC|SD|SE|SG|SH|SI|SJ|SK|SL|SM|SN|SO|SR|SS|ST|SV|SX|SY|SZ|TC|TD|TF|TG|TH|TJ|TK|TL|TM|TN|TO|TR|TT|TV|TW|TZ|UA|UG|UM|US|UY|UZ|VA|VC|VE|VG|VI|VN|VU|WF|WS|YE|YT|ZA|ZM|ZW)([0-9A-Z]{9})([0-9]{1})$

CUSIP: ^[A-Z0-9]{8}[0-9]$