Validate International Securities Identification Number: Difference between revisions
(→{{header|Visual Basic}}: Added zkl) |
(→{{header|REXX}}: added the REXX language.) |
||
Line 227: | Line 227: | ||
All tests pass. |
All tests pass. |
||
=={{header|REXX}}== |
|||
<lang rexx>/*REXX pgm calculates checksum digit for an International Securities ID number*/ |
|||
@@=123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ /*the alphabet that is used by an ISIN.*/ |
|||
parse arg z; z=space(z) /*obtain optional ISINs from the C.L. */ |
|||
if z=='' then z='US037833100 US037383100 AU0000XVGZA AU0000VXGZA' /*defaults?*/ |
|||
/*No ISINs specified? Then use defaults*/ |
|||
do n=1 for words(z); x=word(z,n) /*process each ISIN that was specified.*/ |
|||
if length(x)<9 then x=right(z,9,0) /*pad with zeros if length is too short*/ |
|||
$= /* [↓] construct a list of ISIN digits*/ |
|||
do k=1 for length(x) |
|||
$=$ || pos(substr(x,k,1),@@) /*convert alphabetic letters──► digits.*/ |
|||
end /*k*/ /* [↑] $ contains the new dec digits.*/ |
|||
g.= /* [↓] construct two groups of digits.*/ |
|||
do g=1 for length($); !=g//2 /*!: the oddness/evenness of the group.*/ |
|||
g.!=g.! || substr($,g,1) /* [↑] !=1, it's odd; !=0, it's even.*/ |
|||
end /*g*/ /* [↑] // is the remainder in REXX. */ |
|||
/* [↓] double the digits of the group */ |
|||
g.!=translate(g.!,246913579,123456789) /* that contains the last digits. */ |
|||
s=0 /*start with a zeroed sum of the digits*/ |
|||
do m=0 to 1 |
|||
do i=1 for length(g.m) /* [↓] sum the ISIN digits for a group*/ |
|||
s=s+substr(g.m,i,1) /*add a group's digit to the sum. */ |
|||
end /*i*/ |
|||
end /*m*/ /* [↑] sum both groups of ISIN digits.*/ |
|||
/* [↓] calculate the checksum for ISIN*/ |
|||
ch=(10-s//10)//10 |
|||
say ' check sum is ' ch " for ISIN: " x |
|||
end /*n*/ |
|||
/*stick a fork in it, we're all done. */</lang> |
|||
'''output''' when using the defaults for input: |
|||
<pre> |
|||
check sum is 5 for: US037833100 |
|||
check sum is 9 for: US037383100 |
|||
check sum is 3 for: AU0000XVGZA |
|||
check sum is 3 for: AU0000VXGZA |
|||
</pre> |
|||
=={{header|Tcl}}== |
=={{header|Tcl}}== |
Revision as of 20:09, 18 July 2015
Calculate an International Securities Identification Number (ISIN)
An International Securities Identification Number (ISIN) is a unique international identifier for a financial security such as a stock or bond.
It consists of an exchange identifier, usually a two character ISO country code, followed by nine characters to identify the security. If the security code is less then nine characters, it is left-padded with zeroes (ASCII character 48). The final character is a checksum between '0' and '9' (ASCII 48 to 57).
The checksum algorithm is based on the Luhn algorithm used for credit card numbers and other purposes. The Luhn algorithm works on numbers, so letters must first be translated to numbers. A becomes 10, B 11, and so on to Z which is translated to 35. This translation is the same in the checksum for CUSIP and for SEDOL. Both CUSIP and ISIN use the Luhn algorithm after letters have been translated, but SEDOL uses a different checksum algorithm. An ISIN may include a SEDOL, or some other identifier for exchanges outside Europe, and is always twelve characters including checksum.
Ada
package ISIN
We start with specifying an Ada package (a collection of subprograms) to compute the checksum digit for a given ISIN (without checksum), and to check the ISIN (when given with the checksum).
<lang Ada>package ISIN is
subtype Decimal is Character range '0' .. '9'; subtype Letter is Character range 'A' .. 'Z'; Invalid_Character: exception; function Checksum(S: String) return Decimal; function Valid(S: String) return Boolean is (Checksum(S(S'First .. S'Last-1)) = S(S'Last));
end ISIN;</lang>
The implementation of the package is as follows.
<lang Ada>package body ISIN is
function To_Digits(S: String) return String is -- converts a string of decimals and letters into a string of decimals Offset: constant Integer := Character'Pos('A')-10; -- Character'Pos('A')-Offset=10, Character'Pos('B')-Offset=11, ... begin if S = "" then
return "";
elsif S(S'First) = ' ' then -- skip blanks
return To_Digits(S(S'First+1 .. S'Last));
elsif S(S'First) in Decimal then
return S(S'First) & To_Digits(S(S'First+1 .. S'Last));
elsif S(S'First) in Letter then
return To_Digits(Integer'Image(Character'Pos(S(S'First))-Offset)) & To_Digits(S(S'First+1 .. S'Last));
else
raise Invalid_Character;
end if; end To_Digits; function Checksum(S: String) return Decimal is T: String := To_Digits(S); -- first convert letters to numbers by adding their ordinal position Double: Boolean := True; Sum: Integer range 0 .. 9 := 0; Add: Integer range 0 .. 18; Result: String(1 .. 2); begin for I in reverse T'Range loop
Add := Integer'Value(T(I .. I)); if Double then -- starting with the rightmost digit, every other digit is doubled Add := Add * 2; if Add > 8 then -- if Add is 1X (*10, 12, ..., 18*), add X+1 Add := (Add mod 10) + 1; end if; end if; Double := not Double; Sum := (Sum + Add) mod 10;
end loop; Result:= Integer'Image((10-Sum) mod 10); -- result is " X", with Decimal X return Result(2); end Checksum;
end ISIN;</lang>
Computing Checksums
Now the main program is easy. It reads a couple of ISINs (without checksum) from the command line and outputs the checksum digits.
<lang Ada>with Ada.Command_Line, Ada.Text_IO, ISIN;
procedure Compute_ISIN is begin
for I in 1 .. Ada.Command_Line.Argument_Count loop Ada.Text_IO.Put_Line("The Checksum for " &
Ada.Command_Line.Argument(I) & " is " & ISIN.Checksum(Ada.Command_Line.Argument(I)));
end loop;
end Compute_ISIN;</lang>
We compute the ISIN-Checksums for Apple, Apple with two digits swapped, the Treasury Corporation of Victoria, and the Treasury Corporation of Victoria with two digits swapped. Note that the first swap does actually change the checksum, while the second one does not. I.e., the ISIN checksums don't always discover flaws, such as swapping two adjacent digits.
./compute_isin US037833100 US037383100 AU0000XVGZA AU0000VXGZA The Checksum for US037833100 is 5 The Checksum for US037383100 is 9 The Checksum for AU0000XVGZA is 3 The Checksum for AU0000VXGZA is 3
Verifying ISINs with given Checksums
Similarily to the above, we check if an ISIN with checksum is valid.
<lang Ada>with Ada.Command_Line, Ada.Text_IO, ISIN;
procedure Check_ISIN is begin
for I in 1 .. Ada.Command_Line.Argument_Count loop if ISIN.Valid(Ada.Command_Line.Argument(I)) then Ada.Text_IO.Put_Line(Ada.Command_Line.Argument(I) & " OK!"); else Ada.Text_IO.Put_Line(Ada.Command_Line.Argument(I) & " ** Fail! **"); end if; end loop;
end Check_ISIN;</lang>
We check Apple's ISIN, and two "misspellings" of Apple's ISIN, we got by permuting two digits or letters. The error of permuting "US" to "SU" is not discovered by the algorithm, the error of permuting 83 to 38 is.
./check_isin US0378331005 SU0378331005 US0373831005 US0378331005 OK! SU0378331005 OK! US0373831005 ** Fail! **
Groovy
<lang groovy>CHARS = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
int checksum(String prefix) {
def digits = prefix.toUpperCase().collect { CHARS.indexOf(it).toString() }.sum() def groups = digits.collect { CHARS.indexOf(it) }.inject([[], []]) { acc, i -> [acc[1], acc[0] + i] } def ds = groups[1].collect { (2 * it).toString() }.sum().collect { CHARS.indexOf(it) } + groups[0] (10 - ds.sum() % 10) % 10
}
assert checksum('AU0000VXGZA') == 3 assert checksum('GB000263494') == 6 assert checksum('US037833100') == 5 assert checksum('US037833107') == 0</lang>
J
<lang j>C=: '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ' splt=: C i. ' ' delstring ": checksum=: 3 : '10| 10- 10| +/ splt , 2 1* |: _2]\ |. splt C i. y'
assert 5 = checksum 'US037833100' assert 0 = checksum 'US037833107' assert 3 = checksum 'AU0000VXGZA' assert 6 = checksum 'GB000263494'</lang>
Racket
<lang racket>#lang racket
(define-logger issn) (current-logger issn-logger)
(define ((letter-char->digits a-point-integer) c)
(call-with-values (λ () (quotient/remainder (+ 10 (- (char->integer c) a-point-integer)) 10)) list))
(define char->digits
(let ((char-code:A (char->integer #\A)) (char-code:a (char->integer #\a)) (char-code:0 (char->integer #\0))) (match-lambda [(? char-whitespace?) null] [(? char-numeric? c) (list (- (char->integer c) char-code:0))] [(? char-upper-case? (app (letter-char->digits char-code:A) dd)) dd] [(? char-lower-case? (app (letter-char->digits char-code:a) dd)) dd])))
(define (string->ISIN-digits s)
(apply append (map char->digits (string->list s))))
(define (ISIN-checksum s)
(define (mod-10 n) (modulo n 10)) (define sum (for/fold ((sum 0)) ((d (reverse (string->ISIN-digits s))) (i (in-naturals))) (mod-10 (+ sum (cond [(odd? i) d] ;; (even? i) henceforth... [(> d 4) (+ 1 (mod-10 (* d 2)))] [else (* d 2)]))))) (mod-10 (- 10 sum)))
(define check-ISIN
(match-lambda [(regexp #rx"(...........)(.)" (list isin (and body (app ISIN-checksum sum)) (app string->number cksum))) (define good? (= sum cksum)) (log-debug "check-ISIN: ~s. ~s wants check sum ~a. got ~a [~a]" isin body sum cksum good?) good?]))
(module+ test
(require tests/eli-tester) (test (char->digits #\A) => '(1 0) (char->digits #\a) => '(1 0) (char->digits #\Z) => '(3 5) (char->digits #\z) => '(3 5) (char->digits #\0) => '(0) (char->digits #\9) => '(9) (char->digits #\space) => '() (string->ISIN-digits "US037833100") => '(3 0 2 8 0 3 7 8 3 3 1 0 0) (ISIN-checksum "US037833100") => 5 (ISIN-checksum "US037383100") => 9 (ISIN-checksum "AU0000XVGZA") => 3 (ISIN-checksum "AU0000VXGZA") => 3 (check-ISIN "US0378331005") => #t (check-ISIN "SU0378331005") => #t (check-ISIN "US0373831005") => #f))</lang>
All tests pass.
REXX
<lang rexx>/*REXX pgm calculates checksum digit for an International Securities ID number*/ @@=123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ /*the alphabet that is used by an ISIN.*/ parse arg z; z=space(z) /*obtain optional ISINs from the C.L. */ if z== then z='US037833100 US037383100 AU0000XVGZA AU0000VXGZA' /*defaults?*/
/*No ISINs specified? Then use defaults*/ do n=1 for words(z); x=word(z,n) /*process each ISIN that was specified.*/ if length(x)<9 then x=right(z,9,0) /*pad with zeros if length is too short*/ $= /* [↓] construct a list of ISIN digits*/ do k=1 for length(x) $=$ || pos(substr(x,k,1),@@) /*convert alphabetic letters──► digits.*/ end /*k*/ /* [↑] $ contains the new dec digits.*/
g.= /* [↓] construct two groups of digits.*/
do g=1 for length($); !=g//2 /*!: the oddness/evenness of the group.*/ g.!=g.! || substr($,g,1) /* [↑] !=1, it's odd; !=0, it's even.*/ end /*g*/ /* [↑] // is the remainder in REXX. */ /* [↓] double the digits of the group */
g.!=translate(g.!,246913579,123456789) /* that contains the last digits. */ s=0 /*start with a zeroed sum of the digits*/
do m=0 to 1 do i=1 for length(g.m) /* [↓] sum the ISIN digits for a group*/ s=s+substr(g.m,i,1) /*add a group's digit to the sum. */ end /*i*/ end /*m*/ /* [↑] sum both groups of ISIN digits.*/ /* [↓] calculate the checksum for ISIN*/ ch=(10-s//10)//10 say ' check sum is ' ch " for ISIN: " x end /*n*/ /*stick a fork in it, we're all done. */</lang>
output when using the defaults for input:
check sum is 5 for: US037833100 check sum is 9 for: US037383100 check sum is 3 for: AU0000XVGZA check sum is 3 for: AU0000VXGZA
Tcl
<lang Tcl>package require Tcl 8.6 ;# mostly needed for [assert]. Substitute a simpler one or a NOP if required.</lang>
A proc like assert is always good to have around. This one tries to report values used in its expression using subst:
<lang Tcl>proc assert {expr} { ;# for "static" assertions that throw nice errors
if {![uplevel 1 [list expr $expr]]} { set msg "{$expr}" catch {append msg " {[uplevel 1 [list subst -noc $expr]]}"} tailcall throw {ASSERT ERROR} $msg }
}</lang>
isin itself is a simple package. We compute the alphabet when the package is loaded in _init, because that's more fun than typing out the table:
<lang Tcl>namespace eval isin {
proc _init {} { ;# sets up the map used on every call variable map set alphabet abcdefghijklmnopqrstuvwxyz set n 9 lmap c [split $alphabet ""] { lappend map $c [incr n] } } _init
proc normalize {isin} { variable map string map $map [string tolower [string trim $isin]] }
proc cksum {isin} { set isin [normalize $isin] assert {[string is digit -strict $isin]} set digits [split $isin ""] if {[llength $digits] % 2} { set digits [list 0 {*}$digits] } foreach {o e} $digits { incr sum [expr {$o + ($e * 2) % 9}] } expr {(10 - ($sum % 10)) % 10} }
proc validate {isin} { set isin [normalize $isin] regexp {^(.*)(.)$} $isin -> body sum expr {$sum eq [cksum $body]} }
}</lang>
Finally, some tcltests pinched from other examples in this page:
<lang Tcl>package require tcltest tcltest::test isin-1 "Test isin validation" -body {
foreach {str sum} { US037833100 5 US037383100 9 SU037833100 5 AU0000XVGZA 3 AU0000VXGZA 3 GB000263494 6 } { assert {[isin::cksum $str] eq $sum} assert {![isin::validate $str$sum]}
set err [expr {1+int(rand()*8)}] ;# create a random checksum error set sum [expr {$sum + $err % 10}] assert {![isin::validate $str$sum]} } return ok
} -result ok </lang>
Visual Basic
<lang vb> Option Explicit
Function MakeIsinCode(Exchange As String, security As String)
Dim numLeadingZeroes As Integer numLeadingZeroes = 9 - Len(security) Dim leader As String leader = Exchange & String(numLeadingZeroes, "0") & security MakeIsinCode = leader & CStr(IsinCheckDigit(leader))
End Function
Function IsinCheckDigit(ByVal security As String) As Integer
Dim digits As String Dim i As Integer For i = 1 To Len(security) Dim ch As String ch = UCase(Mid(security, i, 1)) If ch >= "A" And ch <= "Z" Then ' A to Z translated to "10", "11", .. "35" digits = digits & CStr(Asc(ch) - 55) ElseIf ch >= "0" And ch <= "9" Then digits = digits & ch Else Err.Raise 50001, , "Security must contain only letters and digits" End If Next Dim total As Integer Dim tmp As Integer total = 0 'If rightmost even, "other" digits for doubling are 2,4,6. If rightmost odd, they're 1,3,5. 'rightmost digit is always doubled, so start with it and work backwards Dim other As Boolean other = True For i = Len(digits) To 1 Step -1 tmp = CInt(Mid(digits, i, 1)) If other Then If tmp < 5 Then ' 0 to 4 map to 0,2,4,6,8 total = total + (tmp * 2) Else ' 5 to 9 map to 1,3,5,7,9 total = total + ((tmp * 2) - 9) End If Else total = total + tmp End If 'Toggle doubling flag other = Not other Next 'Last Mod 10 is to wrap 10 to zero IsinCheckDigit = (10 - (total Mod 10)) Mod 10
End Function </lang>
zkl
<lang zkl>const CHARS="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
fcn checksum(prefix){
digits:=prefix.toUpper().reduce(fcn(s,it){ s + CHARS.index(it) },""); groups:=digits.split("").reduce(fcn(acc,i){ T(acc[1],acc[0] + i) },T(T,T)); ds:=groups[1].reduce(fcn(s,it){ s + 2*it },"").split("").extend(groups[0]); (10 - ds.sum(0) % 10) % 10
}</lang> <lang zkl>foreach prefix in (T("AU0000VXGZA","GB000263494","US037833100","US037833107")){
println(prefix," --> ",checksum(prefix));
}</lang>
- Output:
AU0000VXGZA --> 3 GB000263494 --> 6 US037833100 --> 5 US037833107 --> 0