BPay is a broadly used Australian bill payment system. http://www.bpay.com.au
The system uses check digits with a sort of 'mix and match' 'Check Digit Rule Name' to select the checkdigit algorithm.
This is of the format "WxxMyyyFza" where Wxx indicates the key of an entry in a weights table
Myyy indicates the key of an entry in a modulus table
Fz indicates the key of an entry in a flags table
a, which must only be specified for Modulus 11 check digits, indicates the translations required for check digit values 10 and 11.
BPay recommends the check digit rule: W01M101F3 (MOD10V01) for billers who don't already have a preferred method. This happens to be the same algorithm used for many credit cards and other systems - the Luhn Algorithm or 'mod 10 algorithm'.
--- Below is a *minimally tested* tcl8.5 package to return and test BPay checkdigits.
Save it as bpaycheckdigit-0.2.tm and place it on your module path (see output of [tcl::tm::list])
synopsis:
%package require bpaycheckdigit
0.2
%bpaycheckdigit::get 2007050100001
1
%bpaycheckdigit::test 20070501000012
0
%bpaycheckdigit::test 20070501000011
1
%bpaycheckdigit::get 2007050100001 W17M971F1
49
%bpaycheckdigit::test 200705010000149 W17M971F1
1
%bpaycheckdigit::test 200705010500149 W17M971F1
0 WARNING: This has not been properly tested, reviewed or used in a production environment.
You should review the code, and USE AT YOUR OWN RISK.
In particular - weights array member 19 may need to be extended to contain further powers of 2
to support larger inputs (or better; the code adjusted to extrapolate values)
Also - this work was done by working from an old bpay document.
Things may have changed, comments/updates welcome.
According to this wikipedia article: http://en.wikipedia.org/wiki/Luhn_algorithm
the Luhn Algorithm itself is public domain.
The package supplied here is also released as public domain. #jmn 2007-05
package require Tcl 8.5 ;#require 8.5 features such as lreverse, in
package provide bpaycheckdigit [namespace eval bpaycheckdigit {
variable version 0.2
set version
}]
proc bpaycheckdigit::init {} {
variable weights
variable modulii
variable flags
variable translations
set weights(01,array) {1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2}
set weights(01,maxdigits) ""
set weights(02,array) {2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1}
set weights(02,maxdigits) ""
set weights(03,array) {2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 0 0 0}
set weights(03,maxdigits) ""
set weights(04,array) {1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20}
set weights(04,maxdigits) ""
set weights(05,array) {20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1}
set weights(05,maxdigits) ""
set weights(06,array) {2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21}
set weights(06,maxdigits) ""
set weights(07,array) {21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2}
set weights(07,maxdigits) ""
set weights(08,array) {2 1 7 4 5 3 2 1 7 4 5 3 2 1 7 4 5 3 2 1}
set weights(08,maxdigits) ""
set weights(09,array) {3 2 7 6 5 4 3 2 7 6 5 4 3 2 7 6 5 4 3 2}
set weights(09,maxdigits) ""
set weights(10,array) {3 2 9 8 7 4 3 2 9 8 7 4 3 2 9 8 7 4 3 2}
set weights(10,maxdigits) ""
set weights(11,array) {3 5 2 4 6 1 3 5 2 4 6 1 3 5 2 4 6 1 3 5}
set weights(11,maxdigits) ""
set weights(12,array) {3 7 1 3 7 1 3 7 1 3 7 1 3 7 1 3 7 1 3 7}
set weights(12,maxdigits) ""
set weights(13,array) {6 2 7 5 3 2 8 6 2 7 5 3 2 8 6 2 7 5 3 2}
set weights(13,maxdigits) ""
set weights(14,array) {7 1 3 7 1 3 7 1 3 7 1 3 7 1 3 7 1 3 7 1}
set weights(14,maxdigits) ""
set weights(15,array) {9 7 3 1 9 7 3 1 9 7 3 1 9 7 3 1 9 7 3 1}
set weights(15,maxdigits) ""
set weights(16,array) {9 7 5 3 1 9 7 5 3 1 9 7 5 3 1 9 7 5 3 1}
set weights(16,maxdigits) ""
set weights(17,array) {20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 2 1 4 3}
set weights(17,maxdigits) ""
set weights(18,array) {39 37 35 33 31 29 27 25 23 21 19 17 15 13 11 9 7 5 3 1}
set weights(18,maxdigits) ""
set weights(19,array) {1024 512 256 128 64 32 16 8 4 2}
set weights(19,maxdigits) ""
set weights(20,array) {0 0 5 2 7 4 3}
set weights(20,maxdigits) "7"
set weights(21,array) {0 0 7 6 9 2 3}
set weights(21,maxdigits) "7"
set weights(22,array) {0 0 11 3 7 19 13}
set weights(22,maxdigits) "7"
set weights(23,array) {5 8 4 2 1 6 3 7}
set weights(23,maxdigits) "8"
set weights(24,array) {6 9 7 5 3 8 4 2}
set weights(24,maxdigits) "8"
set weights(25,array) {0 0 15 17 12 13 07 18 14 3}
set weights(25,maxdigits) "10"
set weights(26,array) {0 0 7 1 3 9 1 7 9 1 3 7 9 1}
set weights(26,maxdigits) "14"
set weights(27,array) {1 6 7 2 9 4}
set weights(27,maxdigits) "6"
set weights(28,array) {7 9 10 5 8 4 2}
set weights(28,maxdigits) "7"
set weights(29,array) {3 9 7 3 1 7 5 3 1}
set weights(29,maxdigits) "9"
set weights(30,array) {13 11 7 5 3 2 1 13 11 7 5 3 2 1 13 11 7 5 3 2}
set weights(30,maxdigits) ""
set weights(31,array) {10 7 8 4 6 3 5 2}
set weights(31,maxdigits) "8"
set weights(32,array) {17 13 3 5 7}
set weights(32,maxdigits) "5"
set mlist {
090 9 0 1
091 9 9 1
100 10 0 1
101 10 10 1
102 10 9 1
103 10 17 1
110 11 0 1
111 11 11 1
112 11 0 1
113 11 0 1
130 13 0 2
131 13 13 2
132 13 61 2
970 97 00 2
971 97 97 2
}
foreach {num divideby subtractfrom cdlength} $mlist {
set modulii($num,divideby) $divideby
set modulii($num,subtractfrom) $subtractfrom
set modulii($num,cdlength) $cdlength
}
set flist {
0 N N N
1 N N Y
2 N Y N
3 N Y Y
4 N T N
5 N T Y
6 Y N N
7 Y N Y
8 Y Y N
9 Y Y Y
}
foreach {num start_left add_digits keep_zero} $flist {
set flags($num,start_left) $start_left
set flags($num,add_digits) $add_digits
set flags($num,keep_zero) $keep_zero
}
set tlist {
a "" ""
b "" 0
c "" 1
d 0 ""
e 0 1
f 0 10
g 1 ""
h 1 0
i 1 10
j 11 0
k 11 1
l 11 10
}
foreach {name cd10 cd11} $tlist {
set translations($name,cd10) $cd10
set translations($name,cd11) $cd11
}
}
# cdrule format WxxMyyyFza
# (a optional)
#e.g cdrule -> W17M971F1
#return a dict containing rule values required by algorithm
proc bpaycheckdigit::getrule {cdrule} {
variable weights
variable modulii
variable flags
variable translations
set cdrule [string trim $cdrule]
if {![string length $cdrule]} {
error "empty rule string supplied"
}
if {[string length $cdrule] ni {9 10}} {
error "expected rule string of format WxxMyyyFz or WxxMyyyFza"
}
set w [string tolower [string index $cdrule 0]]
if {$w ne "w"} {
error "bad rule string: expected firstchar 'w'"
}
set weight [string range $cdrule 1 2]
set m [string tolower [string index $cdrule 3]]
if {$m ne "m"} {
error "bad rule string: expected 'm' at char index 3"
}
set modulus [string range $cdrule 4 6]
set f [string tolower [string index $cdrule 7]]
if {$f ne "f"} {
error "bad rule string: expected 'f' at char index 7"
}
set flag [string index $cdrule 8]
set translation ""
if {[string length $cdrule] == 10} {
set translation [string index $cdrule 9]
}
set result [list weight $weight modulus $modulus flag $flag translation $translation]
dict set result weightarray $weights($weight,array)
if {![string length $weights($weight,maxdigits)]} {
dict set result maxdigits [llength $weights($weight,array)]
} else {
dict set result maxdigits $weights($weight,maxdigits)
}
dict set result divideby $modulii($modulus,divideby)
dict set result subtractfrom $modulii($modulus,subtractfrom)
dict set result cdlength $modulii($modulus,cdlength)
dict set result startleft $flags($flag,start_left)
dict set result adddigits $flags($flag,add_digits)
dict set result keepzero $flags($flag,keep_zero)
if {[string length $translation]} {
dict set result cd10 $translations($translation,cd10)
dict set result cd11 $translations($translation,cd11)
} else {
dict set result cd10 ""
dict set result cd11 ""
}
return $result
}
proc bpaycheckdigit::test {completenumber {cdrule W01M101F3}} {
set rule [getrule $cdrule]
set cdlength [dict get $rule cdlength]
set refnumber [string range $completenumber 0 end-$cdlength]
if {[string length $refnumber] > [dict get $rule maxdigits]} {
error "number is longer than maxdigits specified by the supplied rule"
}
set cd [string range $completenumber end-[expr {$cdlength - 1}] end]
if {$cd eq [bpaycheckdigit::get $refnumber $cdrule]} {
return 1
} else {
return 0
}
}
proc bpaycheckdigit::get {refnumber {cdrule W01M101F3}} {
#rule recommended by bpay for billers that haven't currently got a check digit routine.
#W01M101F3 = MOD10V01 (STANDARD LUHNS MODULUS 10)
#(also works for visa/mastercard)
set rule [getrule $cdrule]
if {[string length $refnumber] > [dict get $rule maxdigits]} {
error "number is longer than maxdigits specified by the supplied rule"
}
set refdigits [split $refnumber {}]
if {[string tolower [dict get $rule startleft]] eq "n"} {
set refdigits [lreverse $refdigits]
set weights [lreverse [dict get $rule weightarray]]
} else {
set weights [dict get $rule weightarray]
}
set adddigits [string tolower [dict get $rule adddigits]]
set keepzero [string tolower [dict get $rule keepzero]]
set cd 0
set i 0
foreach ref $refdigits wt $weights {
set weighted [expr {$wt * $ref}]
if {$weighted > 9} {
if {$adddigits eq "y"} {
set weighted [expr [join [split $weighted {}] +]] ;#not fastest way to sum a list.. but should be fine here.
} elseif {$adddigits eq "t"} {
set weighted [string index $weighted end] ;#(efficiency warning: will shimmer)
}
}
incr cd $weighted
incr i
if {$i >= [llength $refdigits]} {
break
}
}
set divideby [dict get $rule divideby]
set subtractfrom [dict get $rule subtractfrom]
set cd10 [dict get $rule cd10]
set cd11 [dict get $rule cd11]
set cdlength [dict get $rule cdlength]
set cd [expr {$cd % $divideby}]
if {($cd != 0) && ($subtractfrom != 0)} {
set cd [expr {$subtractfrom - $cd}]
} elseif {($cd == 0) && !$keepzero} {
set cd $subtractfrom
}
set cd [expr {abs($cd)}]
if {($cd == 10) && [string length $cd10]} {
set cd $cd10
} elseif {($cd == 11) && [string length $cd11]} {
set cd $cd11
}
if {($cdlength == 2) && ([string length $cd] == 1)} {
set cd "0$cd"
}
return $cd
}
bpaycheckdigit::init