def test_ANP___init__():
rep = [QQ(1), QQ(1)]
mod = [QQ(1), QQ(0), QQ(1)]
f = ANP(rep, mod, QQ)
assert f.rep == [QQ(1), QQ(1)]
assert f.mod == [QQ(1), QQ(0), QQ(1)]
assert f.dom == QQ
rep = {1: QQ(1), 0: QQ(1)}
mod = {2: QQ(1), 0: QQ(1)}
f = ANP(rep, mod, QQ)
assert f.rep == [QQ(1), QQ(1)]
assert f.mod == [QQ(1), QQ(0), QQ(1)]
assert f.dom == QQ
f = ANP(1, mod, QQ)
assert f.rep == [QQ(1)]
assert f.mod == [QQ(1), QQ(0), QQ(1)]
assert f.dom == QQ
f = ANP([1, 0.5], mod, QQ)
assert all(QQ.of_type(a) for a in f.rep)
raises(CoercionFailed, lambda: ANP([sqrt(2)], mod, QQ))
def test_dmp_lift():
q = [QQ(1, 1), QQ(0, 1), QQ(1, 1)]
f = [
ANP([QQ(1, 1)], q, QQ),
ANP([], q, QQ),
ANP([], q, QQ),
ANP([QQ(1, 1), QQ(0, 1)], q, QQ),
ANP([QQ(17, 1), QQ(0, 1)], q, QQ),
]
assert dmp_lift(f, 0, QQ.algebraic_field(I)) == [
QQ(1),
QQ(0),
QQ(0),
QQ(0),
QQ(0),
QQ(0),
QQ(2),
QQ(0),
QQ(578),
QQ(0),
QQ(0),
QQ(0),
QQ(1),
QQ(0),
QQ(-578),
QQ(0),
QQ(83521),
]
raises(DomainError, lambda: dmp_lift([EX(1), EX(2)], 0, EX))
def test_dup_factor_list():
assert dup_factor_list([], ZZ) == (ZZ(0), [])
assert dup_factor_list([], QQ) == (QQ(0), [])
assert dup_factor_list([], ZZ['y']) == (DMP([],ZZ), [])
assert dup_factor_list([], QQ['y']) == (DMP([],QQ), [])
assert dup_factor_list_include([], ZZ) == [([], 1)]
assert dup_factor_list([ZZ(7)], ZZ) == (ZZ(7), [])
assert dup_factor_list([QQ(1,7)], QQ) == (QQ(1,7), [])
assert dup_factor_list([DMP([ZZ(7)],ZZ)], ZZ['y']) == (DMP([ZZ(7)],ZZ), [])
assert dup_factor_list([DMP([QQ(1,7)],QQ)], QQ['y']) == (DMP([QQ(1,7)],QQ), [])
assert dup_factor_list_include([ZZ(7)], ZZ) == [([ZZ(7)], 1)]
assert dup_factor_list([ZZ(1),ZZ(2),ZZ(1)], ZZ) == \
(ZZ(1), [([ZZ(1), ZZ(1)], 2)])
assert dup_factor_list([QQ(1,2),QQ(1),QQ(1,2)], QQ) == \
(QQ(1,2), [([QQ(1),QQ(1)], 2)])
assert dup_factor_list_include([ZZ(1),ZZ(2),ZZ(1)], ZZ) == \
[([ZZ(1), ZZ(1)], 2)]
K = FF(2)
assert dup_factor_list([K(1),K(0),K(1)], K) == \
(K(1), [([K(1), K(1)], 2)])
assert dup_factor_list([RR(1.0),RR(2.0),RR(1.0)], RR) == \
(RR(1.0), [([RR(1.0),RR(1.0)], 2)])
assert dup_factor_list([RR(2.0),RR(4.0),RR(2.0)], RR) == \
(RR(2.0), [([RR(1.0),RR(1.0)], 2)])
f = [DMP([ZZ(4),ZZ(0)],ZZ),DMP([ZZ(4),ZZ(0),ZZ(0)],ZZ),DMP([],ZZ)]
assert dup_factor_list(f, ZZ['y']) == \
(DMP([ZZ(4)],ZZ), [([DMP([ZZ(1),ZZ(0)],ZZ)], 1),
([DMP([ZZ(1)],ZZ),DMP([],ZZ)], 1),
([DMP([ZZ(1)],ZZ),DMP([ZZ(1),ZZ(0)],ZZ)], 1)])
f = [DMP([QQ(1,2),QQ(0)],ZZ),DMP([QQ(1,2),QQ(0),QQ(0)],ZZ),DMP([],ZZ)]
assert dup_factor_list(f, QQ['y']) == \
(DMP([QQ(1,2)],QQ), [([DMP([QQ(1),QQ(0)],QQ)], 1),
([DMP([QQ(1)],QQ),DMP([],QQ)], 1),
([DMP([QQ(1)],QQ),DMP([QQ(1),QQ(0)],QQ)], 1)])
K = QQ.algebraic_field(I)
h = [QQ(1,1), QQ(0,1), QQ(1,1)]
f = [ANP([QQ(1,1)], h, QQ), ANP([], h, QQ), ANP([QQ(2,1)], h, QQ), ANP([], h, QQ), ANP([], h, QQ)]
assert dup_factor_list(f, K) == \
(ANP([QQ(1,1)], h, QQ), [([ANP([QQ(1,1)], h, QQ), ANP([], h, QQ)], 2),
([ANP([QQ(1,1)], h, QQ), ANP([], h, QQ), ANP([QQ(2,1)], h, QQ)], 1)])
raises(DomainError, "dup_factor_list([EX(sin(1))], EX)")
def test_ANP_properties():
mod = [QQ(1),QQ(0),QQ(1)]
assert ANP([QQ(0)], mod, QQ).is_zero == True
assert ANP([QQ(1)], mod, QQ).is_zero == False
assert ANP([QQ(1)], mod, QQ).is_one == True
assert ANP([QQ(2)], mod, QQ).is_one == False
def test___hash__():
# Issue 2472
# Make sure int vs. long doesn't affect hashing with Python ground types
assert DMP([[1, 2], [3]], ZZ) == DMP([[1l, 2l], [3l]], ZZ)
assert hash(DMP([[1, 2], [3]], ZZ)) == hash(DMP([[1l, 2l], [3l]], ZZ))
assert DMF(([[1, 2], [3]], [[1]]), ZZ) == DMF(([[1L, 2L], [3L]], [[1L]]), ZZ)
assert hash(DMF(([[1, 2], [3]], [[1]]), ZZ)) == hash(DMF(([[1L, 2L], [3L]], [[1L]]), ZZ))
assert ANP([1, 1], [1, 0, 1], ZZ) == ANP([1l, 1l], [1l, 0l, 1l], ZZ)
assert hash(ANP([1, 1], [1, 0, 1], ZZ)) == hash(ANP([1l, 1l], [1l, 0l, 1l], ZZ))
def test___hash__():
# issue 5571
# Make sure int vs. long doesn't affect hashing with Python ground types
assert DMP([[1, 2], [3]], ZZ) == DMP([[long(1), long(2)], [long(3)]], ZZ)
assert hash(DMP([[1, 2], [3]], ZZ)) == hash(DMP([[long(1), long(2)], [long(3)]], ZZ))
assert DMF(
([[1, 2], [3]], [[1]]), ZZ) == DMF(([[long(1), long(2)], [long(3)]], [[long(1)]]), ZZ)
assert hash(DMF(([[1, 2], [3]], [[1]]), ZZ)) == hash(DMF(([[long(1),
long(2)], [long(3)]], [[long(1)]]), ZZ))
assert ANP([1, 1], [1, 0, 1], ZZ) == ANP([long(1), long(1)], [long(1), long(0), long(1)], ZZ)
assert hash(
ANP([1, 1], [1, 0, 1], ZZ)) == hash(ANP([long(1), long(1)], [long(1), long(0), long(1)], ZZ))
def test_ANP___eq__():
a = ANP([QQ(1), QQ(1)], [QQ(1),QQ(0),QQ(1)], QQ)
b = ANP([QQ(1), QQ(1)], [QQ(1),QQ(0),QQ(2)], QQ)
assert (a == a) == True
assert (a != a) == False
assert (a == b) == False
assert (a != b) == True
b = ANP([QQ(1), QQ(2)], [QQ(1),QQ(0),QQ(1)], QQ)
assert (a == b) == False
assert (a != b) == True
def test_polys():
x = Symbol("x")
f = Poly(x, x)
g = lambda x: x
ZZ = ZZ_python()
QQ = QQ_sympy()
for c in (Poly, Poly(x, x)):
check(c)
for c in (GFP, GFP([ZZ(1), ZZ(2), ZZ(3)], ZZ(7), ZZ)):
check(c)
for c in (DUP, DUP([ZZ(1), ZZ(2), ZZ(3)], ZZ(7), ZZ)):
check(c)
for c in (DMP, DMP([ZZ(1), ZZ(2), ZZ(3)], 0, ZZ)):
check(c)
for c in (DMF, DMF(([ZZ(1), ZZ(2)], [ZZ(1), ZZ(3)], ZZ))):
check(c)
for c in (ANP, ANP([QQ(1), QQ(2)], [QQ(1), QQ(2), QQ(3)], QQ)):
check(c)
for c in (ZZ_python, ZZ_python()):
check(c)
for c in (ZZ_sympy, ZZ_sympy()):
check(c)
for c in (QQ_sympy, QQ_sympy()):
check(c)
for c in (PolynomialRing, PolynomialRing(ZZ, 'x', 'y')):
check(c)
for c in (FractionField, FractionField(ZZ, 'x', 'y')):
check(c)
for c in (ExpressionDomain, ExpressionDomain()):
check(c)
try:
from sympy.polys.algebratools import QQ_python
for c in (QQ_python, QQ_python()):
check(c)
except ImportError:
pass
try:
from sympy.polys.algebratools import QQ_python
for c in (ZZ_gmpy, ZZ_gmpy()):
check(c)
for c in (QQ_gmpy, QQ_gmpy()):
check(c)
except ImportError:
pass
for c in (RootOf, RootOf(f,
0), RootsOf, RootsOf(x,
x), RootSum, RootSum(g, f)):
check(c)
def test_ANP_unify():
mod = [QQ(1), QQ(0), QQ(-2)]
a = ANP([QQ(1)], mod, QQ)
b = ANP([ZZ(1)], mod, ZZ)
assert a.unify(b)[0] == QQ
assert b.unify(a)[0] == QQ
assert a.unify(a)[0] == QQ
assert b.unify(b)[0] == ZZ
def test_pickling_polys_polyclasses():
from sympy.polys.polyclasses import DMP, DMF, ANP
for c in (DMP, DMP([[ZZ(1)], [ZZ(2)], [ZZ(3)]], ZZ)):
check(c)
for c in (DMF, DMF(([ZZ(1), ZZ(2)], [ZZ(1), ZZ(3)]), ZZ)):
check(c)
for c in (ANP, ANP([QQ(1), QQ(2)], [QQ(1), QQ(2), QQ(3)], QQ)):
check(c)
def test_polys():
x = Symbol("x")
ZZ = PythonIntegerRing()
QQ = SymPyRationalField()
for c in (Poly, Poly(x, x)):
check(c)
for c in (GFP, GFP([ZZ(1), ZZ(2), ZZ(3)], ZZ(7), ZZ)):
check(c)
for c in (DMP, DMP([ZZ(1), ZZ(2), ZZ(3)], 0, ZZ)):
check(c)
for c in (DMF, DMF(([ZZ(1), ZZ(2)], [ZZ(1), ZZ(3)], ZZ))):
check(c)
for c in (ANP, ANP([QQ(1), QQ(2)], [QQ(1), QQ(2), QQ(3)], QQ)):
check(c)
for c in (PythonIntegerRing, PythonIntegerRing()):
check(c)
for c in (SymPyIntegerRing, SymPyIntegerRing()):
check(c)
for c in (SymPyRationalField, SymPyRationalField()):
check(c)
for c in (PolynomialRing, PolynomialRing(ZZ, 'x', 'y')):
check(c)
for c in (FractionField, FractionField(ZZ, 'x', 'y')):
check(c)
for c in (ExpressionDomain, ExpressionDomain()):
check(c)
from sympy.polys.domains import HAS_FRACTION, HAS_GMPY
if HAS_FRACTION:
from sympy.polys.domains import PythonRationalField
for c in (PythonRationalField, PythonRationalField()):
check(c)
if HAS_GMPY:
from sympy.polys.domains import GMPYIntegerRing, GMPYRationalField
for c in (GMPYIntegerRing, GMPYIntegerRing()):
check(c)
for c in (GMPYRationalField, GMPYRationalField()):
check(c)
f = x**3 + x + 3
g = lambda x: x
for c in (RootOf, RootOf(f, 0), RootSum, RootSum(f, g)):
check(c)
def test_ANP___init__():
rep = [QQ(1),QQ(1)]
mod = [QQ(1),QQ(0),QQ(1)]
f = ANP(rep, mod, QQ)
assert f.rep == [QQ(1),QQ(1)]
assert f.mod == [QQ(1),QQ(0),QQ(1)]
assert f.dom == QQ
rep = {1: QQ(1), 0: QQ(1)}
mod = {2: QQ(1), 0: QQ(1)}
f = ANP(rep, mod, QQ)
assert f.rep == [QQ(1),QQ(1)]
assert f.mod == [QQ(1),QQ(0),QQ(1)]
assert f.dom == QQ
f = ANP(1, mod, QQ)
assert f.rep == [QQ(1)]
assert f.mod == [QQ(1),QQ(0),QQ(1)]
assert f.dom == QQ
def test_ANP_unify():
mod = [QQ(1), QQ(0), QQ(-2)]
a = ANP([QQ(1)], mod, QQ)
b = ANP([ZZ(1)], mod, ZZ)
assert a.unify(b)[0] == QQ
assert b.unify(a)[0] == QQ
assert a.unify(a)[0] == QQ
assert b.unify(b)[0] == ZZ
def test_polys():
x = Symbol("X")
ZZ = PythonIntegerRing()
QQ = PythonRationalField()
for c in (Poly, Poly(x, x)):
check(c)
for c in (DMP, DMP([[ZZ(1)], [ZZ(2)], [ZZ(3)]], ZZ)):
check(c)
for c in (DMF, DMF(([ZZ(1), ZZ(2)], [ZZ(1), ZZ(3)]), ZZ)):
check(c)
for c in (ANP, ANP([QQ(1), QQ(2)], [QQ(1), QQ(2), QQ(3)], QQ)):
check(c)
for c in (PythonIntegerRing, PythonIntegerRing()):
check(c)
for c in (PythonRationalField, PythonRationalField()):
check(c)
for c in (PolynomialRing, PolynomialRing(ZZ, 'x', 'y')):
check(c)
for c in (FractionField, FractionField(ZZ, 'x', 'y')):
check(c)
for c in (ExpressionDomain, ExpressionDomain()):
check(c)
from sympy.core.compatibility import HAS_GMPY
if HAS_GMPY:
from sympy.polys.domains import GMPYIntegerRing, GMPYRationalField
for c in (GMPYIntegerRing, GMPYIntegerRing()):
check(c)
for c in (GMPYRationalField, GMPYRationalField()):
check(c)
f = x**3 + x + 3
g = exp
for c in (RootOf, RootOf(f, 0), RootSum, RootSum(f, g)):
check(c)
def __call__(self, a):
"""Construct an element of `self` domain from `a`. """
return ANP(a, self.mod.rep, self.dom)
def test_ANP_arithmetics():
mod = [QQ(1),QQ(0),QQ(0),QQ(-2)]
a = ANP([QQ(2),QQ(-1),QQ(1)], mod, QQ)
b = ANP([QQ(1),QQ(2)], mod, QQ)
c = ANP([QQ(-2), QQ(1), QQ(-1)], mod, QQ)
assert a.neg() == -a == c
c = ANP([QQ(2), QQ(0), QQ(3)], mod, QQ)
assert a.add(b) == a+b == c
assert b.add(a) == b+a == c
c = ANP([QQ(2), QQ(-2), QQ(-1)], mod, QQ)
assert a.sub(b) == a-b == c
c = ANP([QQ(-2), QQ(2), QQ(1)], mod, QQ)
assert b.sub(a) == b-a == c
c = ANP([QQ(3), QQ(-1), QQ(6)], mod, QQ)
assert a.mul(b) == a*b == c
assert b.mul(a) == b*a == c
c = ANP([QQ(-1,43), QQ(9,43), QQ(5,43)], mod, QQ)
assert a.pow(0) == a**(0) == ANP(1, mod, QQ)
assert a.pow(1) == a**(1) == a
assert a.pow(-1) == a**(-1) == c
assert a.quo(a) == a.mul(a.pow(-1)) == a*a**(-1) == ANP(1, mod, QQ)
def test_ANP_arithmetics():
mod = [QQ(1),QQ(0),QQ(0),QQ(-2)]
a = ANP([QQ(2),QQ(-1),QQ(1)], mod, QQ)
b = ANP([QQ(1),QQ(2)], mod, QQ)
c = ANP([QQ(-2), QQ(1), QQ(-1)], mod, QQ)
assert a.neg() == -a == c
c = ANP([QQ(2), QQ(0), QQ(3)], mod, QQ)
assert a.add(b) == a+b == c
assert b.add(a) == b+a == c
c = ANP([QQ(2), QQ(-2), QQ(-1)], mod, QQ)
assert a.sub(b) == a-b == c
c = ANP([QQ(-2), QQ(2), QQ(1)], mod, QQ)
assert b.sub(a) == b-a == c
c = ANP([QQ(3), QQ(-1), QQ(6)], mod, QQ)
assert a.mul(b) == a*b == c
assert b.mul(a) == b*a == c
c = ANP([QQ(-1,43), QQ(9,43), QQ(5,43)], mod, QQ)
assert a.pow(0) == a**(0) == ANP(1, mod, QQ)
assert a.pow(1) == a**(1) == a
assert a.pow(-1) == a**(-1) == c
assert a.quo(a) == a.mul(a.pow(-1)) == a*a**(-1) == ANP(1, mod, QQ)
def test_ANP___bool__():
assert bool(ANP([], [QQ(1),QQ(0),QQ(1)], QQ)) == False
assert bool(ANP([QQ(1)], [QQ(1),QQ(0),QQ(1)], QQ)) == True
def test_dmp_ext_factor():
h = [QQ(1), QQ(0), QQ(-2)]
K = QQ.algebraic_field(sqrt(2))
assert dmp_ext_factor([], 0, K) == (ANP([], h, QQ), [])
assert dmp_ext_factor([[]], 1, K) == (ANP([], h, QQ), [])
f = [[ANP([QQ(1)], h, QQ)], [ANP([QQ(1)], h, QQ)]]
assert dmp_ext_factor(f, 1, K) == (ANP([QQ(1)], h, QQ), [(f, 1)])
g = [[ANP([QQ(2)], h, QQ)], [ANP([QQ(2)], h, QQ)]]
assert dmp_ext_factor(g, 1, K) == (ANP([QQ(2)], h, QQ), [(f, 1)])
f = [[ANP([QQ(1)], h, QQ)], [],
[ANP([QQ(-2)], h, QQ),
ANP([], h, QQ), ANP([], h, QQ)]]
assert dmp_ext_factor(f, 1, K) == \
(ANP([QQ(1)], h, QQ), [
([[ANP([QQ(1)], h, QQ)], [ANP([QQ(-1),QQ(0)], h, QQ), ANP([], h, QQ)]], 1),
([[ANP([QQ(1)], h, QQ)], [ANP([QQ( 1),QQ(0)], h, QQ), ANP([], h, QQ)]], 1),
])
f = [[ANP([QQ(2)], h, QQ)], [],
[ANP([QQ(-4)], h, QQ),
ANP([], h, QQ), ANP([], h, QQ)]]
assert dmp_ext_factor(f, 1, K) == \
(ANP([QQ(2)], h, QQ), [
([[ANP([QQ(1)], h, QQ)], [ANP([QQ(-1),QQ(0)], h, QQ), ANP([], h, QQ)]], 1),
([[ANP([QQ(1)], h, QQ)], [ANP([QQ( 1),QQ(0)], h, QQ), ANP([], h, QQ)]], 1),
])
def test_dup_ext_factor():
h = [QQ(1), QQ(0), QQ(1)]
K = QQ.algebraic_field(I)
assert dup_ext_factor([], K) == (ANP([], h, QQ), [])
f = [ANP([QQ(1)], h, QQ), ANP([QQ(1)], h, QQ)]
assert dup_ext_factor(f, K) == (ANP([QQ(1)], h, QQ), [(f, 1)])
g = [ANP([QQ(2)], h, QQ), ANP([QQ(2)], h, QQ)]
assert dup_ext_factor(g, K) == (ANP([QQ(2)], h, QQ), [(f, 1)])
f = [
ANP([QQ(7)], h, QQ),
ANP([], h, QQ),
ANP([], h, QQ),
ANP([], h, QQ),
ANP([QQ(1, 1)], h, QQ)
]
g = [
ANP([QQ(1)], h, QQ),
ANP([], h, QQ),
ANP([], h, QQ),
ANP([], h, QQ),
ANP([QQ(1, 7)], h, QQ)
]
assert dup_ext_factor(f, K) == (ANP([QQ(7)], h, QQ), [(g, 1)])
f = [
ANP([QQ(1)], h, QQ),
ANP([], h, QQ),
ANP([], h, QQ),
ANP([], h, QQ),
ANP([QQ(1)], h, QQ)
]
assert dup_ext_factor(f, K) == \
(ANP([QQ(1,1)], h, QQ), [
([ANP([QQ(1)], h, QQ), ANP([], h, QQ), ANP([QQ(-1),QQ(0)], h, QQ)], 1),
([ANP([QQ(1)], h, QQ), ANP([], h, QQ), ANP([QQ( 1),QQ(0)], h, QQ)], 1),
])
f = [
ANP([QQ(1)], h, QQ),
ANP([], h, QQ),
ANP([], h, QQ),
ANP([], h, QQ),
ANP([QQ(1)], h, QQ)
]
assert dup_ext_factor(f, K) == \
(ANP([QQ(1,1)], h, QQ), [
([ANP([QQ(1)], h, QQ), ANP([], h, QQ), ANP([QQ(-1),QQ(0)], h, QQ)], 1),
([ANP([QQ(1)], h, QQ), ANP([], h, QQ), ANP([QQ( 1),QQ(0)], h, QQ)], 1),
])
h = [QQ(1), QQ(0), QQ(-2)]
K = QQ.algebraic_field(sqrt(2))
f = [
ANP([QQ(1)], h, QQ),
ANP([], h, QQ),
ANP([], h, QQ),
ANP([], h, QQ),
ANP([QQ(1, 1)], h, QQ)
]
assert dup_ext_factor(f, K) == \
(ANP([QQ(1)], h, QQ), [
([ANP([QQ(1)], h, QQ), ANP([QQ(-1),QQ(0)], h, QQ), ANP([QQ(1)], h, QQ)], 1),
([ANP([QQ(1)], h, QQ), ANP([QQ( 1),QQ(0)], h, QQ), ANP([QQ(1)], h, QQ)], 1),
])
f = [ANP([QQ(1, 1)], h, QQ), ANP([2, 0], h, QQ), ANP([QQ(2, 1)], h, QQ)]
assert dup_ext_factor(f, K) == \
(ANP([QQ(1,1)], h, QQ), [
([ANP([1], h, QQ), ANP([1,0], h, QQ)], 2),
])
assert dup_ext_factor(dup_pow(f, 3, K), K) == \
(ANP([QQ(1,1)], h, QQ), [
([ANP([1], h, QQ), ANP([1,0], h, QQ)], 6),
])
f = dup_mul_ground(f, ANP([QQ(2, 1)], h, QQ), K)
assert dup_ext_factor(f, K) == \
(ANP([QQ(2,1)], h, QQ), [
([ANP([1], h, QQ), ANP([1,0], h, QQ)], 2),
])
assert dup_ext_factor(dup_pow(f, 3, K), K) == \
(ANP([QQ(8,1)], h, QQ), [
([ANP([1], h, QQ), ANP([1,0], h, QQ)], 6),
])
h = [QQ(1, 1), QQ(0, 1), QQ(1, 1)]
K = QQ.algebraic_field(I)
f = [ANP([QQ(4, 1)], h, QQ), ANP([], h, QQ), ANP([QQ(9, 1)], h, QQ)]
assert dup_ext_factor(f, K) == \
(ANP([QQ(4,1)], h, QQ), [
([ANP([QQ(1,1)], h, QQ), ANP([-QQ(3,2), QQ(0,1)], h, QQ)], 1),
([ANP([QQ(1,1)], h, QQ), ANP([ QQ(3,2), QQ(0,1)], h, QQ)], 1),
])
f = [
ANP([QQ(4, 1)], h, QQ),
ANP([QQ(8, 1)], h, QQ),
ANP([QQ(77, 1)], h, QQ),
ANP([QQ(18, 1)], h, QQ),
ANP([QQ(153, 1)], h, QQ)
]
assert dup_ext_factor(f, K) == \
(ANP([QQ(4,1)], h, QQ), [
([ANP([QQ(1,1)], h, QQ), ANP([-QQ(4,1), QQ(1,1)], h, QQ)], 1),
([ANP([QQ(1,1)], h, QQ), ANP([-QQ(3,2), QQ(0,1)], h, QQ)], 1),
([ANP([QQ(1,1)], h, QQ), ANP([ QQ(3,2), QQ(0,1)], h, QQ)], 1),
([ANP([QQ(1,1)], h, QQ), ANP([ QQ(4,1), QQ(1,1)], h, QQ)], 1),
])
def anp(x):
return ANP(x, [QQ(1), QQ(0), QQ(-2)], QQ)
def test_ANP_arithmetics():
mod = [QQ(1), QQ(0), QQ(0), QQ(-2)]
a = ANP([QQ(2), QQ(-1), QQ(1)], mod, QQ)
b = ANP([QQ(1), QQ(2)], mod, QQ)
c = ANP([QQ(-2), QQ(1), QQ(-1)], mod, QQ)
assert a.neg() == -a == c
c = ANP([QQ(2), QQ(0), QQ(3)], mod, QQ)
assert a.add(b) == a + b == c
assert b.add(a) == b + a == c
c = ANP([QQ(2), QQ(-2), QQ(-1)], mod, QQ)
assert a.sub(b) == a - b == c
c = ANP([QQ(-2), QQ(2), QQ(1)], mod, QQ)
assert b.sub(a) == b - a == c
c = ANP([QQ(3), QQ(-1), QQ(6)], mod, QQ)
assert a.mul(b) == a * b == c
assert b.mul(a) == b * a == c
c = ANP([QQ(-1, 43), QQ(9, 43), QQ(5, 43)], mod, QQ)
assert a.pow(0) == a**(0) == ANP(1, mod, QQ)
assert a.pow(1) == a**(1) == a
assert a.pow(-1) == a**(-1) == c
assert a.quo(a) == a.mul(a.pow(-1)) == a * a**(-1) == ANP(1, mod, QQ)
c = ANP([], [1, 0, 0, -2], QQ)
r1 = a.rem(b)
(q, r2) = a.div(b)
assert r1 == r2 == c == a % b
raises(NotInvertible, lambda: a.div(c))
raises(NotInvertible, lambda: a.rem(c))
# Comparison with "hard-coded" value fails despite looking identical
# from sympy import Rational
# c = ANP([Rational(11, 10), Rational(-1, 5), Rational(-3, 5)], [1, 0, 0, -2], QQ)
assert q == a / b # == c
def anp(element):
return ANP(element, [QQ(1), QQ(0), QQ(1)], QQ)
