This figure is meant to represent the neuronal event-related model
and a coefficient of +1 for Faces, -2 for Objects.
"""
import pylab
import numpy as np
from sympy import Symbol, Heaviside, lambdify
ta = [0, 4, 8, 12, 16]
tb = [2, 6, 10, 14, 18]
ba = Symbol('ba')
bb = Symbol('bb')
t = Symbol('t')
fa = sum([Heaviside(t - _t) for _t in ta]) * ba
fb = sum([Heaviside(t - _t) for _t in tb]) * bb
N = fa + fb
Nn = N.subs(ba, 1)
Nn = Nn.subs(bb, -2)
Nn = lambdify(t, Nn)
tt = np.linspace(-1, 21, 1201)
pylab.step(tt, [Nn(_t) for _t in tt])
a = pylab.gca()
a.set_ylim([-5.5, 1.5])
a.set_ylabel('Neuronal (cumulative)')
a.set_xlabel('Time')
def test_inverse_laplace_transform():
from sympy import (expand, sinh, cosh, besselj, besseli, exp_polar,
unpolarify, simplify)
ILT = inverse_laplace_transform
a, b, c, = symbols('a b c', positive=True)
t = symbols('t')
def simp_hyp(expr):
return expand(expand(expr).rewrite(sin))
# just test inverses of all of the above
assert ILT(1 / s, s, t) == Heaviside(t)
assert ILT(1 / s**2, s, t) == t * Heaviside(t)
assert ILT(1 / s**5, s, t) == t**4 * Heaviside(t) / 24
assert ILT(exp(-a * s) / s, s, t) == Heaviside(t - a)
assert ILT(exp(-a * s) / (s + b), s,
t) == exp(b * (a - t)) * Heaviside(-a + t)
assert ILT(a / (s**2 + a**2), s, t) == sin(a * t) * Heaviside(t)
assert ILT(s / (s**2 + a**2), s, t) == cos(a * t) * Heaviside(t)
# TODO is there a way around simp_hyp?
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)
assert ILT(a / ((s + b)**2 + a**2), s,
t) == exp(-b * t) * sin(a * t) * Heaviside(t)
assert ILT((s + b) / ((s + b)**2 + a**2), s,
t) == exp(-b * t) * cos(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))
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(nan) == 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')
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) - 1
assert sign(y).rewrite(Heaviside) == sign(y)
# 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
def _eval_rewrite_as_Heaviside(self, arg):
from sympy import Heaviside
if arg.is_real:
return Heaviside(arg) * 2 - 1
def _eval_rewrite_as_Heaviside(self, *args):
from sympy import Heaviside
return Add(*[j*Mul(*[Heaviside(i-j) for i in args if i!=j]) \
for j in args])
def test_laplace_transform():
from sympy import fresnels, fresnelc
LT = laplace_transform
a, b, c, = symbols('a b c', positive=True)
t = symbols('t')
w = Symbol("w")
f = Function("f")
# Test unevaluated form
assert laplace_transform(f(t), t, w) == LaplaceTransform(f(t), t, w)
assert inverse_laplace_transform(
f(w), w, t, plane=0) == InverseLaplaceTransform(f(w), w, t, 0)
# test a bug
spos = symbols('s', positive=True)
assert LT(exp(t), t, spos)[:2] == (1/(spos - 1), 1)
# 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(t**a, t, s) == (s**(-a - 1)*gamma(a + 1), 0, True)
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(1 - exp(-a*t), t, s) == (a/(s*(a + s)), 0, True)
assert LT((exp(2*t) - 1)*exp(-b - t)*Heaviside(t)/2, t, s, noconds=True) \
== exp(-b)/(s**2 - 1)
assert LT(exp(t), t, s)[:2] == (1/(s - 1), 1)
assert LT(exp(2*t), t, s)[:2] == (1/(s - 2), 2)
assert LT(exp(a*t), t, s)[:2] == (1/(s - a), a)
assert LT(log(t/a), t, s) == ((log(a*s) + EulerGamma)/s/-1, 0, True)
assert LT(erf(t), t, s) == (erfc(s/2)*exp(s**2/4)/s, 0, True)
assert LT(sin(a*t), t, s) == (a/(a**2 + s**2), 0, True)
assert LT(cos(a*t), t, s) == (s/(a**2 + s**2), 0, True)
# TODO would be nice to have these come out better
assert LT(exp(-a*t)*sin(b*t), t, s) == (b/(b**2 + (a + s)**2), -a, True)
assert LT(exp(-a*t)*cos(b*t), t, s) == \
((a + s)/(b**2 + (a + s)**2), -a, True)
assert LT(besselj(0, t), t, s) == (1/sqrt(1 + s**2), 0, True)
assert LT(besselj(1, t), t, s) == (1 - 1/sqrt(1 + 1/s**2), 0, True)
# TODO general order works, but is a *mess*
# TODO besseli also works, but is an even greater mess
# test a bug in conditions processing
# TODO the auxiliary condition should be recognised/simplified
assert LT(exp(t)*cos(t), t, s)[:-1] in [
((s - 1)/(s**2 - 2*s + 2), -oo),
((s - 1)/((s - 1)**2 + 1), -oo),
]
# 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))
# What is this testing:
Ne(1/s, 1) & (0 < cos(Abs(periodic_argument(s, oo)))*Abs(s) - 1)
assert LT(Matrix([[exp(t), t*exp(-t)], [t*exp(-t), exp(t)]]), t, s) ==\
Matrix([
[(1/(s - 1), 1, s > 1), ((s + 1)**(-2), 0, True)],
[((s + 1)**(-2), 0, True), (1/(s - 1), 1, s > 1)]
])
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(1) / 2 * Heaviside(x)
assert deltaintegrate((x + 1)*DiracDelta(2*x/3 + 4/S(9)), x) == \
S(1)/2 * Heaviside(x + S(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_fourier_transform():
from sympy import simplify, expand, expand_complex, factor, expand_trig
FT = fourier_transform
IFT = inverse_fourier_transform
def simp(x):
return simplify(expand_trig(expand_complex(expand(x))))
def sinc(x):
return sin(pi * x) / (pi * x)
k = symbols("k", real=True)
f = Function("f")
# TODO for this to work with real a, need to expand abs(a*x) to abs(a)*abs(x)
a = symbols("a", positive=True)
b = symbols("b", positive=True)
posk = symbols("posk", positive=True)
# Test unevaluated form
assert fourier_transform(f(x), x, k) == FourierTransform(f(x), x, k)
assert inverse_fourier_transform(f(k), k, x) == InverseFourierTransform(f(k), k, x)
# basic examples from wikipedia
assert simp(FT(Heaviside(1 - abs(2 * a * x)), x, k)) == sinc(k / a) / a
# TODO IFT is a *mess*
assert (
simp(FT(Heaviside(1 - abs(a * x)) * (1 - abs(a * x)), x, k))
== sinc(k / a) ** 2 / a
)
# TODO IFT
assert factor(FT(exp(-a * x) * Heaviside(x), x, k), extension=I) == 1 / (
a + 2 * pi * I * k
)
# NOTE: the ift comes out in pieces
assert IFT(1 / (a + 2 * pi * I * x), x, posk, noconds=False) == (
exp(-a * posk),
True,
)
assert IFT(1 / (a + 2 * pi * I * x), x, -posk, noconds=False) == (0, True)
assert IFT(
1 / (a + 2 * pi * I * x), x, symbols("k", negative=True), noconds=False
) == (0, True)
# TODO IFT without factoring comes out as meijer g
assert (
factor(FT(x * exp(-a * x) * Heaviside(x), x, k), extension=I)
== 1 / (a + 2 * pi * I * k) ** 2
)
assert FT(exp(-a * x) * sin(b * x) * Heaviside(x), x, k) == b / (
b ** 2 + (a + 2 * I * pi * k) ** 2
)
assert FT(exp(-a * x ** 2), x, k) == sqrt(pi) * exp(-(pi ** 2) * k ** 2 / a) / sqrt(
a
)
assert IFT(sqrt(pi / a) * exp(-((pi * k) ** 2) / a), k, x) == exp(-a * x ** 2)
assert FT(exp(-a * abs(x)), x, k) == 2 * a / (a ** 2 + 4 * pi ** 2 * k ** 2)
def Klykin_6var():
signal = Signal
signal.A = 2
signal.tau = 3
signal.T = 6
signal.expr = signal.A * (cos(t * numpy.pi/signal.tau) - cos(t * numpy.pi/signal.tau) * Heaviside(t - signal.tau))
return signal
def test_expint():
from sympy import E1, expint, Max, re, lerchphi, Symbol, simplify, Si, Ci, Ei
aneg = Symbol("a", negative=True)
u = Symbol("u", polar=True)
assert mellin_transform(E1(x), x, s) == (gamma(s) / s, (0, oo), True)
assert inverse_mellin_transform(gamma(s) / s, s, x, (0, oo)).rewrite(
expint
).expand() == E1(x)
assert mellin_transform(expint(a, x), x, s) == (
gamma(s) / (a + s - 1),
(Max(1 - re(a), 0), oo),
True,
)
# XXX IMT has hickups with complicated strips ...
assert simplify(
unpolarify(
inverse_mellin_transform(gamma(s) / (aneg + s - 1), s, x, (1 - aneg, oo))
.rewrite(expint)
.expand(func=True)
)
) == expint(aneg, x)
assert mellin_transform(Si(x), x, s) == (
-(2 ** s) * sqrt(pi) * gamma(s / 2 + S.Half) / (2 * s * gamma(-s / 2 + 1)),
(-1, 0),
True,
)
assert inverse_mellin_transform(
-(2 ** s) * sqrt(pi) * gamma((s + 1) / 2) / (2 * s * gamma(-s / 2 + 1)),
s,
x,
(-1, 0),
) == Si(x)
assert mellin_transform(Ci(sqrt(x)), x, s) == (
-(2 ** (2 * s - 1)) * sqrt(pi) * gamma(s) / (s * gamma(-s + S.Half)),
(0, 1),
True,
)
assert inverse_mellin_transform(
-(4 ** s) * sqrt(pi) * gamma(s) / (2 * s * gamma(-s + S.Half)), s, u, (0, 1)
).expand() == Ci(sqrt(u))
# TODO LT of Si, Shi, Chi is a mess ...
assert laplace_transform(Ci(x), x, s) == (-log(1 + s ** 2) / 2 / s, 0, True)
assert laplace_transform(expint(a, x), x, s) == (
lerchphi(s * exp_polar(I * pi), 1, a),
0,
re(a) > S.Zero,
)
assert laplace_transform(expint(1, x), x, s) == (log(s + 1) / s, 0, True)
assert laplace_transform(expint(2, x), x, s) == ((s - log(s + 1)) / s ** 2, 0, True)
assert inverse_laplace_transform(
-log(1 + s ** 2) / 2 / s, s, u
).expand() == Heaviside(u) * Ci(u)
assert inverse_laplace_transform(log(s + 1) / s, s, x).rewrite(expint) == Heaviside(
x
) * E1(x)
assert (
inverse_laplace_transform((s - log(s + 1)) / s ** 2, s, x)
.rewrite(expint)
.expand()
== (expint(2, x) * Heaviside(x)).rewrite(Ei).rewrite(expint).expand()
)
def test_inverse_laplace_transform():
from sympy import sinh, cosh, besselj, besseli, simplify, factor_terms
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)
# just test inverses of all of the above
assert ILT(1 / s, s, t) == Heaviside(t)
assert ILT(1 / s ** 2, s, t) == t * Heaviside(t)
assert ILT(1 / s ** 5, s, t) == t ** 4 * Heaviside(t) / 24
assert ILT(exp(-a * s) / s, s, t) == Heaviside(t - a)
assert ILT(exp(-a * s) / (s + b), s, t) == exp(b * (a - t)) * Heaviside(-a + t)
assert ILT(a / (s ** 2 + a ** 2), s, t) == sin(a * t) * Heaviside(t)
assert ILT(s / (s ** 2 + a ** 2), s, t) == cos(a * t) * Heaviside(t)
# TODO is there a way around simp_hyp?
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)
assert ILT(a / ((s + b) ** 2 + a ** 2), s, t) == exp(-b * t) * sin(
a * t
) * Heaviside(t)
assert ILT((s + b) / ((s + b) ** 2 + a ** 2), s, t) == exp(-b * t) * cos(
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 test_heaviside():
assert Heaviside(0).func == Heaviside
assert Heaviside(-5) == 0
assert Heaviside(1) == 1
assert Heaviside(nan) == nan
assert Heaviside(0, x) == x
assert Heaviside(0, nan) == nan
assert Heaviside(x, None) == Heaviside(x)
assert Heaviside(0, None) == Heaviside(0)
# we do not want None in the args:
assert None not in Heaviside(x, None).args
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 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).rewrite(sign) == (sign(x) + 1) / 2
assert Heaviside(y).rewrite(sign) == Heaviside(y)
assert Heaviside(x, S.Half).rewrite(sign) == (sign(x) + 1) / 2
assert Heaviside(x, y).rewrite(sign) == Heaviside(x, y)
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) == SingularityFunction(
0, 0, 0)
def u(n): return(Heaviside(n,1))
def ramp(t):
ram = symbols('ram')
ram = t * Heaviside(t)
plot(ram)
return ram
def test_laplace_transform():
from sympy import fresnels, fresnelc, DiracDelta
LT = laplace_transform
a, b, c, = symbols('a b c', positive=True)
t = symbols('t')
w = Symbol("w")
f = Function("f")
# Test unevaluated form
assert laplace_transform(f(t), t, w) == LaplaceTransform(f(t), t, w)
assert inverse_laplace_transform(f(w), w, t,
plane=0) == InverseLaplaceTransform(
f(w), w, t, 0)
# test a bug
spos = symbols('s', positive=True)
assert LT(exp(t), t, spos)[:2] == (1 / (spos - 1), 1)
# 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(t**a, t, s) == (s**(-a - 1) * gamma(a + 1), 0, True)
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(1 - exp(-a * t), t, s) == (a / (s * (a + s)), 0, True)
assert LT((exp(2*t) - 1)*exp(-b - t)*Heaviside(t)/2, t, s, noconds=True) \
== exp(-b)/(s**2 - 1)
assert LT(exp(t), t, s)[:2] == (1 / (s - 1), 1)
assert LT(exp(2 * t), t, s)[:2] == (1 / (s - 2), 2)
assert LT(exp(a * t), t, s)[:2] == (1 / (s - a), a)
assert LT(log(t / a), t,
s) == ((log(a * s) + EulerGamma) / s / -1, 0, True)
assert LT(erf(t), t, s) == (erfc(s / 2) * exp(s**2 / 4) / s, 0, True)
assert LT(sin(a * t), t, s) == (a / (a**2 + s**2), 0, True)
assert LT(cos(a * t), t, s) == (s / (a**2 + s**2), 0, True)
# TODO would be nice to have these come out better
assert LT(exp(-a * t) * sin(b * t), t,
s) == (b / (b**2 + (a + s)**2), -a, True)
assert LT(exp(-a*t)*cos(b*t), t, s) == \
((a + s)/(b**2 + (a + s)**2), -a, True)
assert LT(besselj(0, t), t, s) == (1 / sqrt(1 + s**2), 0, True)
assert LT(besselj(1, t), t, s) == (1 - 1 / sqrt(1 + 1 / s**2), 0, True)
# TODO general order works, but is a *mess*
# TODO besseli also works, but is an even greater mess
# test a bug in conditions processing
# TODO the auxiliary condition should be recognised/simplified
assert LT(exp(t) * cos(t), t, s)[:-1] in [
((s - 1) / (s**2 - 2 * s + 2), -oo),
((s - 1) / ((s - 1)**2 + 1), -oo),
]
# DiracDelta function: standard cases
assert LT(DiracDelta(t), t, s) == (1, -oo, True)
assert LT(DiracDelta(a * t), t, s) == (1 / a, -oo, True)
assert LT(DiracDelta(t / 42), t, s) == (42, -oo, True)
assert LT(DiracDelta(t + 42), t, s) == (0, -oo, True)
assert LT(DiracDelta(t)+DiracDelta(t-42), t, s) == \
(1 + exp(-42*s), -oo, True)
assert LT(DiracDelta(t) - a * exp(-a * t), t,
s) == (-a / (a + s) + 1, 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, -oo, 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))
# What is this testing:
Ne(1 / s, 1) & (0 < cos(Abs(periodic_argument(s, oo))) * Abs(s) - 1)
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, s > 1), ((s + 1)**(-2), 0, True)],
[((s + 1)**(-2), 0, True),
(1 / (s - 1), 1, s > 1)]])
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, s > 1)
# 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 approx(functionclass='intro'):
"""
Exemplify approximating various functions by various choices
of finite element functions
"""
import os
if functionclass == 'intro':
# Note: no plot if symbol=True
approximate(x * (1 - x),
symbolic=False,
d=1,
N_e=2,
filename='fe_p1_x2_2e')
#approximate(x*(1-x), symbolic=True, numint='Trapezoidal',
# d=1, N_e=2, filename='fe_p1_x2_2eT')
approximate(x * (1 - x),
symbolic=False,
d=1,
N_e=4,
filename='fe_p1_x2_4e')
approximate(x * (1 - x),
symbolic=False,
d=2,
N_e=1,
filename='fe_p2_x2_1e')
#approximate(x*(1-x), symbolic=True, numint='Simpson',
# d=2, N_e=4, filename='fe_p1_x2_2eS')
approximate(x * (1 - x),
symbolic=False,
d=1,
N_e=4,
filename='fe_p1_x2_4e')
# Only the extended fe_approx1D_numint can do P0 elements
import fe_approx1D_numint
fe_approx1D_numint.approximate(x * (1 - x),
symbolic=False,
d=0,
N_e=4,
filename='fe_p0_x2_4e')
fe_approx1D_numint.approximate(x * (1 - x),
symbolic=False,
d=0,
N_e=8,
filename='fe_p0_x2_8e')
for ext in 'pdf', 'png':
cmd = 'doconce combine_images fe_p1_x2_2e.%(ext)s fe_p1_x2_4e.%(ext)s fe_p1_x2_2e_4e.%(ext)s' % vars(
)
os.system(cmd)
cmd = 'doconce combine_images fe_p0_x2_4e.%(ext)s fe_p0_x2_8e.%(ext)s fe_p1_x2_4e_8e.%(ext)s' % vars(
)
os.system(cmd)
elif functionclass == 'special':
# Does not work well because Heaviside cannot be analytically
# integrated (not important) and numpy cannot evaluate
# Heaviside (serious for plotting)
from sympy import Heaviside, Rational
approximate(Heaviside(x - Rational(1, 2)),
symbolic=False,
d=1,
N_e=2,
filename='fe_p1_H_2e')
approximate(Heaviside(x - Rational(1, 2)),
symbolic=False,
d=1,
N_e=4,
filename='fe_p1_H_4e')
approximate(Heaviside(x - Rational(1, 2)),
symbolic=False,
d=1,
N_e=8,
filename='fe_p1_H_8e')
elif functionclass == 'easy':
approximate(1 - x, symbolic=False, d=1, N_e=4, filename='fe_p1_x_4e')
approximate(x * (1 - x),
symbolic=False,
d=2,
N_e=4,
filename='fe_p2_x2_4e')
approximate(x * (1 - x)**8,
symbolic=False,
d=1,
N_e=4,
filename='fe_p1_x9_4e')
approximate(x * (1 - x)**8,
symbolic=False,
d=1,
N_e=8,
filename='fe_p1_x9_8e')
approximate(x * (1 - x)**8,
symbolic=False,
d=2,
N_e=2,
filename='fe_p2_x9_2e')
approximate(x * (1 - x)**8,
symbolic=False,
d=2,
N_e=4,
filename='fe_p2_x9_4e')
for ext in 'pdf', 'png':
cmd = 'doconce combine_images fe_p1_x9_4e.%(ext)s fe_p1_x9_8e.%(ext)s fe_p1_x9_4e_8e.%(ext)s'
os.system(cmd)
cmd = 'doconce combine_images fe_p2_x9_2e.%(ext)s fe_p2_x9_4e.%(ext)s fe_p2_x9_2e_4e.%(ext)s'
os.system(cmd)
cmd = 'doconce combine_images fe_p1_x9_4e.%(ext)s fe_p2_x9_2e.%(ext)s fe_p1_x9_8e.%(ext)s fe_p2_x9_4e.%(ext)s fe_p1_p2_x9_248e.%(ext)s'
os.system(cmd)
elif functionclass == 'hard':
approximate(sin(pi * x),
symbolic=False,
d=1,
N_e=4,
filename='fe_p1_sin_4e')
approximate(sin(pi * x),
symbolic=False,
d=1,
N_e=8,
filename='fe_p1_sin_8e')
approximate(sin(pi * x),
symbolic=False,
d=2,
N_e=2,
filename='fe_p2_sin_2e')
approximate(sin(pi * x),
symbolic=False,
d=2,
N_e=4,
filename='fe_p2_sin_4e')
approximate(sin(pi * x)**2,
symbolic=False,
d=1,
N_e=4,
filename='fe_p1_sin2_4e')
approximate(sin(pi * x)**2,
symbolic=False,
d=1,
N_e=4,
filename='fe_p1_sin2_8e')
approximate(sin(pi * x)**2,
symbolic=False,
d=2,
N_e=2,
filename='fe_p2_sin2_2e')
approximate(sin(pi * x)**2,
symbolic=False,
d=2,
N_e=4,
filename='fe_p2_sin2_4e')
for ext in 'pdf', 'png':
cmd = 'doconce combine_images fe_p1_sin_4e.%(ext)s fe_p1_sin_8e.%(ext)s fe_p1_sin_4e_8e.%(ext)s'
os.system(cmd)
cmd = 'doconce combine_images fe_p2_sin_2e.%(ext)s fe_p2_sin_4e.%(ext)s fe_p2_sin_2e_4e.%(ext)s'
os.system(cmd)
cmd = 'doconce combine_images fe_p1_sin2_4e.%(ext)s fe_p1_sin2_8e.%(ext)s fe_p1_sin2_4e_8e.%(ext)s'
os.system(cmd)
cmd = 'doconce combine_images fe_p2_sin2_2e.%(ext)s fe_p2_sin2_4e.%(ext)s fe_p2_sin2_2e_4e.%(ext)s'
os.system(cmd)
def test_inverse_laplace_transform():
from sympy import simplify, factor_terms, DiracDelta
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 test_mellin_transform():
from sympy import Max, Min
MT = mellin_transform
bpos = symbols('b', positive=True)
# 8.4.2
assert MT(x**nu*Heaviside(x - 1), x, s) == \
(-1/(nu + s), (-oo, -re(nu)), True)
assert MT(x**nu*Heaviside(1 - x), x, s) == \
(1/(nu + s), (-re(nu), oo), True)
assert MT((1 - x)**(beta - 1)*Heaviside(1 - x), x, s) == \
(gamma(beta)*gamma(s)/gamma(beta + s), (0, oo), re(beta) > 0)
assert MT((x - 1)**(beta - 1)*Heaviside(x - 1), x, s) == \
(gamma(beta)*gamma(1 - beta - s)/gamma(1 - s),
(-oo, -re(beta) + 1), re(beta) > 0)
assert MT((1 + x)**(-rho), x, s) == \
(gamma(s)*gamma(rho - s)/gamma(rho), (0, re(rho)), True)
# TODO also the conditions should be simplified, e.g.
# And(re(rho) - 1 < 0, re(rho) < 1) should just be
# re(rho) < 1
assert MT(abs(1 - x)**(-rho), x, s) == (
2*sin(pi*rho/2)*gamma(1 - rho)*
cos(pi*(rho/2 - s))*gamma(s)*gamma(rho-s)/pi,
(0, re(rho)), And(re(rho) - 1 < 0, re(rho) < 1))
mt = MT((1 - x)**(beta - 1)*Heaviside(1 - x)
+ a*(x - 1)**(beta - 1)*Heaviside(x - 1), x, s)
assert mt[1], mt[2] == ((0, -re(beta) + 1), re(beta) > 0)
assert MT((x**a - b**a)/(x - b), x, s)[0] == \
pi*b**(a + s - 1)*sin(pi*a)/(sin(pi*s)*sin(pi*(a + s)))
assert MT((x**a - bpos**a)/(x - bpos), x, s) == \
(pi*bpos**(a + s - 1)*sin(pi*a)/(sin(pi*s)*sin(pi*(a + s))),
(Max(-re(a), 0), Min(1 - re(a), 1)), True)
expr = (sqrt(x + b**2) + b)**a
assert MT(expr.subs(b, bpos), x, s) == \
(-a*(2*bpos)**(a + 2*s)*gamma(s)*gamma(-a - 2*s)/gamma(-a - s + 1),
(0, -re(a)/2), True)
expr = (sqrt(x + b**2) + b)**a/sqrt(x + b**2)
assert MT(expr.subs(b, bpos), x, s) == \
(2**(a + 2*s)*bpos**(a + 2*s - 1)*gamma(s)
*gamma(1 - a - 2*s)/gamma(1 - a - s),
(0, -re(a)/2 + S.Half), True)
# 8.4.2
assert MT(exp(-x), x, s) == (gamma(s), (0, oo), True)
assert MT(exp(-1/x), x, s) == (gamma(-s), (-oo, 0), True)
# 8.4.5
assert MT(log(x)**4*Heaviside(1 - x), x, s) == (24/s**5, (0, oo), True)
assert MT(log(x)**3*Heaviside(x - 1), x, s) == (6/s**4, (-oo, 0), True)
assert MT(log(x + 1), x, s) == (pi/(s*sin(pi*s)), (-1, 0), True)
assert MT(log(1/x + 1), x, s) == (pi/(s*sin(pi*s)), (0, 1), True)
assert MT(log(abs(1 - x)), x, s) == (pi/(s*tan(pi*s)), (-1, 0), True)
assert MT(log(abs(1 - 1/x)), x, s) == (pi/(s*tan(pi*s)), (0, 1), True)
# 8.4.14
assert MT(erf(sqrt(x)), x, s) == \
(-gamma(s + S.Half)/(sqrt(pi)*s), (Rational(-1, 2), 0), True)
def test_manualintegrate_Heaviside():
assert manualintegrate(Heaviside(x), x) == x * Heaviside(x)
assert manualintegrate(Heaviside(2 * x + 1),
x) == (2 * x + 1) * Heaviside(2 * x + 1) / 2
# emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*-
# vi: set ft=python sts=4 ts=4 sw=4 et:
"""
This figure is meant to represent the neuronal event-related model and a
coefficient of +1 for Faces, -2 for Objects.
"""
import numpy as np
import matplotlib.pyplot as plt
from sympy import Symbol, Heaviside, lambdify
ta = [0,4,8,12,16]; tb = [2,6,10,14,18]
ba = Symbol('ba'); bb = Symbol('bb'); t = Symbol('t')
fa = sum([Heaviside(t-_t) for _t in ta]) * ba
fb = sum([Heaviside(t-_t) for _t in tb]) * bb
N = fa+fb
Nn = N.subs(ba,1)
Nn = Nn.subs(bb,-2)
Nn = lambdify(t, Nn)
tt = np.linspace(-1,21,1201)
neuronal = [Nn(_t) for _t in tt]
# Deal with undefined Heaviside at 0
neuronal = [n.subs(Heaviside(0.0), 1) for n in neuronal]
plt.step(tt, neuronal)
def test_heaviside():
assert Heaviside(0) == 0.5
assert Heaviside(-5) == 0
assert Heaviside(1) == 1
assert Heaviside(nan) == nan
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 _eval_rewrite_as_Heaviside(self, arg):
# Note this only holds for real arg (since Heaviside is not defined
# for complex arguments).
from sympy import Heaviside
if arg.is_real:
return arg * (Heaviside(arg) - Heaviside(-arg))
def test_atan2():
assert atan2.nargs == FiniteSet(2)
assert atan2(0, 0) == S.NaN
assert atan2(0, 1) == 0
assert atan2(1, 1) == pi / 4
assert atan2(1, 0) == pi / 2
assert atan2(1, -1) == 3 * pi / 4
assert atan2(0, -1) == pi
assert atan2(-1, -1) == -3 * pi / 4
assert atan2(-1, 0) == -pi / 2
assert atan2(-1, 1) == -pi / 4
i = symbols('i', imaginary=True)
r = symbols('r', real=True)
eq = atan2(r, i)
ans = -I * log((i + I * r) / sqrt(i**2 + r**2))
reps = ((r, 2), (i, I))
assert eq.subs(reps) == ans.subs(reps)
x = Symbol('x', negative=True)
y = Symbol('y', negative=True)
assert atan2(y, x) == atan(y / x) - pi
y = Symbol('y', nonnegative=True)
assert atan2(y, x) == atan(y / x) + pi
y = Symbol('y')
assert atan2(y, x) == atan2(y, x, evaluate=False)
u = Symbol("u", positive=True)
assert atan2(0, u) == 0
u = Symbol("u", negative=True)
assert atan2(0, u) == pi
assert atan2(y, oo) == 0
assert atan2(y, -oo) == 2 * pi * Heaviside(re(y)) - pi
assert atan2(y, x).rewrite(log) == -I * log(
(x + I * y) / sqrt(x**2 + y**2))
assert atan2(y, x).rewrite(atan) == 2 * atan(y / (x + sqrt(x**2 + y**2)))
ex = atan2(y, x) - arg(x + I * y)
assert ex.subs({x: 2, y: 3}).rewrite(arg) == 0
assert ex.subs({
x: 2,
y: 3 * I
}).rewrite(arg) == -pi - I * log(sqrt(5) * I / 5)
assert ex.subs({
x: 2 * I,
y: 3
}).rewrite(arg) == -pi / 2 - I * log(sqrt(5) * I)
assert ex.subs({
x: 2 * I,
y: 3 * I
}).rewrite(arg) == -pi + atan(2 / S(3)) + atan(3 / S(2))
i = symbols('i', imaginary=True)
r = symbols('r', real=True)
e = atan2(i, r)
rewrite = e.rewrite(arg)
reps = {i: I, r: -2}
assert rewrite == -I * log(abs(I * i + r) / sqrt(abs(i**2 + r**2))) + arg(
(I * i + r) / sqrt(i**2 + r**2))
assert (e - rewrite).subs(reps).equals(0)
assert conjugate(atan2(x, y)) == atan2(conjugate(x), conjugate(y))
assert diff(atan2(y, x), x) == -y / (x**2 + y**2)
assert diff(atan2(y, x), y) == x / (x**2 + y**2)
assert simplify(diff(atan2(y, x).rewrite(log), x)) == -y / (x**2 + y**2)
assert simplify(diff(atan2(y, x).rewrite(log), y)) == x / (x**2 + y**2)
def test_laplace_transform():
from sympy import (fresnels, fresnelc, hyper)
LT = laplace_transform
a, b, c, = symbols('a b c', positive=True)
t = symbols('t')
w = Symbol("w")
f = Function("f")
# Test unevaluated form
assert laplace_transform(f(t), t, w) == LaplaceTransform(f(t), t, w)
assert inverse_laplace_transform(f(w), w, t,
plane=0) == InverseLaplaceTransform(
f(w), w, t, 0)
# test a bug
spos = symbols('s', positive=True)
assert LT(exp(t), t, spos)[:2] == (1 / (spos - 1), True)
# 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(t**a, t, s) == (s**(-a - 1) * gamma(a + 1), 0, True)
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(1 - exp(-a * t), t, s) == (a / (s * (a + s)), 0, True)
assert LT((exp(2*t)-1)*exp(-b - t)*Heaviside(t)/2, t, s, noconds=True) \
== exp(-b)/(s**2 - 1)
assert LT(exp(t), t, s)[:2] == (1 / (s - 1), 1)
assert LT(exp(2 * t), t, s)[:2] == (1 / (s - 2), 2)
assert LT(exp(a * t), t, s)[:2] == (1 / (s - a), a)
assert LT(log(t / a), t,
s) == ((log(a) + log(s) + EulerGamma) / (-s), 0, True)
assert LT(erf(t), t, s) == ((-erf(s / 2) + 1) * exp(s**2 / 4) / s, 0, True)
assert LT(sin(a * t), t, s) == (a / (a**2 + s**2), 0, True)
assert LT(cos(a * t), t, s) == (s / (a**2 + s**2), 0, True)
# TODO would be nice to have these come out better
assert LT(exp(-a * t) * sin(b * t), t,
s) == (1 / b / (1 + (a + s)**2 / b**2), -a, True)
assert LT(exp(-a*t)*cos(b*t), t, s) == \
(1/(s + a)/(1 + b**2/(a + s)**2), -a, True)
# TODO sinh, cosh have delicate cancellation
assert LT(besselj(0, t), t, s) == (1 / sqrt(1 + s**2), 0, True)
assert LT(besselj(1, t), t, s) == (1 - 1 / sqrt(1 + 1 / s**2), 0, True)
# TODO general order works, but is a *mess*
# TODO besseli also works, but is an even greater mess
# test a bug in conditions processing
# TODO the auxiliary condition should be recognised/simplified
assert LT(exp(t) * cos(t), t, s)[:-1] in [
((s - 1) / (s**2 - 2 * s + 2), -oo),
((s - 1) / ((s - 1)**2 + 1), -oo),
]
# 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) == \
((sin(s**2/(2*pi))*fresnelc(s/pi) - sin(s**2/(2*pi))/2 -
cos(s**2/(2*pi))*fresnels(s/pi) + cos(s**2/(2*pi))/2)/s, 0, True)
def test_manualintegrate_Heaviside():
assert manualintegrate(Heaviside(x), x) == x * Heaviside(x)
assert manualintegrate(x * Heaviside(2), x) == x**2 / 2
assert manualintegrate(x * Heaviside(-2), x) == 0
assert manualintegrate(x * Heaviside(x), x) == x**2 * Heaviside(x) / 2
assert manualintegrate(x * Heaviside(-x), x) == x**2 * Heaviside(-x) / 2
assert manualintegrate(Heaviside(2 * x + 4),
x) == (x + 2) * Heaviside(2 * x + 4)
assert manualintegrate(x * Heaviside(x), x) == x**2 * Heaviside(x) / 2
assert manualintegrate(Heaviside(x + 1)*Heaviside(1 - x)*x**2, x) == \
((x**3/3 + S(1)/3)*Heaviside(x + 1) - S(2)/3)*Heaviside(-x + 1)
y = Symbol('y')
assert manualintegrate(sin(7 + x)*Heaviside(3*x - 7), x) == \
(- cos(x + 7) + cos(S(28)/3))*Heaviside(3*x - S(7))
assert manualintegrate(sin(y + x)*Heaviside(3*x - y), x) == \
(cos(4*y/3) - cos(x + y))*Heaviside(3*x - y)
def test_mellin_transform():
from sympy import Max, Min, Ne
MT = mellin_transform
bpos = symbols('b', positive=True)
# 8.4.2
assert MT(x**nu*Heaviside(x - 1), x, s) \
== (1/(-nu - s), (-oo, -re(nu)), True)
assert MT(x**nu*Heaviside(1 - x), x, s) \
== (1/(nu + s), (-re(nu), oo), True)
assert MT((1-x)**(beta - 1)*Heaviside(1-x), x, s) \
== (gamma(beta)*gamma(s)/gamma(beta + s),
(0, oo), re(-beta) < 0)
assert MT((x-1)**(beta - 1)*Heaviside(x-1), x, s) \
== (gamma(beta)*gamma(1 - beta - s)/gamma(1 - s),
(-oo, -re(beta) + 1), re(-beta) < 0)
assert MT(
(1 + x)**(-rho), x,
s) == (gamma(s) * gamma(rho - s) / gamma(rho), (0, re(rho)), True)
# TODO also the conditions should be simplified
assert MT(abs(1-x)**(-rho), x, s) == \
(cos(pi*(rho/2 - s))*gamma(s)*gamma(rho - s)/(cos(pi*rho/2)*gamma(rho)),
(0, re(rho)), And(re(rho) - 1 < 0, re(rho) < 1))
mt = MT((1 - x)**(beta - 1) * Heaviside(1 - x) + a *
(x - 1)**(beta - 1) * Heaviside(x - 1), x, s)
assert mt[1], mt[2] == ((0, -re(beta) + 1), True)
assert MT((x**a-b**a)/(x-b), x, s)[0] == \
pi*b**(a+s-1)*sin(pi*a)/(sin(pi*s)*sin(pi*(a + s)))
assert MT((x**a-bpos**a)/(x-bpos), x, s) == \
(pi*bpos**(a+s-1)*sin(pi*a)/(sin(pi*s)*sin(pi*(a + s))),
(Max(-re(a), 0), Min(1 - re(a), 1)), True)
expr = (sqrt(x + b**2) + b)**a
assert MT(expr.subs(b, bpos), x, s) == \
(-a*(2*bpos)**(a + 2*s)*gamma(s)*gamma(-a - 2*s)/gamma(-a - s + 1),
(0, -re(a)/2), True)
expr = (sqrt(x + b**2) + b)**a / sqrt(x + b**2)
assert MT(expr.subs(b, bpos), x, s) == \
(2**(a + 2*s)*bpos**(a + 2*s - 1)*gamma(s) \
*gamma(1 - a - 2*s)/gamma(1 - a - s),
(0, -re(a)/2 + S(1)/2), True)
# 8.4.2
assert MT(exp(-x), x, s) == (gamma(s), (0, oo), True)
assert MT(exp(-1 / x), x, s) == (gamma(-s), (-oo, 0), True)
# 8.4.5
assert MT(log(x)**4 * Heaviside(1 - x), x, s) == (24 / s**5, (0, oo), True)
assert MT(log(x)**3 * Heaviside(x - 1), x, s) == (6 / s**4, (-oo, 0), True)
assert MT(log(x + 1), x, s) == (pi / (s * sin(pi * s)), (-1, 0), True)
assert MT(log(1 / x + 1), x, s) == (pi / (s * sin(pi * s)), (0, 1), True)
assert MT(log(abs(1 - x)), x, s) == (pi / (s * tan(pi * s)), (-1, 0), True)
assert MT(log(abs(1 - 1 / x)), x,
s) == (pi / (s * tan(pi * s)), (0, 1), True)
# TODO we cannot currently do these (needs summation of 3F2(-1))
# this also implies that they cannot be written as a single g-function
# (although this is possible)
mt = MT(log(x) / (x + 1), x, s)
assert mt[1:] == ((0, 1), True)
assert not hyperexpand(mt[0], allow_hyper=True).has(meijerg)
mt = MT(log(x)**2 / (x + 1), x, s)
assert mt[1:] == ((0, 1), True)
assert not hyperexpand(mt[0], allow_hyper=True).has(meijerg)
mt = MT(log(x) / (x + 1)**2, x, s)
assert mt[1:] == ((0, 2), True)
assert not hyperexpand(mt[0], allow_hyper=True).has(meijerg)
# 8.4.14
assert MT(erf(sqrt(x)), x, s) == \
(-gamma(s + S(1)/2)/(sqrt(pi)*s), (-S(1)/2, 0), True)
def unitstep(t):
x = Heaviside(t)
plot(x)
return x
def test_inverse_mellin_transform():
from sympy import (sin, simplify, Max, Min, expand, powsimp, exp_polar,
cos, cot)
IMT = inverse_mellin_transform
assert IMT(gamma(s), s, x, (0, oo)) == exp(-x)
assert IMT(gamma(-s), s, x, (-oo, 0)) == exp(-1 / x)
assert simplify(IMT(s/(2*s**2 - 2), s, x, (2, oo))) == \
(x**2 + 1)*Heaviside(1 - x)/(4*x)
# test passing "None"
assert IMT(1/(s**2 - 1), s, x, (-1, None)) == \
-x*Heaviside(-x + 1)/2 - Heaviside(x - 1)/(2*x)
assert IMT(1/(s**2 - 1), s, x, (None, 1)) == \
-x*Heaviside(-x + 1)/2 - Heaviside(x - 1)/(2*x)
# test expansion of sums
assert IMT(gamma(s) + gamma(s - 1), s, x, (1, oo)) == (x + 1) * exp(-x) / x
# test factorisation of polys
r = symbols('r', real=True)
assert IMT(1/(s**2 + 1), s, exp(-x), (None, oo)
).subs(x, r).rewrite(sin).simplify() \
== sin(r)*Heaviside(1 - exp(-r))
# test multiplicative substitution
_a, _b = symbols('a b', positive=True)
assert IMT(_b**(-s / _a) * factorial(s / _a) / s, s, x,
(0, oo)) == exp(-_b * x**_a)
assert IMT(factorial(_a / _b + s / _b) / (_a + s), s, x,
(-_a, oo)) == x**_a * exp(-x**_b)
def simp_pows(expr):
return simplify(powsimp(expand_mul(expr, deep=False),
force=True)).replace(exp_polar, exp)
# Now test the inverses of all direct transforms tested above
# Section 8.4.2
nu = symbols('nu', real=True, finite=True)
assert IMT(-1 / (nu + s), s, x, (-oo, None)) == x**nu * Heaviside(x - 1)
assert IMT(1 / (nu + s), s, x, (None, oo)) == x**nu * Heaviside(1 - x)
assert simp_pows(IMT(gamma(beta)*gamma(s)/gamma(s + beta), s, x, (0, oo))) \
== (1 - x)**(beta - 1)*Heaviside(1 - x)
assert simp_pows(IMT(gamma(beta)*gamma(1 - beta - s)/gamma(1 - s),
s, x, (-oo, None))) \
== (x - 1)**(beta - 1)*Heaviside(x - 1)
assert simp_pows(IMT(gamma(s)*gamma(rho - s)/gamma(rho), s, x, (0, None))) \
== (1/(x + 1))**rho
assert simp_pows(IMT(d**c*d**(s - 1)*sin(pi*c)
*gamma(s)*gamma(s + c)*gamma(1 - s)*gamma(1 - s - c)/pi,
s, x, (Max(-re(c), 0), Min(1 - re(c), 1)))) \
== (x**c - d**c)/(x - d)
assert simplify(IMT(1/sqrt(pi)*(-c/2)*gamma(s)*gamma((1 - c)/2 - s)
*gamma(-c/2 - s)/gamma(1 - c - s),
s, x, (0, -re(c)/2))) == \
(1 + sqrt(x + 1))**c
assert simplify(IMT(2**(a + 2*s)*b**(a + 2*s - 1)*gamma(s)*gamma(1 - a - 2*s)
/gamma(1 - a - s), s, x, (0, (-re(a) + 1)/2))) == \
b**(a - 1)*(sqrt(1 + x/b**2) + 1)**(a - 1)*(b**2*sqrt(1 + x/b**2) +
b**2 + x)/(b**2 + x)
assert simplify(IMT(-2**(c + 2*s)*c*b**(c + 2*s)*gamma(s)*gamma(-c - 2*s)
/ gamma(-c - s + 1), s, x, (0, -re(c)/2))) == \
b**c*(sqrt(1 + x/b**2) + 1)**c
# Section 8.4.5
assert IMT(24 / s**5, s, x, (0, oo)) == log(x)**4 * Heaviside(1 - x)
assert expand(IMT(6/s**4, s, x, (-oo, 0)), force=True) == \
log(x)**3*Heaviside(x - 1)
assert IMT(pi / (s * sin(pi * s)), s, x, (-1, 0)) == log(x + 1)
assert IMT(pi / (s * sin(pi * s / 2)), s, x, (-2, 0)) == log(x**2 + 1)
assert IMT(pi / (s * sin(2 * pi * s)), s, x,
(-S(1) / 2, 0)) == log(sqrt(x) + 1)
assert IMT(pi / (s * sin(pi * s)), s, x, (0, 1)) == log(1 + 1 / x)
# TODO
def mysimp(expr):
from sympy import expand, logcombine, powsimp
return expand(powsimp(logcombine(expr, force=True),
force=True,
deep=True),
force=True).replace(exp_polar, exp)
assert mysimp(mysimp(IMT(pi / (s * tan(pi * s)), s, x, (-1, 0)))) in [
log(1 - x) * Heaviside(1 - x) + log(x - 1) * Heaviside(x - 1),
log(x) * Heaviside(x - 1) + log(1 - 1 / x) * Heaviside(x - 1) +
log(-x + 1) * Heaviside(-x + 1)
]
# test passing cot
assert mysimp(IMT(pi * cot(pi * s) / s, s, x, (0, 1))) in [
log(1 / x - 1) * Heaviside(1 - x) + log(1 - 1 / x) * Heaviside(x - 1),
-log(x) * Heaviside(-x + 1) + log(1 - 1 / x) * Heaviside(x - 1) +
log(-x + 1) * Heaviside(-x + 1),
]
# 8.4.14
assert IMT(-gamma(s + S(1)/2)/(sqrt(pi)*s), s, x, (-S(1)/2, 0)) == \
erf(sqrt(x))
# 8.4.19
assert simplify(IMT(gamma(a/2 + s)/gamma(a/2 - s + 1), s, x, (-re(a)/2, S(3)/4))) \
== besselj(a, 2*sqrt(x))
assert simplify(IMT(2**a*gamma(S(1)/2 - 2*s)*gamma(s + (a + 1)/2)
/ (gamma(1 - s - a/2)*gamma(1 - 2*s + a)),
s, x, (-(re(a) + 1)/2, S(1)/4))) == \
sin(sqrt(x))*besselj(a, sqrt(x))
assert simplify(IMT(2**a*gamma(a/2 + s)*gamma(S(1)/2 - 2*s)
/ (gamma(S(1)/2 - s - a/2)*gamma(1 - 2*s + a)),
s, x, (-re(a)/2, S(1)/4))) == \
cos(sqrt(x))*besselj(a, sqrt(x))
# TODO this comes out as an amazing mess, but simplifies nicely
assert simplify(IMT(gamma(a + s)*gamma(S(1)/2 - s)
/ (sqrt(pi)*gamma(1 - s)*gamma(1 + a - s)),
s, x, (-re(a), S(1)/2))) == \
besselj(a, sqrt(x))**2
assert simplify(IMT(gamma(s)*gamma(S(1)/2 - s)
/ (sqrt(pi)*gamma(1 - s - a)*gamma(1 + a - s)),
s, x, (0, S(1)/2))) == \
besselj(-a, sqrt(x))*besselj(a, sqrt(x))
assert simplify(IMT(4**s*gamma(-2*s + 1)*gamma(a/2 + b/2 + s)
/ (gamma(-a/2 + b/2 - s + 1)*gamma(a/2 - b/2 - s + 1)
*gamma(a/2 + b/2 - s + 1)),
s, x, (-(re(a) + re(b))/2, S(1)/2))) == \
besselj(a, sqrt(x))*besselj(b, sqrt(x))
# Section 8.4.20
# TODO this can be further simplified!
assert simplify(IMT(-2**(2*s)*cos(pi*a/2 - pi*b/2 + pi*s)*gamma(-2*s + 1) *
gamma(a/2 - b/2 + s)*gamma(a/2 + b/2 + s) /
(pi*gamma(a/2 - b/2 - s + 1)*gamma(a/2 + b/2 - s + 1)),
s, x,
(Max(-re(a)/2 - re(b)/2, -re(a)/2 + re(b)/2), S(1)/2))) == \
besselj(a, sqrt(x))*-(besselj(-b, sqrt(x)) -
besselj(b, sqrt(x))*cos(pi*b))/sin(pi*b)
# TODO more
# for coverage
assert IMT(pi / cos(pi * s), s, x, (0, S(1) / 2)) == sqrt(x) / (x + 1)
def test_manualintegrate_Heaviside():
assert manualintegrate(Heaviside(x), x) == x * Heaviside(x)
assert manualintegrate(x * Heaviside(2), x) == x**2 / 2
assert manualintegrate(x * Heaviside(-2), x) == 0
assert manualintegrate(x * Heaviside(x), x) == x**2 * Heaviside(x) / 2
assert manualintegrate(x * Heaviside(-x), x) == x**2 * Heaviside(-x) / 2
assert manualintegrate(Heaviside(2 * x + 4),
x) == (x + 2) * Heaviside(2 * x + 4)
assert manualintegrate(x * Heaviside(x), x) == x**2 * Heaviside(x) / 2
assert manualintegrate(Heaviside(x + 1)*Heaviside(1 - x)*x**2, x) == \
((x**3/3 + Rational(1, 3))*Heaviside(x + 1) - Rational(2, 3))*Heaviside(-x + 1)
y = Symbol('y')
assert manualintegrate(sin(7 + x)*Heaviside(3*x - 7), x) == \
(- cos(x + 7) + cos(Rational(28, 3)))*Heaviside(3*x - S(7))
assert manualintegrate(sin(y + x)*Heaviside(3*x - y), x) == \
(cos(y*Rational(4, 3)) - cos(x + y))*Heaviside(3*x - y)
