def test_mod_7_gcd(self): """Test that the GCD works in mod-7 arithmetic.""" Mod7 = IntegersModP(7) # TODO(rbharath): Why are these modular equations right? Is there a way to # do simple mental arithmetic to calculate these values? assert Mod7(6) == gcd(Mod7(6), Mod7(14)) assert Mod7(2) == gcd(Mod7(6), Mod7(9))
def test_gcd_ints(self): """Test that the GCD functions correctly on ints.""" assert gcd(7, 9) == 1 assert gcd(8, 18) == 2 assert gcd(-12, 24) == -12 # gcd is only unique up to multiplication by a unit, and so sometimes we'll get negatives. assert gcd(12, -24) == 12 assert gcd(4864, 3458) == 38
def test_mod_large_gcd(self): """Test that GCD works with a larger prime.""" ModHuge = IntegersModP(9923) assert ModHuge(38) == gcd(ModHuge(4864), ModHuge(3458)) assert (ModHuge(32), ModHuge(-45), ModHuge(38)) == extended_euclidean_algorithm( ModHuge(4864), ModHuge(3458))
def is_irreducible(polynomial: Poly, p: int) -> bool: """is_irreducible: Polynomial, int -> bool Determine if the given monic polynomial with coefficients in Z/p is irreducible over Z/p where p is the given integer Algorithm 4.69 in the Handbook of Applied Cryptography """ ZmodP = IntegersModP(p) if polynomial.ring is not ZmodP: raise TypeError( "Given a polynomial that's not over %s, but instead %r" % (ZmodP.__name__, polynomial.ring.__name__)) poly = polynomials_over(ZmodP).factory x = poly([0, 1]) power_term = x is_unit = lambda p: p.degree() == 0 for _ in range(int(polynomial.degree() / 2)): power_term = power_term.powmod(p, polynomial) gcd_over_Zmodp = gcd(polynomial, power_term - x) if not is_unit(gcd_over_Zmodp): return False return True
def __init__(self, m, n=1): """Constructor for rationals. If denominator is not specified, set it to 1. """ try: # This is awkward constructor overloading if isinstance(m, bytes): num = int.from_bytes(m[:32], 'big') den = int.from_bytes(m[32:], 'big') else: num = int(m) % RationalModP.p den = int(n) % RationalModP.p common = gcd(num, den) # Handle case with 0 if common == 0: self.m, self.n = num, den else: self.m = num // common self.n = den // common except: raise TypeError("Can't cast type %s to %s in __init__" % (type(n).__name__, type(self).__name__)) self.field = RationalModP
def test_mod_2_gcd(self): """Test that the GCD works in mod-2 arithmetic.""" Mod2 = IntegersModP(2) assert Mod2(1) == gcd(Mod2(1), Mod2(0)) assert Mod2(1) == gcd(Mod2(1), Mod2(1)) assert Mod2(0) == gcd(Mod2(2), Mod2(2))
def __sub__(self, other): num = (self.m * other.n - other.m * self.n) % RationalModP.p den = (self.n * other.n) % RationalModP.p common = gcd(num, den) return RationalModP(num // common, den // common)