Warum modulare Potenzfunktionen in Python und Javascript für große Zahlen unterschiedlich funktionieren?

Question

Ich muss modulare Potenzierung auf ziemlich großen Zahlen auf Python3 und Javascript durchführen. Ich habe Funktionen, die die Aufgabe erledigen, aber sie geben mir unterschiedliche Ergebnisse.

Python (alle drei arbeiten in der gleichen Art und Weise):

pow(176672119508, 55, 200000023499) 

def expmod_iter(a,b,c): 
    x = 1 
    while(b>0): 
     if(b&1==1): x = (x*a)%c 
     a=(a*a)%c 
     b >>= 1 
    return x%c 

def pow_mod(x, y, z): 
    number = 1 
    while y: 
     if y & 1: 
      number = number * x % z 
     y >>= 1 
     x = x * x % z 
    return number 

# The result is always 124912252967 

und jetzt JavaScript (beide Funktionen in der gleichen Art und Weise arbeiten):

function powMod(x, y, z) { 
    let number = 1; 
    while (y) { 
     if (y & 1) { 
      number = number * x % z; 
     } 
     y >>= 1; 
     x = x * x % z; 
    } 
    return number; 
} 

function expmod_iter(a, b, c) { 
    let x = 1; 

    while (b > 0) { 
    if (b & 1 === 1) { 
     x = (x * a) % c; 
    } 
    a = (a * a) % c; 
    b >>= 1 
    } 
    return x % c; 
} 

console.log(powMod(176672119508, 55, 200000023499)); 
console.log(expmod_iter(176672119508, 55, 200000023499)); 

// The result is always 138693107570 

Und wenn ich darüber hinaus verwendet this service mit meinen Zahlen, ich

---

Warum passiert das dies auch 138693107570. bekam? Ich bin mir nicht einmal sicher, welche Variante jetzt korrekt ist. Bei kleineren Zahlen ergeben die Funktionen jedoch identische Ergebnisse.

Ist es irgendwie möglich, das gleiche Ergebnis von den Funktionen zu bekommen? Es ist gar nicht so wichtig, dass das Ergebnis mathematisch korrekt ist, die Ergebnisse sollten mindestens gleich sein.

Könnten Sie bitte erklären, warum das passiert? Ist es das Funktionsdesign? Für mich scheinen Funktionen in beiden Sprachen identisch zu sein.

Gibt es eine Möglichkeit, das gleiche Ergebnis von den Funktionen beider Sprachen zu erhalten?

Answer 1

Pythons Ergebnis ist korrekt.

Python verwendet eine Integer-Repräsentation mit beliebiger Genauigkeit, während Javascript alle Zahlen als IEEE754-64-Bit-Gleitkomma speichert (und sie für Bit-Operationen vorübergehend in 32-Bit-Ganzzahlen umwandelt). Dies bedeutet, dass der Javascript-Code bei großen Ganzzahlen an Genauigkeit verliert, während der Python-Code die genauen Werte aller Ergebnisse während der Berechnung beibehält.

Wenn Sie große Ganzzahlen genau in Javascript verarbeiten möchten, müssen Sie an appropriate library verwenden. Alternativ sagen Sie, dass es Ihnen nicht wichtig ist, dass das Ergebnis korrekt ist. Das ist eine wirklich seltsame Sache, die man nicht interessiert, aber wenn man sich wirklich so fühlt:

# Python 
def wrongpow(a, b, c): 
    return 0 

// Javascript 
function wrongpow(a, b, c) { 
    return 0; 
}