def test_ANP___bool__():
assert bool(ANP([], [QQ(1), QQ(0), QQ(1)], QQ)) is False
assert bool(ANP([QQ(1)], [QQ(1), QQ(0), QQ(1)], QQ)) is True
def test_puiseux():
R, x, y = ring('x, y', QQ)
p = x**QQ(2, 5) + x**QQ(2, 3) + x
r = rs_series_inversion(p, x, 1)
r1 = -x**QQ(14,15) + x**QQ(4,5) - 3*x**QQ(11,15) + x**QQ(2,3) + \
2*x**QQ(7,15) - x**QQ(2,5) - x**QQ(1,5) + x**QQ(2,15) - x**QQ(-2,15) \
+ x**QQ(-2,5)
assert r == r1
r = rs_nth_root(1 + p, 3, x, 1)
assert r == -x**QQ(4, 5) / 9 + x**QQ(2, 3) / 3 + x**QQ(2, 5) / 3 + 1
r = rs_log(1 + p, x, 1)
assert r == -x**QQ(4, 5) / 2 + x**QQ(2, 3) + x**QQ(2, 5)
r = rs_LambertW(p, x, 1)
assert r == -x**QQ(4, 5) + x**QQ(2, 3) + x**QQ(2, 5)
p1 = x + x**QQ(1, 5) * y
r = rs_exp(p1, x, 1)
assert r == x**QQ(4,5)*y**4/24 + x**QQ(3,5)*y**3/6 + x**QQ(2,5)*y**2/2 + \
x**QQ(1,5)*y + 1
r = rs_atan(p, x, 2)
assert r == -x**QQ(9,5) - x**QQ(26,15) - x**QQ(22,15) - x**QQ(6,5)/3 + \
x + x**QQ(2,3) + x**QQ(2,5)
r = rs_atan(p1, x, 2)
assert r == x**QQ(9,5)*y**9/9 + x**QQ(9,5)*y**4 - x**QQ(7,5)*y**7/7 - \
x**QQ(7,5)*y**2 + x*y**5/5 + x - x**QQ(3,5)*y**3/3 + x**QQ(1,5)*y
r = rs_asin(p, x, 2)
assert r == x**QQ(9,5)/2 + x**QQ(26,15)/2 + x**QQ(22,15)/2 + \
x**QQ(6,5)/6 + x + x**QQ(2,3) + x**QQ(2,5)
r = rs_cot(p, x, 1)
assert r == -x**QQ(14,15) + x**QQ(4,5) - 3*x**QQ(11,15) + \
2*x**QQ(2,3)/3 + 2*x**QQ(7,15) - 4*x**QQ(2,5)/3 - x**QQ(1,5) + \
x**QQ(2,15) - x**QQ(-2,15) + x**QQ(-2,5)
r = rs_cos_sin(p, x, 2)
assert r[0] == x**QQ(28,15)/6 - x**QQ(5,3) + x**QQ(8,5)/24 - x**QQ(7,5) - \
x**QQ(4,3)/2 - x**QQ(16,15) - x**QQ(4,5)/2 + 1
assert r[1] == -x**QQ(9,5)/2 - x**QQ(26,15)/2 - x**QQ(22,15)/2 - \
x**QQ(6,5)/6 + x + x**QQ(2,3) + x**QQ(2,5)
r = rs_atanh(p, x, 2)
assert r == x**QQ(9,5) + x**QQ(26,15) + x**QQ(22,15) + x**QQ(6,5)/3 + x + \
x**QQ(2,3) + x**QQ(2,5)
r = rs_sinh(p, x, 2)
assert r == x**QQ(9,5)/2 + x**QQ(26,15)/2 + x**QQ(22,15)/2 + \
x**QQ(6,5)/6 + x + x**QQ(2,3) + x**QQ(2,5)
r = rs_cosh(p, x, 2)
assert r == x**QQ(28,15)/6 + x**QQ(5,3) + x**QQ(8,5)/24 + x**QQ(7,5) + \
x**QQ(4,3)/2 + x**QQ(16,15) + x**QQ(4,5)/2 + 1
r = rs_tanh(p, x, 2)
assert r == -x**QQ(9,5) - x**QQ(26,15) - x**QQ(22,15) - x**QQ(6,5)/3 + \
x + x**QQ(2,3) + x**QQ(2,5)
def test_rs_series():
x, a, b, c = symbols('x, a, b, c')
assert rs_series(a, a, 5).as_expr() == a
assert rs_series(sin(a), a, 5).as_expr() == (sin(a).series(a, 0,
5)).removeO()
assert rs_series(sin(a) + cos(a), a,
5).as_expr() == ((sin(a) + cos(a)).series(a, 0,
5)).removeO()
assert rs_series(sin(a) * cos(a), a,
5).as_expr() == ((sin(a) * cos(a)).series(a, 0,
5)).removeO()
p = (sin(a) - a) * (cos(a**2) + a**4 / 2)
assert expand(rs_series(p, a, 10).as_expr()) == expand(
p.series(a, 0, 10).removeO())
p = sin(a**2 / 2 + a / 3) + cos(a / 5) * sin(a / 2)**3
assert expand(rs_series(p, a, 5).as_expr()) == expand(
p.series(a, 0, 5).removeO())
p = sin(x**2 + a) * (cos(x**3 - 1) - a - a**2)
assert expand(rs_series(p, a, 5).as_expr()) == expand(
p.series(a, 0, 5).removeO())
p = sin(a**2 - a / 3 + 2)**5 * exp(a**3 - a / 2)
assert expand(rs_series(p, a, 10).as_expr()) == expand(
p.series(a, 0, 10).removeO())
p = sin(a + b + c)
assert expand(rs_series(p, a, 5).as_expr()) == expand(
p.series(a, 0, 5).removeO())
p = tan(sin(a**2 + 4) + b + c)
assert expand(rs_series(p, a, 6).as_expr()) == expand(
p.series(a, 0, 6).removeO())
p = a**QQ(2, 5) + a**QQ(2, 3) + a
r = rs_series(tan(p), a, 2)
assert r.as_expr() == a**QQ(9,5) + a**QQ(26,15) + a**QQ(22,15) + a**QQ(6,5)/3 + \
a + a**QQ(2,3) + a**QQ(2,5)
r = rs_series(exp(p), a, 1)
assert r.as_expr() == a**QQ(4, 5) / 2 + a**QQ(2, 3) + a**QQ(2, 5) + 1
r = rs_series(sin(p), a, 2)
assert r.as_expr() == -a**QQ(9,5)/2 - a**QQ(26,15)/2 - a**QQ(22,15)/2 - \
a**QQ(6,5)/6 + a + a**QQ(2,3) + a**QQ(2,5)
r = rs_series(cos(p), a, 2)
assert r.as_expr() == a**QQ(28,15)/6 - a**QQ(5,3) + a**QQ(8,5)/24 - a**QQ(7,5) - \
a**QQ(4,3)/2 - a**QQ(16,15) - a**QQ(4,5)/2 + 1
assert rs_series(sin(a) / 7, a,
5).as_expr() == (sin(a) / 7).series(a, 0, 5).removeO()
assert rs_series(log(1 + x), x, 5).as_expr() == -x**4/4 + x**3/3 - \
x**2/2 + x
assert rs_series(log(1 + 4*x), x, 5).as_expr() == -64*x**4 + 64*x**3/3 - \
8*x**2 + 4*x
assert rs_series(log(1 + x + x**2), x, 10).as_expr() == -2*x**9/9 + \
x**8/8 + x**7/7 - x**6/3 + x**5/5 + x**4/4 - 2*x**3/3 + \
x**2/2 + x
assert rs_series(log(1 + x*a**2), x, 7).as_expr() == -x**6*a**12/6 + \
x**5*a**10/5 - x**4*a**8/4 + x**3*a**6/3 - \
x**2*a**4/2 + x*a**2
def test_representing_matrices():
R, x,y = ring("x,y", QQ, grlex)
basis = [(0, 0), (0, 1), (1, 0), (1, 1)]
F = [x**2 - x - 3*y + 1, -2*x + y**2 + y - 1]
assert _representing_matrices(basis, F, R) == [
[[QQ(0, 1), QQ(0, 1),-QQ(1, 1), QQ(3, 1)],
[QQ(0, 1), QQ(0, 1), QQ(3, 1),-QQ(4, 1)],
[QQ(1, 1), QQ(0, 1), QQ(1, 1), QQ(6, 1)],
[QQ(0, 1), QQ(1, 1), QQ(0, 1), QQ(1, 1)]],
[[QQ(0, 1), QQ(1, 1), QQ(0, 1),-QQ(2, 1)],
[QQ(1, 1),-QQ(1, 1), QQ(0, 1), QQ(6, 1)],
[QQ(0, 1), QQ(2, 1), QQ(0, 1), QQ(3, 1)],
[QQ(0, 1), QQ(0, 1), QQ(1, 1),-QQ(1, 1)]]]
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 is 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 is 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 is 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 is 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 is 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 is 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
c = AlgebraicNumber(sqrt(2), gen=x)
d = AlgebraicNumber(sqrt(2), gen=x)
assert a == b
assert a == c
a = AlgebraicNumber(sqrt(2), [1, 2])
b = AlgebraicNumber(sqrt(2), [1, 3])
assert a != b and a != sqrt(2) + 3
assert (a == x) is False and (a != x) is 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_expr() == sqrt(2)
assert a.as_expr(x) == x
assert b.as_expr() == sqrt(2)
assert b.as_expr(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_expr() == 2 * sqrt(2) + 3
assert a.as_expr(x) == 2 * x + 3
assert b.as_expr() == 2 * sqrt(2) + 3
assert b.as_expr(x) == 2 * x + 3
a = AlgebraicNumber(sqrt(2))
b = to_number_field(sqrt(2))
assert a.args == b.args == (sqrt(2), Tuple())
b = AlgebraicNumber(sqrt(2), alias='alpha')
assert b.args == (sqrt(2), Tuple(), Symbol('alpha'))
a = AlgebraicNumber(sqrt(2), [1, 2, 3])
assert a.args == (sqrt(2), Tuple(1, 2, 3))
def test_dup_gcd():
R, x = ring("x", ZZ)
f, g = 0, 0
assert R.dup_zz_heu_gcd(f, g) == R.dup_rr_prs_gcd(f, g) == (0, 0, 0)
f, g = 2, 0
assert R.dup_zz_heu_gcd(f, g) == R.dup_rr_prs_gcd(f, g) == (2, 1, 0)
f, g = -2, 0
assert R.dup_zz_heu_gcd(f, g) == R.dup_rr_prs_gcd(f, g) == (2, -1, 0)
f, g = 0, -2
assert R.dup_zz_heu_gcd(f, g) == R.dup_rr_prs_gcd(f, g) == (2, 0, -1)
f, g = 0, 2 * x + 4
assert R.dup_zz_heu_gcd(f, g) == R.dup_rr_prs_gcd(f,
g) == (2 * x + 4, 0, 1)
f, g = 2 * x + 4, 0
assert R.dup_zz_heu_gcd(f, g) == R.dup_rr_prs_gcd(f,
g) == (2 * x + 4, 1, 0)
f, g = 2, 2
assert R.dup_zz_heu_gcd(f, g) == R.dup_rr_prs_gcd(f, g) == (2, 1, 1)
f, g = -2, 2
assert R.dup_zz_heu_gcd(f, g) == R.dup_rr_prs_gcd(f, g) == (2, -1, 1)
f, g = 2, -2
assert R.dup_zz_heu_gcd(f, g) == R.dup_rr_prs_gcd(f, g) == (2, 1, -1)
f, g = -2, -2
assert R.dup_zz_heu_gcd(f, g) == R.dup_rr_prs_gcd(f, g) == (2, -1, -1)
f, g = x**2 + 2 * x + 1, 1
assert R.dup_zz_heu_gcd(f, g) == R.dup_rr_prs_gcd(
f, g) == (1, x**2 + 2 * x + 1, 1)
f, g = x**2 + 2 * x + 1, 2
assert R.dup_zz_heu_gcd(f, g) == R.dup_rr_prs_gcd(
f, g) == (1, x**2 + 2 * x + 1, 2)
f, g = 2 * x**2 + 4 * x + 2, 2
assert R.dup_zz_heu_gcd(f, g) == R.dup_rr_prs_gcd(
f, g) == (2, x**2 + 2 * x + 1, 1)
f, g = 2, 2 * x**2 + 4 * x + 2
assert R.dup_zz_heu_gcd(f, g) == R.dup_rr_prs_gcd(
f, g) == (2, 1, x**2 + 2 * x + 1)
f, g = 2 * x**2 + 4 * x + 2, x + 1
assert R.dup_zz_heu_gcd(f, g) == R.dup_rr_prs_gcd(
f, g) == (x + 1, 2 * x + 2, 1)
f, g = x + 1, 2 * x**2 + 4 * x + 2
assert R.dup_zz_heu_gcd(f, g) == R.dup_rr_prs_gcd(
f, g) == (x + 1, 1, 2 * x + 2)
f, g = x - 31, x
assert R.dup_zz_heu_gcd(f, g) == R.dup_rr_prs_gcd(f, g) == (1, f, g)
f = x**4 + 8 * x**3 + 21 * x**2 + 22 * x + 8
g = x**3 + 6 * x**2 + 11 * x + 6
h = x**2 + 3 * x + 2
cff = x**2 + 5 * x + 4
cfg = x + 3
assert R.dup_zz_heu_gcd(f, g) == (h, cff, cfg)
assert R.dup_rr_prs_gcd(f, g) == (h, cff, cfg)
f = x**4 - 4
g = x**4 + 4 * x**2 + 4
h = x**2 + 2
cff = x**2 - 2
cfg = x**2 + 2
assert R.dup_zz_heu_gcd(f, g) == (h, cff, cfg)
assert R.dup_rr_prs_gcd(f, g) == (h, cff, cfg)
f = x**8 + x**6 - 3 * x**4 - 3 * x**3 + 8 * x**2 + 2 * x - 5
g = 3 * x**6 + 5 * x**4 - 4 * x**2 - 9 * x + 21
h = 1
cff = f
cfg = g
assert R.dup_zz_heu_gcd(f, g) == (h, cff, cfg)
assert R.dup_rr_prs_gcd(f, g) == (h, cff, cfg)
R, x = ring("x", QQ)
f = x**8 + x**6 - 3 * x**4 - 3 * x**3 + 8 * x**2 + 2 * x - 5
g = 3 * x**6 + 5 * x**4 - 4 * x**2 - 9 * x + 21
h = 1
cff = f
cfg = g
assert R.dup_qq_heu_gcd(f, g) == (h, cff, cfg)
assert R.dup_ff_prs_gcd(f, g) == (h, cff, cfg)
R, x = ring("x", ZZ)
f = - 352518131239247345597970242177235495263669787845475025293906825864749649589178600387510272*x**49 \
+ 46818041807522713962450042363465092040687472354933295397472942006618953623327997952*x**42 \
+ 378182690892293941192071663536490788434899030680411695933646320291525827756032*x**35 \
+ 112806468807371824947796775491032386836656074179286744191026149539708928*x**28 \
- 12278371209708240950316872681744825481125965781519138077173235712*x**21 \
+ 289127344604779611146960547954288113529690984687482920704*x**14 \
+ 19007977035740498977629742919480623972236450681*x**7 \
+ 311973482284542371301330321821976049
g = 365431878023781158602430064717380211405897160759702125019136*x**21 \
+ 197599133478719444145775798221171663643171734081650688*x**14 \
- 9504116979659010018253915765478924103928886144*x**7 \
- 311973482284542371301330321821976049
assert R.dup_zz_heu_gcd(f, R.dup_diff(f, 1))[0] == g
assert R.dup_rr_prs_gcd(f, R.dup_diff(f, 1))[0] == g
R, x = ring("x", QQ)
f = QQ(1, 2) * x**2 + x + QQ(1, 2)
g = QQ(1, 2) * x + QQ(1, 2)
h = x + 1
assert R.dup_qq_heu_gcd(f, g) == (h, g, QQ(1, 2))
assert R.dup_ff_prs_gcd(f, g) == (h, g, QQ(1, 2))
R, x = ring("x", ZZ)
f = 1317378933230047068160 * x + 2945748836994210856960
g = 120352542776360960 * x + 269116466014453760
h = 120352542776360960 * x + 269116466014453760
cff = 10946
cfg = 1
assert R.dup_zz_heu_gcd(f, g) == (h, cff, cfg)
def test_dup_invert():
R, x = ring("x", QQ)
assert R.dup_invert(2 * x, x**2 - 16) == QQ(1, 32) * x
def test_PythonRational__hash__():
assert hash(QQ(0)) == hash(0)
assert hash(QQ(1)) == hash(1)
assert hash(QQ(117)) == hash(117)
def test_PythonRational__int__():
assert int(QQ(-1, 4)) == 0
assert int(QQ(1, 4)) == 0
assert int(QQ(-5, 4)) == -1
assert int(QQ(5, 4)) == 1
def test_PythonRational__eq__():
assert (QQ(1, 2) == QQ(1, 2)) is True
assert (QQ(1, 2) != QQ(1, 2)) is False
assert (QQ(1, 2) == QQ(1, 3)) is False
assert (QQ(1, 2) != QQ(1, 3)) is True
def test_PythonRational__lt_le_gt_ge__():
assert (QQ(1, 2) < QQ(1, 4)) is False
assert (QQ(1, 2) <= QQ(1, 4)) is False
assert (QQ(1, 2) > QQ(1, 4)) is True
assert (QQ(1, 2) >= QQ(1, 4)) is True
assert (QQ(1, 4) < QQ(1, 2)) is True
assert (QQ(1, 4) <= QQ(1, 2)) is True
assert (QQ(1, 4) > QQ(1, 2)) is False
assert (QQ(1, 4) >= QQ(1, 2)) is False
def test_PythonRational__pow__():
assert QQ(1)**10 == QQ(1)
assert QQ(2)**10 == QQ(1024)
assert QQ(1)**(-10) == QQ(1)
assert QQ(2)**(-10) == QQ(1, 1024)
def test_PythonRational__div__():
assert QQ(-1, 2) / QQ(1, 2) == QQ(-1)
assert QQ(1, 2) / QQ(-1, 2) == QQ(-1)
assert QQ(1, 2) / QQ(1, 2) == QQ(1)
assert QQ(1, 2) / QQ(3, 2) == QQ(1, 3)
assert QQ(3, 2) / QQ(1, 2) == QQ(3)
assert QQ(3, 2) / QQ(3, 2) == QQ(1)
assert 2 / QQ(1, 2) == QQ(4)
assert QQ(1, 2) / 2 == QQ(1, 4)
raises(ZeroDivisionError, lambda: QQ(1, 2) / QQ(0))
raises(ZeroDivisionError, lambda: QQ(1, 2) / 0)
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_PythonRational__mul__():
assert QQ(-1, 2) * QQ(1, 2) == QQ(-1, 4)
assert QQ(1, 2) * QQ(-1, 2) == QQ(-1, 4)
assert QQ(1, 2) * QQ(1, 2) == QQ(1, 4)
assert QQ(1, 2) * QQ(3, 2) == QQ(3, 4)
assert QQ(3, 2) * QQ(1, 2) == QQ(3, 4)
assert QQ(3, 2) * QQ(3, 2) == QQ(9, 4)
assert 2 * QQ(1, 2) == QQ(1)
assert QQ(1, 2) * 2 == QQ(1)
def test_PythonRational__float__():
assert float(QQ(-1, 2)) == -0.5
assert float(QQ(1, 2)) == 0.5
def test_dmp_subresultants():
R, x, y = ring("x,y", ZZ)
assert R.dmp_resultant(0, 0) == 0
assert R.dmp_prs_resultant(0, 0)[0] == 0
assert R.dmp_zz_collins_resultant(0, 0) == 0
assert R.dmp_qq_collins_resultant(0, 0) == 0
assert R.dmp_resultant(1, 0) == 0
assert R.dmp_resultant(1, 0) == 0
assert R.dmp_resultant(1, 0) == 0
assert R.dmp_resultant(0, 1) == 0
assert R.dmp_prs_resultant(0, 1)[0] == 0
assert R.dmp_zz_collins_resultant(0, 1) == 0
assert R.dmp_qq_collins_resultant(0, 1) == 0
f = 3 * x**2 * y - y**3 - 4
g = x**2 + x * y**3 - 9
a = 3 * x * y**4 + y**3 - 27 * y + 4
b = -3 * y**10 - 12 * y**7 + y**6 - 54 * y**4 + 8 * y**3 + 729 * y**2 - 216 * y + 16
r = R.dmp_LC(b)
assert R.dmp_subresultants(f, g) == [f, g, a, b]
assert R.dmp_resultant(f, g) == r
assert R.dmp_prs_resultant(f, g)[0] == r
assert R.dmp_zz_collins_resultant(f, g) == r
assert R.dmp_qq_collins_resultant(f, g) == r
f = -x**3 + 5
g = 3 * x**2 * y + x**2
a = 45 * y**2 + 30 * y + 5
b = 675 * y**3 + 675 * y**2 + 225 * y + 25
r = R.dmp_LC(b)
assert R.dmp_subresultants(f, g) == [f, g, a]
assert R.dmp_resultant(f, g) == r
assert R.dmp_prs_resultant(f, g)[0] == r
assert R.dmp_zz_collins_resultant(f, g) == r
assert R.dmp_qq_collins_resultant(f, g) == r
R, x, y, z, u, v = ring("x,y,z,u,v", ZZ)
f = 6 * x**2 - 3 * x * y - 2 * x * z + y * z
g = x**2 - x * u - x * v + u * v
r = y**2*z**2 - 3*y**2*z*u - 3*y**2*z*v + 9*y**2*u*v - 2*y*z**2*u \
- 2*y*z**2*v + 6*y*z*u**2 + 12*y*z*u*v + 6*y*z*v**2 - 18*y*u**2*v \
- 18*y*u*v**2 + 4*z**2*u*v - 12*z*u**2*v - 12*z*u*v**2 + 36*u**2*v**2
assert R.dmp_zz_collins_resultant(f, g) == r.drop(x)
R, x, y, z, u, v = ring("x,y,z,u,v", QQ)
f = x**2 - QQ(1, 2) * x * y - QQ(1, 3) * x * z + QQ(1, 6) * y * z
g = x**2 - x * u - x * v + u * v
r = QQ(1,36)*y**2*z**2 - QQ(1,12)*y**2*z*u - QQ(1,12)*y**2*z*v + QQ(1,4)*y**2*u*v \
- QQ(1,18)*y*z**2*u - QQ(1,18)*y*z**2*v + QQ(1,6)*y*z*u**2 + QQ(1,3)*y*z*u*v \
+ QQ(1,6)*y*z*v**2 - QQ(1,2)*y*u**2*v - QQ(1,2)*y*u*v**2 + QQ(1,9)*z**2*u*v \
- QQ(1,3)*z*u**2*v - QQ(1,3)*z*u*v**2 + u**2*v**2
assert R.dmp_qq_collins_resultant(f, g) == r.drop(x)
def test_PythonRational__abs__():
assert abs(QQ(-1, 2)) == QQ(1, 2)
assert abs(QQ(1, 2)) == QQ(1, 2)
def test_dmp_gcd():
R, x, y = ring("x,y", ZZ)
f, g = 0, 0
assert R.dmp_zz_heu_gcd(f, g) == R.dmp_rr_prs_gcd(f, g) == (0, 0, 0)
f, g = 2, 0
assert R.dmp_zz_heu_gcd(f, g) == R.dmp_rr_prs_gcd(f, g) == (2, 1, 0)
f, g = -2, 0
assert R.dmp_zz_heu_gcd(f, g) == R.dmp_rr_prs_gcd(f, g) == (2, -1, 0)
f, g = 0, -2
assert R.dmp_zz_heu_gcd(f, g) == R.dmp_rr_prs_gcd(f, g) == (2, 0, -1)
f, g = 0, 2 * x + 4
assert R.dmp_zz_heu_gcd(f, g) == R.dmp_rr_prs_gcd(f,
g) == (2 * x + 4, 0, 1)
f, g = 2 * x + 4, 0
assert R.dmp_zz_heu_gcd(f, g) == R.dmp_rr_prs_gcd(f,
g) == (2 * x + 4, 1, 0)
f, g = 2, 2
assert R.dmp_zz_heu_gcd(f, g) == R.dmp_rr_prs_gcd(f, g) == (2, 1, 1)
f, g = -2, 2
assert R.dmp_zz_heu_gcd(f, g) == R.dmp_rr_prs_gcd(f, g) == (2, -1, 1)
f, g = 2, -2
assert R.dmp_zz_heu_gcd(f, g) == R.dmp_rr_prs_gcd(f, g) == (2, 1, -1)
f, g = -2, -2
assert R.dmp_zz_heu_gcd(f, g) == R.dmp_rr_prs_gcd(f, g) == (2, -1, -1)
f, g = x**2 + 2 * x + 1, 1
assert R.dmp_zz_heu_gcd(f, g) == R.dmp_rr_prs_gcd(
f, g) == (1, x**2 + 2 * x + 1, 1)
f, g = x**2 + 2 * x + 1, 2
assert R.dmp_zz_heu_gcd(f, g) == R.dmp_rr_prs_gcd(
f, g) == (1, x**2 + 2 * x + 1, 2)
f, g = 2 * x**2 + 4 * x + 2, 2
assert R.dmp_zz_heu_gcd(f, g) == R.dmp_rr_prs_gcd(
f, g) == (2, x**2 + 2 * x + 1, 1)
f, g = 2, 2 * x**2 + 4 * x + 2
assert R.dmp_zz_heu_gcd(f, g) == R.dmp_rr_prs_gcd(
f, g) == (2, 1, x**2 + 2 * x + 1)
f, g = 2 * x**2 + 4 * x + 2, x + 1
assert R.dmp_zz_heu_gcd(f, g) == R.dmp_rr_prs_gcd(
f, g) == (x + 1, 2 * x + 2, 1)
f, g = x + 1, 2 * x**2 + 4 * x + 2
assert R.dmp_zz_heu_gcd(f, g) == R.dmp_rr_prs_gcd(
f, g) == (x + 1, 1, 2 * x + 2)
R, x, y, z, u = ring("x,y,z,u", ZZ)
f, g = u**2 + 2 * u + 1, 2 * u + 2
assert R.dmp_zz_heu_gcd(f, g) == R.dmp_rr_prs_gcd(f,
g) == (u + 1, u + 1, 2)
f, g = z**2 * u**2 + 2 * z**2 * u + z**2 + z * u + z, u**2 + 2 * u + 1
h, cff, cfg = u + 1, z**2 * u + z**2 + z, u + 1
assert R.dmp_zz_heu_gcd(f, g) == (h, cff, cfg)
assert R.dmp_rr_prs_gcd(f, g) == (h, cff, cfg)
assert R.dmp_zz_heu_gcd(g, f) == (h, cfg, cff)
assert R.dmp_rr_prs_gcd(g, f) == (h, cfg, cff)
R, x, y, z = ring("x,y,z", ZZ)
f, g, h = map(R.from_dense, dmp_fateman_poly_F_1(2, ZZ))
H, cff, cfg = R.dmp_zz_heu_gcd(f, g)
assert H == h and R.dmp_mul(H, cff) == f \
and R.dmp_mul(H, cfg) == g
H, cff, cfg = R.dmp_rr_prs_gcd(f, g)
assert H == h and R.dmp_mul(H, cff) == f \
and R.dmp_mul(H, cfg) == g
R, x, y, z, u, v = ring("x,y,z,u,v", ZZ)
f, g, h = map(R.from_dense, dmp_fateman_poly_F_1(4, ZZ))
H, cff, cfg = R.dmp_zz_heu_gcd(f, g)
assert H == h and R.dmp_mul(H, cff) == f \
and R.dmp_mul(H, cfg) == g
R, x, y, z, u, v, a, b = ring("x,y,z,u,v,a,b", ZZ)
f, g, h = map(R.from_dense, dmp_fateman_poly_F_1(6, ZZ))
H, cff, cfg = R.dmp_zz_heu_gcd(f, g)
assert H == h and R.dmp_mul(H, cff) == f \
and R.dmp_mul(H, cfg) == g
R, x, y, z, u, v, a, b, c, d = ring("x,y,z,u,v,a,b,c,d", ZZ)
f, g, h = map(R.from_dense, dmp_fateman_poly_F_1(8, ZZ))
H, cff, cfg = R.dmp_zz_heu_gcd(f, g)
assert H == h and R.dmp_mul(H, cff) == f \
and R.dmp_mul(H, cfg) == g
R, x, y, z = ring("x,y,z", ZZ)
f, g, h = map(R.from_dense, dmp_fateman_poly_F_2(2, ZZ))
H, cff, cfg = R.dmp_zz_heu_gcd(f, g)
assert H == h and R.dmp_mul(H, cff) == f \
and R.dmp_mul(H, cfg) == g
H, cff, cfg = R.dmp_rr_prs_gcd(f, g)
assert H == h and R.dmp_mul(H, cff) == f \
and R.dmp_mul(H, cfg) == g
f, g, h = map(R.from_dense, dmp_fateman_poly_F_3(2, ZZ))
H, cff, cfg = R.dmp_zz_heu_gcd(f, g)
assert H == h and R.dmp_mul(H, cff) == f \
and R.dmp_mul(H, cfg) == g
H, cff, cfg = R.dmp_rr_prs_gcd(f, g)
assert H == h and R.dmp_mul(H, cff) == f \
and R.dmp_mul(H, cfg) == g
R, x, y, z, u, v = ring("x,y,z,u,v", ZZ)
f, g, h = map(R.from_dense, dmp_fateman_poly_F_3(4, ZZ))
H, cff, cfg = R.dmp_inner_gcd(f, g)
assert H == h and R.dmp_mul(H, cff) == f \
and R.dmp_mul(H, cfg) == g
R, x, y = ring("x,y", QQ)
f = QQ(1, 2) * x**2 + x + QQ(1, 2)
g = QQ(1, 2) * x + QQ(1, 2)
h = x + 1
assert R.dmp_qq_heu_gcd(f, g) == (h, g, QQ(1, 2))
assert R.dmp_ff_prs_gcd(f, g) == (h, g, QQ(1, 2))
R, x, y = ring("x,y", RR)
f = 2.1 * x * y**2 - 2.2 * x * y + 2.1 * x
g = 1.0 * x**3
assert R.dmp_ff_prs_gcd(f, g) == \
(1.0*x, 2.1*y**2 - 2.2*y + 2.1, 1.0*x**2)
def test_PythonRational__init__():
assert QQ(0).p == 0
assert QQ(0).q == 1
assert QQ(0, 1).p == 0
assert QQ(0, 1).q == 1
assert QQ(0, -1).p == 0
assert QQ(0, -1).q == 1
assert QQ(1).p == 1
assert QQ(1).q == 1
assert QQ(1, 1).p == 1
assert QQ(1, 1).q == 1
assert QQ(-1, -1).p == 1
assert QQ(-1, -1).q == 1
assert QQ(-1).p == -1
assert QQ(-1).q == 1
assert QQ(-1, 1).p == -1
assert QQ(-1, 1).q == 1
assert QQ(1, -1).p == -1
assert QQ(1, -1).q == 1
assert QQ(1, 2).p == 1
assert QQ(1, 2).q == 2
assert QQ(3, 4).p == 3
assert QQ(3, 4).q == 4
assert QQ(2, 2).p == 1
assert QQ(2, 2).q == 1
assert QQ(2, 4).p == 1
assert QQ(2, 4).q == 2
def _do_test_groebner():
R, x,y = ring("x,y", QQ, lex)
f = x**2 + 2*x*y**2
g = x*y + 2*y**3 - 1
assert groebner([f, g], R) == [x, y**3 - QQ(1,2)]
R, y,x = ring("y,x", QQ, lex)
f = 2*x**2*y + y**2
g = 2*x**3 + x*y - 1
assert groebner([f, g], R) == [y, x**3 - QQ(1,2)]
R, x,y,z = ring("x,y,z", QQ, lex)
f = x - z**2
g = y - z**3
assert groebner([f, g], R) == [f, g]
R, x,y = ring("x,y", QQ, grlex)
f = x**3 - 2*x*y
g = x**2*y + x - 2*y**2
assert groebner([f, g], R) == [x**2, x*y, -QQ(1,2)*x + y**2]
R, x,y,z = ring("x,y,z", QQ, lex)
f = -x**2 + y
g = -x**3 + z
assert groebner([f, g], R) == [x**2 - y, x*y - z, x*z - y**2, y**3 - z**2]
R, x,y,z = ring("x,y,z", QQ, grlex)
f = -x**2 + y
g = -x**3 + z
assert groebner([f, g], R) == [y**3 - z**2, x**2 - y, x*y - z, x*z - y**2]
R, x,y,z = ring("x,y,z", QQ, lex)
f = -x**2 + z
g = -x**3 + y
assert groebner([f, g], R) == [x**2 - z, x*y - z**2, x*z - y, y**2 - z**3]
R, x,y,z = ring("x,y,z", QQ, grlex)
f = -x**2 + z
g = -x**3 + y
assert groebner([f, g], R) == [-y**2 + z**3, x**2 - z, x*y - z**2, x*z - y]
R, x,y,z = ring("x,y,z", QQ, lex)
f = x - y**2
g = -y**3 + z
assert groebner([f, g], R) == [x - y**2, y**3 - z]
R, x,y,z = ring("x,y,z", QQ, grlex)
f = x - y**2
g = -y**3 + z
assert groebner([f, g], R) == [x**2 - y*z, x*y - z, -x + y**2]
R, x,y,z = ring("x,y,z", QQ, lex)
f = x - z**2
g = y - z**3
assert groebner([f, g], R) == [x - z**2, y - z**3]
R, x,y,z = ring("x,y,z", QQ, grlex)
f = x - z**2
g = y - z**3
assert groebner([f, g], R) == [x**2 - y*z, x*z - y, -x + z**2]
R, x,y,z = ring("x,y,z", QQ, lex)
f = -y**2 + z
g = x - y**3
assert groebner([f, g], R) == [x - y*z, y**2 - z]
R, x,y,z = ring("x,y,z", QQ, grlex)
f = -y**2 + z
g = x - y**3
assert groebner([f, g], R) == [-x**2 + z**3, x*y - z**2, y**2 - z, -x + y*z]
R, x,y,z = ring("x,y,z", QQ, lex)
f = y - z**2
g = x - z**3
assert groebner([f, g], R) == [x - z**3, y - z**2]
R, x,y,z = ring("x,y,z", QQ, grlex)
f = y - z**2
g = x - z**3
assert groebner([f, g], R) == [-x**2 + y**3, x*z - y**2, -x + y*z, -y + z**2]
R, x,y,z = ring("x,y,z", QQ, lex)
f = 4*x**2*y**2 + 4*x*y + 1
g = x**2 + y**2 - 1
assert groebner([f, g], R) == [
x - 4*y**7 + 8*y**5 - 7*y**3 + 3*y,
y**8 - 2*y**6 + QQ(3,2)*y**4 - QQ(1,2)*y**2 + QQ(1,16),
]
def test_PythonRational__pos__():
assert +QQ(-1, 2) == QQ(-1, 2)
assert +QQ(1, 2) == QQ(1, 2)
def test_is_groebner():
R, x,y = ring("x,y", QQ, grlex)
valid_groebner = [x**2, x*y, -QQ(1,2)*x + y**2]
invalid_groebner = [x**3, x*y, -QQ(1,2)*x + y**2]
assert is_groebner(valid_groebner, R) is True
assert is_groebner(invalid_groebner, R) is False
def test_PythonRational__neg__():
assert -QQ(-1, 2) == QQ(1, 2)
assert -QQ(1, 2) == QQ(-1, 2)
def test_nth_root():
R, x, y = ring('x, y', QQ)
r1 = rs_nth_root(1 + x**2 * y, 4, x, 10)
assert rs_nth_root(1 + x**2*y, 4, x, 10) == -77*x**8*y**4/2048 + \
7*x**6*y**3/128 - 3*x**4*y**2/32 + x**2*y/4 + 1
assert rs_nth_root(1 + x*y + x**2*y**3, 3, x, 5) == -x**4*y**6/9 + \
5*x**4*y**5/27 - 10*x**4*y**4/243 - 2*x**3*y**4/9 + 5*x**3*y**3/81 + \
x**2*y**3/3 - x**2*y**2/9 + x*y/3 + 1
assert rs_nth_root(8 * x, 3, x, 3) == 2 * x**QQ(1, 3)
assert rs_nth_root(8 * x + x**2 + x**3, 3, x,
3) == x**QQ(4, 3) / 12 + 2 * x**QQ(1, 3)
r = rs_nth_root(8 * x + x**2 * y + x**3, 3, x, 4)
assert r == -x**QQ(7, 3) * y**2 / 288 + x**QQ(7, 3) / 12 + x**QQ(
4, 3) * y / 12 + 2 * x**QQ(1, 3)
# Constant term in series
a = symbols('a')
R, x, y = ring('x, y', EX)
assert rs_nth_root(x + a, 3, x, 4) == EX(5/(81*a**QQ(8, 3)))*x**3 - \
EX(1/(9*a**QQ(5, 3)))*x**2 + EX(1/(3*a**QQ(2, 3)))*x + EX(a**QQ(1, 3))
assert rs_nth_root(x**QQ(2, 3) + x**2*y + 5, 2, x, 3) == -EX(sqrt(5)/100)*\
x**QQ(8, 3)*y - EX(sqrt(5)/16000)*x**QQ(8, 3) + EX(sqrt(5)/10)*x**2*y + \
EX(sqrt(5)/2000)*x**2 - EX(sqrt(5)/200)*x**QQ(4, 3) + \
EX(sqrt(5)/10)*x**QQ(2, 3) + EX(sqrt(5))
def test_PythonRational__add__():
assert QQ(-1, 2) + QQ(1, 2) == QQ(0)
assert QQ(1, 2) + QQ(-1, 2) == QQ(0)
assert QQ(1, 2) + QQ(1, 2) == QQ(1)
assert QQ(1, 2) + QQ(3, 2) == QQ(2)
assert QQ(3, 2) + QQ(1, 2) == QQ(2)
assert QQ(3, 2) + QQ(3, 2) == QQ(3)
assert 1 + QQ(1, 2) == QQ(3, 2)
assert QQ(1, 2) + 1 == QQ(3, 2)
def test1():
R, x = ring('x', QQ)
r = rs_sin(x, x, 15) * x**(-5)
assert r == x**8/6227020800 - x**6/39916800 + x**4/362880 - x**2/5040 + \
QQ(1,120) - x**-2/6 + x**-4
p = rs_sin(x, x, 10)
r = rs_nth_root(p, 2, x, 10)
assert r == -67*x**QQ(17,2)/29030400 - x**QQ(13,2)/24192 + \
x**QQ(9,2)/1440 - x**QQ(5,2)/12 + x**QQ(1,2)
p = rs_sin(x, x, 10)
r = rs_nth_root(p, 7, x, 10)
r = rs_pow(r, 5, x, 10)
assert r == -97*x**QQ(61,7)/124467840 - x**QQ(47,7)/16464 + \
11*x**QQ(33,7)/3528 - 5*x**QQ(19,7)/42 + x**QQ(5,7)
r = rs_exp(x**QQ(1, 2), x, 10)
assert r == x**QQ(19,2)/121645100408832000 + x**9/6402373705728000 + \
x**QQ(17,2)/355687428096000 + x**8/20922789888000 + \
x**QQ(15,2)/1307674368000 + x**7/87178291200 + \
x**QQ(13,2)/6227020800 + x**6/479001600 + x**QQ(11,2)/39916800 + \
x**5/3628800 + x**QQ(9,2)/362880 + x**4/40320 + x**QQ(7,2)/5040 + \
x**3/720 + x**QQ(5,2)/120 + x**2/24 + x**QQ(3,2)/6 + x/2 + \
x**QQ(1,2) + 1
def test_PythonRational__sub__():
assert QQ(-1, 2) - QQ(1, 2) == QQ(-1)
assert QQ(1, 2) - QQ(-1, 2) == QQ(1)
assert QQ(1, 2) - QQ(1, 2) == QQ(0)
assert QQ(1, 2) - QQ(3, 2) == QQ(-1)
assert QQ(3, 2) - QQ(1, 2) == QQ(1)
assert QQ(3, 2) - QQ(3, 2) == QQ(0)
assert 1 - QQ(1, 2) == QQ(1, 2)
assert QQ(1, 2) - 1 == QQ(-1, 2)
def test_dmp_subresultants():
assert dmp_resultant([[]], [[]], 1, ZZ) == []
assert dmp_prs_resultant([[]], [[]], 1, ZZ)[0] == []
assert dmp_zz_collins_resultant([[]], [[]], 1, ZZ) == []
assert dmp_qq_collins_resultant([[]], [[]], 1, ZZ) == []
assert dmp_resultant([[ZZ(1)]], [[]], 1, ZZ) == []
assert dmp_resultant([[ZZ(1)]], [[]], 1, ZZ) == []
assert dmp_resultant([[ZZ(1)]], [[]], 1, ZZ) == []
assert dmp_resultant([[]], [[ZZ(1)]], 1, ZZ) == []
assert dmp_prs_resultant([[]], [[ZZ(1)]], 1, ZZ)[0] == []
assert dmp_zz_collins_resultant([[]], [[ZZ(1)]], 1, ZZ) == []
assert dmp_qq_collins_resultant([[]], [[ZZ(1)]], 1, ZZ) == []
f = dmp_normal([[3, 0], [], [-1, 0, 0, -4]], 1, ZZ)
g = dmp_normal([[1], [1, 0, 0, 0], [-9]], 1, ZZ)
a = dmp_normal([[3, 0, 0, 0, 0], [1, 0, -27, 4]], 1, ZZ)
b = dmp_normal([[-3, 0, 0, -12, 1, 0, -54, 8, 729, -216, 16]], 1, ZZ)
r = dmp_LC(b, ZZ)
assert dmp_subresultants(f, g, 1, ZZ) == [f, g, a, b]
assert dmp_resultant(f, g, 1, ZZ) == r
assert dmp_prs_resultant(f, g, 1, ZZ)[0] == r
assert dmp_zz_collins_resultant(f, g, 1, ZZ) == r
assert dmp_qq_collins_resultant(f, g, 1, ZZ) == r
f = dmp_normal([[-1], [], [], [5]], 1, ZZ)
g = dmp_normal([[3, 1], [], []], 1, ZZ)
a = dmp_normal([[45, 30, 5]], 1, ZZ)
b = dmp_normal([[675, 675, 225, 25]], 1, ZZ)
r = dmp_LC(b, ZZ)
assert dmp_subresultants(f, g, 1, ZZ) == [f, g, a]
assert dmp_resultant(f, g, 1, ZZ) == r
assert dmp_prs_resultant(f, g, 1, ZZ)[0] == r
assert dmp_zz_collins_resultant(f, g, 1, ZZ) == r
assert dmp_qq_collins_resultant(f, g, 1, ZZ) == r
f = [[[[[6]]]], [[[[-3]]], [[[-2]], [[]]]], [[[[1]], [[]]], [[[]]]]]
g = [[[[[1]]]], [[[[-1], [-1, 0]]]], [[[[1, 0], []]]]]
r = [[[[1]], [[-3], [-3, 0]], [[9, 0], []]],
[[[-2], [-2, 0]], [[6], [12, 0], [6, 0, 0]],
[[-18, 0], [-18, 0, 0], []]],
[[[4, 0], []], [[-12, 0], [-12, 0, 0], []], [[36, 0, 0], [], []]]]
assert dmp_zz_collins_resultant(f, g, 4, ZZ) == r
f = [[[[[QQ(1, 1)]]]], [[[[QQ(-1, 2)]]], [[[QQ(-1, 3)]], [[]]]],
[[[[QQ(1, 6)]], [[]]], [[[]]]]]
g = [[[[[QQ(1, 1)]]]], [[[[QQ(-1, 1)], [QQ(-1, 1), QQ(0, 1)]]]],
[[[[QQ(1, 1), QQ(0, 1)], []]]]]
r = [[[[QQ(1, 36)]], [[QQ(-1, 12)], [QQ(-1, 12), QQ(0, 1)]],
[[QQ(1, 4), QQ(0, 1)], []]],
[[[QQ(-1, 18)], [QQ(-1, 18), QQ(0, 1)]],
[[QQ(1, 6)], [QQ(1, 3), QQ(0, 1)], [QQ(1, 6),
QQ(0, 1),
QQ(0, 1)]],
[[QQ(-1, 2), QQ(0, 1)], [QQ(-1, 2), QQ(0, 1),
QQ(0, 1)], []]],
[[[QQ(1, 9), QQ(0, 1)], []],
[[QQ(-1, 3), QQ(0, 1)], [QQ(-1, 3), QQ(0, 1),
QQ(0, 1)], []],
[[QQ(1, 1), QQ(0, 1), QQ(0, 1)], [], []]]]
assert dmp_qq_collins_resultant(f, g, 4, QQ) == r
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) is True
assert (a != a) is False
assert (a == b) is False
assert (a != b) is True
b = ANP([QQ(1), QQ(2)], [QQ(1), QQ(0), QQ(1)], QQ)
assert (a == b) is False
assert (a != b) is True
