Poly Domains 的参考文档¶

本页面列出了 polys 模块中域的参考文档。对于 polys 模块的一般介绍，建议阅读模块的基本功能。对于域系统是什么以及如何使用的介绍性解释，建议阅读介绍 poly 模块的领域。本页面列出了 Domain 类及其子类（如 ZZ 等特定域）以及表示域元素的类的参考文档。

域¶

这里我们记录了各种已实现的基础域（更多解释请参见介绍 poly 模块的领域）。有三种类型的 Domain 子类：抽象域、具体域和“实现域”。抽象域根本无法（有用地）实例化，只是收集了许多其他域共享的功能。具体域是那些旨在实例化并在多项式操作算法中使用的域。在某些情况下，有多种可能的方式来实现域提供的数据类型。例如，根据系统上可用的库，整数要么使用Python内置的整数实现，要么使用gmpy实现。请注意，根据可用的库，会自动创建各种别名。因此，例如 ZZ 总是指可用的最有效的整数环实现。

抽象域¶

class sympy.polys.domains.domain.Domain[源代码][源代码]¶

多域系统中所有域的超类。

有关域系统的介绍性解释，请参见介绍 poly 模块的领域。

The Domain 类是所有具体域类型的抽象基类。有许多不同的 Domain 子类，每个子类都有一个关联的 dtype，这是一个表示域元素的类。一个 Poly 的系数是域的元素，该域必须是 Domain 的子类。

属性:

别名
dtype
一
rep
tp: 别名 dtype
零

方法

`__call__`(*args)	从 `args` 构造 `self` 域的一个元素。
`abs`(a)	`a` 的绝对值，意味着 `__abs__`。
`add`(a, b)	`a` 和 `b` 的和，意味着 `__add__`。
`alg_field_from_poly`(poly[, alias, root_index])	通过根索引选择多项式的根来构造代数扩展的便捷方法。
`algebraic_field`(*extension[, alias])	返回一个代数数域，即 \(K(\alpha, \ldots)\)。
`almosteq`(a, b[, tolerance])	检查 `a` 和 `b` 是否几乎相等。
`characteristic`()	返回此域的特征。
`cofactors`(a, b)	返回 `a` 和 `b` 的最大公约数和余因子。
`convert`(element[, base])	将 `element` 转换为 `self.dtype`。
`convert_from`(element, base)	在给定的基本域中将 `element` 转换为 `self.dtype`。
`cyclotomic_field`(n[, ss, alias, gen, root_index])	构建分圆域的便捷方法。
`denom`(a)	返回 `a` 的分母。
`div`(a, b)	计算 a 和 b 的商和余数。
`drop`(*symbols)	从此领域中移除生成器。
`evalf`(a[, prec])	返回 `a` 的数值近似值。
`exquo`(a, b)	a 和 b 的精确商。
`exsqrt`(a)	在 `a` 是平方数的域内的主平方根。
`frac_field`(*symbols[, order])	返回一个分数域，即 \(K(X)\)。
`from_AlgebraicField`(a, K0)	将一个代数数转换为 `dtype`。
`from_ComplexField`(a, K0)	将复杂元素转换为 `dtype`。
`from_ExpressionDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_ExpressionRawDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_FF`(a, K0)	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FF_gmpy`(a, K0)	将 `ModularInteger(mpz)` 转换为 `dtype`。
`from_FF_python`(a, K0)	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FractionField`(a, K0)	将一个有理函数转换为 `dtype`。
`from_GlobalPolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_MonogenicFiniteExtension`(a, K0)	将 `ExtensionElement` 转换为 `dtype`。
`from_PolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_QQ_gmpy`(a, K0)	将 GMPY 的 `mpq` 对象转换为 `dtype`。
`from_QQ_python`(a, K0)	将 Python `Fraction` 对象转换为 `dtype`。
`from_RealField`(a, K0)	将一个真实的元素对象转换为 `dtype`。
`from_ZZ_gmpy`(a, K0)	将 GMPY 的 `mpz` 对象转换为 `dtype`。
`from_ZZ_python`(a, K0)	将 Python `int` 对象转换为 `dtype`。
`from_sympy`(a)	将 SymPy 表达式转换为此域的一个元素。
`gcd`(a, b)	返回 `a` 和 `b` 的最大公约数。
`gcdex`(a, b)	`a` 和 `b` 的扩展最大公约数。
`get_exact`()	返回与 `self` 关联的精确域。
`get_field`()	返回与 `self` 关联的字段。
`get_ring`()	返回与 `self` 相关联的环。
`half_gcdex`(a, b)	`a` 和 `b` 的半扩展最大公约数。
`inject`(*symbols)	将生成器注入此域。
`invert`(a, b)	返回 `a mod b` 的逆，意味着某事。
`is_negative`(a)	如果 `a` 为负数，则返回 True。
`is_nonnegative`(a)	如果 `a` 是非负的，则返回 True。
`is_nonpositive`(a)	如果 `a` 是非正数，则返回 True。
`is_one`(a)	如果 `a` 是 1，则返回 True。
`is_positive`(a)	如果 `a` 为正，则返回 True。
`is_square`(a)	返回 `a` 是否是该域中的一个平方数。
`is_zero`(a)	如果 `a` 为零，则返回 True。
`lcm`(a, b)	返回 `a` 和 `b` 的最小公倍数。
`log`(a, b)	返回 `a` 的 b 进制对数。
`map`(seq)	递归地将 `self` 应用于 `seq` 的所有元素。
`mul`(a, b)	`a` 和 `b` 的乘积，意味着 `__mul__`。
`n`(a[, prec])	返回 `a` 的数值近似值。
`neg`(a)	返回 `a` 的否定值，意味着 `__neg__`。
`numer`(a)	返回 `a` 的分子。
`of_type`(element)	检查 `a` 是否为 `dtype` 类型。
`old_frac_field`(symbols, *kwargs)	返回一个分数域，即 \(K(X)\)。
`old_poly_ring`(symbols, *kwargs)	返回一个多项式环，即 \(K[X]\)。
`poly_ring`(*symbols[, order])	返回一个多项式环，即 \(K[X]\)。
`pos`(a)	返回 `a` 为正，意味着 `__pos__`。
`pow`(a, b)	将 `a` 提升到 `b` 的幂，意味着 `__pow__`。
`quo`(a, b)	a 和 b 的商。
`rem`(a, b)	对 a 和 b 进行取模运算。
`revert`(a)	如果可能，返回 `a**(-1)`。
`sqrt`(a)	返回 `a` 的（可能不精确的）平方根。
`sub`(a, b)	`a` 和 `b` 的差异，意味着 `__sub__`。
`to_sympy`(a)	将域元素 a 转换为 SymPy 表达式 (Expr)。
`unify`(K1[, symbols])	构建一个包含 `K0` 和 `K1` 元素的最小域。
`unify_composite`(K1)	统一两个领域，其中至少一个是复合的。

canonical_unit
from_GeneralizedPolynomialRing
imag
新
正常
真实
总和
unify_with_symbols

参见

DomainElement: 域元素的抽象基类
construct_domain: 为某些表达式构建一个最小的领域

示例

最常见的示例域是整数 ZZ 和有理数 QQ。

>>> from sympy import Poly, symbols, Domain
>>> x, y = symbols('x, y')
>>> p = Poly(x**2 + y)
>>> p
Poly(x**2 + y, x, y, domain='ZZ')
>>> p.domain
ZZ
>>> isinstance(p.domain, Domain)
True
>>> Poly(x**2 + y/2)
Poly(x**2 + 1/2*y, x, y, domain='QQ')

域可以直接使用，在这种情况下，域对象（例如 ZZ 或 QQ）可以作为 dtype 元素的构造函数。

>>> from sympy import ZZ, QQ
>>> ZZ(2)
2
>>> ZZ.dtype  
<class 'int'>
>>> type(ZZ(2))  
<class 'int'>
>>> QQ(1, 2)
1/2
>>> type(QQ(1, 2))  
<class 'sympy.polys.domains.pythonrational.PythonRational'>

相应的域元素可以使用算术运算 +,-,*,** ，并且根据域的不同，某些 /,//,% 的组合可能可用。例如，在 ZZ 中，//``（地板除法）和 ``%``（模除法）可以使用，但 ``/``（真除法）不能使用。由于 :ref:`QQ` 是一个 :py:class:`~.Field`，其元素可以使用 ``/，但不应使用 // 和 %。某些域具有 gcd() 方法。

>>> ZZ(2) + ZZ(3)
5
>>> ZZ(5) // ZZ(2)
2
>>> ZZ(5) % ZZ(2)
1
>>> QQ(1, 2) / QQ(2, 3)
3/4
>>> ZZ.gcd(ZZ(4), ZZ(2))
2
>>> QQ.gcd(QQ(2,7), QQ(5,3))
1/21
>>> ZZ.is_Field
False
>>> QQ.is_Field
True

还有许多其他领域包括：

GF(p) 用于素数阶的有限域。

RR 表示实数（浮点数）。

CC 用于复数（浮点数）。

QQ<a> 用于代数数域。

K[x] 用于多项式环。

K(x) 对于有理函数域。

EX 用于任意表达式。

每个域由一个域对象和一个实现类（dtype）表示，用于该域的元素。例如，K[x] 域由一个域对象表示，该对象是 PolynomialRing 的实例，而元素始终是 PolyElement 的实例。实现类以比类型为 Expr 的普通 SymPy 表达式更高效的方式表示特定类型的数学表达式。域方法 from_sympy() 和 to_sympy() 用于将 Expr 转换为域元素，反之亦然。

>>> from sympy import Symbol, ZZ, Expr
>>> x = Symbol('x')
>>> K = ZZ[x]           # polynomial ring domain
>>> K
ZZ[x]
>>> type(K)             # class of the domain
<class 'sympy.polys.domains.polynomialring.PolynomialRing'>
>>> K.dtype             # class of the elements
<class 'sympy.polys.rings.PolyElement'>
>>> p_expr = x**2 + 1   # Expr
>>> p_expr
x**2 + 1
>>> type(p_expr)
<class 'sympy.core.add.Add'>
>>> isinstance(p_expr, Expr)
True
>>> p_domain = K.from_sympy(p_expr)
>>> p_domain            # domain element
x**2 + 1
>>> type(p_domain)
<class 'sympy.polys.rings.PolyElement'>
>>> K.to_sympy(p_domain) == p_expr
True

使用 convert_from() 方法将域元素从一个域转换到另一个域。

>>> from sympy import ZZ, QQ
>>> ez = ZZ(2)
>>> eq = QQ.convert_from(ez, ZZ)
>>> type(ez)  
<class 'int'>
>>> type(eq)  
<class 'sympy.polys.domains.pythonrational.PythonRational'>

不同域的元素不应在算术或其他操作中混合：它们应首先转换为通用域。域方法 unify() 用于找到一个可以表示两个给定域所有元素的域。

>>> from sympy import ZZ, QQ, symbols
>>> x, y = symbols('x, y')
>>> ZZ.unify(QQ)
QQ
>>> ZZ[x].unify(QQ)
QQ[x]
>>> ZZ[x].unify(QQ[y])
QQ[x,y]

如果一个域是一个 Ring ，那么它可能有一个相关的 Field ，反之亦然。 get_field() 和 get_ring() 方法将找到或创建相关的域。

>>> from sympy import ZZ, QQ, Symbol
>>> x = Symbol('x')
>>> ZZ.has_assoc_Field
True
>>> ZZ.get_field()
QQ
>>> QQ.has_assoc_Ring
True
>>> QQ.get_ring()
ZZ
>>> K = QQ[x]
>>> K
QQ[x]
>>> K.get_field()
QQ(x)

abs(a)[源代码][源代码]¶: a 的绝对值，意味着 __abs__。

add(a, b)[源代码][源代码]¶: a 和 b 的和，意味着 __add__。

alg_field_from_poly( poly, alias=None, root_index=-1, )[源代码][源代码]¶

通过根索引选择多项式的根来构造代数扩展的便捷方法。

参数:

poly多: 生成扩展的根的多项式。
别名str, 可选 (默认=None): 扩展生成器的符号名称。例如，“alpha”或“theta”。
根索引int, 可选 (默认=-1): 指定所需的根多项式的根。顺序由 ComplexRootOf 类定义。默认值 -1 在二次和分圆域的常见情况下选择最自然的选择（分别为正实轴或虚轴上的平方根，即 \(\mathrm{e}^{2\pi i/n}\)）。

示例

>>> from sympy import QQ, Poly
>>> from sympy.abc import x
>>> f = Poly(x**2 - 2)
>>> K = QQ.alg_field_from_poly(f)
>>> K.ext.minpoly == f
True
>>> g = Poly(8*x**3 - 6*x - 1)
>>> L = QQ.alg_field_from_poly(g, "alpha")
>>> L.ext.minpoly == g
True
>>> L.to_sympy(L([1, 1, 1]))
alpha**2 + alpha + 1

algebraic_field(*extension, alias=None)[源代码][源代码]¶: 返回一个代数数域，即 \(K(\alpha, \ldots)\)。

almosteq(a, b, tolerance=None)[源代码][源代码]¶: 检查 a 和 b 是否几乎相等。

characteristic()[源代码][源代码]¶: 返回此域的特征。

cofactors(a, b)[源代码][源代码]¶: 返回 a 和 b 的最大公约数和余因子。

convert(element, base=None)[源代码][源代码]¶: 将 element 转换为 self.dtype。

convert_from(element, base)[源代码][源代码]¶: 在给定的基本域中将 element 转换为 self.dtype。

cyclotomic_field( n, ss=False, alias='zeta', gen=None, root_index=-1, )[源代码][源代码]¶

构建分圆域的便捷方法。

参数:

n整数: 构造第 n 个分圆域。
ss布尔值，可选（默认=False）: 如果为真，将 n 作为下标附加到别名字符串上。
别名str, 可选 (默认值为”zeta”): 生成器的符号名称。
gen : Symbol, 可选 (默认=None)符号, 可选 (默认=None): 定义域的循环多项式所需的变量。如果为 None ，将使用一个虚拟变量。
根索引int, 可选 (默认=-1): 指定所需的根多项式的根。顺序由 ComplexRootOf 类定义。默认值 -1 选择根 \(\mathrm{e}^{2\pi i/n}\)。

示例

>>> from sympy import QQ, latex
>>> K = QQ.cyclotomic_field(5)
>>> K.to_sympy(K([-1, 1]))
1 - zeta
>>> L = QQ.cyclotomic_field(7, True)
>>> a = L.to_sympy(L([-1, 1]))
>>> print(a)
1 - zeta7
>>> print(latex(a))
1 - \zeta_{7}

denom(a)[源代码][源代码]¶: 返回 a 的分母。

div(a, b)[源代码][源代码]¶

商和余数为 a 和 b。类似于 divmod(a, b)

参数:

a: 域元素: 股息
b: 域元素: 除数

返回:

(q, r): 域元素的元组: 商和余数

Raises:

ZeroDivisionError: 当除数为零时。

参见

quo: a // b 的模拟
rem: a % b 的模拟
exquo: a / b 的模拟

注释

如果安装了 gmpy ，那么 gmpy.mpq 类型将被用作 QQ 的 dtype 。gmpy.mpq 类型以一种不理想的方式定义了 divmod ，因此应使用 div() 而不是 divmod 。

>>> a = QQ(1)
>>> b = QQ(3, 2)
>>> a               
mpq(1,1)
>>> b               
mpq(3,2)
>>> divmod(a, b)    
(mpz(0), mpq(1,1))
>>> QQ.div(a, b)    
(mpq(2,3), mpq(0,1))

使用 // 或 % 与 QQ 会导致错误的结果，因此应使用 div() 代替。

示例

我们可以使用 K.div 来替代 divmod 进行地板除和取余。

>>> from sympy import ZZ, QQ
>>> ZZ.div(ZZ(5), ZZ(2))
(2, 1)

如果 K 是一个 Field ，那么除法总是精确的，余数为 zero 。

>>> QQ.div(QQ(5), QQ(2))
(5/2, 0)

drop(*symbols)[源代码][源代码]¶: 从此领域中移除生成器。

dtype: type | None = None¶

这个 Domain 的元素的类型（类）：

>>> from sympy import ZZ, QQ, Symbol
>>> ZZ.dtype
<class 'int'>
>>> z = ZZ(2)
>>> z
2
>>> type(z)
<class 'int'>
>>> type(z) == ZZ.dtype
True

每个域都有一个关联的 dtype (“数据类型”)，这是关联域元素的类。

参见

of_type

evalf(a, prec=None, **options)[源代码][源代码]¶: 返回 a 的数值近似值。

exquo(a, b)[源代码][源代码]¶

a 和 b 的精确商。类似于 a / b。

参数:

a: 域元素: 股息
b: 域元素: 除数

返回:

q: 域元素: 确切的商

Raises:

ExactQuotientFailed: 如果无法进行精确除法。
ZeroDivisionError: 当除数为零时。

参见

quo: a // b 的模拟
rem: a % b 的模拟
div: divmod(a, b) 的模拟

注释

由于 ZZ 的默认 dtype 是 int (或 mpz)，因此不应使用 a / b 进行除法，因为它会得到一个 float，这不是域的元素。

>>> ZZ(4) / ZZ(2) 
2.0
>>> ZZ(5) / ZZ(2) 
2.5

另一方面，使用 \(SYMPY_GROUND_TYPES=flint\) 时，ZZ 的元素是 flint.fmpz，并且除法会引发异常：

>>> ZZ(4) / ZZ(2) 
Traceback (most recent call last):
...
TypeError: unsupported operand type(s) for /: 'fmpz' and 'fmpz'

使用 / 与 ZZ 会导致错误结果，因此应使用 exquo() 代替。

示例

我们可以使用 K.exquo 来代替 / 进行精确除法。

>>> from sympy import ZZ
>>> ZZ.exquo(ZZ(4), ZZ(2))
2
>>> ZZ.exquo(ZZ(5), ZZ(2))
Traceback (most recent call last):
    ...
ExactQuotientFailed: 2 does not divide 5 in ZZ

在 Field 上，例如 QQ ，除法（除数不为零）总是精确的，因此在那种情况下可以使用 / 代替 exquo()。

>>> from sympy import QQ
>>> QQ.exquo(QQ(5), QQ(2))
5/2
>>> QQ(5) / QQ(2)
5/2

exsqrt(a)[源代码][源代码]¶

在 a 是平方数的域内的主平方根。

参见

sqrt, is_square

frac_field(*symbols, order=LexOrder())[源代码][源代码]¶: 返回一个分数域，即 \(K(X)\)。

from_AlgebraicField(a, K0)[源代码][源代码]¶: 将一个代数数转换为 dtype。

from_ComplexField(a, K0)[源代码][源代码]¶: 将复杂元素转换为 dtype。

from_ExpressionDomain(a, K0)[源代码][源代码]¶: 将 EX 对象转换为 dtype。

from_ExpressionRawDomain(a, K0)[源代码][源代码]¶: 将 EX 对象转换为 dtype。

from_FF(a, K0)[源代码][源代码]¶: 将 ModularInteger(int) 转换为 dtype。

from_FF_gmpy(a, K0)[源代码][源代码]¶: 将 ModularInteger(mpz) 转换为 dtype。

from_FF_python(a, K0)[源代码][源代码]¶: 将 ModularInteger(int) 转换为 dtype。

from_FractionField(a, K0)[源代码][源代码]¶: 将一个有理函数转换为 dtype。

from_GlobalPolynomialRing(a, K0)[源代码][源代码]¶: 将多项式转换为 dtype。

from_MonogenicFiniteExtension(a, K0)[源代码][源代码]¶: 将 ExtensionElement 转换为 dtype。

from_PolynomialRing(a, K0)[源代码][源代码]¶: 将多项式转换为 dtype。

from_QQ_gmpy(a, K0)[源代码][源代码]¶: 将 GMPY 的 mpq 对象转换为 dtype。

from_QQ_python(a, K0)[源代码][源代码]¶: 将 Python Fraction 对象转换为 dtype。

from_RealField(a, K0)[源代码][源代码]¶: 将一个真实的元素对象转换为 dtype。

from_ZZ_gmpy(a, K0)[源代码][源代码]¶: 将 GMPY 的 mpz 对象转换为 dtype。

from_ZZ_python(a, K0)[源代码][源代码]¶: 将 Python int 对象转换为 dtype。

from_sympy(a)[源代码][源代码]¶

将 SymPy 表达式转换为此域的一个元素。

参数:

expr: Expr: 一个类型为 Expr 的普通 SymPy 表达式。

返回:

a: 域元素: 这个 Domain 的一个元素。

参见

to_sympy
convert_from

gcd(a, b)[源代码][源代码]¶: 返回 a 和 b 的最大公约数。

gcdex(a, b)[源代码][源代码]¶: a 和 b 的扩展最大公约数。

get_exact()[源代码][源代码]¶: 返回与 self 关联的精确域。

get_field()[源代码][源代码]¶: 返回与 self 关联的字段。

get_ring()[源代码][源代码]¶: 返回与 self 相关联的环。

half_gcdex(a, b)[源代码][源代码]¶: a 和 b 的半扩展最大公约数。

has_assoc_Field = False¶

布尔标志，指示域是否有关联的 Field。

>>> from sympy import ZZ
>>> ZZ.has_assoc_Field
True
>>> ZZ.get_field()
QQ

参见

is_Field
get_field

has_assoc_Ring = False¶

布尔标志，指示域是否有关联的 Ring。

>>> from sympy import QQ
>>> QQ.has_assoc_Ring
True
>>> QQ.get_ring()
ZZ

参见

is_Field
get_ring

inject(*symbols)[源代码][源代码]¶: 将生成器注入此域。

invert(a, b)[源代码][源代码]¶: 返回 a mod b 的逆，意味着某事。

is_Field = False¶

布尔标志，指示域是否为 Field。

>>> from sympy import ZZ, QQ
>>> ZZ.is_Field
False
>>> QQ.is_Field
True

参见

is_PID
is_Ring
get_field
has_assoc_Field

is_PID = False¶

布尔标志，指示该域是否为主理想域。

>>> from sympy import ZZ
>>> ZZ.has_assoc_Field
True
>>> ZZ.get_field()
QQ

参见

is_Field
get_field

is_Ring = False¶

布尔标志，指示域是否为 Ring 。

>>> from sympy import ZZ
>>> ZZ.is_Ring
True

基本上每个 Domain 代表一个环，所以这个标志不是那么有用。

参见

is_PID
is_Field
get_ring
has_assoc_Ring

is_negative(a)[源代码][源代码]¶: 如果 a 为负数，则返回 True。

is_nonnegative(a)[源代码][源代码]¶: 如果 a 是非负的，则返回 True。

is_nonpositive(a)[源代码][源代码]¶: 如果 a 是非正数，则返回 True。

is_one(a)[源代码][源代码]¶: 如果 a 是 1，则返回 True。

is_positive(a)[源代码][源代码]¶: 如果 a 为正，则返回 True。

is_square(a)[源代码][源代码]¶

返回 a 是否是该域中的一个平方数。

参见

exsqrt

is_zero(a)[源代码][源代码]¶: 如果 a 为零，则返回 True。

lcm(a, b)[源代码][源代码]¶: 返回 a 和 b 的最小公倍数。

log(a, b)[源代码][源代码]¶: 返回 a 的 b 进制对数。

map(seq)[源代码][源代码]¶: 递归地将 self 应用于 seq 的所有元素。

mul(a, b)[源代码][源代码]¶: a 和 b 的乘积，意味着 __mul__。

n(a, prec=None, **options)[源代码]¶: 返回 a 的数值近似值。

neg(a)[源代码][源代码]¶: 返回 a 的否定值，意味着 __neg__。

numer(a)[源代码][源代码]¶: 返回 a 的分子。

of_type(element)[源代码][源代码]¶: 检查 a 是否为 dtype 类型。

old_frac_field(*symbols, **kwargs)[源代码][源代码]¶: 返回一个分数域，即 \(K(X)\)。

old_poly_ring(*symbols, **kwargs)[源代码][源代码]¶: 返回一个多项式环，即 \(K[X]\)。

one: Any = None¶

The one element of the Domain:

>>> from sympy import QQ
>>> QQ.one
1
>>> QQ.of_type(QQ.one)
True

参见

of_type
zero

poly_ring(*symbols, order=LexOrder())[源代码][源代码]¶: 返回一个多项式环，即 \(K[X]\)。

pos(a)[源代码][源代码]¶: 返回 a 为正，意味着 __pos__。

pow(a, b)[源代码][源代码]¶: 将 a 提升到 b 的幂，意味着 __pow__。

quo(a, b)[源代码][源代码]¶

a 和 b 的商。类似于 a // b 。

K.quo(a, b) 等同于 K.div(a, b)[0]。更多解释请参见 div()。

参见

rem: a % b 的模拟
div: divmod(a, b) 的模拟
exquo: a / b 的模拟

rem(a, b)[源代码][源代码]¶

对 a 和 b 进行模除运算。类似于 a % b。

K.rem(a, b) 等同于 K.div(a, b)[1]。更多解释请参见 div()。

参见

quo: a // b 的模拟
div: divmod(a, b) 的模拟
exquo: a / b 的模拟

revert(a)[源代码][源代码]¶: 如果可能，返回 a**(-1)。

sqrt(a)[源代码][源代码]¶

返回 a 的（可能不精确的）平方根。

参见

exsqrt

sub(a, b)[源代码][源代码]¶: a 和 b 的差异，意味着 __sub__。

to_sympy(a)[源代码][源代码]¶

将域元素 a 转换为 SymPy 表达式 (Expr)。

参数:

a: 域元素: 这个 Domain 的一个元素。

返回:

expr: Expr: 一个类型为 Expr 的普通 SymPy 表达式。

参见

from_sympy
convert_from

示例

构造 QQ 域的一个元素，然后将其转换为 Expr。

>>> from sympy import QQ, Expr
>>> q_domain = QQ(2)
>>> q_domain
2
>>> q_expr = QQ.to_sympy(q_domain)
>>> q_expr
2

尽管印刷形式看起来相似，但这些对象并不是同一类型的。

>>> isinstance(q_domain, Expr)
False
>>> isinstance(q_expr, Expr)
True

构造 K[x] 的一个元素并转换为 Expr。

>>> from sympy import Symbol
>>> x = Symbol('x')
>>> K = QQ[x]
>>> x_domain = K.gens[0]  # generator x as a domain element
>>> p_domain = x_domain**2/3 + 1
>>> p_domain
1/3*x**2 + 1
>>> p_expr = K.to_sympy(p_domain)
>>> p_expr
x**2/3 + 1

The from_sympy() method is used for the opposite conversion from a normal SymPy expression to a domain element.

>>> p_domain == p_expr
False
>>> K.from_sympy(p_expr) == p_domain
True
>>> K.to_sympy(p_domain) == p_expr
True
>>> K.from_sympy(K.to_sympy(p_domain)) == p_domain
True
>>> K.to_sympy(K.from_sympy(p_expr)) == p_expr
True

使用 from_sympy() 方法可以更方便地交互式构建域元素。

>>> from sympy import Symbol
>>> x = Symbol('x')
>>> K = QQ[x]
>>> K.from_sympy(x**2/3 + 1)
1/3*x**2 + 1

property tp¶: 别名 dtype

unify(K1, symbols=None)[源代码][源代码]¶

构建一个包含 K0 和 K1 元素的最小域。

已知领域（从小到大）：

GF(p)
ZZ
QQ
RR(prec, tol)
CC(prec, tol)
ALG(a, b, c)
K[x, y, z]
K(x, y, z)
EX

unify_composite(K1)[源代码][源代码]¶: 统一两个领域，其中至少一个是复合的。

zero: Any = None¶

The zero element of the Domain:

>>> from sympy import QQ
>>> QQ.zero
0
>>> QQ.of_type(QQ.zero)
True

参见

of_type
one

class sympy.polys.domains.domainelement.DomainElement[源代码][源代码]¶

表示一个域的元素。

将此特性混合到一个类中，该类的实例应被识别为某个域的元素。方法 parent() 给出该域。

方法

parent()

获取与 self 关联的域

parent()[源代码][源代码]¶

获取与 self 关联的域

注释

这被 convert() 用于识别与域元素关联的域。

示例

>>> from sympy import ZZ, symbols
>>> x, y = symbols('x, y')
>>> K = ZZ[x,y]
>>> p = K(x)**2 + K(y)**2
>>> p
x**2 + y**2
>>> p.parent()
ZZ[x,y]

class sympy.polys.domains.field.Field[源代码][源代码]¶

表示一个字段域。

属性:

别名
dtype
一
rep
tp: 别名 dtype
零

方法

`__call__`(*args)	从 `args` 构造 `self` 域的一个元素。
`abs`(a)	`a` 的绝对值，意味着 `__abs__`。
`add`(a, b)	`a` 和 `b` 的和，意味着 `__add__`。
`alg_field_from_poly`(poly[, alias, root_index])	通过根索引选择多项式的根来构造代数扩展的便捷方法。
`algebraic_field`(*extension[, alias])	返回一个代数数域，即 \(K(\alpha, \ldots)\)。
`almosteq`(a, b[, tolerance])	检查 `a` 和 `b` 是否几乎相等。
`characteristic`()	返回此域的特征。
`cofactors`(a, b)	返回 `a` 和 `b` 的最大公约数和余因子。
`convert`(element[, base])	将 `element` 转换为 `self.dtype`。
`convert_from`(element, base)	在给定的基本域中将 `element` 转换为 `self.dtype`。
`cyclotomic_field`(n[, ss, alias, gen, root_index])	构建分圆域的便捷方法。
`denom`(a)	返回 \(a\) 的分母。
`div`(a, b)	`a` 和 `b` 的除法，意味着 `__truediv__`。
`drop`(*symbols)	从此领域中移除生成器。
`evalf`(a[, prec])	返回 `a` 的数值近似值。
`exquo`(a, b)	`a` 和 `b` 的精确商，意味着 `__truediv__`。
`exsqrt`(a)	在 `a` 是平方数的域内的主平方根。
`frac_field`(*symbols[, order])	返回一个分数域，即 \(K(X)\)。
`free_module`(rank)	在自身上生成一个秩为 `rank` 的自由模。
`from_AlgebraicField`(a, K0)	将一个代数数转换为 `dtype`。
`from_ComplexField`(a, K0)	将复杂元素转换为 `dtype`。
`from_ExpressionDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_ExpressionRawDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_FF`(a, K0)	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FF_gmpy`(a, K0)	将 `ModularInteger(mpz)` 转换为 `dtype`。
`from_FF_python`(a, K0)	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FractionField`(a, K0)	将一个有理函数转换为 `dtype`。
`from_GlobalPolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_MonogenicFiniteExtension`(a, K0)	将 `ExtensionElement` 转换为 `dtype`。
`from_PolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_QQ_gmpy`(a, K0)	将 GMPY 的 `mpq` 对象转换为 `dtype`。
`from_QQ_python`(a, K0)	将 Python `Fraction` 对象转换为 `dtype`。
`from_RealField`(a, K0)	将一个真实的元素对象转换为 `dtype`。
`from_ZZ_gmpy`(a, K0)	将 GMPY 的 `mpz` 对象转换为 `dtype`。
`from_ZZ_python`(a, K0)	将 Python `int` 对象转换为 `dtype`。
`from_sympy`(a)	将 SymPy 表达式转换为此域的一个元素。
`gcd`(a, b)	返回 `a` 和 `b` 的最大公约数。
`gcdex`(a, b)	返回 x, y, g 使得 a * x + b * y == g == gcd(a, b)
`get_exact`()	返回与 `self` 关联的精确域。
`get_field`()	返回与 `self` 关联的字段。
`get_ring`()	返回与 `self` 相关联的环。
`half_gcdex`(a, b)	`a` 和 `b` 的半扩展最大公约数。
`ideal`(*gens)	生成一个理想的 `自我`。
`inject`(*symbols)	将生成器注入此域。
`invert`(a, b)	返回 `a mod b` 的逆。
`is_negative`(a)	如果 `a` 为负数，则返回 True。
`is_nonnegative`(a)	如果 `a` 是非负的，则返回 True。
`is_nonpositive`(a)	如果 `a` 是非正数，则返回 True。
`is_one`(a)	如果 `a` 是 1，则返回 True。
`is_positive`(a)	如果 `a` 为正，则返回 True。
`is_square`(a)	返回 `a` 是否是该域中的一个平方数。
`is_unit`(a)	如果 `a` 是可逆的，则返回 true
`is_zero`(a)	如果 `a` 为零，则返回 True。
`lcm`(a, b)	返回 `a` 和 `b` 的最小公倍数。
`log`(a, b)	返回 `a` 的 b 进制对数。
`map`(seq)	递归地将 `self` 应用于 `seq` 的所有元素。
`mul`(a, b)	`a` 和 `b` 的乘积，意味着 `__mul__`。
`n`(a[, prec])	返回 `a` 的数值近似值。
`neg`(a)	返回 `a` 的否定值，意味着 `__neg__`。
`numer`(a)	返回 `a` 的分子。
`of_type`(element)	检查 `a` 是否为 `dtype` 类型。
`old_frac_field`(symbols, *kwargs)	返回一个分数域，即 \(K(X)\)。
`old_poly_ring`(symbols, *kwargs)	返回一个多项式环，即 \(K[X]\)。
`poly_ring`(*symbols[, order])	返回一个多项式环，即 \(K[X]\)。
`pos`(a)	返回 `a` 为正，意味着 `__pos__`。
`pow`(a, b)	将 `a` 提升到 `b` 的幂，意味着 `__pow__`。
`quo`(a, b)	`a` 和 `b` 的商，意味着 `__truediv__`。
`quotient_ring`(e)	形成 `self` 的商环。
`rem`(a, b)	`a` 和 `b` 的余数，没有隐含意义。
`revert`(a)	如果可能，返回 `a**(-1)`。
`sqrt`(a)	返回 `a` 的（可能不精确的）平方根。
`sub`(a, b)	`a` 和 `b` 的差异，意味着 `__sub__`。
`to_sympy`(a)	将域元素 a 转换为 SymPy 表达式 (Expr)。
`unify`(K1[, symbols])	构建一个包含 `K0` 和 `K1` 元素的最小域。
`unify_composite`(K1)	统一两个领域，其中至少一个是复合的。

canonical_unit
from_GeneralizedPolynomialRing
imag
新
正常
真实
总和
unify_with_symbols

div(a, b)[源代码][源代码]¶: a 和 b 的除法，意味着 __truediv__。

exquo(a, b)[源代码][源代码]¶: a 和 b 的精确商，意味着 __truediv__。

gcd(a, b)[源代码][源代码]¶

返回 a 和 b 的最大公约数。

域上GCD的这个定义允许在 \(primitive()\) 中清除分母。

示例

>>> from sympy.polys.domains import QQ
>>> from sympy import S, gcd, primitive
>>> from sympy.abc import x

>>> QQ.gcd(QQ(2, 3), QQ(4, 9))
2/9
>>> gcd(S(2)/3, S(4)/9)
2/9
>>> primitive(2*x/3 + S(4)/9)
(2/9, 3*x + 2)

gcdex(a, b)[源代码][源代码]¶: 返回 x, y, g 使得 a * x + b * y == g == gcd(a, b)

get_field()[源代码][源代码]¶: 返回与 self 关联的字段。

get_ring()[源代码][源代码]¶: 返回与 self 相关联的环。

is_unit(a)[源代码][源代码]¶: 如果 a 是可逆的，则返回 true

lcm(a, b)[源代码][源代码]¶

返回 a 和 b 的最小公倍数。

>>> from sympy.polys.domains import QQ
>>> from sympy import S, lcm

>>> QQ.lcm(QQ(2, 3), QQ(4, 9))
4/3
>>> lcm(S(2)/3, S(4)/9)
4/3

quo(a, b)[源代码][源代码]¶: a 和 b 的商，意味着 __truediv__。

rem(a, b)[源代码][源代码]¶: a 和 b 的余数，没有隐含意义。

revert(a)[源代码][源代码]¶: 如果可能，返回 a**(-1)。

class sympy.polys.domains.ring.Ring[源代码][源代码]¶

表示一个环域。

属性:

别名
dtype
一
rep
tp: 别名 dtype
零

方法

`__call__`(*args)	从 `args` 构造 `self` 域的一个元素。
`abs`(a)	`a` 的绝对值，意味着 `__abs__`。
`add`(a, b)	`a` 和 `b` 的和，意味着 `__add__`。
`alg_field_from_poly`(poly[, alias, root_index])	通过根索引选择多项式的根来构造代数扩展的便捷方法。
`algebraic_field`(*extension[, alias])	返回一个代数数域，即 \(K(\alpha, \ldots)\)。
`almosteq`(a, b[, tolerance])	检查 `a` 和 `b` 是否几乎相等。
`characteristic`()	返回此域的特征。
`cofactors`(a, b)	返回 `a` 和 `b` 的最大公约数和余因子。
`convert`(element[, base])	将 `element` 转换为 `self.dtype`。
`convert_from`(element, base)	在给定的基本域中将 `element` 转换为 `self.dtype`。
`cyclotomic_field`(n[, ss, alias, gen, root_index])	构建分圆域的便捷方法。
`denom`(a)	返回 \(a\) 的分母。
`div`(a, b)	`a` 和 `b` 的除法，意味着 `__divmod__`。
`drop`(*symbols)	从此领域中移除生成器。
`evalf`(a[, prec])	返回 `a` 的数值近似值。
`exquo`(a, b)	`a` 和 `b` 的精确商，意味着 `__floordiv__`。
`exsqrt`(a)	在 `a` 是平方数的域内的主平方根。
`frac_field`(*symbols[, order])	返回一个分数域，即 \(K(X)\)。
`free_module`(rank)	在自身上生成一个秩为 `rank` 的自由模。
`from_AlgebraicField`(a, K0)	将一个代数数转换为 `dtype`。
`from_ComplexField`(a, K0)	将复杂元素转换为 `dtype`。
`from_ExpressionDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_ExpressionRawDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_FF`(a, K0)	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FF_gmpy`(a, K0)	将 `ModularInteger(mpz)` 转换为 `dtype`。
`from_FF_python`(a, K0)	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FractionField`(a, K0)	将一个有理函数转换为 `dtype`。
`from_GlobalPolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_MonogenicFiniteExtension`(a, K0)	将 `ExtensionElement` 转换为 `dtype`。
`from_PolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_QQ_gmpy`(a, K0)	将 GMPY 的 `mpq` 对象转换为 `dtype`。
`from_QQ_python`(a, K0)	将 Python `Fraction` 对象转换为 `dtype`。
`from_RealField`(a, K0)	将一个真实的元素对象转换为 `dtype`。
`from_ZZ_gmpy`(a, K0)	将 GMPY 的 `mpz` 对象转换为 `dtype`。
`from_ZZ_python`(a, K0)	将 Python `int` 对象转换为 `dtype`。
`from_sympy`(a)	将 SymPy 表达式转换为此域的一个元素。
`gcd`(a, b)	返回 `a` 和 `b` 的最大公约数。
`gcdex`(a, b)	`a` 和 `b` 的扩展最大公约数。
`get_exact`()	返回与 `self` 关联的精确域。
`get_field`()	返回与 `self` 关联的字段。
`get_ring`()	返回与 `self` 相关联的环。
`half_gcdex`(a, b)	`a` 和 `b` 的半扩展最大公约数。
`ideal`(*gens)	生成一个理想的 `自我`。
`inject`(*symbols)	将生成器注入此域。
`invert`(a, b)	返回 `a mod b` 的逆。
`is_negative`(a)	如果 `a` 为负数，则返回 True。
`is_nonnegative`(a)	如果 `a` 是非负的，则返回 True。
`is_nonpositive`(a)	如果 `a` 是非正数，则返回 True。
`is_one`(a)	如果 `a` 是 1，则返回 True。
`is_positive`(a)	如果 `a` 为正，则返回 True。
`is_square`(a)	返回 `a` 是否是该域中的一个平方数。
`is_zero`(a)	如果 `a` 为零，则返回 True。
`lcm`(a, b)	返回 `a` 和 `b` 的最小公倍数。
`log`(a, b)	返回 `a` 的 b 进制对数。
`map`(seq)	递归地将 `self` 应用于 `seq` 的所有元素。
`mul`(a, b)	`a` 和 `b` 的乘积，意味着 `__mul__`。
`n`(a[, prec])	返回 `a` 的数值近似值。
`neg`(a)	返回 `a` 的否定值，意味着 `__neg__`。
`numer`(a)	返回 `a` 的分子。
`of_type`(element)	检查 `a` 是否为 `dtype` 类型。
`old_frac_field`(symbols, *kwargs)	返回一个分数域，即 \(K(X)\)。
`old_poly_ring`(symbols, *kwargs)	返回一个多项式环，即 \(K[X]\)。
`poly_ring`(*symbols[, order])	返回一个多项式环，即 \(K[X]\)。
`pos`(a)	返回 `a` 为正，意味着 `__pos__`。
`pow`(a, b)	将 `a` 提升到 `b` 的幂，意味着 `__pow__`。
`quo`(a, b)	`a` 和 `b` 的商，意味着 `__floordiv__`。
`quotient_ring`(e)	形成 `self` 的商环。
`rem`(a, b)	`a` 和 `b` 的余数，意味着 `__mod__`。
`revert`(a)	如果可能，返回 `a**(-1)`。
`sqrt`(a)	返回 `a` 的（可能不精确的）平方根。
`sub`(a, b)	`a` 和 `b` 的差异，意味着 `__sub__`。
`to_sympy`(a)	将域元素 a 转换为 SymPy 表达式 (Expr)。
`unify`(K1[, symbols])	构建一个包含 `K0` 和 `K1` 元素的最小域。
`unify_composite`(K1)	统一两个领域，其中至少一个是复合的。

canonical_unit
from_GeneralizedPolynomialRing
imag
is_unit
新
正常
真实
总和
unify_with_symbols

denom(a)[源代码][源代码]¶: 返回 \(a\) 的分母。

div(a, b)[源代码][源代码]¶: a 和 b 的除法，意味着 __divmod__。

exquo(a, b)[源代码][源代码]¶: a 和 b 的精确商，意味着 __floordiv__。

free_module(rank)[源代码][源代码]¶

在自身上生成一个秩为 rank 的自由模。

>>> from sympy.abc import x
>>> from sympy import QQ
>>> QQ.old_poly_ring(x).free_module(2)
QQ[x]**2

get_ring()[源代码][源代码]¶: 返回与 self 相关联的环。

ideal(*gens)[源代码][源代码]¶

生成一个理想的 自我。

>>> from sympy.abc import x
>>> from sympy import QQ
>>> QQ.old_poly_ring(x).ideal(x**2)
<x**2>

invert(a, b)[源代码][源代码]¶: 返回 a mod b 的逆。

numer(a)[源代码][源代码]¶: 返回 a 的分子。

quo(a, b)[源代码][源代码]¶: a 和 b 的商，意味着 __floordiv__。

quotient_ring(e)[源代码][源代码]¶

形成 self 的商环。

这里 e 可以是一个理想或一个可迭代对象。

>>> from sympy.abc import x
>>> from sympy import QQ
>>> QQ.old_poly_ring(x).quotient_ring(QQ.old_poly_ring(x).ideal(x**2))
QQ[x]/<x**2>
>>> QQ.old_poly_ring(x).quotient_ring([x**2])
QQ[x]/<x**2>

除法运算符已为此重载：

>>> QQ.old_poly_ring(x)/[x**2]
QQ[x]/<x**2>

rem(a, b)[源代码][源代码]¶: a 和 b 的余数，意味着 __mod__。

revert(a)[源代码][源代码]¶: 如果可能，返回 a**(-1)。

class sympy.polys.domains.simpledomain.SimpleDomain[源代码][源代码]¶

简单域的基类，例如 ZZ, QQ。

属性:

别名
dtype
一
rep
tp: 别名 dtype
零

方法

`__call__`(*args)	从 `args` 构造 `self` 域的一个元素。
`abs`(a)	`a` 的绝对值，意味着 `__abs__`。
`add`(a, b)	`a` 和 `b` 的和，意味着 `__add__`。
`alg_field_from_poly`(poly[, alias, root_index])	通过根索引选择多项式的根来构造代数扩展的便捷方法。
`algebraic_field`(*extension[, alias])	返回一个代数数域，即 \(K(\alpha, \ldots)\)。
`almosteq`(a, b[, tolerance])	检查 `a` 和 `b` 是否几乎相等。
`characteristic`()	返回此域的特征。
`cofactors`(a, b)	返回 `a` 和 `b` 的最大公约数和余因子。
`convert`(element[, base])	将 `element` 转换为 `self.dtype`。
`convert_from`(element, base)	在给定的基本域中将 `element` 转换为 `self.dtype`。
`cyclotomic_field`(n[, ss, alias, gen, root_index])	构建分圆域的便捷方法。
`denom`(a)	返回 `a` 的分母。
`div`(a, b)	计算 a 和 b 的商和余数。
`drop`(*symbols)	从此领域中移除生成器。
`evalf`(a[, prec])	返回 `a` 的数值近似值。
`exquo`(a, b)	a 和 b 的精确商。
`exsqrt`(a)	在 `a` 是平方数的域内的主平方根。
`frac_field`(*symbols[, order])	返回一个分数域，即 \(K(X)\)。
`from_AlgebraicField`(a, K0)	将一个代数数转换为 `dtype`。
`from_ComplexField`(a, K0)	将复杂元素转换为 `dtype`。
`from_ExpressionDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_ExpressionRawDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_FF`(a, K0)	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FF_gmpy`(a, K0)	将 `ModularInteger(mpz)` 转换为 `dtype`。
`from_FF_python`(a, K0)	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FractionField`(a, K0)	将一个有理函数转换为 `dtype`。
`from_GlobalPolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_MonogenicFiniteExtension`(a, K0)	将 `ExtensionElement` 转换为 `dtype`。
`from_PolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_QQ_gmpy`(a, K0)	将 GMPY 的 `mpq` 对象转换为 `dtype`。
`from_QQ_python`(a, K0)	将 Python `Fraction` 对象转换为 `dtype`。
`from_RealField`(a, K0)	将一个真实的元素对象转换为 `dtype`。
`from_ZZ_gmpy`(a, K0)	将 GMPY 的 `mpz` 对象转换为 `dtype`。
`from_ZZ_python`(a, K0)	将 Python `int` 对象转换为 `dtype`。
`from_sympy`(a)	将 SymPy 表达式转换为此域的一个元素。
`gcd`(a, b)	返回 `a` 和 `b` 的最大公约数。
`gcdex`(a, b)	`a` 和 `b` 的扩展最大公约数。
`get_exact`()	返回与 `self` 关联的精确域。
`get_field`()	返回与 `self` 关联的字段。
`get_ring`()	返回与 `self` 相关联的环。
`half_gcdex`(a, b)	`a` 和 `b` 的半扩展最大公约数。
`inject`(*gens)	将生成器注入此域。
`invert`(a, b)	返回 `a mod b` 的逆，意味着某事。
`is_negative`(a)	如果 `a` 为负数，则返回 True。
`is_nonnegative`(a)	如果 `a` 是非负的，则返回 True。
`is_nonpositive`(a)	如果 `a` 是非正数，则返回 True。
`is_one`(a)	如果 `a` 是 1，则返回 True。
`is_positive`(a)	如果 `a` 为正，则返回 True。
`is_square`(a)	返回 `a` 是否是该域中的一个平方数。
`is_zero`(a)	如果 `a` 为零，则返回 True。
`lcm`(a, b)	返回 `a` 和 `b` 的最小公倍数。
`log`(a, b)	返回 `a` 的 b 进制对数。
`map`(seq)	递归地将 `self` 应用于 `seq` 的所有元素。
`mul`(a, b)	`a` 和 `b` 的乘积，意味着 `__mul__`。
`n`(a[, prec])	返回 `a` 的数值近似值。
`neg`(a)	返回 `a` 的否定值，意味着 `__neg__`。
`numer`(a)	返回 `a` 的分子。
`of_type`(element)	检查 `a` 是否为 `dtype` 类型。
`old_frac_field`(symbols, *kwargs)	返回一个分数域，即 \(K(X)\)。
`old_poly_ring`(symbols, *kwargs)	返回一个多项式环，即 \(K[X]\)。
`poly_ring`(*symbols[, order])	返回一个多项式环，即 \(K[X]\)。
`pos`(a)	返回 `a` 为正，意味着 `__pos__`。
`pow`(a, b)	将 `a` 提升到 `b` 的幂，意味着 `__pow__`。
`quo`(a, b)	a 和 b 的商。
`rem`(a, b)	对 a 和 b 进行取模运算。
`revert`(a)	如果可能，返回 `a**(-1)`。
`sqrt`(a)	返回 `a` 的（可能不精确的）平方根。
`sub`(a, b)	`a` 和 `b` 的差异，意味着 `__sub__`。
`to_sympy`(a)	将域元素 a 转换为 SymPy 表达式 (Expr)。
`unify`(K1[, symbols])	构建一个包含 `K0` 和 `K1` 元素的最小域。
`unify_composite`(K1)	统一两个领域，其中至少一个是复合的。

canonical_unit
from_GeneralizedPolynomialRing
imag
新
正常
真实
总和
unify_with_symbols

inject(*gens)[源代码][源代码]¶: 将生成器注入此域。

class sympy.polys.domains.compositedomain.CompositeDomain[源代码][源代码]¶

复合域的基类，例如 ZZ[x], ZZ(X)。

属性:

别名
领域
dtype
生成
has_CharacteristicZero
is_Exact: 如果此域是精确的，则返回 True。
ngens
一
rep
符号
tp: 别名 dtype
零

方法

`__call__`(*args)	从 `args` 构造 `self` 域的一个元素。
`abs`(a)	`a` 的绝对值，意味着 `__abs__`。
`add`(a, b)	`a` 和 `b` 的和，意味着 `__add__`。
`alg_field_from_poly`(poly[, alias, root_index])	通过根索引选择多项式的根来构造代数扩展的便捷方法。
`algebraic_field`(*extension[, alias])	返回一个代数数域，即 \(K(\alpha, \ldots)\)。
`almosteq`(a, b[, tolerance])	检查 `a` 和 `b` 是否几乎相等。
`characteristic`()
`cofactors`(a, b)	返回 `a` 和 `b` 的最大公约数和余因子。
`convert`(element[, base])	将 `element` 转换为 `self.dtype`。
`convert_from`(element, base)	在给定的基本域中将 `element` 转换为 `self.dtype`。
`cyclotomic_field`(n[, ss, alias, gen, root_index])	构建分圆域的便捷方法。
`denom`(a)	返回 `a` 的分母。
`div`(a, b)	计算 a 和 b 的商和余数。
`drop`(*symbols)	从此领域中移除生成器。
`evalf`(a[, prec])	返回 `a` 的数值近似值。
`exquo`(a, b)	a 和 b 的精确商。
`exsqrt`(a)	在 `a` 是平方数的域内的主平方根。
`frac_field`(*symbols[, order])	返回一个分数域，即 \(K(X)\)。
`from_AlgebraicField`(a, K0)	将一个代数数转换为 `dtype`。
`from_ComplexField`(a, K0)	将复杂元素转换为 `dtype`。
`from_ExpressionDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_ExpressionRawDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_FF`(a, K0)	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FF_gmpy`(a, K0)	将 `ModularInteger(mpz)` 转换为 `dtype`。
`from_FF_python`(a, K0)	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FractionField`(a, K0)	将一个有理函数转换为 `dtype`。
`from_GlobalPolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_MonogenicFiniteExtension`(a, K0)	将 `ExtensionElement` 转换为 `dtype`。
`from_PolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_QQ_gmpy`(a, K0)	将 GMPY 的 `mpq` 对象转换为 `dtype`。
`from_QQ_python`(a, K0)	将 Python `Fraction` 对象转换为 `dtype`。
`from_RealField`(a, K0)	将一个真实的元素对象转换为 `dtype`。
`from_ZZ_gmpy`(a, K0)	将 GMPY 的 `mpz` 对象转换为 `dtype`。
`from_ZZ_python`(a, K0)	将 Python `int` 对象转换为 `dtype`。
`from_sympy`(a)	将 SymPy 表达式转换为此域的一个元素。
`gcd`(a, b)	返回 `a` 和 `b` 的最大公约数。
`gcdex`(a, b)	`a` 和 `b` 的扩展最大公约数。
`get_exact`()	返回此域的精确版本。
`get_field`()	返回与 `self` 关联的字段。
`get_ring`()	返回与 `self` 相关联的环。
`half_gcdex`(a, b)	`a` 和 `b` 的半扩展最大公约数。
`inject`(*symbols)	将生成器注入此域。
`invert`(a, b)	返回 `a mod b` 的逆，意味着某事。
`is_negative`(a)	如果 `a` 为负数，则返回 True。
`is_nonnegative`(a)	如果 `a` 是非负的，则返回 True。
`is_nonpositive`(a)	如果 `a` 是非正数，则返回 True。
`is_one`(a)	如果 `a` 是 1，则返回 True。
`is_positive`(a)	如果 `a` 为正，则返回 True。
`is_square`(a)	返回 `a` 是否是该域中的一个平方数。
`is_zero`(a)	如果 `a` 为零，则返回 True。
`lcm`(a, b)	返回 `a` 和 `b` 的最小公倍数。
`log`(a, b)	返回 `a` 的 b 进制对数。
`map`(seq)	递归地将 `self` 应用于 `seq` 的所有元素。
`mul`(a, b)	`a` 和 `b` 的乘积，意味着 `__mul__`。
`n`(a[, prec])	返回 `a` 的数值近似值。
`neg`(a)	返回 `a` 的否定值，意味着 `__neg__`。
`numer`(a)	返回 `a` 的分子。
`of_type`(element)	检查 `a` 是否为 `dtype` 类型。
`old_frac_field`(symbols, *kwargs)	返回一个分数域，即 \(K(X)\)。
`old_poly_ring`(symbols, *kwargs)	返回一个多项式环，即 \(K[X]\)。
`poly_ring`(*symbols[, order])	返回一个多项式环，即 \(K[X]\)。
`pos`(a)	返回 `a` 为正，意味着 `__pos__`。
`pow`(a, b)	将 `a` 提升到 `b` 的幂，意味着 `__pow__`。
`quo`(a, b)	a 和 b 的商。
`rem`(a, b)	对 a 和 b 进行取模运算。
`revert`(a)	如果可能，返回 `a**(-1)`。
`set_domain`(domain)	设置此域的基本域。
`sqrt`(a)	返回 `a` 的（可能不精确的）平方根。
`sub`(a, b)	`a` 和 `b` 的差异，意味着 `__sub__`。
`to_sympy`(a)	将域元素 a 转换为 SymPy 表达式 (Expr)。
`unify`(K1[, symbols])	构建一个包含 `K0` 和 `K1` 元素的最小域。
`unify_composite`(K1)	统一两个领域，其中至少一个是复合的。

canonical_unit
from_GeneralizedPolynomialRing
imag
新
正常
真实
总和
unify_with_symbols

drop(*symbols)[源代码][源代码]¶: 从此领域中移除生成器。

get_exact()[源代码][源代码]¶: 返回此域的精确版本。

inject(*symbols)[源代码][源代码]¶: 将生成器注入此域。

property is_Exact¶: 如果此域是精确的，则返回 True。

set_domain(domain)[源代码][源代码]¶: 设置此域的基本域。

GF(p)¶

class sympy.polys.domains.FiniteField(mod, symmetric=True)[源代码][源代码]¶

素数阶有限域 GF(p)

GF(p) 域表示一个素数阶的有限域 \(\mathbb{F}_p\)，作为域系统中的 Domain`（参见 :ref:`polys-domainsintro）。

从具有整数系数的表达式创建的 Poly 将具有域 ZZ。然而，如果给出了 modulus=p 选项，那么域将是一个有限域。

>>> from sympy import Poly, Symbol
>>> x = Symbol('x')
>>> p = Poly(x**2 + 1)
>>> p
Poly(x**2 + 1, x, domain='ZZ')
>>> p.domain
ZZ
>>> p2 = Poly(x**2 + 1, modulus=2)
>>> p2
Poly(x**2 + 1, x, modulus=2)
>>> p2.domain
GF(2)

可以通过将模数参数传递给 factor() 或在显式指定域的情况下，对多项式进行 GF(p) 上的因式分解。域也可以作为字符串给出。

>>> from sympy import factor, GF
>>> factor(x**2 + 1)
x**2 + 1
>>> factor(x**2 + 1, modulus=2)
(x + 1)**2
>>> factor(x**2 + 1, domain=GF(2))
(x + 1)**2
>>> factor(x**2 + 1, domain='GF(2)')
(x + 1)**2

也可以使用 GF(p) 与 cancel() 和 gcd() 函数。

>>> from sympy import cancel, gcd
>>> cancel((x**2 + 1)/(x + 1))
(x**2 + 1)/(x + 1)
>>> cancel((x**2 + 1)/(x + 1), domain=GF(2))
x + 1
>>> gcd(x**2 + 1, x + 1)
1
>>> gcd(x**2 + 1, x + 1, domain=GF(2))
x + 1

当直接使用域时，GF(p) 可以用作构造函数来创建实例，这些实例随后支持操作 +,-,*,**,/

>>> from sympy import GF
>>> K = GF(5)
>>> K
GF(5)
>>> x = K(3)
>>> y = K(2)
>>> x
3 mod 5
>>> y
2 mod 5
>>> x * y
1 mod 5
>>> x / y
4 mod 5

属性:

dom
dtype
mod
一
tp: 别名 dtype
零

方法

`__call__`(*args)	从 `args` 构造 `self` 域的一个元素。
`abs`(a)	`a` 的绝对值，意味着 `__abs__`。
`add`(a, b)	`a` 和 `b` 的和，意味着 `__add__`。
`alg_field_from_poly`(poly[, alias, root_index])	通过根索引选择多项式的根来构造代数扩展的便捷方法。
`algebraic_field`(*extension[, alias])	返回一个代数数域，即 \(K(\alpha, \ldots)\)。
`almosteq`(a, b[, tolerance])	检查 `a` 和 `b` 是否几乎相等。
`characteristic`()	返回此域的特征。
`cofactors`(a, b)	返回 `a` 和 `b` 的最大公约数和余因子。
`convert`(element[, base])	将 `element` 转换为 `self.dtype`。
`convert_from`(element, base)	在给定的基本域中将 `element` 转换为 `self.dtype`。
`cyclotomic_field`(n[, ss, alias, gen, root_index])	构建分圆域的便捷方法。
`denom`(a)	返回 \(a\) 的分母。
`div`(a, b)	`a` 和 `b` 的除法，意味着 `__truediv__`。
`drop`(*symbols)	从此领域中移除生成器。
`evalf`(a[, prec])	返回 `a` 的数值近似值。
`exquo`(a, b)	`a` 和 `b` 的精确商，意味着 `__truediv__`。
`exsqrt`(a)	如果 `a` 是二次剩余，则为其模 `p` 的平方根。
`frac_field`(*symbols[, order])	返回一个分数域，即 \(K(X)\)。
`free_module`(rank)	在自身上生成一个秩为 `rank` 的自由模。
`from_AlgebraicField`(a, K0)	将一个代数数转换为 `dtype`。
`from_ComplexField`(a, K0)	将复杂元素转换为 `dtype`。
`from_ExpressionDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_ExpressionRawDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_FF`(a[, K0])	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FF_gmpy`(a[, K0])	将 `ModularInteger(mpz)` 转换为 `dtype`。
`from_FF_python`(a[, K0])	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FractionField`(a, K0)	将一个有理函数转换为 `dtype`。
`from_GlobalPolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_MonogenicFiniteExtension`(a, K0)	将 `ExtensionElement` 转换为 `dtype`。
`from_PolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_QQ`(a[, K0])	将 Python 的 `Fraction` 转换为 `dtype`。
`from_QQ_gmpy`(a[, K0])	将 GMPY 的 `mpq` 转换为 `dtype`。
`from_QQ_python`(a[, K0])	将 Python 的 `Fraction` 转换为 `dtype`。
`from_RealField`(a, K0)	将 mpmath 的 `mpf` 转换为 `dtype`。
`from_ZZ`(a[, K0])	将 Python 的 `int` 转换为 `dtype`。
`from_ZZ_gmpy`(a[, K0])	将 GMPY 的 `mpz` 转换为 `dtype`。
`from_ZZ_python`(a[, K0])	将 Python 的 `int` 转换为 `dtype`。
`from_sympy`(a)	将 SymPy 的 Integer 转换为 SymPy 的 `Integer`。
`gcd`(a, b)	返回 `a` 和 `b` 的最大公约数。
`gcdex`(a, b)	返回 x, y, g 使得 a * x + b * y == g == gcd(a, b)
`get_exact`()	返回与 `self` 关联的精确域。
`get_field`()	返回与 `self` 关联的字段。
`get_ring`()	返回与 `self` 相关联的环。
`half_gcdex`(a, b)	`a` 和 `b` 的半扩展最大公约数。
`ideal`(*gens)	生成一个理想的 `自我`。
`inject`(*gens)	将生成器注入此域。
`invert`(a, b)	返回 `a mod b` 的逆。
`is_negative`(a)	如果 `a` 为负数，则返回 True。
`is_nonnegative`(a)	如果 `a` 是非负的，则返回 True。
`is_nonpositive`(a)	如果 `a` 是非正数，则返回 True。
`is_one`(a)	如果 `a` 是 1，则返回 True。
`is_positive`(a)	如果 `a` 为正，则返回 True。
`is_square`(a)	如果 `a` 是模 p 的二次剩余，则返回 True。
`is_unit`(a)	如果 `a` 是可逆的，则返回 true
`is_zero`(a)	如果 `a` 为零，则返回 True。
`lcm`(a, b)	返回 `a` 和 `b` 的最小公倍数。
`log`(a, b)	返回 `a` 的 b 进制对数。
`map`(seq)	递归地将 `self` 应用于 `seq` 的所有元素。
`mul`(a, b)	`a` 和 `b` 的乘积，意味着 `__mul__`。
`n`(a[, prec])	返回 `a` 的数值近似值。
`neg`(a)	返回 `a` 的否定值，意味着 `__neg__`。
`numer`(a)	返回 `a` 的分子。
`of_type`(element)	检查 `a` 是否为 `dtype` 类型。
`old_frac_field`(symbols, *kwargs)	返回一个分数域，即 \(K(X)\)。
`old_poly_ring`(symbols, *kwargs)	返回一个多项式环，即 \(K[X]\)。
`poly_ring`(*symbols[, order])	返回一个多项式环，即 \(K[X]\)。
`pos`(a)	返回 `a` 为正，意味着 `__pos__`。
`pow`(a, b)	将 `a` 提升到 `b` 的幂，意味着 `__pow__`。
`quo`(a, b)	`a` 和 `b` 的商，意味着 `__truediv__`。
`quotient_ring`(e)	形成 `self` 的商环。
`rem`(a, b)	`a` 和 `b` 的余数，没有隐含意义。
`revert`(a)	如果可能，返回 `a**(-1)`。
`sqrt`(a)	返回 `a` 的（可能不精确的）平方根。
`sub`(a, b)	`a` 和 `b` 的差异，意味着 `__sub__`。
`to_int`(a)	将 `val` 转换为 Python `int` 对象。
`to_sympy`(a)	将 `a` 转换为 SymPy 对象。
`unify`(K1[, symbols])	构建一个包含 `K0` 和 `K1` 元素的最小域。
`unify_composite`(K1)	统一两个领域，其中至少一个是复合的。

canonical_unit
from_GeneralizedPolynomialRing
imag
新
正常
真实
总和
unify_with_symbols

注释

也可以创建一个 GF(p) 域，其阶数为 非素数 ，但生成的环不是一个域：它只是整数模 n 的环。

>>> K = GF(9)
>>> z = K(3)
>>> z
3 mod 9
>>> z**2
0 mod 9

有一个素数幂域（GF(p**n)）的适当实现会很好，但这些在SymPY中尚未实现。

characteristic()[源代码][源代码]¶: 返回此域的特征。

exsqrt(a)[源代码][源代码]¶: 如果 a 是二次剩余，则为其模 p 的平方根。

from_FF(a, K0=None)[源代码][源代码]¶: 将 ModularInteger(int) 转换为 dtype。

from_FF_gmpy(a, K0=None)[源代码][源代码]¶: 将 ModularInteger(mpz) 转换为 dtype。

from_FF_python(a, K0=None)[源代码][源代码]¶: 将 ModularInteger(int) 转换为 dtype。

from_QQ(a, K0=None)[源代码][源代码]¶: 将 Python 的 Fraction 转换为 dtype。

from_QQ_gmpy(a, K0=None)[源代码][源代码]¶: 将 GMPY 的 mpq 转换为 dtype。

from_QQ_python(a, K0=None)[源代码][源代码]¶: 将 Python 的 Fraction 转换为 dtype。

from_RealField(a, K0)[源代码][源代码]¶: 将 mpmath 的 mpf 转换为 dtype。

from_ZZ(a, K0=None)[源代码][源代码]¶: 将 Python 的 int 转换为 dtype。

from_ZZ_gmpy(a, K0=None)[源代码][源代码]¶: 将 GMPY 的 mpz 转换为 dtype。

from_ZZ_python(a, K0=None)[源代码][源代码]¶: 将 Python 的 int 转换为 dtype。

from_sympy(a)[源代码][源代码]¶: 将 SymPy 的 Integer 转换为 SymPy 的 Integer。

get_field()[源代码][源代码]¶: 返回与 self 关联的字段。

is_negative(a)[源代码][源代码]¶: 如果 a 为负数，则返回 True。

is_nonnegative(a)[源代码][源代码]¶: 如果 a 是非负的，则返回 True。

is_nonpositive(a)[源代码][源代码]¶: 如果 a 是非正数，则返回 True。

is_positive(a)[源代码][源代码]¶: 如果 a 为正，则返回 True。

is_square(a)[源代码][源代码]¶: 如果 a 是模 p 的二次剩余，则返回 True。

to_int(a)[源代码][源代码]¶: 将 val 转换为 Python int 对象。

to_sympy(a)[源代码][源代码]¶: 将 a 转换为 SymPy 对象。

class sympy.polys.domains.PythonFiniteField(mod, symmetric=True)[源代码][源代码]¶

基于Python整数的有限域。

属性:

dom
dtype
mod
一
tp: 别名 dtype
零

方法

`__call__`(*args)	从 `args` 构造 `self` 域的一个元素。
`abs`(a)	`a` 的绝对值，意味着 `__abs__`。
`add`(a, b)	`a` 和 `b` 的和，意味着 `__add__`。
`alg_field_from_poly`(poly[, alias, root_index])	通过根索引选择多项式的根来构造代数扩展的便捷方法。
`algebraic_field`(*extension[, alias])	返回一个代数数域，即 \(K(\alpha, \ldots)\)。
`almosteq`(a, b[, tolerance])	检查 `a` 和 `b` 是否几乎相等。
`characteristic`()	返回此域的特征。
`cofactors`(a, b)	返回 `a` 和 `b` 的最大公约数和余因子。
`convert`(element[, base])	将 `element` 转换为 `self.dtype`。
`convert_from`(element, base)	在给定的基本域中将 `element` 转换为 `self.dtype`。
`cyclotomic_field`(n[, ss, alias, gen, root_index])	构建分圆域的便捷方法。
`denom`(a)	返回 \(a\) 的分母。
`div`(a, b)	`a` 和 `b` 的除法，意味着 `__truediv__`。
`drop`(*symbols)	从此领域中移除生成器。
`evalf`(a[, prec])	返回 `a` 的数值近似值。
`exquo`(a, b)	`a` 和 `b` 的精确商，意味着 `__truediv__`。
`exsqrt`(a)	如果 `a` 是二次剩余，则为其模 `p` 的平方根。
`frac_field`(*symbols[, order])	返回一个分数域，即 \(K(X)\)。
`free_module`(rank)	在自身上生成一个秩为 `rank` 的自由模。
`from_AlgebraicField`(a, K0)	将一个代数数转换为 `dtype`。
`from_ComplexField`(a, K0)	将复杂元素转换为 `dtype`。
`from_ExpressionDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_ExpressionRawDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_FF`(a[, K0])	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FF_gmpy`(a[, K0])	将 `ModularInteger(mpz)` 转换为 `dtype`。
`from_FF_python`(a[, K0])	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FractionField`(a, K0)	将一个有理函数转换为 `dtype`。
`from_GlobalPolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_MonogenicFiniteExtension`(a, K0)	将 `ExtensionElement` 转换为 `dtype`。
`from_PolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_QQ`(a[, K0])	将 Python 的 `Fraction` 转换为 `dtype`。
`from_QQ_gmpy`(a[, K0])	将 GMPY 的 `mpq` 转换为 `dtype`。
`from_QQ_python`(a[, K0])	将 Python 的 `Fraction` 转换为 `dtype`。
`from_RealField`(a, K0)	将 mpmath 的 `mpf` 转换为 `dtype`。
`from_ZZ`(a[, K0])	将 Python 的 `int` 转换为 `dtype`。
`from_ZZ_gmpy`(a[, K0])	将 GMPY 的 `mpz` 转换为 `dtype`。
`from_ZZ_python`(a[, K0])	将 Python 的 `int` 转换为 `dtype`。
`from_sympy`(a)	将 SymPy 的 Integer 转换为 SymPy 的 `Integer`。
`gcd`(a, b)	返回 `a` 和 `b` 的最大公约数。
`gcdex`(a, b)	返回 x, y, g 使得 a * x + b * y == g == gcd(a, b)
`get_exact`()	返回与 `self` 关联的精确域。
`get_field`()	返回与 `self` 关联的字段。
`get_ring`()	返回与 `self` 相关联的环。
`half_gcdex`(a, b)	`a` 和 `b` 的半扩展最大公约数。
`ideal`(*gens)	生成一个理想的 `自我`。
`inject`(*gens)	将生成器注入此域。
`invert`(a, b)	返回 `a mod b` 的逆。
`is_negative`(a)	如果 `a` 为负数，则返回 True。
`is_nonnegative`(a)	如果 `a` 是非负的，则返回 True。
`is_nonpositive`(a)	如果 `a` 是非正数，则返回 True。
`is_one`(a)	如果 `a` 是 1，则返回 True。
`is_positive`(a)	如果 `a` 为正，则返回 True。
`is_square`(a)	如果 `a` 是模 p 的二次剩余，则返回 True。
`is_unit`(a)	如果 `a` 是可逆的，则返回 true
`is_zero`(a)	如果 `a` 为零，则返回 True。
`lcm`(a, b)	返回 `a` 和 `b` 的最小公倍数。
`log`(a, b)	返回 `a` 的 b 进制对数。
`map`(seq)	递归地将 `self` 应用于 `seq` 的所有元素。
`mul`(a, b)	`a` 和 `b` 的乘积，意味着 `__mul__`。
`n`(a[, prec])	返回 `a` 的数值近似值。
`neg`(a)	返回 `a` 的否定值，意味着 `__neg__`。
`numer`(a)	返回 `a` 的分子。
`of_type`(element)	检查 `a` 是否为 `dtype` 类型。
`old_frac_field`(symbols, *kwargs)	返回一个分数域，即 \(K(X)\)。
`old_poly_ring`(symbols, *kwargs)	返回一个多项式环，即 \(K[X]\)。
`poly_ring`(*symbols[, order])	返回一个多项式环，即 \(K[X]\)。
`pos`(a)	返回 `a` 为正，意味着 `__pos__`。
`pow`(a, b)	将 `a` 提升到 `b` 的幂，意味着 `__pow__`。
`quo`(a, b)	`a` 和 `b` 的商，意味着 `__truediv__`。
`quotient_ring`(e)	形成 `self` 的商环。
`rem`(a, b)	`a` 和 `b` 的余数，没有隐含意义。
`revert`(a)	如果可能，返回 `a**(-1)`。
`sqrt`(a)	返回 `a` 的（可能不精确的）平方根。
`sub`(a, b)	`a` 和 `b` 的差异，意味着 `__sub__`。
`to_int`(a)	将 `val` 转换为 Python `int` 对象。
`to_sympy`(a)	将 `a` 转换为 SymPy 对象。
`unify`(K1[, symbols])	构建一个包含 `K0` 和 `K1` 元素的最小域。
`unify_composite`(K1)	统一两个领域，其中至少一个是复合的。

canonical_unit
from_GeneralizedPolynomialRing
imag
新
正常
真实
总和
unify_with_symbols

class sympy.polys.domains.GMPYFiniteField(mod, symmetric=True)[源代码][源代码]¶

基于 GMPY 整数的有限域。

属性:

dom
dtype
mod
一
tp: 别名 dtype
零

方法

`__call__`(*args)	从 `args` 构造 `self` 域的一个元素。
`abs`(a)	`a` 的绝对值，意味着 `__abs__`。
`add`(a, b)	`a` 和 `b` 的和，意味着 `__add__`。
`alg_field_from_poly`(poly[, alias, root_index])	通过根索引选择多项式的根来构造代数扩展的便捷方法。
`algebraic_field`(*extension[, alias])	返回一个代数数域，即 \(K(\alpha, \ldots)\)。
`almosteq`(a, b[, tolerance])	检查 `a` 和 `b` 是否几乎相等。
`characteristic`()	返回此域的特征。
`cofactors`(a, b)	返回 `a` 和 `b` 的最大公约数和余因子。
`convert`(element[, base])	将 `element` 转换为 `self.dtype`。
`convert_from`(element, base)	在给定的基本域中将 `element` 转换为 `self.dtype`。
`cyclotomic_field`(n[, ss, alias, gen, root_index])	构建分圆域的便捷方法。
`denom`(a)	返回 \(a\) 的分母。
`div`(a, b)	`a` 和 `b` 的除法，意味着 `__truediv__`。
`drop`(*symbols)	从此领域中移除生成器。
`evalf`(a[, prec])	返回 `a` 的数值近似值。
`exquo`(a, b)	`a` 和 `b` 的精确商，意味着 `__truediv__`。
`exsqrt`(a)	如果 `a` 是二次剩余，则为其模 `p` 的平方根。
`frac_field`(*symbols[, order])	返回一个分数域，即 \(K(X)\)。
`free_module`(rank)	在自身上生成一个秩为 `rank` 的自由模。
`from_AlgebraicField`(a, K0)	将一个代数数转换为 `dtype`。
`from_ComplexField`(a, K0)	将复杂元素转换为 `dtype`。
`from_ExpressionDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_ExpressionRawDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_FF`(a[, K0])	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FF_gmpy`(a[, K0])	将 `ModularInteger(mpz)` 转换为 `dtype`。
`from_FF_python`(a[, K0])	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FractionField`(a, K0)	将一个有理函数转换为 `dtype`。
`from_GlobalPolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_MonogenicFiniteExtension`(a, K0)	将 `ExtensionElement` 转换为 `dtype`。
`from_PolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_QQ`(a[, K0])	将 Python 的 `Fraction` 转换为 `dtype`。
`from_QQ_gmpy`(a[, K0])	将 GMPY 的 `mpq` 转换为 `dtype`。
`from_QQ_python`(a[, K0])	将 Python 的 `Fraction` 转换为 `dtype`。
`from_RealField`(a, K0)	将 mpmath 的 `mpf` 转换为 `dtype`。
`from_ZZ`(a[, K0])	将 Python 的 `int` 转换为 `dtype`。
`from_ZZ_gmpy`(a[, K0])	将 GMPY 的 `mpz` 转换为 `dtype`。
`from_ZZ_python`(a[, K0])	将 Python 的 `int` 转换为 `dtype`。
`from_sympy`(a)	将 SymPy 的 Integer 转换为 SymPy 的 `Integer`。
`gcd`(a, b)	返回 `a` 和 `b` 的最大公约数。
`gcdex`(a, b)	返回 x, y, g 使得 a * x + b * y == g == gcd(a, b)
`get_exact`()	返回与 `self` 关联的精确域。
`get_field`()	返回与 `self` 关联的字段。
`get_ring`()	返回与 `self` 相关联的环。
`half_gcdex`(a, b)	`a` 和 `b` 的半扩展最大公约数。
`ideal`(*gens)	生成一个理想的 `自我`。
`inject`(*gens)	将生成器注入此域。
`invert`(a, b)	返回 `a mod b` 的逆。
`is_negative`(a)	如果 `a` 为负数，则返回 True。
`is_nonnegative`(a)	如果 `a` 是非负的，则返回 True。
`is_nonpositive`(a)	如果 `a` 是非正数，则返回 True。
`is_one`(a)	如果 `a` 是 1，则返回 True。
`is_positive`(a)	如果 `a` 为正，则返回 True。
`is_square`(a)	如果 `a` 是模 p 的二次剩余，则返回 True。
`is_unit`(a)	如果 `a` 是可逆的，则返回 true
`is_zero`(a)	如果 `a` 为零，则返回 True。
`lcm`(a, b)	返回 `a` 和 `b` 的最小公倍数。
`log`(a, b)	返回 `a` 的 b 进制对数。
`map`(seq)	递归地将 `self` 应用于 `seq` 的所有元素。
`mul`(a, b)	`a` 和 `b` 的乘积，意味着 `__mul__`。
`n`(a[, prec])	返回 `a` 的数值近似值。
`neg`(a)	返回 `a` 的否定值，意味着 `__neg__`。
`numer`(a)	返回 `a` 的分子。
`of_type`(element)	检查 `a` 是否为 `dtype` 类型。
`old_frac_field`(symbols, *kwargs)	返回一个分数域，即 \(K(X)\)。
`old_poly_ring`(symbols, *kwargs)	返回一个多项式环，即 \(K[X]\)。
`poly_ring`(*symbols[, order])	返回一个多项式环，即 \(K[X]\)。
`pos`(a)	返回 `a` 为正，意味着 `__pos__`。
`pow`(a, b)	将 `a` 提升到 `b` 的幂，意味着 `__pow__`。
`quo`(a, b)	`a` 和 `b` 的商，意味着 `__truediv__`。
`quotient_ring`(e)	形成 `self` 的商环。
`rem`(a, b)	`a` 和 `b` 的余数，没有隐含意义。
`revert`(a)	如果可能，返回 `a**(-1)`。
`sqrt`(a)	返回 `a` 的（可能不精确的）平方根。
`sub`(a, b)	`a` 和 `b` 的差异，意味着 `__sub__`。
`to_int`(a)	将 `val` 转换为 Python `int` 对象。
`to_sympy`(a)	将 `a` 转换为 SymPy 对象。
`unify`(K1[, symbols])	构建一个包含 `K0` 和 `K1` 元素的最小域。
`unify_composite`(K1)	统一两个领域，其中至少一个是复合的。

canonical_unit
from_GeneralizedPolynomialRing
imag
新
正常
真实
总和
unify_with_symbols

ZZ¶

The ZZ 域表示整数 \(\mathbb{Z}\) 作为域系统中的 Domain (参见介绍 poly 模块的领域)。

默认情况下，从具有整数系数的表达式创建的 Poly 将具有域 ZZ:

>>> from sympy import Poly, Symbol
>>> x = Symbol('x')
>>> p = Poly(x**2 + 1)
>>> p
Poly(x**2 + 1, x, domain='ZZ')
>>> p.domain
ZZ

对应的 field of fractions 是 QQ 的有理数域。相反，ZZ 是 QQ 的 ring of integers:

>>> from sympy import ZZ, QQ
>>> ZZ.get_field()
QQ
>>> QQ.get_ring()
ZZ

当直接使用域时，ZZ 可以用作构造函数来创建实例，这些实例随后支持操作 +,-,*,**,//,%``（真除法 ``/ 不应与 ZZ 一起使用 - 请参阅 exquo() 域方法）:

>>> x = ZZ(5)
>>> y = ZZ(2)
>>> x // y  # floor division
2
>>> x % y   # modulo division (remainder)
1

可以使用 gcd() 方法来计算任意两个元素的 gcd:

>>> ZZ.gcd(ZZ(10), ZZ(2))
2

在 SymPy 中有两种 ZZ 的实现。如果安装了 gmpy 或 gmpy2，那么 ZZ 将由 GMPYIntegerRing 实现，元素将是 gmpy.mpz 类型的实例。否则，如果未安装 gmpy 和 gmpy2，则 ZZ 将由 PythonIntegerRing 实现，该类使用 Python 的标准内置 int 类型。对于较大的整数，gmpy 可以更高效，因此在可用时是首选。

class sympy.polys.domains.IntegerRing[源代码][源代码]¶

域 ZZ 表示整数 \(\mathbb{Z}\)。

The IntegerRing 类表示整数环作为域系统中的 Domain。IntegerRing 是 PythonIntegerRing 和 GMPYIntegerRing 的超类之一，具体实现将取决于是否安装了 gmpy 或 gmpy2，用于 ZZ。

方法

`__call__`(*args)	从 `args` 构造 `self` 域的一个元素。
`abs`(a)	`a` 的绝对值，意味着 `__abs__`。
`add`(a, b)	`a` 和 `b` 的和，意味着 `__add__`。
`alg_field_from_poly`(poly[, alias, root_index])	通过根索引选择多项式的根来构造代数扩展的便捷方法。
`algebraic_field`(*extension[, alias])	返回一个代数域，即 \(\mathbb{Q}(\alpha, \ldots)\)。
`almosteq`(a, b[, tolerance])	检查 `a` 和 `b` 是否几乎相等。
`characteristic`()	返回此域的特征。
`cofactors`(a, b)	返回 `a` 和 `b` 的最大公约数和余因子。
`convert`(element[, base])	将 `element` 转换为 `self.dtype`。
`convert_from`(element, base)	在给定的基本域中将 `element` 转换为 `self.dtype`。
`cyclotomic_field`(n[, ss, alias, gen, root_index])	构建分圆域的便捷方法。
`denom`(a)	返回 \(a\) 的分母。
`div`(a, b)	`a` 和 `b` 的除法，意味着 `__divmod__`。
`drop`(*symbols)	从此领域中移除生成器。
`evalf`(a[, prec])	返回 `a` 的数值近似值。
`exquo`(a, b)	`a` 和 `b` 的精确商，意味着 `__floordiv__`。
`exsqrt`(a)	如果 `a` 是一个平方数，则 `a` 的非负平方根。
`factorial`(a)	计算 `a` 的阶乘。
`frac_field`(*symbols[, order])	返回一个分数域，即 \(K(X)\)。
`free_module`(rank)	在自身上生成一个秩为 `rank` 的自由模。
`from_AlgebraicField`(a, K0)	将 `ANP` 对象转换为 ZZ。
`from_ComplexField`(a, K0)	将复杂元素转换为 `dtype`。
`from_EX`(a, K0)	将 `Expression` 转换为 GMPY 的 `mpz`。
`from_ExpressionDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_ExpressionRawDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_FF`(a, K0)	将 `ModularInteger(int)` 转换为 GMPY 的 `mpz`。
`from_FF_gmpy`(a, K0)	将 `ModularInteger(mpz)` 转换为 GMPY 的 `mpz`。
`from_FF_python`(a, K0)	将 `ModularInteger(int)` 转换为 GMPY 的 `mpz`。
`from_FractionField`(a, K0)	将一个有理函数转换为 `dtype`。
`from_GlobalPolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_MonogenicFiniteExtension`(a, K0)	将 `ExtensionElement` 转换为 `dtype`。
`from_PolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_QQ`(a, K0)	将 Python 的 `Fraction` 转换为 GMPY 的 `mpz`。
`from_QQ_gmpy`(a, K0)	将 GMPY 的 `mpq` 转换为 GMPY 的 `mpz`。
`from_QQ_python`(a, K0)	将 Python 的 `Fraction` 转换为 GMPY 的 `mpz`。
`from_RealField`(a, K0)	将 mpmath 的 `mpf` 转换为 GMPY 的 `mpz`。
`from_ZZ`(a, K0)	将 Python 的 `int` 转换为 GMPY 的 `mpz`。
`from_ZZ_gmpy`(a, K0)	将 GMPY 的 `mpz` 转换为 GMPY 的 `mpz`。
`from_ZZ_python`(a, K0)	将 Python 的 `int` 转换为 GMPY 的 `mpz`。
`from_sympy`(a)	将 SymPy 的 Integer 转换为 `dtype`。
`gcd`(a, b)	计算 `a` 和 `b` 的最大公约数。
`gcdex`(a, b)	计算 `a` 和 `b` 的扩展最大公约数。
`get_exact`()	返回与 `self` 关联的精确域。
`get_field`()	返回相关的分数域 QQ
`get_ring`()	返回与 `self` 相关联的环。
`half_gcdex`(a, b)	`a` 和 `b` 的半扩展最大公约数。
`ideal`(*gens)	生成一个理想的 `自我`。
`inject`(*gens)	将生成器注入此域。
`invert`(a, b)	返回 `a mod b` 的逆。
`is_negative`(a)	如果 `a` 为负数，则返回 True。
`is_nonnegative`(a)	如果 `a` 是非负的，则返回 True。
`is_nonpositive`(a)	如果 `a` 是非正数，则返回 True。
`is_one`(a)	如果 `a` 是 1，则返回 True。
`is_positive`(a)	如果 `a` 为正，则返回 True。
`is_square`(a)	如果 `a` 是平方数，则返回 `True`。
`is_zero`(a)	如果 `a` 为零，则返回 True。
`lcm`(a, b)	计算 `a` 和 `b` 的最小公倍数。
`log`(a, b)	以 b 为底 a 的对数。
`map`(seq)	递归地将 `self` 应用于 `seq` 的所有元素。
`mul`(a, b)	`a` 和 `b` 的乘积，意味着 `__mul__`。
`n`(a[, prec])	返回 `a` 的数值近似值。
`neg`(a)	返回 `a` 的否定值，意味着 `__neg__`。
`numer`(a)	返回 `a` 的分子。
`of_type`(element)	检查 `a` 是否为 `dtype` 类型。
`old_frac_field`(symbols, *kwargs)	返回一个分数域，即 \(K(X)\)。
`old_poly_ring`(symbols, *kwargs)	返回一个多项式环，即 \(K[X]\)。
`poly_ring`(*symbols[, order])	返回一个多项式环，即 \(K[X]\)。
`pos`(a)	返回 `a` 为正，意味着 `__pos__`。
`pow`(a, b)	将 `a` 提升到 `b` 的幂，意味着 `__pow__`。
`quo`(a, b)	`a` 和 `b` 的商，意味着 `__floordiv__`。
`quotient_ring`(e)	形成 `self` 的商环。
`rem`(a, b)	`a` 和 `b` 的余数，意味着 `__mod__`。
`revert`(a)	如果可能，返回 `a**(-1)`。
`sqrt`(a)	计算 `a` 的平方根。
`sub`(a, b)	`a` 和 `b` 的差异，意味着 `__sub__`。
`to_sympy`(a)	将 `a` 转换为 SymPy 对象。
`unify`(K1[, symbols])	构建一个包含 `K0` 和 `K1` 元素的最小域。
`unify_composite`(K1)	统一两个领域，其中至少一个是复合的。

canonical_unit
from_GaussianIntegerRing
from_GeneralizedPolynomialRing
imag
is_unit
新
正常
真实
总和
unify_with_symbols

参见

Domain

algebraic_field( *extension, alias=None, )[源代码][源代码]¶

返回一个代数域，即 \(\mathbb{Q}(\alpha, \ldots)\)。

参数:

*扩展 : 一个或多个 Expr。一个或多个: 扩展的生成元。这些应该是代数上在 \(\mathbb{Q}\) 上的表达式。
别名 : str, Symbol, None, 可选 (默认=None)str, Symbol, None, optional (default=None): 如果提供，这将用作返回的 AlgebraicField 的基本元素的别名符号。

返回:

AlgebraicField: 一个表示代数域扩展的 Domain。

示例

>>> from sympy import ZZ, sqrt
>>> ZZ.algebraic_field(sqrt(2))
QQ<sqrt(2)>

exsqrt(a)[源代码][源代码]¶

如果 a 是一个平方数，则 a 的非负平方根。

参见

is_square

factorial(a)[源代码][源代码]¶: 计算 a 的阶乘。

from_AlgebraicField(a, K0)[源代码][源代码]¶

将 ANP 对象转换为 ZZ。

参见 convert()。

from_EX(a, K0)[源代码][源代码]¶: 将 Expression 转换为 GMPY 的 mpz。

from_FF(a, K0)[源代码][源代码]¶: 将 ModularInteger(int) 转换为 GMPY 的 mpz。

from_FF_gmpy(a, K0)[源代码][源代码]¶: 将 ModularInteger(mpz) 转换为 GMPY 的 mpz。

from_FF_python(a, K0)[源代码][源代码]¶: 将 ModularInteger(int) 转换为 GMPY 的 mpz。

from_QQ(a, K0)[源代码][源代码]¶: 将 Python 的 Fraction 转换为 GMPY 的 mpz。

from_QQ_gmpy(a, K0)[源代码][源代码]¶: 将 GMPY 的 mpq 转换为 GMPY 的 mpz。

from_QQ_python(a, K0)[源代码][源代码]¶: 将 Python 的 Fraction 转换为 GMPY 的 mpz。

from_RealField(a, K0)[源代码][源代码]¶: 将 mpmath 的 mpf 转换为 GMPY 的 mpz。

from_ZZ(a, K0)[源代码][源代码]¶: 将 Python 的 int 转换为 GMPY 的 mpz。

from_ZZ_gmpy(a, K0)[源代码][源代码]¶: 将 GMPY 的 mpz 转换为 GMPY 的 mpz。

from_ZZ_python(a, K0)[源代码][源代码]¶: 将 Python 的 int 转换为 GMPY 的 mpz。

from_sympy(a)[源代码][源代码]¶: 将 SymPy 的 Integer 转换为 dtype。

gcd(a, b)[源代码][源代码]¶: 计算 a 和 b 的最大公约数。

gcdex(a, b)[源代码][源代码]¶: 计算 a 和 b 的扩展最大公约数。

get_field()[源代码][源代码]¶

返回相关的分数域 QQ

返回:

QQ:: 相关分数域 QQ，一个表示有理数 \(\mathbb{Q}\) 的 Domain。

示例

>>> from sympy import ZZ
>>> ZZ.get_field()
QQ

is_square(a)[源代码][源代码]¶: 如果 a 是平方数，则返回 True。

lcm(a, b)[源代码][源代码]¶: 计算 a 和 b 的最小公倍数。

log(a, b)[源代码][源代码]¶

以 b 为底 a 的对数。

参数:

a: 数字
b: 数字

返回:

\(\lfloor\log(a, b)\rfloor\):: 以 b 为底 a 的对数的向下取整

注释

此函数使用 math.log ，该函数基于 float ，因此对于大整数参数将会失败。

示例

>>> from sympy import ZZ
>>> ZZ.log(ZZ(8), ZZ(2))
3
>>> ZZ.log(ZZ(9), ZZ(2))
3

sqrt(a)[源代码][源代码]¶: 计算 a 的平方根。

to_sympy(a)[源代码][源代码]¶: 将 a 转换为 SymPy 对象。

class sympy.polys.domains.PythonIntegerRing[源代码][源代码]¶

基于Python int 类型的整数环。

如果未安装 gmpy 和 gmpy2 ，这将用作 ZZ 。元素是标准 Python int 类型的实例。

方法

`__call__`(*args)	从 `args` 构造 `self` 域的一个元素。
`abs`(a)	`a` 的绝对值，意味着 `__abs__`。
`add`(a, b)	`a` 和 `b` 的和，意味着 `__add__`。
`alg_field_from_poly`(poly[, alias, root_index])	通过根索引选择多项式的根来构造代数扩展的便捷方法。
`algebraic_field`(*extension[, alias])	返回一个代数域，即 \(\mathbb{Q}(\alpha, \ldots)\)。
`almosteq`(a, b[, tolerance])	检查 `a` 和 `b` 是否几乎相等。
`characteristic`()	返回此域的特征。
`cofactors`(a, b)	返回 `a` 和 `b` 的最大公约数和余因子。
`convert`(element[, base])	将 `element` 转换为 `self.dtype`。
`convert_from`(element, base)	在给定的基本域中将 `element` 转换为 `self.dtype`。
`cyclotomic_field`(n[, ss, alias, gen, root_index])	构建分圆域的便捷方法。
`denom`(a)	返回 \(a\) 的分母。
`div`(a, b)	`a` 和 `b` 的除法，意味着 `__divmod__`。
`drop`(*symbols)	从此领域中移除生成器。
`dtype`	`int` 的别名
`evalf`(a[, prec])	返回 `a` 的数值近似值。
`exquo`(a, b)	`a` 和 `b` 的精确商，意味着 `__floordiv__`。
`exsqrt`(a)	如果 `a` 是一个平方数，则 `a` 的非负平方根。
`factorial`(a)	计算 `a` 的阶乘。
`frac_field`(*symbols[, order])	返回一个分数域，即 \(K(X)\)。
`free_module`(rank)	在自身上生成一个秩为 `rank` 的自由模。
`from_AlgebraicField`(a, K0)	将 `ANP` 对象转换为 ZZ。
`from_ComplexField`(a, K0)	将复杂元素转换为 `dtype`。
`from_EX`(a, K0)	将 `Expression` 转换为 GMPY 的 `mpz`。
`from_ExpressionDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_ExpressionRawDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_FF`(a, K0)	将 `ModularInteger(int)` 转换为 GMPY 的 `mpz`。
`from_FF_gmpy`(a, K0)	将 `ModularInteger(mpz)` 转换为 Python 的 `int`。
`from_FF_python`(a, K0)	将 `ModularInteger(int)` 转换为 Python 的 `int`。
`from_FractionField`(a, K0)	将一个有理函数转换为 `dtype`。
`from_GlobalPolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_MonogenicFiniteExtension`(a, K0)	将 `ExtensionElement` 转换为 `dtype`。
`from_PolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_QQ`(a, K0)	将 Python 的 `Fraction` 转换为 Python 的 `int`。
`from_QQ_gmpy`(a, K0)	将 GMPY 的 `mpq` 转换为 Python 的 `int`。
`from_QQ_python`(a, K0)	将 Python 的 `Fraction` 转换为 Python 的 `int`。
`from_RealField`(a, K0)	将 mpmath 的 `mpf` 转换为 Python 的 `int`。
`from_ZZ`(a, K0)	将 Python 的 `int` 转换为 GMPY 的 `mpz`。
`from_ZZ_gmpy`(a, K0)	将 GMPY 的 `mpz` 转换为 Python 的 `int`。
`from_ZZ_python`(a, K0)	将 Python 的 `int` 转换为 Python 的 `int`。
`from_sympy`(a)	将 SymPy 的 Integer 转换为 `dtype`。
`gcd`(a, b)	计算 `a` 和 `b` 的最大公约数。
`gcdex`(a, b)	计算 `a` 和 `b` 的扩展最大公约数。
`get_exact`()	返回与 `self` 关联的精确域。
`get_field`()	返回相关的分数域 QQ
`get_ring`()	返回与 `self` 相关联的环。
`half_gcdex`(a, b)	`a` 和 `b` 的半扩展最大公约数。
`ideal`(*gens)	生成一个理想的 `自我`。
`inject`(*gens)	将生成器注入此域。
`invert`(a, b)	返回 `a mod b` 的逆。
`is_negative`(a)	如果 `a` 为负数，则返回 True。
`is_nonnegative`(a)	如果 `a` 是非负的，则返回 True。
`is_nonpositive`(a)	如果 `a` 是非正数，则返回 True。
`is_one`(a)	如果 `a` 是 1，则返回 True。
`is_positive`(a)	如果 `a` 为正，则返回 True。
`is_square`(a)	如果 `a` 是平方数，则返回 `True`。
`is_zero`(a)	如果 `a` 为零，则返回 True。
`lcm`(a, b)	计算 `a` 和 `b` 的最小公倍数。
`log`(a, b)	以 b 为底 a 的对数。
`map`(seq)	递归地将 `self` 应用于 `seq` 的所有元素。
`mul`(a, b)	`a` 和 `b` 的乘积，意味着 `__mul__`。
`n`(a[, prec])	返回 `a` 的数值近似值。
`neg`(a)	返回 `a` 的否定值，意味着 `__neg__`。
`numer`(a)	返回 `a` 的分子。
`of_type`(element)	检查 `a` 是否为 `dtype` 类型。
`old_frac_field`(symbols, *kwargs)	返回一个分数域，即 \(K(X)\)。
`old_poly_ring`(symbols, *kwargs)	返回一个多项式环，即 \(K[X]\)。
`poly_ring`(*symbols[, order])	返回一个多项式环，即 \(K[X]\)。
`pos`(a)	返回 `a` 为正，意味着 `__pos__`。
`pow`(a, b)	将 `a` 提升到 `b` 的幂，意味着 `__pow__`。
`quo`(a, b)	`a` 和 `b` 的商，意味着 `__floordiv__`。
`quotient_ring`(e)	形成 `self` 的商环。
`rem`(a, b)	`a` 和 `b` 的余数，意味着 `__mod__`。
`revert`(a)	如果可能，返回 `a**(-1)`。
`sqrt`(a)	计算 `a` 的平方根。
`sub`(a, b)	`a` 和 `b` 的差异，意味着 `__sub__`。
`to_sympy`(a)	将 `a` 转换为 SymPy 对象。
`tp`	`int` 的别名
`unify`(K1[, symbols])	构建一个包含 `K0` 和 `K1` 元素的最小域。
`unify_composite`(K1)	统一两个领域，其中至少一个是复合的。

canonical_unit
from_GaussianIntegerRing
from_GeneralizedPolynomialRing
imag
is_unit
新
正常
真实
总和
unify_with_symbols

class sympy.polys.domains.GMPYIntegerRing[源代码][源代码]¶

基于 GMPY 的 mpz 类型的整数环。

如果安装了 gmpy 或 gmpy2 ，这将是对 ZZ 的实现。元素将是 gmpy.mpz 类型。

方法

`__call__`(*args)	从 `args` 构造 `self` 域的一个元素。
`abs`(a)	`a` 的绝对值，意味着 `__abs__`。
`add`(a, b)	`a` 和 `b` 的和，意味着 `__add__`。
`alg_field_from_poly`(poly[, alias, root_index])	通过根索引选择多项式的根来构造代数扩展的便捷方法。
`algebraic_field`(*extension[, alias])	返回一个代数域，即 \(\mathbb{Q}(\alpha, \ldots)\)。
`almosteq`(a, b[, tolerance])	检查 `a` 和 `b` 是否几乎相等。
`characteristic`()	返回此域的特征。
`cofactors`(a, b)	返回 `a` 和 `b` 的最大公约数和余因子。
`convert`(element[, base])	将 `element` 转换为 `self.dtype`。
`convert_from`(element, base)	在给定的基本域中将 `element` 转换为 `self.dtype`。
`cyclotomic_field`(n[, ss, alias, gen, root_index])	构建分圆域的便捷方法。
`denom`(a)	返回 \(a\) 的分母。
`div`(a, b)	`a` 和 `b` 的除法，意味着 `__divmod__`。
`drop`(*symbols)	从此领域中移除生成器。
`evalf`(a[, prec])	返回 `a` 的数值近似值。
`exquo`(a, b)	`a` 和 `b` 的精确商，意味着 `__floordiv__`。
`exsqrt`(a)	如果 `a` 是一个平方数，则 `a` 的非负平方根。
`factorial`(a)	计算 `a` 的阶乘。
`frac_field`(*symbols[, order])	返回一个分数域，即 \(K(X)\)。
`free_module`(rank)	在自身上生成一个秩为 `rank` 的自由模。
`from_AlgebraicField`(a, K0)	将 `ANP` 对象转换为 ZZ。
`from_ComplexField`(a, K0)	将复杂元素转换为 `dtype`。
`from_EX`(a, K0)	将 `Expression` 转换为 GMPY 的 `mpz`。
`from_ExpressionDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_ExpressionRawDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_FF`(a, K0)	将 `ModularInteger(int)` 转换为 GMPY 的 `mpz`。
`from_FF_gmpy`(a, K0)	将 `ModularInteger(mpz)` 转换为 GMPY 的 `mpz`。
`from_FF_python`(a, K0)	将 `ModularInteger(int)` 转换为 GMPY 的 `mpz`。
`from_FractionField`(a, K0)	将一个有理函数转换为 `dtype`。
`from_GlobalPolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_MonogenicFiniteExtension`(a, K0)	将 `ExtensionElement` 转换为 `dtype`。
`from_PolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_QQ`(a, K0)	将 Python 的 `Fraction` 转换为 GMPY 的 `mpz`。
`from_QQ_gmpy`(a, K0)	将 GMPY 的 `mpq` 转换为 GMPY 的 `mpz`。
`from_QQ_python`(a, K0)	将 Python 的 `Fraction` 转换为 GMPY 的 `mpz`。
`from_RealField`(a, K0)	将 mpmath 的 `mpf` 转换为 GMPY 的 `mpz`。
`from_ZZ`(a, K0)	将 Python 的 `int` 转换为 GMPY 的 `mpz`。
`from_ZZ_gmpy`(a, K0)	将 GMPY 的 `mpz` 转换为 GMPY 的 `mpz`。
`from_ZZ_python`(a, K0)	将 Python 的 `int` 转换为 GMPY 的 `mpz`。
`from_sympy`(a)	将 SymPy 的 Integer 转换为 `dtype`。
`gcd`(a, b)	计算 `a` 和 `b` 的最大公约数。
`gcdex`(a, b)	计算 `a` 和 `b` 的扩展最大公约数。
`get_exact`()	返回与 `self` 关联的精确域。
`get_field`()	返回相关的分数域 QQ
`get_ring`()	返回与 `self` 相关联的环。
`half_gcdex`(a, b)	`a` 和 `b` 的半扩展最大公约数。
`ideal`(*gens)	生成一个理想的 `自我`。
`inject`(*gens)	将生成器注入此域。
`invert`(a, b)	返回 `a mod b` 的逆。
`is_negative`(a)	如果 `a` 为负数，则返回 True。
`is_nonnegative`(a)	如果 `a` 是非负的，则返回 True。
`is_nonpositive`(a)	如果 `a` 是非正数，则返回 True。
`is_one`(a)	如果 `a` 是 1，则返回 True。
`is_positive`(a)	如果 `a` 为正，则返回 True。
`is_square`(a)	如果 `a` 是平方数，则返回 `True`。
`is_zero`(a)	如果 `a` 为零，则返回 True。
`lcm`(a, b)	计算 `a` 和 `b` 的最小公倍数。
`log`(a, b)	以 b 为底 a 的对数。
`map`(seq)	递归地将 `self` 应用于 `seq` 的所有元素。
`mul`(a, b)	`a` 和 `b` 的乘积，意味着 `__mul__`。
`n`(a[, prec])	返回 `a` 的数值近似值。
`neg`(a)	返回 `a` 的否定值，意味着 `__neg__`。
`numer`(a)	返回 `a` 的分子。
`of_type`(element)	检查 `a` 是否为 `dtype` 类型。
`old_frac_field`(symbols, *kwargs)	返回一个分数域，即 \(K(X)\)。
`old_poly_ring`(symbols, *kwargs)	返回一个多项式环，即 \(K[X]\)。
`poly_ring`(*symbols[, order])	返回一个多项式环，即 \(K[X]\)。
`pos`(a)	返回 `a` 为正，意味着 `__pos__`。
`pow`(a, b)	将 `a` 提升到 `b` 的幂，意味着 `__pow__`。
`quo`(a, b)	`a` 和 `b` 的商，意味着 `__floordiv__`。
`quotient_ring`(e)	形成 `self` 的商环。
`rem`(a, b)	`a` 和 `b` 的余数，意味着 `__mod__`。
`revert`(a)	如果可能，返回 `a**(-1)`。
`sqrt`(a)	计算 `a` 的平方根。
`sub`(a, b)	`a` 和 `b` 的差异，意味着 `__sub__`。
`to_sympy`(a)	将 `a` 转换为 SymPy 对象。
`unify`(K1[, symbols])	构建一个包含 `K0` 和 `K1` 元素的最小域。
`unify_composite`(K1)	统一两个领域，其中至少一个是复合的。

canonical_unit
from_GaussianIntegerRing
from_GeneralizedPolynomialRing
imag
is_unit
新
正常
真实
总和
unify_with_symbols

factorial(a)[源代码][源代码]¶: 计算 a 的阶乘。

from_FF_gmpy(a, K0)[源代码][源代码]¶: 将 ModularInteger(mpz) 转换为 GMPY 的 mpz。

from_FF_python(a, K0)[源代码][源代码]¶: 将 ModularInteger(int) 转换为 GMPY 的 mpz。

from_QQ(a, K0)[源代码][源代码]¶: 将 Python 的 Fraction 转换为 GMPY 的 mpz。

from_QQ_gmpy(a, K0)[源代码][源代码]¶: 将 GMPY 的 mpq 转换为 GMPY 的 mpz。

from_QQ_python(a, K0)[源代码][源代码]¶: 将 Python 的 Fraction 转换为 GMPY 的 mpz。

from_RealField(a, K0)[源代码][源代码]¶: 将 mpmath 的 mpf 转换为 GMPY 的 mpz。

from_ZZ_gmpy(a, K0)[源代码][源代码]¶: 将 GMPY 的 mpz 转换为 GMPY 的 mpz。

from_ZZ_python(a, K0)[源代码][源代码]¶: 将 Python 的 int 转换为 GMPY 的 mpz。

from_sympy(a)[源代码][源代码]¶: 将 SymPy 的 Integer 转换为 dtype。

gcd(a, b)[源代码][源代码]¶: 计算 a 和 b 的最大公约数。

gcdex(a, b)[源代码][源代码]¶: 计算 a 和 b 的扩展最大公约数。

lcm(a, b)[源代码][源代码]¶: 计算 a 和 b 的最小公倍数。

sqrt(a)[源代码][源代码]¶: 计算 a 的平方根。

to_sympy(a)[源代码][源代码]¶: 将 a 转换为 SymPy 对象。

QQ¶

The QQ 域表示 rationals \(\mathbb{Q}\) 作为域系统中的 Domain (参见介绍 poly 模块的领域)。

默认情况下，从具有有理系数表达式创建的 Poly 将具有域 QQ:

>>> from sympy import Poly, Symbol
>>> x = Symbol('x')
>>> p = Poly(x**2 + x/2)
>>> p
Poly(x**2 + 1/2*x, x, domain='QQ')
>>> p.domain
QQ

对应的整数环是整数 ZZ 的 Domain。相反，QQ 是 ZZ 的分数字段:

>>> from sympy import ZZ, QQ
>>> QQ.get_ring()
ZZ
>>> ZZ.get_field()
QQ

当直接使用域时，QQ 可以用作构造函数来创建实例，这些实例随后支持操作 +,-,*,**,/``（对于 :ref:`QQ` 中的非零除数，真除法 ``/ 总是可能的）:

>>> x = QQ(5)
>>> y = QQ(2)
>>> x / y  # true division
5/2

在 SymPy 中有两种 QQ 的实现。如果安装了 gmpy 或 gmpy2，那么 QQ 将由 GMPYRationalField 实现，元素将是 gmpy.mpq 类型的实例。否则，如果未安装 gmpy 和 gmpy2，则 QQ 将由 PythonRationalField 实现，这是 sympy 的一部分的纯 Python 类。首选 gmpy 实现，因为它明显更快。

class sympy.polys.domains.RationalField[源代码][源代码]¶

域 QQ 的抽象基类。

RationalField 类表示有理数域 \(\mathbb{Q}\) 作为域系统中的 Domain。RationalField 是 PythonRationalField 和 GMPYRationalField 的超类之一，具体实现为 QQ，取决于是否安装了 gmpy 或 gmpy2。

方法

`__call__`(*args)	从 `args` 构造 `self` 域的一个元素。
`abs`(a)	`a` 的绝对值，意味着 `__abs__`。
`add`(a, b)	`a` 和 `b` 的和，意味着 `__add__`。
`alg_field_from_poly`(poly[, alias, root_index])	通过根索引选择多项式的根来构造代数扩展的便捷方法。
`algebraic_field`(*extension[, alias])	返回一个代数域，即 \(\mathbb{Q}(\alpha, \ldots)\)。
`almosteq`(a, b[, tolerance])	检查 `a` 和 `b` 是否几乎相等。
`characteristic`()	返回此域的特征。
`cofactors`(a, b)	返回 `a` 和 `b` 的最大公约数和余因子。
`convert`(element[, base])	将 `element` 转换为 `self.dtype`。
`convert_from`(element, base)	在给定的基本域中将 `element` 转换为 `self.dtype`。
`cyclotomic_field`(n[, ss, alias, gen, root_index])	构建分圆域的便捷方法。
`denom`(a)	返回 `a` 的分母。
`div`(a, b)	`a` 和 `b` 的除法，意味着 `__truediv__`。
`drop`(*symbols)	从此领域中移除生成器。
`evalf`(a[, prec])	返回 `a` 的数值近似值。
`exquo`(a, b)	`a` 和 `b` 的精确商，意味着 `__truediv__`。
`exsqrt`(a)	如果 `a` 是一个平方数，则 `a` 的非负平方根。
`frac_field`(*symbols[, order])	返回一个分数域，即 \(K(X)\)。
`free_module`(rank)	在自身上生成一个秩为 `rank` 的自由模。
`from_AlgebraicField`(a, K0)	将 `ANP` 对象转换为 QQ。
`from_ComplexField`(a, K0)	将复杂元素转换为 `dtype`。
`from_ExpressionDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_ExpressionRawDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_FF`(a, K0)	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FF_gmpy`(a, K0)	将 `ModularInteger(mpz)` 转换为 `dtype`。
`from_FF_python`(a, K0)	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FractionField`(a, K0)	将一个有理函数转换为 `dtype`。
`from_GaussianRationalField`(a, K0)	将 `GaussianElement` 对象转换为 `dtype`。
`from_GlobalPolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_MonogenicFiniteExtension`(a, K0)	将 `ExtensionElement` 转换为 `dtype`。
`from_PolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_QQ`(a, K0)	将 Python `Fraction` 对象转换为 `dtype`。
`from_QQ_gmpy`(a, K0)	将 GMPY 的 `mpq` 对象转换为 `dtype`。
`from_QQ_python`(a, K0)	将 Python `Fraction` 对象转换为 `dtype`。
`from_RealField`(a, K0)	将 mpmath 的 `mpf` 对象转换为 `dtype`。
`from_ZZ`(a, K0)	将 Python `int` 对象转换为 `dtype`。
`from_ZZ_gmpy`(a, K0)	将 GMPY 的 `mpz` 对象转换为 `dtype`。
`from_ZZ_python`(a, K0)	将 Python `int` 对象转换为 `dtype`。
`from_sympy`(a)	将 SymPy 的 Integer 转换为 `dtype`。
`gcd`(a, b)	返回 `a` 和 `b` 的最大公约数。
`gcdex`(a, b)	返回 x, y, g 使得 a * x + b * y == g == gcd(a, b)
`get_exact`()	返回与 `self` 关联的精确域。
`get_field`()	返回与 `self` 关联的字段。
`get_ring`()	返回与 `self` 关联的环。
`half_gcdex`(a, b)	`a` 和 `b` 的半扩展最大公约数。
`ideal`(*gens)	生成一个理想的 `自我`。
`inject`(*gens)	将生成器注入此域。
`invert`(a, b)	返回 `a mod b` 的逆。
`is_negative`(a)	如果 `a` 为负数，则返回 True。
`is_nonnegative`(a)	如果 `a` 是非负的，则返回 True。
`is_nonpositive`(a)	如果 `a` 是非正数，则返回 True。
`is_one`(a)	如果 `a` 是 1，则返回 True。
`is_positive`(a)	如果 `a` 为正，则返回 True。
`is_square`(a)	如果 `a` 是平方数，则返回 `True`。
`is_unit`(a)	如果 `a` 是可逆的，则返回 true
`is_zero`(a)	如果 `a` 为零，则返回 True。
`lcm`(a, b)	返回 `a` 和 `b` 的最小公倍数。
`log`(a, b)	返回 `a` 的 b 进制对数。
`map`(seq)	递归地将 `self` 应用于 `seq` 的所有元素。
`mul`(a, b)	`a` 和 `b` 的乘积，意味着 `__mul__`。
`n`(a[, prec])	返回 `a` 的数值近似值。
`neg`(a)	返回 `a` 的否定值，意味着 `__neg__`。
`numer`(a)	返回 `a` 的分子。
`of_type`(element)	检查 `a` 是否为 `dtype` 类型。
`old_frac_field`(symbols, *kwargs)	返回一个分数域，即 \(K(X)\)。
`old_poly_ring`(symbols, *kwargs)	返回一个多项式环，即 \(K[X]\)。
`poly_ring`(*symbols[, order])	返回一个多项式环，即 \(K[X]\)。
`pos`(a)	返回 `a` 为正，意味着 `__pos__`。
`pow`(a, b)	将 `a` 提升到 `b` 的幂，意味着 `__pow__`。
`quo`(a, b)	`a` 和 `b` 的商，意味着 `__truediv__`。
`quotient_ring`(e)	形成 `self` 的商环。
`rem`(a, b)	`a` 和 `b` 的余数，没有隐含意义。
`revert`(a)	如果可能，返回 `a**(-1)`。
`sqrt`(a)	返回 `a` 的（可能不精确的）平方根。
`sub`(a, b)	`a` 和 `b` 的差异，意味着 `__sub__`。
`to_sympy`(a)	将 `a` 转换为 SymPy 对象。
`unify`(K1[, symbols])	构建一个包含 `K0` 和 `K1` 元素的最小域。
`unify_composite`(K1)	统一两个领域，其中至少一个是复合的。

canonical_unit
from_GeneralizedPolynomialRing
imag
新
正常
真实
总和
unify_with_symbols

参见

Domain

algebraic_field( *extension, alias=None, )[源代码][源代码]¶

返回一个代数域，即 \(\mathbb{Q}(\alpha, \ldots)\)。

参数:

*扩展 : 一个或多个 Expr一个或多个: 扩展的生成元。这些应该是代数上在 \(\mathbb{Q}\) 上的表达式。
别名 : str, Symbol, None, 可选 (默认=None)str, Symbol, None, optional (default=None): 如果提供，这将用作返回的 AlgebraicField 的基本元素的别名符号。

返回:

AlgebraicField: 一个表示代数域扩展的 Domain。

示例

>>> from sympy import QQ, sqrt
>>> QQ.algebraic_field(sqrt(2))
QQ<sqrt(2)>

denom(a)[源代码][源代码]¶: 返回 a 的分母。

div(a, b)[源代码][源代码]¶: a 和 b 的除法，意味着 __truediv__。

exquo(a, b)[源代码][源代码]¶: a 和 b 的精确商，意味着 __truediv__。

exsqrt(a)[源代码][源代码]¶

如果 a 是一个平方数，则 a 的非负平方根。

参见

is_square

from_AlgebraicField(a, K0)[源代码][源代码]¶

将 ANP 对象转换为 QQ。

参见 convert()

from_GaussianRationalField(a, K0)[源代码][源代码]¶: 将 GaussianElement 对象转换为 dtype。

from_QQ(a, K0)[源代码][源代码]¶: 将 Python Fraction 对象转换为 dtype。

from_QQ_gmpy(a, K0)[源代码][源代码]¶: 将 GMPY 的 mpq 对象转换为 dtype。

from_QQ_python(a, K0)[源代码][源代码]¶: 将 Python Fraction 对象转换为 dtype。

from_RealField(a, K0)[源代码][源代码]¶: 将 mpmath 的 mpf 对象转换为 dtype。

from_ZZ(a, K0)[源代码][源代码]¶: 将 Python int 对象转换为 dtype。

from_ZZ_gmpy(a, K0)[源代码][源代码]¶: 将 GMPY 的 mpz 对象转换为 dtype。

from_ZZ_python(a, K0)[源代码][源代码]¶: 将 Python int 对象转换为 dtype。

from_sympy(a)[源代码][源代码]¶: 将 SymPy 的 Integer 转换为 dtype。

get_ring()[源代码][源代码]¶: 返回与 self 关联的环。

is_square(a)[源代码][源代码]¶: 如果 a 是平方数，则返回 True。

numer(a)[源代码][源代码]¶: 返回 a 的分子。

quo(a, b)[源代码][源代码]¶: a 和 b 的商，意味着 __truediv__。

rem(a, b)[源代码][源代码]¶: a 和 b 的余数，没有隐含意义。

to_sympy(a)[源代码][源代码]¶: 将 a 转换为 SymPy 对象。

class sympy.polys.domains.PythonRationalField[源代码][源代码]¶

基于 MPQ 的有理数域。

如果未安装 gmpy 和 gmpy2，这将用作 QQ。元素是 MPQ 的实例。

方法

`__call__`(*args)	从 `args` 构造 `self` 域的一个元素。
`abs`(a)	`a` 的绝对值，意味着 `__abs__`。
`add`(a, b)	`a` 和 `b` 的和，意味着 `__add__`。
`alg_field_from_poly`(poly[, alias, root_index])	通过根索引选择多项式的根来构造代数扩展的便捷方法。
`algebraic_field`(*extension[, alias])	返回一个代数域，即 \(\mathbb{Q}(\alpha, \ldots)\)。
`almosteq`(a, b[, tolerance])	检查 `a` 和 `b` 是否几乎相等。
`characteristic`()	返回此域的特征。
`cofactors`(a, b)	返回 `a` 和 `b` 的最大公约数和余因子。
`convert`(element[, base])	将 `element` 转换为 `self.dtype`。
`convert_from`(element, base)	在给定的基本域中将 `element` 转换为 `self.dtype`。
`cyclotomic_field`(n[, ss, alias, gen, root_index])	构建分圆域的便捷方法。
`denom`(a)	返回 \(a\) 的分母。
`div`(a, b)	`a` 和 `b` 的除法，意味着 `__truediv__`。
`drop`(*symbols)	从此领域中移除生成器。
`dtype`	`PythonMPQ` 的别名
`evalf`(a[, prec])	返回 `a` 的数值近似值。
`exquo`(a, b)	`a` 和 `b` 的精确商，意味着 `__truediv__`。
`exsqrt`(a)	如果 `a` 是一个平方数，则 `a` 的非负平方根。
`frac_field`(*symbols[, order])	返回一个分数域，即 \(K(X)\)。
`free_module`(rank)	在自身上生成一个秩为 `rank` 的自由模。
`from_AlgebraicField`(a, K0)	将 `ANP` 对象转换为 QQ。
`from_ComplexField`(a, K0)	将复杂元素转换为 `dtype`。
`from_ExpressionDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_ExpressionRawDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_FF`(a, K0)	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FF_gmpy`(a, K0)	将 `ModularInteger(mpz)` 转换为 `dtype`。
`from_FF_python`(a, K0)	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FractionField`(a, K0)	将一个有理函数转换为 `dtype`。
`from_GaussianRationalField`(a, K0)	将 `GaussianElement` 对象转换为 `dtype`。
`from_GlobalPolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_MonogenicFiniteExtension`(a, K0)	将 `ExtensionElement` 转换为 `dtype`。
`from_PolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_QQ`(a, K0)	将 Python `Fraction` 对象转换为 `dtype`。
`from_QQ_gmpy`(a, K0)	将 GMPY 的 \(mpq\) 对象转换为 \(dtype\)。
`from_QQ_python`(a, K0)	将 Python \(Fraction\) 对象转换为 \(dtype\)。
`from_RealField`(a, K0)	将 mpmath 的 \(mpf\) 对象转换为 \(dtype\)。
`from_ZZ`(a, K0)	将 Python `int` 对象转换为 `dtype`。
`from_ZZ_gmpy`(a, K0)	将 GMPY 的 \(mpz\) 对象转换为 \(dtype\)。
`from_ZZ_python`(a, K0)	将 Python \(int\) 对象转换为 \(dtype\)。
`from_sympy`(a)	将 SymPy 的 Rational 转换为 \(dtype\)。
`gcd`(a, b)	返回 `a` 和 `b` 的最大公约数。
`gcdex`(a, b)	返回 x, y, g 使得 a * x + b * y == g == gcd(a, b)
`get_exact`()	返回与 `self` 关联的精确域。
`get_field`()	返回与 `self` 关联的字段。
`get_ring`()	返回与 `self` 关联的环。
`half_gcdex`(a, b)	`a` 和 `b` 的半扩展最大公约数。
`ideal`(*gens)	生成一个理想的 `自我`。
`inject`(*gens)	将生成器注入此域。
`invert`(a, b)	返回 `a mod b` 的逆。
`is_negative`(a)	如果 `a` 为负数，则返回 True。
`is_nonnegative`(a)	如果 `a` 是非负的，则返回 True。
`is_nonpositive`(a)	如果 `a` 是非正数，则返回 True。
`is_one`(a)	如果 `a` 是 1，则返回 True。
`is_positive`(a)	如果 `a` 为正，则返回 True。
`is_square`(a)	如果 `a` 是平方数，则返回 `True`。
`is_unit`(a)	如果 `a` 是可逆的，则返回 true
`is_zero`(a)	如果 `a` 为零，则返回 True。
`lcm`(a, b)	返回 `a` 和 `b` 的最小公倍数。
`log`(a, b)	返回 `a` 的 b 进制对数。
`map`(seq)	递归地将 `self` 应用于 `seq` 的所有元素。
`mul`(a, b)	`a` 和 `b` 的乘积，意味着 `__mul__`。
`n`(a[, prec])	返回 `a` 的数值近似值。
`neg`(a)	返回 `a` 的否定值，意味着 `__neg__`。
`numer`(a)	返回 \(a\) 的分子。
`of_type`(element)	检查 `a` 是否为 `dtype` 类型。
`old_frac_field`(symbols, *kwargs)	返回一个分数域，即 \(K(X)\)。
`old_poly_ring`(symbols, *kwargs)	返回一个多项式环，即 \(K[X]\)。
`poly_ring`(*symbols[, order])	返回一个多项式环，即 \(K[X]\)。
`pos`(a)	返回 `a` 为正，意味着 `__pos__`。
`pow`(a, b)	将 `a` 提升到 `b` 的幂，意味着 `__pow__`。
`quo`(a, b)	`a` 和 `b` 的商，意味着 `__truediv__`。
`quotient_ring`(e)	形成 `self` 的商环。
`rem`(a, b)	`a` 和 `b` 的余数，没有隐含意义。
`revert`(a)	如果可能，返回 `a**(-1)`。
`sqrt`(a)	返回 `a` 的（可能不精确的）平方根。
`sub`(a, b)	`a` 和 `b` 的差异，意味着 `__sub__`。
`to_sympy`(a)	将 \(a\) 转换为 SymPy 对象。
`tp`	`PythonMPQ` 的别名
`unify`(K1[, symbols])	构建一个包含 `K0` 和 `K1` 元素的最小域。
`unify_composite`(K1)	统一两个领域，其中至少一个是复合的。

canonical_unit
from_GeneralizedPolynomialRing
imag
新
正常
真实
总和
unify_with_symbols

class sympy.polys.domains.GMPYRationalField[源代码][源代码]¶

基于 GMPY 的 mpq 类型的有理数域。

如果安装了 gmpy 或 gmpy2，这将是 QQ 的实现。元素将是 gmpy.mpq 类型。

方法

`__call__`(*args)	从 `args` 构造 `self` 域的一个元素。
`abs`(a)	`a` 的绝对值，意味着 `__abs__`。
`add`(a, b)	`a` 和 `b` 的和，意味着 `__add__`。
`alg_field_from_poly`(poly[, alias, root_index])	通过根索引选择多项式的根来构造代数扩展的便捷方法。
`algebraic_field`(*extension[, alias])	返回一个代数域，即 \(\mathbb{Q}(\alpha, \ldots)\)。
`almosteq`(a, b[, tolerance])	检查 `a` 和 `b` 是否几乎相等。
`characteristic`()	返回此域的特征。
`cofactors`(a, b)	返回 `a` 和 `b` 的最大公约数和余因子。
`convert`(element[, base])	将 `element` 转换为 `self.dtype`。
`convert_from`(element, base)	在给定的基本域中将 `element` 转换为 `self.dtype`。
`cyclotomic_field`(n[, ss, alias, gen, root_index])	构建分圆域的便捷方法。
`denom`(a)	返回 `a` 的分母。
`div`(a, b)	`a` 和 `b` 的除法，意味着 `__truediv__`。
`drop`(*symbols)	从此领域中移除生成器。
`evalf`(a[, prec])	返回 `a` 的数值近似值。
`exquo`(a, b)	`a` 和 `b` 的精确商，意味着 `__truediv__`。
`exsqrt`(a)	如果 `a` 是一个平方数，则 `a` 的非负平方根。
`factorial`(a)	返回 `a` 的阶乘。
`frac_field`(*symbols[, order])	返回一个分数域，即 \(K(X)\)。
`free_module`(rank)	在自身上生成一个秩为 `rank` 的自由模。
`from_AlgebraicField`(a, K0)	将 `ANP` 对象转换为 QQ。
`from_ComplexField`(a, K0)	将复杂元素转换为 `dtype`。
`from_ExpressionDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_ExpressionRawDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_FF`(a, K0)	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FF_gmpy`(a, K0)	将 `ModularInteger(mpz)` 转换为 `dtype`。
`from_FF_python`(a, K0)	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FractionField`(a, K0)	将一个有理函数转换为 `dtype`。
`from_GaussianRationalField`(a, K0)	将 `GaussianElement` 对象转换为 `dtype`。
`from_GlobalPolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_MonogenicFiniteExtension`(a, K0)	将 `ExtensionElement` 转换为 `dtype`。
`from_PolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_QQ`(a, K0)	将 Python `Fraction` 对象转换为 `dtype`。
`from_QQ_gmpy`(a, K0)	将 GMPY 的 `mpq` 对象转换为 `dtype`。
`from_QQ_python`(a, K0)	将 Python `Fraction` 对象转换为 `dtype`。
`from_RealField`(a, K0)	将 mpmath 的 `mpf` 对象转换为 `dtype`。
`from_ZZ`(a, K0)	将 Python `int` 对象转换为 `dtype`。
`from_ZZ_gmpy`(a, K0)	将 GMPY 的 `mpz` 对象转换为 `dtype`。
`from_ZZ_python`(a, K0)	将 Python `int` 对象转换为 `dtype`。
`from_sympy`(a)	将 SymPy 的 Integer 转换为 `dtype`。
`gcd`(a, b)	返回 `a` 和 `b` 的最大公约数。
`gcdex`(a, b)	返回 x, y, g 使得 a * x + b * y == g == gcd(a, b)
`get_exact`()	返回与 `self` 关联的精确域。
`get_field`()	返回与 `self` 关联的字段。
`get_ring`()	返回与 `self` 关联的环。
`half_gcdex`(a, b)	`a` 和 `b` 的半扩展最大公约数。
`ideal`(*gens)	生成一个理想的 `自我`。
`inject`(*gens)	将生成器注入此域。
`invert`(a, b)	返回 `a mod b` 的逆。
`is_negative`(a)	如果 `a` 为负数，则返回 True。
`is_nonnegative`(a)	如果 `a` 是非负的，则返回 True。
`is_nonpositive`(a)	如果 `a` 是非正数，则返回 True。
`is_one`(a)	如果 `a` 是 1，则返回 True。
`is_positive`(a)	如果 `a` 为正，则返回 True。
`is_square`(a)	如果 `a` 是平方数，则返回 `True`。
`is_unit`(a)	如果 `a` 是可逆的，则返回 true
`is_zero`(a)	如果 `a` 为零，则返回 True。
`lcm`(a, b)	返回 `a` 和 `b` 的最小公倍数。
`log`(a, b)	返回 `a` 的 b 进制对数。
`map`(seq)	递归地将 `self` 应用于 `seq` 的所有元素。
`mul`(a, b)	`a` 和 `b` 的乘积，意味着 `__mul__`。
`n`(a[, prec])	返回 `a` 的数值近似值。
`neg`(a)	返回 `a` 的否定值，意味着 `__neg__`。
`numer`(a)	返回 `a` 的分子。
`of_type`(element)	检查 `a` 是否为 `dtype` 类型。
`old_frac_field`(symbols, *kwargs)	返回一个分数域，即 \(K(X)\)。
`old_poly_ring`(symbols, *kwargs)	返回一个多项式环，即 \(K[X]\)。
`poly_ring`(*symbols[, order])	返回一个多项式环，即 \(K[X]\)。
`pos`(a)	返回 `a` 为正，意味着 `__pos__`。
`pow`(a, b)	将 `a` 提升到 `b` 的幂，意味着 `__pow__`。
`quo`(a, b)	`a` 和 `b` 的商，意味着 `__truediv__`。
`quotient_ring`(e)	形成 `self` 的商环。
`rem`(a, b)	`a` 和 `b` 的余数，没有隐含意义。
`revert`(a)	如果可能，返回 `a**(-1)`。
`sqrt`(a)	返回 `a` 的（可能不精确的）平方根。
`sub`(a, b)	`a` 和 `b` 的差异，意味着 `__sub__`。
`to_sympy`(a)	将 `a` 转换为 SymPy 对象。
`unify`(K1[, symbols])	构建一个包含 `K0` 和 `K1` 元素的最小域。
`unify_composite`(K1)	统一两个领域，其中至少一个是复合的。

canonical_unit
from_GeneralizedPolynomialRing
imag
新
正常
真实
总和
unify_with_symbols

denom(a)[源代码][源代码]¶: 返回 a 的分母。

div(a, b)[源代码][源代码]¶: a 和 b 的除法，意味着 __truediv__。

exquo(a, b)[源代码][源代码]¶: a 和 b 的精确商，意味着 __truediv__。

factorial(a)[源代码][源代码]¶: 返回 a 的阶乘。

from_GaussianRationalField( a, K0, )[源代码][源代码]¶: 将 GaussianElement 对象转换为 dtype。

from_QQ_gmpy(a, K0)[源代码][源代码]¶: 将 GMPY 的 mpq 对象转换为 dtype。

from_QQ_python(a, K0)[源代码][源代码]¶: 将 Python Fraction 对象转换为 dtype。

from_RealField(a, K0)[源代码][源代码]¶: 将 mpmath 的 mpf 对象转换为 dtype。

from_ZZ_gmpy(a, K0)[源代码][源代码]¶: 将 GMPY 的 mpz 对象转换为 dtype。

from_ZZ_python(a, K0)[源代码][源代码]¶: 将 Python int 对象转换为 dtype。

from_sympy(a)[源代码][源代码]¶: 将 SymPy 的 Integer 转换为 dtype。

get_ring()[源代码][源代码]¶: 返回与 self 关联的环。

numer(a)[源代码][源代码]¶: 返回 a 的分子。

quo(a, b)[源代码][源代码]¶: a 和 b 的商，意味着 __truediv__。

rem(a, b)[源代码][源代码]¶: a 和 b 的余数，没有隐含意义。

to_sympy(a)[源代码][源代码]¶: 将 a 转换为 SymPy 对象。

class sympy.external.pythonmpq.PythonMPQ(numerator, denominator=None)[源代码][源代码]¶

旨在与 gmpy2 的 mpq 兼容的有理数实现。

也比 fractions.Fraction 稍快。

PythonMPQ 应被视为不可变对象，尽管没有采取措施防止其变异（因为这可能会减慢计算速度）。

属性:

分母
分子

MPQ¶

MPQ 类型要么是 PythonMPQ ，否则就是 gmpy2 中的 mpq 类型。

高斯域¶

高斯域 ZZ_I 和 QQ_I 共享共同的父类 GaussianElement 用于域元素，以及 GaussianDomain 用于域本身。

class sympy.polys.domains.gaussiandomains.GaussianDomain[源代码][源代码]¶

高斯域的基类。

属性:

dom

方法

`from_AlgebraicField`(a, K0)	将一个元素从 ZZ<I> 或 QQ<I> 转换为 `self.dtype`。
`from_QQ`(a, K0)	将 GMPY mpq 转换为 `self.dtype`。
`from_QQ_gmpy`(a, K0)	将 GMPY mpq 转换为 `self.dtype`。
`from_QQ_python`(a, K0)	将一个 QQ_python 元素转换为 `self.dtype`。
`from_ZZ`(a, K0)	将一个 ZZ_python 元素转换为 `self.dtype`。
`from_ZZ_gmpy`(a, K0)	将 GMPY 的 mpz 转换为 `self.dtype`。
`from_ZZ_python`(a, K0)	将一个 ZZ_python 元素转换为 `self.dtype`。
`from_sympy`(a)	将一个 SymPy 对象转换为 `self.dtype`。
`inject`(*gens)	将生成器注入此域。
`is_negative`(element)	对于任何 `GaussianElement` 返回 `False`。
`is_nonnegative`(element)	对于任何 `GaussianElement` 返回 `False`。
`is_nonpositive`(element)	对于任何 `GaussianElement` 返回 `False`。
`is_positive`(element)	对于任何 `GaussianElement` 返回 `False`。
`to_sympy`(a)	将 `a` 转换为 SymPy 对象。

canonical_unit

from_AlgebraicField(a, K0)[源代码][源代码]¶: 将一个元素从 ZZ<I> 或 QQ<I> 转换为 self.dtype。

from_QQ(a, K0)[源代码][源代码]¶: 将 GMPY mpq 转换为 self.dtype。

from_QQ_gmpy(a, K0)[源代码][源代码]¶: 将 GMPY mpq 转换为 self.dtype。

from_QQ_python(a, K0)[源代码][源代码]¶: 将一个 QQ_python 元素转换为 self.dtype。

from_ZZ(a, K0)[源代码][源代码]¶: 将一个 ZZ_python 元素转换为 self.dtype。

from_ZZ_gmpy(a, K0)[源代码][源代码]¶: 将 GMPY 的 mpz 转换为 self.dtype。

from_ZZ_python(a, K0)[源代码][源代码]¶: 将一个 ZZ_python 元素转换为 self.dtype。

from_sympy(a)[源代码][源代码]¶: 将一个 SymPy 对象转换为 self.dtype。

inject(*gens)[源代码][源代码]¶: 将生成器注入此域。

is_negative(element)[源代码][源代码]¶: 对于任何 GaussianElement 返回 False。

is_nonnegative(element)[源代码][源代码]¶: 对于任何 GaussianElement 返回 False。

is_nonpositive(element)[源代码][源代码]¶: 对于任何 GaussianElement 返回 False。

is_positive(element)[源代码][源代码]¶: 对于任何 GaussianElement 返回 False。

to_sympy(a)[源代码][源代码]¶: 将 a 转换为 SymPy 对象。

class sympy.polys.domains.gaussiandomains.GaussianElement(x, y=0)[源代码][源代码]¶

高斯型域元素的基类。

属性:

x
y

方法

`new`(x, y)	创建一个相同域的新 GaussianElement。
`parent`()	这个元素所属的域（ZZ_I 或 QQ_I）
`quadrant`()	返回象限索引 0-3。

classmethod new(x, y)[源代码][源代码]¶: 创建一个相同域的新 GaussianElement。

parent()[源代码][源代码]¶: 这个元素所属的域（ZZ_I 或 QQ_I）

quadrant()[源代码][源代码]¶

返回象限索引 0-3。

0 包含在象限 0 中。

ZZ_I¶

class sympy.polys.domains.gaussiandomains.GaussianIntegerRing[源代码][源代码]¶

高斯整数环 ZZ_I

ZZ_I 域表示高斯整数 \(\mathbb{Z}[i]\) 作为域系统中的 Domain`（参见 :ref:`polys-domainsintro）。

默认情况下，从系数为整数和 I (\(\sqrt{-1}\)) 组合的表达式创建的 Poly 将具有域 ZZ_I。

>>> from sympy import Poly, Symbol, I
>>> x = Symbol('x')
>>> p = Poly(x**2 + I)
>>> p
Poly(x**2 + I, x, domain='ZZ_I')
>>> p.domain
ZZ_I

可以使用 ZZ_I 域来分解在高斯整数上可约的多项式。

>>> from sympy import factor
>>> factor(x**2 + 1)
x**2 + 1
>>> factor(x**2 + 1, domain='ZZ_I')
(x - I)*(x + I)

对应的分数域是高斯有理数的域 QQ_I。相反，ZZ_I 是 QQ_I 的整数环。

>>> from sympy import ZZ_I, QQ_I
>>> ZZ_I.get_field()
QQ_I
>>> QQ_I.get_ring()
ZZ_I

当直接使用域时，可以使用 ZZ_I 作为构造函数。

>>> ZZ_I(3, 4)
(3 + 4*I)
>>> ZZ_I(5)
(5 + 0*I)

域元素 ZZ_I 是 GaussianInteger 的实例，支持环操作 +,-,*,**。

>>> z1 = ZZ_I(5, 1)
>>> z2 = ZZ_I(2, 3)
>>> z1
(5 + 1*I)
>>> z2
(2 + 3*I)
>>> z1 + z2
(7 + 4*I)
>>> z1 * z2
(7 + 17*I)
>>> z1 ** 2
(24 + 10*I)

地板除 (//) 和取模 (%) 运算都适用于 GaussianInteger （参见 div() 方法）。

>>> z3, z4 = ZZ_I(5), ZZ_I(1, 3)
>>> z3 // z4  # floor division
(1 + -1*I)
>>> z3 % z4   # modulo division (remainder)
(1 + -2*I)
>>> (z3//z4)*z4 + z3%z4 == z3
True

在 ZZ_I 中的真除法 (/) 得到 QQ_I 的一个元素。当可以进行精确除法时，可以使用 exquo() 方法在 ZZ_I 中进行除法。

>>> z1 / z2
(1 + -1*I)
>>> ZZ_I.exquo(z1, z2)
(1 + -1*I)
>>> z3 / z4
(1/2 + -3/2*I)
>>> ZZ_I.exquo(z3, z4)
Traceback (most recent call last):
    ...
ExactQuotientFailed: (1 + 3*I) does not divide (5 + 0*I) in ZZ_I

可以使用 gcd() 方法来计算任意两个元素的 gcd。

>>> ZZ_I.gcd(ZZ_I(10), ZZ_I(2))
(2 + 0*I)
>>> ZZ_I.gcd(ZZ_I(5), ZZ_I(2, 1))
(2 + 1*I)

属性:

别名
has_CharacteristicZero
tp: 别名 dtype

方法

`__call__`(*args)	从 `args` 构造 `self` 域的一个元素。
`abs`(a)	`a` 的绝对值，意味着 `__abs__`。
`add`(a, b)	`a` 和 `b` 的和，意味着 `__add__`。
`alg_field_from_poly`(poly[, alias, root_index])	通过根索引选择多项式的根来构造代数扩展的便捷方法。
`algebraic_field`(*extension[, alias])	返回一个代数数域，即 \(K(\alpha, \ldots)\)。
`almosteq`(a, b[, tolerance])	检查 `a` 和 `b` 是否几乎相等。
`characteristic`()
`cofactors`(a, b)	返回 `a` 和 `b` 的最大公约数和余因子。
`convert`(element[, base])	将 `element` 转换为 `self.dtype`。
`convert_from`(element, base)	在给定的基本域中将 `element` 转换为 `self.dtype`。
`cyclotomic_field`(n[, ss, alias, gen, root_index])	构建分圆域的便捷方法。
`denom`(a)	返回 \(a\) 的分母。
`div`(a, b)	`a` 和 `b` 的除法，意味着 `__divmod__`。
`drop`(*symbols)	从此领域中移除生成器。
`dtype`	`GaussianInteger` 的别名
`evalf`(a[, prec])	返回 `a` 的数值近似值。
`exquo`(a, b)	`a` 和 `b` 的精确商，意味着 `__floordiv__`。
`exsqrt`(a)	在 `a` 是平方数的域内的主平方根。
`frac_field`(*symbols[, order])	返回一个分数域，即 \(K(X)\)。
`free_module`(rank)	在自身上生成一个秩为 `rank` 的自由模。
`from_AlgebraicField`(a, K0)	将一个元素从 ZZ<I> 或 QQ<I> 转换为 `self.dtype`。
`from_ComplexField`(a, K0)	将复杂元素转换为 `dtype`。
`from_ExpressionDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_ExpressionRawDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_FF`(a, K0)	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FF_gmpy`(a, K0)	将 `ModularInteger(mpz)` 转换为 `dtype`。
`from_FF_python`(a, K0)	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FractionField`(a, K0)	将一个有理函数转换为 `dtype`。
`from_GaussianIntegerRing`(a, K0)	将 ZZ_I 元素转换为 ZZ_I。
`from_GaussianRationalField`(a, K0)	将 QQ_I 元素转换为 ZZ_I。
`from_GlobalPolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_MonogenicFiniteExtension`(a, K0)	将 `ExtensionElement` 转换为 `dtype`。
`from_PolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_QQ`(a, K0)	将 GMPY mpq 转换为 `self.dtype`。
`from_QQ_gmpy`(a, K0)	将 GMPY mpq 转换为 `self.dtype`。
`from_QQ_python`(a, K0)	将一个 QQ_python 元素转换为 `self.dtype`。
`from_RealField`(a, K0)	将一个真实的元素对象转换为 `dtype`。
`from_ZZ`(a, K0)	将一个 ZZ_python 元素转换为 `self.dtype`。
`from_ZZ_gmpy`(a, K0)	将 GMPY 的 mpz 转换为 `self.dtype`。
`from_ZZ_python`(a, K0)	将一个 ZZ_python 元素转换为 `self.dtype`。
`from_sympy`(a)	将一个 SymPy 对象转换为 `self.dtype`。
`gcd`(a, b)	在 ZZ_I 上 a 和 b 的最大公约数。
`gcdex`(a, b)	返回 x, y, g 使得 x * a + y * b = g = gcd(a, b)
`get_exact`()	返回与 `self` 关联的精确域。
`get_field`()	返回与 `self` 关联的字段。
`get_ring`()	返回与 `self` 相关联的环。
`half_gcdex`(a, b)	`a` 和 `b` 的半扩展最大公约数。
`ideal`(*gens)	生成一个理想的 `自我`。
`inject`(*gens)	将生成器注入此域。
`invert`(a, b)	返回 `a mod b` 的逆。
`is_negative`(element)	对于任何 `GaussianElement` 返回 `False`。
`is_nonnegative`(element)	对于任何 `GaussianElement` 返回 `False`。
`is_nonpositive`(element)	对于任何 `GaussianElement` 返回 `False`。
`is_one`(a)	如果 `a` 是 1，则返回 True。
`is_positive`(element)	对于任何 `GaussianElement` 返回 `False`。
`is_square`(a)	返回 `a` 是否是该域中的一个平方数。
`is_zero`(a)	如果 `a` 为零，则返回 True。
`lcm`(a, b)	在 ZZ_I 上 a 和 b 的最小公倍数。
`log`(a, b)	返回 `a` 的 b 进制对数。
`map`(seq)	递归地将 `self` 应用于 `seq` 的所有元素。
`mul`(a, b)	`a` 和 `b` 的乘积，意味着 `__mul__`。
`n`(a[, prec])	返回 `a` 的数值近似值。
`neg`(a)	返回 `a` 的否定值，意味着 `__neg__`。
`normalize`(d, *args)	返回与 `d` 关联的第一象限元素。
`numer`(a)	返回 `a` 的分子。
`of_type`(element)	检查 `a` 是否为 `dtype` 类型。
`old_frac_field`(symbols, *kwargs)	返回一个分数域，即 \(K(X)\)。
`old_poly_ring`(symbols, *kwargs)	返回一个多项式环，即 \(K[X]\)。
`poly_ring`(*symbols[, order])	返回一个多项式环，即 \(K[X]\)。
`pos`(a)	返回 `a` 为正，意味着 `__pos__`。
`pow`(a, b)	将 `a` 提升到 `b` 的幂，意味着 `__pow__`。
`quo`(a, b)	`a` 和 `b` 的商，意味着 `__floordiv__`。
`quotient_ring`(e)	形成 `self` 的商环。
`rem`(a, b)	`a` 和 `b` 的余数，意味着 `__mod__`。
`revert`(a)	如果可能，返回 `a**(-1)`。
`sqrt`(a)	返回 `a` 的（可能不精确的）平方根。
`sub`(a, b)	`a` 和 `b` 的差异，意味着 `__sub__`。
`to_sympy`(a)	将 `a` 转换为 SymPy 对象。
`unify`(K1[, symbols])	构建一个包含 `K0` 和 `K1` 元素的最小域。
`unify_composite`(K1)	统一两个领域，其中至少一个是复合的。

canonical_unit
dom
from_GeneralizedPolynomialRing
imag
is_unit
新
正常
真实
总和
unify_with_symbols

dtype[源代码]¶: GaussianInteger 的别名

from_GaussianIntegerRing( a, K0, )[源代码][源代码]¶: 将 ZZ_I 元素转换为 ZZ_I。

from_GaussianRationalField( a, K0, )[源代码][源代码]¶: 将 QQ_I 元素转换为 ZZ_I。

gcd(a, b)[源代码][源代码]¶: 在 ZZ_I 上 a 和 b 的最大公约数。

gcdex(a, b)[源代码][源代码]¶: 返回 x, y, g 使得 x * a + y * b = g = gcd(a, b)

get_field()[源代码][源代码]¶: 返回与 self 关联的字段。

get_ring()[源代码][源代码]¶: 返回与 self 相关联的环。

lcm(a, b)[源代码][源代码]¶: 在 ZZ_I 上 a 和 b 的最小公倍数。

normalize(d, *args)[源代码][源代码]¶

返回与 d 关联的第一象限元素。

同样将其他参数乘以相同的 i 的幂。

class sympy.polys.domains.gaussiandomains.GaussianInteger(x, y=0)[源代码][源代码]¶

高斯整数：ZZ_I 的域元素

>>> from sympy import ZZ_I
>>> z = ZZ_I(2, 3)
>>> z
(2 + 3*I)
>>> type(z)
<class 'sympy.polys.domains.gaussiandomains.GaussianInteger'>

属性:

x
y

方法

`new`(x, y)	创建一个相同域的新 GaussianElement。
`parent`()	这个元素所属的域（ZZ_I 或 QQ_I）
`quadrant`()	返回象限索引 0-3。

基础

QQ_I¶

class sympy.polys.domains.gaussiandomains.GaussianRationalField[源代码][源代码]¶

高斯有理数域 QQ_I

The QQ_I 域表示 Gaussian rationals \(\mathbb{Q}(i)\) 作为域系统中的 Domain （参见介绍 poly 模块的领域）。

默认情况下，从系数为有理数和 ``I``（\(\sqrt{-1}\)）组合的表达式创建的 Poly 将具有域 QQ_I。

>>> from sympy import Poly, Symbol, I
>>> x = Symbol('x')
>>> p = Poly(x**2 + I/2)
>>> p
Poly(x**2 + I/2, x, domain='QQ_I')
>>> p.domain
QQ_I

选项 gaussian=True 可以用于指定域应该是 QQ_I，即使系数不包含 I 或全是整数。

>>> Poly(x**2)
Poly(x**2, x, domain='ZZ')
>>> Poly(x**2 + I)
Poly(x**2 + I, x, domain='ZZ_I')
>>> Poly(x**2/2)
Poly(1/2*x**2, x, domain='QQ')
>>> Poly(x**2, gaussian=True)
Poly(x**2, x, domain='QQ_I')
>>> Poly(x**2 + I, gaussian=True)
Poly(x**2 + I, x, domain='QQ_I')
>>> Poly(x**2/2, gaussian=True)
Poly(1/2*x**2, x, domain='QQ_I')

可以使用 QQ_I 域来分解在高斯有理数上可约的多项式。

>>> from sympy import factor, QQ_I
>>> factor(x**2/4 + 1)
(x**2 + 4)/4
>>> factor(x**2/4 + 1, domain='QQ_I')
(x - 2*I)*(x + 2*I)/4
>>> factor(x**2/4 + 1, domain=QQ_I)
(x - 2*I)*(x + 2*I)/4

也可以通过像 apart() 这样的 polys 函数显式指定 QQ_I 域。

>>> from sympy import apart
>>> apart(1/(1 + x**2))
1/(x**2 + 1)
>>> apart(1/(1 + x**2), domain=QQ_I)
I/(2*(x + I)) - I/(2*(x - I))

对应的整数环是高斯整数的域 ZZ_I。相反，QQ_I 是 ZZ_I 的分式域。

>>> from sympy import ZZ_I, QQ_I, QQ
>>> ZZ_I.get_field()
QQ_I
>>> QQ_I.get_ring()
ZZ_I

当直接使用域时，可以使用 QQ_I 作为构造函数。

>>> QQ_I(3, 4)
(3 + 4*I)
>>> QQ_I(5)
(5 + 0*I)
>>> QQ_I(QQ(2, 3), QQ(4, 5))
(2/3 + 4/5*I)

The domain elements of QQ_I are instances of GaussianRational which support the field operations +,-,*,**,/.

>>> z1 = QQ_I(5, 1)
>>> z2 = QQ_I(2, QQ(1, 2))
>>> z1
(5 + 1*I)
>>> z2
(2 + 1/2*I)
>>> z1 + z2
(7 + 3/2*I)
>>> z1 * z2
(19/2 + 9/2*I)
>>> z2 ** 2
(15/4 + 2*I)

在 QQ_I 中的真除法 (/) 给出一个 QQ_I 的元素，并且总是精确的。

>>> z1 / z2
(42/17 + -2/17*I)
>>> QQ_I.exquo(z1, z2)
(42/17 + -2/17*I)
>>> z1 == (z1/z2)*z2
True

地板除 (//) 和取模 (%) 除法都可以与 GaussianRational 一起使用（参见 div()），但除法总是精确的，因此没有余数。

>>> z1 // z2
(42/17 + -2/17*I)
>>> z1 % z2
(0 + 0*I)
>>> QQ_I.div(z1, z2)
((42/17 + -2/17*I), (0 + 0*I))
>>> (z1//z2)*z2 + z1%z2 == z1
True

属性:

别名
has_CharacteristicZero
tp: 别名 dtype

方法

`__call__`(*args)	从 `args` 构造 `self` 域的一个元素。
`abs`(a)	`a` 的绝对值，意味着 `__abs__`。
`add`(a, b)	`a` 和 `b` 的和，意味着 `__add__`。
`alg_field_from_poly`(poly[, alias, root_index])	通过根索引选择多项式的根来构造代数扩展的便捷方法。
`algebraic_field`(*extension[, alias])	返回一个代数数域，即 \(K(\alpha, \ldots)\)。
`almosteq`(a, b[, tolerance])	检查 `a` 和 `b` 是否几乎相等。
`as_AlgebraicField`()	获取与 `AlgebraicField` 等价的域。
`characteristic`()
`cofactors`(a, b)	返回 `a` 和 `b` 的最大公约数和余因子。
`convert`(element[, base])	将 `element` 转换为 `self.dtype`。
`convert_from`(element, base)	在给定的基本域中将 `element` 转换为 `self.dtype`。
`cyclotomic_field`(n[, ss, alias, gen, root_index])	构建分圆域的便捷方法。
`denom`(a)	获取 `a` 的分母。
`div`(a, b)	`a` 和 `b` 的除法，意味着 `__truediv__`。
`drop`(*symbols)	从此领域中移除生成器。
`dtype`	`GaussianRational` 的别名
`evalf`(a[, prec])	返回 `a` 的数值近似值。
`exquo`(a, b)	`a` 和 `b` 的精确商，意味着 `__truediv__`。
`exsqrt`(a)	在 `a` 是平方数的域内的主平方根。
`frac_field`(*symbols[, order])	返回一个分数域，即 \(K(X)\)。
`free_module`(rank)	在自身上生成一个秩为 `rank` 的自由模。
`from_AlgebraicField`(a, K0)	将一个元素从 ZZ<I> 或 QQ<I> 转换为 `self.dtype`。
`from_ComplexField`(a, K0)	将一个 ComplexField 元素转换为 QQ_I。
`from_ExpressionDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_ExpressionRawDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_FF`(a, K0)	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FF_gmpy`(a, K0)	将 `ModularInteger(mpz)` 转换为 `dtype`。
`from_FF_python`(a, K0)	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FractionField`(a, K0)	将一个有理函数转换为 `dtype`。
`from_GaussianIntegerRing`(a, K0)	将 ZZ_I 元素转换为 QQ_I。
`from_GaussianRationalField`(a, K0)	将 QQ_I 元素转换为 QQ_I。
`from_GlobalPolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_MonogenicFiniteExtension`(a, K0)	将 `ExtensionElement` 转换为 `dtype`。
`from_PolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_QQ`(a, K0)	将 GMPY mpq 转换为 `self.dtype`。
`from_QQ_gmpy`(a, K0)	将 GMPY mpq 转换为 `self.dtype`。
`from_QQ_python`(a, K0)	将一个 QQ_python 元素转换为 `self.dtype`。
`from_RealField`(a, K0)	将一个真实的元素对象转换为 `dtype`。
`from_ZZ`(a, K0)	将一个 ZZ_python 元素转换为 `self.dtype`。
`from_ZZ_gmpy`(a, K0)	将 GMPY 的 mpz 转换为 `self.dtype`。
`from_ZZ_python`(a, K0)	将一个 ZZ_python 元素转换为 `self.dtype`。
`from_sympy`(a)	将一个 SymPy 对象转换为 `self.dtype`。
`gcd`(a, b)	返回 `a` 和 `b` 的最大公约数。
`gcdex`(a, b)	返回 x, y, g 使得 a * x + b * y == g == gcd(a, b)
`get_exact`()	返回与 `self` 关联的精确域。
`get_field`()	返回与 `self` 关联的字段。
`get_ring`()	返回与 `self` 相关联的环。
`half_gcdex`(a, b)	`a` 和 `b` 的半扩展最大公约数。
`ideal`(*gens)	生成一个理想的 `自我`。
`inject`(*gens)	将生成器注入此域。
`invert`(a, b)	返回 `a mod b` 的逆。
`is_negative`(element)	对于任何 `GaussianElement` 返回 `False`。
`is_nonnegative`(element)	对于任何 `GaussianElement` 返回 `False`。
`is_nonpositive`(element)	对于任何 `GaussianElement` 返回 `False`。
`is_one`(a)	如果 `a` 是 1，则返回 True。
`is_positive`(element)	对于任何 `GaussianElement` 返回 `False`。
`is_square`(a)	返回 `a` 是否是该域中的一个平方数。
`is_unit`(a)	如果 `a` 是可逆的，则返回 true
`is_zero`(a)	如果 `a` 为零，则返回 True。
`lcm`(a, b)	返回 `a` 和 `b` 的最小公倍数。
`log`(a, b)	返回 `a` 的 b 进制对数。
`map`(seq)	递归地将 `self` 应用于 `seq` 的所有元素。
`mul`(a, b)	`a` 和 `b` 的乘积，意味着 `__mul__`。
`n`(a[, prec])	返回 `a` 的数值近似值。
`neg`(a)	返回 `a` 的否定值，意味着 `__neg__`。
`numer`(a)	获取 `a` 的分子。
`of_type`(element)	检查 `a` 是否为 `dtype` 类型。
`old_frac_field`(symbols, *kwargs)	返回一个分数域，即 \(K(X)\)。
`old_poly_ring`(symbols, *kwargs)	返回一个多项式环，即 \(K[X]\)。
`poly_ring`(*symbols[, order])	返回一个多项式环，即 \(K[X]\)。
`pos`(a)	返回 `a` 为正，意味着 `__pos__`。
`pow`(a, b)	将 `a` 提升到 `b` 的幂，意味着 `__pow__`。
`quo`(a, b)	`a` 和 `b` 的商，意味着 `__truediv__`。
`quotient_ring`(e)	形成 `self` 的商环。
`rem`(a, b)	`a` 和 `b` 的余数，没有隐含意义。
`revert`(a)	如果可能，返回 `a**(-1)`。
`sqrt`(a)	返回 `a` 的（可能不精确的）平方根。
`sub`(a, b)	`a` 和 `b` 的差异，意味着 `__sub__`。
`to_sympy`(a)	将 `a` 转换为 SymPy 对象。
`unify`(K1[, symbols])	构建一个包含 `K0` 和 `K1` 元素的最小域。
`unify_composite`(K1)	统一两个领域，其中至少一个是复合的。

canonical_unit
dom
from_GeneralizedPolynomialRing
imag
新
正常
真实
总和
unify_with_symbols

as_AlgebraicField()[源代码][源代码]¶: 获取与 AlgebraicField 等价的域。

denom(a)[源代码][源代码]¶: 获取 a 的分母。

dtype[源代码]¶: GaussianRational 的别名

from_ComplexField(a, K0)[源代码][源代码]¶: 将一个 ComplexField 元素转换为 QQ_I。

from_GaussianIntegerRing( a, K0, )[源代码][源代码]¶: 将 ZZ_I 元素转换为 QQ_I。

from_GaussianRationalField( a, K0, )[源代码][源代码]¶: 将 QQ_I 元素转换为 QQ_I。

get_field()[源代码][源代码]¶: 返回与 self 关联的字段。

get_ring()[源代码][源代码]¶: 返回与 self 相关联的环。

numer(a)[源代码][源代码]¶: 获取 a 的分子。

class sympy.polys.domains.gaussiandomains.GaussianRational(x, y=0)[源代码][源代码]¶

高斯有理数：QQ_I 的域元素

>>> from sympy import QQ_I, QQ
>>> z = QQ_I(QQ(2, 3), QQ(4, 5))
>>> z
(2/3 + 4/5*I)
>>> type(z)
<class 'sympy.polys.domains.gaussiandomains.GaussianRational'>

属性:

x
y

方法

`new`(x, y)	创建一个相同域的新 GaussianElement。
`parent`()	这个元素所属的域（ZZ_I 或 QQ_I）
`quadrant`()	返回象限索引 0-3。

基础

QQ<a>¶

class sympy.polys.domains.AlgebraicField(dom, *ext, alias=None)[源代码][源代码]¶

代数数域 QQ<a>

一个 QQ(a) 域表示一个代数数域 \(\mathbb{Q}(a)\) 作为域系统中的 ~.Domain`（参见 :ref:`多项式域介绍）。

如果未指定 \(generators\) 参数，从涉及代数数的表达式创建的 Poly 将把代数数视为生成器。

>>> from sympy import Poly, Symbol, sqrt
>>> x = Symbol('x')
>>> Poly(x**2 + sqrt(2))
Poly(x**2 + (sqrt(2)), x, sqrt(2), domain='ZZ')

这是一个多元多项式，其中 sqrt(2) 被视为生成器（变量）之一。如果生成器被明确指定，那么 sqrt(2) 将被视为系数，但默认情况下使用 EX 域。要创建一个带有 QQ<a> 域的 Poly，可以给出参数 extension=True。

>>> Poly(x**2 + sqrt(2), x)
Poly(x**2 + sqrt(2), x, domain='EX')
>>> Poly(x**2 + sqrt(2), x, extension=True)
Poly(x**2 + sqrt(2), x, domain='QQ<sqrt(2)>')

代数域扩展的生成元也可以显式指定，这在系数均为有理数但需要扩展域时特别有用（例如，用于因式分解多项式）。

>>> Poly(x**2 + 1)
Poly(x**2 + 1, x, domain='ZZ')
>>> Poly(x**2 + 1, extension=sqrt(2))
Poly(x**2 + 1, x, domain='QQ<sqrt(2)>')

可以通过使用 extension 参数到 factor() 或通过显式指定域来对 QQ<a> 域上的多项式进行因式分解。

>>> from sympy import factor, QQ
>>> factor(x**2 - 2)
x**2 - 2
>>> factor(x**2 - 2, extension=sqrt(2))
(x - sqrt(2))*(x + sqrt(2))
>>> factor(x**2 - 2, domain='QQ<sqrt(2)>')
(x - sqrt(2))*(x + sqrt(2))
>>> factor(x**2 - 2, domain=QQ.algebraic_field(sqrt(2)))
(x - sqrt(2))*(x + sqrt(2))

extension=True 参数可以使用，但只会创建一个包含系数的扩展，这通常不足以因式分解多项式。

>>> p = x**3 + sqrt(2)*x**2 - 2*x - 2*sqrt(2)
>>> factor(p)                         # treats sqrt(2) as a symbol
(x + sqrt(2))*(x**2 - 2)
>>> factor(p, extension=True)
(x - sqrt(2))*(x + sqrt(2))**2
>>> factor(x**2 - 2, extension=True)  # all rational coefficients
x**2 - 2

也可以使用 QQ<a> 与 cancel() 和 gcd() 函数。

>>> from sympy import cancel, gcd
>>> cancel((x**2 - 2)/(x - sqrt(2)))
(x**2 - 2)/(x - sqrt(2))
>>> cancel((x**2 - 2)/(x - sqrt(2)), extension=sqrt(2))
x + sqrt(2)
>>> gcd(x**2 - 2, x - sqrt(2))
1
>>> gcd(x**2 - 2, x - sqrt(2), extension=sqrt(2))
x - sqrt(2)

当直接使用域时，QQ<a> 可以用作构造函数来创建实例，这些实例随后支持操作 +,-,*,**,/。algebraic_field() 方法用于构造特定的 QQ<a> 域。from_sympy() 方法可用于从普通 SymPy 表达式创建域元素。

>>> K = QQ.algebraic_field(sqrt(2))
>>> K
QQ<sqrt(2)>
>>> xk = K.from_sympy(3 + 4*sqrt(2))
>>> xk  
ANP([4, 3], [1, 0, -2], QQ)

Elements of QQ<a> are instances of ANP which have limited printing support. The raw display shows the internal representation of the element as the list [4, 3] representing the coefficients of 1 and sqrt(2) for this element in the form a * sqrt(2) + b * 1 where a and b are elements of QQ. The minimal polynomial for the generator (x**2 - 2) is also shown in the DUP 表示 as the list [1, 0, -2]. We can use to_sympy() to get a better printed form for the elements and to see the results of operations.

>>> xk = K.from_sympy(3 + 4*sqrt(2))
>>> yk = K.from_sympy(2 + 3*sqrt(2))
>>> xk * yk  
ANP([17, 30], [1, 0, -2], QQ)
>>> K.to_sympy(xk * yk)
17*sqrt(2) + 30
>>> K.to_sympy(xk + yk)
5 + 7*sqrt(2)
>>> K.to_sympy(xk ** 2)
24*sqrt(2) + 41
>>> K.to_sympy(xk / yk)
sqrt(2)/14 + 9/7

任何表示代数数的表达式都可以用来生成一个 QQ<a> 域，前提是其最小多项式可以被计算。函数 minpoly() 用于此目的。

>>> from sympy import exp, I, pi, minpoly
>>> g = exp(2*I*pi/3)
>>> g
exp(2*I*pi/3)
>>> g.is_algebraic
True
>>> minpoly(g, x)
x**2 + x + 1
>>> factor(x**3 - 1, extension=g)
(x - 1)*(x - exp(2*I*pi/3))*(x + 1 + exp(2*I*pi/3))

也可以通过多个扩展元素来构建一个代数域。

>>> K = QQ.algebraic_field(sqrt(2), sqrt(3))
>>> K
QQ<sqrt(2) + sqrt(3)>
>>> p = x**4 - 5*x**2 + 6
>>> factor(p)
(x**2 - 3)*(x**2 - 2)
>>> factor(p, domain=K)
(x - sqrt(2))*(x + sqrt(2))*(x - sqrt(3))*(x + sqrt(3))
>>> factor(p, extension=[sqrt(2), sqrt(3)])
(x - sqrt(2))*(x + sqrt(2))*(x - sqrt(3))*(x + sqrt(3))

多个扩展元素总是组合在一起形成一个基本元素。在 [sqrt(2), sqrt(3)] 的情况下，选择的基本元素是 sqrt(2) + sqrt(3)，这就是为什么域显示为 QQ<sqrt(2) + sqrt(3)>。基本元素的最小多项式是使用 primitive_element() 函数计算的。

>>> from sympy import primitive_element
>>> primitive_element([sqrt(2), sqrt(3)], x)
(x**4 - 10*x**2 + 1, [1, 1])
>>> minpoly(sqrt(2) + sqrt(3), x)
x**4 - 10*x**2 + 1

生成域的扩展元素可以通过 ext 和 orig_ext 属性从域中访问，这些属性作为 AlgebraicNumber 的实例。原始元素的最小多项式作为 DMP 实例可作为 mod 使用。

>>> K = QQ.algebraic_field(sqrt(2), sqrt(3))
>>> K
QQ<sqrt(2) + sqrt(3)>
>>> K.ext
sqrt(2) + sqrt(3)
>>> K.orig_ext
(sqrt(2), sqrt(3))
>>> K.mod  
DMP_Python([1, 0, -10, 0, 1], QQ)

可以通过 discriminant() 方法获取域的 discriminant，通过 integral_basis() 方法获取 integral basis。后者默认返回一个 ANP 实例列表，但可以通过传递 fmt 参数使其返回 Expr 或 AlgebraicNumber 实例。域的最大序，或整数环，也可以通过 maximal_order() 方法获取，作为 Submodule。

>>> zeta5 = exp(2*I*pi/5)
>>> K = QQ.algebraic_field(zeta5)
>>> K
QQ<exp(2*I*pi/5)>
>>> K.discriminant()
125
>>> K = QQ.algebraic_field(sqrt(5))
>>> K
QQ<sqrt(5)>
>>> K.integral_basis(fmt='sympy')
[1, 1/2 + sqrt(5)/2]
>>> K.maximal_order()
Submodule[[2, 0], [1, 1]]/2

有理数域的素数分解为域的素理想是通过 primes_above() 方法计算的，该方法返回一个 PrimeIdeal 实例的列表。

>>> zeta7 = exp(2*I*pi/7)
>>> K = QQ.algebraic_field(zeta7)
>>> K
QQ<exp(2*I*pi/7)>
>>> K.primes_above(11)
[(11, _x**3 + 5*_x**2 + 4*_x - 1), (11, _x**3 - 4*_x**2 - 5*_x - 1)]

可以计算域的伽罗瓦闭包的伽罗瓦群（当域的最小多项式的次数足够小时）。

>>> K.galois_group(by_name=True)[0]
S6TransitiveSubgroups.C6

属性:

别名
一
rep
tp: 别名 dtype
零

方法

`__call__`(*args)	从 `args` 构造 `self` 域的一个元素。
`abs`(a)	`a` 的绝对值，意味着 `__abs__`。
`add`(a, b)	`a` 和 `b` 的和，意味着 `__add__`。
`alg_field_from_poly`(poly[, alias, root_index])	通过根索引选择多项式的根来构造代数扩展的便捷方法。
`algebraic_field`(*extension[, alias])	返回一个代数域，即 \(\mathbb{Q}(\alpha, \ldots)\)。
`almosteq`(a, b[, tolerance])	检查 `a` 和 `b` 是否几乎相等。
`characteristic`()	返回此域的特征。
`cofactors`(a, b)	返回 `a` 和 `b` 的最大公约数和余因子。
`convert`(element[, base])	将 `element` 转换为 `self.dtype`。
`convert_from`(element, base)	在给定的基本域中将 `element` 转换为 `self.dtype`。
`cyclotomic_field`(n[, ss, alias, gen, root_index])	构建分圆域的便捷方法。
`denom`(a)	返回 `a` 的分母。
`discriminant`()	获取字段的判别式。
`div`(a, b)	`a` 和 `b` 的除法，意味着 `__truediv__`。
`drop`(*symbols)	从此领域中移除生成器。
`dtype`	`ANP` 的别名
`evalf`(a[, prec])	返回 `a` 的数值近似值。
`exquo`(a, b)	`a` 和 `b` 的精确商，意味着 `__truediv__`。
`exsqrt`(a)	在 `a` 是平方数的域内的主平方根。
`frac_field`(*symbols[, order])	返回一个分数域，即 \(K(X)\)。
`free_module`(rank)	在自身上生成一个秩为 `rank` 的自由模。
`from_AlgebraicField`(a, K0)	将代数域元素 'a' 转换为另一个代数域
`from_ComplexField`(a, K0)	将复杂元素转换为 `dtype`。
`from_ExpressionDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_ExpressionRawDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_FF`(a, K0)	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FF_gmpy`(a, K0)	将 `ModularInteger(mpz)` 转换为 `dtype`。
`from_FF_python`(a, K0)	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FractionField`(a, K0)	将一个有理函数转换为 `dtype`。
`from_GaussianIntegerRing`(a, K0)	将一个 GaussianInteger 元素 'a' 转换为 `dtype`。
`from_GaussianRationalField`(a, K0)	将一个 GaussianRational 元素 'a' 转换为 `dtype`。
`from_GlobalPolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_MonogenicFiniteExtension`(a, K0)	将 `ExtensionElement` 转换为 `dtype`。
`from_PolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_QQ`(a, K0)	将 Python `Fraction` 对象转换为 `dtype`。
`from_QQ_gmpy`(a, K0)	将 GMPY 的 `mpq` 对象转换为 `dtype`。
`from_QQ_python`(a, K0)	将 Python `Fraction` 对象转换为 `dtype`。
`from_RealField`(a, K0)	将 mpmath 的 `mpf` 对象转换为 `dtype`。
`from_ZZ`(a, K0)	将 Python `int` 对象转换为 `dtype`。
`from_ZZ_gmpy`(a, K0)	将 GMPY 的 `mpz` 对象转换为 `dtype`。
`from_ZZ_python`(a, K0)	将 Python `int` 对象转换为 `dtype`。
`from_sympy`(a)	将 SymPy 的表达式转换为 `dtype`。
`galois_group`([by_name, max_tries, randomize])	计算此域的伽罗瓦闭包的伽罗瓦群。
`gcd`(a, b)	返回 `a` 和 `b` 的最大公约数。
`gcdex`(a, b)	返回 x, y, g 使得 a * x + b * y == g == gcd(a, b)
`get_exact`()	返回与 `self` 关联的精确域。
`get_field`()	返回与 `self` 关联的字段。
`get_ring`()	返回与 `self` 相关联的环。
`half_gcdex`(a, b)	`a` 和 `b` 的半扩展最大公约数。
`ideal`(*gens)	生成一个理想的 `自我`。
`inject`(*gens)	将生成器注入此域。
`integral_basis`([fmt])	获取该域的积分基。
`invert`(a, b)	返回 `a mod b` 的逆。
`is_negative`(a)	如果 `a` 为负数，则返回 True。
`is_nonnegative`(a)	如果 `a` 是非负的，则返回 True。
`is_nonpositive`(a)	如果 `a` 是非正数，则返回 True。
`is_one`(a)	如果 `a` 是 1，则返回 True。
`is_positive`(a)	如果 `a` 为正，则返回 True。
`is_square`(a)	返回 `a` 是否是该域中的一个平方数。
`is_unit`(a)	如果 `a` 是可逆的，则返回 true
`is_zero`(a)	如果 `a` 为零，则返回 True。
`lcm`(a, b)	返回 `a` 和 `b` 的最小公倍数。
`log`(a, b)	返回 `a` 的 b 进制对数。
`map`(seq)	递归地将 `self` 应用于 `seq` 的所有元素。
`maximal_order`()	计算域的最大序，或整数环。
`mul`(a, b)	`a` 和 `b` 的乘积，意味着 `__mul__`。
`n`(a[, prec])	返回 `a` 的数值近似值。
`neg`(a)	返回 `a` 的否定值，意味着 `__neg__`。
`numer`(a)	返回 `a` 的分子。
`of_type`(element)	检查 `a` 是否为 `dtype` 类型。
`old_frac_field`(symbols, *kwargs)	返回一个分数域，即 \(K(X)\)。
`old_poly_ring`(symbols, *kwargs)	返回一个多项式环，即 \(K[X]\)。
`poly_ring`(*symbols[, order])	返回一个多项式环，即 \(K[X]\)。
`pos`(a)	返回 `a` 为正，意味着 `__pos__`。
`pow`(a, b)	将 `a` 提升到 `b` 的幂，意味着 `__pow__`。
`primes_above`(p)	计算位于给定有理素数 p 之上的素理想。
`quo`(a, b)	`a` 和 `b` 的商，意味着 `__truediv__`。
`quotient_ring`(e)	形成 `self` 的商环。
`rem`(a, b)	`a` 和 `b` 的余数，没有隐含意义。
`revert`(a)	如果可能，返回 `a**(-1)`。
`sqrt`(a)	返回 `a` 的（可能不精确的）平方根。
`sub`(a, b)	`a` 和 `b` 的差异，意味着 `__sub__`。
`to_alg_num`(a)	将 `a` 的 `dtype` 转换为 `AlgebraicNumber`。
`to_sympy`(a)	将 `a` 的 `dtype` 转换为 SymPy 对象。
`unify`(K1[, symbols])	构建一个包含 `K0` 和 `K1` 元素的最小域。
`unify_composite`(K1)	统一两个领域，其中至少一个是复合的。

canonical_unit
from_GeneralizedPolynomialRing
imag
新
正常
真实
总和
unify_with_symbols

注释

目前无法在除 QQ 以外的任何域上生成代数扩展。理想情况下，应该可以生成像 QQ(x)(sqrt(x**2 - 2)) 这样的扩展。这等价于商环 QQ(x)[y]/(y**2 - x**2 + 2)，并且在 QuotientRing 和 MonogenicFiniteExtension 类中有两种此类商环/扩展的实现。然而，这些实现中的每一个都需要一些工作才能使它们完全可用。

algebraic_field( *extension, alias=None, )[源代码][源代码]¶: 返回一个代数域，即 \(\mathbb{Q}(\alpha, \ldots)\)。

denom(a)[源代码][源代码]¶: 返回 a 的分母。

discriminant()[源代码][源代码]¶: 获取字段的判别式。

dtype[源代码]¶: ANP 的别名

ext¶

用于扩展的基本元素。

>>> from sympy import QQ, sqrt
>>> K = QQ.algebraic_field(sqrt(2), sqrt(3))
>>> K.ext
sqrt(2) + sqrt(3)

from_AlgebraicField(a, K0)[源代码][源代码]¶: 将代数域元素 ‘a’ 转换为另一个代数域

from_GaussianIntegerRing(a, K0)[源代码][源代码]¶: 将一个 GaussianInteger 元素 ‘a’ 转换为 dtype。

from_GaussianRationalField(a, K0)[源代码][源代码]¶: 将一个 GaussianRational 元素 ‘a’ 转换为 dtype。

from_QQ(a, K0)[源代码][源代码]¶: 将 Python Fraction 对象转换为 dtype。

from_QQ_gmpy(a, K0)[源代码][源代码]¶: 将 GMPY 的 mpq 对象转换为 dtype。

from_QQ_python(a, K0)[源代码][源代码]¶: 将 Python Fraction 对象转换为 dtype。

from_RealField(a, K0)[源代码][源代码]¶: 将 mpmath 的 mpf 对象转换为 dtype。

from_ZZ(a, K0)[源代码][源代码]¶: 将 Python int 对象转换为 dtype。

from_ZZ_gmpy(a, K0)[源代码][源代码]¶: 将 GMPY 的 mpz 对象转换为 dtype。

from_ZZ_python(a, K0)[源代码][源代码]¶: 将 Python int 对象转换为 dtype。

from_sympy(a)[源代码][源代码]¶: 将 SymPy 的表达式转换为 dtype。

galois_group( by_name=False, max_tries=30, randomize=False, )[源代码][源代码]¶

计算此域的伽罗瓦闭包的伽罗瓦群。

参见

sympy.polys.numberfields.galoisgroups.galois_group

示例

如果该域是伽罗瓦域，群的阶将等于该域的次数：

>>> from sympy import QQ
>>> from sympy.abc import x
>>> k = QQ.alg_field_from_poly(x**4 + 1)
>>> G, _ = k.galois_group()
>>> G.order()
4

如果这个域不是伽罗瓦域，那么它的伽罗瓦闭包是一个真扩张，并且伽罗瓦群的阶将大于域的次数：

>>> k = QQ.alg_field_from_poly(x**4 - 2)
>>> G, _ = k.galois_group()
>>> G.order()
8

get_ring()[源代码][源代码]¶: 返回与 self 相关联的环。

integral_basis(fmt=None)[源代码][源代码]¶

获取该域的积分基。

参数:

fmtstr, None, 可选 (默认=None): 如果 None，返回一个 ANP 实例的列表。如果 "sympy"，将列表中的每个元素转换为 Expr，使用 self.to_sympy()。如果 "alg"，将列表中的每个元素转换为 AlgebraicNumber，使用 self.to_alg_num()。

参见

to_sympy
to_alg_num
maximal_order

示例

>>> from sympy import QQ, AlgebraicNumber, sqrt
>>> alpha = AlgebraicNumber(sqrt(5), alias='alpha')
>>> k = QQ.algebraic_field(alpha)
>>> B0 = k.integral_basis()
>>> B1 = k.integral_basis(fmt='sympy')
>>> B2 = k.integral_basis(fmt='alg')
>>> print(B0[1])  
ANP([mpq(1,2), mpq(1,2)], [mpq(1,1), mpq(0,1), mpq(-5,1)], QQ)
>>> print(B1[1])
1/2 + alpha/2
>>> print(B2[1])
alpha/2 + 1/2

在最后两种情况下，我们得到了可读的表达式，由于涉及的不同类型，它们的打印方式略有不同：

>>> print(type(B1[1]))
<class 'sympy.core.add.Add'>
>>> print(type(B2[1]))
<class 'sympy.core.numbers.AlgebraicNumber'>

is_negative(a)[源代码][源代码]¶: 如果 a 为负数，则返回 True。

is_nonnegative(a)[源代码][源代码]¶: 如果 a 是非负的，则返回 True。

is_nonpositive(a)[源代码][源代码]¶: 如果 a 是非正数，则返回 True。

is_positive(a)[源代码][源代码]¶: 如果 a 为正，则返回 True。

maximal_order()[源代码][源代码]¶

计算域的最大序，或整数环。

返回:

Submodule.

参见

integral_basis

mod¶

扩展的原始元素的最小多项式。

>>> from sympy import QQ, sqrt
>>> K = QQ.algebraic_field(sqrt(2))
>>> K.mod
DMP([1, 0, -2], QQ)

numer(a)[源代码][源代码]¶: 返回 a 的分子。

orig_ext¶

用于生成扩展的原始元素。

>>> from sympy import QQ, sqrt
>>> K = QQ.algebraic_field(sqrt(2), sqrt(3))
>>> K.orig_ext
(sqrt(2), sqrt(3))

primes_above(p)[源代码][源代码]¶: 计算位于给定有理素数 p 之上的素理想。

to_alg_num(a)[源代码][源代码]¶: 将 a 的 dtype 转换为 AlgebraicNumber。

to_sympy(a)[源代码][源代码]¶: 将 a 的 dtype 转换为 SymPy 对象。

RR¶

class sympy.polys.domains.RealField(prec=None, dps=None, tol=None)[源代码][源代码]¶

达到给定精度的实数。

属性:

别名
dps
has_default_precision
一
精度
容差
tp: 别名 dtype
零

方法

`__call__`(*args)	从 `args` 构造 `self` 域的一个元素。
`abs`(a)	`a` 的绝对值，意味着 `__abs__`。
`add`(a, b)	`a` 和 `b` 的和，意味着 `__add__`。
`alg_field_from_poly`(poly[, alias, root_index])	通过根索引选择多项式的根来构造代数扩展的便捷方法。
`algebraic_field`(*extension[, alias])	返回一个代数数域，即 \(K(\alpha, \ldots)\)。
`almosteq`(a, b[, tolerance])	检查 `a` 和 `b` 是否几乎相等。
`characteristic`()	返回此域的特征。
`cofactors`(a, b)	返回 `a` 和 `b` 的最大公约数和余因子。
`convert`(element[, base])	将 `element` 转换为 `self.dtype`。
`convert_from`(element, base)	在给定的基本域中将 `element` 转换为 `self.dtype`。
`cyclotomic_field`(n[, ss, alias, gen, root_index])	构建分圆域的便捷方法。
`denom`(a)	返回 \(a\) 的分母。
`div`(a, b)	`a` 和 `b` 的除法，意味着 `__truediv__`。
`drop`(*symbols)	从此领域中移除生成器。
`evalf`(a[, prec])	返回 `a` 的数值近似值。
`exquo`(a, b)	`a` 和 `b` 的精确商，意味着 `__truediv__`。
`exsqrt`(a)	对于 `a >= 0` 返回非负平方根，否则返回 `None`。
`frac_field`(*symbols[, order])	返回一个分数域，即 \(K(X)\)。
`free_module`(rank)	在自身上生成一个秩为 `rank` 的自由模。
`from_AlgebraicField`(element, base)
`from_ComplexField`(element, base)
`from_ExpressionDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_ExpressionRawDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_FF`(a, K0)	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FF_gmpy`(a, K0)	将 `ModularInteger(mpz)` 转换为 `dtype`。
`from_FF_python`(a, K0)	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FractionField`(a, K0)	将一个有理函数转换为 `dtype`。
`from_GlobalPolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_MonogenicFiniteExtension`(a, K0)	将 `ExtensionElement` 转换为 `dtype`。
`from_PolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_QQ_gmpy`(element, base)
`from_QQ_python`(element, base)
`from_RealField`(element, base)
`from_ZZ_gmpy`(element, base)
`from_ZZ_python`(element, base)
`from_sympy`(expr)	将 SymPy 的数字转换为 `dtype`。
`gcd`(a, b)	返回 `a` 和 `b` 的最大公约数。
`gcdex`(a, b)	返回 x, y, g 使得 a * x + b * y == g == gcd(a, b)
`get_exact`()	返回与 `self` 关联的精确域。
`get_field`()	返回与 `self` 关联的字段。
`get_ring`()	返回与 `self` 相关联的环。
`half_gcdex`(a, b)	`a` 和 `b` 的半扩展最大公约数。
`ideal`(*gens)	生成一个理想的 `自我`。
`inject`(*gens)	将生成器注入此域。
`invert`(a, b)	返回 `a mod b` 的逆。
`is_negative`(a)	如果 `a` 为负数，则返回 True。
`is_nonnegative`(a)	如果 `a` 是非负的，则返回 True。
`is_nonpositive`(a)	如果 `a` 是非正数，则返回 True。
`is_one`(a)	如果 `a` 是 1，则返回 True。
`is_positive`(a)	如果 `a` 为正，则返回 True。
`is_square`(a)	如果 `a >= 0` 则返回 `True`，否则返回 `False`。
`is_unit`(a)	如果 `a` 是可逆的，则返回 true
`is_zero`(a)	如果 `a` 为零，则返回 True。
`lcm`(a, b)	返回 `a` 和 `b` 的最小公倍数。
`log`(a, b)	返回 `a` 的 b 进制对数。
`map`(seq)	递归地将 `self` 应用于 `seq` 的所有元素。
`mul`(a, b)	`a` 和 `b` 的乘积，意味着 `__mul__`。
`n`(a[, prec])	返回 `a` 的数值近似值。
`neg`(a)	返回 `a` 的否定值，意味着 `__neg__`。
`numer`(a)	返回 `a` 的分子。
`of_type`(element)	检查 `a` 是否为 `dtype` 类型。
`old_frac_field`(symbols, *kwargs)	返回一个分数域，即 \(K(X)\)。
`old_poly_ring`(symbols, *kwargs)	返回一个多项式环，即 \(K[X]\)。
`poly_ring`(*symbols[, order])	返回一个多项式环，即 \(K[X]\)。
`pos`(a)	返回 `a` 为正，意味着 `__pos__`。
`pow`(a, b)	将 `a` 提升到 `b` 的幂，意味着 `__pow__`。
`quo`(a, b)	`a` 和 `b` 的商，意味着 `__truediv__`。
`quotient_ring`(e)	形成 `self` 的商环。
`rem`(a, b)	`a` 和 `b` 的余数，没有隐含意义。
`revert`(a)	如果可能，返回 `a**(-1)`。
`sqrt`(a)	返回 `a` 的（可能不精确的）平方根。
`sub`(a, b)	`a` 和 `b` 的差异，意味着 `__sub__`。
`to_rational`(element[, limit])	将实数转换为有理数。
`to_sympy`(element)	将 `element` 转换为 SymPy 数字。
`unify`(K1[, symbols])	构建一个包含 `K0` 和 `K1` 元素的最小域。
`unify_composite`(K1)	统一两个领域，其中至少一个是复合的。

canonical_unit
dtype
from_GeneralizedPolynomialRing
来自QQ
from_ZZ
imag
新
正常
真实
总和
unify_with_symbols

almosteq(a, b, tolerance=None)[源代码][源代码]¶: 检查 a 和 b 是否几乎相等。

exsqrt(a)[源代码][源代码]¶: 对于 a >= 0 返回非负平方根，否则返回 None。

from_sympy(expr)[源代码][源代码]¶: 将 SymPy 的数字转换为 dtype。

gcd(a, b)[源代码][源代码]¶: 返回 a 和 b 的最大公约数。

get_exact()[源代码][源代码]¶: 返回与 self 关联的精确域。

get_ring()[源代码][源代码]¶: 返回与 self 相关联的环。

is_square(a)[源代码][源代码]¶: 如果 a >= 0 则返回 True，否则返回 False。

lcm(a, b)[源代码][源代码]¶: 返回 a 和 b 的最小公倍数。

to_rational(element, limit=True)[源代码][源代码]¶: 将实数转换为有理数。

to_sympy(element)[源代码][源代码]¶: 将 element 转换为 SymPy 数字。

CC¶

class sympy.polys.domains.ComplexField(prec=None, dps=None, tol=None)[源代码][源代码]¶

复数，精度达到给定值。

属性:

别名
dps
has_default_precision
一
精度
容差
tp: 别名 dtype
零

方法

`__call__`(*args)	从 `args` 构造 `self` 域的一个元素。
`abs`(a)	`a` 的绝对值，意味着 `__abs__`。
`add`(a, b)	`a` 和 `b` 的和，意味着 `__add__`。
`alg_field_from_poly`(poly[, alias, root_index])	通过根索引选择多项式的根来构造代数扩展的便捷方法。
`algebraic_field`(*extension[, alias])	返回一个代数数域，即 \(K(\alpha, \ldots)\)。
`almosteq`(a, b[, tolerance])	检查 `a` 和 `b` 是否几乎相等。
`characteristic`()	返回此域的特征。
`cofactors`(a, b)	返回 `a` 和 `b` 的最大公约数和余因子。
`convert`(element[, base])	将 `element` 转换为 `self.dtype`。
`convert_from`(element, base)	在给定的基本域中将 `element` 转换为 `self.dtype`。
`cyclotomic_field`(n[, ss, alias, gen, root_index])	构建分圆域的便捷方法。
`denom`(a)	返回 \(a\) 的分母。
`div`(a, b)	`a` 和 `b` 的除法，意味着 `__truediv__`。
`drop`(*symbols)	从此领域中移除生成器。
`evalf`(a[, prec])	返回 `a` 的数值近似值。
`exquo`(a, b)	`a` 和 `b` 的精确商，意味着 `__truediv__`。
`exsqrt`(a)	返回 `a` 的主复数平方根。
`frac_field`(*symbols[, order])	返回一个分数域，即 \(K(X)\)。
`free_module`(rank)	在自身上生成一个秩为 `rank` 的自由模。
`from_AlgebraicField`(element, base)
`from_ComplexField`(element, base)
`from_ExpressionDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_ExpressionRawDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_FF`(a, K0)	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FF_gmpy`(a, K0)	将 `ModularInteger(mpz)` 转换为 `dtype`。
`from_FF_python`(a, K0)	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FractionField`(a, K0)	将一个有理函数转换为 `dtype`。
`from_GlobalPolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_MonogenicFiniteExtension`(a, K0)	将 `ExtensionElement` 转换为 `dtype`。
`from_PolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_QQ_gmpy`(element, base)
`from_QQ_python`(element, base)
`from_RealField`(element, base)
`from_ZZ_gmpy`(element, base)
`from_ZZ_python`(element, base)
`from_sympy`(expr)	将 SymPy 的数字转换为 `dtype`。
`gcd`(a, b)	返回 `a` 和 `b` 的最大公约数。
`gcdex`(a, b)	返回 x, y, g 使得 a * x + b * y == g == gcd(a, b)
`get_exact`()	返回与 `self` 关联的精确域。
`get_field`()	返回与 `self` 关联的字段。
`get_ring`()	返回与 `self` 相关联的环。
`half_gcdex`(a, b)	`a` 和 `b` 的半扩展最大公约数。
`ideal`(*gens)	生成一个理想的 `自我`。
`inject`(*gens)	将生成器注入此域。
`invert`(a, b)	返回 `a mod b` 的逆。
`is_negative`(element)	对于任何 `ComplexElement` 返回 `False`。
`is_nonnegative`(element)	对于任何 `ComplexElement` 返回 `False`。
`is_nonpositive`(element)	对于任何 `ComplexElement` 返回 `False`。
`is_one`(a)	如果 `a` 是 1，则返回 True。
`is_positive`(element)	对于任何 `ComplexElement` 返回 `False`。
`is_square`(a)	返回 `True`。
`is_unit`(a)	如果 `a` 是可逆的，则返回 true
`is_zero`(a)	如果 `a` 为零，则返回 True。
`lcm`(a, b)	返回 `a` 和 `b` 的最小公倍数。
`log`(a, b)	返回 `a` 的 b 进制对数。
`map`(seq)	递归地将 `self` 应用于 `seq` 的所有元素。
`mul`(a, b)	`a` 和 `b` 的乘积，意味着 `__mul__`。
`n`(a[, prec])	返回 `a` 的数值近似值。
`neg`(a)	返回 `a` 的否定值，意味着 `__neg__`。
`numer`(a)	返回 `a` 的分子。
`of_type`(element)	检查 `a` 是否为 `dtype` 类型。
`old_frac_field`(symbols, *kwargs)	返回一个分数域，即 \(K(X)\)。
`old_poly_ring`(symbols, *kwargs)	返回一个多项式环，即 \(K[X]\)。
`poly_ring`(*symbols[, order])	返回一个多项式环，即 \(K[X]\)。
`pos`(a)	返回 `a` 为正，意味着 `__pos__`。
`pow`(a, b)	将 `a` 提升到 `b` 的幂，意味着 `__pow__`。
`quo`(a, b)	`a` 和 `b` 的商，意味着 `__truediv__`。
`quotient_ring`(e)	形成 `self` 的商环。
`rem`(a, b)	`a` 和 `b` 的余数，没有隐含意义。
`revert`(a)	如果可能，返回 `a**(-1)`。
`sqrt`(a)	返回 `a` 的（可能不精确的）平方根。
`sub`(a, b)	`a` 和 `b` 的差异，意味着 `__sub__`。
`to_sympy`(element)	将 `element` 转换为 SymPy 数字。
`unify`(K1[, symbols])	构建一个包含 `K0` 和 `K1` 元素的最小域。
`unify_composite`(K1)	统一两个领域，其中至少一个是复合的。

canonical_unit
dtype
from_GaussianIntegerRing
from_GaussianRationalField
from_GeneralizedPolynomialRing
来自QQ
from_ZZ
imag
新
正常
真实
总和
unify_with_symbols

almosteq(a, b, tolerance=None)[源代码][源代码]¶: 检查 a 和 b 是否几乎相等。

exsqrt(a)[源代码][源代码]¶: 返回 a 的主复数平方根。

from_sympy(expr)[源代码][源代码]¶: 将 SymPy 的数字转换为 dtype。

gcd(a, b)[源代码][源代码]¶: 返回 a 和 b 的最大公约数。

get_exact()[源代码][源代码]¶: 返回与 self 关联的精确域。

get_ring()[源代码][源代码]¶: 返回与 self 相关联的环。

is_negative(element)[源代码][源代码]¶: 对于任何 ComplexElement 返回 False。

is_nonnegative(element)[源代码][源代码]¶: 对于任何 ComplexElement 返回 False。

is_nonpositive(element)[源代码][源代码]¶: 对于任何 ComplexElement 返回 False。

is_positive(element)[源代码][源代码]¶: 对于任何 ComplexElement 返回 False。

is_square(a)[源代码][源代码]¶: 返回 True。每个复数都有一个复数平方根。

lcm(a, b)[源代码][源代码]¶: 返回 a 和 b 的最小公倍数。

to_sympy(element)[源代码][源代码]¶: 将 element 转换为 SymPy 数字。

K[x]¶

class sympy.polys.domains.PolynomialRing( domain_or_ring, symbols=None, order=None, )[源代码][源代码]¶

用于表示多元多项式环的类。

属性:

别名
领域
dtype
生成
has_CharacteristicZero
is_Exact: 如果此域是精确的，则返回 True。
ngens
一
顺序
rep
符号
tp: 别名 dtype
零

方法

`__call__`(*args)	从 `args` 构造 `self` 域的一个元素。
`abs`(a)	`a` 的绝对值，意味着 `__abs__`。
`add`(a, b)	`a` 和 `b` 的和，意味着 `__add__`。
`alg_field_from_poly`(poly[, alias, root_index])	通过根索引选择多项式的根来构造代数扩展的便捷方法。
`algebraic_field`(*extension[, alias])	返回一个代数数域，即 \(K(\alpha, \ldots)\)。
`almosteq`(a, b[, tolerance])	检查 `a` 和 `b` 是否几乎相等。
`characteristic`()
`cofactors`(a, b)	返回 `a` 和 `b` 的最大公约数和余因子。
`convert`(element[, base])	将 `element` 转换为 `self.dtype`。
`convert_from`(element, base)	在给定的基本域中将 `element` 转换为 `self.dtype`。
`cyclotomic_field`(n[, ss, alias, gen, root_index])	构建分圆域的便捷方法。
`denom`(a)	返回 \(a\) 的分母。
`div`(a, b)	`a` 和 `b` 的除法，意味着 `__divmod__`。
`drop`(*symbols)	从此领域中移除生成器。
`evalf`(a[, prec])	返回 `a` 的数值近似值。
`exquo`(a, b)	`a` 和 `b` 的精确商，意味着 `__floordiv__`。
`exsqrt`(a)	在 `a` 是平方数的域内的主平方根。
`factorial`(a)	返回 \(a\) 的阶乘。
`frac_field`(*symbols[, order])	返回一个分数域，即 \(K(X)\)。
`free_module`(rank)	在自身上生成一个秩为 `rank` 的自由模。
`from_AlgebraicField`(a, K0)	将一个代数数转换为 `dtype`。
`from_ComplexField`(a, K0)	将 mpmath 的 \(mpf\) 对象转换为 \(dtype\)。
`from_ExpressionDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_ExpressionRawDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_FF`(a, K0)	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FF_gmpy`(a, K0)	将 `ModularInteger(mpz)` 转换为 `dtype`。
`from_FF_python`(a, K0)	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FractionField`(a, K0)	将一个有理函数转换为 `dtype`。
`from_GaussianIntegerRing`(a, K0)	将 \(GaussianInteger\) 对象转换为 \(dtype\)。
`from_GaussianRationalField`(a, K0)	将 \(GaussianRational\) 对象转换为 \(dtype\)。
`from_GlobalPolynomialRing`(a, K0)	从旧的多项式环转换为 `dtype`。
`from_MonogenicFiniteExtension`(a, K0)	将 `ExtensionElement` 转换为 `dtype`。
`from_PolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_QQ`(a, K0)	将 Python \(Fraction\) 对象转换为 \(dtype\)。
`from_QQ_gmpy`(a, K0)	将 GMPY 的 \(mpq\) 对象转换为 \(dtype\)。
`from_QQ_python`(a, K0)	将 Python \(Fraction\) 对象转换为 \(dtype\)。
`from_RealField`(a, K0)	将 mpmath 的 \(mpf\) 对象转换为 \(dtype\)。
`from_ZZ`(a, K0)	将 Python \(int\) 对象转换为 \(dtype\)。
`from_ZZ_gmpy`(a, K0)	将 GMPY 的 \(mpz\) 对象转换为 \(dtype\)。
`from_ZZ_python`(a, K0)	将 Python \(int\) 对象转换为 \(dtype\)。
`from_sympy`(a)	将 SymPy 的表达式转换为 \(dtype\)。
`gcd`(a, b)	返回 \(a\) 和 \(b\) 的最大公约数。
`gcdex`(a, b)	\(a\) 和 \(b\) 的扩展最大公约数。
`get_exact`()	返回此域的精确版本。
`get_field`()	返回与 \(self\) 关联的字段。
`get_ring`()	返回与 `self` 相关联的环。
`half_gcdex`(a, b)	`a` 和 `b` 的半扩展最大公约数。
`ideal`(*gens)	生成一个理想的 `自我`。
`inject`(*symbols)	将生成器注入此域。
`invert`(a, b)	返回 `a mod b` 的逆。
`is_negative`(a)	如果 \(LC(a)\) 为负，则返回 True。
`is_nonnegative`(a)	如果 \(LC(a)\) 是非负的，则返回 True。
`is_nonpositive`(a)	如果 \(LC(a)\) 是非正的，则返回 True。
`is_one`(a)	如果 `a` 是 1，则返回 True。
`is_positive`(a)	如果 \(LC(a)\) 为正，则返回 True。
`is_square`(a)	返回 `a` 是否是该域中的一个平方数。
`is_unit`(a)	如果 `a` 是 `self` 的单位，则返回 `True`
`is_zero`(a)	如果 `a` 为零，则返回 True。
`lcm`(a, b)	返回 \(a\) 和 \(b\) 的最小公倍数。
`log`(a, b)	返回 `a` 的 b 进制对数。
`map`(seq)	递归地将 `self` 应用于 `seq` 的所有元素。
`mul`(a, b)	`a` 和 `b` 的乘积，意味着 `__mul__`。
`n`(a[, prec])	返回 `a` 的数值近似值。
`neg`(a)	返回 `a` 的否定值，意味着 `__neg__`。
`numer`(a)	返回 `a` 的分子。
`of_type`(element)	检查 `a` 是否为 `dtype` 类型。
`old_frac_field`(symbols, *kwargs)	返回一个分数域，即 \(K(X)\)。
`old_poly_ring`(symbols, *kwargs)	返回一个多项式环，即 \(K[X]\)。
`poly_ring`(*symbols[, order])	返回一个多项式环，即 \(K[X]\)。
`pos`(a)	返回 `a` 为正，意味着 `__pos__`。
`pow`(a, b)	将 `a` 提升到 `b` 的幂，意味着 `__pow__`。
`quo`(a, b)	`a` 和 `b` 的商，意味着 `__floordiv__`。
`quotient_ring`(e)	形成 `self` 的商环。
`rem`(a, b)	`a` 和 `b` 的余数，意味着 `__mod__`。
`revert`(a)	如果可能，返回 `a**(-1)`。
`set_domain`(domain)	设置此域的基本域。
`sqrt`(a)	返回 `a` 的（可能不精确的）平方根。
`sub`(a, b)	`a` 和 `b` 的差异，意味着 `__sub__`。
`to_sympy`(a)	将 \(a\) 转换为 SymPy 对象。
`unify`(K1[, symbols])	构建一个包含 `K0` 和 `K1` 元素的最小域。
`unify_composite`(K1)	统一两个领域，其中至少一个是复合的。

canonical_unit
from_GeneralizedPolynomialRing
imag
新
正常
真实
总和
unify_with_symbols

factorial(a)[源代码][源代码]¶: 返回 \(a\) 的阶乘。

from_AlgebraicField(a, K0)[源代码][源代码]¶: 将一个代数数转换为 dtype。

from_ComplexField(a, K0)[源代码][源代码]¶: 将 mpmath 的 \(mpf\) 对象转换为 \(dtype\)。

from_FractionField(a, K0)[源代码][源代码]¶: 将一个有理函数转换为 dtype。

from_GaussianIntegerRing(a, K0)[源代码][源代码]¶: 将 \(GaussianInteger\) 对象转换为 \(dtype\)。

from_GaussianRationalField(a, K0)[源代码][源代码]¶: 将 \(GaussianRational\) 对象转换为 \(dtype\)。

from_GlobalPolynomialRing(a, K0)[源代码][源代码]¶: 从旧的多项式环转换为 dtype。

from_PolynomialRing(a, K0)[源代码][源代码]¶: 将多项式转换为 dtype。

from_QQ(a, K0)[源代码][源代码]¶: 将 Python \(Fraction\) 对象转换为 \(dtype\)。

from_QQ_gmpy(a, K0)[源代码][源代码]¶: 将 GMPY 的 \(mpq\) 对象转换为 \(dtype\)。

from_QQ_python(a, K0)[源代码][源代码]¶: 将 Python \(Fraction\) 对象转换为 \(dtype\)。

from_RealField(a, K0)[源代码][源代码]¶: 将 mpmath 的 \(mpf\) 对象转换为 \(dtype\)。

from_ZZ(a, K0)[源代码][源代码]¶: 将 Python \(int\) 对象转换为 \(dtype\)。

from_ZZ_gmpy(a, K0)[源代码][源代码]¶: 将 GMPY 的 \(mpz\) 对象转换为 \(dtype\)。

from_ZZ_python(a, K0)[源代码][源代码]¶: 将 Python \(int\) 对象转换为 \(dtype\)。

from_sympy(a)[源代码][源代码]¶: 将 SymPy 的表达式转换为 \(dtype\)。

gcd(a, b)[源代码][源代码]¶: 返回 \(a\) 和 \(b\) 的最大公约数。

gcdex(a, b)[源代码][源代码]¶: \(a\) 和 \(b\) 的扩展最大公约数。

get_field()[源代码][源代码]¶: 返回与 \(self\) 关联的字段。

is_negative(a)[源代码][源代码]¶: 如果 \(LC(a)\) 为负，则返回 True。

is_nonnegative(a)[源代码][源代码]¶: 如果 \(LC(a)\) 是非负的，则返回 True。

is_nonpositive(a)[源代码][源代码]¶: 如果 \(LC(a)\) 是非正的，则返回 True。

is_positive(a)[源代码][源代码]¶: 如果 \(LC(a)\) 为正，则返回 True。

is_unit(a)[源代码][源代码]¶: 如果 a 是 self 的单位，则返回 True

lcm(a, b)[源代码][源代码]¶: 返回 \(a\) 和 \(b\) 的最小公倍数。

to_sympy(a)[源代码][源代码]¶: 将 \(a\) 转换为 SymPy 对象。

K(x)¶

class sympy.polys.domains.FractionField( domain_or_field, symbols=None, order=None, )[源代码][源代码]¶

用于表示多元有理函数域的类。

属性:

别名
领域
dtype
生成
has_CharacteristicZero
is_Exact: 如果此域是精确的，则返回 True。
ngens
一
顺序
rep
符号
tp: 别名 dtype
零

方法

`__call__`(*args)	从 `args` 构造 `self` 域的一个元素。
`abs`(a)	`a` 的绝对值，意味着 `__abs__`。
`add`(a, b)	`a` 和 `b` 的和，意味着 `__add__`。
`alg_field_from_poly`(poly[, alias, root_index])	通过根索引选择多项式的根来构造代数扩展的便捷方法。
`algebraic_field`(*extension[, alias])	返回一个代数数域，即 \(K(\alpha, \ldots)\)。
`almosteq`(a, b[, tolerance])	检查 `a` 和 `b` 是否几乎相等。
`characteristic`()
`cofactors`(a, b)	返回 `a` 和 `b` 的最大公约数和余因子。
`convert`(element[, base])	将 `element` 转换为 `self.dtype`。
`convert_from`(element, base)	在给定的基本域中将 `element` 转换为 `self.dtype`。
`cyclotomic_field`(n[, ss, alias, gen, root_index])	构建分圆域的便捷方法。
`denom`(a)	返回 `a` 的分母。
`div`(a, b)	`a` 和 `b` 的除法，意味着 `__truediv__`。
`drop`(*symbols)	从此领域中移除生成器。
`evalf`(a[, prec])	返回 `a` 的数值近似值。
`exquo`(a, b)	`a` 和 `b` 的精确商，意味着 `__truediv__`。
`exsqrt`(a)	在 `a` 是平方数的域内的主平方根。
`factorial`(a)	返回 `a` 的阶乘。
`frac_field`(*symbols[, order])	返回一个分数域，即 \(K(X)\)。
`free_module`(rank)	在自身上生成一个秩为 `rank` 的自由模。
`from_AlgebraicField`(a, K0)	将一个代数数转换为 `dtype`。
`from_ComplexField`(a, K0)	将 mpmath 的 `mpf` 对象转换为 `dtype`。
`from_ExpressionDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_ExpressionRawDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_FF`(a, K0)	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FF_gmpy`(a, K0)	将 `ModularInteger(mpz)` 转换为 `dtype`。
`from_FF_python`(a, K0)	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FractionField`(a, K0)	将一个有理函数转换为 `dtype`。
`from_GaussianIntegerRing`(a, K0)	将 `GaussianInteger` 对象转换为 `dtype`。
`from_GaussianRationalField`(a, K0)	将 `GaussianRational` 对象转换为 `dtype`。
`from_GlobalPolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_MonogenicFiniteExtension`(a, K0)	将 `ExtensionElement` 转换为 `dtype`。
`from_PolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_QQ`(a, K0)	将 Python `Fraction` 对象转换为 `dtype`。
`from_QQ_gmpy`(a, K0)	将 GMPY 的 `mpq` 对象转换为 `dtype`。
`from_QQ_python`(a, K0)	将 Python `Fraction` 对象转换为 `dtype`。
`from_RealField`(a, K0)	将 mpmath 的 `mpf` 对象转换为 `dtype`。
`from_ZZ`(a, K0)	将 Python `int` 对象转换为 `dtype`。
`from_ZZ_gmpy`(a, K0)	将 GMPY 的 `mpz` 对象转换为 `dtype`。
`from_ZZ_python`(a, K0)	将 Python `int` 对象转换为 `dtype`。
`from_sympy`(a)	将 SymPy 的表达式转换为 `dtype`。
`gcd`(a, b)	返回 `a` 和 `b` 的最大公约数。
`gcdex`(a, b)	返回 x, y, g 使得 a * x + b * y == g == gcd(a, b)
`get_exact`()	返回此域的精确版本。
`get_field`()	返回与 `self` 关联的字段。
`get_ring`()	返回与 `self` 关联的字段。
`half_gcdex`(a, b)	`a` 和 `b` 的半扩展最大公约数。
`ideal`(*gens)	生成一个理想的 `自我`。
`inject`(*symbols)	将生成器注入此域。
`invert`(a, b)	返回 `a mod b` 的逆。
`is_negative`(a)	如果 `LC(a)` 为负数，则返回 True。
`is_nonnegative`(a)	如果 `LC(a)` 是非负的，则返回 True。
`is_nonpositive`(a)	如果 `LC(a)` 是非正的，则返回 True。
`is_one`(a)	如果 `a` 是 1，则返回 True。
`is_positive`(a)	如果 `LC(a)` 为正，则返回 True。
`is_square`(a)	返回 `a` 是否是该域中的一个平方数。
`is_unit`(a)	如果 `a` 是可逆的，则返回 true
`is_zero`(a)	如果 `a` 为零，则返回 True。
`lcm`(a, b)	返回 `a` 和 `b` 的最小公倍数。
`log`(a, b)	返回 `a` 的 b 进制对数。
`map`(seq)	递归地将 `self` 应用于 `seq` 的所有元素。
`mul`(a, b)	`a` 和 `b` 的乘积，意味着 `__mul__`。
`n`(a[, prec])	返回 `a` 的数值近似值。
`neg`(a)	返回 `a` 的否定值，意味着 `__neg__`。
`numer`(a)	返回 `a` 的分子。
`of_type`(element)	检查 `a` 是否为 `dtype` 类型。
`old_frac_field`(symbols, *kwargs)	返回一个分数域，即 \(K(X)\)。
`old_poly_ring`(symbols, *kwargs)	返回一个多项式环，即 \(K[X]\)。
`poly_ring`(*symbols[, order])	返回一个多项式环，即 \(K[X]\)。
`pos`(a)	返回 `a` 为正，意味着 `__pos__`。
`pow`(a, b)	将 `a` 提升到 `b` 的幂，意味着 `__pow__`。
`quo`(a, b)	`a` 和 `b` 的商，意味着 `__truediv__`。
`quotient_ring`(e)	形成 `self` 的商环。
`rem`(a, b)	`a` 和 `b` 的余数，没有隐含意义。
`revert`(a)	如果可能，返回 `a**(-1)`。
`set_domain`(domain)	设置此域的基本域。
`sqrt`(a)	返回 `a` 的（可能不精确的）平方根。
`sub`(a, b)	`a` 和 `b` 的差异，意味着 `__sub__`。
`to_sympy`(a)	将 `a` 转换为 SymPy 对象。
`unify`(K1[, symbols])	构建一个包含 `K0` 和 `K1` 元素的最小域。
`unify_composite`(K1)	统一两个领域，其中至少一个是复合的。

canonical_unit
from_GeneralizedPolynomialRing
imag
新
正常
真实
总和
unify_with_symbols

denom(a)[源代码][源代码]¶: 返回 a 的分母。

factorial(a)[源代码][源代码]¶: 返回 a 的阶乘。

from_AlgebraicField(a, K0)[源代码][源代码]¶: 将一个代数数转换为 dtype。

from_ComplexField(a, K0)[源代码][源代码]¶: 将 mpmath 的 mpf 对象转换为 dtype。

from_FractionField(a, K0)[源代码][源代码]¶: 将一个有理函数转换为 dtype。

from_GaussianIntegerRing(a, K0)[源代码][源代码]¶: 将 GaussianInteger 对象转换为 dtype。

from_GaussianRationalField(a, K0)[源代码][源代码]¶: 将 GaussianRational 对象转换为 dtype。

from_PolynomialRing(a, K0)[源代码][源代码]¶: 将多项式转换为 dtype。

from_QQ(a, K0)[源代码][源代码]¶: 将 Python Fraction 对象转换为 dtype。

from_QQ_gmpy(a, K0)[源代码][源代码]¶: 将 GMPY 的 mpq 对象转换为 dtype。

from_QQ_python(a, K0)[源代码][源代码]¶: 将 Python Fraction 对象转换为 dtype。

from_RealField(a, K0)[源代码][源代码]¶: 将 mpmath 的 mpf 对象转换为 dtype。

from_ZZ(a, K0)[源代码][源代码]¶: 将 Python int 对象转换为 dtype。

from_ZZ_gmpy(a, K0)[源代码][源代码]¶: 将 GMPY 的 mpz 对象转换为 dtype。

from_ZZ_python(a, K0)[源代码][源代码]¶: 将 Python int 对象转换为 dtype。

from_sympy(a)[源代码][源代码]¶: 将 SymPy 的表达式转换为 dtype。

get_ring()[源代码][源代码]¶: 返回与 self 关联的字段。

is_negative(a)[源代码][源代码]¶: 如果 LC(a) 为负数，则返回 True。

is_nonnegative(a)[源代码][源代码]¶: 如果 LC(a) 是非负的，则返回 True。

is_nonpositive(a)[源代码][源代码]¶: 如果 LC(a) 是非正的，则返回 True。

is_positive(a)[源代码][源代码]¶: 如果 LC(a) 为正，则返回 True。

numer(a)[源代码][源代码]¶: 返回 a 的分子。

to_sympy(a)[源代码][源代码]¶: 将 a 转换为 SymPy 对象。

`EX`¶

class sympy.polys.domains.ExpressionDomain[源代码][源代码]¶

用于任意表达式的类。

属性:

别名
tp: 别名 dtype

方法

`Expression`(ex)	一个任意表达式。
`__call__`(*args)	从 `args` 构造 `self` 域的一个元素。
`abs`(a)	`a` 的绝对值，意味着 `__abs__`。
`add`(a, b)	`a` 和 `b` 的和，意味着 `__add__`。
`alg_field_from_poly`(poly[, alias, root_index])	通过根索引选择多项式的根来构造代数扩展的便捷方法。
`algebraic_field`(*extension[, alias])	返回一个代数数域，即 \(K(\alpha, \ldots)\)。
`almosteq`(a, b[, tolerance])	检查 `a` 和 `b` 是否几乎相等。
`characteristic`()	返回此域的特征。
`cofactors`(a, b)	返回 `a` 和 `b` 的最大公约数和余因子。
`convert`(element[, base])	将 `element` 转换为 `self.dtype`。
`convert_from`(element, base)	在给定的基本域中将 `element` 转换为 `self.dtype`。
`cyclotomic_field`(n[, ss, alias, gen, root_index])	构建分圆域的便捷方法。
`denom`(a)	返回 `a` 的分母。
`div`(a, b)	`a` 和 `b` 的除法，意味着 `__truediv__`。
`drop`(*symbols)	从此领域中移除生成器。
`dtype`	`Expression` 的别名
`evalf`(a[, prec])	返回 `a` 的数值近似值。
`exquo`(a, b)	`a` 和 `b` 的精确商，意味着 `__truediv__`。
`exsqrt`(a)	在 `a` 是平方数的域内的主平方根。
`frac_field`(*symbols[, order])	返回一个分数域，即 \(K(X)\)。
`free_module`(rank)	在自身上生成一个秩为 `rank` 的自由模。
`from_AlgebraicField`(a, K0)	将 `ANP` 对象转换为 `dtype`。
`from_ComplexField`(a, K0)	将 mpmath 的 `mpc` 对象转换为 `dtype`。
`from_ExpressionDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_ExpressionRawDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_FF`(a, K0)	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FF_gmpy`(a, K0)	将 `ModularInteger(mpz)` 转换为 `dtype`。
`from_FF_python`(a, K0)	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FractionField`(a, K0)	将 `DMF` 对象转换为 `dtype`。
`from_GaussianIntegerRing`(a, K0)	将 `GaussianRational` 对象转换为 `dtype`。
`from_GaussianRationalField`(a, K0)	将 `GaussianRational` 对象转换为 `dtype`。
`from_GlobalPolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_MonogenicFiniteExtension`(a, K0)	将 `ExtensionElement` 转换为 `dtype`。
`from_PolynomialRing`(a, K0)	将 `DMP` 对象转换为 `dtype`。
`from_QQ`(a, K0)	将 Python `Fraction` 对象转换为 `dtype`。
`from_QQ_gmpy`(a, K0)	将 GMPY 的 `mpq` 对象转换为 `dtype`。
`from_QQ_python`(a, K0)	将 Python `Fraction` 对象转换为 `dtype`。
`from_RealField`(a, K0)	将 mpmath 的 `mpf` 对象转换为 `dtype`。
`from_ZZ`(a, K0)	将 Python `int` 对象转换为 `dtype`。
`from_ZZ_gmpy`(a, K0)	将 GMPY 的 `mpz` 对象转换为 `dtype`。
`from_ZZ_python`(a, K0)	将 Python `int` 对象转换为 `dtype`。
`from_sympy`(a)	将 SymPy 的表达式转换为 `dtype`。
`gcd`(a, b)
`gcdex`(a, b)	返回 x, y, g 使得 a * x + b * y == g == gcd(a, b)
`get_exact`()	返回与 `self` 关联的精确域。
`get_field`()	返回与 `self` 关联的字段。
`get_ring`()	返回与 `self` 相关联的环。
`half_gcdex`(a, b)	`a` 和 `b` 的半扩展最大公约数。
`ideal`(*gens)	生成一个理想的 `自我`。
`inject`(*gens)	将生成器注入此域。
`invert`(a, b)	返回 `a mod b` 的逆。
`is_negative`(a)	如果 `a` 为负数，则返回 True。
`is_nonnegative`(a)	如果 `a` 是非负的，则返回 True。
`is_nonpositive`(a)	如果 `a` 是非正数，则返回 True。
`is_one`(a)	如果 `a` 是 1，则返回 True。
`is_positive`(a)	如果 `a` 为正，则返回 True。
`is_square`(a)	返回 `a` 是否是该域中的一个平方数。
`is_unit`(a)	如果 `a` 是可逆的，则返回 true
`is_zero`(a)	如果 `a` 为零，则返回 True。
`lcm`(a, b)
`log`(a, b)	返回 `a` 的 b 进制对数。
`map`(seq)	递归地将 `self` 应用于 `seq` 的所有元素。
`mul`(a, b)	`a` 和 `b` 的乘积，意味着 `__mul__`。
`n`(a[, prec])	返回 `a` 的数值近似值。
`neg`(a)	返回 `a` 的否定值，意味着 `__neg__`。
`numer`(a)	返回 `a` 的分子。
`of_type`(element)	检查 `a` 是否为 `dtype` 类型。
`old_frac_field`(symbols, *kwargs)	返回一个分数域，即 \(K(X)\)。
`old_poly_ring`(symbols, *kwargs)	返回一个多项式环，即 \(K[X]\)。
`poly_ring`(*symbols[, order])	返回一个多项式环，即 \(K[X]\)。
`pos`(a)	返回 `a` 为正，意味着 `__pos__`。
`pow`(a, b)	将 `a` 提升到 `b` 的幂，意味着 `__pow__`。
`quo`(a, b)	`a` 和 `b` 的商，意味着 `__truediv__`。
`quotient_ring`(e)	形成 `self` 的商环。
`rem`(a, b)	`a` 和 `b` 的余数，没有隐含意义。
`revert`(a)	如果可能，返回 `a**(-1)`。
`sqrt`(a)	返回 `a` 的（可能不精确的）平方根。
`sub`(a, b)	`a` 和 `b` 的差异，意味着 `__sub__`。
`to_sympy`(a)	将 `a` 转换为 SymPy 对象。
`unify`(K1[, symbols])	构建一个包含 `K0` 和 `K1` 元素的最小域。
`unify_composite`(K1)	统一两个领域，其中至少一个是复合的。

canonical_unit
from_GeneralizedPolynomialRing
imag
新
正常
真实
总和
unify_with_symbols

class Expression(ex)[源代码][源代码]¶

一个任意表达式。

属性:

示例

方法

parent()

as_expr
denom
gcd
lcm
numer
简化

denom(a)[源代码][源代码]¶: 返回 a 的分母。

dtype[源代码]¶: Expression 的别名

from_AlgebraicField(a, K0)[源代码][源代码]¶: 将 ANP 对象转换为 dtype。

from_ComplexField(a, K0)[源代码][源代码]¶: 将 mpmath 的 mpc 对象转换为 dtype。

from_ExpressionDomain(a, K0)[源代码][源代码]¶: 将 EX 对象转换为 dtype。

from_FractionField(a, K0)[源代码][源代码]¶: 将 DMF 对象转换为 dtype。

from_GaussianIntegerRing(a, K0)[源代码][源代码]¶: 将 GaussianRational 对象转换为 dtype。

from_GaussianRationalField(a, K0)[源代码][源代码]¶: 将 GaussianRational 对象转换为 dtype。

from_PolynomialRing(a, K0)[源代码][源代码]¶: 将 DMP 对象转换为 dtype。

from_QQ(a, K0)[源代码][源代码]¶: 将 Python Fraction 对象转换为 dtype。

from_QQ_gmpy(a, K0)[源代码][源代码]¶: 将 GMPY 的 mpq 对象转换为 dtype。

from_QQ_python(a, K0)[源代码][源代码]¶: 将 Python Fraction 对象转换为 dtype。

from_RealField(a, K0)[源代码][源代码]¶: 将 mpmath 的 mpf 对象转换为 dtype。

from_ZZ(a, K0)[源代码][源代码]¶: 将 Python int 对象转换为 dtype。

from_ZZ_gmpy(a, K0)[源代码][源代码]¶: 将 GMPY 的 mpz 对象转换为 dtype。

from_ZZ_python(a, K0)[源代码][源代码]¶: 将 Python int 对象转换为 dtype。

from_sympy(a)[源代码][源代码]¶: 将 SymPy 的表达式转换为 dtype。

get_field()[源代码][源代码]¶: 返回与 self 关联的字段。

get_ring()[源代码][源代码]¶: 返回与 self 相关联的环。

is_negative(a)[源代码][源代码]¶: 如果 a 为负数，则返回 True。

is_nonnegative(a)[源代码][源代码]¶: 如果 a 是非负的，则返回 True。

is_nonpositive(a)[源代码][源代码]¶: 如果 a 是非正数，则返回 True。

is_positive(a)[源代码][源代码]¶: 如果 a 为正，则返回 True。

numer(a)[源代码][源代码]¶: 返回 a 的分子。

to_sympy(a)[源代码][源代码]¶: 将 a 转换为 SymPy 对象。

class ExpressionDomain.Expression(ex)[源代码][源代码]¶

一个任意表达式。

属性:

示例

方法

parent()

as_expr
denom
gcd
lcm
numer
简化

商环¶

class sympy.polys.domains.quotientring.QuotientRing(ring, ideal)[源代码][源代码]¶

表示（交换）商环的类。

通常你不应该手动实例化这个对象，而是应该在构造过程中使用基环中的构造函数。

>>> from sympy.abc import x
>>> from sympy import QQ
>>> I = QQ.old_poly_ring(x).ideal(x**3 + 1)
>>> QQ.old_poly_ring(x).quotient_ring(I)
QQ[x]/<x**3 + 1>

可以有更短的版本：

>>> QQ.old_poly_ring(x)/I
QQ[x]/<x**3 + 1>

>>> QQ.old_poly_ring(x)/[x**3 + 1]
QQ[x]/<x**3 + 1>

属性：

ring - 基础环
base_ideal - 用于形成商的理想

属性:

别名
一
rep
tp: 别名 dtype
零

方法

`__call__`(*args)	从 `args` 构造 `self` 域的一个元素。
`abs`(a)	`a` 的绝对值，意味着 `__abs__`。
`add`(a, b)	`a` 和 `b` 的和，意味着 `__add__`。
`alg_field_from_poly`(poly[, alias, root_index])	通过根索引选择多项式的根来构造代数扩展的便捷方法。
`algebraic_field`(*extension[, alias])	返回一个代数数域，即 \(K(\alpha, \ldots)\)。
`almosteq`(a, b[, tolerance])	检查 `a` 和 `b` 是否几乎相等。
`characteristic`()	返回此域的特征。
`cofactors`(a, b)	返回 `a` 和 `b` 的最大公约数和余因子。
`convert`(element[, base])	将 `element` 转换为 `self.dtype`。
`convert_from`(element, base)	在给定的基本域中将 `element` 转换为 `self.dtype`。
`cyclotomic_field`(n[, ss, alias, gen, root_index])	构建分圆域的便捷方法。
`denom`(a)	返回 \(a\) 的分母。
`div`(a, b)	`a` 和 `b` 的除法，意味着 `__divmod__`。
`drop`(*symbols)	从此领域中移除生成器。
`dtype`	`QuotientRingElement` 的别名
`evalf`(a[, prec])	返回 `a` 的数值近似值。
`exquo`(a, b)	`a` 和 `b` 的精确商，意味着 `__floordiv__`。
`exsqrt`(a)	在 `a` 是平方数的域内的主平方根。
`frac_field`(*gens)	返回一个分数域，即 `K(X)`。
`free_module`(rank)	在 `self` 上生成一个秩为 `rank` 的自由模。
`from_AlgebraicField`(a, K0)	将一个代数数转换为 `dtype`。
`from_ComplexField`(a, K0)	将复杂元素转换为 `dtype`。
`from_ExpressionDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_ExpressionRawDomain`(a, K0)	将 `EX` 对象转换为 `dtype`。
`from_FF`(a, K0)	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FF_gmpy`(a, K0)	将 `ModularInteger(mpz)` 转换为 `dtype`。
`from_FF_python`(a, K0)	将 `ModularInteger(int)` 转换为 `dtype`。
`from_FractionField`(a, K0)	将 Python `int` 对象转换为 `dtype`。
`from_GlobalPolynomialRing`(a, K0)	将 Python `int` 对象转换为 `dtype`。
`from_MonogenicFiniteExtension`(a, K0)	将 `ExtensionElement` 转换为 `dtype`。
`from_PolynomialRing`(a, K0)	将多项式转换为 `dtype`。
`from_QQ_gmpy`(a, K0)	将 Python `int` 对象转换为 `dtype`。
`from_QQ_python`(a, K0)	将 Python `int` 对象转换为 `dtype`。
`from_RealField`(a, K0)	将 Python `int` 对象转换为 `dtype`。
`from_ZZ`(a, K0)	将 Python `int` 对象转换为 `dtype`。
`from_ZZ_gmpy`(a, K0)	将 Python `int` 对象转换为 `dtype`。
`from_ZZ_python`(a, K0)	将 Python `int` 对象转换为 `dtype`。
`from_sympy`(a)
`gcd`(a, b)	返回 `a` 和 `b` 的最大公约数。
`gcdex`(a, b)	`a` 和 `b` 的扩展最大公约数。
`get_exact`()	返回与 `self` 关联的精确域。
`get_field`()	返回与 `self` 关联的字段。
`get_ring`()	返回与 `self` 相关联的环。
`half_gcdex`(a, b)	`a` 和 `b` 的半扩展最大公约数。
`ideal`(*gens)	生成一个理想的 `自我`。
`inject`(*symbols)	将生成器注入此域。
`invert`(a, b)	返回 `a mod b` 的逆。
`is_negative`(a)	如果 `a` 为负数，则返回 True。
`is_nonnegative`(a)	如果 `a` 是非负的，则返回 True。
`is_nonpositive`(a)	如果 `a` 是非正数，则返回 True。
`is_one`(a)	如果 `a` 是 1，则返回 True。
`is_positive`(a)	如果 `a` 为正，则返回 True。
`is_square`(a)	返回 `a` 是否是该域中的一个平方数。
`is_zero`(a)
`lcm`(a, b)	返回 `a` 和 `b` 的最小公倍数。
`log`(a, b)	返回 `a` 的 b 进制对数。
`map`(seq)	递归地将 `self` 应用于 `seq` 的所有元素。
`mul`(a, b)	`a` 和 `b` 的乘积，意味着 `__mul__`。
`n`(a[, prec])	返回 `a` 的数值近似值。
`neg`(a)	返回 `a` 的否定值，意味着 `__neg__`。
`new`(a)	从 `a` 构建 `self` 域的一个元素。
`numer`(a)	返回 `a` 的分子。
`of_type`(element)	检查 `a` 是否为 `dtype` 类型。
`old_frac_field`(symbols, *kwargs)	返回一个分数域，即 \(K(X)\)。
`old_poly_ring`(symbols, *kwargs)	返回一个多项式环，即 \(K[X]\)。
`poly_ring`(*gens)	返回一个多项式环，即 `K[X]`。
`pos`(a)	返回 `a` 为正，意味着 `__pos__`。
`pow`(a, b)	将 `a` 提升到 `b` 的幂，意味着 `__pow__`。
`quo`(a, b)	`a` 和 `b` 的商，意味着 `__floordiv__`。
`quotient_ring`(e)	形成 `self` 的商环。
`rem`(a, b)	`a` 和 `b` 的余数，意味着 `__mod__`。
`revert`(a)	计算 a**(-1)，如果可能的话。
`sqrt`(a)	返回 `a` 的（可能不精确的）平方根。
`sub`(a, b)	`a` 和 `b` 的差异，意味着 `__sub__`。
`to_sympy`(a)
`unify`(K1[, symbols])	构建一个包含 `K0` 和 `K1` 元素的最小域。
`unify_composite`(K1)	统一两个领域，其中至少一个是复合的。

canonical_unit
from_GeneralizedPolynomialRing
from_QuotientRing
imag
is_unit
正常
真实
总和
unify_with_symbols

稀疏多项式¶

稀疏多项式表示为字典。

sympy.polys.rings.ring(symbols, domain, order=LexOrder())[源代码][源代码]¶

构建一个多项式环，返回 (ring, x_1, ..., x_n)。

参数:

符号str: 符号/表达式或字符串/符号/表达式序列（非空）
域 : Domain 或可转换的域或可强制转换
order : MonomialOrder 或可强制转换的类型, 可选, 默认为 lexMonomialOrder 或可强制转换的类型，可选，默认为 lex

示例

>>> from sympy.polys.rings import ring
>>> from sympy.polys.domains import ZZ
>>> from sympy.polys.orderings import lex

>>> R, x, y, z = ring("x,y,z", ZZ, lex)
>>> R
Polynomial ring in x, y, z over ZZ with lex order
>>> x + y + z
x + y + z
>>> type(_)
<class 'sympy.polys.rings.PolyElement'>

sympy.polys.rings.xring(symbols, domain, order=LexOrder())[源代码][源代码]¶

构建一个多项式环，返回 (ring, (x_1, ..., x_n))。

参数:

符号str: 符号/表达式或字符串/符号/表达式序列（非空）
域 : Domain 或可转换的域或可强制转换
order : MonomialOrder 或可强制转换的类型, 可选, 默认为 lexMonomialOrder 或可强制转换的类型，可选，默认为 lex

示例

>>> from sympy.polys.rings import xring
>>> from sympy.polys.domains import ZZ
>>> from sympy.polys.orderings import lex

>>> R, (x, y, z) = xring("x,y,z", ZZ, lex)
>>> R
Polynomial ring in x, y, z over ZZ with lex order
>>> x + y + z
x + y + z
>>> type(_)
<class 'sympy.polys.rings.PolyElement'>

sympy.polys.rings.vring(symbols, domain, order=LexOrder())[源代码][源代码]¶

构建一个多项式环并将 x_1, ..., x_n 注入到全局命名空间中。

参数:

符号str: 符号/表达式或字符串/符号/表达式序列（非空）
域 : Domain 或可转换的域或可强制转换
order : MonomialOrder 或可强制转换的类型, 可选, 默认为 lexMonomialOrder 或可强制转换的类型，可选，默认为 lex

示例

>>> from sympy.polys.rings import vring
>>> from sympy.polys.domains import ZZ
>>> from sympy.polys.orderings import lex

>>> vring("x,y,z", ZZ, lex)
Polynomial ring in x, y, z over ZZ with lex order
>>> x + y + z # noqa:
x + y + z
>>> type(_)
<class 'sympy.polys.rings.PolyElement'>

sympy.polys.rings.sring(exprs, *symbols, **options)[源代码][源代码]¶

从选项和输入表达式中构造一个环，推导生成器和域。

参数:

exprs : Expr 或 Expr 的序列 (可符号化)Expr 或 Expr 的序列（可符号化）
符号 : Symbol/Expr 的序列序列
选项 : Options 所理解的键值参数理解的关键字参数

示例

>>> from sympy import sring, symbols

>>> x, y, z = symbols("x,y,z")
>>> R, f = sring(x + 2*y + 3*z)
>>> R
Polynomial ring in x, y, z over ZZ with lex order
>>> f
x + 2*y + 3*z
>>> type(_)
<class 'sympy.polys.rings.PolyElement'>

class sympy.polys.rings.PolyRing(symbols, domain, order=LexOrder())[源代码][源代码]¶

多元分布多项式环。

属性:

领域
生成
is_multivariate
is_univariate
ngens
一
顺序
符号
零

方法

`add`(*objs)	添加一系列多项式或多项式容器。
`add_gens`(symbols)	将 `symbols` 的元素作为生成器添加到 `self`
`compose`(other)	将 `other` 的生成器添加到 `self`
`dmp_zz_diophantine`(F, c, A, d, p)
`dmp_zz_wang_hensel_lifting`(f, H, LC, A, p)
`dmp_zz_wang_lead_coeffs`(f, T, cs, E, H, A)
`dmp_zz_wang_non_divisors`(E, cs, ct)
`drop`(*gens)	从此环中移除指定的生成器。
`drop_to_ground`(*gens)	从环中移除指定的生成器，并将其注入其域中。
`dup_zz_diophantine`(F, m, p)
`index`(gen)	计算 `gen` 在 `self.gens` 中的索引。
`monomial_basis`(i)	返回第 i 个基元素。
`mul`(*objs)	将一系列多项式或多项式容器相乘。
`symmetric_poly`(n)	返回此环生成元上的 n 次初等对称多项式。

__call__
克隆
dmp_LC
dmp_TC
dmp_abs
dmp_add
dmp_add_ground
dmp_add_mul
dmp_add_term
dmp_cancel
dmp_clear_denoms
dmp_compose
dmp_content
dmp_degree
dmp_degree_in
dmp_diff
dmp_diff_eval_in
dmp_diff_in
dmp_discriminant
dmp_div
dmp_euclidean_prs
dmp_eval
dmp_eval_in
dmp_eval_尾
dmp_expand
dmp_exquo
dmp_exquo_ground
dmp_ext_factor
dmp_factor_list
dmp_factor_list_include
dmp_ff_div
dmp_ff_lcm
dmp_ff_prs_gcd
dmp_gcd
dmp_gcdex
dmp_gf_factor
dmp_gf_sqf_list
dmp_gf_sqf_part
dmp_gff_list
dmp_ground_LC
dmp_ground_TC
dmp_ground_content
dmp_ground_extract
dmp_ground_monic
dmp_ground_primitive
dmp_ground_trunc
dmp_half_gcdex
dmp_inner_gcd
dmp_inner_subresultants
dmp_integrate
dmp_integrate_in
dmp_invert
dmp_irreducible_p
dmp_l1_norm
dmp_l2_norm_squared
dmp_lcm
dmp_lift
dmp_max_norm
dmp_mul
dmp_mul_ground
dmp_mul_term
dmp_neg
dmp_norm
dmp_pdiv
dmp_pexquo
dmp_pow
dmp_pquo
dmp_prem
dmp_primitive
dmp_primitive_prs
dmp_prs_resultant
dmp_qq_collins_resultant
dmp_qq_heu_gcd
dmp_qq_i_factor
dmp_quo
dmp_quo_ground
dmp_rem
dmp_resultant
dmp_rr_div
dmp_rr_lcm
dmp_rr_prs_gcd
dmp_shift
dmp_sqf_list
dmp_sqf_list_include
dmp_sqf_norm
dmp_sqf_p
dmp_sqf_part
dmp_sqr
dmp_sub
dmp_sub_ground
dmp_sub_mul
dmp_sub_term
dmp_subresultants
dmp_trial_division
dmp_trunc
dmp_zz_collins_resultant
dmp_zz_factor
dmp_zz_heu_gcd
dmp_zz_i_factor
dmp_zz_mignotte_bound
dmp_zz_modular_resultant
dmp_zz_wang
domain_new
dup_LC
dup_TC
dup_abs
dup_add
dup_add_ground
dup_add_mul
dup_add_term
dup_cancel
dup_clear_denoms
dup_compose
重复内容
dup_count_complex_roots
dup_count_real_roots
dup_cyclotomic_p
dup_decompose
dup_degree
dup_diff
dup_discriminant
dup_div
dup_euclidean_prs
dup_eval
dup_expand
dup_exquo
dup_exquo_ground
dup_ext_factor
dup_extract
dup_factor_list
dup_factor_list_include
dup_ff_div
dup_ff_lcm
dup_ff_prs_gcd
dup_gcd
dup_gcdex
dup_gf_factor
dup_gf_sqf_list
dup_gf_sqf_part
dup_gff_list
dup_half_gcdex
dup_inner_gcd
dup_inner_isolate_negative_roots
dup_inner_isolate_positive_roots
dup_inner_isolate_real_roots
dup_inner_refine_real_root
dup_inner_subresultants
dup_integrate
dup_invert
dup_irreducible_p
dup_isolate_all_roots
dup_isolate_all_roots_sqf
dup_isolate_complex_roots_sqf
dup_isolate_real_roots
dup_isolate_real_roots_list
dup_isolate_real_roots_sqf
dup_l1_norm
dup_l2_norm_squared
dup_lcm
dup_lshift
dup_max_norm
dup_mirror
dup_monic
dup_mul
dup_mul_ground
dup_mul_term
dup_neg
dup_outer_refine_real_root
dup_pdiv
dup_pexquo
dup_pow
dup_pquo
dup_prem
dup_primitive
dup_primitive_prs
dup_prs_resultant
dup_qq_heu_gcd
dup_qq_i_factor
dup_quo
dup_quo_ground
dup_real_imag
dup_refine_real_root
dup_rem
dup_resultant
dup_revert
dup_root_lower_bound
dup_root_upper_bound
dup_rr_div
dup_rr_lcm
dup_rr_prs_gcd
dup_rshift
dup_scale
dup_shift
重复签名变体
dup_sqf_list
dup_sqf_list_include
dup_sqf_norm
dup_sqf_p
dup_sqf_part
dup_sqr
dup_step_refine_real_root
dup_sturm
dup_sub
dup_sub_ground
dup_sub_mul
重复子术语
dup_subresultants
dup_transform
dup_trial_division
dup_trunc
dup_zz_cyclotomic_factor
dup_zz_cyclotomic_poly
dup_zz_factor
dup_zz_factor_sqf
dup_zz_hensel_lift
dup_zz_hensel_step
dup_zz_heu_gcd
dup_zz_i_factor
dup_zz_irreducible_p
dup_zz_mignotte_bound
dup_zz_zassenhaus
fateman_poly_F_1
fateman_poly_F_2
fateman_poly_F_3
from_dense
from_dict
from_expr
from_gf_dense
from_list
from_terms
gf_LC
gf_Qmatrix
gf_TC
gf_add
gf_add_ground
gf_add_mul
gf_berlekamp
gf_cofactors
gf_compose
gf_compose_mod
gf_ddf_shoup
gf_ddf_zassenhaus
gf_degree
gf_diff
gf_div
gf_edf_shoup
gf_edf_zassenhaus
gf_eval
gf_expand
gf_exquo
gf_factor
gf_factor_sqf
gf_from_dict
gf_from_int_poly
gf_gcd
gf_gcdex
gf_irred_p_ben_or
gf_irred_p_rabin
gf_irreducible
gf_irreducible_p
gf_lcm
gf_lshift
gf_monic
gf_mul
gf_mul_ground
gf_multi_eval
gf_neg
gf_normal
gf_pow
gf_pow_mod
gf_quo
gf_quo_ground
gf_random
gf_rem
gf_rshift
gf_shoup
gf_sqf_list
gf_sqf_p
gf_sqf_part
gf_sqr
gf_strip
gf_sub
gf_sub_ground
gf_sub_mul
gf_to_dict
gf_to_int_poly
gf_trace_map
gf_trunc
gf_zassenhaus
ground_new
ring_new
term_new
to_dense
to_domain
to_field
to_gf_dense
to_ground
包裹

add(*objs)[源代码][源代码]¶

添加一系列多项式或多项式容器。

示例

>>> from sympy.polys.rings import ring
>>> from sympy.polys.domains import ZZ

>>> R, x = ring("x", ZZ)
>>> R.add([ x**2 + 2*i + 3 for i in range(4) ])
4*x**2 + 24
>>> _.factor_list()
(4, [(x**2 + 6, 1)])

add_gens(symbols)[源代码][源代码]¶: 将 symbols 的元素作为生成器添加到 self

compose(other)[源代码][源代码]¶: 将 other 的生成器添加到 self

drop(*gens)[源代码][源代码]¶: 从此环中移除指定的生成器。

drop_to_ground(*gens)[源代码][源代码]¶: 从环中移除指定的生成器，并将其注入其域中。

index(gen)[源代码][源代码]¶: 计算 gen 在 self.gens 中的索引。

monomial_basis(i)[源代码][源代码]¶: 返回第 i 个基元素。

mul(*objs)[源代码][源代码]¶

将一系列多项式或多项式容器相乘。

示例

>>> from sympy.polys.rings import ring
>>> from sympy.polys.domains import ZZ

>>> R, x = ring("x", ZZ)
>>> R.mul([ x**2 + 2*i + 3 for i in range(4) ])
x**8 + 24*x**6 + 206*x**4 + 744*x**2 + 945
>>> _.factor_list()
(1, [(x**2 + 3, 1), (x**2 + 5, 1), (x**2 + 7, 1), (x**2 + 9, 1)])

symmetric_poly(n)[源代码][源代码]¶: 返回此环生成元上的 n 次初等对称多项式。

class sympy.polys.rings.PolyElement[源代码][源代码]¶

多元分布多项式环的元素。

属性:

LC
LM
LT
is_cyclotomic
is_generator
is_ground
is_irreducible
is_linear
is_monic
is_monomial
is_negative
is_nonnegative
is_nonpositive
是_一个
is_positive
is_primitive
is_quadratic
is_squarefree
is_term
is_zero

方法

`__call__`(*values)
`almosteq`(p2[, tolerance])	多项式的近似相等测试。
`cancel`(g)	在有理函数 `f/g` 中消去公因子。
`clear`()
`coeff`(element)	返回给定单项式旁边的系数。
`coeff_wrt`(x, deg)	`self` 相对于 `x**deg` 的系数。
`coeffs`([order])	多项式系数的顺序列表。
`const`()	返回常数系数。
`content`()	返回多项式系数的最大公约数。
`copy`()	返回多项式 self 的副本。
`degree`([x])	`x` 中的领先次数或主要变量。
`degrees`()	包含所有变量的前导度的元组。
`diff`(x)	计算 `x` 中的偏导数。
`div`(fv)	除法算法，参见 [CLO] p64。
`fromkeys`(iterable[, value])	使用可迭代对象中的键创建一个新字典，并将值设置为指定的值。
`get`(key[, default])	如果字典中存在键，则返回键的值，否则返回默认值。
`imul_num`(c)	在系数环中，如果多项式 p 不是生成元之一，则就地将其乘以一个元素；否则不就地相乘。
`items`()
`itercoeffs`()	遍历多项式的系数。
`itermonoms`()	遍历多项式的单项式。
`iterterms`()	遍历多项式的项。
`keys`()
`leading_expv`()	根据单项式排序的领先单项式元组。
`leading_monom`()	作为多项式元素的领先单项式。
`leading_term`()	作为多项式元素的领先项。
`listcoeffs`()	多项式系数的无序列表。
`listmonoms`()	多项式单项式的无序列表。
`listterms`()	多项式项的无序列表。
`monic`()	将所有系数除以首项系数。
`monoms`([order])	多项式单项式的有序列表。
`parent`()
`pdiv`(g[, x])	计算多项式 `self` 相对于 `g` 的伪除法。
`pexquo`(g[, x])	多元多项式环中的多项式精确伪商。
`pop`(key[, default])	如果未找到键，则返回给定的默认值；否则，引发 KeyError。
`popitem`(/)	移除并返回一个 (键, 值) 对作为 2-tuple。
`pquo`(g[, x])	多元多项式环中的多项式伪商。
`prem`(g[, x])	多项式 `self` 相对于 `g` 的伪余数。
`primitive`()	返回内容和一个原始多项式。
`setdefault`(key[, default])	如果字典中不存在键，则插入键并赋予默认值。
`square`()	多项式的平方
`strip_zero`()	消除系数为零的单项式。
`subresultants`(g[, x])	计算两个多项式 `self` 和 `g` 的子结果PRS。
`symmetrize`()	用基本对称多项式重写 self。
`tail_degree`([x])	`x` 中的尾次数或主变量。
`tail_degrees`()	包含所有变量中尾度的元组。
`terms`([order])	多项式项的有序列表。
`update`([E, ]**F)	如果 E 存在且有 .keys() 方法，则执行： for k in E: D[k] = E[k] 如果 E 存在但没有 .keys() 方法，则执行： for k, v in E: D[k] = v 在任何一种情况下，之后都会执行： for k in F: D[k] = F[k]
`values`()

as_expr
as_expr_dict
canonical_unit
clear_denoms
辅因子
组合
分解
deflate
判别式
删除
drop_to_ground
评估
exquo
提取地面
因子列表
gcd
gcdex
gff_list
half_gcdex
膨胀
l1_norm
lcm
max_norm
mul_ground
mul_monom
mul_term
新
规范
quo
quo_ground
quo_term
rem
rem_ground
结果
设置环
shift
shift_list
sort_key
sqf_list
sqf_norm
sqf_part
str
sturm
subs
to_dense
to_dict
trunc_ground

almosteq(p2, tolerance=None)[源代码][源代码]¶: 多项式的近似相等测试。

cancel(g)[源代码][源代码]¶

在有理函数 f/g 中消去公因子。

示例

>>> from sympy.polys import ring, ZZ
>>> R, x,y = ring("x,y", ZZ)

>>> (2*x**2 - 2).cancel(x**2 - 2*x + 1)
(2*x + 2, x - 1)

coeff(element)[源代码][源代码]¶

返回给定单项式旁边的系数。

参数:

元素 : PolyElement (带有 is_monomial = True) 或 1PolyElement (

示例

>>> from sympy.polys.rings import ring
>>> from sympy.polys.domains import ZZ

>>> _, x, y, z = ring("x,y,z", ZZ)
>>> f = 3*x**2*y - x*y*z + 7*z**3 + 23

>>> f.coeff(x**2*y)
3
>>> f.coeff(x*y)
0
>>> f.coeff(1)
23

coeff_wrt(x, deg)[源代码][源代码]¶

self 相对于 x**deg 的系数。

将 self 视为 x 中的单变量多项式，这会找到作为其他生成器中多项式的 x**deg 的系数。

参数:

x生成器或生成器索引: 用于计算表达式的生成器或生成器索引。
度整数: 计算表达式所需的多项式的次数。

返回:

PolyElement: 作为同一环中的多项式，x**deg 的系数。

参见

coeff, coeffs

示例

>>> from sympy.polys import ring, ZZ
>>> R, x, y, z = ring("x, y, z", ZZ)

>>> p = 2*x**4 + 3*y**4 + 10*z**2 + 10*x*z**2
>>> deg = 2
>>> p.coeff_wrt(2, deg) # Using the generator index
10*x + 10
>>> p.coeff_wrt(z, deg) # Using the generator
10*x + 10
>>> p.coeff(z**2) # shows the difference between coeff and coeff_wrt
10

coeffs(order=None)[源代码][源代码]¶

多项式系数的顺序列表。

参数:

顺序 : MonomialOrder 或可强制转换的, 可选单项式顺序或可强制转换，可选

示例

>>> from sympy.polys.rings import ring
>>> from sympy.polys.domains import ZZ
>>> from sympy.polys.orderings import lex, grlex

>>> _, x, y = ring("x, y", ZZ, lex)
>>> f = x*y**7 + 2*x**2*y**3

>>> f.coeffs()
[2, 1]
>>> f.coeffs(grlex)
[1, 2]

const()[源代码][源代码]¶: 返回常数系数。

content()[源代码][源代码]¶: 返回多项式系数的最大公约数。

copy()[源代码][源代码]¶

返回多项式 self 的副本。

多项式是可变的；如果有人对保留一个多项式感兴趣，并且计划使用就地操作，可以复制该多项式。此方法生成一个浅拷贝。

示例

>>> from sympy.polys.domains import ZZ
>>> from sympy.polys.rings import ring

>>> R, x, y = ring('x, y', ZZ)
>>> p = (x + y)**2
>>> p1 = p.copy()
>>> p2 = p
>>> p[R.zero_monom] = 3
>>> p
x**2 + 2*x*y + y**2 + 3
>>> p1
x**2 + 2*x*y + y**2
>>> p2
x**2 + 2*x*y + y**2 + 3

degree(x=None)[源代码][源代码]¶

x 中的领先次数或主要变量。

注意，0 度是负无穷大（float('-inf')）

degrees()[源代码][源代码]¶

包含所有变量的前导度的元组。

注意，0 度是负无穷大（float('-inf')）

diff(x)[源代码][源代码]¶

计算 x 中的偏导数。

示例

>>> from sympy.polys.rings import ring
>>> from sympy.polys.domains import ZZ

>>> _, x, y = ring("x,y", ZZ)
>>> p = x + x**2*y**3
>>> p.diff(x)
2*x*y**3 + 1

div(fv)[源代码][源代码]¶

除法算法，参见 [CLO] p64。

多项式数组 fv: 返回 qv, r 使得 self = sum(fv[i]*qv[i]) + r

所有多项式都要求不是Laurent多项式。

示例

>>> from sympy.polys.rings import ring
>>> from sympy.polys.domains import ZZ

>>> _, x, y = ring('x, y', ZZ)
>>> f = x**3
>>> f0 = x - y**2
>>> f1 = x - y
>>> qv, r = f.div((f0, f1))
>>> qv[0]
x**2 + x*y**2 + y**4
>>> qv[1]
0
>>> r
y**6

imul_num(c)[源代码][源代码]¶

在系数环中，如果多项式 p 不是生成元之一，则就地将其乘以一个元素；否则不就地相乘。

示例

>>> from sympy.polys.rings import ring
>>> from sympy.polys.domains import ZZ

>>> _, x, y = ring('x, y', ZZ)
>>> p = x + y**2
>>> p1 = p.imul_num(3)
>>> p1
3*x + 3*y**2
>>> p1 is p
True
>>> p = x
>>> p1 = p.imul_num(3)
>>> p1
3*x
>>> p1 is p
False

itercoeffs()[源代码][源代码]¶: 遍历多项式的系数。

itermonoms()[源代码][源代码]¶: 遍历多项式的单项式。

iterterms()[源代码][源代码]¶: 遍历多项式的项。

leading_expv()[源代码][源代码]¶

根据单项式排序的领先单项式元组。

示例

>>> from sympy.polys.rings import ring
>>> from sympy.polys.domains import ZZ

>>> _, x, y, z = ring('x, y, z', ZZ)
>>> p = x**4 + x**3*y + x**2*z**2 + z**7
>>> p.leading_expv()
(4, 0, 0)

leading_monom()[源代码][源代码]¶

作为多项式元素的领先单项式。

示例

>>> from sympy.polys.rings import ring
>>> from sympy.polys.domains import ZZ

>>> _, x, y = ring('x, y', ZZ)
>>> (3*x*y + y**2).leading_monom()
x*y

leading_term()[源代码][源代码]¶

作为多项式元素的领先项。

示例

>>> from sympy.polys.rings import ring
>>> from sympy.polys.domains import ZZ

>>> _, x, y = ring('x, y', ZZ)
>>> (3*x*y + y**2).leading_term()
3*x*y

listcoeffs()[源代码][源代码]¶: 多项式系数的无序列表。

listmonoms()[源代码][源代码]¶: 多项式单项式的无序列表。

listterms()[源代码][源代码]¶: 多项式项的无序列表。

monic()[源代码][源代码]¶: 将所有系数除以首项系数。

monoms(order=None)[源代码][源代码]¶

多项式单项式的有序列表。

参数:

顺序 : MonomialOrder 或可强制转换的, 可选单项式顺序或可强制转换，可选

示例

>>> from sympy.polys.rings import ring
>>> from sympy.polys.domains import ZZ
>>> from sympy.polys.orderings import lex, grlex

>>> _, x, y = ring("x, y", ZZ, lex)
>>> f = x*y**7 + 2*x**2*y**3

>>> f.monoms()
[(2, 3), (1, 7)]
>>> f.monoms(grlex)
[(1, 7), (2, 3)]

pdiv(g, x=None)[源代码][源代码]¶

计算多项式 self 相对于 g 的伪除法。

伪除法算法用于找到伪商 q 和伪余数 r ，使得 m*f = g*q + r ，其中 m 表示乘数，f 是被除多项式。

伪商 q 和伪余数 r 是变量 x 中的多项式，其中 r 相对于 x 的次数严格小于 g 相对于 x 的次数。

乘数 m 定义为 LC(g, x) ^ (deg(f, x) - deg(g, x) + 1)，其中 LC(g, x) 表示 g 的首项系数。

需要注意的是，在 prem 方法的上下文中，环中的多元多项式，如 R[x,y,z]，被视为系数为多项式的单变量多项式，如 R[x,y][z]。当用变量 z 对 f 除以 g 时，伪商 q 和伪余数 r 满足 m*f = g*q + r，其中 deg(r, z) < deg(g, z) 且 m = LC(g, z)^(deg(f, z) - deg(g, z) + 1)。

在这个函数中，伪余数 r 可以通过 prem 方法获得，伪商 q 可以通过 pquo 方法获得，而函数 pdiv 本身返回一个元组 (q, r)。

参数:

gPolyElement: 要除以 self 的多项式。
x生成器或生成器索引，可选: 多项式的主变量和默认值是第一个生成器。

返回:

PolyElement: 伪除法多项式（q 和 r 的元组）。

Raises:

ZeroDivisionError : 如果 g 是零多项式。如果

参见

prem: 比 \(f.pdiv(g)[1]\) 更高效地计算伪余数。
pquo: 仅返回伪商。
pexquo: 仅返回一个没有余数的精确伪商。
div: 返回多项式 f 和 g 的商和余数。

示例

>>> from sympy.polys import ring, ZZ
>>> R, x, y = ring("x, y", ZZ)

>>> f = x**2 + x*y
>>> g = 2*x + 2
>>> f.pdiv(g) # first generator is chosen by default if it is not given
(2*x + 2*y - 2, -4*y + 4)
>>> f.div(g) # shows the difference between pdiv and div
(0, x**2 + x*y)
>>> f.pdiv(g, y) # generator is given
(2*x**3 + 2*x**2*y + 6*x**2 + 2*x*y + 8*x + 4, 0)
>>> f.pdiv(g, 1) # generator index is given
(2*x**3 + 2*x**2*y + 6*x**2 + 2*x*y + 8*x + 4, 0)

pexquo(g, x=None)[源代码][源代码]¶

多元多项式环中的多项式精确伪商。

参见

prem, pdiv, pquo, sympy.polys.domains.ring.Ring.exquo

示例

>>> from sympy.polys import ring, ZZ
>>> R, x,y = ring("x,y", ZZ)

>>> f = x**2 + x*y
>>> g = 2*x + 2*y
>>> h = 2*x + 2
>>> f.pexquo(g)
2*x
>>> f.exquo(g) # shows the differnce between pexquo and exquo
Traceback (most recent call last):
...
ExactQuotientFailed: 2*x + 2*y does not divide x**2 + x*y
>>> f.pexquo(h)
Traceback (most recent call last):
...
ExactQuotientFailed: 2*x + 2 does not divide x**2 + x*y

pquo(g, x=None)[源代码][源代码]¶

多元多项式环中的多项式伪商。

参见

prem, pdiv, pexquo, sympy.polys.domains.ring.Ring.quo

示例

>>> from sympy.polys import ring, ZZ
>>> R, x,y = ring("x,y", ZZ)

>>> f = x**2 + x*y
>>> g = 2*x + 2*y
>>> h = 2*x + 2
>>> f.pquo(g)
2*x
>>> f.quo(g) # shows the difference between pquo and quo
0
>>> f.pquo(h)
2*x + 2*y - 2
>>> f.quo(h) # shows the difference between pquo and quo
0

prem(g, x=None)[源代码][源代码]¶

多项式 self 相对于 g 的伪余数。

当用 g 除以 f 时，关于 z 的伪商 q 和伪余数 r 满足 m*f = g*q + r，其中 deg(r,z) < deg(g,z) 且 m = LC(g,z)**(deg(f,z) - deg(g,z)+1)。

关于伪除法的解释，请参见 pdiv()。

参数:

gPolyElement: 要除以 self 的多项式。
x生成器或生成器索引，可选: 多项式的主变量和默认值是第一个生成器。

返回:

PolyElement: 伪余数多项式。

Raises:

ZeroDivisionError : 如果 g 是零多项式。如果

参见

pdiv, pquo, pexquo, sympy.polys.domains.ring.Ring.rem

示例

>>> from sympy.polys import ring, ZZ
>>> R, x, y = ring("x, y", ZZ)

>>> f = x**2 + x*y
>>> g = 2*x + 2
>>> f.prem(g) # first generator is chosen by default if it is not given
-4*y + 4
>>> f.rem(g) # shows the differnce between prem and rem
x**2 + x*y
>>> f.prem(g, y) # generator is given
0
>>> f.prem(g, 1) # generator index is given
0

primitive()[源代码][源代码]¶: 返回内容和一个原始多项式。

square()[源代码][源代码]¶

多项式的平方

示例

>>> from sympy.polys.rings import ring
>>> from sympy.polys.domains import ZZ

>>> _, x, y = ring('x, y', ZZ)
>>> p = x + y**2
>>> p.square()
x**2 + 2*x*y**2 + y**4

strip_zero()[源代码][源代码]¶: 消除系数为零的单项式。

subresultants(g, x=None)[源代码][源代码]¶

计算两个多项式 self 和 g 的子结果PRS。

参数:

gPolyElement: 第二个多项式。
x生成器或生成器索引: 计算子结果序列所依据的变量。

返回:

R列表: 返回一个表示子结式PRS的多项式列表。

示例

>>> from sympy.polys import ring, ZZ
>>> R, x, y = ring("x, y", ZZ)

>>> f = x**2*y + x*y
>>> g = x + y
>>> f.subresultants(g) # first generator is chosen by default if not given
[x**2*y + x*y, x + y, y**3 - y**2]
>>> f.subresultants(g, 0) # generator index is given
[x**2*y + x*y, x + y, y**3 - y**2]
>>> f.subresultants(g, y) # generator is given
[x**2*y + x*y, x + y, x**3 + x**2]

symmetrize()[源代码][源代码]¶

用基本对称多项式重写 self。

返回:

三元组 (p, r, m)

p 是一个 PolyElement，它代表了我们尝试将 self 表示为基本对称多项式函数的尝试。p 中的每个变量代表一个基本对称多项式。对应关系由 m 给出。

r 是余数。

m 是一个对列表，给出了从 p 中的变量到初等对称多项式的映射。

三元组满足方程 p.compose(m) + r == self。如果余数 r 为零，则 self 是对称的。如果它非零，我们无法将 self 表示为对称的。

参见

sympy.polys.polyfuncs.symmetrize

参考文献

[1]

Lauer, E. 对称多项式的算法, Proc. 1976 ACM 符号与代数计算研讨会, NY 242-247. https://dl.acm.org/doi/pdf/10.1145/800205.806342

示例

>>> from sympy.polys.rings import ring
>>> from sympy.polys.domains import ZZ
>>> R, x, y = ring("x,y", ZZ)

>>> f = x**2 + y**2
>>> f.symmetrize()
(x**2 - 2*y, 0, [(x, x + y), (y, x*y)])

>>> f = x**2 - y**2
>>> f.symmetrize()
(x**2 - 2*y, -2*y**2, [(x, x + y), (y, x*y)])

tail_degree(x=None)[源代码][源代码]¶

x 中的尾次数或主变量。

注意，0 度是负无穷大（float('-inf')）

tail_degrees()[源代码][源代码]¶

包含所有变量中尾度的元组。

注意，0 度是负无穷大（float('-inf')）

terms(order=None)[源代码][源代码]¶

多项式项的有序列表。

参数:

顺序 : MonomialOrder 或可强制转换的, 可选单项式顺序或可强制转换，可选

示例

>>> from sympy.polys.rings import ring
>>> from sympy.polys.domains import ZZ
>>> from sympy.polys.orderings import lex, grlex

>>> _, x, y = ring("x, y", ZZ, lex)
>>> f = x*y**7 + 2*x**2*y**3

>>> f.terms()
[((2, 3), 2), ((1, 7), 1)]
>>> f.terms(grlex)
[((1, 7), 1), ((2, 3), 2)]

稀疏有理函数¶

稀疏多项式表示为字典。

sympy.polys.fields.field(symbols, domain, order=LexOrder())[源代码][源代码]¶: 构造新的有理函数域，返回 (域, x1, …, xn)。

sympy.polys.fields.xfield(symbols, domain, order=LexOrder())[源代码][源代码]¶: 构造新的有理函数域，返回 (域, (x1, …, xn))。

sympy.polys.fields.vfield(symbols, domain, order=LexOrder())[源代码][源代码]¶: 构建新的有理函数域并将生成器注入全局命名空间。

sympy.polys.fields.sfield(exprs, *symbols, **options)[源代码][源代码]¶

根据选项和输入表达式构造一个字段派生生成器和域。

参数:

exprs : Expr 或 Expr 的序列 (可符号化)py:class:\(~.Expr\) or sequence of Expr (sympifiable)
符号 : Symbol/Expr 的序列序列
选项 : 由 Options 理解的键值参数理解的关键字参数

示例

>>> from sympy import exp, log, symbols, sfield

>>> x = symbols("x")
>>> K, f = sfield((x*log(x) + 4*x**2)*exp(1/x + log(x)/3)/x**2)
>>> K
Rational function field in x, exp(1/x), log(x), x**(1/3) over ZZ with lex order
>>> f
(4*x**2*(exp(1/x)) + x*(exp(1/x))*(log(x)))/((x**(1/3))**5)

class sympy.polys.fields.FracField(symbols, domain, order=LexOrder())[源代码][源代码]¶

多元分布有理函数域。

方法

__call__
domain_new
field_new
from_expr
ground_new
索引
新
raw_new
to_domain
to_ring

class sympy.polys.fields.FracElement(numer, denom=None)[源代码][源代码]¶

多元分布有理函数域的元素。

方法

`__call__`(*values)
`diff`(x)	计算 `x` 中的偏导数。
`parent`()

as_expr
组合
复制
评估
新
raw_new
set_field
sort_key
subs
to_poly

diff(x)[源代码][源代码]¶

计算 x 中的偏导数。

示例

>>> from sympy.polys.fields import field
>>> from sympy.polys.domains import ZZ

>>> _, x, y, z = field("x,y,z", ZZ)
>>> ((x**2 + y)/(z + 1)).diff(x)
2*x/(z + 1)

稠密多项式¶

class sympy.polys.polyclasses.DMP(rep, dom, lev=None)[源代码][源代码]¶

\(K\) 上的稠密多元多项式。

属性:

is_cyclotomic: 如果 f 是分圆多项式，则返回 True。
is_ground: 如果 f 是基域的一个元素，则返回 True。
is_homogeneous: 如果 f 是齐次多项式，则返回 True。
is_irreducible: 如果 f 在其定义域内没有因子，则返回 True。
is_linear: 如果 f 在其所有变量中线性，则返回 True。
is_monic: 如果 f 的首项系数为1，则返回 True。
is_monomial: 如果 f 为零或仅有一个项，则返回 True。
is_one: 如果 f 是一个单位多项式，则返回 True。
is_primitive: 如果 f 的系数的最大公约数为 1，则返回 True。
is_quadratic: 如果 f 在其所有变量中都是二次的，则返回 True。
is_sqf: 如果 f 是一个无平方多项式，则返回 True。
is_zero: 如果 f 是零多项式，则返回 True。
rep: 获取 f 的表示。

方法

`LC`()	返回 `f` 的首项系数。
`TC`()	返回 `f` 的尾系数。
`abs`()	使 `f` 中的所有系数为正。
`add`(g)	添加两个多元多项式 `f` 和 `g`。
`add_ground`(c)	将一个地面域的元素添加到 `f` 中。
`all_coeffs`()	返回 `f` 中的所有系数。
`all_monoms`()	返回 `f` 中的所有单项式。
`all_terms`()	返回 `f` 中的所有术语。
`cancel`(g[, include])	在有理函数 `f/g` 中消去公因子。
`cauchy_lower_bound`()	计算多项式 `f` 的非零根的柯西下界。
`cauchy_upper_bound`()	计算多项式 `f` 根的柯西上界。
`clear_denoms`()	清除分母，但保持基础域。
`coeffs`([order])	返回 `f` 中按字典顺序排列的所有非零系数。
`cofactors`(g)	返回 `f` 和 `g` 的最大公约数及其余因子。
`compose`(g)	计算 `f` 和 `g` 的函数组合。
`content`()	返回多项式系数的最大公约数。
`convert`(dom)	将 `f` 转换为新域上的 `DMP`。
`count_complex_roots`([inf, sup])	返回 `f` 在 `[inf, sup]` 中的复数根的数量。
`count_real_roots`([inf, sup])	返回 `f` 在 `[inf, sup]` 中的实根数量。
`decompose`()	计算 `f` 的功能分解。
`deflate`()	通过将 \(x_i^m\) 映射到 \(y_i\) 来降低 \(f\) 的次数。
`degree`([j])	返回 `f` 在 `x_j` 中的前导次数。
`degree_list`()	返回 `f` 的度数列表。
`diff`([m, j])	计算 `f` 在 `x_j` 处的 `m` 阶导数。
`discriminant`()	计算 `f` 的判别式。
`div`(g)	多项式 `f` 和 `g` 的带余除法。
`eject`(dom[, front])	将选定的生成器弹出到地面领域。
`eval`(a[, j])	在 `x_j` 中的给定点 `a` 处计算 `f`。
`exclude`()	从 `f` 中移除无用的生成器。
`exquo`(g)	计算多项式 `f` 和 `g` 的精确商。
`exquo_ground`(c)	`f` 除以基域中一个元素的精确商。
`factor_list`()	返回 `f` 的不可约因子列表。
`factor_list_include`()	返回 `f` 的不可约因子列表。
`from_list`(rep, lev, dom)	根据一组本机系数创建 `cls` 的实例。
`from_sympy_list`(rep, lev, dom)	给定一个SymPy系数列表，创建一个``cls``的实例。
`gcd`(g)	返回多项式 `f` 和 `g` 的最大公约数。
`gcdex`(g)	扩展欧几里得算法，如果是一元的话。
`gff_list`()	计算 `f` 的最大阶乘分解。
`ground_new`(coeff)	构造 `f` 的新地面实例。
`half_gcdex`(g)	半扩展欧几里得算法，如果是一元的话。
`homogeneous_order`()	返回 `f` 的齐次阶。
`homogenize`(s)	返回 `f` 的齐次多项式
`inject`([front])	将地面域生成器注入 `f`。
`integrate`([m, j])	计算 `f` 在 `x_j` 中的第 `m` 阶不定积分。
`intervals`([all, eps, inf, sup, fast, sqf])	计算多项式 `f` 的根的隔离区间。
`invert`(g)	如果可能，对 `f` 模 `g` 取反。
`l1_norm`()	返回 `f` 的 l1 范数。
`l2_norm_squared`()	返回 `f` 的平方 l2 范数。
`lcm`(g)	返回多项式 `f` 和 `g` 的最小公倍数。
`lift`()	将代数系数转换为有理数。
`max_norm`()	返回 `f` 的最大范数。
`mignotte_sep_bound_squared`()	计算 `f` 的根分离的平方 Mignotte 界。
`monic`()	将所有系数除以 `LC(f)`。
`monoms`([order])	返回 `f` 中按字典顺序排列的所有非零单项式。
`mul`(g)	将两个多元多项式 `f` 和 `g` 相乘。
`mul_ground`(c)	将 `f` 乘以基域的一个元素。
`neg`()	在 `f` 中否定所有系数。
`norm`()	计算 `Norm(f)`。
`nth`(*N)	返回 `f` 的第 `n` 个系数。
`pdiv`(g)	多项式伪除法 `f` 和 `g`。
`permute`(P)	返回一个多项式在 \(K[x_{P(1)}, ..., x_{P(n)}]\) 中。
`pexquo`(g)	多项式 `f` 和 `g` 的精确伪商。
`pow`(n)	将 `f` 提升到一个非负的幂 `n`。
`pquo`(g)	`f` 和 `g` 的多项式伪商。
`prem`(g)	多项式 `f` 和 `g` 的伪余数。
`primitive`()	返回内容和 `f` 的原始形式。
`quo`(g)	计算多项式 `f` 和 `g` 的商。
`quo_ground`(c)	`f` 除以基域中一个元素的商。
`refine_root`(s, t[, eps, steps, fast])	将隔离区间细化到给定的精度。
`rem`(g)	计算多项式 `f` 和 `g` 的余数。
`resultant`(g[, includePRS])	通过PRS计算 `f` 和 `g` 的结果。
`revert`(n)	计算 `f(-1)` 模 `xn`。
`shift`(a)	高效计算泰勒位移 `f(x + a)`。
`shift_list`(a)	高效计算泰勒位移 `f(X + A)`。
`slice`(m, n[, j])	取 `f` 的连续子序列项。
`sqf_list`([all])	返回 `f` 的无平方因子的列表。
`sqf_list_include`([all])	返回 `f` 的无平方因子的列表。
`sqf_norm`()	计算 `f` 的无平方范数。
`sqf_part`()	计算 `f` 的无平方部分。
`sqr`()	对多元多项式 `f` 进行平方。
`sturm`()	计算 `f` 的 Sturm 序列。
`sub`(g)	减去两个多元多项式 `f` 和 `g`。
`sub_ground`(c)	从 `f` 中减去地面域的一个元素。
`subresultants`(g)	计算 `f` 和 `g` 的子结果PRS序列。
`terms`([order])	返回 `f` 中按字典顺序排列的所有非零项。
`terms_gcd`()	从多项式 `f` 中去除各项的最大公约数。
`to_best`()	如果可能，转换为 DUP_Flint。
`to_dict`([zero])	将 `f` 转换为带有原生系数的字典表示形式。
`to_exact`()	使基础域精确。
`to_field`()	将基础域设为一个域。
`to_list`()	将 `f` 转换为带有原生系数的列表表示。
`to_ring`()	将基础域设为一个环。
`to_sympy_dict`([zero])	将 `f` 转换为带有 SymPy 系数的字典表示形式。
`to_sympy_list`()	将 `f` 转换为带有 SymPy 系数的列表表示形式。
`to_tuple`()	将 `f` 转换为包含本机系数的元组表示形式。
`total_degree`()	返回 `f` 的总次数。
`transform`(p, q)	评估函数变换 `q*n f(p/q)`。
`trunc`(p)	将 `f` 对常数 `p` 取模。
`unify_DMP`(g)	统一并返回 `f` 和 `g` 的 `DMP` 实例。

eq
from_dict
from_monoms_coeffs
不
新
一
零

LC()[源代码][源代码]¶: 返回 f 的首项系数。

TC()[源代码][源代码]¶: 返回 f 的尾系数。

abs()[源代码][源代码]¶: 使 f 中的所有系数为正。

add(g)[源代码][源代码]¶: 添加两个多元多项式 f 和 g。

add_ground(c)[源代码][源代码]¶: 将一个地面域的元素添加到 f 中。

all_coeffs()[源代码][源代码]¶: 返回 f 中的所有系数。

all_monoms()[源代码][源代码]¶: 返回 f 中的所有单项式。

all_terms()[源代码][源代码]¶: 返回 f 中的所有术语。

cancel(g, include=True)[源代码][源代码]¶: 在有理函数 f/g 中消去公因子。

cauchy_lower_bound()[源代码][源代码]¶: 计算多项式 f 的非零根的柯西下界。

cauchy_upper_bound()[源代码][源代码]¶: 计算多项式 f 根的柯西上界。

clear_denoms()[源代码][源代码]¶: 清除分母，但保持基础域。

coeffs(order=None)[源代码][源代码]¶: 返回 f 中按字典顺序排列的所有非零系数。

cofactors(g)[源代码][源代码]¶: 返回 f 和 g 的最大公约数及其余因子。

compose(g)[源代码][源代码]¶: 计算 f 和 g 的函数组合。

content()[源代码][源代码]¶: 返回多项式系数的最大公约数。

convert(dom)[源代码][源代码]¶: 将 f 转换为新域上的 DMP。

count_complex_roots(inf=None, sup=None)[源代码][源代码]¶: 返回 f 在 [inf, sup] 中的复数根的数量。

count_real_roots(inf=None, sup=None)[源代码][源代码]¶: 返回 f 在 [inf, sup] 中的实根数量。

decompose()[源代码][源代码]¶: 计算 f 的功能分解。

deflate()[源代码][源代码]¶: 通过将 \(x_i^m\) 映射到 \(y_i\) 来降低 \(f\) 的次数。

degree(j=0)[源代码][源代码]¶: 返回 f 在 x_j 中的前导次数。

degree_list()[源代码][源代码]¶: 返回 f 的度数列表。

diff(m=1, j=0)[源代码][源代码]¶: 计算 f 在 x_j 处的 m 阶导数。

discriminant()[源代码][源代码]¶: 计算 f 的判别式。

div(g)[源代码][源代码]¶: 多项式 f 和 g 的带余除法。

eject(dom, front=False)[源代码][源代码]¶: 将选定的生成器弹出到地面领域。

eval(a, j=0)[源代码][源代码]¶: 在 x_j 中的给定点 a 处计算 f。

exclude()[源代码][源代码]¶

从 f 中移除无用的生成器。

返回被移除的生成器和新排除的 f。

示例

>>> from sympy.polys.polyclasses import DMP
>>> from sympy.polys.domains import ZZ

>>> DMP([[[ZZ(1)]], [[ZZ(1)], [ZZ(2)]]], ZZ).exclude()
([2], DMP_Python([[1], [1, 2]], ZZ))

exquo(g)[源代码][源代码]¶: 计算多项式 f 和 g 的精确商。

exquo_ground(c)[源代码][源代码]¶: f 除以基域中一个元素的精确商。

factor_list()[源代码][源代码]¶: 返回 f 的不可约因子列表。

factor_list_include()[源代码][源代码]¶: 返回 f 的不可约因子列表。

classmethod from_list(rep, lev, dom)[源代码][源代码]¶: 根据一组本机系数创建 cls 的实例。

classmethod from_sympy_list(rep, lev, dom)[源代码][源代码]¶: 给定一个SymPy系数列表，创建一个``cls``的实例。

gcd(g)[源代码][源代码]¶: 返回多项式 f 和 g 的最大公约数。

gcdex(g)[源代码][源代码]¶: 扩展欧几里得算法，如果是一元的话。

gff_list()[源代码][源代码]¶: 计算 f 的最大阶乘分解。

ground_new(coeff)[源代码][源代码]¶: 构造 f 的新地面实例。

half_gcdex(g)[源代码][源代码]¶: 半扩展欧几里得算法，如果是一元的话。

homogeneous_order()[源代码][源代码]¶: 返回 f 的齐次阶。

homogenize(s)[源代码][源代码]¶: 返回 f 的齐次多项式

inject(front=False)[源代码][源代码]¶: 将地面域生成器注入 f。

integrate(m=1, j=0)[源代码][源代码]¶: 计算 f 在 x_j 中的第 m 阶不定积分。

intervals( all=False, eps=None, inf=None, sup=None, fast=False, sqf=False, )[源代码][源代码]¶: 计算多项式 f 的根的隔离区间。

invert(g)[源代码][源代码]¶: 如果可能，对 f 模 g 取反。

property is_cyclotomic¶: 如果 f 是分圆多项式，则返回 True。

property is_ground¶: 如果 f 是基域的一个元素，则返回 True。

property is_homogeneous¶: 如果 f 是齐次多项式，则返回 True。

property is_irreducible¶: 如果 f 在其定义域内没有因子，则返回 True。

property is_linear¶: 如果 f 在其所有变量中线性，则返回 True。

property is_monic¶: 如果 f 的首项系数为1，则返回 True。

property is_monomial¶: 如果 f 为零或仅有一个项，则返回 True。

property is_one¶: 如果 f 是一个单位多项式，则返回 True。

property is_primitive¶: 如果 f 的系数的最大公约数为 1，则返回 True。

property is_quadratic¶: 如果 f 在其所有变量中都是二次的，则返回 True。

property is_sqf¶: 如果 f 是一个无平方多项式，则返回 True。

property is_zero¶: 如果 f 是零多项式，则返回 True。

l1_norm()[源代码][源代码]¶: 返回 f 的 l1 范数。

l2_norm_squared()[源代码][源代码]¶: 返回 f 的平方 l2 范数。

lcm(g)[源代码][源代码]¶: 返回多项式 f 和 g 的最小公倍数。

lift()[源代码][源代码]¶: 将代数系数转换为有理数。

max_norm()[源代码][源代码]¶: 返回 f 的最大范数。

mignotte_sep_bound_squared()[源代码][源代码]¶: 计算 f 的根分离的平方 Mignotte 界。

monic()[源代码][源代码]¶: 将所有系数除以 LC(f)。

monoms(order=None)[源代码][源代码]¶: 返回 f 中按字典顺序排列的所有非零单项式。

mul(g)[源代码][源代码]¶: 将两个多元多项式 f 和 g 相乘。

mul_ground(c)[源代码][源代码]¶: 将 f 乘以基域的一个元素。

neg()[源代码][源代码]¶: 在 f 中否定所有系数。

norm()[源代码][源代码]¶: 计算 Norm(f)。

nth(*N)[源代码][源代码]¶: 返回 f 的第 n 个系数。

pdiv(g)[源代码][源代码]¶: 多项式伪除法 f 和 g。

permute(P)[源代码][源代码]¶

返回一个多项式在 \(K[x_{P(1)}, ..., x_{P(n)}]\) 中。

示例

>>> from sympy.polys.polyclasses import DMP
>>> from sympy.polys.domains import ZZ

>>> DMP([[[ZZ(2)], [ZZ(1), ZZ(0)]], [[]]], ZZ).permute([1, 0, 2])
DMP_Python([[[2], []], [[1, 0], []]], ZZ)

>>> DMP([[[ZZ(2)], [ZZ(1), ZZ(0)]], [[]]], ZZ).permute([1, 2, 0])
DMP_Python([[[1], []], [[2, 0], []]], ZZ)

pexquo(g)[源代码][源代码]¶: 多项式 f 和 g 的精确伪商。

pow(n)[源代码][源代码]¶: 将 f 提升到一个非负的幂 n。

pquo(g)[源代码][源代码]¶: f 和 g 的多项式伪商。

prem(g)[源代码][源代码]¶: 多项式 f 和 g 的伪余数。

primitive()[源代码][源代码]¶: 返回内容和 f 的原始形式。

quo(g)[源代码][源代码]¶: 计算多项式 f 和 g 的商。

quo_ground(c)[源代码][源代码]¶: f 除以基域中一个元素的商。

refine_root( s, t, eps=None, steps=None, fast=False, )[源代码][源代码]¶

将隔离区间细化到给定的精度。

eps 应该是一个有理数。

rem(g)[源代码][源代码]¶: 计算多项式 f 和 g 的余数。

property rep¶: 获取 f 的表示。

resultant(g, includePRS=False)[源代码][源代码]¶: 通过PRS计算 f 和 g 的结果。

revert(n)[源代码][源代码]¶: 计算 f**(-1) 模 x**n。

shift(a)[源代码][源代码]¶: 高效计算泰勒位移 f(x + a)。

shift_list(a)[源代码][源代码]¶: 高效计算泰勒位移 f(X + A)。

slice(m, n, j=0)[源代码][源代码]¶: 取 f 的连续子序列项。

sqf_list(all=False)[源代码][源代码]¶: 返回 f 的无平方因子的列表。

sqf_list_include(all=False)[源代码][源代码]¶: 返回 f 的无平方因子的列表。

sqf_norm()[源代码][源代码]¶: 计算 f 的无平方范数。

sqf_part()[源代码][源代码]¶: 计算 f 的无平方部分。

sqr()[源代码][源代码]¶: 对多元多项式 f 进行平方。

sturm()[源代码][源代码]¶: 计算 f 的 Sturm 序列。

sub(g)[源代码][源代码]¶: 减去两个多元多项式 f 和 g。

sub_ground(c)[源代码][源代码]¶: 从 f 中减去地面域的一个元素。

subresultants(g)[源代码][源代码]¶: 计算 f 和 g 的子结果PRS序列。

terms(order=None)[源代码][源代码]¶: 返回 f 中按字典顺序排列的所有非零项。

terms_gcd()[源代码][源代码]¶: 从多项式 f 中去除各项的最大公约数。

to_best()[源代码][源代码]¶

如果可能，转换为 DUP_Flint。

当域或级别发生变化，并且可能从DMP_Python转换为DUP_Flint时，应使用此方法。

to_dict(zero=False)[源代码][源代码]¶: 将 f 转换为带有原生系数的字典表示形式。

to_exact()[源代码][源代码]¶: 使基础域精确。

to_field()[源代码][源代码]¶: 将基础域设为一个域。

to_list()[源代码][源代码]¶: 将 f 转换为带有原生系数的列表表示。

to_ring()[源代码][源代码]¶: 将基础域设为一个环。

to_sympy_dict(zero=False)[源代码][源代码]¶: 将 f 转换为带有 SymPy 系数的字典表示形式。

to_sympy_list()[源代码][源代码]¶: 将 f 转换为带有 SymPy 系数的列表表示形式。

to_tuple()[源代码][源代码]¶

将 f 转换为包含本机系数的元组表示形式。

这是用于哈希的必要条件。

total_degree()[源代码][源代码]¶: 返回 f 的总次数。

transform(p, q)[源代码][源代码]¶: 评估函数变换 q**n * f(p/q)。

trunc(p)[源代码][源代码]¶: 将 f 对常数 p 取模。

unify_DMP(g)[源代码][源代码]¶: 统一并返回 f 和 g 的 DMP 实例。

class sympy.polys.polyclasses.DMF(rep, dom, lev=None)[源代码][源代码]¶

在 \(K\) 上的稠密多元分数。

属性:

den
dom
is_one: 如果 f 是单位分数，则返回 True。
is_zero: 如果 f 是一个零分数，则返回 True。
lev
num

方法

`add`(g)	添加两个多元分数 `f` 和 `g`。
`add_ground`(c)	将一个地面域的元素添加到 `f` 中。
`cancel`()	从 `f.num` 和 `f.den` 中移除公因子。
`denom`()	返回 `f` 的分母。
`exquo`(g)	计算分数 `f` 和 `g` 的商。
`frac_unify`(g)	统一表示两个多元分数。
`half_per`(rep[, kill])	根据给定的表示创建一个DMP。
`invert`([check])	计算分数 `f` 的倒数。
`mul`(g)	将两个多元分数 `f` 和 `g` 相乘。
`neg`()	在 `f` 中否定所有系数。
`numer`()	返回 `f` 的分子。
`per`(num, den[, cancel, kill])	根据给定的表示创建一个DMF。
`poly_unify`(g)	统一一个多元分数和一个多项式。
`pow`(n)	将 `f` 提升到一个非负的幂 `n`。
`quo`(g)	计算分数 `f` 和 `g` 的商。
`sub`(g)	减去两个多元分数 `f` 和 `g`。

ground_new
新
一
零

add(g)[源代码][源代码]¶: 添加两个多元分数 f 和 g。

add_ground(c)[源代码][源代码]¶: 将一个地面域的元素添加到 f 中。

cancel()[源代码][源代码]¶: 从 f.num 和 f.den 中移除公因子。

denom()[源代码][源代码]¶: 返回 f 的分母。

exquo(g)[源代码]¶: 计算分数 f 和 g 的商。

frac_unify(g)[源代码][源代码]¶: 统一表示两个多元分数。

half_per(rep, kill=False)[源代码][源代码]¶: 根据给定的表示创建一个DMP。

invert(check=True)[源代码][源代码]¶: 计算分数 f 的倒数。

property is_one¶: 如果 f 是单位分数，则返回 True。

property is_zero¶: 如果 f 是一个零分数，则返回 True。

mul(g)[源代码][源代码]¶: 将两个多元分数 f 和 g 相乘。

neg()[源代码][源代码]¶: 在 f 中否定所有系数。

numer()[源代码][源代码]¶: 返回 f 的分子。

per(num, den, cancel=True, kill=False)[源代码][源代码]¶: 根据给定的表示创建一个DMF。

poly_unify(g)[源代码][源代码]¶: 统一一个多元分数和一个多项式。

pow(n)[源代码][源代码]¶: 将 f 提升到一个非负的幂 n。

quo(g)[源代码][源代码]¶: 计算分数 f 和 g 的商。

sub(g)[源代码][源代码]¶: 减去两个多元分数 f 和 g。

class sympy.polys.polyclasses.ANP(rep, mod, dom)[源代码][源代码]¶

域上的稠密代数数多项式。

属性:

dom
is_ground: 如果 f 是基域的一个元素，则返回 True。
is_one: 如果 f 是一个单位代数数，则返回 True。
is_zero: 如果 f 是一个零代数数，则返回 True。
mod
rep

方法

`LC`()	返回 `f` 的首项系数。
`TC`()	返回 `f` 的尾系数。
`add_ground`(c)	将一个地面域的元素添加到 `f` 中。
`convert`(dom)	将 `f` 转换为新域上的 `ANP`。
`mod_to_list`()	将 `f.mod` 作为包含原生系数的列表返回。
`mul_ground`(c)	将 `f` 乘以基域的一个元素。
`pow`(n)	将 `f` 提升到一个非负的幂 `n`。
`quo_ground`(c)	`f` 除以基础域中元素的商。
`sub_ground`(c)	从 `f` 中减去地面域的一个元素。
`to_dict`()	将 `f` 转换为带有原生系数的字典表示形式。
`to_list`()	将 `f` 转换为带有原生系数的列表表示。
`to_sympy_dict`()	将 `f` 转换为带有 SymPy 系数的字典表示形式。
`to_sympy_list`()	将 `f` 转换为带有 SymPy 系数的列表表示形式。
`to_tuple`()	将 `f` 转换为包含本机系数的元组表示形式。
`unify`(g)	统一两个代数数的表示。
`unify_ANP`(g)	统一并返回 `f` 和 `g` 的 `DMP` 实例。

添加
div
exquo
from_list
mod_to_DMP
mul
neg
新
一
每
quo
rem
子
to_DMP
零

LC()[源代码][源代码]¶: 返回 f 的首项系数。

TC()[源代码][源代码]¶: 返回 f 的尾系数。

add_ground(c)[源代码][源代码]¶: 将一个地面域的元素添加到 f 中。

convert(dom)[源代码][源代码]¶: 将 f 转换为新域上的 ANP。

property is_ground¶: 如果 f 是基域的一个元素，则返回 True。

property is_one¶: 如果 f 是一个单位代数数，则返回 True。

property is_zero¶: 如果 f 是一个零代数数，则返回 True。

mod_to_list()[源代码][源代码]¶: 将 f.mod 作为包含原生系数的列表返回。

mul_ground(c)[源代码][源代码]¶: 将 f 乘以基域的一个元素。

pow(n)[源代码][源代码]¶: 将 f 提升到一个非负的幂 n。

quo_ground(c)[源代码][源代码]¶: f 除以基础域中元素的商。

sub_ground(c)[源代码][源代码]¶: 从 f 中减去地面域的一个元素。

to_dict()[源代码][源代码]¶: 将 f 转换为带有原生系数的字典表示形式。

to_list()[源代码][源代码]¶: 将 f 转换为带有原生系数的列表表示。

to_sympy_dict()[源代码][源代码]¶: 将 f 转换为带有 SymPy 系数的字典表示形式。

to_sympy_list()[源代码][源代码]¶: 将 f 转换为带有 SymPy 系数的列表表示形式。

to_tuple()[源代码][源代码]¶

将 f 转换为包含本机系数的元组表示形式。

这是用于哈希的必要条件。

unify(g)[源代码][源代码]¶: 统一两个代数数的表示。

unify_ANP(g)[源代码][源代码]¶: 统一并返回 f 和 g 的 DMP 实例。

Poly Domains 的参考文档¶

域¶

抽象域¶

GF(p)¶

ZZ¶

QQ¶

MPQ¶

高斯域¶

ZZ_I¶

QQ_I¶

QQ<a>¶

RR¶

CC¶

K[x]¶

K(x)¶

EX¶

商环¶

稀疏多项式¶

稀疏有理函数¶

稠密多项式¶

`EX`¶