Berechnungsverfahren

from BasicFunctions import *

# repraesentiert ein Element von Zn (dem Koerper der Zahlen modulo n)
# und stellt die Grundrechenoperationen zur Verfuegung
class ModInt(object):

    # Modul n (n Primzahl) ist Klassenattribut (statisches Attribut),
    # muss vor Beginn der Berechnungen gesetzt werden
    # z.B. ModInt.n=23

    def __init__(self, i):
        self.i=i % ModInt.n

    # Addition
    def __add__(self, other):
        return ModInt(self.i+other.i)

    # additiv inverses Element
    def __neg__(self):
        return ModInt(-self.i)

    # Subtraktion
    def __sub__(self, other):
        return self+(-other)

    # Multiplikation
    def __mul__(self, other):
        return ModInt(self.i*other.i)

    # multiplikativ inverses (reziprokes) Element
    def rec(self):
        return ModInt(modinverse(self.i, ModInt.n))

    # Division
    def __div__(self, other):        # __truediv__ in Python 3
        return self*other.rec()
    
    # Exponentiation, k Integer-Zahl
    def __pow__(self, k):
        if k==0:
            return ModInt(1)
        if k%2==1:    # k ungerade
            return self*self**(k-1)
        else:
            return (self*self)**(k//2)
        
    # Gleichheit
    def __eq__(self, other):
        return self.i==other.i

    # Umwandlung in String
    def __str__(self):
        return str(self.i)
    

# --------- Test -------------
if __name__=="__main__":
 
    def assertion(k, r):
        assert str(k)==str(r)
        
    # Zahlen und Berechnungen modulo n=7:
    ModInt.n=7    # n ist Klassenattribut (statisches Attribut)
    s=ModInt(2)
    t=ModInt(13)
        
    assertion(s, 2)
    assertion(t, 6)
    assertion(s+t, 1)
    assertion(s*t, 5)
    assertion(s-t, 3)
    assertion(s/t, 5)
    assertion(s**999, 1)
    assertion(s*t, s/t)
    print("Ok")