def test_modular():
assert solve_congruence(*list(zip([3, 4, 2], [12, 35, 17]))) == (1719,
7140)
assert solve_congruence(*list(zip([3, 4, 2], [12, 6, 17]))) is None
assert solve_congruence(*list(zip([3, 4, 2], [13, 7, 17]))) == (172, 1547)
assert solve_congruence(*list(zip([-10, -3, -15], [13, 7, 17]))) == (172,
1547)
assert solve_congruence(
*list(zip([-10, -3, 1, -15], [13, 7, 7, 17]))) is None
assert solve_congruence(
*list(zip([-10, -5, 2, -15], [13, 7, 7, 17]))) == (835, 1547)
assert solve_congruence(
*list(zip([-10, -5, 2, -15], [13, 7, 14, 17]))) == (2382, 3094)
assert solve_congruence(
*list(zip([-10, 2, 2, -15], [13, 7, 14, 17]))) == (2382, 3094)
assert solve_congruence(*list(zip((1, 1, 2), (3, 2, 4)))) is None
pytest.raises(
ValueError,
lambda: solve_congruence(*list(zip([3, 4, 2], [12.1, 35, 17]))))
assert integer_rational_reconstruction(ZZ(2), 3, ZZ) == QQ(-1)
assert integer_rational_reconstruction(ZZ(21), 33, ZZ) == QQ(-1)
assert integer_rational_reconstruction(ZZ(-21), 17, ZZ) == QQ(-4)
assert integer_rational_reconstruction(ZZ(17), 333, ZZ) is None
assert integer_rational_reconstruction(ZZ(49), 335, ZZ) == QQ(8, 7)
def test_dmp_mul_ground():
R, x = ring('x', ZZ)
f = 0
assert R.dmp_mul_ground(f, ZZ(2)) == 0
f = x**2 + 2 * x - 1
assert R.dmp_mul_ground(f, ZZ(3)) == 3 * x**2 + 6 * x - 3
f = x**2 + 2 * x + 3
assert R.dmp_mul_ground(f, ZZ(0)) == 0
assert R.dmp_mul_ground(f, ZZ(2)) == 2 * x**2 + 4 * x + 6
R, x, y, z = ring('x y z', ZZ)
f = f_polys()[0]
assert (R.dmp_mul_ground(f,
ZZ(2)) == 2 * x**2 * y * z**2 + 4 * x**2 * y * z +
6 * x**2 * y + 4 * x**2 + 6 * x + 8 * y**2 * z**2 + 10 * y**2 * z +
12 * y**2 + 2 * y * z**2 + 4 * y * z + 2 * y + 2)
R, x, y, z = ring('x y z', QQ)
f = f.set_ring(R) / 7
assert (R.dmp_mul_ground(f, QQ(
1, 2)) == x**2 * y * z**2 / 14 + x**2 * y * z / 7 + 3 * x**2 * y / 14 +
x**2 / 7 + 3 * x / 14 + 2 * y**2 * z**2 / 7 + 5 * y**2 * z / 14 +
3 * y**2 / 7 + y * z**2 / 14 + y * z / 7 + y / 14 + QQ(1, 14))
def test_dmp_eval_in():
R, x = ring('x', ZZ)
assert R.dmp_eval_in(0, ZZ(7), 0) == 0
assert R.dmp_eval_in(x + 2, ZZ(0), 0) == 2
assert R.dmp_eval_in(x**2 + 2 * x + 3, ZZ(7), 0) == 66
assert R.dmp_eval_in(x**2 + 2 * x + 3, ZZ(2), 0) == 11
assert R.dmp_eval_in(0, ZZ(3), 0) == 0
R, x, y = ring('x y', ZZ)
R1 = R.drop(x)
assert R.dmp_eval_in(0, 3, 0) == 0
assert R.dmp_eval_in(y + 2, 0, 0) == R1.y + 2
assert R.dmp_eval_in(3 * x * y + 2 * x + y + 2, 3, 0) == 10 * R1.y + 8
assert R.dmp_eval_in(2 * x * y + 3 * x + y + 2, 2, 0) == 5 * R1.y + 8
R, x, y, z = ring('x y z', ZZ)
R1 = R.drop(x)
R3 = R.drop(z)
assert R.dmp_eval_in(0, 3, 0) == 0
assert R.dmp_eval_in(1, 3, 0) == 1
assert R.dmp_eval_in(z + 2, 3, 0) == R1.z + 2
assert R.dmp_eval_in(3 * x * z + 2 * x + z + 2, 3, 0) == 10 * R1.z + 8
f = 45 * x**3 - 9 * y**3 - y**2 + 3 * z**3 + 10 * z
assert R.dmp_eval_in(f, -2, 2) == 45 * R3.x**3 - 9 * R3.y**3 - R3.y**2 - 44
pytest.raises(IndexError, lambda: R.dmp_eval_in(f, -2, -1))
R, x, y, z, t = ring('x y z t', ZZ)
f = f_polys()[6]
R2 = R.drop(y)
R3 = R.drop(z)
x, z, t = R2.gens
assert (R.dmp_eval_in(f, -2, 1) == -4230 * x**4 + 45 * x**3 * z**3 * t**2 -
45 * x**3 * t**2 - 282 * x * z**3 - 188 * x * z * t - 6392 * x +
3 * z**6 * t**2 + 2 * z**4 * t**3 + 65 * z**3 * t**2 -
2 * z * t**3 - 68 * t**2)
assert (R.dmp_eval_in(
f, 7, 1) == 14805 * x**4 + 45 * x**3 * z**3 * t**2 - 45 * x**3 * t**2 +
987 * x * z**3 + 658 * x * z * t - 1031744 * x + 3 * z**6 * t**2 +
2 * z**4 * t**3 - 3139 * z**3 * t**2 - 2 * z * t**3 + 3136 * t**2)
x, y, t = R3.gens
assert (R.dmp_eval_in(f, -2, 2) == 2115 * x**4 * y - 405 * x**3 * t**2 -
423 * x * y**4 - 47 * x * y**3 - 188 * x * y * t - 1128 * x * y +
81 * y**3 * t**2 + 9 * y**2 * t**2 + 36 * t**3 + 216 * t**2)
assert (R.dmp_eval_in(f, 7, 2) == 2115 * x**4 * y + 15390 * x**3 * t**2 -
423 * x * y**4 - 47 * x * y**3 + 658 * x * y * t + 48363 * x * y -
3078 * y**3 * t**2 - 342 * y**2 * t**2 + 4788 * t**3 +
351918 * t**2)
def test_dmp_grounds():
assert dmp_grounds(ZZ(7), 0, 2) == []
assert dmp_grounds(ZZ(7), 1, 2) == [[[[7]]]]
assert dmp_grounds(ZZ(7), 2, 2) == [[[[7]]], [[[7]]]]
assert dmp_grounds(ZZ(7), 3, 2) == [[[[7]]], [[[7]]], [[[7]]]]
assert dmp_grounds(ZZ(7), 3, -1) == [7, 7, 7]
def test_dmp_from_diofant():
assert dmp_from_diofant([Integer(1), Integer(2)], 0, ZZ) == [ZZ(1), ZZ(2)]
assert dmp_from_diofant([Rational(1, 2), Integer(3)], 0,
QQ) == [QQ(1, 2), QQ(3, 1)]
assert dmp_from_diofant([[Integer(1), Integer(2)], [Integer(0)]], 1,
ZZ) == [[ZZ(1), ZZ(2)], []]
assert dmp_from_diofant([[Rational(1, 2), Integer(2)]], 1,
QQ) == [[QQ(1, 2), QQ(2, 1)]]
def test_dmp_from_to_dict():
assert dmp_from_dict({}, 1, ZZ) == [[]]
assert dmp_to_dict([[]], 1) == {}
assert dmp_to_dict([], 0, ZZ, zero=True) == {(0, ): ZZ(0)}
assert dmp_to_dict([[]], 1, ZZ, zero=True) == {(0, 0): ZZ(0)}
f = [[3], [], [], [2], [], [], [], [], [8]]
g = {(8, 0): 3, (5, 0): 2, (0, 0): 8}
assert dmp_from_dict(g, 1, ZZ) == f
assert dmp_to_dict(f, 1) == g
def test_PolyElement_clear_denoms():
R, x, y = ring("x,y", QQ)
assert R(1).clear_denoms() == (ZZ(1), 1)
assert R(7).clear_denoms() == (ZZ(1), 7)
assert R(QQ(7, 3)).clear_denoms() == (3, 7)
assert R(QQ(7, 3)).clear_denoms() == (3, 7)
assert (3*x**2 + x).clear_denoms() == (1, 3*x**2 + x)
assert (x**2 + x/2).clear_denoms() == (2, 2*x**2 + x)
rQQ, x, t = ring("x,t", QQ)
rZZ, X, T = ring("x,t", ZZ)
F = [x - QQ(17824537287975195925064602467992950991718052713078834557692023531499318507213727406844943097, 413954288007559433755329699713866804710749652268151059918115348815925474842910720000)*t**7
- QQ(4882321164854282623427463828745855894130208215961904469205260756604820743234704900167747753, 12936071500236232304854053116058337647210926633379720622441104650497671088840960000)*t**6
- QQ(36398103304520066098365558157422127347455927422509913596393052633155821154626830576085097433, 25872143000472464609708106232116675294421853266759441244882209300995342177681920000)*t**5
- QQ(168108082231614049052707339295479262031324376786405372698857619250210703675982492356828810819, 58212321751063045371843239022262519412449169850208742800984970927239519899784320000)*t**4
- QQ(5694176899498574510667890423110567593477487855183144378347226247962949388653159751849449037, 1617008937529529038106756639507292205901365829172465077805138081312208886105120000)*t**3
- QQ(154482622347268833757819824809033388503591365487934245386958884099214649755244381307907779, 60637835157357338929003373981523457721301218593967440417692678049207833228942000)*t**2
- QQ(2452813096069528207645703151222478123259511586701148682951852876484544822947007791153163, 2425513406294293557160134959260938308852048743758697616707707121968313329157680)*t
- QQ(34305265428126440542854669008203683099323146152358231964773310260498715579162112959703, 202126117191191129763344579938411525737670728646558134725642260164026110763140),
t**8 + QQ(693749860237914515552, 67859264524169150569)*t**7
+ QQ(27761407182086143225024, 610733380717522355121)*t**6
+ QQ(7785127652157884044288, 67859264524169150569)*t**5
+ QQ(36567075214771261409792, 203577793572507451707)*t**4
+ QQ(36336335165196147384320, 203577793572507451707)*t**3
+ QQ(7452455676042754048000, 67859264524169150569)*t**2
+ QQ(2593331082514399232000, 67859264524169150569)*t
+ QQ(390399197427343360000, 67859264524169150569)]
G = [3725588592068034903797967297424801242396746870413359539263038139343329273586196480000*X -
160420835591776763325581422211936558925462474417709511019228211783493866564923546661604487873*T**7 -
1406108495478033395547109582678806497509499966197028487131115097902188374051595011248311352864*T**6 -
5241326875850889518164640374668786338033653548841427557880599579174438246266263602956254030352*T**5 -
10758917262823299139373269714910672770004760114329943852726887632013485035262879510837043892416*T**4 -
13119383576444715672578819534846747735372132018341964647712009275306635391456880068261130581248*T**3 -
9491412317016197146080450036267011389660653495578680036574753839055748080962214787557853941760*T**2 -
3767520915562795326943800040277726397326609797172964377014046018280260848046603967211258368000*T -
632314652371226552085897259159210286886724229880266931574701654721512325555116066073245696000,
610733380717522355121*T**8 +
6243748742141230639968*T**7 +
27761407182086143225024*T**6 +
70066148869420956398592*T**5 +
109701225644313784229376*T**4 +
109009005495588442152960*T**3 +
67072101084384786432000*T**2 +
23339979742629593088000*T +
3513592776846090240000]
assert [ f.clear_denoms()[1].set_ring(rZZ) for f in F ] == G
def test_FractionField_methods():
F = ZZ.frac_field("x")
assert F.domain_new(2) == ZZ(2)
x = symbols("x")
assert F.field_new(x**2 + x) == F.x**2 + F.x
def test_dmp_zz_wang():
R, x, y, z = ring("x,y,z", ZZ)
UV, _x = ring("x", ZZ)
p = ZZ(nextprime(R.dmp_zz_mignotte_bound(w_1)))
assert p == 6291469
t_1, k_1, e_1 = y, 1, ZZ(-14)
t_2, k_2, e_2 = z, 2, ZZ(3)
t_3, k_3, e_3 = y + z, 2, ZZ(-11)
t_4, k_4, e_4 = y - z, 1, ZZ(-17)
T = [t_1, t_2, t_3, t_4]
K = [k_1, k_2, k_3, k_4]
E = [e_1, e_2, e_3, e_4]
T = zip([t.drop(x) for t in T], K)
A = [ZZ(-14), ZZ(3)]
S = R.dmp_eval_tail(w_1, A)
cs, s = UV.dmp_ground_primitive(S)
assert cs == 1 and s == S == \
1036728*_x**6 + 915552*_x**5 + 55748*_x**4 + 105621*_x**3 - 17304*_x**2 - 26841*_x - 644
assert R.dmp_zz_wang_non_divisors(E, cs, ZZ(4)) == [7, 3, 11, 17]
assert s.is_squarefree and UV.dmp_degree_in(s, 0) == R.dmp_degree_in(
w_1, 0)
_, H = UV.dup_zz_factor_sqf(s)
h_1 = 44 * _x**2 + 42 * _x + 1
h_2 = 126 * _x**2 - 9 * _x + 28
h_3 = 187 * _x**2 - 23
assert H == [h_1, h_2, h_3]
LC = [lc.drop(x) for lc in [-4 * y - 4 * z, -y * z**2, y**2 - z**2]]
assert R.dmp_zz_wang_lead_coeffs(w_1, T, cs, E, H, A) == (w_1, H, LC)
# H_1 = [44*x**2 + 42*x + 1, 126*x**2 - 9*x + 28, 187*x**2 - 23]
# H_2 = [-4*x**2*y - 12*x**2 - 3*x*y + 1, -9*x**2*y - 9*x - 2*y, x**2*y**2 - 9*x**2 + y - 9]
# H_3 = [-4*x**2*y - 12*x**2 - 3*x*y + 1, -9*x**2*y - 9*x - 2*y, x**2*y**2 - 9*x**2 + y - 9]
# c_1 = -70686*x**5 - 5863*x**4 - 17826*x**3 + 2009*x**2 + 5031*x + 74
# c_2 = 9*x**5*y**4 + 12*x**5*y**3 - 45*x**5*y**2 - 108*x**5*y - 324*x**5 + 18*x**4*y**3 - 216*x**4*y**2 - 810*x**4*y + 2*x**3*y**4 + 9*x**3*y**3 - 252*x**3*y**2 - 288*x**3*y - 945*x**3 - 30*x**2*y**2 - 414*x**2*y + 2*x*y**3 - 54*x*y**2 - 3*x*y + 81*x + 12*y
# c_3 = -36*x**4*y**2 - 108*x**4*y - 27*x**3*y**2 - 36*x**3*y - 108*x**3 - 8*x**2*y**2 - 42*x**2*y - 6*x*y**2 + 9*x + 2*y
# TODO
# assert R.dmp_zz_diophantine(H_1, c_1, [], 5, p) == [-3*x, -2, 1]
# assert R.dmp_zz_diophantine(H_2, c_2, [ZZ(-14)], 5, p) == [-x*y, -3*x, -6]
# assert R.dmp_zz_diophantine(H_3, c_3, [ZZ(-14)], 5, p) == [0, 0, -1]
factors = R.dmp_zz_wang_hensel_lifting(w_1, H, LC, A, p)
assert R.dmp_expand(factors) == w_1
def test_dmp_convert():
K0, K1 = ZZ.poly_ring('x'), ZZ
assert dmp_convert([K0(1), K0(2)], 0, K0, K1) == [ZZ(1), ZZ(2)]
assert dmp_convert([K1(1), K1(2)], 0, K1, K0) == [K0(1), K0(2)]
f = [K0(1), K0(2), K0(0), K0(3)]
assert dmp_convert(f, 0, K0, K1) == [ZZ(1), ZZ(2), ZZ(0), ZZ(3)]
f = [[K0(1)], [K0(2)], [], [K0(3)]]
assert dmp_convert(f, 1, K0, K1) == [[ZZ(1)], [ZZ(2)], [], [ZZ(3)]]
def test_dup_zz_hensel_lift():
R, x = ring("x", ZZ)
f = x**4 - 1
F = [x - 1, x - 2, x + 2, x + 1]
assert R.dup_zz_hensel_lift(ZZ(5), f, F, 4) == \
[x - 1, x - 182, x + 182, x + 1]
def test_gf_ddf():
f = gf_from_dict({15: ZZ(1), 0: ZZ(-1)}, 11, ZZ)
g = [([1, 0, 0, 0, 0, 10], 1), ([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1], 2)]
assert gf_ddf_zassenhaus(f, 11, ZZ) == g
assert gf_ddf_shoup(f, 11, ZZ) == g
f = gf_from_dict({63: ZZ(1), 0: ZZ(1)}, 2, ZZ)
g = [([1, 1], 1), ([1, 1, 1], 2), ([1, 1, 1, 1, 1, 1, 1], 3),
([
1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1,
1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1
], 6)]
assert gf_ddf_zassenhaus(f, 2, ZZ) == g
assert gf_ddf_shoup(f, 2, ZZ) == g
f = gf_from_dict({
6: ZZ(1),
5: ZZ(-1),
4: ZZ(1),
3: ZZ(1),
1: ZZ(-1)
}, 3, ZZ)
g = [([1, 1, 0], 1), ([1, 1, 0, 1, 2], 2)]
assert gf_ddf_zassenhaus(f, 3, ZZ) == g
assert gf_ddf_shoup(f, 3, ZZ) == g
f = [1, 2, 5, 26, 677, 436, 791, 325, 456, 24, 577]
g = [([1, 701], 1), ([1, 110, 559, 532, 694, 151, 110, 70, 735, 122], 9)]
assert gf_ddf_zassenhaus(f, 809, ZZ) == g
assert gf_ddf_shoup(f, 809, ZZ) == g
p = ZZ(nextprime(int((2**15 * pi))))
f = gf_from_dict({15: 1, 1: 1, 0: 1}, p, ZZ)
g = [([1, 22730, 68144], 2),
([1, 64876, 83977, 10787, 12561, 68608, 52650, 88001, 84356], 4),
([1, 15347, 95022, 84569, 94508, 92335], 5)]
assert gf_ddf_zassenhaus(f, p, ZZ) == g
assert gf_ddf_shoup(f, p, ZZ) == g
def test_arithmetics():
assert ZZ.rem(ZZ(2), ZZ(3)) == 2
assert ZZ.div(ZZ(2), ZZ(3)) == (0, 2)
assert QQ.rem(QQ(2, 3), QQ(4, 7)) == 0
assert QQ.div(QQ(2, 3), QQ(4, 7)) == (QQ(7, 6), 0)
assert QQ_python.factorial(QQ_python(7, 2)) == 6
assert CC.gcd(CC(1), CC(2)) == 1
assert CC.lcm(CC(1), CC(2)) == 2
assert EX(Rational(2, 3)).numerator == 2
assert EX(Rational(2, 3)).denominator == 3
assert abs(EX(-2)) == 2
assert -EX(2) == -2
assert 2 + EX(3) == EX(3) + 2 == 5
assert 2 - EX(3) == EX(2) - 3 == -1
assert 2 * EX(3) == EX(3) * 2 == 6
assert 2 / EX(3) == EX(2) / 3 == EX(Rational(2, 3))
assert EX(2)**2 == 4
pytest.raises(TypeError, lambda: EX(2) + object())
pytest.raises(TypeError, lambda: EX(2) - object())
pytest.raises(TypeError, lambda: EX(2) * object())
pytest.raises(TypeError, lambda: EX(2)**object())
pytest.raises(TypeError, lambda: EX(2) / object())
F11 = FF(11)
assert +F11(2) == F11(2)
assert F11(5) + 7 == 7 + F11(5) == F11(1)
assert F11(5) - 7 == 5 - F11(7) == F11(9)
assert F11(5) * 7 == 7 * F11(5) == F11(2)
assert F11(5) / 9 == 5 / F11(9) == F11(3)
assert F11(4) % 9 == 4 % F11(9) == F11(4)
pytest.raises(TypeError, lambda: F11(2) + object())
pytest.raises(TypeError, lambda: F11(2) - object())
pytest.raises(TypeError, lambda: F11(2) * object())
pytest.raises(TypeError, lambda: F11(2)**object())
pytest.raises(TypeError, lambda: F11(2) / object())
pytest.raises(TypeError, lambda: F11(2) % object())
pytest.raises(TypeError, lambda: object() % F11(2))
def test_dmp_quo_ground():
R, x = ring('x', ZZ)
pytest.raises(ZeroDivisionError,
lambda: R.dmp_quo_ground(x**2 + 2 * x + 3, ZZ(0)))
f = 3 * x**2 + 2
assert R.dmp_quo_ground(f, ZZ(2)) == x**2 + 1
R, x = ring('x', QQ)
f = 3 * x**2 + 2
assert R.dmp_quo_ground(f, QQ(2)) == 3 * x**2 / 2 + 1
R, x = ring('x', ZZ)
f = 0
assert R.dmp_quo_ground(f, ZZ(3)) == 0
f = 6 * x**2 + 2 * x + 8
assert R.dmp_quo_ground(f, ZZ(1)) == f
assert R.dmp_quo_ground(f, ZZ(2)) == 3 * x**2 + x + 4
assert R.dmp_quo_ground(f, ZZ(3)) == 2 * x**2 + 2
R, x = ring('x', QQ)
f = 6 * x**2 + 2 * x + 8
assert R.dmp_quo_ground(f, QQ(1)) == f
assert R.dmp_quo_ground(f, QQ(2)) == 3 * x**2 + x + 4
assert R.dmp_quo_ground(f, QQ(7)) == 6 * x**2 / 7 + 2 * x / 7 + QQ(8, 7)
R, x, y = ring('x y', ZZ)
f = 6 * x**2 + 2 * x + 8
assert R.dmp_quo_ground(f, ZZ(1)) == f
assert R.dmp_quo_ground(f, ZZ(2)) == 3 * x**2 + x + 4
assert R.dmp_quo_ground(f, ZZ(3)) == 2 * x**2 + 2
def test_dmp_ground_trunc():
R, x = ring('x', ZZ)
assert R.dmp_ground_trunc(
x**5 + 2 * x**4 + 3 * x**3 + 4 * x**2 + 5 * x + 6,
ZZ(3)) == x**5 - x**4 + x**2 - x
assert R.dmp_ground_trunc(
6 * x**5 + 5 * x**4 + 4 * x**3 + 3 * x**2 + 2 * x + 1,
ZZ(3)) == -x**4 + x**3 - x + 1
R, x = ring('x', QQ)
assert R.dmp_ground_trunc(
x**5 + 2 * x**4 + 3 * x**3 + 4 * x**2 + 5 * x + 6,
ZZ(3)) == x**5 + 2 * x**4 + x**2 + 2 * x
R, x, y, z = ring('x y z', ZZ)
f = f_polys()[0]
assert R.dmp_ground_trunc(
f, ZZ(3)) == (x**2 * y * z**2 - x**2 * y * z - x**2 + y**2 * z**2 -
y**2 * z + y * z**2 - y * z + y + 1)
def test_Domain_convert():
assert QQ.convert(10e-52) == QQ(
1684996666696915,
1684996666696914987166688442938726917102321526408785780068975640576)
R, x = ring("x", ZZ)
assert ZZ.convert(x - x) == 0
assert ZZ.convert(x - x, R) == 0
F3 = FF(3)
assert F3.convert(Float(2.0)) == F3.dtype(2)
assert F3.convert(PythonRational(2, 1)) == F3.dtype(2)
pytest.raises(CoercionFailed, lambda: F3.convert(PythonRational(1, 2)))
assert F3.convert(2.0) == F3.dtype(2)
pytest.raises(CoercionFailed, lambda: F3.convert(2.1))
assert RR.convert(CC(1)) == RR(1)
pytest.raises(CoercionFailed, lambda: RR.convert(CC(1, 2)))
assert QQ.convert(ALG(1), ALG) == QQ(1)
pytest.raises(CoercionFailed, lambda: QQ.convert(ALG([1, 1]), ALG))
assert ZZ.convert(ALG(1), ALG) == ZZ(1)
pytest.raises(CoercionFailed, lambda: ZZ.convert(ALG([1, 1]), ALG))
assert EX.convert(ALG([1, 1]), ALG) == sqrt(2) + sqrt(3) + 1
ALG2 = QQ.algebraic_field(sqrt(2))
a2 = ALG2.convert(sqrt(2))
a = ALG.convert(a2, ALG2)
assert a.rep.to_dense() == [QQ(1, 2), 0, -QQ(9, 2), 0]
assert RR.convert(a) == RR(1.4142135623730951)
assert CC.convert(a) == CC(1.4142135623730951)
assert ZZ_python.convert(3.0) == ZZ_python.dtype(3)
pytest.raises(CoercionFailed, lambda: ZZ_python.convert(3.2))
assert CC.convert(QQ_python(1, 2)) == CC(0.5)
CC01 = ComplexField(tol=0.1)
assert CC.convert(CC01(0.3)) == CC(0.3)
assert RR.convert(complex(2 + 0j)) == RR(2)
pytest.raises(CoercionFailed, lambda: RR.convert(complex(2 + 3j)))
assert ALG.convert(EX(sqrt(2)), EX) == ALG.from_expr(sqrt(2))
pytest.raises(CoercionFailed, lambda: ALG.convert(EX(sqrt(5)), EX))
pytest.raises(CoercionFailed, lambda: ALG2.convert(ALG.unit))
def test_dmp_ground_p():
assert dmp_ground_p([], 0, 0) is True
assert dmp_ground_p([[]], 0, 1) is True
assert dmp_ground_p([[]], 1, 1) is False
assert dmp_ground_p([[ZZ(1)]], 1, 1) is True
assert dmp_ground_p([[[ZZ(2)]]], 2, 2) is True
assert dmp_ground_p([[[ZZ(2)]]], 3, 2) is False
assert dmp_ground_p([[[ZZ(3)], []]], 3, 2) is False
assert dmp_ground_p([], None, 0) is True
assert dmp_ground_p([[]], None, 1) is True
assert dmp_ground_p([ZZ(1)], None, 0) is True
assert dmp_ground_p([[[ZZ(1)]]], None, 2) is True
assert dmp_ground_p([[[ZZ(3)], []]], None, 2) is False
def test_dup_real_imag():
assert dup_real_imag([], ZZ) == ([[]], [[]])
assert dup_real_imag([ZZ(1)], ZZ) == ([[1]], [[]])
assert dup_real_imag([ZZ(1), ZZ(1)], ZZ) == ([[1], [1]], [[1, 0]])
assert dup_real_imag([ZZ(1), ZZ(2)], ZZ) == ([[1], [2]], [[1, 0]])
assert dup_real_imag([ZZ(1), ZZ(2), ZZ(3)], ZZ) == ([[1], [2], [-1, 0, 3]],
[[2, 0], [2, 0]])
f = dmp_normal([1, 1, 1, 1], 0, ZZ)
assert dup_real_imag(f, ZZ) == ([[1], [1], [-3, 0, 1], [-1, 0, 1]],
[[3, 0], [2, 0], [-1, 0, 1, 0]])
f = dmp_normal([1, 1], 0, EX)
pytest.raises(DomainError, lambda: dup_real_imag(f, EX))
A = QQ.algebraic_field(I)
f = [A(1), A(I), A(0), A(-1), A(1)]
assert dup_real_imag(f, A) == ([[1], [], [-6, -3, 0], [-1],
[1, 1, 0, 0, 1]],
[[4, 1], [], [-4, -3, 0, 0], [-1, 0]])
A = QQ.algebraic_field(sqrt(2))
f = [A(1), A(sqrt(2)), A(-1)]
assert dup_real_imag(f, A) == ([[1], [A.unit], [-1, 0, -1]],
[[2, 0], [A.unit, 0]])
A2 = A.algebraic_field(I)
f = [A2(1), A2(2*sqrt(2)*I), A2(I - 1)]
assert dup_real_imag(f, A2) == ([[1], [], [-1, -2*A.unit, -1]],
[[2, 2*A.unit], [1]])
def test_dmp_ground_monic():
assert dmp_ground_monic([ZZ(3), ZZ(6), ZZ(9)], 0, ZZ) == [1, 2, 3]
assert dmp_ground_monic([QQ(3), QQ(4), QQ(2)], 0, QQ) == [1, QQ(4, 3), QQ(2, 3)]
pytest.raises(ExactQuotientFailed, lambda: dmp_ground_monic([3, 4, 5], 0, ZZ))
assert dmp_ground_monic([], 0, QQ) == []
assert dmp_ground_monic([QQ(1)], 0, QQ) == [1]
assert dmp_ground_monic([QQ(7), QQ(1), QQ(21)], 0, QQ) == [1, QQ(1, 7), 3]
assert dmp_ground_monic([[ZZ(3)], [ZZ(6)], [ZZ(9)]], 1, ZZ) == [[1], [2], [3]]
pytest.raises(ExactQuotientFailed, lambda: dmp_ground_monic([[3], [4], [5]], 1, ZZ))
assert dmp_ground_monic([[]], 1, QQ) == [[]]
assert dmp_ground_monic([[QQ(1)]], 1, QQ) == [[1]]
assert dmp_ground_monic([[QQ(7)], [QQ(1)], [QQ(21)]], 1, QQ) == [[1], [QQ(1, 7)], [3]]
def test_dup_from_to_dict():
assert dup_from_dict({}, ZZ) == []
assert dmp_to_dict([], 0) == {}
assert dmp_to_dict([], 0, ZZ, zero=True) == {(0, ): ZZ(0)}
f = [3, 0, 0, 2, 0, 0, 0, 0, 8]
h = {(8, ): 3, (5, ): 2, (0, ): 8}
assert dup_from_dict(h, ZZ) == f
assert dmp_to_dict(f, 0) == h
R, x, y = ring("x,y", ZZ)
f = [R(3), R(0), R(2), R(0), R(0), R(8)]
h = {(5, ): R(3), (3, ): R(2), (0, ): R(8)}
assert dup_from_dict(h, R) == f
assert dmp_to_dict(f, 0) == h
assert dmp_to_dict([1, 0, 5, 0, 7], 0) == {(0, ): 7, (2, ): 5, (4, ): 1}
def test_dmp_ground_extract():
f = dmp_normal([2930944, 0, 2198208, 0, 549552, 0, 45796], 0, ZZ)
g = dmp_normal([17585664, 0, 8792832, 0, 1099104, 0], 0, ZZ)
F = dmp_normal([64, 0, 48, 0, 12, 0, 1], 0, ZZ)
G = dmp_normal([384, 0, 192, 0, 24, 0], 0, ZZ)
assert dmp_ground_extract(f, g, 0, ZZ) == (45796, F, G)
f, g = [ZZ(6), ZZ(12), ZZ(18)], [ZZ(4), ZZ(8), ZZ(12)]
assert dmp_ground_extract(f, g, 0, ZZ) == (2, [3, 6, 9], [2, 4, 6])
f = dmp_normal([[2930944], [], [2198208], [], [549552], [], [45796]], 1, ZZ)
g = dmp_normal([[17585664], [], [8792832], [], [1099104], []], 1, ZZ)
F = dmp_normal([[64], [], [48], [], [12], [], [1]], 1, ZZ)
G = dmp_normal([[384], [], [192], [], [24], []], 1, ZZ)
assert dmp_ground_extract(f, g, 1, ZZ) == (45796, F, G)
def test_residue():
assert n_order(2, 13) == 12
assert [n_order(a, 7) for a in range(1, 7)] == \
[1, 3, 6, 3, 6, 2]
assert n_order(5, 17) == 16
assert n_order(17, 11) == n_order(6, 11)
assert n_order(101, 119) == 6
assert n_order(11, (10**50 + 151)**2) == 10000000000000000000000000000000000000000000000030100000000000000000000000000000000000000000000022650
pytest.raises(ValueError, lambda: n_order(6, 9))
assert is_primitive_root(2, 7) is False
assert is_primitive_root(3, 8) is False
assert is_primitive_root(11, 14) is False
assert is_primitive_root(12, 17) == is_primitive_root(29, 17)
pytest.raises(ValueError, lambda: is_primitive_root(3, 6))
assert [primitive_root(i) for i in range(2, 31)] == [1, 2, 3, 2, 5, 3,
None, 2, 3, 2, None, 2, 3, None, None, 3, 5, 2, None, None, 7, 5,
None, 2, 7, 2, None, 2, None]
for p in primerange(3, 100):
it = _primitive_root_prime_iter(p)
assert len(list(it)) == totient(totient(p))
assert primitive_root(97) == 5
assert primitive_root(97**2) == 5
assert primitive_root(40487) == 5
# note that primitive_root(40487) + 40487 = 40492 is a primitive root
# of 40487**2, but it is not the smallest
assert primitive_root(40487**2) == 10
assert primitive_root(82) == 7
p = 10**50 + 151
assert primitive_root(p) == 11
assert primitive_root(2*p) == 11
assert primitive_root(p**2) == 11
pytest.raises(ValueError, lambda: primitive_root(-3))
assert is_quad_residue(3, 7) is False
assert is_quad_residue(10, 13) is True
assert is_quad_residue(12364, 139) == is_quad_residue(12364 % 139, 139)
assert is_quad_residue(207, 251) is True
assert is_quad_residue(0, 1) is True
assert is_quad_residue(1, 1) is True
assert is_quad_residue(0, 2) == is_quad_residue(1, 2) is True
assert is_quad_residue(1, 4) is True
assert is_quad_residue(2, 27) is False
assert is_quad_residue(13122380800, 13604889600) is True
assert [j for j in range(14) if is_quad_residue(j, 14)] == \
[0, 1, 2, 4, 7, 8, 9, 11]
pytest.raises(ValueError, lambda: is_quad_residue(1.1, 2))
pytest.raises(ValueError, lambda: is_quad_residue(2, 0))
assert quadratic_residues(12) == [0, 1, 4, 9]
assert quadratic_residues(13) == [0, 1, 3, 4, 9, 10, 12]
assert [len(quadratic_residues(i)) for i in range(1, 20)] == \
[1, 2, 2, 2, 3, 4, 4, 3, 4, 6, 6, 4, 7, 8, 6, 4, 9, 8, 10]
assert list(sqrt_mod_iter(6, 2)) == [0]
assert sqrt_mod(3, 13) == 4
assert sqrt_mod(3, -13) == 4
assert sqrt_mod(6, 23) == 11
assert sqrt_mod(345, 690) == 345
assert sqrt_mod(9, 18) == 3
for p in range(3, 100):
d = collections.defaultdict(list)
for i in range(p):
d[pow(i, 2, p)].append(i)
for i in range(1, p):
it = sqrt_mod_iter(i, p)
v = sqrt_mod(i, p, True)
if v:
v = sorted(v)
assert d[i] == v
else:
assert not d[i]
assert sqrt_mod(9, 27, True) == [3, 6, 12, 15, 21, 24]
assert sqrt_mod(9, 81, True) == [3, 24, 30, 51, 57, 78]
assert sqrt_mod(9, 3**5, True) == [3, 78, 84, 159, 165, 240]
assert sqrt_mod(81, 3**4, True) == [0, 9, 18, 27, 36, 45, 54, 63, 72]
assert sqrt_mod(81, 3**5, True) == [9, 18, 36, 45, 63, 72, 90, 99, 117,
126, 144, 153, 171, 180, 198, 207, 225, 234]
assert sqrt_mod(81, 3**6, True) == [9, 72, 90, 153, 171, 234, 252, 315,
333, 396, 414, 477, 495, 558, 576, 639, 657, 720]
assert sqrt_mod(81, 3**7, True) == [9, 234, 252, 477, 495, 720, 738, 963,
981, 1206, 1224, 1449, 1467, 1692, 1710, 1935, 1953, 2178]
for a, p in [(26214400, 32768000000), (26214400, 16384000000),
(262144, 1048576), (87169610025, 163443018796875),
(22315420166400, 167365651248000000)]:
assert pow(sqrt_mod(a, p), 2, p) == a
n = 70
a, p = 5**2*3**n*2**n, 5**6*3**(n+1)*2**(n+2)
it = sqrt_mod_iter(a, p)
for i in range(10):
assert pow(next(it), 2, p) == a
a, p = 5**2*3**n*2**n, 5**6*3**(n+1)*2**(n+3)
it = sqrt_mod_iter(a, p)
for i in range(2):
assert pow(next(it), 2, p) == a
n = 100
a, p = 5**2*3**n*2**n, 5**6*3**(n+1)*2**(n+1)
it = sqrt_mod_iter(a, p)
for i in range(2):
assert pow(next(it), 2, p) == a
assert type(next(sqrt_mod_iter(9, 27))) is int
assert isinstance(next(sqrt_mod_iter(9, 27, ZZ)), type(ZZ(1)))
assert isinstance(next(sqrt_mod_iter(1, 7, ZZ)), type(ZZ(1)))
assert list(sqrt_mod_iter(4, 919, ZZ)) == [2, 917]
assert list(sqrt_mod_iter(6, 146, ZZ)) == [88, 58]
pytest.raises(ValueError, lambda: is_nthpow_residue(+2, +1, 0))
pytest.raises(ValueError, lambda: is_nthpow_residue(+2, -1, 5))
pytest.raises(ValueError, lambda: is_nthpow_residue(-2, +1, 5))
assert is_nthpow_residue(2, 1, 5)
assert is_nthpow_residue(1, 0, 1) is False
assert is_nthpow_residue(1, 0, 2) is True
assert is_nthpow_residue(3, 0, 2) is False
assert is_nthpow_residue(0, 1, 8) is True
assert is_nthpow_residue(2, 3, 2) is False
assert is_nthpow_residue(2, 3, 9) is False
assert is_nthpow_residue(3, 5, 30) is True
assert is_nthpow_residue(21, 11, 20) is True
assert is_nthpow_residue(7, 10, 20) is False
assert is_nthpow_residue(5, 10, 20) is True
assert is_nthpow_residue(3, 10, 48) is False
assert is_nthpow_residue(1, 10, 40) is True
assert is_nthpow_residue(3, 10, 24) is False
assert is_nthpow_residue(1, 10, 24) is True
assert is_nthpow_residue(3, 10, 24) is False
assert is_nthpow_residue(2, 10, 48) is False
assert is_nthpow_residue(81, 3, 972) is False
assert is_nthpow_residue(243, 5, 5103) is True
assert is_nthpow_residue(243, 3, 1240029) is False
assert {a for a in range(1024)
if is_nthpow_residue(a, 56, 1024)} == {pow(i, 56, 1024)
for i in range(1024)}
assert {a for a in range(2048)
if is_nthpow_residue(a, 256, 2048)} == {pow(i, 256, 2048)
for i in range(2048)}
x = {pow(i, 11, 324000) for i in range(1000)}
assert [is_nthpow_residue(a, 11, 324000) for a in x]
x = {pow(i, 17, 22217575536) for i in range(1000)}
assert [is_nthpow_residue(a, 17, 22217575536) for a in x]
assert is_nthpow_residue(676, 3, 5364)
assert is_nthpow_residue(9, 12, 36)
assert is_nthpow_residue(32, 10, 41)
assert is_nthpow_residue(4, 2, 64)
assert is_nthpow_residue(31, 4, 41)
assert not is_nthpow_residue(2, 2, 5)
assert is_nthpow_residue(8547, 12, 10007)
assert nthroot_mod(1801, 11, 2663) == 44
for a, q, p in [(51922, 2, 203017), (43, 3, 109), (1801, 11, 2663),
(26118163, 1303, 33333347), (1499, 7, 2663), (595, 6, 2663),
(1714, 12, 2663), (28477, 9, 33343)]:
r = nthroot_mod(a, q, p)
assert pow(r, q, p) == a
assert nthroot_mod(11, 3, 109) is None
assert nthroot_mod(6, 12, 5) == 1
pytest.raises(NotImplementedError, lambda: nthroot_mod(16, 5, 36))
pytest.raises(NotImplementedError, lambda: nthroot_mod(9, 16, 36))
for p in primerange(5, 100):
qv = range(3, p, 4)
for q in qv:
d = collections.defaultdict(list)
for i in range(p):
d[pow(i, q, p)].append(i)
for a in range(1, p - 1):
res = nthroot_mod(a, q, p, True)
if d[a]:
assert d[a] == res
else:
assert res is None
assert legendre_symbol(5, 11) == 1
assert legendre_symbol(25, 41) == 1
assert legendre_symbol(67, 101) == -1
assert legendre_symbol(0, 13) == 0
assert legendre_symbol(9, 3) == 0
pytest.raises(ValueError, lambda: legendre_symbol(2, 4))
assert jacobi_symbol(25, 41) == 1
assert jacobi_symbol(-23, 83) == -1
assert jacobi_symbol(3, 9) == 0
assert jacobi_symbol(42, 97) == -1
assert jacobi_symbol(3, 5) == -1
assert jacobi_symbol(7, 9) == 1
assert jacobi_symbol(0, 3) == 0
assert jacobi_symbol(0, 1) == 1
assert jacobi_symbol(2, 1) == 1
assert jacobi_symbol(1, 3) == 1
pytest.raises(ValueError, lambda: jacobi_symbol(3, 8))
assert mobius(13*7) == 1
assert mobius(1) == 1
assert mobius(13*7*5) == -1
assert mobius(13**2) == 0
pytest.raises(ValueError, lambda: mobius(-3))
p = Symbol('p', integer=True, positive=True, prime=True)
x = Symbol('x', positive=True)
i = Symbol('i', integer=True)
assert mobius(p) == -1
pytest.raises(TypeError, lambda: mobius(x))
pytest.raises(ValueError, lambda: mobius(i))
mobius(Symbol('p', positive=True, integer=True))
assert _discrete_log_trial_mul(41, 15, 7) == 3
assert _discrete_log_trial_mul(587, 2**7, 2) == 7
assert _discrete_log_trial_mul(941, 7**18, 7) == 18
assert _discrete_log_trial_mul(389, 3**81, 3) == 81
assert _discrete_log_trial_mul(191, 19**123, 19) == 123
pytest.raises(ValueError, lambda: _discrete_log_trial_mul(11, 7, 31))
assert _discrete_log_shanks_steps(41, 15, 7) == 3
assert _discrete_log_shanks_steps(442879, 7**2, 7) == 2
assert _discrete_log_shanks_steps(874323, 5**19, 5) == 19
assert _discrete_log_shanks_steps(6876342, 7**71, 7) == 71
assert _discrete_log_shanks_steps(2456747, 3**321, 3) == 321
pytest.raises(ValueError, lambda: _discrete_log_shanks_steps(11, 7, 31))
assert _discrete_log_pohlig_hellman(251, 210, 71) == 197
assert _discrete_log_pohlig_hellman(98376431, 11**9, 11) == 9
assert _discrete_log_pohlig_hellman(78723213, 11**31, 11) == 31
assert _discrete_log_pohlig_hellman(32942478, 11**98, 11) == 98
assert _discrete_log_pohlig_hellman(14789363, 11**444, 11) == 444
pytest.raises(ValueError, lambda: _discrete_log_pohlig_hellman(11, 7, 31))
assert discrete_log(587, 2**9, 2) == 9
assert discrete_log(2456747, 3**51, 3) == 51
assert discrete_log(32942478, 11**127, 11) == 127
assert discrete_log(432751500361, 7**324, 7) == 324
pytest.raises(ValueError, lambda: discrete_log(11, 7, 31))
def test_construct_domain():
assert construct_domain([1, 2, 3]) == (ZZ, [ZZ(1), ZZ(2), ZZ(3)])
assert construct_domain([1, 2, 3],
field=True) == (QQ, [QQ(1), QQ(2),
QQ(3)])
assert construct_domain([Integer(1), Integer(2),
Integer(3)]) == (ZZ, [ZZ(1), ZZ(2),
ZZ(3)])
assert construct_domain(
[Integer(1), Integer(2), Integer(3)],
field=True) == (QQ, [QQ(1), QQ(2), QQ(3)])
assert construct_domain([Rational(1, 2),
Integer(2)]) == (QQ, [QQ(1, 2), QQ(2)])
assert construct_domain([3.14, 1, Rational(1, 2)
]) == (RR, [RR(3.14), RR(1.0),
RR(0.5)])
assert construct_domain([3.14, sqrt(2)],
extension=None) == (EX, [EX(3.14),
EX(sqrt(2))])
assert construct_domain([3.14, sqrt(2)],
extension=True) == (EX, [EX(3.14),
EX(sqrt(2))])
assert construct_domain([sqrt(2), 3.14],
extension=True) == (EX, [EX(sqrt(2)),
EX(3.14)])
assert construct_domain([1, sqrt(2)],
extension=None) == (EX, [EX(1), EX(sqrt(2))])
assert construct_domain([x, sqrt(x)]) == (EX, [EX(x), EX(sqrt(x))])
assert construct_domain([x, sqrt(x), sqrt(y)
]) == (EX, [EX(x),
EX(sqrt(x)),
EX(sqrt(y))])
alg = QQ.algebraic_field(sqrt(2))
assert (construct_domain(
[7, Rational(1, 2), sqrt(2)],
extension=True) == (alg, [alg(7),
alg(Rational(1, 2)),
alg(sqrt(2))]))
alg = QQ.algebraic_field(sqrt(2) + sqrt(3))
assert (construct_domain([7, sqrt(2), sqrt(3)], extension=True) == (alg, [
alg(7), alg(sqrt(2)), alg(sqrt(3))
]))
dom = ZZ.poly_ring(x)
assert construct_domain([2 * x, 3]) == (dom, [dom(2 * x), dom(3)])
dom = ZZ.poly_ring(x, y)
assert construct_domain([2 * x, 3 * y]) == (dom, [dom(2 * x), dom(3 * y)])
dom = QQ.poly_ring(x)
assert construct_domain([x / 2, 3]) == (dom, [dom(x / 2), dom(3)])
dom = QQ.poly_ring(x, y)
assert construct_domain([x / 2, 3 * y]) == (dom, [dom(x / 2), dom(3 * y)])
dom = RR.poly_ring(x)
assert construct_domain([x / 2, 3.5]) == (dom, [dom(x / 2), dom(3.5)])
dom = RR.poly_ring(x, y)
assert construct_domain([x / 2,
3.5 * y]) == (dom, [dom(x / 2),
dom(3.5 * y)])
dom = ZZ.frac_field(x)
assert construct_domain([2 / x, 3]) == (dom, [dom(2 / x), dom(3)])
dom = ZZ.frac_field(x, y)
assert construct_domain([2 / x, 3 * y]) == (dom, [dom(2 / x), dom(3 * y)])
dom = RR.frac_field(x)
assert construct_domain([2 / x, 3.5]) == (dom, [dom(2 / x), dom(3.5)])
dom = RR.frac_field(x, y)
assert construct_domain([2 / x,
3.5 * y]) == (dom, [dom(2 / x),
dom(3.5 * y)])
assert construct_domain(2) == (ZZ, ZZ(2))
assert construct_domain(Rational(2, 3)) == (QQ, QQ(2, 3))
assert construct_domain({}) == (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() == 2
pytest.raises(TypeError, lambda: f.degree("spam"))
assert f.LC() == ZZ(1)
assert f.TC() == ZZ(0)
assert f.nth(1, 1) == ZZ(2)
pytest.raises(TypeError, lambda: 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
pytest.raises(TypeError, lambda: f.diff(m='x', j=0))
pytest.raises(TypeError, lambda: f.diff(j="spam"))
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
pytest.raises(TypeError, lambda: f.eval(a=1, j="spam"))
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)
pytest.raises(ValueError, lambda: f.half_gcdex(f))
pytest.raises(ValueError, lambda: f.gcdex(f))
pytest.raises(ValueError, lambda: 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)
pytest.raises(ValueError, lambda: f.decompose())
pytest.raises(ValueError, lambda: f.sturm())
pytest.raises(PolynomialError, lambda: f.all_coeffs())
pytest.raises(PolynomialError, lambda: f.all_monoms())
pytest.raises(PolynomialError, lambda: f.all_terms())
pytest.raises(ValueError, lambda: f.revert(1))
pytest.raises(ValueError, lambda: f.shift(1))
pytest.raises(ValueError, lambda: f.gff_list())
pytest.raises(PolynomialError, lambda: f.intervals())
pytest.raises(PolynomialError, lambda: f.refine_root(1, 2))
assert f.integrate() == DMP([[QQ(1, 3)], [QQ(1, 1)], [QQ(3, 1)], []], QQ)
pytest.raises(TypeError, lambda: f.integrate(m="spam"))
pytest.raises(TypeError, lambda: f.integrate(j="spam"))
f = DMP([[-1], [], [], [5]], ZZ)
g = DMP([[3, 1], [], []], QQ)
r = DMP([675, 675, 225, 25], QQ)
assert f.resultant(g) == r
assert DMP([1, 2], QQ).resultant(DMP([3], ZZ)) == 3
assert f.is_cyclotomic is False
def test_dmp_clear_denoms():
assert dmp_clear_denoms([[]], 1, QQ, ZZ) == (ZZ(1), [[]])
assert dmp_clear_denoms([[QQ(1)]], 1, QQ, ZZ) == (ZZ(1), [[QQ(1)]])
assert dmp_clear_denoms([[QQ(7)]], 1, QQ, ZZ) == (ZZ(1), [[QQ(7)]])
assert dmp_clear_denoms([[QQ(7, 3)]], 1, QQ) == (ZZ(3), [[QQ(7)]])
assert dmp_clear_denoms([[QQ(7, 3)]], 1, QQ, ZZ) == (ZZ(3), [[QQ(7)]])
assert dmp_clear_denoms(
[[QQ(3)], [QQ(1)], []], 1, QQ, ZZ) == (ZZ(1), [[QQ(3)], [QQ(1)], []])
assert dmp_clear_denoms([[QQ(
1)], [QQ(1, 2)], []], 1, QQ, ZZ) == (ZZ(2), [[QQ(2)], [QQ(1)], []])
assert dmp_clear_denoms([QQ(3), QQ(
1), QQ(0)], 0, QQ, ZZ, convert=True) == (ZZ(1), [ZZ(3), ZZ(1), ZZ(0)])
assert dmp_clear_denoms([QQ(1), QQ(1, 2), QQ(
0)], 0, QQ, ZZ, convert=True) == (ZZ(2), [ZZ(2), ZZ(1), ZZ(0)])
assert dmp_clear_denoms([[QQ(3)], [QQ(
1)], []], 1, QQ, ZZ, convert=True) == (ZZ(1), [[QQ(3)], [QQ(1)], []])
assert dmp_clear_denoms([[QQ(1)], [QQ(1, 2)], []], 1, QQ, ZZ,
convert=True) == (ZZ(2), [[QQ(2)], [QQ(1)], []])
assert dmp_clear_denoms(
[[EX(Rational(3, 2))], [EX(Rational(9, 4))]], 1, EX) == (EX(4), [[EX(6)], [EX(9)]])
assert dmp_clear_denoms([[EX(7)]], 1, EX) == (EX(1), [[EX(7)]])
assert dmp_clear_denoms([[EX(sin(x)/x), EX(0)]], 1, EX) == (EX(x), [[EX(sin(x)), EX(0)]])
def test_dmp_ground_primitive():
assert dmp_ground_primitive([], 0, ZZ) == (0, [])
assert dmp_ground_primitive([ZZ(1)], 0, ZZ) == (1, [1])
assert dmp_ground_primitive([ZZ(1), ZZ(1)], 0, ZZ) == (1, [1, 1])
assert dmp_ground_primitive([ZZ(2), ZZ(2)], 0, ZZ) == (2, [1, 1])
assert dmp_ground_primitive([ZZ(1), ZZ(2), ZZ(1)], 0, ZZ) == (1, [1, 2, 1])
assert dmp_ground_primitive([ZZ(2), ZZ(4), ZZ(2)], 0, ZZ) == (2, [1, 2, 1])
assert dmp_ground_primitive([ZZ(6), ZZ(8), ZZ(12)], 0, ZZ) == (2, [3, 4, 6])
assert dmp_ground_primitive([], 0, QQ) == (0, [])
assert dmp_ground_primitive([QQ(1)], 0, QQ) == (1, [1])
assert dmp_ground_primitive([QQ(1), QQ(1)], 0, QQ) == (1, [1, 1])
assert dmp_ground_primitive([QQ(2), QQ(2)], 0, QQ) == (2, [1, 1])
assert dmp_ground_primitive([QQ(1), QQ(2), QQ(1)], 0, QQ) == (1, [1, 2, 1])
assert dmp_ground_primitive([QQ(2), QQ(4), QQ(2)], 0, QQ) == (2, [1, 2, 1])
assert dmp_ground_primitive([QQ(6), QQ(8), QQ(12)], 0, QQ) == (2, [3, 4, 6])
assert dmp_ground_primitive([QQ(2, 3), QQ(4, 9)], 0, QQ) == (QQ(2, 9), [3, 2])
assert dmp_ground_primitive([QQ(2, 3), QQ(4, 5)], 0, QQ) == (QQ(2, 15), [5, 6])
assert dmp_ground_primitive([[]], 1, ZZ) == (0, [[]])
assert dmp_ground_primitive(f_0, 2, ZZ) == (1, f_0)
assert dmp_ground_primitive(dmp_mul_ground(f_0, ZZ(2), 2, ZZ), 2, ZZ) == (2, f_0)
assert dmp_ground_primitive(f_1, 2, ZZ) == (1, f_1)
assert dmp_ground_primitive(dmp_mul_ground(f_1, ZZ(3), 2, ZZ), 2, ZZ) == (3, f_1)
assert dmp_ground_primitive(f_2, 2, ZZ) == (1, f_2)
assert dmp_ground_primitive(dmp_mul_ground(f_2, ZZ(4), 2, ZZ), 2, ZZ) == (4, f_2)
assert dmp_ground_primitive(f_3, 2, ZZ) == (1, f_3)
assert dmp_ground_primitive(dmp_mul_ground(f_3, ZZ(5), 2, ZZ), 2, ZZ) == (5, f_3)
assert dmp_ground_primitive(f_4, 2, ZZ) == (1, f_4)
assert dmp_ground_primitive(dmp_mul_ground(f_4, ZZ(6), 2, ZZ), 2, ZZ) == (6, f_4)
assert dmp_ground_primitive(f_5, 2, ZZ) == (1, f_5)
assert dmp_ground_primitive(dmp_mul_ground(f_5, ZZ(7), 2, ZZ), 2, ZZ) == (7, f_5)
assert dmp_ground_primitive(f_6, 3, ZZ) == (1, f_6)
assert dmp_ground_primitive(dmp_mul_ground(f_6, ZZ(8), 3, ZZ), 3, ZZ) == (8, f_6)
assert dmp_ground_primitive([[ZZ(2)]], 1, ZZ) == (2, [[1]])
assert dmp_ground_primitive([[QQ(2)]], 1, QQ) == (2, [[1]])
assert dmp_ground_primitive([[QQ(2, 3)], [QQ(4, 9)]], 1, QQ) == (QQ(2, 9), [[3], [2]])
assert dmp_ground_primitive([[QQ(2, 3)], [QQ(4, 5)]], 1, QQ) == (QQ(2, 15), [[5], [6]])
def test_dmp_ground_content():
assert dmp_ground_content([], 0, ZZ) == 0
assert dmp_ground_content([ZZ(+1)], 0, ZZ) == 1
assert dmp_ground_content([ZZ(-1)], 0, ZZ) == 1
assert dmp_ground_content([ZZ(1), ZZ(1)], 0, ZZ) == 1
assert dmp_ground_content([ZZ(2), ZZ(2)], 0, ZZ) == 2
assert dmp_ground_content([ZZ(1), ZZ(2), ZZ(1)], 0, ZZ) == 1
assert dmp_ground_content([ZZ(2), ZZ(4), ZZ(2)], 0, ZZ) == 2
assert dmp_ground_content([ZZ(6), ZZ(8), ZZ(12)], 0, ZZ) == 2
assert dmp_ground_content([QQ(6), QQ(8), QQ(12)], 0, QQ) == 2
assert dmp_ground_content([QQ(2, 3), QQ(4, 9)], 0, QQ) == QQ(2, 9)
assert dmp_ground_content([QQ(2, 3), QQ(4, 5)], 0, QQ) == QQ(2, 15)
assert dmp_ground_content([[]], 1, ZZ) == 0
assert dmp_ground_content([[]], 1, QQ) == 0
assert dmp_ground_content([[ZZ(+1)]], 1, ZZ) == 1
assert dmp_ground_content([[ZZ(-1)]], 1, ZZ) == 1
assert dmp_ground_content([[ZZ(1)], [ZZ(1)]], 1, ZZ) == 1
assert dmp_ground_content([[ZZ(2)], [ZZ(2)]], 1, ZZ) == 2
assert dmp_ground_content([[ZZ(1)], [ZZ(2)], [ZZ(1)]], 1, ZZ) == 1
assert dmp_ground_content([[ZZ(2)], [ZZ(4)], [ZZ(2)]], 1, ZZ) == 2
assert dmp_ground_content([[QQ(2, 3)], [QQ(4, 9)]], 1, QQ) == QQ(2, 9)
assert dmp_ground_content([[QQ(2, 3)], [QQ(4, 5)]], 1, QQ) == QQ(2, 15)
assert dmp_ground_content(f_0, 2, ZZ) == 1
assert dmp_ground_content(dmp_mul_ground(f_0, ZZ(2), 2, ZZ), 2, ZZ) == 2
assert dmp_ground_content(f_1, 2, ZZ) == 1
assert dmp_ground_content(dmp_mul_ground(f_1, ZZ(3), 2, ZZ), 2, ZZ) == 3
assert dmp_ground_content(f_2, 2, ZZ) == 1
assert dmp_ground_content(dmp_mul_ground(f_2, ZZ(4), 2, ZZ), 2, ZZ) == 4
assert dmp_ground_content(f_3, 2, ZZ) == 1
assert dmp_ground_content(dmp_mul_ground(f_3, ZZ(5), 2, ZZ), 2, ZZ) == 5
assert dmp_ground_content(f_4, 2, ZZ) == 1
assert dmp_ground_content(dmp_mul_ground(f_4, ZZ(6), 2, ZZ), 2, ZZ) == 6
assert dmp_ground_content(f_5, 2, ZZ) == 1
assert dmp_ground_content(dmp_mul_ground(f_5, ZZ(7), 2, ZZ), 2, ZZ) == 7
assert dmp_ground_content(f_6, 3, ZZ) == 1
assert dmp_ground_content(dmp_mul_ground(f_6, ZZ(8), 3, ZZ), 3, ZZ) == 8
def test_dmp_ground_trunc():
assert dmp_ground_trunc(f_0, ZZ(3), 2, ZZ) == \
dmp_normal(
[[[1, -1, 0], [-1]], [[]], [[1, -1, 0], [1, -1, 1], [1]]], 2, ZZ)
def test_dup_trunc():
assert dup_trunc([1, 2, 3, 4, 5, 6], ZZ(3), ZZ) == [1, -1, 0, 1, -1, 0]
assert dup_trunc([6, 5, 4, 3, 2, 1], ZZ(3), ZZ) == [-1, 1, 0, -1, 1]
def test_DMP___eq__():
f = DMP([[ZZ(1), ZZ(2)], [ZZ(3)]], ZZ)
assert f == f
assert f.eq(f)
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).ne(DMP([[ZZ(1)]], ZZ))
assert DMP([[ZZ(1)]], ZZ) != DMP([[[ZZ(1)]]], ZZ)