Check Digit Algorithm

 sub checkdigit {
     my ( $tocheck ) = @_;

     $tocheck = uc $tocheck;
     die 'Invalid characters' if $tocheck =~ m/ [^0-9A-Z_] /xms;

     my $sum  = 0;
     my $even = 0;

     for my $char ( reverse split( qr//, $tocheck ) ) {
         my $n = ord( $char ) - 48;
         $sum +=
               $even
             ? $n
             : 2 * $n - 9 * int( $n / 5 );
         $even = ( $even + 1 ) % 2;
     }

     $sum = abs $sum + 10;
     return ( 10 - $sum % 10 ) % 10;
 }

        private static int D3CustomerCheckDigit(string idWithoutCheckdigit) {

            // allowable characters within identifier
            const string validChars = "0123456789ABCDEFGHIJKLMNOPQRSTUVYWXZ_";

            // remove leading or trailing whitespace, convert to uppercase
            idWithoutCheckdigit = idWithoutCheckdigit.Trim().ToUpper();

            // this will be a running total
            int sum = 0;

            // loop through digits from right to left
            for (int i = 0; i < idWithoutCheckdigit.Length; i++) {

                //set ch to "current" character to be processed
                char ch = idWithoutCheckdigit[idWithoutCheckdigit.Length - i - 1];

                // throw exception for invalid characters
                if (validChars.IndexOf(ch) == -1)
                    throw new Exception(ch + " is an invalid character");

                // our "digit" is calculated using ASCII value - 48
                int digit = (int)ch - 48;

                // weight will be the current digit's contribution to
                // the running total
                int weight;
                if (i % 2 == 0)
                {

                  // for alternating digits starting with the rightmost, we
                  // use our formula this is the same as multiplying x 2 and
                  // adding digits together for values 0 to 9.  Using the
                  // following formula allows us to gracefully calculate a
                  // weight for non-numeric "digits" as well (from their
                  // ASCII value - 48).
                  weight = (2 * digit) - (int) (digit / 5) * 9;
                }
                else
                {
                    // even-positioned digits just contribute their ascii
                    // value minus 48
                    weight = digit;
                }

                // keep a running total of weights
                sum += weight;

            }

            // avoid sum less than 10 (if characters below "0" allowed,
            // this could happen)
            sum = Math.Abs(sum) + 10;

            // check digit is amount needed to reach next number
            // divisible by ten
            return (10 - (sum % 10)) % 10;

        }

function CalcModulo10Recursive(const RefNr:String;  VerifyRefNr:Boolean;  var CheckDigit:char):Boolean;
{

  /*
  Check digit calculation "Modulo 10 recursive" as used for reference number of
  the swiss ISR (ISR=ESR: Inpayment slip with reference number [http://tinyurl.com/2ubyob])

  Prfzifferverfahren nach Modulo 10 rekursiv
  Algorithmus: [http://www.sic.ch/de/dl_tkicch_dta.pdf] (p. 51)

  Input:
    RefNr        String of digits building the reference number.
                 Formatting space characters are allowed and ignored.

    VerifyRefNr  a flag that controls the operation verification or
                 calculation

  Output:
    CheckDigit   In any case the check digit is calculated and returned.
                 If the string passed holds non digit characters '@' is
                 returned
    Result       indicates success if set to true

  */

    const
       cModTab:Array [0..9] of byte = (0,9,4,6,8,2,7,1,3,5);
       cSpaceChar:array[0..1]  of char = (' ',#9);  // white space: spaces and tabs
    var
      i:         integer;
      Refw:      String;
      CarryOver: Byte;
      SpaceChar: Char;
begin

// remove white space
    RefW:=RefNr;
    for i:=0 to length(cSpaceChar)-1 do
      RefW:= StringReplace(RefW,cSpaceChar[i],'',[rfReplaceAll]);

// assume success
    Result:=True;

// calculate check digit
    CarryOver:=0;
    for i:=1 to length(RefW)-Ord(VerifyRefNr) do begin
      if RefW[i] in ['0'..'9'] then
        CarryOver:=cModTab[(CarryOver + (ord(RefW[i])-ord('0'))) mod 10]
      else begin
// if a non digit charater is found with in the string return false and abort
        CheckDigit:='@';
        Result:=False;
        exit;
      end;
    end;
    CheckDigit:=Char(ord('0') + (10 - CarryOver) mod 10);

    if VerifyRefNr then
// return success if the calculated check digit matches the given
      Result:=(RefW[Length(RefW)]=CheckDigit)
    else
      Result:=True;
end;

ALTER FUNCTION ComputeCheckDigit (@InString varchar(50))
RETURNS varchar(1)
AS
BEGIN
    DECLARE @CheckDigit varchar(1);
    WITH numbers(seqnum) AS
    (
        SELECT 1 AS seqnum UNION ALL
        SELECT seqnum+1 AS seqnum FROM numbers
        WHERE seqnum <= LEN(@InString)
    )
    SELECT @CheckDigit = CHAR(48+(10-(SUM(CASE WHEN (seqnum % 2) = 1 THEN chr*2-9*(chr/5) ELSE chr END)%10))%10) FROM
    (
      SELECT ASCII(SUBSTRING(REVERSE(UPPER(@InString)),seqnum,1))-48 AS chr,seqnum
      FROM numbers
    ) a;
    RETURN @CheckDigit
END
GO
SELECT CASE WHEN dbo.ComputeCheckDigit('CHECKDIGIT')='7' THEN 'pass1' ELSE 'fail1' END UNION ALL
SELECT CASE WHEN dbo.ComputeCheckDigit('1245496594')='3' THEN 'pass2' ELSE 'fail2' END UNION ALL
SELECT CASE WHEN dbo.ComputeCheckDigit('10899')='3' THEN 'pass3' ELSE 'fail3' END UNION ALL
SELECT CASE WHEN dbo.ComputeCheckDigit('1043')='9' THEN 'pass4' ELSE 'fail4' END

function CheckDigit(idWithoutCheckdigit : string) : Integer;
const
  // allowable characters within identifier
  validChars : string = '0123456789ABCDEFGHIJKLMNOPQRSTUVYWXZ_';
var
  I, Sum, Digit, Weight : Integer;
  ch : Char;
begin
  // remove leading or trailing whitespace, convert to uppercase
  idWithoutCheckdigit := UpperCase(Trim(idWithoutCheckdigit));
  // this will be a running total
  Sum := 0;
  // loop through digits from right to left
  for I := 0 to Length(idWithoutCheckdigit) - 1 do
  begin
    //set ch to "current" character to be processed
    ch := idWithoutCheckdigit[Length(idWithoutCheckdigit) - i];
    // throw exception for invalid characters
    if Pos(ch,validChars) = 0 then
      raise Exception.Create(ch + ' is an invalid character');
    // our "digit" is calculated using ASCII value - 48
    Digit := Ord(ch) - 48;
    // weight will be the current digit's contribution to
    // the running total
    if (i mod 2 = 0) then
      // for alternating digits starting with the rightmost, we
      // use our formula this is the same as multiplying x 2 and
      // adding digits together for values 0 to 9.  Using the
      // following formula allows us to gracefully calculate a
      // weight for non-numeric "digits" as well (from their
      // ASCII value - 48).
      Weight := (2 * Digit) - Floor(Digit / 5) * 9
    else
      // even-positioned digits just contribute their ascii
      // value minus 48
      Weight := Digit;
    // keep a running total of weights
    Sum := Sum + Weight;
  end;
  // avoid sum less than 10 (if characters below "0" allowed,
  // this could happen)
  Sum := Abs(Sum) + 10;
  // check digit is amount needed to reach next number
  // divisible by ten
  result := (10 - (sum mod 10)) mod 10;
end;

create or replace function generate_check_digit (var_mrn in varchar2) return number
is

-- To hold the check digit we generate.
var_check_digit number;
-- To hold the valid characters.
var_valid_chars varchar2(40);
-- To hold the mrn after we make it all upper case.
var_upper_mrn varchar2(100);
-- To hold the sum as we're computing the check digits.
var_sum number;
-- For looping through each character.
var_mrn_length number;
-- For looping through each character.
var_current_char varchar2(1);
-- For figuring out whether we're on an even or odd character as we're looping through.
var_valid_char_index number;
-- For converting the character into a number.
var_char_digit number;
-- For getting the weight that the character adds to the sum.
var_weight number;
-- For when we need a number but we're not going to keep it around.
var_temp_number number;

begin

-- Have to initialize the sum.
var_sum := 0;
-- Valid characters are numbers, upper case letters, and the underscore.
var_valid_chars := '0123456789ABCDEFGHIJKLMNOPQRSTUVYWXZ_';
-- Have to set it to something initially.
var_check_digit := -1;
-- Remove leading or trailing whitespace, convert to uppercase
var_upper_mrn := trim(upper(var_mrn));
-- Get the length of the string so we can go through each character one by one.
var_mrn_length := length(var_upper_mrn);
-- Go through each character in the string.
for char_counter in 1..var_mrn_length loop
  -- Get out the next right most character.  We read from right to left, starting at the end.
  -- The loop starts at one and substr starts from 1, not 0 like java, so the next 
  -- character to read is: the length of the string - the character we're on now + 1.
  var_current_char := substr(var_upper_mrn, var_mrn_length - char_counter + 1, 1);
  
  -- Check whether the character is valid or not.
  var_valid_char_index := instr(var_valid_chars, var_current_char);
  
  -- If the character wasn't in the string of valid characters, show an error that shows the invalid character.
  if var_valid_char_index = 0 then
    raise_application_error(-20001, 'Found invalid character ' || var_current_char || ' in given mrn!');
    return -1;
  end if;
  
  -- Our "digit" is calculated using ASCII value - 48
  var_char_digit := ascii(var_current_char) - 48;
  
  -- We start counting at 1, not 0 so the characters that would be at even indexes
  -- in java or any other language are at odd indexes in pl/sql.
  -- So, mod the character we're on by 2 to see whether we're at an even or odd index.
  var_temp_number := mod(char_counter, 2);
  if var_temp_number = 1 then
    -- For alternating digits starting with the rightmost, we
    -- use our formula. This is the same as multiplying x 2 and
    -- adding digits together for values 0 to 9.  Using the
    -- following formula allows us to gracefully calculate a
    -- weight for non-numeric "digits" as well (from their
    -- ASCII value - 48).
    var_weight := (2 * var_char_digit) - (floor(var_char_digit / 5) * 9);
  else
    -- Even-positioned digits just contribute their ascii
    -- value minus 48 (which we already did above).
    var_weight := var_char_digit;
  end if;
  
  -- Add the weight for this character to our total.
  var_sum := var_sum + var_weight;
  
end loop;
-- Avoid sum less than 10 (if characters below "0" allowed,
-- this could happen)
var_sum := abs(var_sum) + 10;
-- Check digit is amount needed to reach next number
-- divisible by ten.
var_check_digit := mod(10 - mod(var_sum, 10), 10);

return var_check_digit;

end;