MOD und EXTENDED arbeiten nicht zusammen, alternative?

[trockentaucher]

Hallo, in einem html/java habe ich folgendes gefunden:

Delphi-Quellcode:

function crypt(f) {
  var e = f.T5.value
  var klartext = f.T9.value
  var n = f.T3.value
  var ergebnis = 1
  if (klartext < n*1) {
    for (i=1;i<=e;i++) {
      ergebnis *= klartext
      ergebnis %= n
    }
    f.T10.value = klartext+" hoch "+e+" (mod "+n+") = "+ergebnis
    f.T17.value = n
  }
  else {
    hilf = n-1
    alert("Nur Zahlen von 0 bis "+hilf+" können verschlüsselt werden !")
  }
}

Diese Funktion macht nicht anderes als (ERGEBNISS = Zahl^E mod N); gehört zu einer simplen Verschlüsselung von Zahlen durch die Anwendung von Primzahlen. Dieses wollte ich eigentlich unter Delphi einsetzen (D7 prof.), was aber nicht funzt, weil ZAHL^E als Ergebniss einen EXTENDED-Wert liefert:

Delphi-Quellcode:

ERGEBNISS := Power(Zahl, E) mod N; {ergibt Operanden-Fehler}

Gibt es ein Mathe-Genie hier im Forum, der eine Lösung für D7 aus der Tasche zaubern kann? :?

[bigg]

Probiers doch mal mit Runden (:

[Union]

Versuch es doch so

Delphi-Quellcode:

ERGEBNISS := Trunc(Power(Zahl, E)) mod N; {ergibt Operanden-Fehler}

Gibt es ein Mathe-Genie hier im Forum, der eine Lösung für D7 aus der Tasche zaubern kann? :?[/quote]

[moritz]

Delphi-Quellcode:

function ExtendedMod(Value: Extended; Divisor: Integer):Extended;
begin
  Result := Value;
  while Result >= Divisor do
    Result := Result - Divisor;
end;

Sollte so eigentlich stimmen.
[Edit]Waaah Nein.... :wall: Okay, das war's ned![Edit]

Edit 2:
Vielleicht so....

Delphi-Quellcode:

function ExtendedMod(Value: Extended; Divisor: Integer):Extended;
begin
  Result := (Value / Divisor) - Floor(Value / Divisor);
end;

[bigg]

na wenn dann so:

Delphi-Quellcode:

function ExtendedMod(Value: Extended; Divisor: Integer):Extended;
var x: Extended;
begin 
x      := (Value / Divisor);
Result := x - Floor(x);
end;

[schöni]

Hallo trockentaucher!

Also mit mod kannst Du nur ganze Zahlen dividieren. Entweder Du rundest mit Trunc oder Round und rechnest mit dem Int64 Wert weiter, oder Du musst ne eigene Routine für Power schreiben, die ein ganzzahliges Ergebnis liefert, fall Du den Verschlüsselungsalgotithmus beibehalten willst. Wahrscheinlich eher letzteres, da ich aus dem Thread entnehme, das es mit Int64 auch nicht geht. Aber mit der Zahl e als Basis oder Exponent kannst Du nur mit Round oder Trunc runden.

Viel Erfolg

schöni

[Binärbaum]

Also ich gehe mal davon aus, dass das "E" nur für den allgemeinen Exponenten steht und nicht für e (eulersche Zahl), da man sonst kein ganzzahliges Ergebnis erhalten kann.
Statt Power könnte man auch IntPower verwenden, dort werden nur ganzzahlige Exponenten zugelassen (und müsste somit auch schneller sein als Power). Ich bin mir jetzt nicht ganz sicher, welchen Rückgabetyp die Funktion hat, aber wahrscheinlich auch Extended. Deshalb muss man mit Round oder Trunc das Ergebnis in einen Int64 umwandeln (Das geht aber nur, wenn das Ergebnis noch im Bereich von Int64 liegt also < 2^63 -1 :!: ). Dann sollte auch der mod-Operator wieder funktionieren.

MfG
Binärbaum

[trockentaucher]

Hi Binärbaum and all, thanks so far...

Zitat:

Zitat von Binärbaum

Also ich gehe mal davon aus, dass das "E" nur für den allgemeinen Exponenten steht und nicht für e (eulersche Zahl)

Yepp, soweit richtig.

Beispiel:

Delphi-Quellcode:

Function gfGetKey(intNr:Extended) :Extended; {intNr ist ein 4-stelliger Integer, der verschlüsselt werden soll}

Var Zahl : Extended;

begin
  Zahl := Power(intNr, 7); {Result: 3,3541434664347E24}
  gfGetKey := Zahl mod 119; {hier rumst es weil Zahl:Extended}
end;

Im Prinzip soll gfGetKey einen Integer liefern, der aus dem Rest (mod) von "Zahl div 119" enthält. Dieser Wert wäre die Verschlüsselung. Die Idee habe ich hier gefunden: Verschlüsselung von Zahlen
Als Primzahlen können zum testen die 7 und die 17 verwendet werden, Zahl E wäre 7. Daraus ergibt sich 119 für Zahl N...

[Binärbaum]

Zitat:

Zitat von trockentaucher

Beispiel:

Delphi-Quellcode:

Function gfGetKey(intNr:Extended) :Extended; {intNr ist ein 4-stelliger Integer, der verschlüsselt werden soll}

Var Zahl : Extended;

begin
  Zahl := Power(intNr, 7); {Result: 3,3541434664347E24}
  gfGetKey := Zahl mod 119; {hier rumst es weil Zahl:Extended}
end;

Im Prinzip soll gfGetKey einen Integer liefern, der aus dem Rest (mod) von "Zahl div 119" enthält. Dieser Wert wäre die Verschlüsselung. Die Idee habe ich hier gefunden: Verschlüsselung von Zahlen
Als Primzahlen können zum testen die 7 und die 17 verwendet werden, Zahl E wäre 7. Daraus ergibt sich 119 für Zahl N...

Warum deklarierst du intNr als Extended, wenn dort nur 4-Stellige Integer vorkommen?

Delphi-Quellcode:

Function gfGetKey(intNr: Integer) :Cardinal; {intNr ist ein 4-stelliger Integer, der verschlüsselt werden soll}
var Zahl : Int64;
begin
  Zahl := Round(IntPower(intNr, 7));
  gfGetKey := Zahl mod 119; 
end;

MfG
Binärbaum

[Edit]
Als Rückgabewert würde in diesem Falle sogar der Typ Byte ausreichen, da Zahl mod 119 stets im Bereich 0..118 liegt.
[/Edit]