def test10(self):
"""Parser check of internal state automaton
'X^ + 1' is an invalid expression
"""
expr = 'X^ + 1'
with self.assertRaises(SyntaxError):
symbolic_polynomial(expr, IntegerRing())
def testF16gcd(self):
"""Check GCD of polynomials over F16
"""
f2 = PrimeField(2)
p = f2.polynomial(1, 1, 0, 0, 1)
f16 = FiniteField(2, 4, p)
a = symbolic_polynomial('X^6 + X^3 + 1', f16)
b = symbolic_polynomial('X^3 + 1', f16)
self.assertEqual(gcd(a, b), f16.polynomial(1))
def testF9Product(self):
"""Check product of polynomials over F9
"""
f3 = PrimeField(3)
p = f3.polynomial(1, 0, 1)
f9 = FiniteField(3, 2, p)
a = symbolic_polynomial('-1 + X - (1+j)X^2', f9)
b = symbolic_polynomial('1 + X^2 + (j)X', f9)
self.assertTrue(
a * b == f9.polynomial(-1, f9(1, -1), 1, f9(-1, -1), f9(-1, -1)))
def test8(self):
"""Parser check of internal state automaton
'(j+)X' is an invalid expression
"""
expr = '(j+)X'
f2 = PrimeField(2)
p = f2.polynomial(1, 1, 1)
f4 = FiniteField(2, 2, p)
with self.assertRaises(SyntaxError):
symbolic_polynomial(expr, f4)
def testF8Add(self):
"""Check addition of polynomials over F8
"""
f2 = PrimeField(2)
p = f2.polynomial(1, 1, 0, 1)
f8 = FiniteField(2, 3, p, root_symbol='w')
a = symbolic_polynomial('1 + X + (1+w^2)X^3', f8)
b = symbolic_polynomial('(1+w)X^2 + X^3', f8)
self.assertEqual(b.trailing, FFElement(f8, (1, 1, 0)))
self.assertTrue(a + b == f8.polynomial(1, 1, f8(1, 1, 0), f8(0, 0, 1)))
def testF16Div(self):
"""Check long division of polynomials over F16
"""
f2 = PrimeField(2)
p = f2.polynomial(1, 1, 0, 0, 1)
f16 = FiniteField(2, 4, p)
a = symbolic_polynomial('X^6 + X^3 + 1', f16)
b = symbolic_polynomial('X^3 + 1', f16)
q = a / b
r = a % b
self.assertEqual(q, f16.polynomial(0, 0, 0, 1))
self.assertEqual(r, a.unit)
def test5(self):
"""Check full factorization over F7, non monic
"""
f7 = PrimeField(7)
p = symbolic_polynomial('-3X^3 - 2X^2 + X + 3', f7)
factors, c = factorize(p).cantor_zassenhaus()
self.assertTrue(factorize(p).factors_product(factors) * c == p)
def test4(self):
"""Check full factorization over F3, non monic
"""
f3 = PrimeField(3)
p = symbolic_polynomial('-X^3 - X^2 + X + 1', f3)
factors, c = factorize(p).cantor_zassenhaus()
self.assertTrue(factorize(p).factors_product(factors) * c == p)
def parse(self, expr: str) -> 'GaussInt':
"""Returns a gaussian integer from its symbolic expression
"""
p = symbolic_polynomial(expr,
IntegerRing(),
indeterminate=self.root_symbol)
if p.degree > 1:
raise ValueError(f'{expr} is not a valid gaussian integer')
return self(p[0], p[1])
def test1(self):
"""Parser test over F4
"""
f2 = PrimeField(2)
f4 = FiniteField(2, 2, f2.polynomial(1, 1, 1))
expr = '+(j+1)X + (1+j)X^2 + (j)'
p = symbolic_polynomial(expr, f4)
self.assertTrue(p == f4.polynomial(f4(0, 1), f4(1, 1), f4(1, 1)))
def test4(self):
"""Parser test for a linear polynomial over the finite field of order 8
"""
expr = '-(1+w+w^2) + X'
f2 = PrimeField(2)
g = f2.polynomial(1, 1, 0, 1)
f8 = FiniteField(2, 3, g, root_symbol='w')
p = symbolic_polynomial(expr, f8)
self.assertTrue(p == f8.polynomial(f8(1, 1, 1), 1))
def test3(self):
"""Check full factorization over F2, square of degree 8
"""
f2 = PrimeField(2)
p = symbolic_polynomial('1 + X^2 + X^4 + X^8', f2)
factors, c = factorize(p).cantor_zassenhaus()
self.assertTrue(c == 1)
self.assertTrue(len(factors) == 2)
self.assertTrue(factorize(p).factors_product(factors) == p)
def testF25Repr(self):
"""Check equivalence of symbolic representation and printable representation of a polynomial over F25
"""
f5 = PrimeField(5)
f25 = FiniteField(5, 2, f5.polynomial(2, 0, 1))
p = symbolic_polynomial('(1+j)X^2 + (j)X^5 + X + 2X^3 + (2+j)', f25)
self.assertEqual(
p,
eval(repr(f25.polynomial(f25(2, 1), 1, f25(1, 1), 2, 0, f25(0,
1)))))
def test1(self):
"""Extended checks for monic and non-monic polynomials in Z
"""
p = Polynomial([0, 1, 1], IntegerRing())
self.assertTrue(str(p) == 'X + X^2')
f5 = PrimeField(5)
p = f5.linear_polynomial(f5(-2))
self.assertTrue(str(p) == '2 + X')
p = f5.polynomial(0, -1, 1)
self.assertTrue(str(p) == '-X + X^2')
p = symbolic_polynomial('-2 - X^16', PrimeField(5))
self.assertTrue(str(p) == '-2 - X^16')
def test2(self):
"""Extended checks for polynomials over F4"""
f4 = self.f4
p = symbolic_polynomial('1', f4)
self.assertTrue(str(p) == '1')
p = symbolic_polynomial('X+1', f4)
self.assertTrue(str(p) == '1 + X')
p = symbolic_polynomial('(j)', f4)
self.assertTrue(str(p) == '(j)')
p = symbolic_polynomial('(1+j) + X^2', f4)
self.assertTrue(str(p) == '(1+j) + X^2')
p = symbolic_polynomial('(1+j)X^2', f4)
self.assertTrue(str(p) == '(1+j)X^2')
p = symbolic_polynomial('1 + (j)X', f4)
self.assertTrue(str(p) == '1 + (j)X')
p = symbolic_polynomial('1 + (1+j)X + (j)X^2', f4)
self.assertTrue(str(p) == '1 + (1+j)X + (j)X^2')
def test2(self):
"""Basic check in F5
"""
expr = 'X^3 + 2X - 1'
p = symbolic_polynomial(expr, PrimeField(5))
self.assertEqual(p, p.base_field.polynomial(-1, 2, 0, 1))
def test12(self):
"""Parser check of internal state automaton: empty expression
"""
expr = ''
p = symbolic_polynomial(expr, IntegerRing())
self.assertTrue(p == IntegerRing().polynomial(IntegerRing().zero))
def test11(self):
"""Parser check of internal state automaton: missing operator
"""
expr = '-X + X^2 X^3'
with self.assertRaises(SyntaxError):
symbolic_polynomial(expr, IntegerRing())
def test3(self):
"""Parser test for linear polynomial over a prime field
"""
expr = '-1 - X'
p = symbolic_polynomial(expr, PrimeField(3))
self.assertTrue(p == PrimeField(3).polynomial(-1, -1))
def test2(self):
"""Parser test for constant polynomial and operator ==
"""
expr = '-1'
p = symbolic_polynomial(expr, IntegerRing())
self.assertTrue(p == IntegerRing().polynomial(-1))
def test1(self):
"""Basic check in F2
"""
expr = '1 + X + X^2 + X^3'
p = symbolic_polynomial(expr, PrimeField(2))
self.assertEqual(str(p), expr)
def parse_poly(self, expr: str) -> Polynomial:
"""Returns a polynomial from its symbolic expression
"""
return symbolic_polynomial(expr, self)
def test5(self):
"""Parser check missing terms of a polynomial of degree 6
"""
expr = '1 + X - X^2 + X^6'
p = symbolic_polynomial(expr, IntegerRing())
self.assertTrue(p == IntegerRing().polynomial(1, 1, -1, 0, 0, 0, 1))
