def test_dmp_sqr():
assert dmp_sqr([ZZ(1),ZZ(2)], 0, ZZ) == \
dup_sqr([ZZ(1),ZZ(2)], ZZ)
assert dmp_sqr([[[]]], 2, ZZ) == [[[]]]
assert dmp_sqr([[[ZZ(2)]]], 2, ZZ) == [[[ZZ(4)]]]
assert dmp_sqr([[[]]], 2, QQ) == [[[]]]
assert dmp_sqr([[[QQ(2,3)]]], 2, QQ) == [[[QQ(4,9)]]]
def test_dup_ff_div():
raises(ZeroDivisionError, "dup_ff_div([1,2,3], [], QQ)")
f = dup_normal([3,1,1,5], QQ)
g = dup_normal([5,-3,1], QQ)
q = [QQ(3,5), QQ(14,25)]
r = [QQ(52,25), QQ(111,25)]
assert dup_ff_div(f, g, QQ) == (q, r)
def test_dup_neg():
assert dup_neg([], ZZ) == []
assert dup_neg([ZZ(1)], ZZ) == [ZZ(-1)]
assert dup_neg([ZZ(-7)], ZZ) == [ZZ(7)]
assert dup_neg([ZZ(-1),ZZ(2),ZZ(3)], ZZ) == [ZZ(1),ZZ(-2),ZZ(-3)]
assert dup_neg([], QQ) == []
assert dup_neg([QQ(1,2)], QQ) == [QQ(-1,2)]
assert dup_neg([QQ(-7,9)], QQ) == [QQ(7,9)]
assert dup_neg([QQ(-1,7),QQ(2,7),QQ(3,7)], QQ) == [QQ(1,7),QQ(-2,7),QQ(-3,7)]
def test_dup_abs():
assert dup_abs([], ZZ) == []
assert dup_abs([ZZ( 1)], ZZ) == [ZZ(1)]
assert dup_abs([ZZ(-7)], ZZ) == [ZZ(7)]
assert dup_abs([ZZ(-1),ZZ(2),ZZ(3)], ZZ) == [ZZ(1),ZZ(2),ZZ(3)]
assert dup_abs([], QQ) == []
assert dup_abs([QQ( 1,2)], QQ) == [QQ(1,2)]
assert dup_abs([QQ(-7,3)], QQ) == [QQ(7,3)]
assert dup_abs([QQ(-1,7),QQ(2,7),QQ(3,7)], QQ) == [QQ(1,7),QQ(2,7),QQ(3,7)]
def test_to_algebraic_integer():
a = AlgebraicNumber(sqrt(3), gen=x).to_algebraic_integer()
assert a.minpoly == x**2 - 3
assert a.root == sqrt(3)
assert a.rep == DMP([QQ(1), QQ(0)], QQ)
a = AlgebraicNumber(2 * sqrt(3), gen=x).to_algebraic_integer()
assert a.minpoly == x**2 - 12
assert a.root == 2 * sqrt(3)
assert a.rep == DMP([QQ(1), QQ(0)], QQ)
a = AlgebraicNumber(sqrt(3) / 2, gen=x).to_algebraic_integer()
assert a.minpoly == x**2 - 12
assert a.root == 2 * sqrt(3)
assert a.rep == DMP([QQ(1), QQ(0)], QQ)
a = AlgebraicNumber(sqrt(3) / 2, [S(7) / 19, 3],
gen=x).to_algebraic_integer()
assert a.minpoly == x**2 - 12
assert a.root == 2 * sqrt(3)
assert a.rep == DMP([QQ(7, 19), QQ(3)], QQ)
def test_DUP___eq__():
assert DUP([ZZ(1),ZZ(2),ZZ(3)], ZZ) == \
DUP([ZZ(1),ZZ(2),ZZ(3)], ZZ)
assert DUP([QQ(1),QQ(2),QQ(3)], QQ) == \
DUP([ZZ(1),ZZ(2),ZZ(3)], ZZ)
assert DUP([ZZ(1),ZZ(2),ZZ(3)], ZZ) == \
DUP([QQ(1),QQ(2),QQ(3)], QQ)
assert DUP([ZZ(1),ZZ(2),ZZ(4)], ZZ) != \
DUP([ZZ(1),ZZ(2),ZZ(3)], ZZ)
assert DUP([QQ(1),QQ(2),QQ(4)], QQ) != \
DUP([ZZ(1),ZZ(2),ZZ(3)], ZZ)
def test_DUP_properties():
assert DUP([QQ(0)], QQ).is_zero == True
assert DUP([QQ(1)], QQ).is_zero == False
assert DUP([QQ(1)], QQ).is_one == True
assert DUP([QQ(2)], QQ).is_one == False
assert DUP([1], ZZ).is_ground == True
assert DUP([1,2,1], ZZ).is_ground == False
assert DUP([1,2,2], ZZ).is_sqf == True
assert DUP([1,2,1], ZZ).is_sqf == False
assert DUP([1,2,3], ZZ).is_monic == True
assert DUP([2,2,3], ZZ).is_monic == False
assert DUP([1,2,3], ZZ).is_primitive == True
assert DUP([2,4,6], ZZ).is_primitive == False
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_dmp_mul_term():
assert dmp_mul_term([ZZ(1),ZZ(2),ZZ(3)], ZZ(2), 1, 0, ZZ) == \
dup_mul_term([ZZ(1),ZZ(2),ZZ(3)], ZZ(2), 1, ZZ)
assert dmp_mul_term([[]], [ZZ(2)], 3, 1, ZZ) == [[]]
assert dmp_mul_term([[ZZ(1)]], [], 3, 1, ZZ) == [[]]
assert dmp_mul_term([[ZZ(1),ZZ(2)], [ZZ(3)]], [ZZ(2)], 2, 1, ZZ) == \
[[ZZ(2),ZZ(4)], [ZZ(6)], [], []]
assert dmp_mul_term([[]], [QQ(2,3)], 3, 1, QQ) == [[]]
assert dmp_mul_term([[QQ(1,2)]], [], 3, 1, QQ) == [[]]
assert dmp_mul_term([[QQ(1,5),QQ(2,5)], [QQ(3,5)]], [QQ(2,3)], 2, 1, QQ) == \
[[QQ(2,15),QQ(4,15)], [QQ(6,15)], [], []]
def test_dup_quo_ground():
raises(ZeroDivisionError, 'dup_quo_ground(dup_normal([1,2,3], ZZ), ZZ(0), ZZ)')
raises(ExactQuotientFailed, 'dup_quo_ground(dup_normal([1,2,3], ZZ), ZZ(3), ZZ)')
f = dup_normal([], ZZ)
assert dup_quo_ground(f, ZZ(3), ZZ) == dup_normal([], ZZ)
f = dup_normal([6,2,8], ZZ)
assert dup_quo_ground(f, ZZ(1), ZZ) == f
assert dup_quo_ground(f, ZZ(2), ZZ) == dup_normal([3,1,4], ZZ)
f = dup_normal([6,2,8], QQ)
assert dup_quo_ground(f, QQ(1), QQ) == f
assert dup_quo_ground(f, QQ(2), QQ) == [QQ(3),QQ(1),QQ(4)]
assert dup_quo_ground(f, QQ(7), QQ) == [QQ(6,7),QQ(2,7),QQ(8,7)]
def test_dup_sqr():
assert dup_sqr([], ZZ) == []
assert dup_sqr([ZZ(2)], ZZ) == [ZZ(4)]
assert dup_sqr([ZZ(1),ZZ(2)], ZZ) == [ZZ(1),ZZ(4),ZZ(4)]
assert dup_sqr([], QQ) == []
assert dup_sqr([QQ(2,3)], QQ) == [QQ(4,9)]
assert dup_sqr([QQ(1,3),QQ(2,3)], QQ) == [QQ(1,9),QQ(4,9),QQ(4,9)]
f = dup_normal([2,0,0,1,7], ZZ)
assert dup_sqr(f, ZZ) == dup_normal([4,0,0,4,28,0,1,14,49], ZZ)
def test_DMP___eq__():
assert DMP([[ZZ(1),ZZ(2)],[ZZ(3)]], ZZ) == \
DMP([[ZZ(1),ZZ(2)],[ZZ(3)]], ZZ)
assert DMP([[ZZ(1),ZZ(2)],[ZZ(3)]], ZZ) == \
DMP([[QQ(1),QQ(2)],[QQ(3)]], QQ)
assert DMP([[QQ(1),QQ(2)],[QQ(3)]], QQ) == \
DMP([[ZZ(1),ZZ(2)],[ZZ(3)]], ZZ)
assert DMP([[[ZZ(1)]]], ZZ) != DMP([[ZZ(1)]], ZZ)
assert DMP([[ZZ(1)]], ZZ) != DMP([[[ZZ(1)]]], ZZ)
def test_dmp_neg():
assert dmp_neg([ZZ(-1)], 0, ZZ) == [ZZ(1)]
assert dmp_neg([QQ(-1,2)], 0, QQ) == [QQ(1,2)]
assert dmp_neg([[[]]], 2, ZZ) == [[[]]]
assert dmp_neg([[[ZZ(1)]]], 2, ZZ) == [[[ZZ(-1)]]]
assert dmp_neg([[[ZZ(-7)]]], 2, ZZ) == [[[ZZ(7)]]]
assert dmp_neg([[[]]], 2, QQ) == [[[]]]
assert dmp_neg([[[QQ(1,9)]]], 2, QQ) == [[[QQ(-1,9)]]]
assert dmp_neg([[[QQ(-7,9)]]], 2, QQ) == [[[QQ(7,9)]]]
def test_dmp_pow():
assert dmp_pow([[]], 0, 1, ZZ) == [[ZZ(1)]]
assert dmp_pow([[]], 0, 1, QQ) == [[QQ(1)]]
assert dmp_pow([[]], 1, 1, ZZ) == [[]]
assert dmp_pow([[]], 7, 1, ZZ) == [[]]
assert dmp_pow([[ZZ(1)]], 0, 1, ZZ) == [[ZZ(1)]]
assert dmp_pow([[ZZ(1)]], 1, 1, ZZ) == [[ZZ(1)]]
assert dmp_pow([[ZZ(1)]], 7, 1, ZZ) == [[ZZ(1)]]
assert dmp_pow([[QQ(3,7)]], 0, 1, QQ) == [[QQ(1,1)]]
assert dmp_pow([[QQ(3,7)]], 1, 1, QQ) == [[QQ(3,7)]]
assert dmp_pow([[QQ(3,7)]], 7, 1, QQ) == [[QQ(2187,823543)]]
f = dup_normal([2,0,0,1,7], ZZ)
assert dmp_pow(f, 2, 0, ZZ) == dup_pow(f, 2, ZZ)
def test_DUP___init__():
f = DUP([0,0,1,2,3], ZZ)
assert f.rep == [1,2,3]
assert f.dom == ZZ
f = DUP({2: QQ(1), 0: QQ(1)}, QQ)
assert f.rep == [QQ(1),QQ(0),QQ(1)]
assert f.dom == QQ
f = DUP(1, QQ)
assert f.rep == [QQ(1)]
assert f.dom == QQ
def test_dup_mul():
assert dup_mul([], [], ZZ) == []
assert dup_mul([], [ZZ(1)], ZZ) == []
assert dup_mul([ZZ(1)], [], ZZ) == []
assert dup_mul([ZZ(1)], [ZZ(1)], ZZ) == [ZZ(1)]
assert dup_mul([ZZ(5)], [ZZ(7)], ZZ) == [ZZ(35)]
assert dup_mul([], [], QQ) == []
assert dup_mul([], [QQ(1,2)], QQ) == []
assert dup_mul([QQ(1,2)], [], QQ) == []
assert dup_mul([QQ(1,2)], [QQ(4,7)], QQ) == [QQ(2,7)]
assert dup_mul([QQ(5,7)], [QQ(3,7)], QQ) == [QQ(15,49)]
f = dup_normal([3,0,0,6,1,2], ZZ)
g = dup_normal([4,0,1,0], ZZ)
h = dup_normal([12,0,3,24,4,14,1,2,0], ZZ)
assert dup_mul(f, g, ZZ) == h
assert dup_mul(g, f, ZZ) == h
f = dup_normal([2,0,0,1,7], ZZ)
h = dup_normal([4,0,0,4,28,0,1,14,49], ZZ)
assert dup_mul(f, f, ZZ) == h
def test_DUP_functionality():
f = DUP([1,2,3,4], ZZ)
g = DUP([3,4,3], ZZ)
assert f.degree() == 3
assert f.LC() == ZZ(1)
assert f.TC() == ZZ(4)
assert f.nth(1) == ZZ(3)
raises(TypeError, "f.nth('x')")
assert f.max_norm() == ZZ(4)
assert f.l1_norm() == ZZ(10)
assert f.diff(1) == g
assert f.eval(1) == ZZ(10)
raises(TypeError, "f.diff('x')")
f = DUP([QQ(2),QQ(0)], QQ)
g = DUP([QQ(1),QQ(0),QQ(-16)], QQ)
s = DUP([QQ(1,32),QQ(0)], QQ)
t = DUP([QQ(-1,16)], QQ)
h = DUP([QQ(1)], QQ)
assert f.half_gcdex(g) == (s, h)
assert f.gcdex(g) == (s, t, h)
assert f.invert(g) == s
f = DUP([1,-2,1], ZZ)
g = DUP([1,0,-1], ZZ)
a = DUP([2,-2], ZZ)
assert f.subresultants(g) == [f, g, a]
assert f.resultant(g) == 0
f = DUP([1,3,9,-13], ZZ)
assert f.discriminant() == -11664
f = DUP([1,2,1], ZZ)
g = DUP([1,1], ZZ)
h = DUP([1], ZZ)
assert f.cofactors(g) == (g, g, h)
assert f.gcd(g) == g
assert f.lcm(g) == f
assert f.sqf_part() == g
assert f.sqf_list() == (ZZ(1), [(g, 2)])
f = DUP([1,2,3,4,5,6], ZZ)
assert f.trunc(3) == DUP([1,-1,0,1,-1,0], ZZ)
f = DUP([QQ(3),QQ(-6)], QQ)
g = DUP([QQ(1),QQ(-2)], QQ)
assert f.monic() == g
f = DUP([3,-6], ZZ)
g = DUP([1,-2], ZZ)
assert f.content() == ZZ(3)
assert f.primitive() == (ZZ(3), g)
f = DUP([1,0,20,0,150,0,500,0,625,-2,0,-10,9], ZZ)
g = DUP([1,0,0,-2,9], ZZ)
h = DUP([1,0,5,0], ZZ)
assert g.compose(h) == f
assert f.decompose() == [g, h]
f = DUP([QQ(1),QQ(0)], QQ)
assert f.sturm() == [f, DUP([QQ(1)], QQ)]
def test_dmp_factor_list():
assert dmp_factor_list([[]], 1, ZZ) == (ZZ(0), [])
assert dmp_factor_list([[]], 1, QQ) == (QQ(0), [])
assert dmp_factor_list([[]], 1, ZZ['y']) == (DMP([], ZZ), [])
assert dmp_factor_list([[]], 1, QQ['y']) == (DMP([], QQ), [])
assert dmp_factor_list([[]], 1, ZZ, include=True) == [([[]], 1)]
assert dmp_factor_list([[ZZ(7)]], 1, ZZ) == (ZZ(7), [])
assert dmp_factor_list([[QQ(1, 7)]], 1, QQ) == (QQ(1, 7), [])
assert dmp_factor_list([[DMP([ZZ(7)], ZZ)]], 1, ZZ['y']) == (DMP([ZZ(7)],
ZZ), [])
assert dmp_factor_list([[DMP([QQ(1, 7)], QQ)]], 1,
QQ['y']) == (DMP([QQ(1, 7)], QQ), [])
assert dmp_factor_list([[ZZ(7)]], 1, ZZ, include=True) == [([[ZZ(7)]], 1)]
f, g = [ZZ(1), ZZ(2), ZZ(1)], [ZZ(1), ZZ(1)]
assert dmp_factor_list(dmp_nest(f, 200, ZZ), 200, ZZ) == \
(ZZ(1), [(dmp_nest(g, 200, ZZ), 2)])
assert dmp_factor_list(dmp_raise(f, 200, 0, ZZ), 200, ZZ) == \
(ZZ(1), [(dmp_raise(g, 200, 0, ZZ), 2)])
assert dmp_factor_list([ZZ(1),ZZ(2),ZZ(1)], 0, ZZ) == \
(ZZ(1), [([ZZ(1), ZZ(1)], 2)])
assert dmp_factor_list([QQ(1,2),QQ(1),QQ(1,2)], 0, QQ) == \
(QQ(1,2), [([QQ(1),QQ(1)], 2)])
assert dmp_factor_list([[ZZ(1)],[ZZ(2)],[ZZ(1)]], 1, ZZ) == \
(ZZ(1), [([[ZZ(1)], [ZZ(1)]], 2)])
assert dmp_factor_list([[QQ(1,2)],[QQ(1)],[QQ(1,2)]], 1, QQ) == \
(QQ(1,2), [([[QQ(1)],[QQ(1)]], 2)])
f = [[ZZ(4), ZZ(0)], [ZZ(4), ZZ(0), ZZ(0)], []]
assert dmp_factor_list(f, 1, ZZ) == \
(ZZ(4), [([[ZZ(1)],[]], 1),
([[ZZ(1),ZZ(0)]], 1),
([[ZZ(1)],[ZZ(1),ZZ(0)]], 1)])
assert dmp_factor_list(f, 1, ZZ, include=True) == \
[([[ZZ(4)],[]], 1),
([[ZZ(1),ZZ(0)]], 1),
([[ZZ(1)],[ZZ(1),ZZ(0)]], 1)]
f = [[QQ(1, 2), QQ(0)], [QQ(1, 2), QQ(0), QQ(0)], []]
assert dmp_factor_list(f, 1, QQ) == \
(QQ(1,2), [([[QQ(1)],[]], 1),
([[QQ(1),QQ(0)]], 1),
([[QQ(1)],[QQ(1),QQ(0)]], 1)])
f = [[RR(2.0)], [], [-RR(8.0), RR(0.0), RR(0.0)]]
assert dmp_factor_list(f, 1, RR) == \
(RR(2.0), [([[RR(1.0)],[-RR(2.0),RR(0.0)]], 1),
([[RR(1.0)],[ RR(2.0),RR(0.0)]], 1)])
f = [[DMP([ZZ(4), ZZ(0)], ZZ)], [DMP([ZZ(4), ZZ(0), ZZ(0)], ZZ)],
[DMP([], ZZ)]]
assert dmp_factor_list(f, 1, ZZ['y']) == \
(DMP([ZZ(4)],ZZ), [([[DMP([ZZ(1)],ZZ)],[]], 1),
([[DMP([ZZ(1),ZZ(0)],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 dmp_factor_list(f, 1, QQ['y']) == \
(DMP([QQ(1,2)],QQ), [([[DMP([QQ(1)],QQ)],[]], 1),
([[DMP([QQ(1),QQ(0)],QQ)]], 1),
([[DMP([QQ(1)],QQ)],[DMP([QQ(1),QQ(0)],QQ)]], 1)])
raises(DomainError, "dmp_factor_list([[EX(sin(1))]], 1, 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([], ZZ, include=True) == [([], 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([ZZ(7)], ZZ, include=True) == [([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([ZZ(1),ZZ(2),ZZ(1)], ZZ, include=True) == \
[([ZZ(1), ZZ(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),DMP([],ZZ)], 1),
([DMP([ZZ(1),ZZ(0)],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),DMP([],QQ)], 1),
([DMP([QQ(1),QQ(0)],QQ)], 1),
([DMP([QQ(1)],QQ),DMP([QQ(1),QQ(0)],QQ)], 1)])
raises(DomainError, "dup_factor_list([EX(sin(1))], EX)")
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___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_dup_pow():
assert dup_pow([], 0, ZZ) == [ZZ(1)]
assert dup_pow([], 0, QQ) == [QQ(1)]
assert dup_pow([], 1, ZZ) == []
assert dup_pow([], 7, ZZ) == []
assert dup_pow([ZZ(1)], 0, ZZ) == [ZZ(1)]
assert dup_pow([ZZ(1)], 1, ZZ) == [ZZ(1)]
assert dup_pow([ZZ(1)], 7, ZZ) == [ZZ(1)]
assert dup_pow([ZZ(3)], 0, ZZ) == [ZZ(1)]
assert dup_pow([ZZ(3)], 1, ZZ) == [ZZ(3)]
assert dup_pow([ZZ(3)], 7, ZZ) == [ZZ(2187)]
assert dup_pow([QQ(1,1)], 0, QQ) == [QQ(1,1)]
assert dup_pow([QQ(1,1)], 1, QQ) == [QQ(1,1)]
assert dup_pow([QQ(1,1)], 7, QQ) == [QQ(1,1)]
assert dup_pow([QQ(3,7)], 0, QQ) == [QQ(1,1)]
assert dup_pow([QQ(3,7)], 1, QQ) == [QQ(3,7)]
assert dup_pow([QQ(3,7)], 7, QQ) == [QQ(2187,823543)]
f = dup_normal([2,0,0,1,7], ZZ)
assert dup_pow(f, 0, ZZ) == dup_normal([1], ZZ)
assert dup_pow(f, 1, ZZ) == dup_normal([2,0,0,1,7], ZZ)
assert dup_pow(f, 2, ZZ) == dup_normal([4,0,0,4,28,0,1,14,49], ZZ)
assert dup_pow(f, 3, ZZ) == dup_normal([8,0,0,12,84,0,6,84,294,1,21,147,343], ZZ)
def test_DMP_functionality():
f = DMP([[1],[2,0],[1,0,0]], ZZ)
g = DMP([[1],[1,0]], ZZ)
h = DMP([[1]], ZZ)
assert f.degree() == 2
assert f.degree_list() == (2, 2)
assert f.total_degree() == 4
assert f.LC() == ZZ(1)
assert f.TC() == ZZ(0)
assert f.nth(1, 1) == ZZ(2)
raises(TypeError, "f.nth(0, 'x')")
assert f.max_norm() == 2
assert f.l1_norm() == 4
u = DMP([[2],[2,0]], ZZ)
assert f.diff(m=1, j=0) == u
assert f.diff(m=1, j=1) == u
raises(TypeError, "f.diff(m='x', j=0)")
u = DMP([1,2,1], ZZ)
v = DMP([1,2,1], ZZ)
assert f.eval(a=1, j=0) == u
assert f.eval(a=1, j=1) == v
assert f.eval(1).eval(1) == ZZ(4)
assert f.cofactors(g) == (g, g, h)
assert f.gcd(g) == g
assert f.lcm(g) == f
u = DMP([[QQ(45),QQ(30),QQ(5)]], QQ)
v = DMP([[QQ(1),QQ(2,3),QQ(1,9)]], QQ)
assert u.monic() == v
assert (4*f).content() == ZZ(4)
assert (4*f).primitive() == (ZZ(4), f)
f = DMP([[1],[2],[3],[4],[5],[6]], ZZ)
assert f.trunc(3) == DMP([[1],[-1],[],[1],[-1],[]], ZZ)
f = DMP(f_4, ZZ)
assert f.sqf_part() == -f
assert f.sqf_list() == (ZZ(-1), [(-f, 1)])
f = DMP([[-1],[],[],[5]], ZZ)
g = DMP([[3,1],[],[]], ZZ)
h = DMP([[45,30,5]], ZZ)
r = DMP([675,675,225,25], ZZ)
assert f.subresultants(g) == [f, g, h]
assert f.resultant(g) == r
f = DMP([1,3,9,-13], ZZ)
assert f.discriminant() == -11664
f = DMP([QQ(2),QQ(0)], QQ)
g = DMP([QQ(1),QQ(0),QQ(-16)], QQ)
s = DMP([QQ(1,32),QQ(0)], QQ)
t = DMP([QQ(-1,16)], QQ)
h = DMP([QQ(1)], QQ)
assert f.half_gcdex(g) == (s, h)
assert f.gcdex(g) == (s, t, h)
assert f.invert(g) == s
f = DMP([[1],[2],[3]], QQ)
raises(ValueError, "f.half_gcdex(f)")
raises(ValueError, "f.gcdex(f)")
raises(ValueError, "f.invert(f)")
f = DMP([1,0,20,0,150,0,500,0,625,-2,0,-10,9], ZZ)
g = DMP([1,0,0,-2,9], ZZ)
h = DMP([1,0,5,0], ZZ)
assert g.compose(h) == f
assert f.decompose() == [g, h]
f = DMP([[1],[2],[3]], QQ)
raises(ValueError, "f.decompose()")
raises(ValueError, "f.sturm()")
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_dmp_ff_div():
raises(ZeroDivisionError, "dmp_ff_div([[1,2],[3]], [[]], 1, QQ)")
f = dmp_normal([[1], [], [1,0,0]], 1, QQ)
g = dmp_normal([[1], [-1,0]], 1, QQ)
q = [[QQ(1, 1)], [QQ(1, 1), QQ(0, 1)]]
r = [[QQ(2, 1), QQ(0, 1), QQ(0, 1)]]
assert dmp_ff_div(f, g, 1, QQ) == (q, r)
f = dmp_normal([[1], [], [1,0,0]], 1, QQ)
g = dmp_normal([[-1], [1,0]], 1, QQ)
q = [[QQ(-1, 1)], [QQ(-1, 1), QQ(0, 1)]]
r = [[QQ(2, 1), QQ(0, 1), QQ(0, 1)]]
assert dmp_ff_div(f, g, 1, QQ) == (q, r)
f = dmp_normal([[1], [], [1,0,0]], 1, QQ)
g = dmp_normal([[2], [-2,0]], 1, QQ)
q = [[QQ(1, 2)], [QQ(1, 2), QQ(0, 1)]]
r = [[QQ(2, 1), QQ(0, 1), QQ(0, 1)]]
assert dmp_ff_div(f, g, 1, QQ) == (q, r)
def test_dmp_mul():
assert dmp_mul([ZZ(5)], [ZZ(7)], 0, ZZ) == \
dup_mul([ZZ(5)], [ZZ(7)], ZZ)
assert dmp_mul([QQ(5,7)], [QQ(3,7)], 0, QQ) == \
dup_mul([QQ(5,7)], [QQ(3,7)], QQ)
assert dmp_mul([[[]]], [[[]]], 2, ZZ) == [[[]]]
assert dmp_mul([[[ZZ(1)]]], [[[]]], 2, ZZ) == [[[]]]
assert dmp_mul([[[]]], [[[ZZ(1)]]], 2, ZZ) == [[[]]]
assert dmp_mul([[[ZZ(2)]]], [[[ZZ(1)]]], 2, ZZ) == [[[ZZ(2)]]]
assert dmp_mul([[[ZZ(1)]]], [[[ZZ(2)]]], 2, ZZ) == [[[ZZ(2)]]]
assert dmp_mul([[[]]], [[[]]], 2, QQ) == [[[]]]
assert dmp_mul([[[QQ(1,2)]]], [[[]]], 2, QQ) == [[[]]]
assert dmp_mul([[[]]], [[[QQ(1,2)]]], 2, QQ) == [[[]]]
assert dmp_mul([[[QQ(2,7)]]], [[[QQ(1,3)]]], 2, QQ) == [[[QQ(2,21)]]]
assert dmp_mul([[[QQ(1,7)]]], [[[QQ(2,3)]]], 2, QQ) == [[[QQ(2,21)]]]
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_AlgebraicNumber():
minpoly, root = x**2 - 2, sqrt(2)
a = AlgebraicNumber(root, gen=x)
assert a.rep == DMP([QQ(1),QQ(0)], QQ)
assert a.root == root
assert a.alias is None
assert a.minpoly == minpoly
assert a.is_aliased == False
assert a.coeffs() == [S(1), S(0)]
assert a.native_coeffs() == [QQ(1), QQ(0)]
a = AlgebraicNumber(root, gen=x, alias='y')
assert a.rep == DMP([QQ(1),QQ(0)], QQ)
assert a.root == root
assert a.alias == Symbol('y')
assert a.minpoly == minpoly
assert a.is_aliased == True
a = AlgebraicNumber(root, gen=x, alias=Symbol('y'))
assert a.rep == DMP([QQ(1),QQ(0)], QQ)
assert a.root == root
assert a.alias == Symbol('y')
assert a.minpoly == minpoly
assert a.is_aliased == True
assert AlgebraicNumber(sqrt(2), []).rep == DMP([], QQ)
assert AlgebraicNumber(sqrt(2), [8]).rep == DMP([QQ(8)], QQ)
assert AlgebraicNumber(sqrt(2), [S(8)/3]).rep == DMP([QQ(8,3)], QQ)
assert AlgebraicNumber(sqrt(2), [7, 3]).rep == DMP([QQ(7),QQ(3)], QQ)
assert AlgebraicNumber(sqrt(2), [S(7)/9, S(3)/2]).rep == DMP([QQ(7,9),QQ(3,2)], QQ)
assert AlgebraicNumber(sqrt(2), [1, 2, 3]).rep == DMP([QQ(2),QQ(5)], QQ)
a = AlgebraicNumber(AlgebraicNumber(root, gen=x), [1,2])
assert a.rep == DMP([QQ(1),QQ(2)], QQ)
assert a.root == root
assert a.alias is None
assert a.minpoly == minpoly
assert a.is_aliased == False
assert a.coeffs() == [S(1), S(2)]
assert a.native_coeffs() == [QQ(1), QQ(2)]
a = AlgebraicNumber((minpoly, root), [1,2])
assert a.rep == DMP([QQ(1),QQ(2)], QQ)
assert a.root == root
assert a.alias is None
assert a.minpoly == minpoly
assert a.is_aliased == False
a = AlgebraicNumber((Poly(minpoly), root), [1,2])
assert a.rep == DMP([QQ(1),QQ(2)], QQ)
assert a.root == root
assert a.alias is None
assert a.minpoly == minpoly
assert a.is_aliased == False
assert AlgebraicNumber( sqrt(3)).rep == DMP([ QQ(1),QQ(0)], QQ)
assert AlgebraicNumber(-sqrt(3)).rep == DMP([-QQ(1),QQ(0)], QQ)
a = AlgebraicNumber(sqrt(2))
b = AlgebraicNumber(sqrt(2))
assert a == b and a == sqrt(2)
a = AlgebraicNumber(sqrt(2), gen=x)
b = AlgebraicNumber(sqrt(2), gen=x)
assert a == b and a == sqrt(2)
a = AlgebraicNumber(sqrt(2), [1,2])
b = AlgebraicNumber(sqrt(2), [1,3])
assert a != b and a != sqrt(2)+3
assert (a == x) == False and (a != x) == True
a = AlgebraicNumber(sqrt(2), [1,0])
b = AlgebraicNumber(sqrt(2), [1,0], alias=y)
assert a.as_poly(x) == Poly(x)
assert b.as_poly() == Poly(y)
assert a.as_basic() == sqrt(2)
assert a.as_basic(x) == x
assert b.as_basic() == sqrt(2)
assert b.as_basic(x) == x
a = AlgebraicNumber(sqrt(2), [2,3])
b = AlgebraicNumber(sqrt(2), [2,3], alias=y)
p = a.as_poly()
assert p == Poly(2*p.gen+3)
assert a.as_poly(x) == Poly(2*x+3)
assert b.as_poly() == Poly(2*y+3)
assert a.as_basic() == 2*sqrt(2)+3
assert a.as_basic(x) == 2*x+3
assert b.as_basic() == 2*sqrt(2)+3
assert b.as_basic(x) == 2*x+3
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_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),
])
