Prüfziffer für IBAN berechnen

[kwhk]

Um die Prüfziffer einer deutschen Bankverbindung zu ermitteln, muß man folgendermassen vorgehen
(Hier eine sehr gute Beschreibung)
http://www.iban.de/iban-pruefsumme.html

(1) BLZ (8-stellig) 12345678
(2) Konto (10-stellig, ggf mit Vornullen auffüllen) : 1234567890
(3) Land Deutschland DE : 13 14 (für DE)
(4) Prüfziffer (zunächst 00) : 00

Daraus muss man eine 24-stellige Zahl bilden (1) (2) (3) (4)
12345678 1234567890 13 14 00 => 123456781234567890131400
Diese Zahl muss man durch 97 dividieren (modulo 97)
Es entsteht ein Rest von 00..96
Die Prüfziffer ist : 98 - Rest, sie ist 2-stellig (ggf. Vornull), z.B. 09

Die IBAN ergibt sich danach

Land Prüfziffer BLZ KontoNr
DE 09 12345678 1234567890 => DE09123456781234567890

Ich habe das mit Delphi 7 gemacht, dabei bekam ich ein Problem mit der langen 24-stelligen Zahl.
Die war zunächst ein String und sollte mit VAL(s,v,i) in eine INT64-Zahl gewandelt werden.
Die VAL-Funktion lieferte dabei den Fehlercode i mit 20.
In V werden nur die ersten 18 Stellen dargestellt (ohne 131400).
Ich habe eine andere Lösung gefunden.

Jedoch meine Frage, kann man mit Delphi 7 mit so großen Zahlen arbeiten ?

[mkinzler]

Z.B. http://sourceforge.net/projects/bigint-dl/

[DeddyH]

Es gibt keine 24-stellige Zahl, die in eine Int64 passt. Versuch es doch mal hiermit: http://www.delphipraxis.net/159320-i...erpruefen.html

[kwhk]

So habe ich das gelöst, die 24-stellige Zahl in 18 + 6 Stellen aufgeteilt und solange 97 abgezogen, bis ein Rest von < 97 übrigbleibt. Damit es schneller geht, auch das 10er-Vielfache von 97 abgezogen. Das ist mathematisch korrekt und man vermeidet das unmittelbare Rechnen (Division) mit einer so großen Zahl. Was fehlt, ist INT128 oder eine andere Zahlendarstellung.
Auf dem IBM-Großrechner (wo ich herkomme) gibt es das dezimal-gepackte Format (DP).
Eine 9-stellige Zahl steht in 5 Bytes sieht dann so aus: X'123456789C' das C ist das Vorzeichen (C für + und D für Minus) Es sind max. 16 Bytes möglich, das sind 31 Ziffern. Die 24-stellige BBAN würde also kein Problem machen, und das ist schon seit 1960 so. Auf dem PC gibt es nun riesengroße Festplatten, riesengroßen Hauptspeicher... Aber mit großen Zahlen kann er immer noch nicht rechnen.

Code:

    sBBAN := sBLZ+sKTO;    // 6-st + 8-st
    Val(sBBAN,iBBAN,rc);   // die ersten 14 Stellen modulo 97 rechnen mittels Subtraktion

    While iBBAN > 970 do
      Begin
            if iBBAN > 970000000000000000 then iBBAN := iBBAN - 970000000000000000
        else if iBBAN >  97000000000000000 then iBBAN := iBBAN -  97000000000000000
        else if iBBAN >   9700000000000000 then iBBAN := iBBAN -   9700000000000000
        else if iBBAN >    970000000000000 then iBBAN := iBBAN -    970000000000000
        else if iBBAN >     97000000000000 then iBBAN := iBBAN -     97000000000000
        else if iBBAN >      9700000000000 then iBBAN := iBBAN -      9700000000000
        else if iBBAN >       970000000000 then iBBAN := iBBAN -       970000000000
        else if iBBAN >        97000000000 then iBBAN := iBBAN -        97000000000
        else if iBBAN >         9700000000 then iBBAN := iBBAN -         9700000000
        else if iBBAN >          970000000 then iBBAN := iBBAN -          970000000
        else if iBBAN >           97000000 then iBBAN := iBBAN -           97000000
        else if iBBAN >            9700000 then iBBAN := iBBAN -            9700000
        else if iBBAN >             970000 then iBBAN := iBBAN -             970000
        else if iBBAN >              97000 then iBBAN := iBBAN -              97000
        else if iBBAN >               9700 then iBBAN := iBBAN -               9700
        else if iBBAN >                970 then iBBAN := iBBAN -                970;
      End; // While iBBAN > 970

    iBBAN := (iBBAN * 1000000) + 131400; // 6 Dezimalstellen nach links + Rest 

    While iBBAN > 96 do // nun weiter mit modulo 97
      Begin
            if  iBBAN > 970000000 then iBBAN := iBBAN - 970000000
        else if iBBAN >  97000000 then iBBAN := iBBAN -  97000000
        else if iBBAN >   9700000 then iBBAN := iBBAN -   9700000
        else if iBBAN >    970000 then iBBAN := iBBAN -    970000
        else if iBBAN >     97000 then iBBAN := iBBAN -     97000
        else if iBBAN >      9700 then iBBAN := iBBAN -      9700
        else if iBBAN >       970 then iBBAN := iBBAN -       970
        else if iBBAN >        96 then iBBAN := iBBAN -        97;
      End; // While iBBAN > 96

    iPZ := 98 - iBBAN; // Prüfziffer = 98 - (Rest von mod97)

[Amateurprofi]

Was in #1 nicht erwähnt wurde, ist, dass die Prüfziffern nicht 00 oder 01 sein darf.

Hier eine Funktion, die aus BLZ (8-stellig) und Kontonummer (10-stellig) eine "Deutsche" IBAN erstellt.

Delphi-Quellcode:

FUNCTION CreateGermanIBAN(Const BankCode,Account:String):String;
const csmax=(High(NativeUInt)-9) div 10;
var cs:NativeUInt; i,cc:integer; s:string;
begin
   if (Length(BankCode)<>8) or (Length(Account)<>10) then Exit('');
   s:=BankCode+Account+'131400';  // 131400 = 'DE00'
   cs:=0;
   for i:=1 to Length(s) do begin
      if cs>csmax then cs:=cs mod 97;
      cs:=cs*10+Ord(s[i])-Ord('0');
   end;
   if cs>96 then cs:=cs mod 97;
   cc:=98-cs;
   if cc<2 then inc(cc,97); // 00-->97, 01--> 98
   result:='DE00';
   result[3]:=Chr(cc div 10+Ord('0'));
   result[4]:=Chr(cc mod 10+Ord('0'));
   result:=result+BankCode+Account;
end;

[sx2008]

Dieses "csmax" kann man sich schenken.
Bei der Modulo-Arithmetik rechnet man einfach nach jeder Operation mit mod 97 :

Delphi-Quellcode:

FUNCTION CreateGermanIBAN(Const BankCode,Account:String):String;
var cs, i,cc:integer; s:string;
begin
   if (Length(BankCode)<>8) or (Length(Account)<>10) then Exit('');
   s:=BankCode+Account+'131400'; // 131400 = 'DE00'
   cs:=0;
   for i:=1 to Length(s) do begin
      cs:=(cs*10+Ord(s[i])-Ord('0')) mod 97;
   end;
   cc:=98-cs;
   if cc<2 then inc(cc,97); // 00-->97, 01--> 98
   result:='DE00';
   result[3]:=Chr(cc div 10+Ord('0'));
   result[4]:=Chr(cc mod 10+Ord('0'));
   result:=result+BankCode+Account;
end;

[kwhk]

Zitat von Amateurprofi:

Was in #1 nicht erwähnt wurde, ist, dass die Prüfziffern nicht 00 oder 01 sein darf.

Ich hatte gesagt: der Rest aus MOD97 = 00..96 / PZ = 98 - Rest
Damit kann die PZ nur 02..96 sein, also keine 00 und 01
@sc2008, Deine Methode ist natürlich sehr kompakt.
if cc<2 then ... ist m.E. nicht erforderlich, weil bei mod 97 nur 00 bis 96 herauskommen kann.
Und deshalb 98-cs niemals <2 werden kann (deshalb haben die Erfinder dieser Formel gesagt "98-2").

Ich hätte mir gewünscht, dass jemand einen Weg kennt, wie man auch mit langen Zahlen richtig rechnen kann.
Bei mod97 mag das ja so angehen. Im alten Turbo-Pascal war ja REAL eine reine Software-Zahlendarstellung.
Später kamen dann die Numeric-Prozessoren und deren Zahlenformate dazu.
Da nicht jeder PC automatisch einen Numeric-Prozessor hatte (erst ab 386 / 486), musste, wenn der fehlte, ebenfalls eine Softwarelösung die Bearbeitung dieser Zahlendarstellungen übernehmen.
Man könnte doch eine Software-Darstellung wählen, die lange Integerzahlen erlaubt.
Wenn ich z.B. COBOL nehme, dann ist dort das Zahlenformat, wie auf dem IBM-Host (Großrechner).

http://www.3480-3590-data-conversion...ed-fields.html

Da kann ich z.B. das gepackte Format wie beim Host benutzen. Das macht alles die COBOL-Laufzeitbibliothek.
Es ist damit kein Problem eine 24-stellige Dezimalzahl / 97 zu dividieren.
Bei den heute so schnellen CPUs spielt dieser interne Aufwand, der notwendig ist, um das zu realisieren, doch kaum eine Rolle.
Was PC-COBOL kann, sollte doch in Pascal und C auch möglich sein.
Natürlich könnte man sich eigene Zahlendarstellungen und zugehörige Functionen basteln.

[Union]

So was gibt's ja http://bigint-dl.sourceforge.net/

[Amateurprofi]

Zitat von kwhk:

Zitat von Amateurprofi:

Was in #1 nicht erwähnt wurde, ist, dass die Prüfziffern nicht 00 oder 01 sein darf.

Ich hatte gesagt: der Rest aus MOD97 = 00..96 / PZ = 98 - Rest
Damit kann die PZ nur 02..96 sein, also keine 00 und 01
@sc2008, Deine Methode ist natürlich sehr kompakt.
if cc<2 then ... ist m.E. nicht erforderlich, weil bei mod 97 nur 00 bis 96 herauskommen kann.
Und deshalb 98-cs niemals <2 werden kann (deshalb haben die Erfinder dieser Formel gesagt "98-2").

Recht hast Du.

[Amateurprofi]

Zitat von sx2008:

Dieses "csmax" kann man sich schenken.
Bei der Modulo-Arithmetik rechnet man einfach nach jeder Operation mit mod 97 :

Delphi-Quellcode:

FUNCTION CreateGermanIBAN(Const BankCode,Account:String):String;
var cs, i,cc:integer; s:string;
begin
   if (Length(BankCode)<>8) or (Length(Account)<>10) then Exit('');
   s:=BankCode+Account+'131400'; // 131400 = 'DE00'
   cs:=0;
   for i:=1 to Length(s) do begin
      cs:=(cs*10+Ord(s[i])-Ord('0')) mod 97;
   end;
   cc:=98-cs;
   if cc<2 then inc(cc,97); // 00-->97, 01--> 98
   result:='DE00';
   result[3]:=Chr(cc div 10+Ord('0'));
   result[4]:=Chr(cc mod 10+Ord('0'));
   result:=result+BankCode+Account;
end;

Ja, mit der Folge dass man etwa 10 Mal soviel Mod Operationen braucht.
Mag sein, dass sich das nicht gewaltig auswirkt, aber ich denke man sollte immer auch auf die Performance achten.