def laguerre_poly(n, x=None, alpha=None, polys=False):
"""Generates Laguerre polynomial of degree `n` in `x`.
Parameters
==========
n : int
`n` decides the degree of polynomial
x : optional
alpha
Decides minimal domain for the list
of coefficients.
polys : bool, optional
``polys=True`` returns an expression, otherwise
(default) returns an expression.
"""
if n < 0:
raise ValueError("can't generate Laguerre polynomial of degree %s" % n)
if alpha is not None:
K, alpha = construct_domain(
alpha, field=True) # XXX: ground_field=True
else:
K, alpha = QQ, QQ(0)
poly = DMP(dup_laguerre(int(n), alpha, K), K)
if x is not None:
poly = Poly.new(poly, x)
else:
poly = PurePoly.new(poly, Dummy('x'))
return poly if polys else poly.as_expr()
def gegenbauer_poly(n, a, x=None, polys=False):
"""Generates Gegenbauer polynomial of degree `n` in `x`.
Parameters
==========
n : int
`n` decides the degree of polynomial
x : optional
a
Decides minimal domain for the list of
coefficients.
polys : bool, optional
``polys=True`` returns an expression, otherwise
(default) returns an expression.
"""
if n < 0:
raise ValueError(
"can't generate Gegenbauer polynomial of degree %s" % n)
K, a = construct_domain(a, field=True)
poly = DMP(dup_gegenbauer(int(n), a, K), K)
if x is not None:
poly = Poly.new(poly, x)
else:
poly = PurePoly.new(poly, Dummy('x'))
return poly if polys else poly.as_expr()
def test_DUP_to_dict():
f = DMP([[3],[],[2],[],[8]], ZZ)
assert f.to_dict() == \
{(4, 0): 3, (2, 0): 2, (0, 0): 8}
assert f.to_sympy_dict() == \
{(4, 0): ZZ.to_sympy(3), (2, 0): ZZ.to_sympy(2), (0, 0): ZZ.to_sympy(8)}
def chebyshevu_poly(n, x=None, polys=False):
"""Generates Chebyshev polynomial of the second kind of degree `n` in `x`.
Parameters
==========
n : int
`n` decides the degree of polynomial
x : optional
polys : bool, optional
``polys=True`` returns an expression, otherwise
(default) returns an expression.
"""
if n < 0:
raise ValueError(
"can't generate 2nd kind Chebyshev polynomial of degree %s" % n)
poly = DMP(dup_chebyshevu(int(n), ZZ), ZZ)
if x is not None:
poly = Poly.new(poly, x)
else:
poly = PurePoly.new(poly, Dummy('x'))
return poly if polys else poly.as_expr()
def jacobi_poly(n, a, b, x=None, polys=False):
"""Generates Jacobi polynomial of degree `n` in `x`.
Parameters
==========
n : int
`n` decides the degree of polynomial
a
Lower limit of minimal domain for the list of
coefficients.
b
Upper limit of minimal domain for the list of
coefficients.
x : optional
polys : bool, optional
``polys=True`` returns an expression, otherwise
(default) returns an expression.
"""
if n < 0:
raise ValueError("can't generate Jacobi polynomial of degree %s" % n)
K, v = construct_domain([a, b], field=True)
poly = DMP(dup_jacobi(int(n), v[0], v[1], K), K)
if x is not None:
poly = Poly.new(poly, x)
else:
poly = PurePoly.new(poly, Dummy('x'))
return poly if polys else poly.as_expr()
def spherical_bessel_fn(n, x=None, polys=False):
"""
Coefficients for the spherical Bessel functions.
Those are only needed in the jn() function.
The coefficients are calculated from:
fn(0, z) = 1/z
fn(1, z) = 1/z**2
fn(n-1, z) + fn(n+1, z) == (2*n+1)/z * fn(n, z)
Parameters
==========
n : int
`n` decides the degree of polynomial
x : optional
polys : bool, optional
``polys=True`` returns an expression, otherwise
(default) returns an expression.
Examples
========
>>> from sympy.polys.orthopolys import spherical_bessel_fn as fn
>>> from sympy import Symbol
>>> z = Symbol("z")
>>> fn(1, z)
z**(-2)
>>> fn(2, z)
-1/z + 3/z**3
>>> fn(3, z)
-6/z**2 + 15/z**4
>>> fn(4, z)
1/z - 45/z**3 + 105/z**5
"""
if n < 0:
dup = dup_spherical_bessel_fn_minus(-int(n), ZZ)
else:
dup = dup_spherical_bessel_fn(int(n), ZZ)
poly = DMP(dup, ZZ)
if x is not None:
poly = Poly.new(poly, 1/x)
else:
poly = PurePoly.new(poly, 1/Dummy('x'))
return poly if polys else poly.as_expr()
def __new__(cls, expr, coeffs=Tuple(), alias=None, **args):
"""Construct a new algebraic number. """
expr = sympify(expr)
if isinstance(expr, (tuple, Tuple)):
minpoly, root = expr
if not minpoly.is_Poly:
minpoly = Poly(minpoly)
elif expr.is_AlgebraicNumber:
minpoly, root = expr.minpoly, expr.root
else:
minpoly, root = minimal_polynomial(
expr, args.get('gen'), polys=True), expr
dom = minpoly.get_domain()
if coeffs != Tuple():
if not isinstance(coeffs, ANP):
rep = DMP.from_sympy_list(sympify(coeffs), 0, dom)
scoeffs = Tuple(*coeffs)
else:
rep = DMP.from_list(coeffs.to_list(), 0, dom)
scoeffs = Tuple(*coeffs.to_list())
if rep.degree() >= minpoly.degree():
rep = rep.rem(minpoly.rep)
sargs = (root, scoeffs)
else:
rep = DMP.from_list([1, 0], 0, dom)
if ask(Q.negative(root)):
rep = -rep
sargs = (root, coeffs)
if alias is not None:
if not isinstance(alias, Symbol):
alias = Symbol(alias)
sargs = sargs + (alias,)
obj = Expr.__new__(cls, *sargs)
obj.rep = rep
obj.root = root
obj.alias = alias
obj.minpoly = minpoly
return obj
def legendre_poly(n, x=None, **args):
"""Generates Legendre polynomial of degree `n` in `x`. """
if n < 0:
raise ValueError("can't generate Legendre polynomial of degree %s" % n)
poly = DMP(dup_legendre(int(n), QQ), QQ)
if x is not None:
poly = Poly.new(poly, x)
else:
poly = PurePoly.new(poly, Dummy('x'))
if not args.get('polys', False):
return poly.as_expr()
else:
return poly
def chebyshevu_poly(n, x=None, **args):
"""Generates Chebyshev polynomial of the second kind of degree `n` in `x`. """
if n < 0:
raise ValueError("can't generate 2nd kind Chebyshev polynomial of degree %s" % n)
poly = DMP(dup_chebyshevu(int(n), ZZ), ZZ)
if x is not None:
poly = Poly.new(poly, x)
else:
poly = PurePoly.new(poly, Dummy('x'))
if not args.get('polys', False):
return poly.as_expr()
else:
return poly
def cyclotomic_poly(n, x=None, **args):
"""Generates cyclotomic polynomial of order `n` in `x`. """
if n <= 0:
raise ValueError("can't generate cyclotomic polynomial of order %s" % n)
poly = DMP(dup_zz_cyclotomic_poly(int(n), ZZ), ZZ)
if x is not None:
poly = Poly.new(poly, x)
else:
poly = PurePoly.new(poly, Dummy('x'))
if not args.get('polys', False):
return poly.as_expr()
else:
return poly
def spherical_bessel_fn(n, x=None, **args):
"""
Coefficients for the spherical Bessel functions.
Those are only needed in the jn() function.
The coefficients are calculated from:
fn(0, z) = 1/z
fn(1, z) = 1/z**2
fn(n-1, z) + fn(n+1, z) == (2*n+1)/z * fn(n, z)
Examples
========
>>> from sympy.polys.orthopolys import spherical_bessel_fn as fn
>>> from sympy import Symbol
>>> z = Symbol("z")
>>> fn(1, z)
z**(-2)
>>> fn(2, z)
-1/z + 3/z**3
>>> fn(3, z)
-6/z**2 + 15/z**4
>>> fn(4, z)
1/z - 45/z**3 + 105/z**5
"""
from sympy import sympify
if n < 0:
dup = dup_spherical_bessel_fn_minus(-int(n), ZZ)
else:
dup = dup_spherical_bessel_fn(int(n), ZZ)
poly = DMP(dup, ZZ)
if x is not None:
poly = Poly.new(poly, 1/x)
else:
poly = PurePoly.new(poly, 1/Dummy('x'))
if not args.get('polys', False):
return poly.as_expr()
else:
return poly
def gegenbauer_poly(n, a, x=None, **args):
"""Generates Gegenbauer polynomial of degree `n` in `x`. """
if n < 0:
raise ValueError("can't generate Gegenbauer polynomial of degree %s" % n)
K, a = construct_domain(a, field=True)
poly = DMP(dup_gegenbauer(int(n), a, K), K)
if x is not None:
poly = Poly.new(poly, x)
else:
poly = PurePoly.new(poly, Dummy('x'))
if not args.get('polys', False):
return poly.as_expr()
else:
return poly
def jacobi_poly(n, a, b, x=None, **args):
"""Generates Jacobi polynomial of degree `n` in `x`. """
if n < 0:
raise ValueError("can't generate Jacobi polynomial of degree %s" % n)
K, v = construct_domain([a, b], field=True)
poly = DMP(dup_jacobi(int(n), v[0], v[1], K), K)
if x is not None:
poly = Poly.new(poly, x)
else:
poly = PurePoly.new(poly, Dummy('x'))
if not args.get('polys', False):
return poly.as_expr()
else:
return poly
def test_polys():
x = Symbol("x")
ZZ = PythonIntegerRing()
QQ = SymPyRationalField()
for c in (Poly, Poly(x, x)):
check(c)
for c in (GFP, GFP([ZZ(1), ZZ(2), ZZ(3)], ZZ(7), ZZ)):
check(c)
for c in (DMP, DMP([ZZ(1), ZZ(2), ZZ(3)], 0, ZZ)):
check(c)
for c in (DMF, DMF(([ZZ(1), ZZ(2)], [ZZ(1), ZZ(3)], ZZ))):
check(c)
for c in (ANP, ANP([QQ(1), QQ(2)], [QQ(1), QQ(2), QQ(3)], QQ)):
check(c)
for c in (PythonIntegerRing, PythonIntegerRing()):
check(c)
for c in (SymPyIntegerRing, SymPyIntegerRing()):
check(c)
for c in (SymPyRationalField, SymPyRationalField()):
check(c)
for c in (PolynomialRing, PolynomialRing(ZZ, 'x', 'y')):
check(c)
for c in (FractionField, FractionField(ZZ, 'x', 'y')):
check(c)
for c in (ExpressionDomain, ExpressionDomain()):
check(c)
from sympy.polys.domains import HAS_FRACTION, HAS_GMPY
if HAS_FRACTION:
from sympy.polys.domains import PythonRationalField
for c in (PythonRationalField, PythonRationalField()):
check(c)
if HAS_GMPY:
from sympy.polys.domains import GMPYIntegerRing, GMPYRationalField
for c in (GMPYIntegerRing, GMPYIntegerRing()):
check(c)
for c in (GMPYRationalField, GMPYRationalField()):
check(c)
f = x**3 + x + 3
g = lambda x: x
for c in (RootOf, RootOf(f, 0), RootSum, RootSum(f, g)):
check(c)
def laguerre_poly(n, x=None, alpha=None, **args):
"""Generates Laguerre polynomial of degree `n` in `x`. """
if n < 0:
raise ValueError("can't generate Laguerre polynomial of degree %s" % n)
if alpha is not None:
K, alpha = construct_domain(alpha, field=True) # XXX: ground_field=True
else:
K, alpha = QQ, QQ(0)
poly = DMP(dup_laguerre(int(n), alpha, K), K)
if x is not None:
poly = Poly.new(poly, x)
else:
poly = PurePoly.new(poly, Dummy('x'))
if not args.get('polys', False):
return poly.as_expr()
else:
return poly
def laguerre_poly(n, x=None, alpha=None, **args):
"""Generates Laguerre polynomial of degree `n` in `x`. """
if n < 0:
raise ValueError("can't generate Laguerre polynomial of degree %s" % n)
if alpha is not None:
K, alpha = construct_domain(alpha,
field=True) # XXX: ground_field=True
else:
K, alpha = QQ, QQ(0)
poly = DMP(dup_laguerre(int(n), alpha, K), K)
if x is not None:
poly = Poly.new(poly, x)
else:
poly = PurePoly.new(poly, Dummy('x'))
if not args.get('polys', False):
return poly.as_expr()
else:
return poly
def cyclotomic_poly(n, x=None, polys=False):
"""Generates cyclotomic polynomial of order `n` in `x`.
Parameters
----------
n : int
`n` decides the order of polynomial
x : optional
polys : bool, optional
``polys=True`` returns an expression, otherwise
(default) returns an expression.
"""
if n <= 0:
raise ValueError("can't generate cyclotomic polynomial of order %s" % n)
poly = DMP(dup_zz_cyclotomic_poly(int(n), ZZ), ZZ)
if x is not None:
poly = Poly.new(poly, x)
else:
poly = PurePoly.new(poly, Dummy("x"))
return poly if polys else poly.as_expr()
def legendre_poly(n, x=None, polys=False):
"""Generates Legendre polynomial of degree `n` in `x`.
Parameters
----------
n : int
`n` decides the degree of polynomial
x : optional
polys : bool, optional
``polys=True`` returns an expression, otherwise
(default) returns an expression.
"""
if n < 0:
raise ValueError("can't generate Legendre polynomial of degree %s" % n)
poly = DMP(dup_legendre(int(n), QQ), QQ)
if x is not None:
poly = Poly.new(poly, x)
else:
poly = PurePoly.new(poly, Dummy('x'))
return poly if polys else poly.as_expr()
def legendre_poly(n, x=None, polys=False):
"""Generates Legendre polynomial of degree `n` in `x`.
Parameters
----------
n : int
`n` decides the degree of polynomial
x : optional
polys : bool, optional
``polys=True`` returns an expression, otherwise
(default) returns an expression.
"""
if n < 0:
raise ValueError("can't generate Legendre polynomial of degree %s" % n)
poly = DMP(dup_legendre(int(n), QQ), QQ)
if x is not None:
poly = Poly.new(poly, x)
else:
poly = PurePoly.new(poly, Dummy('x'))
return poly if polys else poly.as_expr()
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 cyclotomic_poly(n, x=None, polys=False):
"""Generates cyclotomic polynomial of order `n` in `x`.
Parameters
----------
n : int
`n` decides the order of polynomial
x : optional
polys : bool, optional
``polys=True`` returns an expression, otherwise
(default) returns an expression.
"""
if n <= 0:
raise ValueError(
"can't generate cyclotomic polynomial of order %s" % n)
poly = DMP(dup_zz_cyclotomic_poly(int(n), ZZ), ZZ)
if x is not None:
poly = Poly.new(poly, x)
else:
poly = PurePoly.new(poly, Dummy('x'))
return poly if polys else poly.as_expr()
def cyclotomic_poly(n, x=None, **args):
"""Generates cyclotomic polynomial of order `n` in `x`. """
if n <= 0:
raise ValueError("can't generate cyclotomic polynomial of order %s" % n)
if x is not None:
x = sympify(x)
else:
x = Dummy('x')
poly = Poly(DMP(dup_zz_cyclotomic_poly(int(n), ZZ), ZZ), x)
if not args.get('polys', False):
return poly.as_basic()
else:
return poly
def laguerre_poly(n, x=None, **args):
"""Generates Laguerre polynomial of degree `n` in `x`. """
if n < 0:
raise ValueError("can't generate Laguerre polynomial of degree %s" % n)
if x is not None:
x = sympify(x)
else:
x = Dummy('x')
poly = Poly.new(DMP(dup_laguerre(int(n), QQ), QQ), x)
if not args.get('polys', False):
return poly.as_expr()
else:
return poly
def chebyshevu_poly(n, x=None, **args):
"""Generates Chebyshev polynomial of the second kind of degree `n` in `x`. """
if n < 0:
raise ValueError("can't generate 2nd kind Chebyshev polynomial of degree %s" % n)
if x is not None:
x = sympify(x)
else:
x = Dummy('x')
poly = Poly(DMP(dup_chebyshevu(int(n), ZZ), ZZ), x)
if not args.get('polys', False):
return poly.as_basic()
else:
return poly
def hermite_poly(n, x=None, **args):
"""Generates Hermite polynomial of degree `n` in `x`. """
if n < 0:
raise ValueError("can't generate Hermite polynomial of degree %s" % n)
if x is not None:
x = sympify(x)
else:
x = Symbol('x', dummy=True)
poly = Poly(DMP(dup_hermite(int(n), ZZ), ZZ), x)
if not args.get('polys', False):
return poly.as_basic()
else:
return poly
def chebyshevt_poly(n, x=None, **args):
"""Generates Chebyshev polynomial of the first kind of degree `n` in `x`. """
if n < 0:
raise ValueError(
"can't generate 1st kind Chebyshev polynomial of degree %s" % n)
if x is not None:
x = sympify(x)
else:
x = Symbol('x', dummy=True)
poly = Poly(DMP(dup_chebyshevt(int(n), ZZ), ZZ), x)
if not args.get('polys', False):
return poly.as_basic()
else:
return poly
def test_polys():
x = Symbol("X")
ZZ = PythonIntegerRing()
QQ = PythonRationalField()
for c in (Poly, Poly(x, x)):
check(c)
for c in (DMP, DMP([[ZZ(1)], [ZZ(2)], [ZZ(3)]], ZZ)):
check(c)
for c in (DMF, DMF(([ZZ(1), ZZ(2)], [ZZ(1), ZZ(3)]), ZZ)):
check(c)
for c in (ANP, ANP([QQ(1), QQ(2)], [QQ(1), QQ(2), QQ(3)], QQ)):
check(c)
for c in (PythonIntegerRing, PythonIntegerRing()):
check(c)
for c in (PythonRationalField, PythonRationalField()):
check(c)
for c in (PolynomialRing, PolynomialRing(ZZ, 'x', 'y')):
check(c)
for c in (FractionField, FractionField(ZZ, 'x', 'y')):
check(c)
for c in (ExpressionDomain, ExpressionDomain()):
check(c)
from sympy.core.compatibility import HAS_GMPY
if HAS_GMPY:
from sympy.polys.domains import GMPYIntegerRing, GMPYRationalField
for c in (GMPYIntegerRing, GMPYIntegerRing()):
check(c)
for c in (GMPYRationalField, GMPYRationalField()):
check(c)
f = x**3 + x + 3
g = exp
for c in (RootOf, RootOf(f, 0), RootSum, RootSum(f, g)):
check(c)
def test_PolynomialRing__from_FractionField():
f = DMF(([1, 0, 1], [1, 1]), ZZ)
g = DMF(([1, 0, 1], [1]), ZZ)
assert ZZ[x].from_FractionField(f, ZZ[x]) is None
assert ZZ[x].from_FractionField(g, ZZ[x]) == DMP([ZZ(1), ZZ(0), ZZ(1)], ZZ)
def test_DMP():
assert srepr(DMP([1, 2], ZZ)) == 'DMP([1, 2], ZZ)'
assert srepr(ZZ.old_poly_ring(x)([1, 2])) == \
"DMP([1, 2], ZZ, ring=GlobalPolynomialRing(ZZ, Symbol('x')))"
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_Domain_convert():
assert QQ.convert(10e-52) != QQ(0)
assert ZZ.convert(DMP([[ZZ(1)]], ZZ)) == ZZ(1)
def test_dup_factor_list():
assert dup_factor_list([], ZZ) == (ZZ(0), [])
assert dup_factor_list([], QQ) == (QQ(0), [])
assert dup_factor_list([], ZZ['y']) == (DMP([],ZZ), [])
assert dup_factor_list([], QQ['y']) == (DMP([],QQ), [])
assert dup_factor_list_include([], ZZ) == [([], 1)]
assert dup_factor_list([ZZ(7)], ZZ) == (ZZ(7), [])
assert dup_factor_list([QQ(1,7)], QQ) == (QQ(1,7), [])
assert dup_factor_list([DMP([ZZ(7)],ZZ)], ZZ['y']) == (DMP([ZZ(7)],ZZ), [])
assert dup_factor_list([DMP([QQ(1,7)],QQ)], QQ['y']) == (DMP([QQ(1,7)],QQ), [])
assert dup_factor_list_include([ZZ(7)], ZZ) == [([ZZ(7)], 1)]
assert dup_factor_list([ZZ(1),ZZ(2),ZZ(1)], ZZ) == \
(ZZ(1), [([ZZ(1), ZZ(1)], 2)])
assert dup_factor_list([QQ(1,2),QQ(1),QQ(1,2)], QQ) == \
(QQ(1,2), [([QQ(1),QQ(1)], 2)])
assert dup_factor_list_include([ZZ(1),ZZ(2),ZZ(1)], ZZ) == \
[([ZZ(1), ZZ(1)], 2)]
K = FF(2)
assert dup_factor_list([K(1),K(0),K(1)], K) == \
(K(1), [([K(1), K(1)], 2)])
assert dup_factor_list([RR(1.0),RR(2.0),RR(1.0)], RR) == \
(RR(1.0), [([RR(1.0),RR(1.0)], 2)])
assert dup_factor_list([RR(2.0),RR(4.0),RR(2.0)], RR) == \
(RR(2.0), [([RR(1.0),RR(1.0)], 2)])
f = [DMP([ZZ(4),ZZ(0)],ZZ),DMP([ZZ(4),ZZ(0),ZZ(0)],ZZ),DMP([],ZZ)]
assert dup_factor_list(f, ZZ['y']) == \
(DMP([ZZ(4)],ZZ), [([DMP([ZZ(1),ZZ(0)],ZZ)], 1),
([DMP([ZZ(1)],ZZ),DMP([],ZZ)], 1),
([DMP([ZZ(1)],ZZ),DMP([ZZ(1),ZZ(0)],ZZ)], 1)])
f = [DMP([QQ(1,2),QQ(0)],ZZ),DMP([QQ(1,2),QQ(0),QQ(0)],ZZ),DMP([],ZZ)]
assert dup_factor_list(f, QQ['y']) == \
(DMP([QQ(1,2)],QQ), [([DMP([QQ(1),QQ(0)],QQ)], 1),
([DMP([QQ(1)],QQ),DMP([],QQ)], 1),
([DMP([QQ(1)],QQ),DMP([QQ(1),QQ(0)],QQ)], 1)])
K = QQ.algebraic_field(I)
h = [QQ(1,1), QQ(0,1), QQ(1,1)]
f = [ANP([QQ(1,1)], h, QQ), ANP([], h, QQ), ANP([QQ(2,1)], h, QQ), ANP([], h, QQ), ANP([], h, QQ)]
assert dup_factor_list(f, K) == \
(ANP([QQ(1,1)], h, QQ), [([ANP([QQ(1,1)], h, QQ), ANP([], h, QQ)], 2),
([ANP([QQ(1,1)], h, QQ), ANP([], h, QQ), ANP([QQ(2,1)], h, QQ)], 1)])
raises(DomainError, "dup_factor_list([EX(sin(1))], EX)")
def test_DMP_arithmetics():
f = DMP([[2],[2,0]], ZZ)
assert f.mul_ground(2) == DMP([[4],[4,0]], ZZ)
assert f.exquo_ground(2) == DMP([[1],[1,0]], ZZ)
raises(ExactQuotientFailed, 'f.quo_ground(3)')
f = DMP([[-5]], ZZ)
g = DMP([[5]], ZZ)
assert f.abs() == g
assert abs(f) == g
assert g.neg() == f
assert -g == f
h = DMP([[]], ZZ)
assert f.add(g) == h
assert f + g == h
assert g + f == h
assert f + 5 == h
assert 5 + f == h
h = DMP([[-10]], ZZ)
assert f.sub(g) == h
assert f - g == h
assert g - f == -h
assert f - 5 == h
assert 5 - f == -h
h = DMP([[-25]], ZZ)
assert f.mul(g) == h
assert f * g == h
assert g * f == h
assert f * 5 == h
assert 5 * f == h
h = DMP([[25]], ZZ)
assert f.sqr() == h
assert f.pow(2) == h
assert f**2 == h
raises(TypeError, "f.pow('x')")
f = DMP([[1],[],[1,0,0]], ZZ)
g = DMP([[2],[-2,0]], ZZ)
q = DMP([[2],[2,0]], ZZ)
r = DMP([[8,0,0]], ZZ)
assert f.pdiv(g) == (q, r)
assert f.pexquo(g) == q
assert f.prem(g) == r
raises(ExactQuotientFailed, 'f.pquo(g)')
f = DMP([[1],[],[1,0,0]], ZZ)
g = DMP([[1],[-1,0]], ZZ)
q = DMP([[1],[1,0]], ZZ)
r = DMP([[2,0,0]], ZZ)
assert f.div(g) == (q, r)
assert f.exquo(g) == q
assert f.rem(g) == r
assert divmod(f, g) == (q, r)
assert f // g == q
assert f % g == r
raises(ExactQuotientFailed, 'f.quo(g)')
def test_DMP_arithmetics():
f = DMP([[2],[2,0]], ZZ)
assert f.mul_ground(2) == DMP([[4],[4,0]], ZZ)
assert f.exquo_ground(2) == DMP([[1],[1,0]], ZZ)
raises(ExactQuotientFailed, 'f.quo_ground(3)')
f = DMP([[-5]], ZZ)
g = DMP([[5]], ZZ)
assert f.abs() == g
assert abs(f) == g
assert g.neg() == f
assert -g == f
h = DMP([[]], ZZ)
assert f.add(g) == h
assert f + g == h
assert g + f == h
assert f + 5 == h
assert 5 + f == h
h = DMP([[-10]], ZZ)
assert f.sub(g) == h
assert f - g == h
assert g - f == -h
assert f - 5 == h
assert 5 - f == -h
h = DMP([[-25]], ZZ)
assert f.mul(g) == h
assert f * g == h
assert g * f == h
assert f * 5 == h
assert 5 * f == h
h = DMP([[25]], ZZ)
assert f.sqr() == h
assert f.pow(2) == h
assert f**2 == h
raises(TypeError, "f.pow('x')")
f = DMP([[1],[],[1,0,0]], ZZ)
g = DMP([[2],[-2,0]], ZZ)
q = DMP([[2],[2,0]], ZZ)
r = DMP([[8,0,0]], ZZ)
assert f.pdiv(g) == (q, r)
assert f.pexquo(g) == q
assert f.prem(g) == r
raises(ExactQuotientFailed, 'f.pquo(g)')
f = DMP([[1],[],[1,0,0]], ZZ)
g = DMP([[1],[-1,0]], ZZ)
q = DMP([[1],[1,0]], ZZ)
r = DMP([[2,0,0]], ZZ)
assert f.div(g) == (q, r)
assert f.exquo(g) == q
assert f.rem(g) == r
assert divmod(f, g) == (q, r)
assert f // g == q
assert f % g == r
raises(ExactQuotientFailed, 'f.quo(g)')
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_number
assert a.is_aliased is False
assert a.coeffs() == [S.One, S.Zero]
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_number
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_number
assert a.is_aliased is True
assert AlgebraicNumber(sqrt(2), []).rep == DMP([], QQ)
assert AlgebraicNumber(sqrt(2), ()).rep == DMP([], QQ)
assert AlgebraicNumber(sqrt(2), (0, 0)).rep == DMP([], QQ)
assert AlgebraicNumber(sqrt(2), [8]).rep == DMP([QQ(8)], QQ)
assert AlgebraicNumber(sqrt(2), [Rational(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), [Rational(7, 9), Rational(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_number
assert a.is_aliased is False
assert a.coeffs() == [S.One, 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_number
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_number
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)
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, domain='QQ')
assert b.as_poly() == Poly(y, domain='QQ')
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, domain='QQ')
assert b.as_poly() == Poly(2*y + 3, domain='QQ')
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(1, 0))
b = AlgebraicNumber(sqrt(2), alias='alpha')
assert b.args == (sqrt(2), Tuple(1, 0), Symbol('alpha'))
a = AlgebraicNumber(sqrt(2), [1, 2, 3])
assert a.args == (sqrt(2), Tuple(1, 2, 3))
a = AlgebraicNumber(sqrt(2), [1, 2], "alpha")
b = AlgebraicNumber(a)
c = AlgebraicNumber(a, alias="gamma")
assert a == b
assert c.alias.name == "gamma"
a = AlgebraicNumber(sqrt(2) + sqrt(3), [S(1)/2, 0, S(-9)/2, 0])
b = AlgebraicNumber(a, [1, 0, 0])
assert b.root == a.root
assert a.to_root() == sqrt(2)
assert b.to_root() == 2
a = AlgebraicNumber(2)
assert a.is_primitive_element is True
def test_dmp_factor_list():
R, x, y = ring("x,y", ZZ)
assert R.dmp_factor_list(0) == (ZZ(0), [])
assert R.dmp_factor_list(7) == (7, [])
R, x, y = ring("x,y", QQ)
assert R.dmp_factor_list(0) == (QQ(0), [])
assert R.dmp_factor_list(QQ(1, 7)) == (QQ(1, 7), [])
R, x, y = ring("x,y", ZZ['y'])
assert R.dmp_factor_list(0) == (DMP([], ZZ), [])
assert R.dmp_factor_list(DMP([ZZ(7)], ZZ)) == (DMP([ZZ(7)], ZZ), [])
R, x, y = ring("x,y", QQ['y'])
assert R.dmp_factor_list(0) == (DMP([], QQ), [])
assert R.dmp_factor_list(DMP([QQ(1, 7)], QQ)) == (DMP([QQ(1, 7)], QQ), [])
R, x, y = ring("x,y", ZZ)
assert R.dmp_factor_list_include(0) == [(0, 1)]
assert R.dmp_factor_list_include(7) == [(7, 1)]
R, X = xring("x:200", ZZ)
f, g = X[0]**2 + 2 * X[0] + 1, X[0] + 1
assert R.dmp_factor_list(f) == (1, [(g, 2)])
f, g = X[-1]**2 + 2 * X[-1] + 1, X[-1] + 1
assert R.dmp_factor_list(f) == (1, [(g, 2)])
R, x = ring("x", ZZ)
assert R.dmp_factor_list(x**2 + 2 * x + 1) == (1, [(x + 1, 2)])
R, x = ring("x", QQ)
assert R.dmp_factor_list(QQ(1, 2) * x**2 + x + QQ(1, 2)) == (QQ(1, 2),
[(x + 1, 2)])
R, x, y = ring("x,y", ZZ)
assert R.dmp_factor_list(x**2 + 2 * x + 1) == (1, [(x + 1, 2)])
R, x, y = ring("x,y", QQ)
assert R.dmp_factor_list(QQ(1, 2) * x**2 + x + QQ(1, 2)) == (QQ(1, 2),
[(x + 1, 2)])
R, x, y = ring("x,y", ZZ)
f = 4 * x**2 * y + 4 * x * y**2
assert R.dmp_factor_list(f) == \
(4, [(y, 1),
(x, 1),
(x + y, 1)])
assert R.dmp_factor_list_include(f) == \
[(4*y, 1),
(x, 1),
(x + y, 1)]
R, x, y = ring("x,y", QQ)
f = QQ(1, 2) * x**2 * y + QQ(1, 2) * x * y**2
assert R.dmp_factor_list(f) == \
(QQ(1,2), [(y, 1),
(x, 1),
(x + y, 1)])
R, x, y = ring("x,y", RR)
f = 2.0 * x**2 - 8.0 * y**2
assert R.dmp_factor_list(f) == \
(RR(2.0), [(1.0*x - 2.0*y, 1),
(1.0*x + 2.0*y, 1)])
R, x, y = ring("x,y", ZZ['t'])
f = DMP([ZZ(4), ZZ(0)], ZZ) * x**2 + DMP([ZZ(4), ZZ(0), ZZ(0)], ZZ) * x
assert R.dmp_factor_list(f) == \
(DMP([ZZ(4)], ZZ), [(DMP([ZZ(1), ZZ(0)], ZZ), 1),
(DMP([ZZ(1)], ZZ)*x, 1),
(DMP([ZZ(1)], ZZ)*x + DMP([ZZ(1), ZZ(0)], ZZ), 1)])
R, x, y = ring("x,y", QQ['t'])
f = DMP([QQ(1, 2), QQ(0)], QQ) * x**2 + DMP(
[QQ(1, 2), QQ(0), QQ(0)], QQ) * x
assert R.dmp_factor_list(f) == \
(DMP([QQ(1, 2)], QQ), [(DMP([QQ(1), QQ(0)], QQ), 1),
(DMP([QQ(1)], QQ)*x, 1),
(DMP([QQ(1)], QQ)*x + DMP([QQ(1), QQ(0)], QQ), 1)])
R, x, y = ring("x,y", FF(2))
raises(NotImplementedError, lambda: R.dmp_factor_list(x**2 + y**2))
R, x, y = ring("x,y", EX)
raises(DomainError, lambda: R.dmp_factor_list(EX(sin(1))))
def __call__(self, a):
"""Construct an element of `self` domain from `a`. """
return DMP(a, self.dom, len(self.gens) - 1)
def test_DMP_exclude():
f = [[[[[[[[[[[[[[[[[[[[[[[[[[1]], [[]]]]]]]]]]]]]]]]]]]]]]]]]]
J = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 24, 25]
assert DMP(f, ZZ).exclude() == (J, DMP([1, 0], ZZ))
assert DMP([[1], [1, 0]], ZZ).exclude() == ([], DMP([[1], [1, 0]], ZZ))
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_DMP_properties():
assert DMP([[]], ZZ).is_zero is True
assert DMP([[1]], ZZ).is_zero is False
assert DMP([[1]], ZZ).is_one is True
assert DMP([[2]], ZZ).is_one is False
assert DMP([[1]], ZZ).is_ground is True
assert DMP([[1], [2], [1]], ZZ).is_ground is False
assert DMP([[1], [2, 0], [1, 0]], ZZ).is_sqf is True
assert DMP([[1], [2, 0], [1, 0, 0]], ZZ).is_sqf is False
assert DMP([[1, 2], [3]], ZZ).is_monic is True
assert DMP([[2, 2], [3]], ZZ).is_monic is False
assert DMP([[1, 2], [3]], ZZ).is_primitive is True
assert DMP([[2, 4], [6]], ZZ).is_primitive is False
def test_DMP_properties():
assert DMP([[]], ZZ).is_zero == True
assert DMP([[1]], ZZ).is_zero == False
assert DMP([[1]], ZZ).is_one == True
assert DMP([[2]], ZZ).is_one == False
assert DMP([[1]], ZZ).is_ground == True
assert DMP([[1],[2],[1]], ZZ).is_ground == False
assert DMP([[1],[2,0],[1,0]], ZZ).is_sqf == True
assert DMP([[1],[2,0],[1,0,0]], ZZ).is_sqf == False
assert DMP([[1,2],[3]], ZZ).is_monic == True
assert DMP([[2,2],[3]], ZZ).is_monic == False
assert DMP([[1,2],[3]], ZZ).is_primitive == True
assert DMP([[2,4],[6]], ZZ).is_primitive == False
def test_dup_sqf():
R, x = ring("x", ZZ)
assert R.dup_sqf_part(0) == 0
assert R.dup_sqf_p(0) is True
assert R.dup_sqf_part(7) == 1
assert R.dup_sqf_p(7) is True
assert R.dup_sqf_part(2*x + 2) == x + 1
assert R.dup_sqf_p(2*x + 2) is True
assert R.dup_sqf_part(x**3 + x + 1) == x**3 + x + 1
assert R.dup_sqf_p(x**3 + x + 1) is True
assert R.dup_sqf_part(-x**3 + x + 1) == x**3 - x - 1
assert R.dup_sqf_p(-x**3 + x + 1) is True
assert R.dup_sqf_part(2*x**3 + 3*x**2) == 2*x**2 + 3*x
assert R.dup_sqf_p(2*x**3 + 3*x**2) is False
assert R.dup_sqf_part(-2*x**3 + 3*x**2) == 2*x**2 - 3*x
assert R.dup_sqf_p(-2*x**3 + 3*x**2) is False
assert R.dup_sqf_list(0) == (0, [])
assert R.dup_sqf_list(1) == (1, [])
assert R.dup_sqf_list(x) == (1, [(x, 1)])
assert R.dup_sqf_list(2*x**2) == (2, [(x, 2)])
assert R.dup_sqf_list(3*x**3) == (3, [(x, 3)])
assert R.dup_sqf_list(-x**5 + x**4 + x - 1) == \
(-1, [(x**3 + x**2 + x + 1, 1), (x - 1, 2)])
assert R.dup_sqf_list(x**8 + 6*x**6 + 12*x**4 + 8*x**2) == \
( 1, [(x, 2), (x**2 + 2, 3)])
assert R.dup_sqf_list(2*x**2 + 4*x + 2) == (2, [(x + 1, 2)])
R, x = ring("x", QQ)
assert R.dup_sqf_list(2*x**2 + 4*x + 2) == (2, [(x + 1, 2)])
R, x = ring("x", FF(2))
assert R.dup_sqf_list(x**2 + 1) == (1, [(x + 1, 2)])
R, x = ring("x", FF(3))
assert R.dup_sqf_list(x**10 + 2*x**7 + 2*x**4 + x) == \
(1, [(x, 1),
(x + 1, 3),
(x + 2, 6)])
R1, x = ring("x", ZZ)
R2, y = ring("y", FF(3))
f = x**3 + 1
g = y**3 + 1
assert R1.dup_sqf_part(f) == f
assert R2.dup_sqf_part(g) == y + 1
assert R1.dup_sqf_p(f) is True
assert R2.dup_sqf_p(g) is False
R, x, y = ring("x,y", ZZ)
A = x**4 - 3*x**2 + 6
D = x**6 - 5*x**4 + 5*x**2 + 4
f, g = D, R.dmp_sub(A, R.dmp_mul(R.dmp_diff(D, 1), y))
res = R.dmp_resultant(f, g)
h = (4*y**2 + 1).drop(x)
assert R.drop(x).dup_sqf_list(res) == (45796, [(h, 3)])
R, x = ring("x", ZZ["t"])
assert R.dup_sqf_list_include(DMP([1, 0, 0, 0], ZZ)*x**2) == \
[(DMP([1, 0, 0, 0], ZZ), 1), (DMP([1], ZZ)*x, 2)]
def test_dup_factor_list():
R, x = ring("x", ZZ)
assert R.dup_factor_list(0) == (0, [])
assert R.dup_factor_list(7) == (7, [])
R, x = ring("x", QQ)
assert R.dup_factor_list(0) == (0, [])
assert R.dup_factor_list(QQ(1, 7)) == (QQ(1, 7), [])
R, x = ring("x", ZZ['t'])
assert R.dup_factor_list(0) == (DMP([], ZZ), [])
assert R.dup_factor_list(DMP([ZZ(7)], ZZ)) == (DMP([ZZ(7)], ZZ), [])
R, x = ring("x", QQ['t'])
assert R.dup_factor_list(0) == (DMP([], QQ), [])
assert R.dup_factor_list(DMP([QQ(1, 7)], QQ)) == (DMP([QQ(1, 7)], QQ), [])
R, x = ring("x", ZZ)
assert R.dup_factor_list_include(0) == [(0, 1)]
assert R.dup_factor_list_include(7) == [(7, 1)]
assert R.dup_factor_list(x**2 + 2 * x + 1) == (1, [(x + 1, 2)])
assert R.dup_factor_list_include(x**2 + 2 * x + 1) == [(x + 1, 2)]
R, x = ring("x", QQ)
assert R.dup_factor_list(QQ(1, 2) * x**2 + x + QQ(1, 2)) == (QQ(1, 2),
[(x + 1, 2)])
R, x = ring("x", FF(2))
assert R.dup_factor_list(x**2 + 1) == (1, [(x + 1, 2)])
R, x = ring("x", RR)
assert R.dup_factor_list(1.0 * x**2 + 2.0 * x + 1.0) == (1.0, [
(1.0 * x + 1.0, 2)
])
assert R.dup_factor_list(2.0 * x**2 + 4.0 * x + 2.0) == (2.0, [
(1.0 * x + 1.0, 2)
])
R, x = ring("x", ZZ['t'])
f = DMP([ZZ(4), ZZ(0)], ZZ) * x**2 + DMP([ZZ(4), ZZ(0), ZZ(0)], ZZ) * x
assert R.dup_factor_list(f) == \
(DMP([ZZ(4)], ZZ), [(DMP([ZZ(1), ZZ(0)], ZZ), 1),
(DMP([ZZ(1)], ZZ)*x, 1),
(DMP([ZZ(1)], ZZ)*x + DMP([ZZ(1), ZZ(0)], ZZ), 1)])
R, x = ring("x", QQ['t'])
f = DMP([QQ(1, 2), QQ(0)], QQ) * x**2 + DMP(
[QQ(1, 2), QQ(0), QQ(0)], QQ) * x
assert R.dup_factor_list(f) == \
(DMP([QQ(1, 2)], QQ), [(DMP([QQ(1), QQ(0)], QQ), 1),
(DMP([QQ(1)], QQ)*x + DMP([], QQ), 1),
(DMP([QQ(1)], QQ)*x + DMP([QQ(1), QQ(0)], QQ), 1)])
R, x = ring("x", QQ.algebraic_field(I))
def anp(element):
return ANP(element, [QQ(1), QQ(0), QQ(1)], QQ)
f = anp([QQ(1, 1)]) * x**4 + anp([QQ(2, 1)]) * x**2
assert R.dup_factor_list(f) == \
(anp([QQ(1, 1)]), [(anp([QQ(1, 1)])*x, 2),
(anp([QQ(1, 1)])*x**2 + anp([])*x + anp([QQ(2, 1)]), 1)])
R, x = ring("x", EX)
raises(DomainError, lambda: R.dup_factor_list(EX(sin(1))))
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___bool__():
assert bool(DMP([[]], ZZ)) == False
assert bool(DMP([[1]], ZZ)) == 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 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_sqf():
assert dup_sqf_part([], ZZ) == []
assert dup_sqf_p([], ZZ) == True
assert dup_sqf_part([7], ZZ) == [1]
assert dup_sqf_p([7], ZZ) == True
assert dup_sqf_part([2,2], ZZ) == [1,1]
assert dup_sqf_p([2,2], ZZ) == True
assert dup_sqf_part([1,0,1,1], ZZ) == [1,0,1,1]
assert dup_sqf_p([1,0,1,1], ZZ) == True
assert dup_sqf_part([-1,0,1,1], ZZ) == [1,0,-1,-1]
assert dup_sqf_p([-1,0,1,1], ZZ) == True
assert dup_sqf_part([2,3,0,0], ZZ) == [2,3,0]
assert dup_sqf_p([2,3,0,0], ZZ) == False
assert dup_sqf_part([-2,3,0,0], ZZ) == [2,-3,0]
assert dup_sqf_p([-2,3,0,0], ZZ) == False
assert dup_sqf_list([], ZZ) == (0, [])
assert dup_sqf_list([1], ZZ) == (1, [])
assert dup_sqf_list([1,0], ZZ) == (1, [([1,0], 1)])
assert dup_sqf_list([2,0,0], ZZ) == (2, [([1,0], 2)])
assert dup_sqf_list([3,0,0,0], ZZ) == (3, [([1,0], 3)])
assert dup_sqf_list([ZZ(2),ZZ(4),ZZ(2)], ZZ) == \
(ZZ(2), [([ZZ(1),ZZ(1)], 2)])
assert dup_sqf_list([QQ(2),QQ(4),QQ(2)], QQ) == \
(QQ(2), [([QQ(1),QQ(1)], 2)])
assert dup_sqf_list([-1,1,0,0,1,-1], ZZ) == \
(-1, [([1,1,1,1], 1), ([1,-1], 2)])
assert dup_sqf_list([1,0,6,0,12,0,8,0,0], ZZ) == \
(1, [([1,0], 2), ([1,0,2], 3)])
K = FF(2)
f = map(K, [1,0,1])
assert dup_sqf_list(f, K) == \
(K(1), [([K(1),K(1)], 2)])
K = FF(3)
f = map(K, [1,0,0,2,0,0,2,0,0,1,0])
assert dup_sqf_list(f, K) == \
(K(1), [([K(1), K(0)], 1),
([K(1), K(1)], 3),
([K(1), K(2)], 6)])
f = [1,0,0,1]
g = map(K, f)
assert dup_sqf_part(f, ZZ) == f
assert dup_sqf_part(g, K) == [K(1), K(1)]
assert dup_sqf_p(f, ZZ) == True
assert dup_sqf_p(g, K) == False
A = [[1],[],[-3],[],[6]]
D = [[1],[],[-5],[],[5],[],[4]]
f, g = D, dmp_sub(A, dmp_mul(dmp_diff(D, 1, 1, ZZ), [[1,0]], 1, ZZ), 1, ZZ)
res = dmp_resultant(f, g, 1, ZZ)
assert dup_sqf_list(res, ZZ) == (45796, [([4,0,1], 3)])
assert dup_sqf_list_include([DMP([1, 0, 0, 0], ZZ), DMP([], ZZ), DMP([], ZZ)], ZZ[x]) == \
[([DMP([1, 0, 0, 0], ZZ)], 1), ([DMP([1], ZZ), DMP([], ZZ)], 2)]
