def test_rewrite():
assert SingularityFunction(x, 4, 5).rewrite(Piecewise) == (
Piecewise(((x - 4)**5, x - 4 > 0), (0, True)))
assert SingularityFunction(x, -10, 0).rewrite(Piecewise) == (
Piecewise((1, x + 10 > 0), (0, True)))
assert SingularityFunction(x, 2, -1).rewrite(Piecewise) == (
Piecewise((oo, Eq(x - 2, 0)), (0, True)))
assert SingularityFunction(x, 0, -2).rewrite(Piecewise) == (
Piecewise((oo, Eq(x, 0)), (0, True)))
n = Symbol('n', nonnegative=True)
assert SingularityFunction(x, a, n).rewrite(Piecewise) == (
Piecewise(((x - a)**n, x - a > 0), (0, True)))
expr_in = SingularityFunction(x, 4, 5) + SingularityFunction(x, -3, -1) - SingularityFunction(x, 0, -2)
expr_out = (x - 4)**5*Heaviside(x - 4) + DiracDelta(x + 3) - DiracDelta(x, 1)
assert expr_in.rewrite(Heaviside) == expr_out
assert expr_in.rewrite(DiracDelta) == expr_out
assert expr_in.rewrite('HeavisideDiracDelta') == expr_out
expr_in = SingularityFunction(x, a, n) + SingularityFunction(x, a, -1) - SingularityFunction(x, a, -2)
expr_out = (x - a)**n*Heaviside(x - a) + DiracDelta(x - a) + DiracDelta(a - x, 1)
assert expr_in.rewrite(Heaviside) == expr_out
assert expr_in.rewrite(DiracDelta) == expr_out
assert expr_in.rewrite('HeavisideDiracDelta') == expr_out
def test_3dpos():
assert Y.hilbert_space == L2(Interval(S.NegativeInfinity, S.Infinity))
assert Z.hilbert_space == L2(Interval(S.NegativeInfinity, S.Infinity))
test_ket = PositionKet3D(x, y, z)
assert qapply(X * test_ket) == x * test_ket
assert qapply(Y * test_ket) == y * test_ket
assert qapply(Z * test_ket) == z * test_ket
assert qapply(X * Y * test_ket) == x * y * test_ket
assert qapply(X * Y * Z * test_ket) == x * y * z * test_ket
assert qapply(Y * Z * test_ket) == y * z * test_ket
assert PositionKet3D() == test_ket
assert YOp() == Y
assert ZOp() == Z
assert PositionKet3D.dual_class() == PositionBra3D
assert PositionBra3D.dual_class() == PositionKet3D
other_ket = PositionKet3D(x_1, y_1, z_1)
assert (Dagger(other_ket)*test_ket).doit() == \
DiracDelta(x - x_1)*DiracDelta(y - y_1)*DiracDelta(z - z_1)
assert test_ket.position_x == x
assert test_ket.position_y == y
assert test_ket.position_z == z
assert other_ket.position_x == x_1
assert other_ket.position_y == y_1
assert other_ket.position_z == z_1
def test_inverse_laplace_transform():
from sympy.core.exprtools import factor_terms
from sympy.functions.special.delta_functions import DiracDelta
from sympy.simplify.simplify import simplify
ILT = inverse_laplace_transform
a, b, c, = symbols('a b c', positive=True)
t = symbols('t')
def simp_hyp(expr):
return factor_terms(expand_mul(expr)).rewrite(sin)
assert ILT(1, s, t) == DiracDelta(t)
assert ILT(1/s, s, t) == Heaviside(t)
assert ILT(a/(a + s), s, t) == a*exp(-a*t)*Heaviside(t)
assert ILT(s/(a + s), s, t) == -a*exp(-a*t)*Heaviside(t) + DiracDelta(t)
assert ILT((a + s)**(-2), s, t) == t*exp(-a*t)*Heaviside(t)
assert ILT((a + s)**(-5), s, t) == t**4*exp(-a*t)*Heaviside(t)/24
assert ILT(a/(a**2 + s**2), s, t) == sin(a*t)*Heaviside(t)
assert ILT(s/(s**2 + a**2), s, t) == cos(a*t)*Heaviside(t)
assert ILT(b/(b**2 + (a + s)**2), s, t) == exp(-a*t)*sin(b*t)*Heaviside(t)
assert ILT(b*s/(b**2 + (a + s)**2), s, t) +\
(a*sin(b*t) - b*cos(b*t))*exp(-a*t)*Heaviside(t) == 0
assert ILT(exp(-a*s)/s, s, t) == Heaviside(-a + t)
assert ILT(exp(-a*s)/(b + s), s, t) == exp(b*(a - t))*Heaviside(-a + t)
assert ILT((b + s)/(a**2 + (b + s)**2), s, t) == \
exp(-b*t)*cos(a*t)*Heaviside(t)
assert ILT(exp(-a*s)/s**b, s, t) == \
(-a + t)**(b - 1)*Heaviside(-a + t)/gamma(b)
assert ILT(exp(-a*s)/sqrt(s**2 + 1), s, t) == \
Heaviside(-a + t)*besselj(0, a - t)
assert ILT(1/(s*sqrt(s + 1)), s, t) == Heaviside(t)*erf(sqrt(t))
assert ILT(1/(s**2*(s**2 + 1)), s, t) == (t - sin(t))*Heaviside(t)
assert ILT(s**2/(s**2 + 1), s, t) == -sin(t)*Heaviside(t) + DiracDelta(t)
assert ILT(1 - 1/(s**2 + 1), s, t) == -sin(t)*Heaviside(t) + DiracDelta(t)
assert ILT(1/s**2, s, t) == t*Heaviside(t)
assert ILT(1/s**5, s, t) == t**4*Heaviside(t)/24
assert simp_hyp(ILT(a/(s**2 - a**2), s, t)) == sinh(a*t)*Heaviside(t)
assert simp_hyp(ILT(s/(s**2 - a**2), s, t)) == cosh(a*t)*Heaviside(t)
# TODO sinh/cosh shifted come out a mess. also delayed trig is a mess
# TODO should this simplify further?
assert ILT(exp(-a*s)/s**b, s, t) == \
(t - a)**(b - 1)*Heaviside(t - a)/gamma(b)
assert ILT(exp(-a*s)/sqrt(1 + s**2), s, t) == \
Heaviside(t - a)*besselj(0, a - t) # note: besselj(0, x) is even
# XXX ILT turns these branch factor into trig functions ...
assert simplify(ILT(a**b*(s + sqrt(s**2 - a**2))**(-b)/sqrt(s**2 - a**2),
s, t).rewrite(exp)) == \
Heaviside(t)*besseli(b, a*t)
assert ILT(a**b*(s + sqrt(s**2 + a**2))**(-b)/sqrt(s**2 + a**2),
s, t).rewrite(exp) == \
Heaviside(t)*besselj(b, a*t)
assert ILT(1/(s*sqrt(s + 1)), s, t) == Heaviside(t)*erf(sqrt(t))
# TODO can we make erf(t) work?
assert ILT(1/(s**2*(s**2 + 1)),s,t) == (t - sin(t))*Heaviside(t)
assert ILT( (s * eye(2) - Matrix([[1, 0], [0, 2]])).inv(), s, t) ==\
Matrix([[exp(t)*Heaviside(t), 0], [0, exp(2*t)*Heaviside(t)]])
def _eval_derivative(self, x):
if self.args[0].is_real:
from sympy.functions.special.delta_functions import DiracDelta
return 2 * Derivative(self.args[0], x, evaluate=True) \
* DiracDelta(self.args[0])
elif self.args[0].is_imaginary:
from sympy.functions.special.delta_functions import DiracDelta
return 2 * Derivative(self.args[0], x, evaluate=True) \
* DiracDelta(-S.ImaginaryUnit * self.args[0])
def test_rewrite():
x, y = Symbol('x', real=True), Symbol('y')
assert Heaviside(x).rewrite(Piecewise) == (Piecewise(
(0, x < 0), (Heaviside(0), Eq(x, 0)), (1, x > 0)))
assert Heaviside(y).rewrite(Piecewise) == (Piecewise(
(0, y < 0), (Heaviside(0), Eq(y, 0)), (1, y > 0)))
assert Heaviside(x, y).rewrite(Piecewise) == (Piecewise(
(0, x < 0), (y, Eq(x, 0)), (1, x > 0)))
assert Heaviside(x, 0).rewrite(Piecewise) == (Piecewise((0, x <= 0),
(1, x > 0)))
assert Heaviside(x, 1).rewrite(Piecewise) == (Piecewise((0, x < 0),
(1, x >= 0)))
assert Heaviside(x, nan).rewrite(Piecewise) == (Piecewise(
(0, x < 0), (nan, Eq(x, 0)), (1, x > 0)))
assert Heaviside(x).rewrite(sign) == \
Heaviside(x, H0=Heaviside(0)).rewrite(sign) == \
Piecewise(
(sign(x)/2 + S(1)/2, Eq(Heaviside(0), S(1)/2)),
(Piecewise(
(sign(x)/2 + S(1)/2, Ne(x, 0)), (Heaviside(0), True)), True)
)
assert Heaviside(y).rewrite(sign) == Heaviside(y)
assert Heaviside(x, S.Half).rewrite(sign) == (sign(x) + 1) / 2
assert Heaviside(x, y).rewrite(sign) == \
Piecewise(
(sign(x)/2 + S(1)/2, Eq(y, S(1)/2)),
(Piecewise(
(sign(x)/2 + S(1)/2, Ne(x, 0)), (y, True)), True)
)
assert DiracDelta(y).rewrite(Piecewise) == Piecewise(
(DiracDelta(0), Eq(y, 0)), (0, True))
assert DiracDelta(y, 1).rewrite(Piecewise) == DiracDelta(y, 1)
assert DiracDelta(x - 5).rewrite(Piecewise) == (Piecewise(
(DiracDelta(0), Eq(x - 5, 0)), (0, True)))
assert (x * DiracDelta(x - 10)).rewrite(
SingularityFunction) == x * SingularityFunction(x, 10, -1)
assert 5 * x * y * DiracDelta(
y, 1).rewrite(SingularityFunction) == 5 * x * y * SingularityFunction(
y, 0, -2)
assert DiracDelta(0).rewrite(SingularityFunction) == SingularityFunction(
0, 0, -1)
assert DiracDelta(0,
1).rewrite(SingularityFunction) == SingularityFunction(
0, 0, -2)
assert Heaviside(x).rewrite(SingularityFunction) == SingularityFunction(
x, 0, 0)
assert 5 * x * y * Heaviside(y + 1).rewrite(
SingularityFunction) == 5 * x * y * SingularityFunction(y, -1, 0)
assert ((x - 3)**3 * Heaviside(x - 3)).rewrite(
SingularityFunction) == (x - 3)**3 * SingularityFunction(x, 3, 0)
assert Heaviside(0).rewrite(SingularityFunction) == S.Half
def test_heaviside():
assert Heaviside(-5) == 0
assert Heaviside(1) == 1
assert Heaviside(0) == S.Half
assert Heaviside(0, x) == x
assert unchanged(Heaviside,x, nan)
assert Heaviside(0, nan) == nan
h0 = Heaviside(x, 0)
h12 = Heaviside(x, S.Half)
h1 = Heaviside(x, 1)
assert h0.args == h0.pargs == (x, 0)
assert h1.args == h1.pargs == (x, 1)
assert h12.args == (x, S.Half)
assert h12.pargs == (x,) # default 1/2 suppressed
assert adjoint(Heaviside(x)) == Heaviside(x)
assert adjoint(Heaviside(x - y)) == Heaviside(x - y)
assert conjugate(Heaviside(x)) == Heaviside(x)
assert conjugate(Heaviside(x - y)) == Heaviside(x - y)
assert transpose(Heaviside(x)) == Heaviside(x)
assert transpose(Heaviside(x - y)) == Heaviside(x - y)
assert Heaviside(x).diff(x) == DiracDelta(x)
assert Heaviside(x + I).is_Function is True
assert Heaviside(I*x).is_Function is True
raises(ArgumentIndexError, lambda: Heaviside(x).fdiff(2))
raises(ValueError, lambda: Heaviside(I))
raises(ValueError, lambda: Heaviside(2 + 3*I))
def _represent_PxKet(self, basis, *, index=1, **options):
states = basis._enumerate_state(2, start_index=index)
coord1 = states[0].momentum
coord2 = states[1].momentum
d = DifferentialOperator(coord1)
delta = DiracDelta(coord1 - coord2)
return I*hbar*(d*delta)
def test_inverse_laplace_transform_delta_cond():
from sympy.functions.elementary.complexes import im
from sympy.functions.special.delta_functions import DiracDelta
ILT = inverse_laplace_transform
t = symbols('t')
r = Symbol('r', real=True)
assert ILT(exp(r*s), s, t, noconds=False) == (DiracDelta(t + r), True)
z = Symbol('z')
assert ILT(exp(z*s), s, t, noconds=False) == \
(DiracDelta(t + z), Eq(im(z), 0))
# inversion does not exist: verify it doesn't evaluate to DiracDelta
for z in (Symbol('z', extended_real=False),
Symbol('z', imaginary=True, zero=False)):
f = ILT(exp(z*s), s, t, noconds=False)
f = f[0] if isinstance(f, tuple) else f
assert f.func != DiracDelta
# issue 15043
assert ILT(1/s + exp(r*s)/s, s, t, noconds=False) == (
Heaviside(t) + Heaviside(r + t), True)
def test_mix_expression():
Y, E = Poisson('Y', 1), Exponential('E', 1)
k = Dummy('k')
expr1 = Integral(
Sum(
exp(-1) * Integral(exp(-k) * DiracDelta(k - 2),
(k, 0, oo)) / factorial(k), (k, 0, oo)),
(k, -oo, 0))
expr2 = Integral(
Sum(
exp(-1) * Integral(exp(-k) * DiracDelta(k - 2),
(k, 0, oo)) / factorial(k), (k, 0, oo)),
(k, 0, oo))
assert P(Eq(Y + E, 1)) == 0
assert P(Ne(Y + E, 2)) == 1
with ignore_warnings(
UserWarning): ### TODO: Restore tests once warnings are removed
assert P(E + Y < 2, evaluate=False).rewrite(Integral).dummy_eq(expr1)
assert P(E + Y > 2, evaluate=False).rewrite(Integral).dummy_eq(expr2)
def compute_density(self, expr, **kwargs):
# Common case Density(X) where X in self.values
if expr in self.values:
# Marginalize all other random symbols out of the density
randomsymbols = tuple(set(self.values) - frozenset([expr]))
symbols = tuple(rs.symbol for rs in randomsymbols)
pdf = self.domain.compute_expectation(self.pdf, symbols, **kwargs)
return Lambda(expr.symbol, pdf)
z = Dummy('z', real=True, finite=True)
return Lambda(z, self.compute_expectation(DiracDelta(expr - z), **kwargs))
def test_p():
assert Px.hilbert_space == L2(Interval(S.NegativeInfinity, S.Infinity))
assert qapply(Px * PxKet(px)) == px * PxKet(px)
assert PxKet(px).dual_class() == PxBra
assert PxBra(x).dual_class() == PxKet
assert (Dagger(PxKet(py)) * PxKet(px)).doit() == DiracDelta(px - py)
assert (XBra(x)*PxKet(px)).doit() == \
exp(I*x*px/hbar)/sqrt(2*pi*hbar)
assert represent(PxKet(px)) == DiracDelta(px - px_1)
rep_x = represent(PxOp(), basis=XOp)
assert rep_x == -hbar * I * DiracDelta(x_1 -
x_2) * DifferentialOperator(x_1)
assert rep_x == represent(PxOp(), basis=XOp())
assert rep_x == represent(PxOp(), basis=XKet)
assert rep_x == represent(PxOp(), basis=XKet())
assert represent(PxOp()*XKet(), basis=XKet) == \
-hbar*I*DiracDelta(x - x_2)*DifferentialOperator(x)
assert represent(XBra("y")*PxOp()*XKet(), basis=XKet) == \
-hbar*I*DiracDelta(x - y)*DifferentialOperator(x)
def compute_density(self, expr, **kwargs):
# Common case Density(X) where X in self.values
if expr in self.values:
# Marginalize all other random symbols out of the density
density = self.domain.integrate(
self.density,
set(rs.symbol for rs in self.values - frozenset((expr, ))),
**kwargs)
return Lambda(expr.symbol, density)
z = Dummy('z', real=True, bounded=True)
return Lambda(z, self.integrate(DiracDelta(expr - z), **kwargs))
def integrate(self, expr, variables=None, **kwargs):
if variables is None:
variables = self.symbols
if not variables:
return expr
# Extract the full integral
fullintgrl = self.fulldomain.integrate(expr, variables, evaluate=False)
# separate into integrand and limits
integrand, limits = fullintgrl.function, list(fullintgrl.limits)
conditions = [self.condition]
while conditions:
cond = conditions.pop()
if cond.is_Boolean:
if isinstance(cond, And):
conditions.extend(cond.args)
elif isinstance(cond, Or):
raise NotImplementedError("Or not implemented here")
elif cond.is_Relational:
if cond.is_Equality:
# Add the appropriate Delta to the integrand
integrand *= DiracDelta(cond.lhs - cond.rhs)
else:
symbols = cond.free_symbols & set(self.symbols)
if len(symbols) != 1: # Can't handle x > y
raise NotImplementedError(
"Multivariate Inequalities not yet implemented")
# Can handle x > 0
symbol = symbols.pop()
# Find the limit with x, such as (x, -oo, oo)
for i, limit in enumerate(limits):
if limit[0] == symbol:
# Make condition into an Interval like [0, oo]
cintvl = reduce_poly_inequalities_wrap(
cond, symbol)
# Make limit into an Interval like [-oo, oo]
lintvl = Interval(limit[1], limit[2])
# Intersect them to get [0, oo]
intvl = cintvl.intersect(lintvl)
# Put back into limits list
limits[i] = (symbol, intvl.left, intvl.right)
else:
raise TypeError("Condition %s is not a relational or Boolean" %
cond)
evaluate = kwargs.pop('evaluate', True)
if evaluate:
return integrate(integrand, *limits, **kwargs)
return Integral(integrand, *limits, **kwargs)
def test_inverse_laplace_transform_delta():
from sympy.functions.special.delta_functions import DiracDelta
ILT = inverse_laplace_transform
t = symbols('t')
assert ILT(2, s, t) == 2*DiracDelta(t)
assert ILT(2*exp(3*s) - 5*exp(-7*s), s, t) == \
2*DiracDelta(t + 3) - 5*DiracDelta(t - 7)
a = cos(sin(7)/2)
assert ILT(a*exp(-3*s), s, t) == a*DiracDelta(t - 3)
assert ILT(exp(2*s), s, t) == DiracDelta(t + 2)
r = Symbol('r', real=True)
assert ILT(exp(r*s), s, t) == DiracDelta(t + r)
def test_density_constant():
assert density(3)(2) == 0
assert density(3)(3) == DiracDelta(0)
def test_laplace_transform():
from sympy import lowergamma
from sympy.functions.special.delta_functions import DiracDelta
from sympy.functions.special.error_functions import (fresnelc, fresnels)
LT = laplace_transform
a, b, c, = symbols('a, b, c', positive=True)
t, w, x = symbols('t, w, x')
f = Function("f")
g = Function("g")
# Test rule-base evaluation according to
# http://eqworld.ipmnet.ru/en/auxiliary/inttrans/
# Power-law functions (laplace2.pdf)
assert LT(a*t+t**2+t**(S(5)/2), t, s) ==\
(a/s**2 + 2/s**3 + 15*sqrt(pi)/(8*s**(S(7)/2)), 0, True)
assert LT(b/(t+a), t, s) == (-b*exp(-a*s)*Ei(-a*s), 0, True)
assert LT(1/sqrt(t+a), t, s) ==\
(sqrt(pi)*sqrt(1/s)*exp(a*s)*erfc(sqrt(a)*sqrt(s)), 0, True)
assert LT(sqrt(t)/(t+a), t, s) ==\
(-pi*sqrt(a)*exp(a*s)*erfc(sqrt(a)*sqrt(s)) + sqrt(pi)*sqrt(1/s),
0, True)
assert LT((t+a)**(-S(3)/2), t, s) ==\
(-2*sqrt(pi)*sqrt(s)*exp(a*s)*erfc(sqrt(a)*sqrt(s)) + 2/sqrt(a),
0, True)
assert LT(t**(S(1)/2)*(t+a)**(-1), t, s) ==\
(-pi*sqrt(a)*exp(a*s)*erfc(sqrt(a)*sqrt(s)) + sqrt(pi)*sqrt(1/s),
0, True)
assert LT(1/(a*sqrt(t) + t**(3/2)), t, s) ==\
(pi*sqrt(a)*exp(a*s)*erfc(sqrt(a)*sqrt(s)), 0, True)
assert LT((t+a)**b, t, s) ==\
(s**(-b - 1)*exp(-a*s)*lowergamma(b + 1, a*s), 0, True)
assert LT(t**5/(t+a), t, s) == (120*a**5*lowergamma(-5, a*s), 0, True)
# Exponential functions (laplace3.pdf)
assert LT(exp(t), t, s) == (1/(s - 1), 1, True)
assert LT(exp(2*t), t, s) == (1/(s - 2), 2, True)
assert LT(exp(a*t), t, s) == (1/(s - a), a, True)
assert LT(exp(a*(t-b)), t, s) == (exp(-a*b)/(-a + s), a, True)
assert LT(t*exp(-a*(t)), t, s) == ((a + s)**(-2), -a, True)
assert LT(t*exp(-a*(t-b)), t, s) == (exp(a*b)/(a + s)**2, -a, True)
assert LT(b*t*exp(-a*t), t, s) == (b/(a + s)**2, -a, True)
assert LT(t**(S(7)/4)*exp(-8*t)/gamma(S(11)/4), t, s) ==\
((s + 8)**(-S(11)/4), -8, True)
assert LT(t**(S(3)/2)*exp(-8*t), t, s) ==\
(3*sqrt(pi)/(4*(s + 8)**(S(5)/2)), -8, True)
assert LT(t**a*exp(-a*t), t, s) == ((a+s)**(-a-1)*gamma(a+1), -a, True)
assert LT(b*exp(-a*t**2), t, s) ==\
(sqrt(pi)*b*exp(s**2/(4*a))*erfc(s/(2*sqrt(a)))/(2*sqrt(a)), 0, True)
assert LT(exp(-2*t**2), t, s) ==\
(sqrt(2)*sqrt(pi)*exp(s**2/8)*erfc(sqrt(2)*s/4)/4, 0, True)
assert LT(b*exp(2*t**2), t, s) == b*LaplaceTransform(exp(2*t**2), t, s)
assert LT(t*exp(-a*t**2), t, s) ==\
(1/(2*a) - s*erfc(s/(2*sqrt(a)))/(4*sqrt(pi)*a**(S(3)/2)), 0, True)
assert LT(exp(-a/t), t, s) ==\
(2*sqrt(a)*sqrt(1/s)*besselk(1, 2*sqrt(a)*sqrt(s)), 0, True)
assert LT(sqrt(t)*exp(-a/t), t, s) ==\
(sqrt(pi)*(2*sqrt(a)*sqrt(s) + 1)*sqrt(s**(-3))*exp(-2*sqrt(a)*\
sqrt(s))/2, 0, True)
assert LT(exp(-a/t)/sqrt(t), t, s) ==\
(sqrt(pi)*sqrt(1/s)*exp(-2*sqrt(a)*sqrt(s)), 0, True)
assert LT( exp(-a/t)/(t*sqrt(t)), t, s) ==\
(sqrt(pi)*sqrt(1/a)*exp(-2*sqrt(a)*sqrt(s)), 0, True)
assert LT(exp(-2*sqrt(a*t)), t, s) ==\
( 1/s -sqrt(pi)*sqrt(a) * exp(a/s)*erfc(sqrt(a)*sqrt(1/s))/\
s**(S(3)/2), 0, True)
assert LT(exp(-2*sqrt(a*t))/sqrt(t), t, s) == (exp(a/s)*erfc(sqrt(a)*\
sqrt(1/s))*(sqrt(pi)*sqrt(1/s)), 0, True)
assert LT(t**4*exp(-2/t), t, s) ==\
(8*sqrt(2)*(1/s)**(S(5)/2)*besselk(5, 2*sqrt(2)*sqrt(s)), 0, True)
# Hyperbolic functions (laplace4.pdf)
assert LT(sinh(a*t), t, s) == (a/(-a**2 + s**2), a, True)
assert LT(b*sinh(a*t)**2, t, s) == (2*a**2*b/(-4*a**2*s**2 + s**3),
2*a, True)
# The following line confirms that issue #21202 is solved
assert LT(cosh(2*t), t, s) == (s/(-4 + s**2), 2, True)
assert LT(cosh(a*t), t, s) == (s/(-a**2 + s**2), a, True)
assert LT(cosh(a*t)**2, t, s) == ((-2*a**2 + s**2)/(-4*a**2*s**2 + s**3),
2*a, True)
assert LT(sinh(x + 3), x, s) == (
(-s + (s + 1)*exp(6) + 1)*exp(-3)/(s - 1)/(s + 1)/2, 0, Abs(s) > 1)
# The following line replaces the old test test_issue_7173()
assert LT(sinh(a*t)*cosh(a*t), t, s) == (a/(-4*a**2 + s**2), 2*a, True)
assert LT(sinh(a*t)/t, t, s) == (log((a + s)/(-a + s))/2, a, True)
assert LT(t**(-S(3)/2)*sinh(a*t), t, s) ==\
(-sqrt(pi)*(sqrt(-a + s) - sqrt(a + s)), a, True)
assert LT(sinh(2*sqrt(a*t)), t, s) ==\
(sqrt(pi)*sqrt(a)*exp(a/s)/s**(S(3)/2), 0, True)
assert LT(sqrt(t)*sinh(2*sqrt(a*t)), t, s) ==\
(-sqrt(a)/s**2 + sqrt(pi)*(a + s/2)*exp(a/s)*erf(sqrt(a)*\
sqrt(1/s))/s**(S(5)/2), 0, True)
assert LT(sinh(2*sqrt(a*t))/sqrt(t), t, s) ==\
(sqrt(pi)*exp(a/s)*erf(sqrt(a)*sqrt(1/s))/sqrt(s), 0, True)
assert LT(sinh(sqrt(a*t))**2/sqrt(t), t, s) ==\
(sqrt(pi)*(exp(a/s) - 1)/(2*sqrt(s)), 0, True)
assert LT(t**(S(3)/7)*cosh(a*t), t, s) ==\
(((a + s)**(-S(10)/7) + (-a+s)**(-S(10)/7))*gamma(S(10)/7)/2, a, True)
assert LT(cosh(2*sqrt(a*t)), t, s) ==\
(sqrt(pi)*sqrt(a)*exp(a/s)*erf(sqrt(a)*sqrt(1/s))/s**(S(3)/2) + 1/s,
0, True)
assert LT(sqrt(t)*cosh(2*sqrt(a*t)), t, s) ==\
(sqrt(pi)*(a + s/2)*exp(a/s)/s**(S(5)/2), 0, True)
assert LT(cosh(2*sqrt(a*t))/sqrt(t), t, s) ==\
(sqrt(pi)*exp(a/s)/sqrt(s), 0, True)
assert LT(cosh(sqrt(a*t))**2/sqrt(t), t, s) ==\
(sqrt(pi)*(exp(a/s) + 1)/(2*sqrt(s)), 0, True)
# logarithmic functions (laplace5.pdf)
assert LT(log(t), t, s) == (-log(s+S.EulerGamma)/s, 0, True)
assert LT(log(t/a), t, s) == (-log(a*s + S.EulerGamma)/s, 0, True)
assert LT(log(1+a*t), t, s) == (-exp(s/a)*Ei(-s/a)/s, 0, True)
assert LT(log(t+a), t, s) == ((log(a) - exp(s/a)*Ei(-s/a)/s)/s, 0, True)
assert LT(log(t)/sqrt(t), t, s) ==\
(sqrt(pi)*(-log(s) - 2*log(2) - S.EulerGamma)/sqrt(s), 0, True)
assert LT(t**(S(5)/2)*log(t), t, s) ==\
(15*sqrt(pi)*(-log(s)-2*log(2)-S.EulerGamma+S(46)/15)/(8*s**(S(7)/2)),
0, True)
assert (LT(t**3*log(t), t, s, noconds=True)-6*(-log(s) - S.EulerGamma\
+ S(11)/6)/s**4).simplify() == S.Zero
assert LT(log(t)**2, t, s) ==\
(((log(s) + EulerGamma)**2 + pi**2/6)/s, 0, True)
assert LT(exp(-a*t)*log(t), t, s) ==\
((-log(a + s) - S.EulerGamma)/(a + s), -a, True)
# Trigonometric functions (laplace6.pdf)
assert LT(sin(a*t), t, s) == (a/(a**2 + s**2), 0, True)
assert LT(Abs(sin(a*t)), t, s) ==\
(a*coth(pi*s/(2*a))/(a**2 + s**2), 0, True)
assert LT(sin(a*t)/t, t, s) == (atan(a/s), 0, True)
assert LT(sin(a*t)**2/t, t, s) == (log(4*a**2/s**2 + 1)/4, 0, True)
assert LT(sin(a*t)**2/t**2, t, s) ==\
(a*atan(2*a/s) - s*log(4*a**2/s**2 + 1)/4, 0, True)
assert LT(sin(2*sqrt(a*t)), t, s) ==\
(sqrt(pi)*sqrt(a)*exp(-a/s)/s**(S(3)/2), 0, True)
assert LT(sin(2*sqrt(a*t))/t, t, s) == (pi*erf(sqrt(a)*sqrt(1/s)), 0, True)
assert LT(cos(a*t), t, s) == (s/(a**2 + s**2), 0, True)
assert LT(cos(a*t)**2, t, s) ==\
((2*a**2 + s**2)/(s*(4*a**2 + s**2)), 0, True)
assert LT(sqrt(t)*cos(2*sqrt(a*t)), t, s) ==\
(sqrt(pi)*(-2*a + s)*exp(-a/s)/(2*s**(S(5)/2)), 0, True)
assert LT(cos(2*sqrt(a*t))/sqrt(t), t, s) ==\
(sqrt(pi)*sqrt(1/s)*exp(-a/s), 0, True)
assert LT(sin(a*t)*sin(b*t), t, s) ==\
(2*a*b*s/((s**2 + (a - b)**2)*(s**2 + (a + b)**2)), 0, True)
assert LT(cos(a*t)*sin(b*t), t, s) ==\
(b*(-a**2 + b**2 + s**2)/((s**2 + (a - b)**2)*(s**2 + (a + b)**2)),
0, True)
assert LT(cos(a*t)*cos(b*t), t, s) ==\
(s*(a**2 + b**2 + s**2)/((s**2 + (a - b)**2)*(s**2 + (a + b)**2)),
0, True)
assert LT(c*exp(-b*t)*sin(a*t), t, s) == (a*c/(a**2 + (b + s)**2),
-b, True)
assert LT(c*exp(-b*t)*cos(a*t), t, s) == ((b + s)*c/(a**2 + (b + s)**2),
-b, True)
assert LT(cos(x + 3), x, s) == ((s*cos(3) - sin(3))/(s**2 + 1), 0, True)
# Error functions (laplace7.pdf)
assert LT(erf(a*t), t, s) == (exp(s**2/(4*a**2))*erfc(s/(2*a))/s, 0, True)
assert LT(erf(sqrt(a*t)), t, s) == (sqrt(a)/(s*sqrt(a + s)), 0, True)
assert LT(exp(a*t)*erf(sqrt(a*t)), t, s) ==\
(sqrt(a)/(sqrt(s)*(-a + s)), a, True)
assert LT(erf(sqrt(a/t)/2), t, s) == ((1-exp(-sqrt(a)*sqrt(s)))/s, 0, True)
assert LT(erfc(sqrt(a*t)), t, s) ==\
((-sqrt(a) + sqrt(a + s))/(s*sqrt(a + s)), 0, True)
assert LT(exp(a*t)*erfc(sqrt(a*t)), t, s) ==\
(1/(sqrt(a)*sqrt(s) + s), 0, True)
assert LT(erfc(sqrt(a/t)/2), t, s) == (exp(-sqrt(a)*sqrt(s))/s, 0, True)
# Bessel functions (laplace8.pdf)
assert LT(besselj(0, a*t), t, s) == (1/sqrt(a**2 + s**2), 0, True)
assert LT(besselj(1, a*t), t, s) ==\
(a/(sqrt(a**2 + s**2)*(s + sqrt(a**2 + s**2))), 0, True)
assert LT(besselj(2, a*t), t, s) ==\
(a**2/(sqrt(a**2 + s**2)*(s + sqrt(a**2 + s**2))**2), 0, True)
assert LT(t*besselj(0, a*t), t, s) ==\
(s/(a**2 + s**2)**(S(3)/2), 0, True)
assert LT(t*besselj(1, a*t), t, s) ==\
(a/(a**2 + s**2)**(S(3)/2), 0, True)
assert LT(t**2*besselj(2, a*t), t, s) ==\
(3*a**2/(a**2 + s**2)**(S(5)/2), 0, True)
assert LT(besselj(0, 2*sqrt(a*t)), t, s) == (exp(-a/s)/s, 0, True)
assert LT(t**(S(3)/2)*besselj(3, 2*sqrt(a*t)), t, s) ==\
(a**(S(3)/2)*exp(-a/s)/s**4, 0, True)
assert LT(besselj(0, a*sqrt(t**2+b*t)), t, s) ==\
(exp(b*s - b*sqrt(a**2 + s**2))/sqrt(a**2 + s**2), 0, True)
assert LT(besseli(0, a*t), t, s) == (1/sqrt(-a**2 + s**2), a, True)
assert LT(besseli(1, a*t), t, s) ==\
(a/(sqrt(-a**2 + s**2)*(s + sqrt(-a**2 + s**2))), a, True)
assert LT(besseli(2, a*t), t, s) ==\
(a**2/(sqrt(-a**2 + s**2)*(s + sqrt(-a**2 + s**2))**2), a, True)
assert LT(t*besseli(0, a*t), t, s) == (s/(-a**2 + s**2)**(S(3)/2), a, True)
assert LT(t*besseli(1, a*t), t, s) == (a/(-a**2 + s**2)**(S(3)/2), a, True)
assert LT(t**2*besseli(2, a*t), t, s) ==\
(3*a**2/(-a**2 + s**2)**(S(5)/2), a, True)
assert LT(t**(S(3)/2)*besseli(3, 2*sqrt(a*t)), t, s) ==\
(a**(S(3)/2)*exp(a/s)/s**4, 0, True)
assert LT(bessely(0, a*t), t, s) ==\
(-2*asinh(s/a)/(pi*sqrt(a**2 + s**2)), 0, True)
assert LT(besselk(0, a*t), t, s) ==\
(log(s + sqrt(-a**2 + s**2))/sqrt(-a**2 + s**2), a, True)
assert LT(sin(a*t)**8, t, s) ==\
(40320*a**8/(s*(147456*a**8 + 52480*a**6*s**2 + 4368*a**4*s**4 +\
120*a**2*s**6 + s**8)), 0, True)
# Test general rules and unevaluated forms
# These all also test whether issue #7219 is solved.
assert LT(Heaviside(t-1)*cos(t-1), t, s) == (s*exp(-s)/(s**2 + 1), 0, True)
assert LT(a*f(t), t, w) == a*LaplaceTransform(f(t), t, w)
assert LT(a*Heaviside(t+1)*f(t+1), t, s) ==\
a*LaplaceTransform(f(t + 1)*Heaviside(t + 1), t, s)
assert LT(a*Heaviside(t-1)*f(t-1), t, s) ==\
a*LaplaceTransform(f(t), t, s)*exp(-s)
assert LT(b*f(t/a), t, s) == a*b*LaplaceTransform(f(t), t, a*s)
assert LT(exp(-f(x)*t), t, s) == (1/(s + f(x)), -f(x), True)
assert LT(exp(-a*t)*f(t), t, s) == LaplaceTransform(f(t), t, a + s)
assert LT(exp(-a*t)*erfc(sqrt(b/t)/2), t, s) ==\
(exp(-sqrt(b)*sqrt(a + s))/(a + s), -a, True)
assert LT(sinh(a*t)*f(t), t, s) ==\
LaplaceTransform(f(t), t, -a+s)/2 - LaplaceTransform(f(t), t, a+s)/2
assert LT(sinh(a*t)*t, t, s) ==\
(-1/(2*(a + s)**2) + 1/(2*(-a + s)**2), a, True)
assert LT(cosh(a*t)*f(t), t, s) ==\
LaplaceTransform(f(t), t, -a+s)/2 + LaplaceTransform(f(t), t, a+s)/2
assert LT(cosh(a*t)*t, t, s) ==\
(1/(2*(a + s)**2) + 1/(2*(-a + s)**2), a, True)
assert LT(sin(a*t)*f(t), t, s) ==\
I*(-LaplaceTransform(f(t), t, -I*a + s) +\
LaplaceTransform(f(t), t, I*a + s))/2
assert LT(sin(a*t)*t, t, s) ==\
(2*a*s/(a**4 + 2*a**2*s**2 + s**4), 0, True)
assert LT(cos(a*t)*f(t), t, s) ==\
LaplaceTransform(f(t), t, -I*a + s)/2 +\
LaplaceTransform(f(t), t, I*a + s)/2
assert LT(cos(a*t)*t, t, s) ==\
((-a**2 + s**2)/(a**4 + 2*a**2*s**2 + s**4), 0, True)
# The following two lines test whether issues #5813 and #7176 are solved.
assert LT(diff(f(t), (t, 1)), t, s) == s*LaplaceTransform(f(t), t, s)\
- f(0)
assert LT(diff(f(t), (t, 3)), t, s) == s**3*LaplaceTransform(f(t), t, s)\
- s**2*f(0) - s*Subs(Derivative(f(t), t), t, 0)\
- Subs(Derivative(f(t), (t, 2)), t, 0)
assert LT(a*f(b*t)+g(c*t), t, s) == a*LaplaceTransform(f(t), t, s/b)/b +\
LaplaceTransform(g(t), t, s/c)/c
assert inverse_laplace_transform(
f(w), w, t, plane=0) == InverseLaplaceTransform(f(w), w, t, 0)
assert LT(f(t)*g(t), t, s) == LaplaceTransform(f(t)*g(t), t, s)
# additional basic tests from wikipedia
assert LT((t - a)**b*exp(-c*(t - a))*Heaviside(t - a), t, s) == \
((s + c)**(-b - 1)*exp(-a*s)*gamma(b + 1), -c, True)
assert LT((exp(2*t) - 1)*exp(-b - t)*Heaviside(t)/2, t, s, noconds=True) \
== exp(-b)/(s**2 - 1)
# DiracDelta function: standard cases
assert LT(DiracDelta(t), t, s) == (1, 0, True)
assert LT(DiracDelta(a*t), t, s) == (1/a, 0, True)
assert LT(DiracDelta(t/42), t, s) == (42, 0, True)
assert LT(DiracDelta(t+42), t, s) == (0, 0, True)
assert LT(DiracDelta(t)+DiracDelta(t-42), t, s) == \
(1 + exp(-42*s), 0, True)
assert LT(DiracDelta(t)-a*exp(-a*t), t, s) == (s/(a + s), 0, True)
assert LT(exp(-t)*(DiracDelta(t)+DiracDelta(t-42)), t, s) == \
(exp(-42*s - 42) + 1, -oo, True)
# Collection of cases that cannot be fully evaluated and/or would catch
# some common implementation errors
assert LT(DiracDelta(t**2), t, s) == LaplaceTransform(DiracDelta(t**2), t, s)
assert LT(DiracDelta(t**2 - 1), t, s) == (exp(-s)/2, -oo, True)
assert LT(DiracDelta(t*(1 - t)), t, s) == \
LaplaceTransform(DiracDelta(-t**2 + t), t, s)
assert LT((DiracDelta(t) + 1)*(DiracDelta(t - 1) + 1), t, s) == \
(LaplaceTransform(DiracDelta(t)*DiracDelta(t - 1), t, s) + \
1 + exp(-s) + 1/s, 0, True)
assert LT(DiracDelta(2*t-2*exp(a)), t, s) == (exp(-s*exp(a))/2, 0, True)
assert LT(DiracDelta(-2*t+2*exp(a)), t, s) == (exp(-s*exp(a))/2, 0, True)
# Heaviside tests
assert LT(Heaviside(t), t, s) == (1/s, 0, True)
assert LT(Heaviside(t - a), t, s) == (exp(-a*s)/s, 0, True)
assert LT(Heaviside(t-1), t, s) == (exp(-s)/s, 0, True)
assert LT(Heaviside(2*t-4), t, s) == (exp(-2*s)/s, 0, True)
assert LT(Heaviside(-2*t+4), t, s) == ((1 - exp(-2*s))/s, 0, True)
assert LT(Heaviside(2*t+4), t, s) == (1/s, 0, True)
assert LT(Heaviside(-2*t+4), t, s) == ((1 - exp(-2*s))/s, 0, True)
# Fresnel functions
assert laplace_transform(fresnels(t), t, s) == \
((-sin(s**2/(2*pi))*fresnels(s/pi) + sin(s**2/(2*pi))/2 -
cos(s**2/(2*pi))*fresnelc(s/pi) + cos(s**2/(2*pi))/2)/s, 0, True)
assert laplace_transform(fresnelc(t), t, s) == (
((2*sin(s**2/(2*pi))*fresnelc(s/pi) - 2*cos(s**2/(2*pi))*fresnels(s/pi)
+ sqrt(2)*cos(s**2/(2*pi) + pi/4))/(2*s), 0, True))
# Matrix tests
Mt = Matrix([[exp(t), t*exp(-t)], [t*exp(-t), exp(t)]])
Ms = Matrix([[ 1/(s - 1), (s + 1)**(-2)],
[(s + 1)**(-2), 1/(s - 1)]])
# The default behaviour for Laplace tranform of a Matrix returns a Matrix
# of Tuples and is deprecated:
with warns_deprecated_sympy():
Ms_conds = Matrix([[(1/(s - 1), 1, True), ((s + 1)**(-2),
-1, True)], [((s + 1)**(-2), -1, True), (1/(s - 1), 1, True)]])
with warns_deprecated_sympy():
assert LT(Mt, t, s) == Ms_conds
# The new behavior is to return a tuple of a Matrix and the convergence
# conditions for the matrix as a whole:
assert LT(Mt, t, s, legacy_matrix=False) == (Ms, 1, True)
# With noconds=True the transformed matrix is returned without conditions
# either way:
assert LT(Mt, t, s, noconds=True) == Ms
assert LT(Mt, t, s, legacy_matrix=False, noconds=True) == Ms
def test_DiracDelta():
assert DiracDelta(1) == 0
assert DiracDelta(5.1) == 0
assert DiracDelta(-pi) == 0
assert DiracDelta(5, 7) == 0
assert DiracDelta(i) == 0
assert DiracDelta(j) == 0
assert DiracDelta(k) == 0
assert DiracDelta(nan) is nan
assert DiracDelta(0).func is DiracDelta
assert DiracDelta(x).func is DiracDelta
# FIXME: this is generally undefined @ x=0
# But then limit(Delta(c)*Heaviside(x),x,-oo)
# need's to be implemented.
# assert 0*DiracDelta(x) == 0
assert adjoint(DiracDelta(x)) == DiracDelta(x)
assert adjoint(DiracDelta(x - y)) == DiracDelta(x - y)
assert conjugate(DiracDelta(x)) == DiracDelta(x)
assert conjugate(DiracDelta(x - y)) == DiracDelta(x - y)
assert transpose(DiracDelta(x)) == DiracDelta(x)
assert transpose(DiracDelta(x - y)) == DiracDelta(x - y)
assert DiracDelta(x).diff(x) == DiracDelta(x, 1)
assert DiracDelta(x, 1).diff(x) == DiracDelta(x, 2)
assert DiracDelta(x).is_simple(x) is True
assert DiracDelta(3*x).is_simple(x) is True
assert DiracDelta(x**2).is_simple(x) is False
assert DiracDelta(sqrt(x)).is_simple(x) is False
assert DiracDelta(x).is_simple(y) is False
assert DiracDelta(x*y).expand(diracdelta=True, wrt=x) == DiracDelta(x)/abs(y)
assert DiracDelta(x*y).expand(diracdelta=True, wrt=y) == DiracDelta(y)/abs(x)
assert DiracDelta(x**2*y).expand(diracdelta=True, wrt=x) == DiracDelta(x**2*y)
assert DiracDelta(y).expand(diracdelta=True, wrt=x) == DiracDelta(y)
assert DiracDelta((x - 1)*(x - 2)*(x - 3)).expand(diracdelta=True, wrt=x) == (
DiracDelta(x - 3)/2 + DiracDelta(x - 2) + DiracDelta(x - 1)/2)
assert DiracDelta(2*x) != DiracDelta(x) # scaling property
assert DiracDelta(x) == DiracDelta(-x) # even function
assert DiracDelta(-x, 2) == DiracDelta(x, 2)
assert DiracDelta(-x, 1) == -DiracDelta(x, 1) # odd deriv is odd
assert DiracDelta(-oo*x) == DiracDelta(oo*x)
assert DiracDelta(x - y) != DiracDelta(y - x)
assert signsimp(DiracDelta(x - y) - DiracDelta(y - x)) == 0
with warns_deprecated_sympy():
assert DiracDelta(x*y).simplify(x) == DiracDelta(x)/abs(y)
with warns_deprecated_sympy():
assert DiracDelta(x*y).simplify(y) == DiracDelta(y)/abs(x)
with warns_deprecated_sympy():
assert DiracDelta(x**2*y).simplify(x) == DiracDelta(x**2*y)
with warns_deprecated_sympy():
assert DiracDelta(y).simplify(x) == DiracDelta(y)
with warns_deprecated_sympy():
assert DiracDelta((x - 1)*(x - 2)*(x - 3)).simplify(x) == (
DiracDelta(x - 3)/2 + DiracDelta(x - 2) + DiracDelta(x - 1)/2)
raises(ArgumentIndexError, lambda: DiracDelta(x).fdiff(2))
raises(ValueError, lambda: DiracDelta(x, -1))
raises(ValueError, lambda: DiracDelta(I))
raises(ValueError, lambda: DiracDelta(2 + 3*I))
def test_integrate_DiracDelta_fails():
# issue 6427
assert integrate(
integrate(integrate(DiracDelta(x - y - z), (z, 0, oo)), (y, 0, 1)),
(x, 0, 1)) == S.Half
def test_x():
assert X.hilbert_space == L2(Interval(S.NegativeInfinity, S.Infinity))
assert Commutator(X, Px).doit() == I * hbar
assert qapply(X * XKet(x)) == x * XKet(x)
assert XKet(x).dual_class() == XBra
assert XBra(x).dual_class() == XKet
assert (Dagger(XKet(y)) * XKet(x)).doit() == DiracDelta(x - y)
assert (PxBra(px)*XKet(x)).doit() == \
exp(-I*x*px/hbar)/sqrt(2*pi*hbar)
assert represent(XKet(x)) == DiracDelta(x - x_1)
assert represent(XBra(x)) == DiracDelta(-x + x_1)
assert XBra(x).position == x
assert represent(XOp() * XKet()) == x * DiracDelta(x - x_2)
assert represent(XOp()*XKet()*XBra('y')) == \
x*DiracDelta(x - x_3)*DiracDelta(x_1 - y)
assert represent(XBra("y") * XKet()) == DiracDelta(x - y)
assert represent(XKet() *
XBra()) == DiracDelta(x - x_2) * DiracDelta(x_1 - x)
rep_p = represent(XOp(), basis=PxOp)
assert rep_p == hbar * I * DiracDelta(px_1 -
px_2) * DifferentialOperator(px_1)
assert rep_p == represent(XOp(), basis=PxOp())
assert rep_p == represent(XOp(), basis=PxKet)
assert rep_p == represent(XOp(), basis=PxKet())
assert represent(XOp()*PxKet(), basis=PxKet) == \
hbar*I*DiracDelta(px - px_2)*DifferentialOperator(px)
def _eval_innerproduct_PxBra(self, bra, **hints):
return DiracDelta(self.momentum - bra.momentum)
def test_deltaintegrate():
assert deltaintegrate(x, x) is None
assert deltaintegrate(x + DiracDelta(x), x) is None
assert deltaintegrate(DiracDelta(x, 0), x) == Heaviside(x)
for n in range(10):
assert deltaintegrate(DiracDelta(x, n + 1), x) == DiracDelta(x, n)
assert deltaintegrate(DiracDelta(x), x) == Heaviside(x)
assert deltaintegrate(DiracDelta(-x), x) == Heaviside(x)
assert deltaintegrate(DiracDelta(x - y), x) == Heaviside(x - y)
assert deltaintegrate(DiracDelta(y - x), x) == Heaviside(x - y)
assert deltaintegrate(x * DiracDelta(x), x) == 0
assert deltaintegrate((x - y) * DiracDelta(x - y), x) == 0
assert deltaintegrate(DiracDelta(x)**2, x) == DiracDelta(0) * Heaviside(x)
assert deltaintegrate(y*DiracDelta(x)**2, x) == \
y*DiracDelta(0)*Heaviside(x)
assert deltaintegrate(DiracDelta(x, 1), x) == DiracDelta(x, 0)
assert deltaintegrate(y * DiracDelta(x, 1), x) == y * DiracDelta(x, 0)
assert deltaintegrate(DiracDelta(x, 1)**2,
x) == -DiracDelta(0, 2) * Heaviside(x)
assert deltaintegrate(y * DiracDelta(x, 1)**2,
x) == -y * DiracDelta(0, 2) * Heaviside(x)
assert deltaintegrate(DiracDelta(x) * f(x), x) == f(0) * Heaviside(x)
assert deltaintegrate(DiracDelta(-x) * f(x), x) == f(0) * Heaviside(x)
assert deltaintegrate(DiracDelta(x - 1) * f(x),
x) == f(1) * Heaviside(x - 1)
assert deltaintegrate(DiracDelta(1 - x) * f(x),
x) == f(1) * Heaviside(x - 1)
assert deltaintegrate(DiracDelta(x**2 + x - 2), x) == \
Heaviside(x - 1)/3 + Heaviside(x + 2)/3
p = cos(x) * (DiracDelta(x) + DiracDelta(x**2 - 1)) * sin(x) * (x - pi)
assert deltaintegrate(p, x) - (-pi*(cos(1)*Heaviside(-1 + x)*sin(1)/2 - \
cos(1)*Heaviside(1 + x)*sin(1)/2) + \
cos(1)*Heaviside(1 + x)*sin(1)/2 + \
cos(1)*Heaviside(-1 + x)*sin(1)/2) == 0
p = x_2 * DiracDelta(x - x_2) * DiracDelta(x_2 - x_1)
assert deltaintegrate(p,
x_2) == x * DiracDelta(x - x_1) * Heaviside(x_2 - x)
p = x * y**2 * z * DiracDelta(y - x) * DiracDelta(y - z) * DiracDelta(x -
z)
assert deltaintegrate(
p, y) == x**3 * z * DiracDelta(x - z)**2 * Heaviside(y - x)
assert deltaintegrate((x + 1) * DiracDelta(2 * x),
x) == S.Half * Heaviside(x)
assert deltaintegrate((x + 1)*DiracDelta(x*Rational(2, 3) + Rational(4, 9)), x) == \
S.Half * Heaviside(x + Rational(2, 3))
a, b, c = symbols('a b c', commutative=False)
assert deltaintegrate(DiracDelta(x - y)*f(x - b)*f(x - a), x) == \
f(y - b)*f(y - a)*Heaviside(x - y)
p = f(x - a) * DiracDelta(x - y) * f(x - c) * f(x - b)
assert deltaintegrate(
p, x) == f(y - a) * f(y - c) * f(y - b) * Heaviside(x - y)
p = DiracDelta(x - z) * f(x - b) * f(x - a) * DiracDelta(x - y)
assert deltaintegrate(p, x) == DiracDelta(y - z)*f(y - b)*f(y - a) * \
Heaviside(x - y)
def test_sympy__functions__special__delta_functions__DiracDelta():
from sympy.functions.special.delta_functions import DiracDelta
assert _test_args(DiracDelta(x, 1))
def _eval_innerproduct_PositionBra3D(self, bra, **options):
x_diff = self.position_x - bra.position_x
y_diff = self.position_y - bra.position_y
z_diff = self.position_z - bra.position_z
return DiracDelta(x_diff)*DiracDelta(y_diff)*DiracDelta(z_diff)
def test_change_mul():
assert change_mul(x, x) == (None, None)
assert change_mul(x * y, x) == (None, None)
assert change_mul(x * y * DiracDelta(x), x) == (DiracDelta(x), x * y)
assert change_mul(x*y*DiracDelta(x)*DiracDelta(y), x) == \
(DiracDelta(x), x*y*DiracDelta(y))
assert change_mul(DiracDelta(x)**2, x) == \
(DiracDelta(x), DiracDelta(x))
assert change_mul(y*DiracDelta(x)**2, x) == \
(DiracDelta(x), y*DiracDelta(x))
def _eval_innerproduct_XBra(self, bra, **hints):
return DiracDelta(self.position - bra.position)
def test_sign():
assert sign(1.2) == 1
assert sign(-1.2) == -1
assert sign(3 * I) == I
assert sign(-3 * I) == -I
assert sign(0) == 0
assert sign(0, evaluate=False).doit() == 0
assert sign(oo, evaluate=False).doit() == 1
assert sign(nan) is nan
assert sign(2 + 2 * I).doit() == sqrt(2) * (2 + 2 * I) / 4
assert sign(2 + 3 * I).simplify() == sign(2 + 3 * I)
assert sign(2 + 2 * I).simplify() == sign(1 + I)
assert sign(im(sqrt(1 - sqrt(3)))) == 1
assert sign(sqrt(1 - sqrt(3))) == I
x = Symbol('x')
assert sign(x).is_finite is True
assert sign(x).is_complex is True
assert sign(x).is_imaginary is None
assert sign(x).is_integer is None
assert sign(x).is_real is None
assert sign(x).is_zero is None
assert sign(x).doit() == sign(x)
assert sign(1.2 * x) == sign(x)
assert sign(2 * x) == sign(x)
assert sign(I * x) == I * sign(x)
assert sign(-2 * I * x) == -I * sign(x)
assert sign(conjugate(x)) == conjugate(sign(x))
p = Symbol('p', positive=True)
n = Symbol('n', negative=True)
m = Symbol('m', negative=True)
assert sign(2 * p * x) == sign(x)
assert sign(n * x) == -sign(x)
assert sign(n * m * x) == sign(x)
x = Symbol('x', imaginary=True)
assert sign(x).is_imaginary is True
assert sign(x).is_integer is False
assert sign(x).is_real is False
assert sign(x).is_zero is False
assert sign(x).diff(x) == 2 * DiracDelta(-I * x)
assert sign(x).doit() == x / Abs(x)
assert conjugate(sign(x)) == -sign(x)
x = Symbol('x', real=True)
assert sign(x).is_imaginary is False
assert sign(x).is_integer is True
assert sign(x).is_real is True
assert sign(x).is_zero is None
assert sign(x).diff(x) == 2 * DiracDelta(x)
assert sign(x).doit() == sign(x)
assert conjugate(sign(x)) == sign(x)
x = Symbol('x', nonzero=True)
assert sign(x).is_imaginary is False
assert sign(x).is_integer is True
assert sign(x).is_real is True
assert sign(x).is_zero is False
assert sign(x).doit() == x / Abs(x)
assert sign(Abs(x)) == 1
assert Abs(sign(x)) == 1
x = Symbol('x', positive=True)
assert sign(x).is_imaginary is False
assert sign(x).is_integer is True
assert sign(x).is_real is True
assert sign(x).is_zero is False
assert sign(x).doit() == x / Abs(x)
assert sign(Abs(x)) == 1
assert Abs(sign(x)) == 1
x = 0
assert sign(x).is_imaginary is False
assert sign(x).is_integer is True
assert sign(x).is_real is True
assert sign(x).is_zero is True
assert sign(x).doit() == 0
assert sign(Abs(x)) == 0
assert Abs(sign(x)) == 0
nz = Symbol('nz', nonzero=True, integer=True)
assert sign(nz).is_imaginary is False
assert sign(nz).is_integer is True
assert sign(nz).is_real is True
assert sign(nz).is_zero is False
assert sign(nz)**2 == 1
assert (sign(nz)**3).args == (sign(nz), 3)
assert sign(Symbol('x', nonnegative=True)).is_nonnegative
assert sign(Symbol('x', nonnegative=True)).is_nonpositive is None
assert sign(Symbol('x', nonpositive=True)).is_nonnegative is None
assert sign(Symbol('x', nonpositive=True)).is_nonpositive
assert sign(Symbol('x', real=True)).is_nonnegative is None
assert sign(Symbol('x', real=True)).is_nonpositive is None
assert sign(Symbol('x', real=True, zero=False)).is_nonpositive is None
x, y = Symbol('x', real=True), Symbol('y')
f = Function('f')
assert sign(x).rewrite(Piecewise) == \
Piecewise((1, x > 0), (-1, x < 0), (0, True))
assert sign(y).rewrite(Piecewise) == sign(y)
assert sign(x).rewrite(Heaviside) == 2 * Heaviside(x, H0=S(1) / 2) - 1
assert sign(y).rewrite(Heaviside) == sign(y)
assert sign(y).rewrite(Abs) == Piecewise((0, Eq(y, 0)), (y / Abs(y), True))
assert sign(f(y)).rewrite(Abs) == Piecewise((0, Eq(f(y), 0)),
(f(y) / Abs(f(y)), True))
# evaluate what can be evaluated
assert sign(exp_polar(I * pi) * pi) is S.NegativeOne
eq = -sqrt(10 + 6 * sqrt(3)) + sqrt(1 + sqrt(3)) + sqrt(3 + 3 * sqrt(3))
# if there is a fast way to know when and when you cannot prove an
# expression like this is zero then the equality to zero is ok
assert sign(eq).func is sign or sign(eq) == 0
# but sometimes it's hard to do this so it's better not to load
# abs down with tests that will be very slow
q = 1 + sqrt(2) - 2 * sqrt(3) + 1331 * sqrt(6)
p = expand(q**3)**Rational(1, 3)
d = p - q
assert sign(d).func is sign or sign(d) == 0
