# Calculus#

Calculus-related methods.

This module implements a method to find Euler-Lagrange Equations for given Lagrangian.

sympy.calculus.euler.euler_equations(L, funcs=(), vars=())[source]#

Find the Euler-Lagrange equations [R31] for a given Lagrangian.

Parameters:

L : Expr

The Lagrangian that should be a function of the functions listed in the second argument and their derivatives.

For example, in the case of two functions $$f(x,y)$$, $$g(x,y)$$ and two independent variables $$x$$, $$y$$ the Lagrangian has the form:

$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)$

In many cases it is not necessary to provide anything, except the Lagrangian, it will be auto-detected (and an error raised if this cannot be done).

funcs : Function or an iterable of Functions

The functions that the Lagrangian depends on. The Euler equations are differential equations for each of these functions.

vars : Symbol or an iterable of Symbols

The Symbols that are the independent variables of the functions.

Returns:

eqns : list of Eq

The list of differential equations, one for each function.

Examples

>>> 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)]


References

## Singularities#

This module implements algorithms for finding singularities for a function and identifying types of functions.

The differential calculus methods in this module include methods to identify the following function types in the given Interval: - Increasing - Strictly Increasing - Decreasing - Strictly Decreasing - Monotonic

sympy.calculus.singularities.is_decreasing(expression, interval=Reals, symbol=None)[source]#

Return whether the function is decreasing in the given interval.

Parameters:

expression : Expr

The target function which is being checked.

interval : Set, optional

The range of values in which we are testing (defaults to set of all real numbers).

symbol : Symbol, optional

The symbol present in expression which gets varied over the given range.

Returns:

Boolean

True if expression is decreasing (either strictly decreasing or constant) in the given interval, False otherwise.

Examples

>>> 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)[source]#

Return whether the function is increasing in the given interval.

Parameters:

expression : Expr

The target function which is being checked.

interval : Set, optional

The range of values in which we are testing (defaults to set of all real numbers).

symbol : Symbol, optional

The symbol present in expression which gets varied over the given range.

Returns:

Boolean

True if expression is increasing (either strictly increasing or constant) in the given interval, False otherwise.

Examples

>>> 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)[source]#

Return whether the function is monotonic in the given interval.

Parameters:

expression : Expr

The target function which is being checked.

interval : Set, optional

The range of values in which we are testing (defaults to set of all real numbers).

symbol : Symbol, optional

The symbol present in expression which gets varied over the given range.

Returns:

Boolean

True if expression is monotonic in the given interval, False otherwise.

Raises:

NotImplementedError

Monotonicity check has not been implemented for the queried function.

Examples

>>> 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)[source]#

Return whether the function is strictly decreasing in the given interval.

Parameters:

expression : Expr

The target function which is being checked.

interval : Set, optional

The range of values in which we are testing (defaults to set of all real numbers).

symbol : Symbol, optional

The symbol present in expression which gets varied over the given range.

Returns:

Boolean

True if expression is strictly decreasing in the given interval, False otherwise.

Examples

>>> 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)[source]#

Return whether the function is strictly increasing in the given interval.

Parameters:

expression : Expr

The target function which is being checked.

interval : Set, optional

The range of values in which we are testing (defaults to set of all real numbers).

symbol : Symbol, optional

The symbol present in expression which gets varied over the given range.

Returns:

Boolean

True if expression is strictly increasing in the given interval, False otherwise.

Examples

>>> 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)[source]#

Helper function for functions checking function monotonicity.

Parameters:

expression : Expr

The target function which is being checked

predicate : function

The property being tested for. The function takes in an integer and returns a boolean. The integer input is the derivative and the boolean result should be true if the property is being held, and false otherwise.

interval : Set, optional

The range of values in which we are testing, defaults to all reals.

symbol : Symbol, optional

The symbol present in expression which gets varied over the given range.

It returns a boolean indicating whether the interval in which

the function’s derivative satisfies given predicate is a superset

of the given interval.

Returns:

Boolean

True if predicate is true for all the derivatives when symbol is varied in range, False otherwise.

sympy.calculus.singularities.singularities(expression, symbol, domain=None)[source]#

Find singularities of a given function.

Parameters:

expression : Expr

The target function in which singularities need to be found.

symbol : Symbol

The symbol over the values of which the singularity in expression in being searched for.

Returns:

Set

A set of values for symbol for which expression has a singularity. An EmptySet is returned if expression has no singularities for any given value of Symbol.

Raises:

NotImplementedError

Methods for determining the singularities of this function have not been developed.

Notes

This function does not find non-isolated singularities nor does it find branch points of the expression.

Currently supported functions are:
• univariate continuous (real or complex) functions

Examples

>>> 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}


References

## Finite difference weights#

This module implements an algorithm for efficient generation of finite difference weights for ordinary differentials of functions for derivatives from 0 (interpolation) up to arbitrary order.

The core algorithm is provided in the finite difference weight generating function (finite_diff_weights), and two convenience functions are provided for:

• estimating a derivative (or interpolate) directly from a series of points

is also provided (apply_finite_diff).

• differentiating by using finite difference approximations

(differentiate_finite).

sympy.calculus.finite_diff.apply_finite_diff(order, x_list, y_list, x0=0)[source]#

Calculates the finite difference approximation of the derivative of requested order at x0 from points provided in x_list and y_list.

Parameters:

order: int

order of derivative to approximate. 0 corresponds to interpolation.

x_list: sequence

Sequence of (unique) values for the independent variable.

y_list: sequence

The function value at corresponding values for the independent variable in x_list.

x0: Number or Symbol

At what value of the independent variable the derivative should be evaluated. Defaults to 0.

Returns:

The finite difference expression approximating the requested derivative order at x0.

Examples

>>> 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


we see that the example above only contain rounding errors. apply_finite_diff can also be used on more abstract objects:

>>> 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]))


Notes

Order = 0 corresponds to interpolation. Only supply so many points you think makes sense to around x0 when extracting the derivative (the function need to be well behaved within that region). Also beware of Runge’s phenomenon.

References

Fortran 90 implementation with Python interface for numerics: finitediff

sympy.calculus.finite_diff.differentiate_finite(expr, *symbols, points=1, x0=None, wrt=None, evaluate=False)[source]#

Differentiate expr and replace Derivatives with finite differences.

Parameters:

expr : expression

*symbols : differentiate with respect to symbols

points: sequence, coefficient or undefined function, optional

see Derivative.as_finite_difference

x0: number or Symbol, optional

see Derivative.as_finite_difference

wrt: Symbol, optional

see Derivative.as_finite_difference

Examples

>>> 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 works on any expression, including the expressions with embedded derivatives:

>>> 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)


To make finite difference with non-constant discretization step use undefined functions:

>>> 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)[source]#

Calculates the finite difference weights for an arbitrarily spaced one-dimensional grid (x_list) for derivatives at x0 of order 0, 1, …, up to order using a recursive formula. Order of accuracy is at least len(x_list) - order, if x_list is defined correctly.

Parameters:

order: int

Up to what derivative order weights should be calculated. 0 corresponds to interpolation.

x_list: sequence

Sequence of (unique) values for the independent variable. It is useful (but not necessary) to order x_list from nearest to furthest from x0; see examples below.

x0: Number or Symbol

Root or value of the independent variable for which the finite difference weights should be generated. Default is S.One.

Returns:

list

A list of sublists, each corresponding to coefficients for increasing derivative order, and each containing lists of coefficients for increasing subsets of x_list.

Examples

>>> 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[-1]  # FD weights for 0th derivative, using full x_list
[5/16, 15/16, -5/16, 1/16]
>>> res[-1]  # FD weights for 1st derivative
[-23/24, 7/8, 1/8, -1/24]
>>> res[-2]  # FD weights for 1st derivative, using x_list[:-1]
[-1, 1, 0, 0]
>>> res[-1]  # FD weight for 1st deriv. for x_list
-23/24
>>> res[-1]  # FD weight for 1st deriv. for x_list, etc.
7/8


Each sublist contains the most accurate formula at the end. Note, that in the above example res is the same as res. Since res has an order of accuracy of len(x_list[:3]) - order = 3 - 1 = 2, the same is true for res!

>>> res = finite_diff_weights(1, [S(0), S(1), -S(1), S(2), -S(2)], 0)
>>> 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  # no approximation possible, using x_list only
[0, 0, 0, 0, 0]
>>> res  # classic forward step approximation
[-1, 1, 0, 0, 0]
>>> res  # 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]]


Let us compare this to a differently defined x_list. Pay attention to foo[i][k] corresponding to the gridpoint defined by x_list[k].

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


Note that, unless you plan on using approximations based on subsets of x_list, the order of gridpoints does not matter.

The capability to generate weights at arbitrary points can be used e.g. to minimize Runge’s phenomenon by using Chebyshev nodes:

>>> 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)
>>> [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]


Notes

If weights for a finite difference approximation of 3rd order derivative is wanted, weights for 0th, 1st and 2nd order are calculated “for free”, so are formulae using subsets of x_list. This is something one can take advantage of to save computational cost. Be aware that one should define x_list from nearest to furthest from x0. If not, subsets of x_list will yield poorer approximations, which might not grand an order of accuracy of len(x_list) - order.

References

[R33]

Generation of Finite Difference Formulas on Arbitrarily Spaced Grids, Bengt Fornberg; Mathematics of computation; 51; 184; (1988); 699-706; doi:10.1090/S0025-5718-1988-0935077-0

sympy.calculus.util.continuous_domain(f, symbol, domain)[source]#

Returns the domain on which the function expression f is continuous.

This function is limited by the ability to determine the various singularities and discontinuities of the given function. The result is either given as a union of intervals or constructed using other set operations.

Parameters:

The concerned function.

symbol : Symbol

The variable for which the intervals are to be determined.

domain : Interval

The domain over which the continuity of the symbol has to be checked.

Returns:

Interval

Union of all intervals where the function is continuous.

Raises:

NotImplementedError

If the method to determine continuity of such a function has not yet been developed.

Examples

>>> 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)[source]#

Finds the range of a function in a given domain. This method is limited by the ability to determine the singularities and determine limits.

Parameters:

The concerned function.

symbol : Symbol

The variable for which the range of function is to be determined.

domain : Interval

The domain under which the range of the function has to be found.

Returns:

Interval

Union of all ranges for all intervals under domain where function is continuous.

Raises:

NotImplementedError

If any of the intervals, in the given domain, for which function is continuous are not finite or real, OR if the critical points of the function on the domain cannot be found.

Examples

>>> 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)[source]#

Determines the convexity of the function passed in the argument.

Parameters:

The concerned function.

syms : Tuple of Symbol

The variables with respect to which the convexity is to be determined.

domain : Interval, optional

The domain over which the convexity of the function has to be checked. If unspecified, S.Reals will be the default domain.

Returns:

bool

The method returns True if the function is convex otherwise it returns False.

Raises:

NotImplementedError

The check for the convexity of multivariate functions is not implemented yet.

Notes

To determine concavity of a function pass $$-f$$ as the concerned function. To determine logarithmic convexity of a function pass $$\log(f)$$ as concerned function. To determine logarithmic concavity of a function pass $$-\log(f)$$ as concerned function.

Currently, convexity check of multivariate functions is not handled.

Examples

>>> 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


References

sympy.calculus.util.lcim(numbers)[source]#

Returns the least common integral multiple of a list of numbers.

The numbers can be rational or irrational or a mixture of both. $$None$$ is returned for incommensurable numbers.

Parameters:

numbers : list

Numbers (rational and/or irrational) for which lcim is to be found.

Returns:

number

lcim if it exists, otherwise None for incommensurable numbers.

Examples

>>> 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)[source]#

Returns the maximum value of a function in the given domain.

Parameters:

The concerned function.

symbol : Symbol

The variable for maximum value needs to be determined.

domain : Interval

The domain over which the maximum have to be checked. If unspecified, then the global maximum is returned.

Returns:

number

Maximum value of the function in given domain.

Examples

>>> 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)[source]#

Returns the minimum value of a function in the given domain.

Parameters:

The concerned function.

symbol : Symbol

The variable for minimum value needs to be determined.

domain : Interval

The domain over which the minimum have to be checked. If unspecified, then the global minimum is returned.

Returns:

number

Minimum value of the function in the given domain.

Examples

>>> 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)[source]#

Finds the domain of the functions in finset_intersection in which the finite_set is not-empty.

Parameters:

finset_intersection : Intersection of FiniteSet

The unevaluated intersection of FiniteSet containing real-valued functions with Union of Sets

syms : Tuple of symbols

Symbol for which domain is to be found

Raises:

NotImplementedError

The algorithms to find the non-emptiness of the given FiniteSet are not yet implemented.

ValueError

The input is not valid.

RuntimeError

It is a bug, please report it to the github issue tracker (https://github.com/sympy/sympy/issues).

Examples

>>> 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)[source]#

Tests the given function for periodicity in the given symbol.

Parameters:

The concerned function.

symbol : Symbol

The variable for which the period is to be determined.

check : bool, optional

The flag to verify whether the value being returned is a period or not.

Returns:

period

The period of the function is returned. None is returned when the function is aperiodic or has a complex period. The value of $$0$$ is returned as the period of a constant function.

Raises:

NotImplementedError

The value of the period computed cannot be verified.

Notes

Currently, we do not support functions with a complex period. The period of functions having complex periodic values such as exp, sinh is evaluated to None.

The value returned might not be the “fundamental” period of the given function i.e. it may not be the smallest periodic value of the function.

The verification of the period through the check flag is not reliable due to internal simplification of the given expression. Hence, it is set to False by default.

Examples

>>> 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)[source]#

Returns the stationary points of a function (where derivative of the function is 0) in the given domain.

Parameters:

The concerned function.

symbol : Symbol

The variable for which the stationary points are to be determined.

domain : Interval

The domain over which the stationary points have to be checked. If unspecified, S.Reals will be the default domain.

Returns:

Set

A set of stationary points for the function. If there are no stationary point, an EmptySet is returned.

Examples

>>> 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}