Elementary¶

This module implements elementary functions such as trigonometric, hyperbolic, and sqrt, as well as functions like Abs, Max, Min etc.

sympy.functions.elementary.complexes¶

re¶

class sympy.functions.elementary.complexes.re(arg)[source]¶

Returns real part of expression. This function performs only elementary analysis and so it will fail to decompose properly more complicated expressions. If completely simplified result is needed then use Basic.as_real_imag() or perform complex expansion on instance of this function.

See also

im

Examples

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

as_real_imag(deep=True, **hints)[source]¶: Returns the real number with a zero imaginary part.

classmethod eval(arg)[source]¶

Returns a canonical form of cls applied to arguments args.

The eval() method is called when the class cls is about to be instantiated and it should return either some simplified instance (possible of some other class), or if the class cls should be unmodified, return None.

Examples Of Eval() For The Function “sign”

@classmethod def eval(cls, arg):

im¶

class sympy.functions.elementary.complexes.im(arg)[source]¶

Returns imaginary part of expression. This function performs only elementary analysis and so it will fail to decompose properly more complicated expressions. If completely simplified result is needed then use Basic.as_real_imag() or perform complex expansion on instance of this function.

See also

re

Examples

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

as_real_imag(deep=True, **hints)[source]¶

Return the imaginary part with a zero real part.

Examples

>>> from sympy.functions import im
>>> from sympy import I
>>> im(2 + 3*I).as_real_imag()
(3, 0)

classmethod eval(arg)[source]¶

Returns a canonical form of cls applied to arguments args.

The eval() method is called when the class cls is about to be instantiated and it should return either some simplified instance (possible of some other class), or if the class cls should be unmodified, return None.

Examples Of Eval() For The Function “sign”

@classmethod def eval(cls, arg):

sign¶

class sympy.functions.elementary.complexes.sign(arg)[source]¶

Returns the complex sign of an expression:

If the expresssion is real the sign will be:

If the expresssion is imaginary the sign will be:

Otherwise an unevaluated expression will be returned. When evaluated, the result (in general) will be cos(arg(expr)) + I*sin(arg(expr)).

See also

Abs, conjugate

Examples

>>> from sympy.functions import sign
>>> from sympy.core.numbers import I

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

doit(**hints)[source]¶

Evaluate objects that are not evaluated by default like limits, integrals, sums and products. All objects of this kind will be evaluated recursively, unless some species were excluded via ‘hints’ or unless the ‘deep’ hint was set to ‘False’.

>>> from sympy import Integral
>>> from sympy.abc import x

>>> 2*Integral(x, x)
2*Integral(x, x)

>>> (2*Integral(x, x)).doit()
x**2

>>> (2*Integral(x, x)).doit(deep=False)
2*Integral(x, x)

classmethod eval(arg)[source]¶

Returns a canonical form of cls applied to arguments args.

The eval() method is called when the class cls is about to be instantiated and it should return either some simplified instance (possible of some other class), or if the class cls should be unmodified, return None.

Examples Of Eval() For The Function “sign”

@classmethod def eval(cls, arg):

Abs¶

class sympy.functions.elementary.complexes.Abs(arg)[source]¶

Return the absolute value of the argument.

This is an extension of the built-in function abs() to accept symbolic values. If you pass a SymPy expression to the built-in abs(), it will pass it automatically to Abs().

See also

sign, conjugate

Examples

>>> from sympy import Abs, Symbol, S
>>> 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)

Note that the Python built-in will return either an Expr or int depending on the argument:

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

Abs will always return a sympy object.

classmethod eval(arg)[source]¶

Returns a canonical form of cls applied to arguments args.

The eval() method is called when the class cls is about to be instantiated and it should return either some simplified instance (possible of some other class), or if the class cls should be unmodified, return None.

Examples Of Eval() For The Function “sign”

@classmethod def eval(cls, arg):

fdiff(argindex=1)[source]¶

Get the first derivative of the argument to Abs().

Examples

>>> from sympy.abc import x
>>> from sympy.functions import Abs
>>> Abs(-x).fdiff()
sign(x)

arg¶

class sympy.functions.elementary.complexes.arg(arg)[source]¶

Returns the argument (in radians) of a complex number. For a real number, the argument is always 0.

Examples

>>> from sympy.functions import arg
>>> from sympy import I, sqrt
>>> arg(2.0)
0
>>> arg(I)
pi/2
>>> arg(sqrt(2) + I*sqrt(2))
pi/4

classmethod eval(arg)[source]¶

Returns a canonical form of cls applied to arguments args.

The eval() method is called when the class cls is about to be instantiated and it should return either some simplified instance (possible of some other class), or if the class cls should be unmodified, return None.

Examples Of Eval() For The Function “sign”

@classmethod def eval(cls, arg):

conjugate¶

class sympy.functions.elementary.complexes.conjugate(arg)[source]¶

Returns the \(complex conjugate\) Ref[1] of an argument. In mathematics, the complex conjugate of a complex number is given by changing the sign of the imaginary part.

Thus, the conjugate of the complex number \(a + ib\) (where a and b are real numbers) is \(a - ib\)

See also

sign, Abs

References

R115: http://en.wikipedia.org/wiki/Complex_conjugation

Examples

>>> from sympy import conjugate, I
>>> conjugate(2)
2
>>> conjugate(I)
-I

classmethod eval(arg)[source]¶

Returns a canonical form of cls applied to arguments args.

The eval() method is called when the class cls is about to be instantiated and it should return either some simplified instance (possible of some other class), or if the class cls should be unmodified, return None.

Examples Of Eval() For The Function “sign”

@classmethod def eval(cls, arg):

polar_lift¶

class sympy.functions.elementary.complexes.polar_lift(arg)[source]¶

Lift argument to the Riemann surface of the logarithm, using the standard branch.

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

See also

sympy.functions.elementary.exponential.exp_polar, periodic_argument

classmethod eval(arg)[source]¶

Returns a canonical form of cls applied to arguments args.

The eval() method is called when the class cls is about to be instantiated and it should return either some simplified instance (possible of some other class), or if the class cls should be unmodified, return None.

Examples Of Eval() For The Function “sign”

@classmethod def eval(cls, arg):

periodic_argument¶

class sympy.functions.elementary.complexes.periodic_argument(ar, period)[source]¶

Represent the argument on a quotient of the Riemann surface of the logarithm. That is, given a period P, always return a value in (-P/2, P/2], by using exp(P*I) == 1.

>>> from sympy import exp, exp_polar, periodic_argument, unbranched_argument
>>> from sympy import I, pi
>>> unbranched_argument(exp(5*I*pi))
pi
>>> unbranched_argument(exp_polar(5*I*pi))
5*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

See also

sympy.functions.elementary.exponential.exp_polar

polar_lift: Lift argument to the Riemann surface of the logarithm

principal_branch

classmethod eval(ar, period)[source]¶

Returns a canonical form of cls applied to arguments args.

The eval() method is called when the class cls is about to be instantiated and it should return either some simplified instance (possible of some other class), or if the class cls should be unmodified, return None.

Examples Of Eval() For The Function “sign”

@classmethod def eval(cls, arg):

principal_branch¶

class sympy.functions.elementary.complexes.principal_branch(x, period)[source]¶

Represent a polar number reduced to its principal branch on a quotient of the Riemann surface of the logarithm.

This is a function of two arguments. The first argument is a polar number \(z\), and the second one a positive real number of infinity, \(p\). The result is “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)

See also

sympy.functions.elementary.exponential.exp_polar

polar_lift: Lift argument to the Riemann surface of the logarithm

periodic_argument

classmethod eval(x, period)[source]¶

Returns a canonical form of cls applied to arguments args.

The eval() method is called when the class cls is about to be instantiated and it should return either some simplified instance (possible of some other class), or if the class cls should be unmodified, return None.

Examples Of Eval() For The Function “sign”

@classmethod def eval(cls, arg):

sympy.functions.elementary.trigonometric¶

Trionometric Functions¶

sin¶

class sympy.functions.elementary.trigonometric.sin(arg)[source]¶

The sine function.

Returns the sine of x (measured in radians).

Notes

This function will evaluate automatically in the case x/pi is some rational number [R119]. For example, if x is a multiple of pi, pi/2, pi/3, pi/4 and pi/6.

References

R116: http://en.wikipedia.org/wiki/Trigonometric_functions
R117: http://dlmf.nist.gov/4.14
R118: http://functions.wolfram.com/ElementaryFunctions/Sin
R119(1,2): http://mathworld.wolfram.com/TrigonometryAngles.html

Examples

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

as_real_imag(deep=True, **hints)[source]¶

Performs complex expansion on ‘self’ and returns a tuple containing collected both real and imaginary parts. This method can’t be confused with re() and im() functions, which does not perform complex expansion at evaluation.

However it is possible to expand both re() and im() functions and get exactly the same results as with a single call to this function.

>>> from sympy import symbols, I

>>> x, y = symbols('x,y', real=True)

>>> (x + y*I).as_real_imag()
(x, y)

>>> from sympy.abc import z, w

>>> (z + w*I).as_real_imag()
(re(z) - im(w), re(w) + im(z))

classmethod eval(arg)[source]¶

Returns a canonical form of cls applied to arguments args.

The eval() method is called when the class cls is about to be instantiated and it should return either some simplified instance (possible of some other class), or if the class cls should be unmodified, return None.

Examples Of Eval() For The Function “sign”

@classmethod def eval(cls, arg):

fdiff(argindex=1)[source]¶: Returns the first derivative of the function.

static taylor_term(n, x, *previous_terms)[source]¶

General method for the taylor term.

This method is slow, because it differentiates n-times. Subclasses can redefine it to make it faster by using the “previous_terms”.

cos¶

class sympy.functions.elementary.trigonometric.cos(arg)[source]¶

The cosine function.

Returns the cosine of x (measured in radians).

Notes

See sin() for notes about automatic evaluation.

References

R120: http://en.wikipedia.org/wiki/Trigonometric_functions
R121: http://dlmf.nist.gov/4.14
R122: http://functions.wolfram.com/ElementaryFunctions/Cos

Examples

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

as_real_imag(deep=True, **hints)[source]¶

Performs complex expansion on ‘self’ and returns a tuple containing collected both real and imaginary parts. This method can’t be confused with re() and im() functions, which does not perform complex expansion at evaluation.

However it is possible to expand both re() and im() functions and get exactly the same results as with a single call to this function.

>>> from sympy import symbols, I

>>> x, y = symbols('x,y', real=True)

>>> (x + y*I).as_real_imag()
(x, y)

>>> from sympy.abc import z, w

>>> (z + w*I).as_real_imag()
(re(z) - im(w), re(w) + im(z))

classmethod eval(arg)[source]¶

Returns a canonical form of cls applied to arguments args.

The eval() method is called when the class cls is about to be instantiated and it should return either some simplified instance (possible of some other class), or if the class cls should be unmodified, return None.

Examples Of Eval() For The Function “sign”

@classmethod def eval(cls, arg):

fdiff(argindex=1)[source]¶: Returns the first derivative of the function.

static taylor_term(n, x, *previous_terms)[source]¶

General method for the taylor term.

This method is slow, because it differentiates n-times. Subclasses can redefine it to make it faster by using the “previous_terms”.

tan¶

class sympy.functions.elementary.trigonometric.tan(arg)[source]¶

The tangent function.

Returns the tangent of x (measured in radians).

Notes

See sin() for notes about automatic evaluation.

References

R123: http://en.wikipedia.org/wiki/Trigonometric_functions
R124: http://dlmf.nist.gov/4.14
R125: http://functions.wolfram.com/ElementaryFunctions/Tan

Examples

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

as_real_imag(deep=True, **hints)[source]¶

Performs complex expansion on ‘self’ and returns a tuple containing collected both real and imaginary parts. This method can’t be confused with re() and im() functions, which does not perform complex expansion at evaluation.

However it is possible to expand both re() and im() functions and get exactly the same results as with a single call to this function.

>>> from sympy import symbols, I

>>> x, y = symbols('x,y', real=True)

>>> (x + y*I).as_real_imag()
(x, y)

>>> from sympy.abc import z, w

>>> (z + w*I).as_real_imag()
(re(z) - im(w), re(w) + im(z))

classmethod eval(arg)[source]¶

Returns a canonical form of cls applied to arguments args.

The eval() method is called when the class cls is about to be instantiated and it should return either some simplified instance (possible of some other class), or if the class cls should be unmodified, return None.

Examples Of Eval() For The Function “sign”

@classmethod def eval(cls, arg):

fdiff(argindex=1)[source]¶: Returns the first derivative of the function.

inverse(argindex=1)[source]¶: Returns the inverse of this function.

static taylor_term(n, x, *previous_terms)[source]¶

General method for the taylor term.

This method is slow, because it differentiates n-times. Subclasses can redefine it to make it faster by using the “previous_terms”.

cot¶

class sympy.functions.elementary.trigonometric.cot(arg)[source]¶

The cotangent function.

Returns the cotangent of x (measured in radians).

Notes

See sin() for notes about automatic evaluation.

References

R126: http://en.wikipedia.org/wiki/Trigonometric_functions
R127: http://dlmf.nist.gov/4.14
R128: http://functions.wolfram.com/ElementaryFunctions/Cot

Examples

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

as_real_imag(deep=True, **hints)[source]¶

Performs complex expansion on ‘self’ and returns a tuple containing collected both real and imaginary parts. This method can’t be confused with re() and im() functions, which does not perform complex expansion at evaluation.

However it is possible to expand both re() and im() functions and get exactly the same results as with a single call to this function.

>>> from sympy import symbols, I

>>> x, y = symbols('x,y', real=True)

>>> (x + y*I).as_real_imag()
(x, y)

>>> from sympy.abc import z, w

>>> (z + w*I).as_real_imag()
(re(z) - im(w), re(w) + im(z))

classmethod eval(arg)[source]¶

Returns a canonical form of cls applied to arguments args.

The eval() method is called when the class cls is about to be instantiated and it should return either some simplified instance (possible of some other class), or if the class cls should be unmodified, return None.

Examples Of Eval() For The Function “sign”

@classmethod def eval(cls, arg):

fdiff(argindex=1)[source]¶: Returns the first derivative of the function.

inverse(argindex=1)[source]¶: Returns the inverse of this function.

static taylor_term(n, x, *previous_terms)[source]¶

General method for the taylor term.

This method is slow, because it differentiates n-times. Subclasses can redefine it to make it faster by using the “previous_terms”.

sec¶

class sympy.functions.elementary.trigonometric.sec(arg)[source]¶

The secant function.

Returns the secant of x (measured in radians).

Notes

See sin() for notes about automatic evaluation.

References

R129: http://en.wikipedia.org/wiki/Trigonometric_functions
R130: http://dlmf.nist.gov/4.14
R131: http://functions.wolfram.com/ElementaryFunctions/Sec

Examples

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

fdiff(argindex=1)[source]¶: Returns the first derivative of the function.

static taylor_term(n, x, *previous_terms)[source]¶

General method for the taylor term.

This method is slow, because it differentiates n-times. Subclasses can redefine it to make it faster by using the “previous_terms”.

csc¶

class sympy.functions.elementary.trigonometric.csc(arg)[source]¶

The cosecant function.

Returns the cosecant of x (measured in radians).

Notes

See sin() for notes about automatic evaluation.

References

R132: http://en.wikipedia.org/wiki/Trigonometric_functions
R133: http://dlmf.nist.gov/4.14
R134: http://functions.wolfram.com/ElementaryFunctions/Csc

Examples

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

fdiff(argindex=1)[source]¶: Returns the first derivative of the function.

static taylor_term(n, x, *previous_terms)[source]¶

General method for the taylor term.

This method is slow, because it differentiates n-times. Subclasses can redefine it to make it faster by using the “previous_terms”.

sinc¶

class sympy.functions.elementary.trigonometric.sinc(arg)[source]¶

Represents unnormalized sinc function

References

R135: http://en.wikipedia.org/wiki/Sinc_function

Examples

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

Automated Evaluation

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

Differentiation

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

Series Expansion

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

As zero’th order spherical Bessel Function

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

classmethod eval(arg)[source]¶

Returns a canonical form of cls applied to arguments args.

The eval() method is called when the class cls is about to be instantiated and it should return either some simplified instance (possible of some other class), or if the class cls should be unmodified, return None.

Examples Of Eval() For The Function “sign”

@classmethod def eval(cls, arg):

fdiff(argindex=1)[source]¶: Returns the first derivative of the function.

Trigonometric Inverses¶

asin¶

class sympy.functions.elementary.trigonometric.asin(arg)[source]¶

The inverse sine function.

Returns the arcsine of x in radians.

Notes

asin(x) will evaluate automatically in the cases oo, -oo, 0, 1, -1 and for some instances when the result is a rational multiple of pi (see the eval class method).

References

R136: http://en.wikipedia.org/wiki/Inverse_trigonometric_functions
R137: http://dlmf.nist.gov/4.23
R138: http://functions.wolfram.com/ElementaryFunctions/ArcSin

Examples

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

classmethod eval(arg)[source]¶

Returns a canonical form of cls applied to arguments args.

The eval() method is called when the class cls is about to be instantiated and it should return either some simplified instance (possible of some other class), or if the class cls should be unmodified, return None.

Examples Of Eval() For The Function “sign”

@classmethod def eval(cls, arg):

fdiff(argindex=1)[source]¶: Returns the first derivative of the function.

inverse(argindex=1)[source]¶: Returns the inverse of this function.

static taylor_term(n, x, *previous_terms)[source]¶

General method for the taylor term.

This method is slow, because it differentiates n-times. Subclasses can redefine it to make it faster by using the “previous_terms”.

acos¶

class sympy.functions.elementary.trigonometric.acos(arg)[source]¶

The inverse cosine function.

Returns the arc cosine of x (measured in radians).

Notes

acos(x) will evaluate automatically in the cases oo, -oo, 0, 1, -1.

acos(zoo) evaluates to zoo (see note in :py:class`sympy.functions.elementary.trigonometric.asec`)

References

R139: http://en.wikipedia.org/wiki/Inverse_trigonometric_functions
R140: http://dlmf.nist.gov/4.23
R141: http://functions.wolfram.com/ElementaryFunctions/ArcCos

Examples

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

classmethod eval(arg)[source]¶

Returns a canonical form of cls applied to arguments args.

The eval() method is called when the class cls is about to be instantiated and it should return either some simplified instance (possible of some other class), or if the class cls should be unmodified, return None.

Examples Of Eval() For The Function “sign”

@classmethod def eval(cls, arg):

fdiff(argindex=1)[source]¶: Returns the first derivative of the function.

inverse(argindex=1)[source]¶: Returns the inverse of this function.

static taylor_term(n, x, *previous_terms)[source]¶

General method for the taylor term.

This method is slow, because it differentiates n-times. Subclasses can redefine it to make it faster by using the “previous_terms”.

atan¶

class sympy.functions.elementary.trigonometric.atan(arg)[source]¶

The inverse tangent function.

Returns the arc tangent of x (measured in radians).

Notes

atan(x) will evaluate automatically in the cases oo, -oo, 0, 1, -1.

References

R142: http://en.wikipedia.org/wiki/Inverse_trigonometric_functions
R143: http://dlmf.nist.gov/4.23
R144: http://functions.wolfram.com/ElementaryFunctions/ArcTan

Examples

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

classmethod eval(arg)[source]¶

Returns a canonical form of cls applied to arguments args.

The eval() method is called when the class cls is about to be instantiated and it should return either some simplified instance (possible of some other class), or if the class cls should be unmodified, return None.

Examples Of Eval() For The Function “sign”

@classmethod def eval(cls, arg):

fdiff(argindex=1)[source]¶: Returns the first derivative of the function.

inverse(argindex=1)[source]¶: Returns the inverse of this function.

static taylor_term(n, x, *previous_terms)[source]¶

General method for the taylor term.

This method is slow, because it differentiates n-times. Subclasses can redefine it to make it faster by using the “previous_terms”.

acot¶

class sympy.functions.elementary.trigonometric.acot(arg)[source]¶

The inverse cotangent function.

Returns the arc cotangent of x (measured in radians).

References

R145: http://en.wikipedia.org/wiki/Inverse_trigonometric_functions
R146: http://dlmf.nist.gov/4.23
R147: http://functions.wolfram.com/ElementaryFunctions/ArcCot

classmethod eval(arg)[source]¶

Returns a canonical form of cls applied to arguments args.

The eval() method is called when the class cls is about to be instantiated and it should return either some simplified instance (possible of some other class), or if the class cls should be unmodified, return None.

Examples Of Eval() For The Function “sign”

@classmethod def eval(cls, arg):

fdiff(argindex=1)[source]¶: Returns the first derivative of the function.

inverse(argindex=1)[source]¶: Returns the inverse of this function.

static taylor_term(n, x, *previous_terms)[source]¶

General method for the taylor term.

This method is slow, because it differentiates n-times. Subclasses can redefine it to make it faster by using the “previous_terms”.

asec¶

class sympy.functions.elementary.trigonometric.asec(arg)[source]¶

The inverse secant function.

Returns the arc secant of x (measured in radians).

Notes

asec(x) will evaluate automatically in the cases oo, -oo, 0, 1, -1.

asec(x) has branch cut in the interval [-1, 1]. For complex arguments, it can be defined [R151] as

\[sec^{-1}(z) = -i*(log(\sqrt{1 - z^2} + 1) / z)\]

At x = 0, for positive branch cut, the limit evaluates to zoo. For negative branch cut, the limit

\[\lim_{z \to 0}-i*(log(-\sqrt{1 - z^2} + 1) / z)\]

simplifies to \(-i*log(z/2 + O(z^3))\) which ultimately evaluates to zoo.

As asex(x) = asec(1/x), a similar argument can be given for acos(x).

References

R148: http://en.wikipedia.org/wiki/Inverse_trigonometric_functions
R149: http://dlmf.nist.gov/4.23
R150: http://functions.wolfram.com/ElementaryFunctions/ArcSec
R151(1,2): http://refrence.wolfram.com/language/ref/ArcSec.html

Examples

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

classmethod eval(arg)[source]¶

Returns a canonical form of cls applied to arguments args.

The eval() method is called when the class cls is about to be instantiated and it should return either some simplified instance (possible of some other class), or if the class cls should be unmodified, return None.

Examples Of Eval() For The Function “sign”

@classmethod def eval(cls, arg):

fdiff(argindex=1)[source]¶: Returns the first derivative of the function.

inverse(argindex=1)[source]¶: Returns the inverse of this function.

acsc¶

class sympy.functions.elementary.trigonometric.acsc(arg)[source]¶

The inverse cosecant function.

Returns the arc cosecant of x (measured in radians).

Notes

acsc(x) will evaluate automatically in the cases oo, -oo, 0, 1, -1.

References

R152: http://en.wikipedia.org/wiki/Inverse_trigonometric_functions
R153: http://dlmf.nist.gov/4.23
R154: http://functions.wolfram.com/ElementaryFunctions/ArcCsc

Examples

>>> from sympy import acsc, oo, pi
>>> acsc(1)
pi/2
>>> acsc(-1)
-pi/2

classmethod eval(arg)[source]¶

Returns a canonical form of cls applied to arguments args.

The eval() method is called when the class cls is about to be instantiated and it should return either some simplified instance (possible of some other class), or if the class cls should be unmodified, return None.

Examples Of Eval() For The Function “sign”

@classmethod def eval(cls, arg):

fdiff(argindex=1)[source]¶: Returns the first derivative of the function.

inverse(argindex=1)[source]¶: Returns the inverse of this function.

atan2¶

class sympy.functions.elementary.trigonometric.atan2(y, x)[source]¶

The function atan2(y, x) computes \(\operatorname{atan}(y/x)\) taking two arguments \(y\) and \(x\). Signs of both \(y\) and \(x\) are considered to determine the appropriate quadrant of \(\operatorname{atan}(y/x)\). The range is \((-\pi, \pi]\). The complete definition reads as follows:

\[\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}\]

Attention: Note the role reversal of both arguments. The \(y\)-coordinate is the first argument and the \(x\)-coordinate the second.

References

R155: http://en.wikipedia.org/wiki/Inverse_trigonometric_functions
R156: http://en.wikipedia.org/wiki/Atan2
R157: http://functions.wolfram.com/ElementaryFunctions/ArcTan2

Examples

Going counter-clock wise around the origin we find the following angles:

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

which are all correct. Compare this to the results of the ordinary \(\operatorname{atan}\) function for the point \((x, y) = (-1, 1)\)

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

where only the \(\operatorname{atan2}\) function reurns what we expect. We can differentiate the function with respect to both arguments:

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

We can express the \(\operatorname{atan2}\) function in terms of complex logarithms:

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

and in terms of \(\operatorname(atan)\):

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

but note that this form is undefined on the negative real axis.

classmethod eval(y, x)[source]¶

Returns a canonical form of cls applied to arguments args.

The eval() method is called when the class cls is about to be instantiated and it should return either some simplified instance (possible of some other class), or if the class cls should be unmodified, return None.

Examples Of Eval() For The Function “sign”

@classmethod def eval(cls, arg):

fdiff(argindex)[source]¶: Returns the first derivative of the function.

sympy.functions.elementary.hyperbolic¶

Hyperbolic Functions¶

HyperbolicFunction¶

class sympy.functions.elementary.hyperbolic.HyperbolicFunction(*args)[source]¶: Base class for hyperbolic functions.

See also

sinh, cosh, tanh, coth

sinh¶

class sympy.functions.elementary.hyperbolic.sinh(arg)[source]¶

The hyperbolic sine function, \(\frac{e^x - e^{-x}}{2}\).

sinh(x) -> Returns the hyperbolic sine of x

See also

cosh, tanh, asinh

as_real_imag(deep=True, **hints)[source]¶: Returns this function as a complex coordinate.

classmethod eval(arg)[source]¶

Returns a canonical form of cls applied to arguments args.

The eval() method is called when the class cls is about to be instantiated and it should return either some simplified instance (possible of some other class), or if the class cls should be unmodified, return None.

Examples Of Eval() For The Function “sign”

@classmethod def eval(cls, arg):

fdiff(argindex=1)[source]¶: Returns the first derivative of this function.

inverse(argindex=1)[source]¶: Returns the inverse of this function.

static taylor_term(n, x, *previous_terms)[source]¶: Returns the next term in the Taylor series expansion.

cosh¶

class sympy.functions.elementary.hyperbolic.cosh(arg)[source]¶

The hyperbolic cosine function, \(\frac{e^x + e^{-x}}{2}\).

cosh(x) -> Returns the hyperbolic cosine of x

See also

sinh, tanh, acosh

as_real_imag(deep=True, **hints)[source]¶

Performs complex expansion on ‘self’ and returns a tuple containing collected both real and imaginary parts. This method can’t be confused with re() and im() functions, which does not perform complex expansion at evaluation.

However it is possible to expand both re() and im() functions and get exactly the same results as with a single call to this function.

>>> from sympy import symbols, I

>>> x, y = symbols('x,y', real=True)

>>> (x + y*I).as_real_imag()
(x, y)

>>> from sympy.abc import z, w

>>> (z + w*I).as_real_imag()
(re(z) - im(w), re(w) + im(z))

classmethod eval(arg)[source]¶

Returns a canonical form of cls applied to arguments args.

The eval() method is called when the class cls is about to be instantiated and it should return either some simplified instance (possible of some other class), or if the class cls should be unmodified, return None.

Examples Of Eval() For The Function “sign”

@classmethod def eval(cls, arg):

fdiff(argindex=1)[source]¶: Returns the first derivative of the function.

static taylor_term(n, x, *previous_terms)[source]¶

General method for the taylor term.

This method is slow, because it differentiates n-times. Subclasses can redefine it to make it faster by using the “previous_terms”.

tanh¶

class sympy.functions.elementary.hyperbolic.tanh(arg)[source]¶

The hyperbolic tangent function, \(\frac{\sinh(x)}{\cosh(x)}\).

tanh(x) -> Returns the hyperbolic tangent of x

See also

sinh, cosh, atanh

as_real_imag(deep=True, **hints)[source]¶

Performs complex expansion on ‘self’ and returns a tuple containing collected both real and imaginary parts. This method can’t be confused with re() and im() functions, which does not perform complex expansion at evaluation.

However it is possible to expand both re() and im() functions and get exactly the same results as with a single call to this function.

>>> from sympy import symbols, I

>>> x, y = symbols('x,y', real=True)

>>> (x + y*I).as_real_imag()
(x, y)

>>> from sympy.abc import z, w

>>> (z + w*I).as_real_imag()
(re(z) - im(w), re(w) + im(z))

classmethod eval(arg)[source]¶

Returns a canonical form of cls applied to arguments args.

The eval() method is called when the class cls is about to be instantiated and it should return either some simplified instance (possible of some other class), or if the class cls should be unmodified, return None.

Examples Of Eval() For The Function “sign”

@classmethod def eval(cls, arg):

fdiff(argindex=1)[source]¶: Returns the first derivative of the function.

inverse(argindex=1)[source]¶: Returns the inverse of this function.

static taylor_term(n, x, *previous_terms)[source]¶

General method for the taylor term.

This method is slow, because it differentiates n-times. Subclasses can redefine it to make it faster by using the “previous_terms”.

coth¶

class sympy.functions.elementary.hyperbolic.coth(arg)[source]¶

The hyperbolic cotangent function, \(\frac{\cosh(x)}{\sinh(x)}\).

coth(x) -> Returns the hyperbolic cotangent of x

as_real_imag(deep=True, **hints)[source]¶

Performs complex expansion on ‘self’ and returns a tuple containing collected both real and imaginary parts. This method can’t be confused with re() and im() functions, which does not perform complex expansion at evaluation.

However it is possible to expand both re() and im() functions and get exactly the same results as with a single call to this function.

>>> from sympy import symbols, I

>>> x, y = symbols('x,y', real=True)

>>> (x + y*I).as_real_imag()
(x, y)

>>> from sympy.abc import z, w

>>> (z + w*I).as_real_imag()
(re(z) - im(w), re(w) + im(z))

classmethod eval(arg)[source]¶

Returns a canonical form of cls applied to arguments args.

The eval() method is called when the class cls is about to be instantiated and it should return either some simplified instance (possible of some other class), or if the class cls should be unmodified, return None.

Examples Of Eval() For The Function “sign”

@classmethod def eval(cls, arg):

fdiff(argindex=1)[source]¶: Returns the first derivative of the function.

inverse(argindex=1)[source]¶: Returns the inverse of this function.

static taylor_term(n, x, *previous_terms)[source]¶

General method for the taylor term.

This method is slow, because it differentiates n-times. Subclasses can redefine it to make it faster by using the “previous_terms”.

sech¶

class sympy.functions.elementary.hyperbolic.sech(arg)[source]¶

The hyperbolic secant function, \(\frac{2}{e^x + e^{-x}}\)

sech(x) -> Returns the hyperbolic secant of x

fdiff(argindex=1)[source]¶: Returns the first derivative of the function.

static taylor_term(n, x, *previous_terms)[source]¶

General method for the taylor term.

This method is slow, because it differentiates n-times. Subclasses can redefine it to make it faster by using the “previous_terms”.

csch¶

class sympy.functions.elementary.hyperbolic.csch(arg)[source]¶

The hyperbolic cosecant function, \(\frac{2}{e^x - e^{-x}}\)

csch(x) -> Returns the hyperbolic cosecant of x

fdiff(argindex=1)[source]¶: Returns the first derivative of this function

static taylor_term(n, x, *previous_terms)[source]¶: Returns the next term in the Taylor series expansion

Hyperbolic Inverses¶

asinh¶

class sympy.functions.elementary.hyperbolic.asinh(arg)[source]¶

The inverse hyperbolic sine function.

asinh(x) -> Returns the inverse hyperbolic sine of x

See also

acosh, atanh, sinh

classmethod eval(arg)[source]¶

Returns a canonical form of cls applied to arguments args.

The eval() method is called when the class cls is about to be instantiated and it should return either some simplified instance (possible of some other class), or if the class cls should be unmodified, return None.

Examples Of Eval() For The Function “sign”

@classmethod def eval(cls, arg):

fdiff(argindex=1)[source]¶: Returns the first derivative of the function.

inverse(argindex=1)[source]¶: Returns the inverse of this function.

static taylor_term(n, x, *previous_terms)[source]¶

General method for the taylor term.

This method is slow, because it differentiates n-times. Subclasses can redefine it to make it faster by using the “previous_terms”.

acosh¶

class sympy.functions.elementary.hyperbolic.acosh(arg)[source]¶

The inverse hyperbolic cosine function.

acosh(x) -> Returns the inverse hyperbolic cosine of x

See also

asinh, atanh, cosh

classmethod eval(arg)[source]¶

Returns a canonical form of cls applied to arguments args.

The eval() method is called when the class cls is about to be instantiated and it should return either some simplified instance (possible of some other class), or if the class cls should be unmodified, return None.

Examples Of Eval() For The Function “sign”

@classmethod def eval(cls, arg):

fdiff(argindex=1)[source]¶: Returns the first derivative of the function.

inverse(argindex=1)[source]¶: Returns the inverse of this function.

static taylor_term(n, x, *previous_terms)[source]¶

General method for the taylor term.

This method is slow, because it differentiates n-times. Subclasses can redefine it to make it faster by using the “previous_terms”.

atanh¶

class sympy.functions.elementary.hyperbolic.atanh(arg)[source]¶

The inverse hyperbolic tangent function.

atanh(x) -> Returns the inverse hyperbolic tangent of x

See also

asinh, acosh, tanh

classmethod eval(arg)[source]¶

Returns a canonical form of cls applied to arguments args.

The eval() method is called when the class cls is about to be instantiated and it should return either some simplified instance (possible of some other class), or if the class cls should be unmodified, return None.

Examples Of Eval() For The Function “sign”

@classmethod def eval(cls, arg):

fdiff(argindex=1)[source]¶: Returns the first derivative of the function.

inverse(argindex=1)[source]¶: Returns the inverse of this function.

static taylor_term(n, x, *previous_terms)[source]¶

General method for the taylor term.

This method is slow, because it differentiates n-times. Subclasses can redefine it to make it faster by using the “previous_terms”.

acoth¶

class sympy.functions.elementary.hyperbolic.acoth(arg)[source]¶

The inverse hyperbolic cotangent function.

acoth(x) -> Returns the inverse hyperbolic cotangent of x

classmethod eval(arg)[source]¶

Returns a canonical form of cls applied to arguments args.

The eval() method is called when the class cls is about to be instantiated and it should return either some simplified instance (possible of some other class), or if the class cls should be unmodified, return None.

Examples Of Eval() For The Function “sign”

@classmethod def eval(cls, arg):

fdiff(argindex=1)[source]¶: Returns the first derivative of the function.

inverse(argindex=1)[source]¶: Returns the inverse of this function.

static taylor_term(n, x, *previous_terms)[source]¶

General method for the taylor term.

This method is slow, because it differentiates n-times. Subclasses can redefine it to make it faster by using the “previous_terms”.

asech¶

class sympy.functions.elementary.hyperbolic.asech(arg)[source]¶

The inverse hyperbolic secant function.

asech(x) -> Returns the inverse hyperbolic secant of x

See also

asinh, atanh, cosh, acoth

References

R158: http://en.wikipedia.org/wiki/Hyperbolic_function
R159: http://dlmf.nist.gov/4.37
R160: http://functions.wolfram.com/ElementaryFunctions/ArcSech/

Examples

>>> from sympy import asech, sqrt, S
>>> from sympy.abc import x
>>> asech(x).diff(x)
-1/(x*sqrt(-x**2 + 1))
>>> 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

classmethod eval(arg)[source]¶

Returns a canonical form of cls applied to arguments args.

The eval() method is called when the class cls is about to be instantiated and it should return either some simplified instance (possible of some other class), or if the class cls should be unmodified, return None.

Examples Of Eval() For The Function “sign”

@classmethod def eval(cls, arg):

fdiff(argindex=1)[source]¶: Returns the first derivative of the function.

inverse(argindex=1)[source]¶: Returns the inverse of this function.

acsch¶

class sympy.functions.elementary.hyperbolic.acsch(arg)[source]¶

The inverse hyperbolic cosecant function.

acsch(x) -> Returns the inverse hyperbolic cosecant of x

References

R161: http://en.wikipedia.org/wiki/Hyperbolic_function
R162: http://dlmf.nist.gov/4.37
R163: http://functions.wolfram.com/ElementaryFunctions/ArcCsch/

Examples

>>> from sympy import acsch, sqrt, S
>>> 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(S.ImaginaryUnit)
-I*pi/2
>>> acsch(-2*S.ImaginaryUnit)
I*pi/6
>>> acsch(S.ImaginaryUnit*(sqrt(6) - sqrt(2)))
-5*I*pi/12

classmethod eval(arg)[source]¶

Returns a canonical form of cls applied to arguments args.

The eval() method is called when the class cls is about to be instantiated and it should return either some simplified instance (possible of some other class), or if the class cls should be unmodified, return None.

Examples Of Eval() For The Function “sign”

@classmethod def eval(cls, arg):

fdiff(argindex=1)[source]¶: Returns the first derivative of the function.

inverse(argindex=1)[source]¶: Returns the inverse of this function.

sympy.functions.elementary.integers¶

ceiling¶

class sympy.functions.elementary.integers.ceiling(arg)[source]¶

Ceiling is a univariate function which returns the smallest integer value not less than its argument. Ceiling function is generalized in this implementation to complex numbers.

References

R164: “Concrete mathematics” by Graham, pp. 87
R165: http://mathworld.wolfram.com/CeilingFunction.html

Examples

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

floor¶

class sympy.functions.elementary.integers.floor(arg)[source]¶

Floor is a univariate function which returns the largest integer value not greater than its argument. However this implementation generalizes floor to complex numbers.

References

R166: “Concrete mathematics” by Graham, pp. 87
R167: http://mathworld.wolfram.com/FloorFunction.html

Examples

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

RoundFunction¶

class sympy.functions.elementary.integers.RoundFunction(arg)[source]¶: The base class for rounding functions.

frac¶

class sympy.functions.elementary.integers.frac(arg)[source]¶

Represents the fractional part of x

For real numbers it is defined [R168] as

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

References

R168(1,2): http://en.wikipedia.org/wiki/Fractional_part
R169: http://mathworld.wolfram.com/FractionalPart.html

Examples

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

returns zero for integer arguments

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

rewrite as floor

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

for complex arguments

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

sympy.functions.elementary.exponential¶

exp¶

class sympy.functions.elementary.exponential.exp(arg)[source]¶

The exponential function, \(e^x\).

See also

log

as_real_imag(deep=True, **hints)[source]¶

Returns this function as a 2-tuple representing a complex number.

Examples

>>> from sympy import I
>>> from sympy.abc import x
>>> from sympy.functions import exp
>>> 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))

property base¶: Returns the base of the exponential function.

classmethod eval(arg)[source]¶

Returns a canonical form of cls applied to arguments args.

The eval() method is called when the class cls is about to be instantiated and it should return either some simplified instance (possible of some other class), or if the class cls should be unmodified, return None.

Examples Of Eval() For The Function “sign”

@classmethod def eval(cls, arg):

fdiff(argindex=1)[source]¶: Returns the first derivative of this function.

static taylor_term(n, x, *previous_terms)[source]¶: Calculates the next term in the Taylor series expansion.

LambertW¶

class sympy.functions.elementary.exponential.LambertW(x, k=None)[source]¶

The Lambert W function \(W(z)\) is defined as the inverse function of \(w \exp(w)\) [R170].

In other words, the value of \(W(z)\) is such that \(z = W(z) \exp(W(z))\) for any complex number \(z\). The Lambert W function is a multivalued function with infinitely many branches \(W_k(z)\), indexed by \(k \in \mathbb{Z}\). Each branch gives a different solution \(w\) of the equation \(z = w \exp(w)\).

The Lambert W function has two partially real branches: the principal branch (\(k = 0\)) is real for real \(z > -1/e\), and the \(k = -1\) branch is real for \(-1/e < z < 0\). All branches except \(k = 0\) have a logarithmic singularity at \(z = 0\).

References

R170(1,2): http://en.wikipedia.org/wiki/Lambert_W_function

Examples

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

classmethod eval(x, k=None)[source]¶

Returns a canonical form of cls applied to arguments args.

The eval() method is called when the class cls is about to be instantiated and it should return either some simplified instance (possible of some other class), or if the class cls should be unmodified, return None.

Examples Of Eval() For The Function “sign”

@classmethod def eval(cls, arg):

fdiff(argindex=1)[source]¶: Return the first derivative of this function.

log¶

class sympy.functions.elementary.exponential.log(arg, base=None)[source]¶

The natural logarithm function \(\ln(x)\) or \(\log(x)\). Logarithms are taken with the natural base, \(e\). To get a logarithm of a different base b, use log(x, b), which is essentially short-hand for log(x)/log(b).

See also

exp

as_base_exp()[source]¶: Returns this function in the form (base, exponent).

as_real_imag(deep=True, **hints)[source]¶

Returns this function as a complex coordinate.

Examples

>>> from sympy import I
>>> from sympy.abc import x
>>> from sympy.functions import log
>>> 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))

classmethod eval(arg, base=None)[source]¶

Returns a canonical form of cls applied to arguments args.

The eval() method is called when the class cls is about to be instantiated and it should return either some simplified instance (possible of some other class), or if the class cls should be unmodified, return None.

Examples Of Eval() For The Function “sign”

@classmethod def eval(cls, arg):

fdiff(argindex=1)[source]¶: Returns the first derivative of the function.

inverse(argindex=1)[source]¶: Returns \(e^x\), the inverse function of \(\log(x)\).

static taylor_term(n, x, *previous_terms)[source]¶: Returns the next term in the Taylor series expansion of \(\log(1+x)\).

sympy.functions.elementary.piecewise¶

ExprCondPair¶

class sympy.functions.elementary.piecewise.ExprCondPair(expr, cond)[source]¶

Represents an expression, condition pair.

property cond¶: Returns the condition of this pair.

property expr¶: Returns the expression of this pair.

property free_symbols¶: Return the free symbols of this pair.

Piecewise¶

class sympy.functions.elementary.piecewise.Piecewise(*args)[source]¶

Represents a piecewise function.

Usage:

See also

piecewise_fold

Examples

>>> from sympy import Piecewise, log
>>> from sympy.abc import x
>>> 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)

doit(**hints)[source]¶: Evaluate this piecewise function.

classmethod eval(*args)[source]¶

Returns a canonical form of cls applied to arguments args.

The eval() method is called when the class cls is about to be instantiated and it should return either some simplified instance (possible of some other class), or if the class cls should be unmodified, return None.

Examples Of Eval() For The Function “sign”

@classmethod def eval(cls, arg):

sympy.functions.elementary.piecewise.piecewise_fold(expr)[source]¶

Takes an expression containing a piecewise function and returns the expression in piecewise form.

See also

Piecewise

Examples

>>> from sympy import Piecewise, piecewise_fold, sympify as 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, 1 <= x))

sympy.functions.elementary.miscellaneous¶

IdentityFunction¶

class sympy.functions.elementary.miscellaneous.IdentityFunction(*args, **kwargs)[source]¶

The identity function

Examples

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

Min¶

class sympy.functions.elementary.miscellaneous.Min(*args)[source]¶

Return, if possible, the minimum value of the list. It is named Min and not min to avoid conflicts with the built-in function min.

See also

Max: find maximum values

Examples

>>> 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(x, -2)
>>> 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(n, -7)

Max¶

class sympy.functions.elementary.miscellaneous.Max(*args)[source]¶

Return, if possible, the maximum value of the list.

When number of arguments is equal one, then return this argument.

When number of arguments is equal two, then return, if possible, the value from (a, b) that is >= the other.

In common case, when the length of list greater than 2, the task is more complicated. Return only the arguments, which are greater than others, if it is possible to determine directional relation.

If is not possible to determine such a relation, return a partially evaluated result.

Assumptions are used to make the decision too.

Also, only comparable arguments are permitted.

It is named Max and not max to avoid conflicts with the built-in function max.

See also

Min: find minimum values

References

R171(1,2): http://en.wikipedia.org/wiki/Directed_complete_partial_order
R172: http://en.wikipedia.org/wiki/Lattice_%28order%29

Examples

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

>>> Max(x, -2)                  
Max(x, -2)
>>> 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

Algorithm

The task can be considered as searching of supremums in the directed complete partial orders [R171].

The source values are sequentially allocated by the isolated subsets in which supremums are searched and result as Max arguments.

If the resulted supremum is single, then it is returned.

The isolated subsets are the sets of values which are only the comparable with each other in the current set. E.g. natural numbers are comparable with each other, but not comparable with the \(x\) symbol. Another example: the symbol \(x\) with negative assumption is comparable with a natural number.

Also there are “least” elements, which are comparable with all others, and have a zero property (maximum or minimum for all elements). E.g. \(oo\). In case of it the allocation operation is terminated and only this value is returned.

Assumption:

if A > B > C then A > C
if A == B then B can be removed

root¶

sympy.functions.elementary.miscellaneous.root(x, n, k) → Returns the k-th n-th root of x, defaulting to the[source]¶

principle root (k=0).

References

Examples

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

To get the k-th n-th root, specify k:

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

To get all n n-th roots you can use the rootof function. The following examples show the roots of unity for n equal 2, 3 and 4:

>>> from sympy import rootof, I

>>> [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, like other symbolic algebra systems, returns the complex root of negative numbers. This is the principal root and differs from the text-book result that one might be expecting. For example, the cube root of -8 does not come back as -2:

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

The real_root function can be used to either make the principle result real (or simply to return the real root directly):

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

Alternatively, the n//2-th n-th root of a negative number can be computed with root:

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

sqrt¶

sympy.functions.elementary.miscellaneous.sqrt(arg)[source]¶

The square root function

sqrt(x) -> Returns the principal square root of x.

References

R173: http://en.wikipedia.org/wiki/Square_root
R174: http://en.wikipedia.org/wiki/Principal_value

Examples

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

>>> sqrt(x)
sqrt(x)

>>> sqrt(x)**2
x

Note that sqrt(x**2) does not simplify to x.

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

This is because the two are not equal to each other in general. For example, consider x == -1:

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

This is because sqrt computes the principal square root, so the square may put the argument in a different branch. This identity does hold if x is positive:

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

You can force this simplification by using the powdenest() function with the force option set to True:

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

To get both branches of the square root you can use the rootof function:

>>> from sympy import rootof

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