微积分

与微积分相关的方法。

此模块实现了一种方法，用于找到给定拉格朗日量的欧拉-拉格朗日方程。

sympy.calculus.euler.euler_equations(L, funcs=(), vars=())[源代码][源代码]

找到给定拉格朗日量的欧拉-拉格朗日方程 [1]。

参数:
L表达式

拉格朗日量应该是第二个参数中列出的函数及其导数的函数。

例如，在两个函数 \(f(x,y)\)、\(g(x,y)\) 和两个独立变量 \(x\)、\(y\) 的情况下，拉格朗日函数的形式为：

\[L\left(f(x,y),g(x,y),\frac{\partial f(x,y)}{\partial x},\frac{\partial f(x,y)}{\partial y},\frac{\partial g(x,y)}{\partial x},\frac{\partial g(x,y)}{\partial y},x,y\right)\]

在许多情况下，除了拉格朗日量之外，不需要提供任何东西，它将被自动检测（如果无法完成，则会引发错误）。

函数函数或函数的可迭代对象

拉格朗日函数所依赖的函数。欧拉方程是这些函数中每一个的微分方程。

变量符号或符号的可迭代对象

这些符号是函数的自变量。

返回:
方程式Eq 列表

微分方程列表，每个函数对应一个。

参考文献

示例

>>> from sympy import euler_equations, Symbol, Function
>>> x = Function('x')
>>> t = Symbol('t')
>>> L = (x(t).diff(t))**2/2 - x(t)**2/2
>>> euler_equations(L, x(t), t)
[Eq(-x(t) - Derivative(x(t), (t, 2)), 0)]
>>> u = Function('u')
>>> x = Symbol('x')
>>> L = (u(t, x).diff(t))**2/2 - (u(t, x).diff(x))**2/2
>>> euler_equations(L, u(t, x), [t, x])
[Eq(-Derivative(u(t, x), (t, 2)) + Derivative(u(t, x), (x, 2)), 0)]

奇点

此模块实现了用于查找函数奇点和识别函数类型的算法。

本模块中的微分计算方法包括识别给定 Interval 中的以下函数类型： - 递增 - 严格递增 - 递减 - 严格递减 - 单调

sympy.calculus.singularities.is_decreasing(
expression,
interval=Reals,
symbol=None,
)[源代码][源代码]

返回函数在给定区间内是否递减。

参数:
表达式表达式

正在检查的目标函数。

间隔设置，可选

我们测试的值的范围（默认为所有实数的集合）。

符号符号, 可选

表达式中存在的符号，在给定范围内变化。

返回:
布尔值

如果 expression 在给定的 interval 内是递减的（严格递减或恒定），则为 True，否则为 False。

示例

>>> from sympy import is_decreasing
>>> from sympy.abc import x, y
>>> from sympy import S, Interval, oo
>>> is_decreasing(1/(x**2 - 3*x), Interval.open(S(3)/2, 3))
True
>>> is_decreasing(1/(x**2 - 3*x), Interval.open(1.5, 3))
True
>>> is_decreasing(1/(x**2 - 3*x), Interval.Lopen(3, oo))
True
>>> is_decreasing(1/(x**2 - 3*x), Interval.Ropen(-oo, S(3)/2))
False
>>> is_decreasing(1/(x**2 - 3*x), Interval.Ropen(-oo, 1.5))
False
>>> is_decreasing(-x**2, Interval(-oo, 0))
False
>>> is_decreasing(-x**2 + y, Interval(-oo, 0), x)
False
sympy.calculus.singularities.is_increasing(
expression,
interval=Reals,
symbol=None,
)[源代码][源代码]

返回函数在给定区间内是否递增。

参数:
表达式表达式

正在检查的目标函数。

间隔设置，可选

我们测试的值的范围（默认为所有实数的集合）。

符号符号, 可选

表达式中存在的符号，在给定范围内变化。

返回:
布尔值

如果 expression 在给定的 interval 内是递增的（无论是严格递增还是常数），则为 True，否则为 False。

示例

>>> from sympy import is_increasing
>>> from sympy.abc import x, y
>>> from sympy import S, Interval, oo
>>> is_increasing(x**3 - 3*x**2 + 4*x, S.Reals)
True
>>> is_increasing(-x**2, Interval(-oo, 0))
True
>>> is_increasing(-x**2, Interval(0, oo))
False
>>> is_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval(-2, 3))
False
>>> is_increasing(x**2 + y, Interval(1, 2), x)
True
sympy.calculus.singularities.is_monotonic(
expression,
interval=Reals,
symbol=None,
)[源代码][源代码]

返回函数在给定区间内是否单调。

参数:
表达式表达式

正在检查的目标函数。

间隔设置，可选

我们测试的值的范围（默认为所有实数的集合）。

符号符号, 可选

表达式中存在的符号，在给定范围内变化。

返回:
布尔值

如果 expression 在给定的 interval 内是单调的，则为 True，否则为 False。

Raises:
NotImplementedError

所查询的函数的单调性检查尚未实现。

示例

>>> from sympy import is_monotonic
>>> from sympy.abc import x, y
>>> from sympy import S, Interval, oo
>>> is_monotonic(1/(x**2 - 3*x), Interval.open(S(3)/2, 3))
True
>>> is_monotonic(1/(x**2 - 3*x), Interval.open(1.5, 3))
True
>>> is_monotonic(1/(x**2 - 3*x), Interval.Lopen(3, oo))
True
>>> is_monotonic(x**3 - 3*x**2 + 4*x, S.Reals)
True
>>> is_monotonic(-x**2, S.Reals)
False
>>> is_monotonic(x**2 + y + 1, Interval(1, 2), x)
True
sympy.calculus.singularities.is_strictly_decreasing(
expression,
interval=Reals,
symbol=None,
)[源代码][源代码]

返回函数在给定区间内是否严格递减。

参数:
表达式表达式

正在检查的目标函数。

间隔设置，可选

我们测试的值的范围（默认为所有实数的集合）。

符号符号, 可选

表达式中存在的符号，在给定范围内变化。

返回:
布尔值

如果 expression 在给定的 interval 内严格递减，则为 True，否则为 False。

示例

>>> from sympy import is_strictly_decreasing
>>> from sympy.abc import x, y
>>> from sympy import S, Interval, oo
>>> is_strictly_decreasing(1/(x**2 - 3*x), Interval.Lopen(3, oo))
True
>>> is_strictly_decreasing(1/(x**2 - 3*x), Interval.Ropen(-oo, S(3)/2))
False
>>> is_strictly_decreasing(1/(x**2 - 3*x), Interval.Ropen(-oo, 1.5))
False
>>> is_strictly_decreasing(-x**2, Interval(-oo, 0))
False
>>> is_strictly_decreasing(-x**2 + y, Interval(-oo, 0), x)
False
sympy.calculus.singularities.is_strictly_increasing(
expression,
interval=Reals,
symbol=None,
)[源代码][源代码]

返回函数在给定区间内是否严格递增。

参数:
表达式表达式

正在检查的目标函数。

间隔设置，可选

我们测试的值的范围（默认为所有实数的集合）。

符号符号, 可选

表达式中存在的符号，在给定范围内变化。

返回:
布尔值

如果 expression 在给定的 interval 内严格递增，则为 True，否则为 False。

示例

>>> from sympy import is_strictly_increasing
>>> from sympy.abc import x, y
>>> from sympy import Interval, oo
>>> is_strictly_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval.Ropen(-oo, -2))
True
>>> is_strictly_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval.Lopen(3, oo))
True
>>> is_strictly_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval.open(-2, 3))
False
>>> is_strictly_increasing(-x**2, Interval(0, oo))
False
>>> is_strictly_increasing(-x**2 + y, Interval(-oo, 0), x)
False
sympy.calculus.singularities.monotonicity_helper(
expression,
predicate,
interval=Reals,
symbol=None,
)[源代码][源代码]

用于检查函数单调性的辅助函数。

参数:
表达式表达式

正在检查的目标函数

谓词函数

正在测试的属性。该函数接收一个整数并返回一个布尔值。整数输入是导数，如果属性成立，布尔结果应为真，否则为假。

间隔设置，可选

我们测试的值的范围，默认为所有实数。

符号符号, 可选

表达式中存在的符号，在给定范围内变化。

它返回一个布尔值，指示是否在
函数的导数满足给定谓词是一个超集
给定区间的。
返回:
布尔值

如果 predicate 在 symbol 在 range 中变化时对所有导数都为真，则为 True，否则为 False。

sympy.calculus.singularities.singularities(expression, symbol, domain=None)[源代码][源代码]

找到给定函数的奇点。

参数:
表达式表达式

需要找到奇点的目标函数。

符号符号

在表达式中寻找奇点的值上方的符号。

返回:
设置

symbol 的一组值，其中 expression 具有奇点。如果 expression 对于任何给定的 Symbol 值都没有奇点，则返回 EmptySet。

Raises:
NotImplementedError

确定此函数奇异性的方法尚未开发。

注释

此函数不会找到非孤立奇点，也不会找到表达式的分支点。

目前支持的功能有：

  • 单变量连续（实数或复数）函数

参考文献

示例

>>> from sympy import singularities, Symbol, log
>>> x = Symbol('x', real=True)
>>> y = Symbol('y', real=False)
>>> singularities(x**2 + x + 1, x)
EmptySet
>>> singularities(1/(x + 1), x)
{-1}
>>> singularities(1/(y**2 + 1), y)
{-I, I}
>>> singularities(1/(y**3 + 1), y)
{-1, 1/2 - sqrt(3)*I/2, 1/2 + sqrt(3)*I/2}
>>> singularities(log(x), x)
{0}

有限差分权重

此模块实现了一种算法，用于高效生成有限差分权重，以计算函数普通导数的导数，从0阶（插值）到任意阶。

核心算法在有限差分权重生成函数 (finite_diff_weights) 中提供，并且提供了两个便利函数：

  • 直接从一系列点中估计导数（或插值）

    也提供了（apply_finite_diff）。

  • 通过使用有限差分近似进行微分

    differentiate_finite).

sympy.calculus.finite_diff.apply_finite_diff(order, x_list, y_list, x0=0)[源代码][源代码]

计算在 x0 处由 x_list 和 y_list 提供的点中请求阶数的导数的有限差分近似。

参数:
order: int

要近似的导数阶数。0 对应于插值。

x_list: 序列

独立变量的（唯一）值序列。

y_list: 序列

在 x_list 中对应的自变量值处的函数值。

x0: 数字或符号

应在独立变量的哪个值处计算导数。默认为 0。

返回:
sympy.core.add.Add 或 sympy.core.numbers.Number

在 x0 处近似请求的导数阶数的有限差分表达式。

参见

sympy.calculus.finite_diff.finite_diff_weights

注释

Order = 0 对应于插值。仅提供在提取导数时（函数在该区域内需要表现良好）在 x0 附近有意义的点数。同时要注意龙格现象。

参考文献

Fortran 90 实现，带有 Python 接口用于数值计算：finitediff

示例

>>> from sympy import apply_finite_diff
>>> cube = lambda arg: (1.0*arg)**3
>>> xlist = range(-3,3+1)
>>> apply_finite_diff(2, xlist, map(cube, xlist), 2) - 12 
-3.55271367880050e-15

我们看到上面的例子只包含舍入误差。apply_finite_diff 也可以用于更抽象的对象：

>>> from sympy import IndexedBase, Idx
>>> x, y = map(IndexedBase, 'xy')
>>> i = Idx('i')
>>> x_list, y_list = zip(*[(x[i+j], y[i+j]) for j in range(-1,2)])
>>> apply_finite_diff(1, x_list, y_list, x[i])
((x[i + 1] - x[i])/(-x[i - 1] + x[i]) - 1)*y[i]/(x[i + 1] - x[i]) -
(x[i + 1] - x[i])*y[i - 1]/((x[i + 1] - x[i - 1])*(-x[i - 1] + x[i])) +
(-x[i - 1] + x[i])*y[i + 1]/((x[i + 1] - x[i - 1])*(x[i + 1] - x[i]))
sympy.calculus.finite_diff.differentiate_finite(
expr,
*symbols,
points=1,
x0=None,
wrt=None,
evaluate=False,
)[源代码][源代码]

区分表达式并将导数替换为有限差分。

参数:
表达式表达式
*符号对符号求导
points: 序列, 系数或未定义函数, 可选

参见 Derivative.as_finite_difference

x0: 数字或符号, 可选

参见 Derivative.as_finite_difference

wrt: 符号，可选

参见 Derivative.as_finite_difference

示例

>>> from sympy import sin, Function, differentiate_finite
>>> from sympy.abc import x, y, h
>>> f, g = Function('f'), Function('g')
>>> differentiate_finite(f(x)*g(x), x, points=[x-h, x+h])
-f(-h + x)*g(-h + x)/(2*h) + f(h + x)*g(h + x)/(2*h)

differentiate_finite 适用于任何表达式，包括包含嵌入导数的表达式：

>>> differentiate_finite(f(x) + sin(x), x, 2)
-2*f(x) + f(x - 1) + f(x + 1) - 2*sin(x) + sin(x - 1) + sin(x + 1)
>>> differentiate_finite(f(x, y), x, y)
f(x - 1/2, y - 1/2) - f(x - 1/2, y + 1/2) - f(x + 1/2, y - 1/2) + f(x + 1/2, y + 1/2)
>>> differentiate_finite(f(x)*g(x).diff(x), x)
(-g(x) + g(x + 1))*f(x + 1/2) - (g(x) - g(x - 1))*f(x - 1/2)

要使用非恒定离散化步长进行有限差分，请使用未定义的函数：

>>> dx = Function('dx')
>>> differentiate_finite(f(x)*g(x).diff(x), points=dx(x))
-(-g(x - dx(x)/2 - dx(x - dx(x)/2)/2)/dx(x - dx(x)/2) +
g(x - dx(x)/2 + dx(x - dx(x)/2)/2)/dx(x - dx(x)/2))*f(x - dx(x)/2)/dx(x) +
(-g(x + dx(x)/2 - dx(x + dx(x)/2)/2)/dx(x + dx(x)/2) +
g(x + dx(x)/2 + dx(x + dx(x)/2)/2)/dx(x + dx(x)/2))*f(x + dx(x)/2)/dx(x)
sympy.calculus.finite_diff.finite_diff_weights(order, x_list, x0=1)[源代码][源代码]

计算任意间距的一维网格 (x_list) 在 x0 处的导数的有限差分权重，阶数为 0, 1, …, 直到 order，使用递归公式。如果 x_list 定义正确，精度至少为 len(x_list) - order。

参数:
order: int

应该计算到什么导数阶数的权重。0 对应于插值。

x_list: 序列

独立变量的（唯一）值序列。将 x_list 从最接近到最远离 x0 进行排序是有用的（但不是必需的）；请参见下面的示例。

x0: 数字或符号

应生成有限差分权重的自变量的根或值。默认值为 S.One。

返回:
列表

子列表的列表，每个子列表对应于增加的导数阶数的系数，并且每个子列表包含增加的 x_list 子集的系数列表。

参见

sympy.calculus.finite_diff.apply_finite_diff

注释

如果需要一个三阶导数的有限差分近似的权重，那么零阶、一阶和二阶的权重是“免费”计算的，使用 x_list 的子集的公式也是如此。这是可以利用来节省计算成本的。需要注意的是，应该从最接近 x0 的位置开始定义 x_list。否则，x_list 的子集将产生较差的近似，可能无法达到 len(x_list) - order 的精度阶数。

参考文献

[1]

任意间距网格上的有限差分公式生成，Bengt Fornberg；计算数学；51；184；(1988)；699-706；doi:10.1090/S0025-5718-1988-0935077-0

示例

>>> from sympy import finite_diff_weights, S
>>> res = finite_diff_weights(1, [-S(1)/2, S(1)/2, S(3)/2, S(5)/2], 0)
>>> res
[[[1, 0, 0, 0],
  [1/2, 1/2, 0, 0],
  [3/8, 3/4, -1/8, 0],
  [5/16, 15/16, -5/16, 1/16]],
 [[0, 0, 0, 0],
  [-1, 1, 0, 0],
  [-1, 1, 0, 0],
  [-23/24, 7/8, 1/8, -1/24]]]
>>> res[0][-1]  # FD weights for 0th derivative, using full x_list
[5/16, 15/16, -5/16, 1/16]
>>> res[1][-1]  # FD weights for 1st derivative
[-23/24, 7/8, 1/8, -1/24]
>>> res[1][-2]  # FD weights for 1st derivative, using x_list[:-1]
[-1, 1, 0, 0]
>>> res[1][-1][0]  # FD weight for 1st deriv. for x_list[0]
-23/24
>>> res[1][-1][1]  # FD weight for 1st deriv. for x_list[1], etc.
7/8

每个子列表在最后包含最准确的公式。注意，在上面的例子中 res[1][1] 与 res[1][2] 是相同的。由于 res[1][2] 的准确度阶数为 len(x_list[:3]) - order = 3 - 1 = 2，因此 res[1][1] 也是如此！

>>> res = finite_diff_weights(1, [S(0), S(1), -S(1), S(2), -S(2)], 0)[1]
>>> res
[[0, 0, 0, 0, 0],
 [-1, 1, 0, 0, 0],
 [0, 1/2, -1/2, 0, 0],
 [-1/2, 1, -1/3, -1/6, 0],
 [0, 2/3, -2/3, -1/12, 1/12]]
>>> res[0]  # no approximation possible, using x_list[0] only
[0, 0, 0, 0, 0]
>>> res[1]  # classic forward step approximation
[-1, 1, 0, 0, 0]
>>> res[2]  # classic centered approximation
[0, 1/2, -1/2, 0, 0]
>>> res[3:]  # higher order approximations
[[-1/2, 1, -1/3, -1/6, 0], [0, 2/3, -2/3, -1/12, 1/12]]

让我们将此与一个不同定义的 x_list 进行比较。注意 foo[i][k] 对应于由 x_list[k] 定义的网格点。

>>> foo = finite_diff_weights(1, [-S(2), -S(1), S(0), S(1), S(2)], 0)[1]
>>> foo
[[0, 0, 0, 0, 0],
 [-1, 1, 0, 0, 0],
 [1/2, -2, 3/2, 0, 0],
 [1/6, -1, 1/2, 1/3, 0],
 [1/12, -2/3, 0, 2/3, -1/12]]
>>> foo[1]  # not the same and of lower accuracy as res[1]!
[-1, 1, 0, 0, 0]
>>> foo[2]  # classic double backward step approximation
[1/2, -2, 3/2, 0, 0]
>>> foo[4]  # the same as res[4]
[1/12, -2/3, 0, 2/3, -1/12]

请注意，除非你计划使用基于 x_list 子集的近似值，否则网格点的顺序并不重要。

在任意点生成权重的功能可以用于例如通过使用切比雪夫节点来最小化龙格现象：

>>> from sympy import cos, symbols, pi, simplify
>>> N, (h, x) = 4, symbols('h x')
>>> x_list = [x+h*cos(i*pi/(N)) for i in range(N,-1,-1)] # chebyshev nodes
>>> print(x_list)
[-h + x, -sqrt(2)*h/2 + x, x, sqrt(2)*h/2 + x, h + x]
>>> mycoeffs = finite_diff_weights(1, x_list, 0)[1][4]
>>> [simplify(c) for c in  mycoeffs] 
[(h**3/2 + h**2*x - 3*h*x**2 - 4*x**3)/h**4,
(-sqrt(2)*h**3 - 4*h**2*x + 3*sqrt(2)*h*x**2 + 8*x**3)/h**4,
(6*h**2*x - 8*x**3)/h**4,
(sqrt(2)*h**3 - 4*h**2*x - 3*sqrt(2)*h*x**2 + 8*x**3)/h**4,
(-h**3/2 + h**2*x + 3*h*x**2 - 4*x**3)/h**4]
sympy.calculus.util.continuous_domain(f, symbol, domain)[源代码][源代码]

返回函数表达式 f 连续的域。

此函数受限于确定给定函数的各种奇点和间断点的能力。结果要么以区间并集的形式给出，要么使用其他集合操作构造。

参数:
f表达式

相关函数。

符号 : Symbol符号

要确定区间范围的变量。

域 : Interval区间

需要检查符号连续性的域。

返回:
Interval

函数连续的所有区间的并集。

Raises:
NotImplementedError

如果尚未开发出确定此类函数连续性的方法。

示例

>>> from sympy import Interval, Symbol, S, tan, log, pi, sqrt
>>> from sympy.calculus.util import continuous_domain
>>> x = Symbol('x')
>>> continuous_domain(1/x, x, S.Reals)
Union(Interval.open(-oo, 0), Interval.open(0, oo))
>>> continuous_domain(tan(x), x, Interval(0, pi))
Union(Interval.Ropen(0, pi/2), Interval.Lopen(pi/2, pi))
>>> continuous_domain(sqrt(x - 2), x, Interval(-5, 5))
Interval(2, 5)
>>> continuous_domain(log(2*x - 1), x, S.Reals)
Interval.open(1/2, oo)
sympy.calculus.util.function_range(f, symbol, domain)[源代码][源代码]

在给定域中找到函数的范围。此方法受限于确定奇点和确定极限的能力。

参数:
f表达式

相关函数。

符号 : Symbol符号

要确定其函数范围的变量。

域 : Interval区间

需要找到函数范围的域。

返回:
Interval

函数在定义域内连续的所有区间上所有范围的并集。

Raises:
NotImplementedError

如果在给定域中，函数的连续区间不是有限或实数，或者在该域上无法找到函数的临界点。

示例

>>> from sympy import Interval, Symbol, S, exp, log, pi, sqrt, sin, tan
>>> from sympy.calculus.util import function_range
>>> x = Symbol('x')
>>> function_range(sin(x), x, Interval(0, 2*pi))
Interval(-1, 1)
>>> function_range(tan(x), x, Interval(-pi/2, pi/2))
Interval(-oo, oo)
>>> function_range(1/x, x, S.Reals)
Union(Interval.open(-oo, 0), Interval.open(0, oo))
>>> function_range(exp(x), x, S.Reals)
Interval.open(0, oo)
>>> function_range(log(x), x, S.Reals)
Interval(-oo, oo)
>>> function_range(sqrt(x), x, Interval(-5, 9))
Interval(0, 3)
sympy.calculus.util.is_convex(f, *syms, domain=Reals)[源代码][源代码]

确定传入参数中函数的凸性。

参数:
f表达式

相关函数。

syms : Symbol 的元组元组

要确定其凸性的变量。

域 : Interval, 可选间隔，可选

需要检查函数凸性的定义域。如果未指定，S.Reals 将是默认的定义域。

返回:
布尔

如果函数是凸的，该方法返回 True，否则返回 False。

Raises:
NotImplementedError

多变量函数的凸性检查尚未实现。

注释

要确定一个函数的凹性，请将 \(-f\) 作为相关函数传递。要确定一个函数的对数凸性，请将对数函数 \(\log(f)\) 作为相关函数传递。要确定一个函数的对数凹性，请将对数函数 \(-\log(f)\) 作为相关函数传递。

目前，多变量函数的凸性检查未被处理。

参考文献

[3]

https://en.wikipedia.org/wiki/对数凸函数

[4]

https://en.wikipedia.org/wiki/对数凹函数

示例

>>> from sympy import is_convex, symbols, exp, oo, Interval
>>> x = symbols('x')
>>> is_convex(exp(x), x)
True
>>> is_convex(x**3, x, domain = Interval(-1, oo))
False
>>> is_convex(1/x**2, x, domain=Interval.open(0, oo))
True
sympy.calculus.util.lcim(numbers)[源代码][源代码]

返回一组数字的最小公倍数。

这些数字可以是理性的或非理性的，或两者的混合。对于不可通约的数字，返回 \(None\)。

参数:
数字列表

要找到其 lcim 的数字（有理数和/或无理数）。

返回:
数字

如果存在，则为 lcim，否则对于不可通约数为 None。

示例

>>> from sympy.calculus.util import lcim
>>> from sympy import S, pi
>>> lcim([S(1)/2, S(3)/4, S(5)/6])
15/2
>>> lcim([2*pi, 3*pi, pi, pi/2])
6*pi
>>> lcim([S(1), 2*pi])
sympy.calculus.util.maximum(f, symbol, domain=Reals)[源代码][源代码]

返回给定域中函数的最大值。

参数:
f表达式

相关函数。

符号 : Symbol符号

需要确定最大值的变量。

域 : Interval区间

需要检查最大值的范围。如果未指定，则返回全局最大值。

返回:
数字

给定域中函数的最大值。

示例

>>> from sympy import Interval, Symbol, S, sin, cos, pi, maximum
>>> x = Symbol('x')

>>> f = -x**2 + 2*x + 5
>>> maximum(f, x, S.Reals)
6

>>> maximum(sin(x), x, Interval(-pi, pi/4))
sqrt(2)/2

>>> maximum(sin(x)*cos(x), x)
1/2
sympy.calculus.util.minimum(f, symbol, domain=Reals)[源代码][源代码]

返回给定域中函数的最小值。

参数:
f表达式

相关函数。

符号 : Symbol符号

需要确定最小值的变量。

域 : Interval区间

需要检查最小值的范围。如果未指定，则返回全局最小值。

返回:
数字

给定域内函数的最小值。

示例

>>> from sympy import Interval, Symbol, S, sin, cos, minimum
>>> x = Symbol('x')

>>> f = x**2 + 2*x + 5
>>> minimum(f, x, S.Reals)
4

>>> minimum(sin(x), x, Interval(2, 3))
sin(3)

>>> minimum(sin(x)*cos(x), x)
-1/2
sympy.calculus.util.not_empty_in(finset_intersection, *syms)[源代码][源代码]

在 finset_intersection 中找到函数的定义域，在该定义域中 finite_set 是非空的。

参数:
finset_intersection有限集的交集

包含实值函数的有限集与集合联合的未求交集

syms符号元组

要查找域的符号

Raises:
NotImplementedError

用于查找给定 FiniteSet 非空性的算法尚未实现。

ValueError

输入无效。

RuntimeError

这是一个错误，请将其报告到 github 问题跟踪器 (https://github.com/sympy/sympy/issues)。

示例

>>> from sympy import FiniteSet, Interval, not_empty_in, oo
>>> from sympy.abc import x
>>> not_empty_in(FiniteSet(x/2).intersect(Interval(0, 1)), x)
Interval(0, 2)
>>> not_empty_in(FiniteSet(x, x**2).intersect(Interval(1, 2)), x)
Union(Interval(1, 2), Interval(-sqrt(2), -1))
>>> not_empty_in(FiniteSet(x**2/(x + 2)).intersect(Interval(1, oo)), x)
Union(Interval.Lopen(-2, -1), Interval(2, oo))
sympy.calculus.util.periodicity(f, symbol, check=False)[源代码][源代码]

测试给定函数在给定符号中的周期性。

参数:
f表达式

相关函数。

符号 : Symbol符号

要确定周期的变量。

检查bool, 可选

用于验证返回值是否为周期的标志。

返回:
周期

函数的周期被返回。当函数是非周期或具有复周期时，返回 None。常数函数的周期返回值为 \(0\)。

Raises:
NotImplementedError

计算出的周期值无法验证。

注释

目前，我们不支持具有复杂周期的函数。具有复杂周期值的函数，如 exp、sinh，其周期评估为 None。

返回的值可能不是给定函数的“基本”周期，即它可能不是函数的最小周期值。

由于对给定表达式进行了内部简化，通过 check 标志验证周期并不可靠。因此，默认情况下将其设置为 False。

示例

>>> from sympy import periodicity, Symbol, sin, cos, tan, exp
>>> x = Symbol('x')
>>> f = sin(x) + sin(2*x) + sin(3*x)
>>> periodicity(f, x)
2*pi
>>> periodicity(sin(x)*cos(x), x)
pi
>>> periodicity(exp(tan(2*x) - 1), x)
pi/2
>>> periodicity(sin(4*x)**cos(2*x), x)
pi
>>> periodicity(exp(x), x)
sympy.calculus.util.stationary_points(f, symbol, domain=Reals)[源代码][源代码]

返回给定域内函数的静止点（函数的导数为0的点）。

参数:
f表达式

相关函数。

符号 : Symbol符号

要确定其驻点的变量。

域 : Interval区间

需要检查驻点的定义域。如果未指定，S.Reals 将是默认域。

返回:
设置

函数的一组驻点。如果没有驻点，则返回 EmptySet。

示例

>>> from sympy import Interval, Symbol, S, sin, pi, pprint, stationary_points
>>> x = Symbol('x')

>>> stationary_points(1/x, x, S.Reals)
EmptySet

>>> pprint(stationary_points(sin(x), x), use_unicode=False)
          pi                              3*pi
{2*n*pi + -- | n in Integers} U {2*n*pi + ---- | n in Integers}
          2                                2

>>> stationary_points(sin(x),x, Interval(0, 4*pi))
{pi/2, 3*pi/2, 5*pi/2, 7*pi/2}