Generalized functions¶

Sage implements several generalized functions (also known as distributions) such as Dirac delta, Heaviside step functions. These generalized functions can be manipulated within Sage like any other symbolic functions.

AUTHORS:

Golam Mortuza Hossain (2009-06-26): initial version

EXAMPLES:

Dirac delta function:

Sage

sage: dirac_delta(x)                                                                # needs sage.symbolic
dirac_delta(x)

Python

>>> from sage.all import *
>>> dirac_delta(x)                                                                # needs sage.symbolic
dirac_delta(x)

Sage Live

dirac_delta(x)                                                                # needs sage.symbolic

Heaviside step function:

Sage

sage: heaviside(x)                                                                  # needs sage.symbolic
heaviside(x)

Python

>>> from sage.all import *
>>> heaviside(x)                                                                  # needs sage.symbolic
heaviside(x)

Sage Live

heaviside(x)                                                                  # needs sage.symbolic

Unit step function:

Sage

sage: unit_step(x)                                                                  # needs sage.symbolic
unit_step(x)

Python

>>> from sage.all import *
>>> unit_step(x)                                                                  # needs sage.symbolic
unit_step(x)

Sage Live

unit_step(x)                                                                  # needs sage.symbolic

Signum (sgn) function:

Sage

sage: sgn(x)                                                                        # needs sage.symbolic
sgn(x)

Python

>>> from sage.all import *
>>> sgn(x)                                                                        # needs sage.symbolic
sgn(x)

Sage Live

sgn(x)                                                                        # needs sage.symbolic

Kronecker delta function:

Sage

sage: m, n = var('m,n')                                                             # needs sage.symbolic
sage: kronecker_delta(m, n)                                                         # needs sage.symbolic
kronecker_delta(m, n)

Python

>>> from sage.all import *
>>> m, n = var('m,n')                                                             # needs sage.symbolic
>>> kronecker_delta(m, n)                                                         # needs sage.symbolic
kronecker_delta(m, n)

Sage Live

m, n = var('m,n')                                                             # needs sage.symbolic
kronecker_delta(m, n)                                                         # needs sage.symbolic

class sage.functions.generalized.FunctionDiracDelta[source]¶

Bases: BuiltinFunction

The Dirac delta (generalized) function, \(\delta(x)\) (dirac_delta(x)).

INPUT:

x – a real number or a symbolic expression

DEFINITION:

Dirac delta function \(\delta(x)\), is defined in Sage as:

\(\delta(x) = 0\) for real \(x \ne 0\) and \(\int_{-\infty}^{\infty} \delta(x) dx = 1\)

Its alternate definition with respect to an arbitrary test function \(f(x)\) is

\(\int_{-\infty}^{\infty} f(x) \delta(x-a) dx = f(a)\)

EXAMPLES:

Sage

sage: # needs sage.symbolic
sage: dirac_delta(1)
0
sage: dirac_delta(0)
dirac_delta(0)
sage: dirac_delta(x)
dirac_delta(x)
sage: integrate(dirac_delta(x), x, -1, 1, algorithm='sympy')                    # needs sympy
1

Python

>>> from sage.all import *
>>> # needs sage.symbolic
>>> dirac_delta(Integer(1))
0
>>> dirac_delta(Integer(0))
dirac_delta(0)
>>> dirac_delta(x)
dirac_delta(x)
>>> integrate(dirac_delta(x), x, -Integer(1), Integer(1), algorithm='sympy')                    # needs sympy
1

Sage Live

# needs sage.symbolic
dirac_delta(1)
dirac_delta(0)
dirac_delta(x)
integrate(dirac_delta(x), x, -1, 1, algorithm='sympy')                    # needs sympy

REFERENCES:

Wikipedia article Dirac_delta_function

class sage.functions.generalized.FunctionHeaviside[source]¶

Bases: GinacFunction

The Heaviside step function, \(H(x)\) (heaviside(x)).

INPUT:

x – a real number or a symbolic expression

DEFINITION:

The Heaviside step function, \(H(x)\) is defined in Sage as:

\(H(x) = 0\) for \(x < 0\) and \(H(x) = 1\) for \(x > 0\)

See also

unit_step()

EXAMPLES:

Sage

sage: # needs sage.symbolic
sage: heaviside(-1)
0
sage: heaviside(1)
1
sage: heaviside(0)
heaviside(0)
sage: heaviside(x)
heaviside(x)

sage: heaviside(-1/2)                                                           # needs sage.symbolic
0
sage: heaviside(exp(-1000000000000000000000))                                   # needs sage.symbolic
1

Python

>>> from sage.all import *
>>> # needs sage.symbolic
>>> heaviside(-Integer(1))
0
>>> heaviside(Integer(1))
1
>>> heaviside(Integer(0))
heaviside(0)
>>> heaviside(x)
heaviside(x)

>>> heaviside(-Integer(1)/Integer(2))                                                           # needs sage.symbolic
0
>>> heaviside(exp(-Integer(1000000000000000000000)))                                   # needs sage.symbolic
1

Sage Live

# needs sage.symbolic
heaviside(-1)
heaviside(1)
heaviside(0)
heaviside(x)
heaviside(-1/2)                                                           # needs sage.symbolic
heaviside(exp(-1000000000000000000000))                                   # needs sage.symbolic

REFERENCES:

Wikipedia article Heaviside_function

class sage.functions.generalized.FunctionKroneckerDelta[source]¶

Bases: BuiltinFunction

The Kronecker delta function \(\delta_{m,n}\) (kronecker_delta(m, n)).

INPUT:

m – a number or a symbolic expression
n – a number or a symbolic expression

DEFINITION:

Kronecker delta function \(\delta_{m,n}\) is defined as:

\(\delta_{m,n} = 0\) for \(m \ne n\) and \(\delta_{m,n} = 1\) for \(m = n\)

EXAMPLES:

Sage

sage: kronecker_delta(1, 2)                                                     # needs sage.rings.complex_interval_field
0
sage: kronecker_delta(1, 1)                                                     # needs sage.rings.complex_interval_field
1
sage: m, n = var('m,n')                                                         # needs sage.symbolic
sage: kronecker_delta(m, n)                                                     # needs sage.symbolic
kronecker_delta(m, n)

Python

>>> from sage.all import *
>>> kronecker_delta(Integer(1), Integer(2))                                                     # needs sage.rings.complex_interval_field
0
>>> kronecker_delta(Integer(1), Integer(1))                                                     # needs sage.rings.complex_interval_field
1
>>> m, n = var('m,n')                                                         # needs sage.symbolic
>>> kronecker_delta(m, n)                                                     # needs sage.symbolic
kronecker_delta(m, n)

Sage Live

kronecker_delta(1, 2)                                                     # needs sage.rings.complex_interval_field
kronecker_delta(1, 1)                                                     # needs sage.rings.complex_interval_field
m, n = var('m,n')                                                         # needs sage.symbolic
kronecker_delta(m, n)                                                     # needs sage.symbolic

REFERENCES:

Wikipedia article Kronecker_delta

class sage.functions.generalized.FunctionSignum[source]¶

Bases: BuiltinFunction

The signum or sgn function \(\mathrm{sgn}(x)\) (sgn(x)).

INPUT:

x – a real number or a symbolic expression

DEFINITION:

The sgn function, \(\mathrm{sgn}(x)\) is defined as:

\(\mathrm{sgn}(x) = 1\) for \(x > 0\), \(\mathrm{sgn}(x) = 0\) for \(x = 0\) and \(\mathrm{sgn}(x) = -1\) for \(x < 0\)

EXAMPLES:

Sage

sage: sgn(-1)
-1
sage: sgn(1)
1
sage: sgn(0)
0
sage: sgn(x)                                                                    # needs sage.symbolic
sgn(x)

Python

>>> from sage.all import *
>>> sgn(-Integer(1))
-1
>>> sgn(Integer(1))
1
>>> sgn(Integer(0))
0
>>> sgn(x)                                                                    # needs sage.symbolic
sgn(x)

Sage Live

sgn(-1)
sgn(1)
sgn(0)
sgn(x)                                                                    # needs sage.symbolic

We can also use sign:

Sage

sage: sign(1)
1
sage: sign(0)
0
sage: a = AA(-5).nth_root(7)                                                    # needs sage.rings.number_field
sage: sign(a)                                                                   # needs sage.rings.number_field
-1

Python

>>> from sage.all import *
>>> sign(Integer(1))
1
>>> sign(Integer(0))
0
>>> a = AA(-Integer(5)).nth_root(Integer(7))                                                    # needs sage.rings.number_field
>>> sign(a)                                                                   # needs sage.rings.number_field
-1

Sage Live

sign(1)
sign(0)
a = AA(-5).nth_root(7)                                                    # needs sage.rings.number_field
sign(a)                                                                   # needs sage.rings.number_field

REFERENCES:

Wikipedia article Sign_function

class sage.functions.generalized.FunctionUnitStep[source]¶

Bases: GinacFunction

The unit step function, \(\mathrm{u}(x)\) (unit_step(x)).

INPUT:

x – a real number or a symbolic expression

DEFINITION:

The unit step function, \(\mathrm{u}(x)\) is defined in Sage as:

\(\mathrm{u}(x) = 0\) for \(x < 0\) and \(\mathrm{u}(x) = 1\) for \(x \geq 0\)