def testInit(self):
self.assertEqual("2/1", str(Rational(2)))
self.assertEqual("2/1", str(Rational(2)))
self.assertEqual("1/2", str(Rational(1,2)))
self.assertEqual("1/2", str(Rational(Rational(1,2))))
self.assertEqual("21/26", str(Rational(Rational(7,13),Rational(2,3))))
self.assertEqual("3/2", str(Rational(1.5)))
self.assertEqual("3/4", str(Rational(1.5, 2.0)))
self.assertRaises(ZeroDivisionError, Rational, 1, 0)
self.assertRaises(TypeError, Rational, 1, finitefield.FinitePrimeFieldElement(1,7))
self.assertRaises(TypeError, Rational, finitefield.FinitePrimeFieldElement(1,7), 4)
def _pull_back(elem, p):
"""
Return an integer which is a pull back of elem in Fp.
"""
if not isinstance(elem, finitefield.FinitePrimeFieldElement):
if isinstance(elem, intresidue.IntegerResidueClass):
# expecting Z/(p^2 Z)
result = finitefield.FinitePrimeFieldElement(elem.n, p).n
else:
# expecting Z or Q
result = finitefield.FinitePrimeFieldElement(elem, p).n
else:
result = elem.n
if result > (p >> 1): # minimum absolute
result -= p
return result
def testWeilPairing(self):
# this example was refered to Washington.
e = elliptic.EC([0, 2], 7)
P = [5, 1]
Q = [0, 3]
R = e.WeilPairing(3, P, Q)
self.assertEqual(finitefield.FinitePrimeFieldElement(2, 7), R)
# test case of extension field, characteristic 7
p = 7
r = 11
F = finitefield.FinitePrimeField(p)
PX = uniutil.polynomial({0:3,1:3,2:2,3:1,4:4,5:1,6:1,10:1},F)
Fx = finitefield.FiniteExtendedField(p,PX)
E = elliptic.EC([F.one,-F.one],F)
Ex = elliptic.EC([Fx.one,-Fx.one],Fx)
P = [3,6]
assert E.whetherOn(P)
assert Ex.whetherOn(P)
assert E.mul(11,P) == E.infpoint
Qxcoord = Fx.createElement(6*7**9+7**8+7**6+6*7**3+6*7**2+7+6)
Qycoord = Fx.createElement(3*7**9+6*7**8+4*7**7+2*7**6+5*7**4+5*7**3+7**2+7+3)
Q = [Qxcoord,Qycoord]
assert Ex.whetherOn(Q)
assert Ex.mul(11,Q) == Ex.infpoint
w = Ex.WeilPairing(11, P, Q)
Wp = Fx.createElement(7**9 + 5*7**8 + 4*7**7 + 2*7**5 + 7**4 + 6*7**2)
assert w == Wp
def _mod_p(poly, p):
"""
Return modulo p reduction of given integer coefficient polynomial.
"""
coeff = {}
for d, c in poly:
coeff[d] = finitefield.FinitePrimeFieldElement(c, p)
return uniutil.polynomial(poly, finitefield.FinitePrimeField.getInstance(p))
def testTatePairing_Extend(self):
# this example was refered to Kim Nguyen.
e = elliptic.EC([0, 4], 997)
P = [0, 2]
Q = [747, 776]
R = e.TatePairing_Extend(3, P, P)
W1 = e.TatePairing_Extend(3, P, Q)
W2 = e.TatePairing_Extend(3, Q, P)
self.assertEqual(e.basefield.one, R)
self.assertEqual(finitefield.FinitePrimeFieldElement(304, 997), W1)
self.assertEqual(W1, W2.inverse())
def _kernel_of_qpow(basis_matrix, q, p, field):
"""
compute kernel of w^q.
(this method is same as round2._kernel_of_qpow)
"""
omega = _matrix_to_algnumber_list(basis_matrix, field)
omega_pow = []
for omega_i in omega:
omega_pow.append(omega_i ** q)
omega_pow_mat = _algnumber_list_to_matrix(omega_pow, field)
A_over_Z = basis_matrix.inverse(omega_pow_mat) #theta repr -> omega repr
A = A_over_Z.map(
lambda x: finitefield.FinitePrimeFieldElement(x.numerator, p))
return A.kernel()
def e3_Fp(x, p):
"""
p is prime
0 = x[0] + x[1]*t + x[2]*t**2 + x[3]*t**3
"""
x.reverse()
lc_inv = finitefield.FinitePrimeFieldElement(x[0], p).inverse()
coeff = []
for c in x[1:]:
coeff.append((c * lc_inv).n)
sol = []
for i in bigrange.range(p):
if (i**3 + coeff[0] * i**2 + coeff[1] * i + coeff[2]) % p == 0:
sol.append(i)
break
if len(sol) == 0:
return sol
X = e2_Fp([coeff[1] + (coeff[0] + sol[0]) * sol[0], coeff[0] + sol[0], 1],
p)
if len(X) != 0:
sol.extend(X)
return sol