CODEWITHSUNDEEP
checksum
sgp667
sgp667

Reputation: 1875

Calculating ISIN checksum

HI I know there have been may question about this here but I wasn't able to find a detailed enough answer, Wikipedia has two examples of ISIN and how is their checksum calculated.

The part of calculation that I'm struggling with is

Multiply the group containing the rightmost character

The way I understand this statement is:

My understanding has to be wrong because there are at least two problems:

Note

isin.org contains even less information on verifying ISINs, they even use the same example as Wikipedia.

Upvotes: 4

Views: 3839

Answers (1)

Jir
Jir

Reputation: 3135

I agree with you; the definition on Wikipedia is not the clearest I have seen.

There's a piece of text just before the two examples that explains when one or the other algorithm should be used:

Since the NSIN element can be any alpha numeric sequence (9 characters), an odd number of letters will result in an even number of digits and an even number of letters will result in an odd number of digits. For an odd number of digits, the approach in the first example is used. For an even number of digits, the approach in the second example is used

The NSIN is identical to the ISIN, excluding the first two letters and the last digit; so if the ISIN is US0378331005 the NSIN is 037833100. So, if you want to verify the checksum digit of US0378331005, you'll have to use the "first algorithm" because there are 9 digits in the NSIN. Conversely, if you want to check AU0000XVGZA3 you're going to use the "second algorithm" because the NSIN contains 4 digits.

As to the "first" and "second" algorithms, they're identical, with the only exception that in the former you'll multiply by 2 the group of odd digits, whereas in the latter you'll multiply by 2 the group of even digits.

Now, the good news is, you can get away without this overcomplicated algorithm.

You can, instead:

  1. Take the ISIN except the last digit (which you'll want to verify)
  2. Convert all letters to numbers, so to obtain a list of digits
  3. Reverse the list of digits
  4. All the digits in an odd position are doubled and their digits summed again if the result is >= 10
  5. All the digits in an even position are taken as they are
  6. Sum all the digits, take the modulo, subtract the result from 0 and take the absolute value

The only tricky step is #4. Let's clarify it with a mini-example. Suppose the digits in an odd position are 4, 0, 7.

You'll double them and get: 8, 0, 14.

8 is not >= 10, so we take it as it is. Ditto for 0. 14 is >= 10, so we sum its digits again: 1+4=5.

The result of step #4 in this mini-example is, therefore: 8, 0, 5.

A minimal, working implementation in Python could look like this:

import string
isin = 'US4581401001'

def digit_sum(n):
    return (n // 10) + (n % 10)

alphabet = {letter: value for (value, letter) in
            enumerate(''.join(str(n) for n in range(10)) + string.ascii_uppercase)}

isin_to_digits = ''.join(str(d) for d in (alphabet[v] for v in isin[:-1]))
isin_sum = 0
for (i, c) in enumerate(reversed(isin_to_digits), 1):
    if i % 2 == 1:
        isin_sum += digit_sum(2*int(c))
    else:
        isin_sum += int(c)

checksum_digit = abs(- isin_sum % 10)

assert int(isin[-1]) == checksum_digit

Or, more crammed, just for functional fun:

checksum_digit = abs( - sum(digit_sum(2*int(c)) if i % 2 == 1 else int(c)
    for (i, c) in enumerate(
    reversed(''.join(str(d) for d in (alphabet[v] for v in isin[:-1]))), 1)) % 10)

Upvotes: 1

Related Questions