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