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: dirac_delta(x)                                                                # needs sage.symbolic
dirac_delta(x)

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

Heaviside step function:

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

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

Unit step function:

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

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

Signum (sgn) function:

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

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

Kronecker delta function:

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

>>> from sage.all import *
>>> m, n = var('m,n')                                                             # needs sage.symbolic
>>> kronecker_delta(m, n)                                                         # needs sage.symbolic
kronecker_delta(m, n)
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: # 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

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

REFERENCES:

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

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

REFERENCES:

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

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

REFERENCES:

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: sgn(-1)
-1
sage: sgn(1)
1
sage: sgn(0)
0
sage: sgn(x)                                                                    # needs sage.symbolic
sgn(x)

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

We can also use sign:

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

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

REFERENCES:

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

See also

heaviside()

EXAMPLES:

sage: # needs sage.symbolic
sage: unit_step(-1)
0
sage: unit_step(1)
1
sage: unit_step(0)
1
sage: unit_step(x)
unit_step(x)
sage: unit_step(-exp(-10000000000000000000))
0

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