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 _eval_rewrite_as_Heaviside(self, arg, **kwargs):
# Note this only holds for real arg (since Heaviside is not defined
# for complex arguments).
from sympy.functions.special.delta_functions import Heaviside
if arg.is_extended_real:
return arg * (Heaviside(arg) - Heaviside(-arg))
def test_exp():
"""Test time_functions.exp"""
v1, v2, td1, tau1, td2, tau2, time = sympy.symbols('v1, v2, td1, tau1, ' +
'td2, tau2, time')
F = v1 + (v2 - v1)*(1 - sympy.exp(-(time - td1)/tau1))*Heaviside(time - td1) +\
(v1 - v2)*(1 - sympy.exp(-(time - td2)/tau2))*Heaviside(time - td2)
v1n, v2n, td1n, tau1n, td2n, tau2n = 0.1, 3, 0.33e-3, 0.2e-3, .66e-3, .11e-3
f = time_functions.exp(v1=v1n,
v2=v2n,
td1=td1n,
tau1=tau1n,
td2=td2n,
tau2=tau2n)
FS = sympy.lambdify(
time,
sympy.N(
F.subs(
dict(v1=v1n,
v2=v2n,
td1=td1n,
tau1=tau1n,
td2=td2n,
tau2=tau2n))))
t = np.linspace(0, 1e-3, 3e3)
for ti in t:
assert np.allclose(f(ti), float(FS(ti)), rtol=1e-4)
def test_sin():
"""Test time_functions.sin"""
vo, va, freq, td, theta, phi, time = sympy.symbols('vo, va, freq, td, ' +
'theta, phi, time')
F = vo + va*sympy.sin(sympy.pi*phi/180)*Heaviside(td - time) + \
va*sympy.sin(2*sympy.pi*freq*(time - td) + sympy.pi*phi/180)* \
sympy.exp(-(time - td)*theta)*Heaviside(time - td)
von, van, freqn, tdn, thetan, phin = 0.1, 3, 20e3, 0.5e-3, 1e2, 50.
f = time_functions.sin(vo=von,
va=van,
freq=freqn,
td=tdn,
theta=thetan,
phi=phin)
FS = sympy.lambdify(
time,
sympy.N(
F.subs(
dict(vo=von,
va=van,
freq=freqn,
td=tdn,
theta=thetan,
phi=phin))))
t = np.linspace(0, 1e-3, 3e3)
for ti in t:
assert np.allclose(f(ti), float(FS(ti)), rtol=1e-4)
def test_issue_22739():
if not numpy:
skip("numpy not installed")
x1, x2 = symbols('x1 x2')
f = Heaviside(Min(x1, x2))
F = lambdify((x1, x2), f, modules='numpy')
point = {x1: 1, x2: 2}
assert abs(f.subs(point) - F(*point.values())) <= 1e-10
def test_Max():
from sympy.abc import x, y, z
n = Symbol('n', negative=True)
n_ = Symbol('n_', negative=True)
nn = Symbol('nn', nonnegative=True)
nn_ = Symbol('nn_', nonnegative=True)
p = Symbol('p', positive=True)
p_ = Symbol('p_', positive=True)
np = Symbol('np', nonpositive=True)
np_ = Symbol('np_', nonpositive=True)
r = Symbol('r', real=True)
assert Max(5, 4) == 5
# lists
raises(ValueError, lambda: Max())
assert Max(x, y) == Max(y, x)
assert Max(x, y, z) == Max(z, y, x)
assert Max(x, Max(y, z)) == Max(z, y, x)
assert Max(x, Min(y, oo)) == Max(x, y)
assert Max(n, -oo, n_, p, 2) == Max(p, 2)
assert Max(n, -oo, n_, p) == p
assert Max(2, x, p, n, -oo, S.NegativeInfinity, n_, p, 2) == Max(2, x, p)
assert Max(0, x, 1, y) == Max(1, x, y)
assert Max(r, r + 1, r - 1) == 1 + r
assert Max(1000, 100, -100, x, p, n) == Max(p, x, 1000)
assert Max(cos(x), sin(x)) == Max(sin(x), cos(x))
assert Max(cos(x), sin(x)).subs(x, 1) == sin(1)
assert Max(cos(x), sin(x)).subs(x, S(1)/2) == cos(S(1)/2)
raises(ValueError, lambda: Max(cos(x), sin(x)).subs(x, I))
raises(ValueError, lambda: Max(I))
raises(ValueError, lambda: Max(I, x))
raises(ValueError, lambda: Max(S.ComplexInfinity, 1))
# interesting:
# Max(n, -oo, n_, p, 2) == Max(p, 2)
# True
# Max(n, -oo, n_, p, 1000) == Max(p, 1000)
# False
assert Max(1, x).diff(x) == Heaviside(x - 1)
assert Max(x, 1).diff(x) == Heaviside(x - 1)
assert Max(x**2, 1 + x, 1).diff(x) == \
2*x*Heaviside(x**2 - Max(1, x + 1)) \
+ Heaviside(x - Max(1, x**2) + 1)
a, b = Symbol('a', real=True), Symbol('b', real=True)
# a and b are both real, Max(a, b) should be real
assert Max(a, b).is_real
# issue 7233
e = Max(0, x)
assert e.evalf == e.n
assert e.n().args == (0, x)
def fdiff(self, argindex):
from sympy.functions.special.delta_functions import Heaviside
n = len(self.args)
if 0 < argindex and argindex <= n:
argindex -= 1
if n == 2:
return Heaviside(self.args[1 - argindex] - self.args[argindex])
newargs = tuple([self.args[i] for i in xrange(n) if i != argindex])
return Heaviside(Min(*newargs) - self.args[argindex])
else:
raise ArgumentIndexError(self, argindex)
def test_fourier_transform():
from sympy.core.function import (expand, expand_complex, expand_trig)
from sympy.polys.polytools import factor
from sympy.simplify.simplify import simplify
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 test_pwl():
"""Test time_functions.pwl"""
# we define a pulse shape, with repeat and we check that it matches with
# its sympy implementation
# as we cannot define a periodic function in sympy, we will use a small hack
v1, v2, td, tr, pw, tf, per, time = sympy.symbols('v1, v2, td, tr, pw, ' +
'tf, per, time')
F = v1*Heaviside(td - time) + \
((v2 - v1)/tr*time + v1 +(v1 - v2)*td/tr)* \
Heaviside(time - td)*Heaviside(td + tr - time) + \
v2*Heaviside(time - td - tr)*Heaviside(td + tr + pw - time) + \
((v1 - v2)/tf*time + v2 + (-v1*(pw + td + tr) + v2*(pw + td + tr))/tf)* \
Heaviside(time - td - tr - pw)*Heaviside(td + tr + pw + tf - time) + \
v1*Heaviside(time - td - tr - pw - tf)
v1n, v2n, tdn, trn, pwn, tfn, pern = (-2, 3, 0.1e-3, 0.05e-3, .5e-3,
.01e-3, 1e-3)
x = [0., 0.05e-3, 0.55e-3, 0.56e-3, 1e-3]
y = [-2, 3, 3, -2, -2]
f = time_functions.pwl(x, y, repeat=True, td=0.1e-3, repeat_time=1e-3)
FS = sympy.lambdify(
time,
sympy.N(
F.subs(
dict(v1=v1n, v2=v2n, td=tdn, tr=trn, pw=pwn, tf=tfn,
per=pern))))
t = np.linspace(0, 1e-3, 1e3)
# first period
for ti in t:
assert np.allclose(f(ti), float(FS(ti)), rtol=1e-4)
# second period
for ti in t:
assert np.allclose(f(ti + 1e-3), float(FS(ti)), rtol=1e-4)
# check str() does not choke
print(str(f))
def test_pulse():
"""Test time_functions.pulse"""
# as we cannot define a periodic function in sympy, we will only check one
# period
v1, v2, td, tr, pw, tf, per, time = sympy.symbols('v1, v2, td, tr, pw, ' +
'tf, per, time')
F = v1*Heaviside(td - time) + \
((v2 - v1)/tr*time + v1 +(v1 - v2)*td/tr)* \
Heaviside(time - td)*Heaviside(td + tr - time) + \
v2*Heaviside(time - td - tr)*Heaviside(td + tr + pw - time) + \
((v1 - v2)/tf*time + v2 + (-v1*(pw + td + tr) + v2*(pw + td + tr))/tf)* \
Heaviside(time - td - tr - pw)*Heaviside(td + tr + pw + tf - time) + \
v1*Heaviside(time - td - tr - pw - tf)
v1n, v2n, tdn, trn, pwn, tfn, pern = (-2, 3, 0.1e-3, 0.05e-3, .5e-3,
.01e-3, 1e-3)
f = time_functions.pulse(v1=v1n,
v2=v2n,
td=tdn,
tr=trn,
pw=pwn,
tf=tfn,
per=pern)
FS = sympy.lambdify(
time,
sympy.N(
F.subs(
dict(v1=v1n, v2=v2n, td=tdn, tr=trn, pw=pwn, tf=tfn,
per=pern))))
t = np.linspace(0, 1e-3, 1e3)
for ti in t:
assert np.allclose(f(ti), float(FS(ti)), rtol=1e-4)
def _eval_rewrite_as_Heaviside(self, *args, **kwargs):
'''
Rewrites a Singularity Function expression using Heavisides and DiracDeltas.
'''
x = self.args[0]
a = self.args[1]
n = sympify(self.args[2])
if n == -2:
return diff(Heaviside(x - a), x.free_symbols.pop(), 2)
if n == -1:
return diff(Heaviside(x - a), x.free_symbols.pop(), 1)
if n.is_nonnegative:
return (x - a)**n * Heaviside(x - a)
def set_sense_average(self, val, mode=0, channel=1):
'''
Sets sense average of channel <channel> to <val>
Input:
val (int) : [1, 100]
mode (str) : 0 (moving average) (default) | 1 (repeat average) | 2 (median)
channel (int) : 1 (default) | 2
Output:
None
'''
# Corresponding Command: smuX.measure.filter.count = filterCount
# Corresponding Command: smuX.measure.filter.enable = filterState
# Corresponding Command: smuX.measure.filter.type = filterType
try:
logging.debug(
__name__ +
': Set sense average of channel %s to %i and mode %s' %
(chr(64 + channel), val, self._avg_types[mode]))
status = bool(Heaviside(val - 1 - 1e-10))
self._write('smu%s.measure.filter.enable = %i' %
(chr(96 + channel), status))
if status:
self._write('smu%s.measure.filter.count = %i' %
(chr(96 + channel), val))
self._write('smu%s.measure.filter.type = %i' %
(chr(96 + channel), mode))
except AttributeError:
logging.error(
__name__ +
': invalid input: cannot set sense average of channel %s to %i and mode %s'
% (chr(64 + channel), val, self._avg_types[mode]))
def test_expint():
from sympy.functions.elementary.miscellaneous import Max
from sympy.functions.special.error_functions import (Ci, E1, Ei, Si)
from sympy.functions.special.zeta_functions import lerchphi
from sympy.simplify.simplify import simplify
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 hatpsi(_t, _gamma=GAMMA):
return \
Heaviside(_t) * \
Matrix([
[0, 0],
[0, sqrt(_gamma)]
]) * \
non_unitary_psi(_t, _gamma)
def test_inversion():
from sympy.functions.elementary.piecewise import piecewise_fold
from sympy.functions.special.bessel import besselj
from sympy.functions.special.delta_functions import Heaviside
def inv(f):
return piecewise_fold(meijerint_inversion(f, s, t))
assert inv(1 / (s**2 + 1)) == sin(t) * Heaviside(t)
assert inv(s / (s**2 + 1)) == cos(t) * Heaviside(t)
assert inv(exp(-s) / s) == Heaviside(t - 1)
assert inv(1 / sqrt(1 + s**2)) == besselj(0, t) * Heaviside(t)
# Test some antcedents checking.
assert meijerint_inversion(sqrt(s) / sqrt(1 + s**2), s, t) is None
assert inv(exp(s**2)) is None
assert meijerint_inversion(exp(-s**2), s, t) is None
def hatpsi(_t):
return \
Heaviside(_t) * \
2**(Rational(3,4)) * \
Matrix([
[0, 0],
[0, 1]
]) * \
non_unitary_psi(_t)
def test_Max():
from sympy.abc import x, y, z
n = Symbol('n', negative=True)
n_ = Symbol('n_', negative=True)
nn = Symbol('nn', nonnegative=True)
nn_ = Symbol('nn_', nonnegative=True)
p = Symbol('p', positive=True)
p_ = Symbol('p_', positive=True)
np = Symbol('np', nonpositive=True)
np_ = Symbol('np_', nonpositive=True)
assert Max(5, 4) == 5
# lists
raises(ValueError, lambda: Max())
assert Max(x, y) == Max(y, x)
assert Max(x, y, z) == Max(z, y, x)
assert Max(x, Max(y, z)) == Max(z, y, x)
assert Max(x, Min(y, oo)) == Max(x, y)
assert Max(n, -oo, n_, p, 2) == Max(p, 2)
assert Max(n, -oo, n_, p) == p
assert Max(2, x, p, n, -oo, S.NegativeInfinity, n_, p, 2) == Max(2, x, p)
assert Max(0, x, 1, y) == Max(1, x, y)
assert Max(x, x + 1, x - 1) == 1 + x
assert Max(1000, 100, -100, x, p, n) == Max(p, x, 1000)
assert Max(cos(x), sin(x)) == Max(sin(x), cos(x))
assert Max(cos(x), sin(x)).subs(x, 1) == sin(1)
assert Max(cos(x), sin(x)).subs(x, S(1) / 2) == cos(S(1) / 2)
raises(ValueError, lambda: Max(cos(x), sin(x)).subs(x, I))
raises(ValueError, lambda: Max(I))
raises(ValueError, lambda: Max(I, x))
raises(ValueError, lambda: Max(S.ComplexInfinity, 1))
# interesting:
# Max(n, -oo, n_, p, 2) == Max(p, 2)
# True
# Max(n, -oo, n_, p, 1000) == Max(p, 1000)
# False
from sympy.functions.special.delta_functions import Heaviside
assert Max(1, x).diff(x) == Heaviside(x - 1)
assert Max(x, 1).diff(x) == Heaviside(x - 1)
assert Max(x**2, 1+x, 1).diff(x) == 2*x*Heaviside(x**2 - Max(1,x+1)) \
+ Heaviside(x - Max(1,x**2) + 1)
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 tau_YY(self, E, z, t_var, delta_D, BPL, x_a=1e-4, x_b=1e4):
"""Function for evaluating the optical depth as a function of the energy
in the case of target photon gas with broken power-law photon distribution
Eq. (10.27) of reference 1.
Parameters:
-----------
E : astropy.units('eV')
energy of the colliding photon
z : float
redshift of the source
t_var : astropy.units('s')
measured variability time scale
delta_D : float
relativistic doppler factor
BPL : `~naima.models.BrokenPowerLaw`
Broken Power Law describing the target photon
Returns:
--------
float, value of the tau_YY for an incident photon of energy E
"""
# we need to get the parameters a, b, eps_pk and f_eps_pk from the BPL
a = BPL.alpha_2 + 2 # we want the value in a nu Fnu rapresentation
b = BPL.alpha_1 + 2 # we want the value in a nu Fnu rapresentation
eps_pk = (BPL.e_break.to('eV') / _mec2_u).decompose()
f_eps_pk = (BPL.e_break**2 * BPL.amplitude).to('erg cm-2 s-1')
# listed all the values we need for the prefactor calculation
r_e = 2.8179403227 * 1e-13 * u.cm
# we have to get the luminosity distance from the redshift
# we use astropy cosmology
d_L = cosmo.luminosity_distance(z)
# dimensionless energy of the colliding photon
eps_1 = (E / (const.m_e * const.c ** 2)).decompose().value
# this is the multiplicative factor of the integral in the second line
# in Eq. (10.27)
prefactor_num = 3 * pi * r_e ** 2 * d_L ** 2 * f_eps_pk
prefactor_denom = const.m_e * const.c ** 4 * \
t_var * eps_1 ** 2 * eps_pk ** 3 * (1 + z) ** 4
prefactor = (prefactor_num / prefactor_denom).decompose().value
# the integral
w = (1 + z) ** 2 * eps_1 * eps_pk / delta_D ** 2
def integrand1(x): return self.phi_bar(x * w) / (x ** (4 - a))
integral1 = Heaviside(1 - 1 / w) * \
quad(integrand1, max(x_a, 1 / w), 1)[0]
def integrand2(x): return self.phi_bar(x * w) / (x ** (4 - b))
integral2 = quad(integrand2, max(1, 1 / w), x_b)[0]
return float(prefactor * (integral1 + integral2))
def test_am():
"""Test time_functions.am"""
sa, fc, fm, oc, td, time = sympy.symbols('sa, fc, fm, oc, td, time')
F = sa*(oc + sympy.sin(2*sympy.pi*fm*(time - td)))* \
sympy.sin(2*sympy.pi*fc*(time - td)) * \
Heaviside(time - td)
san, fcn, fmn, ocn, tdn = 10., 1., 1e3, 100, 1e-3
f = time_functions.am(sa=san, fc=fcn, fm=fmn, oc=ocn, td=tdn)
FS = sympy.lambdify(
time, sympy.N(F.subs(dict(sa=san, fc=fcn, fm=fmn, oc=ocn, td=tdn))))
t = np.linspace(0, 20e-3, 3e3)
for ti in t:
assert np.allclose(f(ti), float(FS(ti)), rtol=1e-4)
def test_Abs_rewrite():
x = Symbol('x', real=True)
a = Abs(x).rewrite(Heaviside).expand()
assert a == x * Heaviside(x) - x * Heaviside(-x)
for i in [-2, -1, 0, 1, 2]:
assert a.subs(x, i) == abs(i)
y = Symbol('y')
assert Abs(y).rewrite(Heaviside) == Abs(y)
x, y = Symbol('x', real=True), Symbol('y')
assert Abs(x).rewrite(Piecewise) == Piecewise((x, x >= 0), (-x, True))
assert Abs(y).rewrite(Piecewise) == Abs(y)
assert Abs(y).rewrite(sign) == y / sign(y)
i = Symbol('i', imaginary=True)
assert abs(i).rewrite(Piecewise) == Piecewise((I * i, I * i >= 0),
(-I * i, True))
assert Abs(y).rewrite(conjugate) == sqrt(y * conjugate(y))
assert Abs(i).rewrite(conjugate) == sqrt(-i**2) # == -I*i
y = Symbol('y', extended_real=True)
assert (Abs(exp(-I*x)-exp(-I*y))**2).rewrite(conjugate) == \
-exp(I*x)*exp(-I*y) + 2 - exp(-I*x)*exp(I*y)
def test_sffm():
"""Test time_functions.sffm"""
vo, va, fc, mdi, fs, td, time = sympy.symbols('vo, va, fc, mdi, fs, td,' +
' time')
F = vo + va*sympy.sin(2*sympy.pi*fc*(time - td) +
mdi*sympy.sin(2*sympy.pi*fs*(time - td)))* \
Heaviside(time - td)
von, van, fcn, mdin, fsn, tdn = 0.1, 1e-3, 20e3, 5, 1e3, 1e-3
f = time_functions.sffm(vo=von, va=van, fc=fcn, mdi=mdin, fs=fsn, td=tdn)
FS = sympy.lambdify(
time,
sympy.N(F.subs(dict(vo=von, va=van, fc=fcn, mdi=mdin, fs=fsn,
td=tdn))))
t = np.linspace(0, 1e-3, 3e3)
for ti in t:
assert np.allclose(f(ti), float(FS(ti)), rtol=1e-4)
def test_Heaviside():
sT(Heaviside(x), "Heaviside(Symbol('x'))")
sT(Heaviside(x, 1), "Heaviside(Symbol('x'), Integer(1))")
def _eval_rewrite_as_Heaviside(self, arg, **kwargs):
from sympy.functions.special.delta_functions import Heaviside
if arg.is_extended_real:
return Heaviside(arg, H0=S(1) / 2) * 2 - 1
def test_Heaviside():
assert str(Heaviside(x)) == str(Heaviside(x, S.Half)) == "Heaviside(x)"
assert str(Heaviside(x, 1)) == "Heaviside(x, 1)"
def test_rewrite_MaxMin_as_Heaviside():
from sympy.abc import x
assert Max(0, x).rewrite(Heaviside) == x * Heaviside(x)
assert Max(3, x).rewrite(Heaviside) == x*Heaviside(x - 3) + \
3*Heaviside(-x + 3)
assert Max(0, x+2, 2*x).rewrite(Heaviside) == \
2*x*Heaviside(2*x)*Heaviside(x - 2) + \
(x + 2)*Heaviside(-x + 2)*Heaviside(x + 2)
assert Min(0, x).rewrite(Heaviside) == x * Heaviside(-x)
assert Min(3, x).rewrite(Heaviside) == x*Heaviside(-x + 3) + \
3*Heaviside(x - 3)
assert Min(x, -x, -2).rewrite(Heaviside) == \
x*Heaviside(-2*x)*Heaviside(-x - 2) - \
x*Heaviside(2*x)*Heaviside(x - 2) \
- 2*Heaviside(-x + 2)*Heaviside(x + 2)
def test_Min():
from sympy.abc import x, y, z
n = Symbol('n', negative=True)
n_ = Symbol('n_', negative=True)
nn = Symbol('nn', nonnegative=True)
nn_ = Symbol('nn_', nonnegative=True)
p = Symbol('p', positive=True)
p_ = Symbol('p_', positive=True)
np = Symbol('np', nonpositive=True)
np_ = Symbol('np_', nonpositive=True)
r = Symbol('r', real=True)
assert Min(5, 4) == 4
assert Min(-oo, -oo) == -oo
assert Min(-oo, n) == -oo
assert Min(n, -oo) == -oo
assert Min(-oo, np) == -oo
assert Min(np, -oo) == -oo
assert Min(-oo, 0) == -oo
assert Min(0, -oo) == -oo
assert Min(-oo, nn) == -oo
assert Min(nn, -oo) == -oo
assert Min(-oo, p) == -oo
assert Min(p, -oo) == -oo
assert Min(-oo, oo) == -oo
assert Min(oo, -oo) == -oo
assert Min(n, n) == n
assert Min(n, np) == Min(n, np)
assert Min(np, n) == Min(np, n)
assert Min(n, 0) == n
assert Min(0, n) == n
assert Min(n, nn) == n
assert Min(nn, n) == n
assert Min(n, p) == n
assert Min(p, n) == n
assert Min(n, oo) == n
assert Min(oo, n) == n
assert Min(np, np) == np
assert Min(np, 0) == np
assert Min(0, np) == np
assert Min(np, nn) == np
assert Min(nn, np) == np
assert Min(np, p) == np
assert Min(p, np) == np
assert Min(np, oo) == np
assert Min(oo, np) == np
assert Min(0, 0) == 0
assert Min(0, nn) == 0
assert Min(nn, 0) == 0
assert Min(0, p) == 0
assert Min(p, 0) == 0
assert Min(0, oo) == 0
assert Min(oo, 0) == 0
assert Min(nn, nn) == nn
assert Min(nn, p) == Min(nn, p)
assert Min(p, nn) == Min(p, nn)
assert Min(nn, oo) == nn
assert Min(oo, nn) == nn
assert Min(p, p) == p
assert Min(p, oo) == p
assert Min(oo, p) == p
assert Min(oo, oo) == oo
assert Min(n, n_).func is Min
assert Min(nn, nn_).func is Min
assert Min(np, np_).func is Min
assert Min(p, p_).func is Min
# lists
raises(ValueError, lambda: Min())
assert Min(x, y) == Min(y, x)
assert Min(x, y, z) == Min(z, y, x)
assert Min(x, Min(y, z)) == Min(z, y, x)
assert Min(x, Max(y, -oo)) == Min(x, y)
assert Min(p, oo, n, p, p, p_) == n
assert Min(p_, n_, p) == n_
assert Min(n, oo, -7, p, p, 2) == Min(n, -7)
assert Min(2, x, p, n, oo, n_, p, 2, -2, -2) == Min(-2, x, n, n_)
assert Min(0, x, 1, y) == Min(0, x, y)
assert Min(1000, 100, -100, x, p, n) == Min(n, x, -100)
assert Min(cos(x), sin(x)) == Min(cos(x), sin(x))
assert Min(cos(x), sin(x)).subs(x, 1) == cos(1)
assert Min(cos(x), sin(x)).subs(x, S(1) / 2) == sin(S(1) / 2)
raises(ValueError, lambda: Min(cos(x), sin(x)).subs(x, I))
raises(ValueError, lambda: Min(I))
raises(ValueError, lambda: Min(I, x))
raises(ValueError, lambda: Min(S.ComplexInfinity, x))
assert Min(1, x).diff(x) == Heaviside(1 - x)
assert Min(x, 1).diff(x) == Heaviside(1 - x)
assert Min(0, -x, 1 - 2*x).diff(x) == -Heaviside(x + Min(0, -2*x + 1)) \
- 2*Heaviside(2*x + Min(0, -x) - 1)
# issue 7619
f = Function('f')
assert Min(1, 2 * Min(f(1), 2)) # doesn't fail
# issue 7233
e = Min(0, x)
assert e.evalf == e.n
assert e.n().args == (0, x)
# issue 8643
m = Min(n, p_, n_, r)
assert m.is_positive is False
assert m.is_nonnegative is False
assert m.is_negative is True
m = Min(p, p_)
assert m.is_positive is True
assert m.is_nonnegative is True
assert m.is_negative is False
m = Min(p, nn_, p_)
assert m.is_positive is None
assert m.is_nonnegative is True
assert m.is_negative is False
m = Min(nn, p, r)
assert m.is_positive is None
assert m.is_nonnegative is None
assert m.is_negative is None
def test_Max():
from sympy.abc import x, y, z
n = Symbol('n', negative=True)
n_ = Symbol('n_', negative=True)
nn = Symbol('nn', nonnegative=True)
nn_ = Symbol('nn_', nonnegative=True)
p = Symbol('p', positive=True)
p_ = Symbol('p_', positive=True)
np = Symbol('np', nonpositive=True)
np_ = Symbol('np_', nonpositive=True)
r = Symbol('r', real=True)
assert Max(5, 4) == 5
# lists
raises(ValueError, lambda: Max())
assert Max(x, y) == Max(y, x)
assert Max(x, y, z) == Max(z, y, x)
assert Max(x, Max(y, z)) == Max(z, y, x)
assert Max(x, Min(y, oo)) == Max(x, y)
assert Max(n, -oo, n_, p, 2) == Max(p, 2)
assert Max(n, -oo, n_, p) == p
assert Max(2, x, p, n, -oo, S.NegativeInfinity, n_, p, 2) == Max(2, x, p)
assert Max(0, x, 1, y) == Max(1, x, y)
assert Max(r, r + 1, r - 1) == 1 + r
assert Max(1000, 100, -100, x, p, n) == Max(p, x, 1000)
assert Max(cos(x), sin(x)) == Max(sin(x), cos(x))
assert Max(cos(x), sin(x)).subs(x, 1) == sin(1)
assert Max(cos(x), sin(x)).subs(x, S(1) / 2) == cos(S(1) / 2)
raises(ValueError, lambda: Max(cos(x), sin(x)).subs(x, I))
raises(ValueError, lambda: Max(I))
raises(ValueError, lambda: Max(I, x))
raises(ValueError, lambda: Max(S.ComplexInfinity, 1))
assert Max(n, -oo, n_, p, 2) == Max(p, 2)
assert Max(n, -oo, n_, p, 1000) == Max(p, 1000)
assert Max(1, x).diff(x) == Heaviside(x - 1)
assert Max(x, 1).diff(x) == Heaviside(x - 1)
assert Max(x**2, 1 + x, 1).diff(x) == \
2*x*Heaviside(x**2 - Max(1, x + 1)) \
+ Heaviside(x - Max(1, x**2) + 1)
e = Max(0, x)
assert e.evalf == e.n
assert e.n().args == (0, x)
# issue 8643
m = Max(p, p_, n, r)
assert m.is_positive is True
assert m.is_nonnegative is True
assert m.is_negative is False
m = Max(n, n_)
assert m.is_positive is False
assert m.is_nonnegative is False
assert m.is_negative is True
m = Max(n, n_, r)
assert m.is_positive is None
assert m.is_nonnegative is None
assert m.is_negative is None
m = Max(n, nn, r)
assert m.is_positive is None
assert m.is_nonnegative is True
assert m.is_negative is False
def _eval_rewrite_as_Heaviside(self, arg):
from sympy.functions.special.delta_functions import Heaviside
if arg.is_real:
return Heaviside(arg)*2-1
def test_sympy__functions__special__delta_functions__Heaviside():
from sympy.functions.special.delta_functions import Heaviside
assert _test_args(Heaviside(x))
