SymPy 1.13 中文文档（十二）

原文：docs.sympy.org/latest/index.html

群构造器

原文：docs.sympy.org/latest/modules/combinatorics/group_constructs.html

sympy.combinatorics.group_constructs.DirectProduct(*groups)

返回几个群的直积作为一个置换群。

解释

这与取两个置换群的直积的 mul 过程实现方式非常相似，但在任意数量的群的情况下实现了生成器的移位思想。一般预期调用 DirectProduct(G1, G2, …, Gn) 比调用 G1G2…*Gn 更快（因此需要此算法）。

示例

>>> from sympy.combinatorics.group_constructs import DirectProduct
>>> from sympy.combinatorics.named_groups import CyclicGroup
>>> C = CyclicGroup(4)
>>> G = DirectProduct(C, C, C)
>>> G.order()
64 

另请参阅

sympy.combinatorics.perm_groups.PermutationGroup.__mul__

测试实用工具

原文：docs.sympy.org/latest/modules/combinatorics/testutil.html

sympy.combinatorics.testutil._cmp_perm_lists(first, second)

比较两个排列列表作为集合。

解释

这用于测试目的。由于排列的数组形式目前是一个列表，排列不可哈希化且无法放入集合中。

例子

>>> from sympy.combinatorics.permutations import Permutation
>>> from sympy.combinatorics.testutil import _cmp_perm_lists
>>> a = Permutation([0, 2, 3, 4, 1])
>>> b = Permutation([1, 2, 0, 4, 3])
>>> c = Permutation([3, 4, 0, 1, 2])
>>> ls1 = [a, b, c]
>>> ls2 = [b, c, a]
>>> _cmp_perm_lists(ls1, ls2)
True 

sympy.combinatorics.testutil._naive_list_centralizer(self, other, af=False)

sympy.combinatorics.testutil._verify_bsgs(group, base, gens)

验证基和强生成集的正确性。

解释

这是一个使用基本定义和相对于其的强生成集的朴素实现。有其他程序用于验证基和强生成集，但这个将用于更健壮的测试。

例子

>>> from sympy.combinatorics.named_groups import AlternatingGroup
>>> from sympy.combinatorics.testutil import _verify_bsgs
>>> A = AlternatingGroup(4)
>>> A.schreier_sims()
>>> _verify_bsgs(A, A.base, A.strong_gens)
True 

另请参见

sympy.combinatorics.perm_groups.PermutationGroup.schreier_sims

sympy.combinatorics.testutil._verify_centralizer(group, arg, centr=None)

验证一个组/集合/元素在另一个组内的中心化器。

这用于测试.centralizer()函数来自sympy.combinatorics.perm_groups。

例子

>>> from sympy.combinatorics.named_groups import (SymmetricGroup,
... AlternatingGroup)
>>> from sympy.combinatorics.perm_groups import PermutationGroup
>>> from sympy.combinatorics.permutations import Permutation
>>> from sympy.combinatorics.testutil import _verify_centralizer
>>> S = SymmetricGroup(5)
>>> A = AlternatingGroup(5)
>>> centr = PermutationGroup([Permutation([0, 1, 2, 3, 4])])
>>> _verify_centralizer(S, A, centr)
True 

另请参见

_naive_list_centralizer, sympy.combinatorics.perm_groups.PermutationGroup.centralizer, _cmp_perm_lists

sympy.combinatorics.testutil._verify_normal_closure(group, arg, closure=None)

张量规范化

原文：docs.sympy.org/latest/modules/combinatorics/tensor_can.html

sympy.combinatorics.tensor_can.canonicalize(g, dummies, msym, *v)

形成张量的张量规范化

参数：

g：表示张量的排列

dummies：表示虚拟指标的列表

它可以是相同类型的虚拟指标列表或虚拟指标列表的列表，每种类型一个列表；虚拟指标必须在自由指标之后，并按逆变、协变顺序排列 [d0, -d0, d1,-d1,…]

msym：度规的对称性

它可以是整数或列表；在第一种情况下，它是虚拟指标度规的对称性；在第二种情况下，它是每种类型指标度规对称性的列表

v：列表，对于类型 (i) 的张量为 (base_i, gens_i, n_i, sym_i)

base_i, gens_i：该类型张量的 BSGS。

BSGS 应按字典顺序具有最小基数；如果不是，则尝试获取最小的 BSGS；如果失败，则使用 canonicalize_naive，这会慢得多。

n_i：类型 (i) 的张量数量。

sym_i：在类型 (i) 的分量张量交换下的对称性。

对于 msym 和 sym_i 情况如下

• 无对称性
• 0 交换
• 1 反交换

返回：

如果张量为零，则返回数组形式；

表示张量的规范形式的排列。

算法

首先使用 canonical_free 获取使用只有槽对称性的字典顺序下的最小张量。如果分量张量没有最小的 BSGS，则尝试找到它；如果尝试失败，则使用 canonicalize_naive。

使用 tensor_gens(base, gens, list_free_indices, sym) 计算保持固定自由指标的残余槽对称性。

通过消除自由指标来减少问题。

然后使用 double_coset_can_rep 并通过重新引入自由指标提升结果。

示例

具有交换度规的一种类型的指标；

(A_{a b}) 和 (B_{a b}) 反对称且交换

(T = A_{d0 d1} * B^{d0}{}_{d2} * B^{d2 d1})

(ord = [d0,-d0,d1,-d1,d2,-d2]) 指标的顺序

g = [1, 3, 0, 5, 4, 2, 6, 7]

(T_c = 0)

>>> from sympy.combinatorics.tensor_can import get_symmetric_group_sgs, canonicalize, bsgs_direct_product
>>> from sympy.combinatorics import Permutation
>>> base2a, gens2a = get_symmetric_group_sgs(2, 1)
>>> t0 = (base2a, gens2a, 1, 0)
>>> t1 = (base2a, gens2a, 2, 0)
>>> g = Permutation([1, 3, 0, 5, 4, 2, 6, 7])
>>> canonicalize(g, range(6), 0, t0, t1)
0 

如上所述，但与 (B_{a b}) 反交换

(T_c = -A^{d0 d1} * B_{d0}{}^{d2} * B_{d1 d2})

can = [0,2,1,4,3,5,7,6]

>>> t1 = (base2a, gens2a, 2, 1)
>>> canonicalize(g, range(6), 0, t0, t1)
[0, 2, 1, 4, 3, 5, 7, 6] 

两种类型的指标 ([a,b,c,d,e,f]) 和 ([m,n])，以这种顺序，都具有交换度规

(f^{a b c}) 反对称，交换

(A_{m a}) 无对称性，交换

(T = f^c{}{d a} * f^f{}{e b} * A_m{}^d * A^{m b} * A_n{}^a * A^{n e})

ord = [c,f,a,-a,b,-b,d,-d,e,-e,m,-m,n,-n]

g = [0,7,3, 1,9,5, 11,6, 10,4, 13,2, 12,8, 14,15]

规范张量为 (T_c = -f^{c a b} * f^{f d e} * A^m{}a * A{m d} * A^n{}b * A{n e})

can = [0,2,4, 1,6,8, 10,3, 11,7, 12,5, 13,9, 15,14]

>>> base_f, gens_f = get_symmetric_group_sgs(3, 1)
>>> base1, gens1 = get_symmetric_group_sgs(1)
>>> base_A, gens_A = bsgs_direct_product(base1, gens1, base1, gens1)
>>> t0 = (base_f, gens_f, 2, 0)
>>> t1 = (base_A, gens_A, 4, 0)
>>> dummies = [range(2, 10), range(10, 14)]
>>> g = Permutation([0, 7, 3, 1, 9, 5, 11, 6, 10, 4, 13, 2, 12, 8, 14, 15])
>>> canonicalize(g, dummies, [0, 0], t0, t1)
[0, 2, 4, 1, 6, 8, 10, 3, 11, 7, 12, 5, 13, 9, 15, 14] 

sympy.combinatorics.tensor_can.double_coset_can_rep(dummies, sym, b_S, sgens, S_transversals, g)

Butler-Portugal 张量规范化算法，带有虚拟指标。

参数：

dummies

虚拟指标列表的列表，每种类型一个列表；虚拟指标按逆变、协变[d0, -d0, d1, -d1, ...]排序。

对称

指标度量的对称性列表对每种类型。

指标度量的可能对称性

• 0 对称
• 1 反对称
• 无，没有对称性

b_S

最小插槽对称 BSGS 的基础。

sgens

插槽对称 BSGS 的生成器。

S 横截面

插槽 BSGS 的横截面。

g

表示张量的置换。

返回：

如果张量为零则返回 0，否则返回数组形式的

表示张量规范形式的置换。

注意事项

一个具有虚拟指标的张量可以用多种等价方式表示，通常随着指标数量的增加而呈指数级增长。在没有有效算法的情况下，要确定两个具有许多指标的张量是否相等变得计算非常缓慢。

Butler-Portugal 算法[3]是一个将张量置于规范形式的高效算法，解决上述问题。

Portugal 观察到一个张量可以用置换表示，并且在插槽和虚拟对称性下等效的张量类等价于双余类(DgS)（注意：在本文档中我们使用置换乘法的约定 p，q 与(p*q)(i) = p[q[i]]相反，这与 Permutation 类中使用的约定相反）

使用 Butler 算法找到双余类的代表可以找到张量的规范形式。

要看到这种对应关系，设(g)是数组形式的置换；具有指标(ind)的张量（包括逆变和协变指标）可以写成

(t = T(ind[g[0]], \dots, ind[g[n-1]])),

其中(n = len(ind))；(g)的大小为(n + 2)，最后两个指标是张量的符号（引入[4]中的技巧）。

插槽对称性变换(s)是作用于插槽上的置换(t \rightarrow T(ind[(gs)[0]], \dots, ind[(gs)[n-1]]))

虚拟对称性变换作用于指标(ind) (t \rightarrow T(ind[(dg)[0]], \dots, ind[(dg)[n-1]]))

仅对这些对称性下的张量变换感兴趣，可以将张量表示为(g)，该张量的变换如下

(g -> dgs), 所以它属于余类(DgS)，或者换句话说，它属于由插槽和虚拟对称性允许的所有排列的集合。

让我们通过一个例子解释惯例。

给定张量(T^{d3 d2 d1}{}_{d1 d2 d3})与插槽对称性

(T^{a0 a1 a2 a3 a4 a5} = -T^{a2 a1 a0 a3 a4 a5})

(T^{a0 a1 a2 a3 a4 a5} = -T^{a4 a1 a2 a3 a0 a5})

并且对称度量，找到与之等价的张量，该张量在指标的排序下是最低的：词典顺序(d1, d2, d3)，然后是逆变指标在协变指标之前；即张量的规范形式。

规范形式是通过(T^{a0 a1 a2 a3 a4 a5} = -T^{a2 a1 a0 a3 a4 a5})获得的(-T^{d1 d2 d3}{}_{d1 d2 d3})。

要将此问题转换为此函数的输入，请使用索引名称的以下顺序 (- 表示缩短的协变) (d1, -d1, d2, -d2, d3, -d3)

(T^{d3 d2 d1}{}_{d1 d2 d3}) 对应于 (g = [4, 2, 0, 1, 3, 5, 6, 7])，其中最后两个指标是为了符号

(sgens = [Permutation(0, 2)(6, 7), Permutation(0, 4)(6, 7)])

sgens[0] 是槽对称性 (-(0, 2))，(T^{a0 a1 a2 a3 a4 a5} = -T^{a2 a1 a0 a3 a4 a5})

sgens[1] 是槽对称性 (-(0, 4))，(T^{a0 a1 a2 a3 a4 a5} = -T^{a4 a1 a2 a3 a0 a5})

虚拟对称群 D 是由强基生成器生成的 ([(0, 1), (2, 3), (4, 5), (0, 2)(1, 3), (0, 4)(1, 5)])，前三个交换同一指标的协变和逆变位置（d1 <-> -d1），后两个交换虚拟指标本身（d1 <-> d2）。

虚拟对称性从左侧作用 (d = [1, 0, 2, 3, 4, 5, 6, 7])，交换 (d1 \leftrightarrow -d1) (T^{d3 d2 d1}{}{d1 d2 d3} == T^{d3 d2}{}{d1}{}^{d1}{}_{d2 d3})

(g=[4, 2, 0, 1, 3, 5, 6, 7] -> [4, 2, 1, 0, 3, 5, 6, 7] = _af_rmul(d, g))，与 (_af_rmul(g, d)) 不同。

槽对称性从右侧作用 (s = [2, 1, 0, 3, 4, 5, 7, 6])，交换槽 0 和 2，并改变符号 (T^{d3 d2 d1}{}{d1 d2 d3} == -T^{d1 d2 d3}{}{d1 d2 d3})

(g=[4,2,0,1,3,5,6,7] -> [0, 2, 4, 1, 3, 5, 7, 6] = _af_rmul(g, s))

张量为零的示例，与上述相同的槽对称性：(T^{d2}{}{d1 d3}{}^{d1 d3}{}{d2})

(= -T^{d3}{}{d1 d3}{}^{d1 d2}{}{d2}) 在槽对称性 (-(0,4)) 下；

(= T_{d3 d1}{}^{d3}{}^{d1 d2}{}_{d2}) 在槽对称性 (-(0,2)) 下；

(= T^{d3}{}{d1 d3}{}^{d1 d2}{}{d2}) 对称度量；

(= 0) 因为这两行张量仅在符号上有所不同。

双余类 DgS 包括与等价张量对应的排列 (h = dgs)；如果有两个相同除了符号的 (h)，返回零；否则按照 ([d1, -d1, d2, -d2, d3, -d3]) 的字典顺序选择张量作为代表，即 rep = min(D*g*S) = min([d*g*s for d in D for s in S])

指标依次固定；首先选择槽 0 的最低指标，然后选择剩余槽 1 的最低指标，依此类推。这样做可以获得一系列的稳定子。

(S \rightarrow S_{b0} \rightarrow S_{b0,b1} \rightarrow \dots) 和 (D \rightarrow D_{p0} \rightarrow D_{p0,p1} \rightarrow \dots)

其中 [b0, b1, ...] = range(b) 是对称群的基；S 的强基 (b_S) 是其有序子列表；因此仅需使用 Schreier-Sims 算法一次计算 S 的强基生成器；强基生成器的稳定子是稳定子子群的强基生成器。

dbase = [p0, p1, ...] 通常不是字典顺序的，因此每次都必须重新计算强基生成器；然而这很简单，不需要使用 Schreier-Sims 算法来处理 D。

该算法保持元素((s_i, d_i, h_i))的 TAB，其中(h_i = d_i \times g \times s_i)满足(h_i[j] = p_j)，对于(0 \le j < i)，从(s_0 = id, d_0 = id, h_0 = g)开始。

方程(h_0[0] = p_0, h_1[1] = p_1, \dots)按照这个顺序解决，每次选择最低可能的 p_i 值。

对于(j < i)，(d_igs_iS_{b_0, \dots, b_{i-1}}b_j = D_{p_0, \dots, p_{i-1}}p_j)，因此对于(D_{p_0,\dots,p_{i-1}})中的 dx 和(S_{base[0], \dots, base[i-1]})中的 sx，有(dxd_igs_isxb_j = p_j)

寻找 dx, sx，使得这个方程对于(j = i)成立；它可以写成(s_isxb_j = J, dxd_igJ = p_j) (sxb_j = s_i**-1J; sx = trace(s_i**-1, S_{b_0,...,b_{i-1}})) (dx**-1p_j = d_igJ; dx = trace(d_igJ, D_{p_0,...,p_{i-1}}))

(s_{i+1} = s_itrace(s_i**-1J, S_{b_0,...,b_{i-1}})) (d_{i+1} = trace(d_igJ, D_{p_0,...,p_{i-1}})**-1*d_i) (h_{i+1}*b_i = d_{i+1}gs_{i+1}*b_i = p_i)

对所有的 j，(h_n*b_j = p_j)，因此(h_n)是解。

将找到的((s, d, h))添加到 TAB1 中。

在迭代结束时，按照(h)对 TAB1 进行排序；如果 TAB1 中有两个连续的(h)只有符号不同，张量为零，所以返回 0；如果有两个连续的(h)相等，则保留一个。

然后稳定(i)下的槽生成器和(p_i)下的虚拟生成器。

在迭代步骤结束时将(TAB = TAB1)赋值。

最后(TAB)包含一个独特的((s, d, h))，因为张量(h)的所有槽都被固定为符合对称性的最小值。算法返回(h)。

重要的是槽 BSGS 具有字典顺序下的最小基，否则存在一个(i)，它不属于槽基，而(p_i)仅由虚拟对称性固定，而(i)不是来自槽稳定器，所以(p_i)通常不是最小值。

这个算法与原始算法[3]略有不同：

规范形式在字典顺序下是最小的，而 BSGS 在字典顺序下具有最小的基。相等的张量(h)从 TAB 中消除。

示例

>>> from sympy.combinatorics.permutations import Permutation
>>> from sympy.combinatorics.tensor_can import double_coset_can_rep, get_transversals
>>> gens = [Permutation(x) for x in [[2, 1, 0, 3, 4, 5, 7, 6], [4, 1, 2, 3, 0, 5, 7, 6]]]
>>> base = [0, 2]
>>> g = Permutation([4, 2, 0, 1, 3, 5, 6, 7])
>>> transversals = get_transversals(base, gens)
>>> double_coset_can_rep([list(range(6))], [0], base, gens, transversals, g)
[0, 1, 2, 3, 4, 5, 7, 6] 

>>> g = Permutation([4, 1, 3, 0, 5, 2, 6, 7])
>>> double_coset_can_rep([list(range(6))], [0], base, gens, transversals, g)
0 

sympy.combinatorics.tensor_can.get_symmetric_group_sgs(n, antisym=False)

返回( (反)对称张量的最小 BSGS 的基和生成元 )

参数：

n：张量的秩

antisym：布尔值

antisym = False 表示对称张量 antisym = True 表示反对称张量

示例

>>> from sympy.combinatorics.tensor_can import get_symmetric_group_sgs
>>> get_symmetric_group_sgs(3)
([0, 1], [(4)(0 1), (4)(1 2)]) 

sympy.combinatorics.tensor_can.bsgs_direct_product(base1, gens1, base2, gens2, signed=True)

两个 BSGS 的直接积。

参数：

base1：第一个 BSGS 的基。

gens1：第一个 BSGS 的强生成序列。

base2, gens2：第二个 BSGS 类似。

signed：表示有符号排列的标志。

示例

>>> from sympy.combinatorics.tensor_can import (get_symmetric_group_sgs, bsgs_direct_product)
>>> base1, gens1 = get_symmetric_group_sgs(1)
>>> base2, gens2 = get_symmetric_group_sgs(2)
>>> bsgs_direct_product(base1, gens1, base2, gens2)
([1], [(4)(1 2)]) 

有限呈现群

原文：docs.sympy.org/latest/modules/combinatorics/fp_groups.html

介绍

本模块提供了用于有限呈现群（fp-groups 简称）计算的功能。对应的 SymPy 对象名称是 FpGroup。这里描述的函数或类是在计算群论下研究的。所有代码示例假设：

>>> from sympy.combinatorics.free_groups import free_group, vfree_group, xfree_group
>>> from sympy.combinatorics.fp_groups import FpGroup, CosetTable, coset_enumeration_r 

设施概述

为有限呈现群提供的设施分为几个自然分组

• 使用自由群和该自由群的生成元词列表构造 fp-groups。

• 使用著名的 Todd-Coxeter 程序确定指数。

• 使用低指标子群算法构造所有指数小于某个（小的）指定正整数的子群。

• 算法用于计算由有限呈现定义的群中有限指数子群的表示。

对于有限呈现群的基本算法描述，我们经常使用计算群论手册。

有限呈现群的构造

有限呈现群通过将自由群因子分解为一组关系者而构造。关系者集合以 SymPy 中自由群的生成元的词列表形式给出，使用列表为关系者提供了顺序。如果关系者列表为空，则返回关联的自由群。

一个有限呈现群构造的示例。四阶对称群可以表示为具有表示 (\left\langle a, b \mid a², b³, (ab)⁴ \right\rangle) 的两个生成元群。将关系者作为关系者列表提供，SymPy 中的群将指定为：

>>> F, a, b = free_group("a, b")
>>> G = FpGroup(F, [a**2, b**3, (a*b)**4])
>>> G
<fp group on the generators (a, b)> 

当前的群具有类似于 (\left\langle r, s, t \mid r², s², t², rst = str = trs \right\rangle) 的表示时，必须指定为：

>>> F, r, s, t = free_group("r, s, t")
>>> G = FpGroup(F, [r**2, s**2, t**2, r*s*t*r**-1*t**-1*s**-1, s*t*r*s**-1*r**-1*t**-1]) 

显然，这不是制造特定群的唯一方法，但重点在于，如果与非身份相等，用户必须手动执行此操作。

自由群和词

自由群的构造

free_group("gen0, gen1, ..., gen_(n-1)") 在 n 个生成元上构造了一个自由群 F，其中 n 是正整数。可以使用方法 .generators[i] 获取 F 的第 i 个生成元，其中 (i = 0, \ldots n-1)。

>>> F, x, y = free_group("x, y") 

创建了一个秩为 2 的自由群 F，并将变量 x 和 y 分配给这两个生成元。

>>> F = vfree_group("x, y")
>>> F
<free group on the generators (x, y)> 

创建了一个秩为 2 的自由群 F，并用生成元组 F.generators 插入 x 和 y 作为全局命名空间中的生成元。

>>> F = xfree_group("x, y")
>>> F
(<free group on the generators (x, y)>, (x, y))
>>> x**2
x**2 

创建了一个秩为 2 的自由群 F[0]，并用生成元组 F[1]。

词的构造

本节适用于 FreeGroup 和 FpGroup 中的词。当我们在 SymPy 中提到 word 时，实际上指的是一个简化词，因为这些词会自动进行简化。给定一个群 G，其由 (n) 个生成元 (x_1, x_2, x_3, \ldots, x_n) 定义，一个词构造为 (s_1^{r_1}s_2^{r_2} \cdots s_k^{r_k})，其中 (s_i \in {x_1, x_2, \ldots, x_n})，(r_i \in \mathbb{Z}) 对所有的 (k) 成立。

每个词可以以各种方式构造，因为它们经过简化后可能是等效的。

余陪枚举：Todd-Coxeter 算法

本节描述了 SymPy 中余陪枚举技术的使用。用于余陪枚举过程的算法是 Todd-Coxeter 算法，并且是在 SymPy 中使用 [Ho05] 和 [CDHW73] 开发的。读者应参考 [CDHW73] 和 [Hav91] 了解算法的一般描述。

我们有两种余陪枚举策略 relator-based 和 coset-table based，并且两者都作为 coset_enumeration_r、coset_enumeration_c 实现了。这两种策略在它们为余陪制定新定义的方式上有所不同。

尽管从用户的角度建议使用 FpGroup 的 .coset_enumeration 方法，并指定 strategy 参数。

strategy：

(default=”relator_based”) 指定余陪枚举策略的策略，可能的值是 “relator_based” 或 “coset_table_based”。

余陪表

用于操作有限呈现群 G 在子群 H 的余陪上余陪枚举信息的类。

基本上 coset table CosetTable(G,H) 是有限呈现群在一个子群的余陪上的置换表示。大多数集合论和群函数使用 G 的常规表示，即在平凡子群上的余陪表。

实际的数学余陪表通过 .table 属性获取，并且是一个列表的列表。对于 G 的每个生成元 g，它包含一列，下一列对应于 g**-1，依此类推对其他生成元，因此总共有 2*G.rank() 列。每列简单地是一个整数列表。如果 l 是生成元列表用于生成元 (g)，如果 l[i] = j，那么生成元 g 将余陪 (i) 送到余陪 (j)，通过右侧乘法。

对于有限呈现的群，余陪表通过 Todd-Coxeter 余陪枚举计算。请注意，您可以通过更改变量 CosetTable.coset_table_max_limit 的值来影响该枚举的性能。

CosetTable 的属性

对于 CosetTable(G, H)，其中 G 是群，H 是子群。

• n：一个非负整数，非可变属性，作为活余陪（即 (\Omega)）的最大值计算。

• table：一个列表的列表，可变属性，数学上表示余陪表。

• omega：一个列表，依赖于内部属性 p。 (\Omega) 表示活余类的列表。一个 标准 余类表具有其 (\Omega = {0, 1, \ldots, index-1 })，其中 (index) 是子群 (H) 在 (G) 中的指标。

对于有经验的用户，我们有一些可以用来操纵算法的参数，如

• coset_table_max_limit（默认值为 (4096000)）：操纵允许的余类数目在余类枚举中，即在余类表中允许的行数。如果子群没有有限指标，则余类枚举将不会结束，即使它有可能会比子群的实际指标多很多中间余类。为了避免余类枚举“失控”，因此 SymPy 具有内置的“安全停止”功能。这由此变量控制。要更改它，请使用 max_cosets 关键字。例如：

  >>> F, a, b = free_group("a, b")
  >>> Cox = FpGroup(F, [a**6, b**6, (a*b)**2, (a**2*b**2)**2, (a**3*b**3)**5])
  >>> C_r = coset_enumeration_r(Cox, [a], max_cosets=50)
  Traceback (most recent call last):
    ...
  ValueError: the coset enumeration has defined more than 50 cosets 
  

• max_stack_size（默认值为 (500)）：操纵 deduction_stack 的最大大小，大于或等于该大小时堆栈被清空。

压缩和标准化

对于余类表中的任意两个条目 (i, j)，其中 (i < j)，在余类表条目的行顺序中，(i) 的第一次出现先于 (j) 的第一次出现。我们称这样的表为标准余类表。要将 CosetTable 标准化，我们使用 .standardize 方法。

注意：该方法改变给定的表，而不是创建一个副本。

有限指标的子群

本节的功能涉及构造有限指标子群。我们描述了一种计算所有指标不超过某个（适度的）整数界限的子群的方法。

低指标子群

low_index_subgroups(G, N): 给定一个有限表达群 (G = \left\langle X \mid R \right\rangle)（可以是自由群），以及一个正整数 N，确定 G 的指标小于或等于 N 的子群的共轭类。

例如，要找到所有满足 (\le 4) 的子群 (G = \left\langle a, b \mid a² = b³ = (ab)⁴ = 1 \right\rangle) 的方法如下所示：

>>> from sympy.combinatorics.fp_groups import low_index_subgroups
>>> F, a, b = free_group("a, b")
>>> G = FpGroup(F, [a**2, b**3, (a*b)**4])
>>> l = low_index_subgroups(G, 4)
>>> for coset_table in l:
...     print(coset_table.table)
...
[[0, 0, 0, 0]]
[[0, 0, 1, 2], [1, 1, 2, 0], [3, 3, 0, 1], [2, 2, 3, 3]]
[[0, 0, 1, 2], [2, 2, 2, 0], [1, 1, 0, 1]]
[[1, 1, 0, 0], [0, 0, 1, 1]] 

这返回满足子群在群中的指标为 ( \le n ) 的子群的余类表。

构建子群的表示

在本节中，我们讨论在有限表达群中找到子群的表示。虽然 子群 目前只允许作为子群的生成器列表的形式输入，但是你可以期待不久的将来将 余类表 的功能作为子群的输入。

有两种方法从 G 的那些到 H 的生成关系中构造一个子群的定义关系。第一种是在一组 Schreier 生成器上，通常称为 Reidemeister-Schreier 算法或给定的 H 的生成器列表上。

Reidemeister Schreier 算法

使用 reidemeister_presentation(G, Y) 调用，其中 G 是群，Y 是我们想要找到其表示的子群 H 的生成器列表。

>>> from sympy.combinatorics.fp_groups import reidemeister_presentation
>>> F, x, y = free_group("x, y")
>>> f = FpGroup(F, [x**3, y**5, (x*y)**2])
>>> H = [x*y, x**-1*y**-1*x*y*x]
>>> p1 = reidemeister_presentation(f, H)
>>> p1
((y_1, y_2), (y_1**2, y_2**3, y_2*y_1*y_2*y_1*y_2*y_1)) 

参考文献

[CDHW73]

John J. Cannon, Lucien A. Dimino, George Havas 和 Jane M. Watson。《Todd-Coxeter 算法的实现与分析》。Math. Comp.，27：463– 490，1973 年。

[Ho05]

Derek F. Holt，《计算群论手册》。在系列“离散数学及其应用”中，Chapman & Hall/CRC 2005, xvi + 514 p。

[Hav91]

George Havas，《余类枚举策略》。在国际符号与代数计算研讨会（ISSAC’91）论文集，1991 年波恩，页码 191–199. ACM 出版社，1991 年。

多周期群

原文：docs.sympy.org/latest/modules/combinatorics/pc_groups.html

介绍

本模块展示了用于计算多周期群（简称 PcGroup）的功能。相应 SymPy 对象的名称为 PolycyclicGroup。这里描述的函数或类是在计算群论下研究的。

功能概述

• 从给定的置换群构造多周期群。

• 计算多周期生成序列（缩写为 pcgs）和多周期系列（pc_series）。

• 计算多周期系列的相对阶实现。

• 类 Collector 的实现，可视为多周期群的基础的实现。

• 多周期群表示（缩写为 pc_presentation）的实现。

• 对于给定的多周期群元素，计算指数向量、深度和领导指数。

对于多周期群的基本算法描述，我们经常使用计算群论手册。

多周期群的构造

给定置换群，通过计算相应的多周期生成序列、多周期系列及其相对阶构造多周期群。

多周期群的属性

• pc_sequence : 多周期序列由在给定置换群的派生系列中邻接群之间的所有缺失生成器收集形成。

• pc_series : 多周期系列由在 der[i] 中添加 der[i+1] 的所有缺失生成器形成，其中 der 表示派生系列。

• relative_order : 一个列表，由 pc_series 中相邻群的比率计算得出。

• collector : 默认情况下为 None。收集器类提供了多周期表示。

>>> from sympy.combinatorics.named_groups import SymmetricGroup
>>> G = SymmetricGroup(4)
>>> PcGroup = G.polycyclic_group()
>>> len(PcGroup.pcgs)
4
>>> pc_series = PcGroup.pc_series
>>> pc_series[0].equals(G)  # use equals, not literal `==`
True
>>> gen = pc_series[len(pc_series) - 1].generators[0]
>>> gen.is_identity
True
>>> PcGroup.relative_order
[2, 3, 2, 2] 

构造收集器

收集器是 PolycyclicGroup 类的属性之一。

收集器的属性

收集器具有所有多周期群的属性，此外还有以下定义的几个属性：

• free_group : free_group 将多周期生成序列映射到自由群元素。

• pc_presentation : 借助幂和共轭关系器，提供了多周期群的表示。

>>> from sympy.combinatorics.named_groups import SymmetricGroup
>>> G = SymmetricGroup(3)
>>> PcGroup = G.polycyclic_group()
>>> Collector = PcGroup.collector
>>> Collector.free_group
<free group on the generators (x0, x1)>
>>> Collector.pc_presentation
{x0**2: (), x1**3: (), x0**-1*x1*x0: x1**2} 

计算最小未收集子词

在 pc_group 的自由群生成器上定义的一个词 V，如果 V 是 W 的子词，并且具有以下形式之一，则 V 是 W 的最小未收集子词：

• (v = {x_{i+1}}^{a_j}x_i)

• (v = {x_{i+1}}^{a_j}{x_i}^{-1})

• (v = {x_i}^{a_j})

(a_j \notin {0, \ldots \mathrm{relative_order}[j]-1})。

>>> from sympy.combinatorics.named_groups import SymmetricGroup
>>> from sympy.combinatorics.free_groups import free_group
>>> G = SymmetricGroup(4)
>>> PcGroup = G.polycyclic_group()
>>> collector = PcGroup.collector
>>> F, x1, x2 = free_group("x1, x2")
>>> word = x2**2*x1**7
>>> collector.minimal_uncollected_subword(word)
((x2, 2),) 

子词索引的计算

对于给定的词和它的子词，subword_index 计算词中子词的起始和结束索引。

>>> from sympy.combinatorics.named_groups import SymmetricGroup
>>> from sympy.combinatorics.free_groups import free_group
>>> G = SymmetricGroup(4)
>>> PcGroup = G.polycyclic_group()
>>> collector = PcGroup.collector
>>> F, x1, x2 = free_group("x1, x2")
>>> word = x2**2*x1**7
>>> w = x2**2*x1
>>> collector.subword_index(word, w)
(0, 3)
>>> w = x1**7
>>> collector.subword_index(word, w)
(2, 9) 

收集词的计算

如果一个词W称为收集的，那么W (= {x_{i_1}}^{a_1} \ldots {x_{i_r}}^{a_r})，其中(i_1 < i_2< \ldots < i_r)且(a_j)在({1 \ldots s_{j-1}})中，其中(s_j)表示相应的相对顺序。

>>> from sympy.combinatorics.named_groups import SymmetricGroup
>>> from sympy.combinatorics.perm_groups import PermutationGroup
>>> from sympy.combinatorics.free_groups import free_group
>>> G = SymmetricGroup(4)
>>> PcGroup = G.polycyclic_group()
>>> collector = PcGroup.collector
>>> F, x0, x1, x2, x3 = free_group("x0, x1, x2, x3")
>>> word = x3*x2*x1*x0
>>> collected_word = collector.collected_word(word)
>>> free_to_perm = {}
>>> free_group = collector.free_group
>>> for sym, gen in zip(free_group.symbols, collector.pcgs):
...     free_to_perm[sym] = gen
>>> G1 = PermutationGroup()
>>> for w in word:
...     sym = w[0]
...     perm = free_to_perm[sym]
...     G1 = PermutationGroup([perm] + G1.generators)
>>> G2 = PermutationGroup()
>>> for w in collected_word:
...     sym = w[0]
...     perm = free_to_perm[sym]
...     G2 = PermutationGroup([perm] + G2.generators) 

这两者不完全相同，但它们是等价的：

>>> G1 == G2
False
>>> G1.equals(G2)
True 

多项式表示的计算

表示的计算从 pcgs 和多项式序列的底部开始。存储来自 pcgs 的所有先前生成器，然后将最后一个生成器作为在列表中作为共轭器的生成器，并共轭所有先前的生成器。

要获得清晰的图像，请以 SymmetricGroup(4)的示例开始。对于 S(4)，在 pcgs 中有 4 个生成器，即([x_0, x_1, x_2, x_3])，相对顺序向量为[2, 3, 2, 2]。从该序列的底部开始，按以下顺序计算表示。

使用pcgs和pc_series[4]中仅使用([x_3])计算：

• (x_3²)

使用pcgs和pc_series[3]中仅使用([x_3])计算：

• (x_2²)

• (x_2^{-1}x_3x_2)

使用pcgs和pc_series[2]中的([x_3, x_2])计算：

• (x_1³)

• (x_1^{-1}x_3x_1)

• (x_1^{-1}x_2x_1)

使用pcgs和pc_series[1]中的([x_3, x_2, x_1])计算：

• (x_0²)

• (x_0^{-1}x_3x_0)

• (x_0^{-1}x_2x_0)

• (x_0^{-1}x_1x_0)

需要注意的是，同一组可能由于不同的派生序列而具有不同的 pcgs，导致不同的多项式表示。

>>> from sympy.combinatorics.named_groups import SymmetricGroup
>>> from sympy.combinatorics.permutations import Permutation
>>> G = SymmetricGroup(4)
>>> PcGroup = G.polycyclic_group()
>>> collector = PcGroup.collector
>>> pcgs = PcGroup.pcgs
>>> len(pcgs)
4
>>> free_group = collector.free_group
>>> pc_resentation = collector.pc_presentation
>>> free_to_perm = {}
>>> for s, g in zip(free_group.symbols, pcgs):
...     free_to_perm[s] = g
>>> for k, v in pc_resentation.items():
...     k_array = k.array_form
...     if v != ():
...        v_array = v.array_form
...     lhs = Permutation()
...     for gen in k_array:
...         s = gen[0]
...         e = gen[1]
...         lhs = lhs*free_to_perm[s]**e
...     if v == ():
...         assert lhs.is_identity
...         continue
...     rhs = Permutation()
...     for gen in v_array:
...         s = gen[0]
...         e = gen[1]
...         rhs = rhs*free_to_perm[s]**e
...     assert lhs == rhs 

指数向量的计算

任何多项式群的生成器都可以借助其多项式生成序列来表示。因此，指数向量的长度等于 pcgs 的长度。

多项式群的给定生成器g可以表示为(g = x_1^{e_1} \ldots x_n^{e_n})，其中(x_i)代表多项式生成器，n是等于 pcgs 长度的自由群中生成器的数量。

>>> from sympy.combinatorics.named_groups import SymmetricGroup
>>> from sympy.combinatorics.permutations import Permutation
>>> G = SymmetricGroup(4)
>>> PcGroup = G.polycyclic_group()
>>> collector = PcGroup.collector
>>> pcgs = PcGroup.pcgs
>>> collector.exponent_vector(G[0])
[1, 0, 0, 0]
>>> exp = collector.exponent_vector(G[1])
>>> g = Permutation()
>>> for i in range(len(exp)):
...     g = g*pcgs[i]**exp[i] if exp[i] else g
>>> assert g == G[1] 

多项式生成器的深度

给定多项式生成器的深度定义为指数向量中第一个非零条目的索引。

>>> from sympy.combinatorics.named_groups import SymmetricGroup
>>> G = SymmetricGroup(3)
>>> PcGroup = G.polycyclic_group()
>>> collector = PcGroup.collector
>>> collector.depth(G[0])
2
>>> collector.depth(G[1])
1 

主导指数的计算

主导指数表示上述深度的多项式生成器的指数。

>>> from sympy.combinatorics.named_groups import SymmetricGroup
>>> G = SymmetricGroup(3)
>>> PcGroup = G.polycyclic_group()
>>> collector = PcGroup.collector
>>> collector.leading_exponent(G[1])
1 

参考文献

[Ho05]

Derek F. Holt，《计算群论手册》。在系列‘离散数学及其应用’中，Chapman & Hall/CRC 2005, xvi + 514 p。

函数

原文：docs.sympy.org/latest/modules/functions/index.html

所有函数都支持以下文档化方法，从继承自sympy.core.function.Function的函数中继承。

class sympy.core.function.Function(*args)

应用数学函数的基类。

它还作为未定义函数类的构造函数。

有关如何子类化Function以及可以定义哪些方法的详细信息，请参见编写自定义函数指南。

示例

未定义函数

要创建未定义函数，请将函数名的字符串传递给Function。

>>> from sympy import Function, Symbol
>>> x = Symbol('x')
>>> f = Function('f')
>>> g = Function('g')(x)
>>> f
f
>>> f(x)
f(x)
>>> g
g(x)
>>> f(x).diff(x)
Derivative(f(x), x)
>>> g.diff(x)
Derivative(g(x), x) 

可以将假设传递给Function，方式与Symbol相同。或者，您可以使用具有函数名和假设的Symbol作为函数名，并且函数将继承与Symbol相关联的名称和假设：

>>> f_real = Function('f', real=True)
>>> f_real(x).is_real
True
>>> f_real_inherit = Function(Symbol('f', real=True))
>>> f_real_inherit(x).is_real
True 

请注意，函数的假设与调用它的变量的假设无关。如果您想要添加关系，请子类化Function并定义自定义假设处理方法。有关详细信息，请参见编写自定义函数指南中的假设部分。

自定义函数子类

编写自定义函数指南有几个完整示例，展示了如何子类化Function以创建自定义函数。

as_base_exp()

返回方法作为二元组（底数，指数）。

fdiff(argindex=1)

返回函数的第一阶导数。

classmethod is_singular(a)

检测参数是本质奇点还是分支点，或者函数是非全纯的。

目录

• 初等函数

• 组合数学

• 枚举

• 特殊函数

基本

原文：docs.sympy.org/latest/modules/functions/elementary.html

该模块实现了如三角函数、双曲函数、平方根等基本函数，以及诸如Abs、Max、Min等函数。

复数函数

class sympy.functions.elementary.complexes.re(arg)

返回表达式的实部。此函数仅执行基本分析，因此无法正确分解更复杂的表达式。如果需要完全简化的结果，则使用Basic.as_real_imag()或在此函数实例上执行复杂展开。

参数：

arg : 表达式

实数或复数表达式。

返回：

expr : 表达式

表达式的实部。

示例

>>> from sympy import re, im, I, E, symbols
>>> x, y = symbols('x y', real=True)
>>> re(2*E)
2*E
>>> re(2*I + 17)
17
>>> re(2*I)
0
>>> re(im(x) + x*I + 2)
2
>>> re(5 + I + 2)
7 

另见

im

as_real_imag(deep=True, **hints)

返回具有零虚部的实数。

class sympy.functions.elementary.complexes.im(arg)

返回表达式的虚部。此函数仅执行基本分析，因此无法正确分解更复杂的表达式。如果需要完全简化的结果，则使用Basic.as_real_imag()或在此函数实例上执行复杂展开。

参数：

arg : 表达式

实数或复数表达式。

返回：

expr : 表达式

表达式的虚部。

示例

>>> from sympy import re, im, E, I
>>> from sympy.abc import x, y
>>> im(2*E)
0
>>> im(2*I + 17)
2
>>> im(x*I)
re(x)
>>> im(re(x) + y)
im(y)
>>> im(2 + 3*I)
3 

另见

re

as_real_imag(deep=True, **hints)

返回具有零实部的虚部。

class sympy.functions.elementary.complexes.sign(arg)

返回表达式的复数符号：

参数：

arg : 表达式

实数或虚数表达式。

返回：

expr : 表达式

表达式的复数符号。

解释

如果表达式为实数，则符号将为：

• 如果表达式为正则返回(1)。
• 如果表达式等于零则返回(0)。
• 如果表达式为负则返回(-1)。

如果表达式为虚数，则符号将为：

• 如果 im(expression)为正则返回(I)。
• 如果 im(expression)为负则返回(-I)。

否则将返回未评估的表达式。一般情况下，当评估时，结果将是cos(arg(expr)) + I*sin(arg(expr))。

示例

>>> from sympy import sign, I 

>>> sign(-1)
-1
>>> sign(0)
0
>>> sign(-3*I)
-I
>>> sign(1 + I)
sign(1 + I)
>>> _.evalf()
0.707106781186548 + 0.707106781186548*I 

另见

Abs, conjugate

class sympy.functions.elementary.complexes.Abs(arg)

返回参数的绝对值。

参数：

arg : 表达式

实数或复数表达式。

返回：

expr : 表达式

返回的绝对值可以是表达式或整数，取决于输入参数。

解释

这是内置函数abs()的扩展，接受符号值。如果将 SymPy 表达式传递给内置的abs()，它将自动传递给Abs()。

示例

>>> from sympy import Abs, Symbol, S, I
>>> Abs(-1)
1
>>> x = Symbol('x', real=True)
>>> Abs(-x)
Abs(x)
>>> Abs(x**2)
x**2
>>> abs(-x) # The Python built-in
Abs(x)
>>> Abs(3*x + 2*I)
sqrt(9*x**2 + 4)
>>> Abs(8*I)
8 

注意 Python 内置函数将根据参数返回 Expr 或 int：

>>> type(abs(-1))
<... 'int'>
>>> type(abs(S.NegativeOne))
<class 'sympy.core.numbers.One'> 

Abs 将始终返回一个 SymPy 对象。

另见

sign, conjugate

fdiff(argindex=1)

获取参数对 Abs()的第一阶导数。

class sympy.functions.elementary.complexes.arg(arg)

返回复数的参数（弧度）。参数按照atan2的一致约定进行评估，其中分支切割沿负实轴进行，arg(z)在区间((-\pi,\pi])内。对于正数，参数始终为 0；负数的参数为(\pi)；0 的参数未定义且返回nan。因此，arg函数永远不会嵌套超过 3 层，因为在第 4 次应用时，结果必须为 nan；对于实数，在第 3 次应用时返回 nan。

参数：

arg：Expr

实数或复数表达式。

返回：

value：Expr

返回以弧度测量的 arg 的反正切。

示例

>>> from sympy import arg, I, sqrt, Dummy
>>> from sympy.abc import x
>>> arg(2.0)
0
>>> arg(I)
pi/2
>>> arg(sqrt(2) + I*sqrt(2))
pi/4
>>> arg(sqrt(3)/2 + I/2)
pi/6
>>> arg(4 + 3*I)
atan(3/4)
>>> arg(0.8 + 0.6*I)
0.643501108793284
>>> arg(arg(arg(arg(x))))
nan
>>> real = Dummy(real=True)
>>> arg(arg(arg(real)))
nan 

class sympy.functions.elementary.complexes.conjugate(arg)

返回复共轭[R276]的参数。在数学中，复数的复共轭是通过改变虚部的符号得到的。

因此，复数(a + ib)（其中(a)和(b)为实数）的共轭是(a - ib)

参数：

arg：Expr

实数或复数表达式。

返回：

arg：Expr

arg 的复共轭作为实数、虚数或混合表达式。

示例

>>> from sympy import conjugate, I
>>> conjugate(2)
2
>>> conjugate(I)
-I
>>> conjugate(3 + 2*I)
3 - 2*I
>>> conjugate(5 - I)
5 + I 

另见

sign, Abs

参考文献

[R276] (1,2)

en.wikipedia.org/wiki/Complex_conjugation

class sympy.functions.elementary.complexes.polar_lift(arg)

将参数提升到对数的黎曼面，使用标准分支。

参数：

arg：Expr

实数或复数表达式。

示例

>>> from sympy import Symbol, polar_lift, I
>>> p = Symbol('p', polar=True)
>>> x = Symbol('x')
>>> polar_lift(4)
4*exp_polar(0)
>>> polar_lift(-4)
4*exp_polar(I*pi)
>>> polar_lift(-I)
exp_polar(-I*pi/2)
>>> polar_lift(I + 2)
polar_lift(2 + I) 

>>> polar_lift(4*x)
4*polar_lift(x)
>>> polar_lift(4*p)
4*p 

另见

sympy.functions.elementary.exponential.exp_polar, periodic_argument

class sympy.functions.elementary.complexes.periodic_argument(ar, period)

表示在对数的黎曼面的商上的参数。也就是说，给定一个周期(P)，始终返回((-P/2, P/2])内的值，通过使用(\exp(PI) = 1)。

参数：

ar：Expr

极坐标数。

period：Expr

周期(P)。

示例

>>> from sympy import exp_polar, periodic_argument
>>> from sympy import I, pi
>>> periodic_argument(exp_polar(10*I*pi), 2*pi)
0
>>> periodic_argument(exp_polar(5*I*pi), 4*pi)
pi
>>> from sympy import exp_polar, periodic_argument
>>> from sympy import I, pi
>>> periodic_argument(exp_polar(5*I*pi), 2*pi)
pi
>>> periodic_argument(exp_polar(5*I*pi), 3*pi)
-pi
>>> periodic_argument(exp_polar(5*I*pi), pi)
0 

另见

sympy.functions.elementary.exponential.exp_polar

polar_lift

将参数提升到对数的黎曼面

principal_branch

class sympy.functions.elementary.complexes.principal_branch(x, period)

表示在对数的黎曼面的商上的主分支的极坐标数。

参数：

x：Expr

极坐标数。

period：Expr

正实数或无穷大。

解释

这是一个两个参数的函数。第一个参数是极坐标数 (z)，第二个是正实数或无穷大，(p)。结果是 z mod exp_polar(I*p)。

示例

>>> from sympy import exp_polar, principal_branch, oo, I, pi
>>> from sympy.abc import z
>>> principal_branch(z, oo)
z
>>> principal_branch(exp_polar(2*pi*I)*3, 2*pi)
3*exp_polar(0)
>>> principal_branch(exp_polar(2*pi*I)*3*z, 2*pi)
3*principal_branch(z, 2*pi) 

另请参阅

sympy.functions.elementary.exponential.exp_polar

polar_lift

将参数提升到对数的黎曼曲面

periodic_argument

三角的

三角函数

class sympy.functions.elementary.trigonometric.sin(arg)

正弦函数。

返回以弧度测量的 x 的正弦值。

解释

当 (x/\pi) 是某个有理数时，此函数将自动评估 [R280]。例如，如果 (x) 是 (\pi) 的倍数，(\pi/2)，(\pi/3)，(\pi/4) 和 (\pi/6)。

示例

>>> from sympy import sin, pi
>>> from sympy.abc import x
>>> sin(x**2).diff(x)
2*x*cos(x**2)
>>> sin(1).diff(x)
0
>>> sin(pi)
0
>>> sin(pi/2)
1
>>> sin(pi/6)
1/2
>>> sin(pi/12)
-sqrt(2)/4 + sqrt(6)/4 

另请参阅

csc, cos, sec, tan, cot, asin, acsc, acos, asec, atan, acot, atan2

参考

[R277]

en.wikipedia.org/wiki/Trigonometric_functions

[R278]

dlmf.nist.gov/4.14

[R279]

functions.wolfram.com/ElementaryFunctions/Sin

[R280] (1,2)

mathworld.wolfram.com/TrigonometryAngles.html

class sympy.functions.elementary.trigonometric.cos(arg)

余弦函数。

返回以弧度测量的 x 的余弦值。

解释

有关自动评估的说明，请参见 sin()。

示例

>>> from sympy import cos, pi
>>> from sympy.abc import x
>>> cos(x**2).diff(x)
-2*x*sin(x**2)
>>> cos(1).diff(x)
0
>>> cos(pi)
-1
>>> cos(pi/2)
0
>>> cos(2*pi/3)
-1/2
>>> cos(pi/12)
sqrt(2)/4 + sqrt(6)/4 

另请参阅

sin, csc, sec, tan, cot, asin, acsc, acos, asec, atan, acot, atan2

参考

[R281]

en.wikipedia.org/wiki/Trigonometric_functions

[R282]

dlmf.nist.gov/4.14

[R283]

functions.wolfram.com/ElementaryFunctions/Cos

class sympy.functions.elementary.trigonometric.tan(arg)

正切函数。

返回 x 的正切值（以弧度为单位）。

解释

有关自动评估的说明，请参见 sin。

示例

>>> from sympy import tan, pi
>>> from sympy.abc import x
>>> tan(x**2).diff(x)
2*x*(tan(x**2)**2 + 1)
>>> tan(1).diff(x)
0
>>> tan(pi/8).expand()
-1 + sqrt(2) 

另请参见

sin, csc, cos, sec, cot, asin, acsc, acos, asec, atan, acot, atan2

参考文献

[R284]

en.wikipedia.org/wiki/Trigonometric_functions

[R285]

dlmf.nist.gov/4.14

[R286]

functions.wolfram.com/ElementaryFunctions/Tan

inverse(argindex=1)

返回此函数的倒数。

class sympy.functions.elementary.trigonometric.cot(arg)

余切函数。

返回 x 的余切（以弧度表示）。

解释

参见sin以获取有关自动评估的说明。

示例

>>> from sympy import cot, pi
>>> from sympy.abc import x
>>> cot(x**2).diff(x)
2*x*(-cot(x**2)**2 - 1)
>>> cot(1).diff(x)
0
>>> cot(pi/12)
sqrt(3) + 2 

另请参阅

sin，csc，cos，sec，tan，asin，acsc，acos，asec，atan，acot，atan2

参考资料

[R287]

en.wikipedia.org/wiki/Trigonometric_functions

[R288]

dlmf.nist.gov/4.14

[R289]

functions.wolfram.com/ElementaryFunctions/Cot

inverse(argindex=1)

返回此函数的倒数。

class sympy.functions.elementary.trigonometric.sec(arg)

正割函数。

返回 x 的正割（以弧度表示）。

解释

有关自动评估的说明，请参阅sin。

示例

>>> from sympy import sec
>>> from sympy.abc import x
>>> sec(x**2).diff(x)
2*x*tan(x**2)*sec(x**2)
>>> sec(1).diff(x)
0 

另见

sin，csc，cos，tan，cot，asin，acsc，acos，asec，atan，acot，atan2

参考文献

[R290]

en.wikipedia.org/wiki/Trigonometric_functions

[R291]

dlmf.nist.gov/4.14

[R292]

functions.wolfram.com/ElementaryFunctions/Sec

class sympy.functions.elementary.trigonometric.csc(arg)

余割函数。

返回 x 的余割（以弧度表示）。

解释

有关自动评估的注释，请参见 sin()。

示例

>>> from sympy import csc
>>> from sympy.abc import x
>>> csc(x**2).diff(x)
-2*x*cot(x**2)*csc(x**2)
>>> csc(1).diff(x)
0 

另请参见

sin, cos, sec, tan, cot, asin, acsc, acos, asec, atan, acot, atan2

参考文献

[R293]

en.wikipedia.org/wiki/Trigonometric_functions

[R294]

dlmf.nist.gov/4.14

[R295]

functions.wolfram.com/ElementaryFunctions/Csc

class sympy.functions.elementary.trigonometric.sinc(arg)

表示未归一化的 sinc 函数：

[\begin{split}\operatorname{sinc}(x) = \begin{cases} \frac{\sin x}{x} & \qquad x \neq 0 \ 1 & \qquad x = 0 \end{cases}\end{split}]

例子

>>> from sympy import sinc, oo, jn
>>> from sympy.abc import x
>>> sinc(x)
sinc(x) 

• 自动评估

>>> sinc(0)
1
>>> sinc(oo)
0 

• 差分

>>> sinc(x).diff()
cos(x)/x - sin(x)/x**2 

• 级数展开

>>> sinc(x).series()
1 - x**2/6 + x**4/120 + O(x**6) 

• 作为零阶球形贝塞尔函数

>>> sinc(x).rewrite(jn)
jn(0, x) 

另请参阅

sin

参考文献

[R296]

en.wikipedia.org/wiki/Sinc_function

三角反函数

class sympy.functions.elementary.trigonometric.asin(arg)

反正弦函数。

返回 x 的反正弦值（弧度）。

解释

asin(x) 将在 (x \in {\infty, -\infty, 0, 1, -1}) 和某些结果为 (\pi) 的有理倍数的情况下自动评估（参见 eval 类方法）。

纯虚数参数将导致 asinh 表达式。

例子

>>> from sympy import asin, oo
>>> asin(1)
pi/2
>>> asin(-1)
-pi/2
>>> asin(-oo)
oo*I
>>> asin(oo)
-oo*I 

另请参阅

sin, csc, cos, sec, tan, cot, acsc, acos, asec, atan, acot, atan2

参考文献

[R297]

反三角函数

[R298]

NIST 4.23

[R299]

ArcSin 函数

inverse(argindex=1)

返回该函数的反函数。

class sympy.functions.elementary.trigonometric.acos(arg)

反余弦函数。

解释

返回 x 的反余弦（以弧度表示）。

acos(x) 在 (x \in {\infty, -\infty, 0, 1, -1}) 的情况下会自动计算，并且在结果为 (\pi) 的有理倍数时也会计算（参见 eval 类方法）。

acos(zoo) 会计算为 zoo（参见 sympy.functions.elementary.trigonometric.asec 的注释）。

纯虚参数将被重写为 asinh。

示例

>>> from sympy import acos, oo
>>> acos(1)
0
>>> acos(0)
pi/2
>>> acos(oo)
oo*I 

另见

sin, csc, cos, sec, tan, cot, asin, acsc, asec, atan, acot, atan2

参考资料

[R300]

反三角函数

[R301]

dlmf.nist.gov/4.23

[R302]

functions.wolfram.com/ElementaryFunctions/ArcCos

inverse(argindex=1)

返回该函数的倒数。

class sympy.functions.elementary.trigonometric.atan(arg)

反正切函数。

返回 x 的反正切（单位为弧度）。

解释

atan(x) 将自动计算在情况 (x \in {\infty, -\infty, 0, 1, -1}) 及某些结果为 (\pi) 的有理倍数时（见 eval 类方法）。

示例

>>> from sympy import atan, oo
>>> atan(0)
0
>>> atan(1)
pi/4
>>> atan(oo)
pi/2 

参见

sin, csc, cos, sec, tan, cot, asin, acsc, acos, asec, acot, atan2

参考文献

[R303]

en.wikipedia.org/wiki/Inverse_trigonometric_functions

[R304]

dlmf.nist.gov/4.23

[R305]

functions.wolfram.com/ElementaryFunctions/ArcTan

inverse(argindex=1)

返回此函数的反函数。

class sympy.functions.elementary.trigonometric.acot(arg)

反余切函数。

返回 x 的反余切（以弧度表示）。

解释

acot(x) 将在 (x \in {\infty, -\infty, \tilde{\infty}, 0, 1, -1}) 的情况下自动评估，并在结果为 (\pi) 的有理倍数之一时进行一些实例（参见 eval 类方法）。

纯虚数参数将导致 acoth 表达式。

acot(x)在 ((-i, i)) 范围内有一个分支切，因此在 0 处不连续。其在实数 (x) 范围内的取值是 ((-\frac{\pi}{2}, \frac{\pi}{2}])。

示例

>>> from sympy import acot, sqrt
>>> acot(0)
pi/2
>>> acot(1)
pi/4
>>> acot(sqrt(3) - 2)
-5*pi/12 

另请参阅

sin, csc, cos, sec, tan, cot, asin, acsc, acos, asec, atan, atan2

参考

[R306]

dlmf.nist.gov/4.23

[R307]

functions.wolfram.com/ElementaryFunctions/ArcCot

inverse(argindex=1)

返回这个函数的反函数。

class sympy.functions.elementary.trigonometric.asec(arg)

反余割函数。

返回 x 的反余割（弧秒，以弧度表示）。

说明

asec(x) 在情况 (x \in {\infty, -\infty, 0, 1, -1}) 时会自动评估，并且在结果是 (\pi) 的有理倍数时（见 eval 类方法）。

asec(x) 在区间 ([-1, 1]) 内有分支切割。对于复数参数，可以定义为 [R311]：

[\operatorname{sec^{-1}}(z) = -i\frac{\log\left(\sqrt{1 - z²} + 1\right)}{z}]

当 x = 0 时，对于正分支切割，极限评估为 zoo。对于负分支切割，极限

[\lim_{z \to 0}-i\frac{\log\left(-\sqrt{1 - z²} + 1\right)}{z}]

简化为 (-i\log\left(z/2 + O\left(z³\right)\right))，最终评估为 zoo。

由于 acos(x) = asec(1/x)，对于 acos(x) 可以给出类似的论证。

例子

>>> from sympy import asec, oo
>>> asec(1)
0
>>> asec(-1)
pi
>>> asec(0)
zoo
>>> asec(-oo)
pi/2 

另见

sin, csc, cos, sec, tan, cot, asin, acsc, acos, atan, acot, atan2

参考

[R308]

en.wikipedia.org/wiki/Inverse_trigonometric_functions

[R309]

dlmf.nist.gov/4.23

[R310]

functions.wolfram.com/ElementaryFunctions/ArcSec

[R311] (1,2)

reference.wolfram.com/language/ref/ArcSec.html

inverse(argindex=1)

返回此函数的反函数。

class sympy.functions.elementary.trigonometric.acsc(arg)

反三角函数。

返回 x 的反余割（以弧度表示）。

解释

acsc(x) 在情况(x \in {\infty, -\infty, 0, 1, -1})时将自动评估，并且在结果是(π)的有理倍数的一些情况下（见eval类方法）。

示例

>>> from sympy import acsc, oo
>>> acsc(1)
pi/2
>>> acsc(-1)
-pi/2
>>> acsc(oo)
0
>>> acsc(-oo) == acsc(oo)
True
>>> acsc(0)
zoo 

参见

sin, csc, cos, sec, tan, cot, asin, acos, asec, atan, acot, atan2

参考文献

[R312]

en.wikipedia.org/wiki/Inverse_trigonometric_functions

[R313]

dlmf.nist.gov/4.23

[R314]

functions.wolfram.com/ElementaryFunctions/ArcCsc

inverse(argindex=1)

返回此函数的反函数。

class sympy.functions.elementary.trigonometric.atan2(y, x)

函数atan2(y, x)计算(\operatorname{atan}(y/x))，并接受两个参数(y)和(x)。考虑(y)和(x)的符号以确定(\operatorname{atan}(y/x))的适当象限。其范围为((-\pi, \pi])。完整的定义如下：

[\begin{split}\operatorname{atan2}(y, x) = \begin{cases} \arctan\left(\frac y x\right) & \qquad x > 0 \ \arctan\left(\frac y x\right) + \pi& \qquad y \ge 0, x < 0 \ \arctan\left(\frac y x\right) - \pi& \qquad y < 0, x < 0 \ +\frac{\pi}{2} & \qquad y > 0, x = 0 \ -\frac{\pi}{2} & \qquad y < 0, x = 0 \ \text{undefined} & \qquad y = 0, x = 0 \end{cases}\end{split}]

注意：注意到两个参数的角色互换。(y)-坐标是第一个参数，(x)-坐标是第二个参数。

如果(x)或(y)是复数：

[\operatorname{atan2}(y, x) = -i\log\left(\frac{x + iy}{\sqrt{x² + y²}}\right)]

例子

逆时针绕原点我们找到以下角度：

>>> from sympy import atan2
>>> atan2(0, 1)
0
>>> atan2(1, 1)
pi/4
>>> atan2(1, 0)
pi/2
>>> atan2(1, -1)
3*pi/4
>>> atan2(0, -1)
pi
>>> atan2(-1, -1)
-3*pi/4
>>> atan2(-1, 0)
-pi/2
>>> atan2(-1, 1)
-pi/4 

这些都是正确的。将其与普通的(\operatorname{atan})函数在点((x, y) = (-1, 1))处的结果进行比较

>>> from sympy import atan, S
>>> atan(S(1)/-1)
-pi/4
>>> atan2(1, -1)
3*pi/4 

只有(\operatorname{atan2})函数返回我们期望的值。我们可以对两个参数分别求导：

>>> from sympy import diff
>>> from sympy.abc import x, y
>>> diff(atan2(y, x), x)
-y/(x**2 + y**2) 

>>> diff(atan2(y, x), y)
x/(x**2 + y**2) 

我们可以用复对数表示 (\operatorname{atan2}) 函数：

>>> from sympy import log
>>> atan2(y, x).rewrite(log)
-I*log((x + I*y)/sqrt(x**2 + y**2)) 

并且用 (\operatorname{atan}) 表示：

>>> from sympy import atan
>>> atan2(y, x).rewrite(atan)
Piecewise((2*atan(y/(x + sqrt(x**2 + y**2))), Ne(y, 0)), (pi, re(x) < 0), (0, Ne(x, 0)), (nan, True)) 

但请注意，此形式在负实轴上是未定义的。

参见

sin, csc, cos, sec, tan, cot, asin, acsc, acos, asec, atan, acot

参考

[R315]

en.wikipedia.org/wiki/Inverse_trigonometric_functions

[R316]

en.wikipedia.org/wiki/Atan2

[R317]

functions.wolfram.com/ElementaryFunctions/ArcTan2

双曲线

双曲函数

class sympy.functions.elementary.hyperbolic.HyperbolicFunction(*args)

双曲函数的基类。

参见

sinh, cosh, tanh, coth

class sympy.functions.elementary.hyperbolic.sinh(arg)

sinh(x) 是 x 的双曲正弦。

双曲正弦函数是 (\frac{e^x - e^{-x}}{2})。

例子

>>> from sympy import sinh
>>> from sympy.abc import x
>>> sinh(x)
sinh(x) 

参见

cosh, tanh, asinh

as_real_imag(deep=True, **hints)

返回此函数的复坐标。

fdiff(argindex=1)

返回此函数的一阶导数。

inverse(argindex=1)

返回此函数的反函数。

static taylor_term(n, x, *previous_terms)

返回泰勒级数展开中的下一个项。

class sympy.functions.elementary.hyperbolic.cosh(arg)

cosh(x) 是 x 的双曲余弦。

双曲余弦函数为 (\frac{e^x + e^{-x}}{2}).

示例

>>> from sympy import cosh
>>> from sympy.abc import x
>>> cosh(x)
cosh(x) 

参见

sinh, tanh, acosh

class sympy.functions.elementary.hyperbolic.tanh(arg)

tanh(x) 是 x 的双曲正切。

双曲正切函数为 (\frac{\sinh(x)}{\cosh(x)}).

示例

>>> from sympy import tanh
>>> from sympy.abc import x
>>> tanh(x)
tanh(x) 

参见

sinh, cosh, atanh

inverse(argindex=1)

返回此函数的反函数。

class sympy.functions.elementary.hyperbolic.coth(arg)

coth(x) 是 x 的双曲余切。

双曲余切函数为 (\frac{\cosh(x)}{\sinh(x)}).

示例

>>> from sympy import coth
>>> from sympy.abc import x
>>> coth(x)
coth(x) 

参见

sinh, cosh, acoth

inverse(argindex=1)

返回此函数的反函数。

class sympy.functions.elementary.hyperbolic.sech(arg)

sech(x) 是 x 的双曲正切。

双曲正切函数为 (\frac{2}{e^x + e^{-x}})

示例

>>> from sympy import sech
>>> from sympy.abc import x
>>> sech(x)
sech(x) 

参见

sinh, cosh, tanh, coth, csch, asinh, acosh

class sympy.functions.elementary.hyperbolic.csch(arg)

csch(x) 是 x 的双曲余切。

双曲余切函数为 (\frac{2}{e^x - e^{-x}})

示例

>>> from sympy import csch
>>> from sympy.abc import x
>>> csch(x)
csch(x) 

参见

sinh, cosh, tanh, sech, asinh, acosh

fdiff(argindex=1)

返回此函数的一阶导数

static taylor_term(n, x, *previous_terms)

返回泰勒级数展开的下一项

双曲反函数

class sympy.functions.elementary.hyperbolic.asinh(arg)

asinh(x) 是 x 的反双曲 sine 函数。

反双曲正弦函数。

例子

>>> from sympy import asinh
>>> from sympy.abc import x
>>> asinh(x).diff(x)
1/sqrt(x**2 + 1)
>>> asinh(1)
log(1 + sqrt(2)) 

参见

acosh, atanh, sinh

inverse(argindex=1)

返回该函数的反函数。

class sympy.functions.elementary.hyperbolic.acosh(arg)

acosh(x) 是 x 的反双曲 cosine 函数。

反双曲余弦函数。

例子

>>> from sympy import acosh
>>> from sympy.abc import x
>>> acosh(x).diff(x)
1/(sqrt(x - 1)*sqrt(x + 1))
>>> acosh(1)
0 

参见

asinh, atanh, cosh

inverse(argindex=1)

返回该函数的反函数。

class sympy.functions.elementary.hyperbolic.atanh(arg)

atanh(x) 是 x 的反双曲 tangent 函数。

反双曲正切函数。

例子

>>> from sympy import atanh
>>> from sympy.abc import x
>>> atanh(x).diff(x)
1/(1 - x**2) 

参见

asinh, acosh, tanh

inverse(argindex=1)

返回该函数的反函数。

class sympy.functions.elementary.hyperbolic.acoth(arg)

acoth(x) 是 x 的反双曲 cotangent 函数。

反双曲 cotangent 函数。

例子

>>> from sympy import acoth
>>> from sympy.abc import x
>>> acoth(x).diff(x)
1/(1 - x**2) 

参见

asinh, acosh, coth

inverse(argindex=1)

返回该函数的反函数。

class sympy.functions.elementary.hyperbolic.asech(arg)

asech(x) 是 x 的反双曲 secant 函数。

反双曲 secant 函数。

例子

>>> from sympy import asech, sqrt, S
>>> from sympy.abc import x
>>> asech(x).diff(x)
-1/(x*sqrt(1 - x**2))
>>> asech(1).diff(x)
0
>>> asech(1)
0
>>> asech(S(2))
I*pi/3
>>> asech(-sqrt(2))
3*I*pi/4
>>> asech((sqrt(6) - sqrt(2)))
I*pi/12 

参见

asinh, atanh, cosh, acoth

参考资料

[R318]

en.wikipedia.org/wiki/Hyperbolic_function

[R319]

dlmf.nist.gov/4.37

[R320]

functions.wolfram.com/ElementaryFunctions/ArcSech/

inverse(argindex=1)

返回该函数的反函数。

class sympy.functions.elementary.hyperbolic.acsch(arg)

acsch(x) 是 x 的反双曲 cosecant 函数。

反双曲 cosecant 函数。

例子

>>> from sympy import acsch, sqrt, I
>>> from sympy.abc import x
>>> acsch(x).diff(x)
-1/(x**2*sqrt(1 + x**(-2)))
>>> acsch(1).diff(x)
0
>>> acsch(1)
log(1 + sqrt(2))
>>> acsch(I)
-I*pi/2
>>> acsch(-2*I)
I*pi/6
>>> acsch(I*(sqrt(6) - sqrt(2)))
-5*I*pi/12 

参见

asinh

参考资料

[R321]

en.wikipedia.org/wiki/Hyperbolic_function

[R322]

dlmf.nist.gov/4.37

[R323]

functions.wolfram.com/ElementaryFunctions/ArcCsch/

inverse(argindex=1)

返回此函数的倒数。

整数函数

class sympy.functions.elementary.integers.ceiling(arg)

Ceiling 是一个一元函数，返回不小于其参数的最小整数值。此实现通过分别取实部和虚部的 ceiling 泛化到复数。

示例

>>> from sympy import ceiling, E, I, S, Float, Rational
>>> ceiling(17)
17
>>> ceiling(Rational(23, 10))
3
>>> ceiling(2*E)
6
>>> ceiling(-Float(0.567))
0
>>> ceiling(I/2)
I
>>> ceiling(S(5)/2 + 5*I/2)
3 + 3*I 

另请参阅

sympy.functions.elementary.integers.floor

参考文献

[R324]

“具体数学”由 Graham，第 87 页

[R325]

mathworld.wolfram.com/CeilingFunction.html

class sympy.functions.elementary.integers.floor(arg)

Floor 是一个一元函数，返回不大于其参数的最大整数值。此实现通过分别取实部和虚部的 floor 泛化到复数。

示例

>>> from sympy import floor, E, I, S, Float, Rational
>>> floor(17)
17
>>> floor(Rational(23, 10))
2
>>> floor(2*E)
5
>>> floor(-Float(0.567))
-1
>>> floor(-I/2)
-I
>>> floor(S(5)/2 + 5*I/2)
2 + 2*I 

另请参阅

sympy.functions.elementary.integers.ceiling

参考文献

[R326]

“具体数学”由 Graham，第 87 页

[R327]

mathworld.wolfram.com/FloorFunction.html

class sympy.functions.elementary.integers.RoundFunction(arg)

用于舍入函数的抽象基类。

class sympy.functions.elementary.integers.frac(arg)

表示 x 的分数部分

对于实数，其定义如 [R328]

[x - \left\lfloor{x}\right\rfloor]

示例

>>> from sympy import Symbol, frac, Rational, floor, I
>>> frac(Rational(4, 3))
1/3
>>> frac(-Rational(4, 3))
2/3 

整数参数返回零

>>> n = Symbol('n', integer=True)
>>> frac(n)
0 

重写为 floor

>>> x = Symbol('x')
>>> frac(x).rewrite(floor)
x - floor(x) 

适用于复数参数

>>> r = Symbol('r', real=True)
>>> t = Symbol('t', real=True)
>>> frac(t + I*r)
I*frac(r) + frac(t) 

另请参阅

sympy.functions.elementary.integers.floor, sympy.functions.elementary.integers.ceiling

参考文献

[R328] (1,2)

en.wikipedia.org/wiki/Fractional_part

[R329]

mathworld.wolfram.com/FractionalPart.html

指数

class sympy.functions.elementary.exponential.exp(arg)

指数函数，(e^x)。

参数：

arg : 表达式

示例

>>> from sympy import exp, I, pi
>>> from sympy.abc import x
>>> exp(x)
exp(x)
>>> exp(x).diff(x)
exp(x)
>>> exp(I*pi)
-1 

另请参阅

log

as_real_imag(deep=True, **hints)

返回此函数作为表示复数的二元组。

示例

>>> from sympy import exp, I
>>> from sympy.abc import x
>>> exp(x).as_real_imag()
(exp(re(x))*cos(im(x)), exp(re(x))*sin(im(x)))
>>> exp(1).as_real_imag()
(E, 0)
>>> exp(I).as_real_imag()
(cos(1), sin(1))
>>> exp(1+I).as_real_imag()
(E*cos(1), E*sin(1)) 

另请参阅

sympy.functions.elementary.complexes.re, sympy.functions.elementary.complexes.im

property base

返回指数函数的底数。

fdiff(argindex=1)

返回此函数的第一阶导数。

static taylor_term(n, x, *previous_terms)

计算泰勒级数展开的下一个项。

class sympy.functions.elementary.exponential.LambertW(x, k=None)

Lambert W 函数 (W(z)) 定义为 (w \exp(w)) 的反函数 [R330]。

解释

换句话说，(W(z)) 的值使得对于任意复数 (z) 都有 (z = W(z) \exp(W(z)))。Lambert W 函数是一个多值函数，有无穷多个分支 (W_k(z))，其中 (k \in \mathbb{Z})。每个分支给出方程 (z = w \exp(w)) 的不同解 (w)。

Lambert W 函数有两个部分实数分支：主分支 ((k = 0)) 在实数 (z > -1/e) 时为实数，(k = -1) 分支在 (-1/e < z < 0) 时为实数。除了 (k = 0) 外，所有分支在 (z = 0) 处有对数奇异性。

示例

>>> from sympy import LambertW
>>> LambertW(1.2)
0.635564016364870
>>> LambertW(1.2, -1).n()
-1.34747534407696 - 4.41624341514535*I
>>> LambertW(-1).is_real
False 

参考文献

[R330] (1,2)

en.wikipedia.org/wiki/Lambert_W_function

fdiff(argindex=1)

返回该函数的一阶导数。

class sympy.functions.elementary.exponential.log(arg, base=None)

自然对数函数 (\ln(x)) 或 (\log(x))。

解释

对数以自然底 (e) 取。要得到不同底数 (b) 的对数，使用 log(x, b)，这本质上是 log(x)/log(b) 的简写。

log 表示自然对数的主分支。因此，它在负实轴上有一个分支切断，并返回复数参数在 ((-\pi, \pi]) 内的值。

示例

>>> from sympy import log, sqrt, S, I
>>> log(8, 2)
3
>>> log(S(8)/3, 2)
-log(3)/log(2) + 3
>>> log(-1 + I*sqrt(3))
log(2) + 2*I*pi/3 

另请参阅

exp

as_base_exp()

以 (base, exponent) 的形式返回该函数。

as_real_imag(deep=True, **hints)

以复数坐标返回该函数。

示例

>>> from sympy import I, log
>>> from sympy.abc import x
>>> log(x).as_real_imag()
(log(Abs(x)), arg(x))
>>> log(I).as_real_imag()
(0, pi/2)
>>> log(1 + I).as_real_imag()
(log(sqrt(2)), pi/4)
>>> log(I*x).as_real_imag()
(log(Abs(x)), arg(I*x)) 

fdiff(argindex=1)

返回该函数的一阶导数。

inverse(argindex=1)

返回 (e^x)，即 (\log(x)) 的反函数。

static taylor_term(n, x, *previous_terms)

返回 (\log(1+x)) 泰勒级数展开的下一个项。

class sympy.functions.elementary.exponential.exp_polar(*args)

表示 极坐标数（请参阅 g-function Sphinx 文档）。

解释

exp_polar 表示函数 (Exp: \mathbb{C} \rightarrow \mathcal{S})，将复数 (z = a + bi) 发送到极坐标数 (r = exp(a), \theta = b)。它是构建极坐标数的主要函数之一。

示例

>>> from sympy import exp_polar, pi, I, exp 

主要区别在于极坐标数不会在 (2 \pi) 处“环绕”：

>>> exp(2*pi*I)
1
>>> exp_polar(2*pi*I)
exp_polar(2*I*pi) 

除此之外，它们的行为大多像经典复数一样：

>>> exp_polar(2)*exp_polar(3)
exp_polar(5) 

另请参阅

sympy.simplify.powsimp.powsimp, polar_lift, periodic_argument, principal_branch

Piecewise

class sympy.functions.elementary.piecewise.ExprCondPair(expr, cond)

表示一个表达式、条件对。

property cond

返回这对的条件。

property expr

返回这对的表达式。

class sympy.functions.elementary.piecewise.Piecewise(*_args)

表示一个分段函数。

用法：

Piecewise( (expr,cond), (expr,cond), … )

• 每个参数都是定义表达式和条件的 2-元组
• 逐个评估条件，返回第一个为True的条件。如果任何评估的条件不明确为False，例如x < 1，则函数以符号形式返回。
• 如果在所有条件均为False的位置评估函数，则将返回nan。
• 如果cond明确为False，则将删除条件为False的对，并且在True条件后出现的对将永远不会被保留。如果只剩下一个带有True条件的对，则将返回它，即使评估为False也是如此。

示例

>>> from sympy import Piecewise, log, piecewise_fold
>>> from sympy.abc import x, y
>>> f = x**2
>>> g = log(x)
>>> p = Piecewise((0, x < -1), (f, x <= 1), (g, True))
>>> p.subs(x,1)
1
>>> p.subs(x,5)
log(5) 

布尔值可以包含分段元素：

>>> cond = (x < y).subs(x, Piecewise((2, x < 0), (3, True))); cond
Piecewise((2, x < 0), (3, True)) < y 

这种折叠版本的结果是一个布尔值的分段函数：

>>> folded_cond = piecewise_fold(cond); folded_cond
Piecewise((2 < y, x < 0), (3 < y, True)) 

当包含分段函数的布尔值（如cond）或带有布尔表达式的分段函数（如folded_cond）被用作条件时，它将转换为等效的ITE对象：

>>> Piecewise((1, folded_cond))
Piecewise((1, ITE(x < 0, y > 2, y > 3))) 

当条件是一个ITE时，它将被转换为简化的布尔表达式：

>>> piecewise_fold(_)
Piecewise((1, ((x >= 0) | (y > 2)) & ((y > 3) | (x < 0)))) 

参见

piecewise_fold, piecewise_exclusive, ITE

_eval_integral(x, _first=True, **kwargs)

返回分段函数的不定积分，使得将 x 替换为一个值后将给出积分的值（不包括积分常数）。要仅积分分段函数的各部分，请使用piecewise_integrate方法。

示例

>>> from sympy import Piecewise
>>> from sympy.abc import x
>>> p = Piecewise((0, x < 0), (1, x < 1), (2, True))
>>> p.integrate(x)
Piecewise((0, x < 0), (x, x < 1), (2*x - 1, True))
>>> p.piecewise_integrate(x)
Piecewise((0, x < 0), (x, x < 1), (2*x, True)) 

参见

Piecewise.piecewise_integrate

as_expr_set_pairs(domain=None)

返回每个 self 参数的元组，给出表达式和其在给定域内包含的有效区间。如果条件无法转换为集合，则会引发错误。假定条件的变量为实数；将返回实值集合。

示例

>>> from sympy import Piecewise, Interval
>>> from sympy.abc import x
>>> p = Piecewise(
...     (1, x < 2),
...     (2,(x > 0) & (x < 4)),
...     (3, True))
>>> p.as_expr_set_pairs()
[(1, Interval.open(-oo, 2)),
 (2, Interval.Ropen(2, 4)),
 (3, Interval(4, oo))]
>>> p.as_expr_set_pairs(Interval(0, 3))
[(1, Interval.Ropen(0, 2)),
 (2, Interval(2, 3))] 

doit(**hints)

评估这个分段函数。

classmethod eval(*_args)

要么返回参数的修改版本，或者如果没有进行修改，则返回None。

在这里进行的修改：

1. 关系被规范化

2. 丢弃任何False条件

3. 忽略任何重复的先前条件

4. 任何带有真条件的参数均被丢弃

如果没有剩余的参数，则将返回nan。如果有一个带有True条件的单个参数，则将返回其对应的表达式。

示例

>>> from sympy import Piecewise
>>> from sympy.abc import x
>>> cond = -x < -1
>>> args = [(1, cond), (4, cond), (3, False), (2, True), (5, x < 1)]
>>> Piecewise(*args, evaluate=False)
Piecewise((1, -x < -1), (4, -x < -1), (2, True))
>>> Piecewise(*args)
Piecewise((1, x > 1), (2, True)) 

piecewise_integrate(x, **kwargs)

返回每个表达式的反导数的分段函数。要获得连续的反导数，请使用integrate()函数或方法。

示例

>>> from sympy import Piecewise
>>> from sympy.abc import x
>>> p = Piecewise((0, x < 0), (1, x < 1), (2, True))
>>> p.piecewise_integrate(x)
Piecewise((0, x < 0), (x, x < 1), (2*x, True)) 

注意这并不会产生连续函数，例如在 x = 1 处应用第三个条件，其原函数为 2*x，因此原函数的值为 2：

>>> anti = _
>>> anti.subs(x, 1)
2 

连续导数考虑到感兴趣点之前的积分 部分，然而：

>>> p.integrate(x)
Piecewise((0, x < 0), (x, x < 1), (2*x - 1, True))
>>> _.subs(x, 1)
1 

另请参见

Piecewise._eval_integral

sympy.functions.elementary.piecewise.piecewise_exclusive(expr, *, skip_nan=False, deep=True)

重写 Piecewise 以具有互斥条件。

参数：

expr: SymPy 表达式。

表达式中的任何 Piecewise 将被重写。

skip_nan: bool (默认 False)

如果 skip_nan 设置为 True，则最终不会包括 NaN 情况。

deep: bool (默认 True)

如果 deep 为 True，则 piecewise_exclusive() 将重写 expr 中的任何 Piecewise 子表达式，而不仅仅是重写 expr 本身。

返回：

一个与 expr 等价的表达式，但所有 Piecewise 都具有

已使用互斥条件重写。

解释

SymPy 以 “if-elif” 方式表示 Piecewise 的条件，允许多个条件同时为真。解释是首个为真的条件即为符合条件。虽然这在计算上是一个有用的表示，但这不是数学文本中典型显示分段函数的方式。可以使用 piecewise_exclusive() 函数将任何具有更典型互斥条件的 Piecewise 重写。

请注意，进一步处理结果的 Piecewise，例如简化它，很可能会使它变得非排他。因此，这主要是一个与打印 Piecewise 结合使用的函数，或者如果想要重新排序表达式条件对时使用的函数。

如果不能确定不同情况下的所有可能性都被Piecewise覆盖，则最终将明确包含NaN情况。可以通过传递skip_nan=True来防止这种情况。

示例

>>> from sympy import piecewise_exclusive, Symbol, Piecewise, S
>>> x = Symbol('x', real=True)
>>> p = Piecewise((0, x < 0), (S.Half, x <= 0), (1, True))
>>> piecewise_exclusive(p)
Piecewise((0, x < 0), (1/2, Eq(x, 0)), (1, x > 0))
>>> piecewise_exclusive(Piecewise((2, x > 1)))
Piecewise((2, x > 1), (nan, x <= 1))
>>> piecewise_exclusive(Piecewise((2, x > 1)), skip_nan=True)
Piecewise((2, x > 1)) 

另见

Piecewise, piecewise_fold

sympy.functions.elementary.piecewise.piecewise_fold(expr, evaluate=True)

获取包含分段函数的表达式并以分段形式返回表达式。此外，任何 ITE 条件都将被重写为否定标准形式并简化。

默认情况下评估最终的 Piecewise，但如果需要原始形式，请发送evaluate=False；如果需要平凡评估，请发送evaluate=None，并处理 True 和 False 的重复条件和处理。

示例

>>> from sympy import Piecewise, piecewise_fold, S
>>> from sympy.abc import x
>>> p = Piecewise((x, x < 1), (1, S(1) <= x))
>>> piecewise_fold(x*p)
Piecewise((x**2, x < 1), (x, True)) 

另见

Piecewise, piecewise_exclusive

杂项

class sympy.functions.elementary.miscellaneous.IdentityFunction

恒等函数

示例

>>> from sympy import Id, Symbol
>>> x = Symbol('x')
>>> Id(x)
x 

class sympy.functions.elementary.miscellaneous.Min(*args)

返回列表的最小值，如果可能的话。它被命名为Min而不是min，以避免与内置函数min冲突。

示例

>>> from sympy import Min, Symbol, oo
>>> from sympy.abc import x, y
>>> p = Symbol('p', positive=True)
>>> n = Symbol('n', negative=True) 

>>> Min(x, -2)
Min(-2, x)
>>> Min(x, -2).subs(x, 3)
-2
>>> Min(p, -3)
-3
>>> Min(x, y)
Min(x, y)
>>> Min(n, 8, p, -7, p, oo)
Min(-7, n) 

另见

Max

查找最大值

class sympy.functions.elementary.miscellaneous.Max(*args)

返回列表的最大值，如果可能的话。

当参数数量等于一时，返回该参数。

当参数数量等于两时，返回(a, b)中较大的值。

通常情况下，当列表长度大于 2 时，任务更加复杂。如果可能确定方向关系，则仅返回大于其他参数的参数。

如果无法确定这样的关系，则返回部分评估结果。

决策也使用假设。

同时，只允许可比较的参数。

它被命名为Max而不是max，以避免与内置函数max冲突。

示例

>>> from sympy import Max, Symbol, oo
>>> from sympy.abc import x, y, z
>>> p = Symbol('p', positive=True)
>>> n = Symbol('n', negative=True) 

>>> Max(x, -2)
Max(-2, x)
>>> Max(x, -2).subs(x, 3)
3
>>> Max(p, -2)
p
>>> Max(x, y)
Max(x, y)
>>> Max(x, y) == Max(y, x)
True
>>> Max(x, Max(y, z))
Max(x, y, z)
>>> Max(n, 8, p, 7, -oo)
Max(8, p)
>>> Max (1, x, oo)
oo 

• 算法

该任务可以被视为在有向完全偏序集合中寻找最小上界[R331]。

源值按顺序分配给孤立子集，在其中搜索最小上界并作为 Max 参数返回。

如果结果的最小上界是唯一的，则返回该值。

孤立的子集是在当前集合中只能相互比较的值的集合。例如，自然数可以相互比较，但不能与符号(x)比较。另一个例子：带有负假设的符号(x)可以与自然数比较。

还有“最小”元素，它们与所有其他元素可比，并具有零属性（所有元素的最大或最小值）。例如，在(\infty)的情况下，分配操作终止，只返回此值。

假设：

• 如果(A > B > C)，则(A > C)

• 如果(A = B)，则可以删除(B)

另请参阅

Min

查找最小值

参考

[R331] (1,2)

zh.wikipedia.org/wiki/定向完全偏序

[R332]

zh.wikipedia.org/wiki/格 _(數學)

sympy.functions.elementary.miscellaneous.root(arg, n, k=0, evaluate=None)

返回arg的第k个第n个根。

参数：

k：int，可选

应为({0, 1, ..., n-1})中的整数。如果(0)，则默认为主根。

evaluate：bool，可选

此参数确定是否应评估表达式。如果为None，则其值来自global_parameters.evaluate。

示例

>>> from sympy import root, Rational
>>> from sympy.abc import x, n 

>>> root(x, 2)
sqrt(x) 

>>> root(x, 3)
x**(1/3) 

>>> root(x, n)
x**(1/n) 

>>> root(x, -Rational(2, 3))
x**(-3/2) 

要获取第 k 个 n 次根，指定 k：

>>> root(-2, 3, 2)
-(-1)**(2/3)*2**(1/3) 

要获得所有n个根，可以使用 rootof 函数。以下示例显示了 n 等于 2、3 和 4 时的单位根：

>>> from sympy import rootof 

>>> [rootof(x**2 - 1, i) for i in range(2)]
[-1, 1] 

>>> [rootof(x**3 - 1,i) for i in range(3)]
[1, -1/2 - sqrt(3)*I/2, -1/2 + sqrt(3)*I/2] 

>>> [rootof(x**4 - 1,i) for i in range(4)]
[-1, 1, -I, I] 

SymPy 与其他符号代数系统一样，返回负数的复根。这是主根，与可能期望的教科书结果不同。例如，-8 的立方根不会返回为-2：

>>> root(-8, 3)
2*(-1)**(1/3) 

real_root 函数可用于使主要结果变为实数（或直接返回实根）：

>>> from sympy import real_root
>>> real_root(_)
-2
>>> real_root(-32, 5)
-2 

或者，可以使用 root 来计算负数的第 n//2 个 n 次根：

>>> root(-32, 5, 5//2)
-2 

另请参阅

sympy.polys.rootoftools.rootof, sympy.core.intfunc.integer_nthroot, sqrt, real_root

参考

[R333]

zh.wikipedia.org/wiki/平方根

[R334]

zh.wikipedia.org/wiki/实根

[R335]

zh.wikipedia.org/wiki/单位根

[R336]

zh.wikipedia.org/wiki/主值

[R337]

zh.wikipedia.org/wiki/立方根

sympy.functions.elementary.miscellaneous.sqrt(arg, evaluate=None)

返回主平方根。

参数：

evaluate：bool，可选

此参数确定是否应评估表达式。如果为None，则其值来自global_parameters.evaluate。

示例

>>> from sympy import sqrt, Symbol, S
>>> x = Symbol('x') 

>>> sqrt(x)
sqrt(x) 

>>> sqrt(x)**2
x 

请注意，sqrt(x**2)不简化为 x。

>>> sqrt(x**2)
sqrt(x**2) 

这是因为一般情况下两者不相等。例如，考虑(x == -1)：

>>> from sympy import Eq
>>> Eq(sqrt(x**2), x).subs(x, -1)
False 

这是因为 sqrt 计算主方根，因此平方可能将参数放在不同的分支中。如果 x 为正数，则此恒等式成立：

>>> y = Symbol('y', positive=True)
>>> sqrt(y**2)
y 

您可以通过将 force 选项设置为 True 来强制使用 powdenest()函数进行此简化：

>>> from sympy import powdenest
>>> sqrt(x**2)
sqrt(x**2)
>>> powdenest(sqrt(x**2), force=True)
x 

要获取平方根的两个分支，可以使用rootof函数：

>>> from sympy import rootof 

>>> [rootof(x**2-3,i) for i in (0,1)]
[-sqrt(3), sqrt(3)] 

虽然打印了sqrt，但没有sqrt函数，因此在表达式中查找sqrt将失败：

>>> from sympy.utilities.misc import func_name
>>> func_name(sqrt(x))
'Pow'
>>> sqrt(x).has(sqrt)
False 

要查找sqrt，请查找带有指数1/2的Pow：

>>> (x + 1/sqrt(x)).find(lambda i: i.is_Pow and abs(i.exp) is S.Half)
{1/sqrt(x)} 

另请参阅

sympy.polys.rootoftools.rootof，root，real_root

参考

[R338]

en.wikipedia.org/wiki/Square_root

[R339]

en.wikipedia.org/wiki/Principal_value

sympy.functions.elementary.miscellaneous.cbrt(arg, evaluate=None)

返回主立方根。

参数：

evaluate：布尔值，可选

参数确定是否应该评估表达式。如果为None，其值将从global_parameters.evaluate中获取。

示例

>>> from sympy import cbrt, Symbol
>>> x = Symbol('x') 

>>> cbrt(x)
x**(1/3) 

>>> cbrt(x)**3
x 

注意，cbrt(x**3)不简化为 x。

>>> cbrt(x**3)
(x**3)**(1/3) 

这是因为一般情况下两者不相等。例如，考虑(x == -1)：

>>> from sympy import Eq
>>> Eq(cbrt(x**3), x).subs(x, -1)
False 

这是因为 cbrt 计算主立方根，如果(x)为正数，则此恒等式成立：

>>> y = Symbol('y', positive=True)
>>> cbrt(y**3)
y 

另请参阅

sympy.polys.rootoftools.rootof，root，real_root

参考

[R340]

en.wikipedia.org/wiki/Cube_root

[R341]

en.wikipedia.org/wiki/Principal_value

sympy.functions.elementary.miscellaneous.real_root(arg, n=None, evaluate=None)

返回arg的实数第n次根（如果可能）。

参数：

n：整数或None，可选

如果n为None，则所有((-n)^{1/\text{odd}})的实例将更改为(-n^{1/\text{odd}})。这仅会创建主根的实根。其他因素的存在可能导致结果不是实数。

evaluate：布尔值，可选

参数确定是否应该评估表达式。如果为None，其值将从global_parameters.evaluate中获取。

示例

>>> from sympy import root, real_root 

>>> real_root(-8, 3)
-2
>>> root(-8, 3)
2*(-1)**(1/3)
>>> real_root(_)
-2 

如果创建非主根并应用real_root，则结果将不是实数（因此请谨慎使用）：

>>> root(-8, 3, 2)
-2*(-1)**(2/3)
>>> real_root(_)
-2*(-1)**(2/3) 

另请参阅

sympy.polys.rootoftools.rootof, sympy.core.intfunc.integer_nthroot, root, sqrt