def compute_density(self, expr, **kwargs): z = Dummy('z', real=True, finite=True) rvs = random_symbols(expr) if any(pspace(rv).is_Continuous for rv in rvs): expr = self.compute_expectation(DiracDelta(expr - z), **kwargs) else: expr = self.compute_expectation(KroneckerDelta(expr, z), **kwargs) return Lambda(z, expr)
def subtractBaseDiracDelta(self, point: Vector, particle: Particle): ''' :param point: :param particle: :return: ''' return DiracDelta(point.getDistanceFrom(particle.getState()))
def doit(self, **kwargs): expr, condition = self.expr, self.condition if condition is not None: # Recompute on new conditional expr expr = given(expr, condition, **kwargs) if not random_symbols(expr): return Lambda(x, DiracDelta(x - expr)) return pspace(expr).compute_density(expr, **kwargs)
def test_heaviside(): assert Heaviside(0) == 0.5 assert Heaviside(-5) == 0 assert Heaviside(1) == 1 assert Heaviside(nan) == nan assert Heaviside(x).diff(x) == DiracDelta(x) raises(ArgumentIndexError, 'Heaviside(x).fdiff(2)')
def test_inverse_laplace_transform_delta_cond(): from sympy import DiracDelta, Eq, im, Heaviside ILT = inverse_laplace_transform t = symbols('t') r = Symbol('r', real=True) assert ILT(exp(r*s), s, t, noconds=False) == (DiracDelta(t + r), True) z = Symbol('z') assert ILT(exp(z*s), s, t, noconds=False) == \ (DiracDelta(t + z), Eq(im(z), 0)) # inversion does not exist: verify it doesn't evaluate to DiracDelta for z in (Symbol('z', extended_real=False), Symbol('z', imaginary=True, zero=False)): f = ILT(exp(z*s), s, t, noconds=False) f = f[0] if isinstance(f, tuple) else f assert f.func != DiracDelta # issue 15043 assert ILT(1/s + exp(r*s)/s, s, t, noconds=False) == ( Heaviside(t) + Heaviside(r + t), True)
def test_parse_input_function(self): t = symbols('t') u = (1 + sin(t) + DiracDelta(2 - t) + 5 * DiracDelta(3 - t) + Piecewise((1, t <= 1), (2, True))) impulses, jump_times = parse_input_function(u, t) self.assertEqual(impulses, [{ 'time': 2, 'intensity': 1 }, { 'time': 3, 'intensity': 5 }]) self.assertEqual(jump_times, [1, 2, 3]) u = 1 impulses, jump_times = parse_input_function(u, t) self.assertEqual(impulses, []) self.assertEqual(jump_times, [])
def test_p(): assert Px.hilbert_space == L2(Interval(S.NegativeInfinity, S.Infinity)) assert apply_operators(Px*PxKet(px)) == px*PxKet(px) assert PxKet(px).dual_class == PxBra assert PxBra(x).dual_class == PxKet assert (Dagger(PxKet(py))*PxKet(px)).doit() == DiracDelta(px-py) assert (XBra(x)*PxKet(px)).doit() ==\ exp(I*x*px/hbar)/sqrt(2*pi*hbar) assert represent(PxKet(px)) == px
def test_integrate_DiracDelta(): # This is here to check that deltaintegrate is being called, but also # to test definite integrals. More tests are in test_deltafunctions.py assert integrate(DiracDelta(x) * f(x), (x, -oo, oo)) == f(0) assert integrate(DiracDelta(x)**2, (x, -oo, oo)) == DiracDelta(0) # issue 4522 assert integrate(integrate((4 - 4*x + x*y - 4*y) * \ DiracDelta(x)*DiracDelta(y - 1), (x, 0, 1)), (y, 0, 1)) == 0 # issue 5729 p = exp(-(x**2 + y**2)) / pi assert integrate(p*DiracDelta(x - 10*y), (x, -oo, oo), (y, -oo, oo)) == \ integrate(p*DiracDelta(x - 10*y), (y, -oo, oo), (x, -oo, oo)) == \ integrate(p*DiracDelta(10*x - y), (x, -oo, oo), (y, -oo, oo)) == \ integrate(p*DiracDelta(10*x - y), (y, -oo, oo), (x, -oo, oo)) == \ 1/sqrt(101*pi)
def test_DiracDelta(): assert DiracDelta(1) == 0 assert DiracDelta(5.1) == 0 assert DiracDelta(-pi) == 0 assert DiracDelta(5, 7) == 0 assert DiracDelta(0) == oo assert DiracDelta(0, 5) == oo assert DiracDelta(x).func == DiracDelta
def test_DiracDelta(): assert DiracDelta(1) == 0 assert DiracDelta(5.1) == 0 assert DiracDelta(-pi) == 0 assert DiracDelta(5,7) == 0 assert DiracDelta(0) == oo assert DiracDelta(0,5) == oo assert isinstance(DiracDelta(x),DiracDelta)
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 _represent_PxKet(self, basis, **options): index = options.pop("index", 1) states = basis._enumerate_state(2, start_index=index) coord1 = states[0].momentum coord2 = states[1].momentum d = DifferentialOperator(coord1) delta = DiracDelta(coord1 - coord2) return I * hbar * (d * delta)
def test_p(): assert Px.hilbert_space == L2(Interval(S.NegativeInfinity, S.Infinity)) assert qapply(Px*PxKet(px)) == px*PxKet(px) assert PxKet(px).dual_class() == PxBra assert PxBra(x).dual_class() == PxKet assert (Dagger(PxKet(py))*PxKet(px)).doit() == DiracDelta(px-py) assert (XBra(x)*PxKet(px)).doit() ==\ exp(I*x*px/hbar)/sqrt(2*pi*hbar) assert represent(PxKet(px)) == DiracDelta(px-px_1) rep_x = represent(PxOp(), basis = XOp) assert rep_x == -hbar*I*DiracDelta(x_1 - x_2)*DifferentialOperator(x_1) assert rep_x == represent(PxOp(), basis = XOp()) assert rep_x == represent(PxOp(), basis = XKet) assert rep_x == represent(PxOp(), basis = XKet()) assert represent(PxOp()*XKet(), basis=XKet) == \ -hbar*I*DiracDelta(x - x_2)*DifferentialOperator(x) assert represent(XBra("y")*PxOp()*XKet(), basis=XKet) == \ -hbar*I*DiracDelta(x-y)*DifferentialOperator(x)
def delta_function(self, m): """ The argument of Dirac is v_para - (w -m*Omega/k_parallel) @param m: The order @return: Dirac function of argument """ vz = symbols('vz') k_para = symbols('k_para') w = symbols('w') argument = vz - (w - m * self.gyro_f.value) / k_para return DiracDelta(argument)
def test_x(): assert X.hilbert_space == L2(Interval(S.NegativeInfinity, S.Infinity)) assert Commutator(X, Px).doit() == I*hbar assert apply_operators(X*XKet(x)) == x*XKet(x) assert XKet(x).dual_class == XBra assert XBra(x).dual_class == XKet assert (Dagger(XKet(y))*XKet(x)).doit() == DiracDelta(x-y) assert (PxBra(px)*XKet(x)).doit() ==\ exp(-I*x*px/hbar)/sqrt(2*pi*hbar) assert represent(XKet(x)) == x assert XBra(x).position == x
def test_as_independent(): assert (2*x*sin(x)+y+x).as_independent(x) == (y, x + 2*x*sin(x)) assert (2*x*sin(x)+y+x).as_independent(y) == (x + 2*x*sin(x), y) assert (2*x*sin(x)+y+x).as_independent(x, y) == (0, y + x + 2*x*sin(x)) assert (x*sin(x)*cos(y)).as_independent(x) == (cos(y), x*sin(x)) assert (x*sin(x)*cos(y)).as_independent(y) == (x*sin(x), cos(y)) assert (x*sin(x)*cos(y)).as_independent(x, y) == (1, x*sin(x)*cos(y)) assert (sin(x)).as_independent(x) == (1, sin(x)) assert (sin(x)).as_independent(y) == (sin(x), 1) assert (2*sin(x)).as_independent(x) == (2, sin(x)) assert (2*sin(x)).as_independent(y) == (2*sin(x), 1) # issue 1804 = 1766b n1, n2, n3 = symbols('n1 n2 n3', commutative=False) assert (n1 + n1*n2).as_independent(n2) == (n1, n1*n2) assert (n2*n1 + n1*n2).as_independent(n2) == (0, n1*n2 + n2*n1) assert (n1*n2*n1).as_independent(n2) == (n1, n2*n1) assert (n1*n2*n1).as_independent(n1) == (1, n1*n2*n1) assert (3*x).as_independent(x, as_Add=True) == (0, 3*x) assert (3*x).as_independent(x, as_Add=False) == (3, x) assert (3+x).as_independent(x, as_Add=True) == (3, x) assert (3+x).as_independent(x, as_Add=False) == (1, 3 + x) # issue 2380 assert (3*x).as_independent(Symbol) == (3, x) # issue 2549 assert (n1*x*y).as_independent(x) == (n1*y, x) assert ((x + n1)*(x - y)).as_independent(x) == (1, (x + n1)*(x - y)) assert ((x + n1)*(x - y)).as_independent(y) == (x + n1, x - y) assert (DiracDelta(x - n1)*DiracDelta(x - y)).as_independent(x) == (1, DiracDelta(x - n1)*DiracDelta(x - y)) assert (x*y*n1*n2*n3).as_independent(n2) == (x*y*n1, n2*n3) assert (x*y*n1*n2*n3).as_independent(n1) == (x*y, n1*n2*n3) assert (x*y*n1*n2*n3).as_independent(n3) == (x*y*n1*n2, n3) assert (DiracDelta(x - n1)*DiracDelta(y - n1)*DiracDelta(x - n2)).as_independent(y) == \ (DiracDelta(x - n1), DiracDelta(y - n1)*DiracDelta(x - n2)) # issue 2685 assert (x + Integral(x, (x, 1, 2))).as_independent(x, strict=True) == \ (Integral(x, (x, 1, 2)), x)
def algebraic_form(regex, what = None, threshold = 1e-3): _, (clusters, basis, partial_coefficients, bottom, (overflow, (top, bottom))) = \ extract_coefficients_algebraically(regex, what, threshold) n = sympify('n') series = 0 for i, (root, k) in enumerate(collate(clusters)): symbolic_root = inverse_symbolic(root) partial_coefficient = inverse_symbolic(partial_coefficients[i]) series += partial_coefficient * binomial(n + k - 1, k - 1) * ((-1) ** k) * (symbolic_root ** (-n - k)) for k, coefficient in overflow.items(): series += coefficient * DiracDelta(n - k) return series
def test_integrate_DiracDelta(): assert integrate(DiracDelta(x),x) == Heaviside(x) assert integrate(DiracDelta(x) * f(x),x) == f(0) * Heaviside(x) assert integrate(DiracDelta(x) * f(x),(x,-oo,oo)) == f(0) assert integrate(DiracDelta(x) * f(x),(x,0,oo)) == f(0)/2 assert integrate(DiracDelta(x**2+x-2),x) - \ (Heaviside(-1 + x)/3 + Heaviside(2 + x)/3) == 0 assert integrate(cos(x)*(DiracDelta(x)+DiracDelta(x**2-1))*sin(x)*(x-pi),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
def test_events(): # test events utility function h = Function('hrf') evs = events([3,6,9]) assert_equal(DiracDelta(-9 + t) + DiracDelta(-6 + t) + DiracDelta(-3 + t), evs) evs = events([3,6,9], f=h) assert_equal(h(-3 + t) + h(-6 + t) + h(-9 + t), evs) # make some beta symbols b = [Dummy('b%d' % i) for i in range(3)] a = Symbol('a') p = b[0] + b[1]*a + b[2]*a**2 evs = events([3,6,9], amplitudes=[2,1,-1], g=p) assert_equal((2*b[1] + 4*b[2] + b[0])*DiracDelta(-3 + t) + (-b[1] + b[0] + b[2])*DiracDelta(-9 + t) + (b[0] + b[1] + b[2])*DiracDelta(-6 + t), evs) evs = events([3,6,9], amplitudes=[2,1,-1], g=p, f=h) assert_equal((2*b[1] + 4*b[2] + b[0])*h(-3 + t) + (-b[1] + b[0] + b[2])*h(-9 + t) + (b[0] + b[1] + b[2])*h(-6 + t), evs) # test no error for numpy int arrays onsets = np.array([30, 70, 100], dtype=np.int64) evs = events(onsets, f=hrf.glover)
def test_heaviside(): assert Heaviside(0) == 0.5 assert Heaviside(-5) == 0 assert Heaviside(1) == 1 assert Heaviside(nan) == nan assert Heaviside(x).diff(x) == DiracDelta(x) assert Heaviside(x + I).is_Function assert Heaviside(I * x).is_Function raises(ArgumentIndexError, lambda: Heaviside(x).fdiff(2)) raises(ValueError, lambda: Heaviside(I)) raises(ValueError, lambda: Heaviside(2 + 3 * I))
def get_values(): """ Get the special values as a dict where the keys are the Symi expressions ans the values are the corresponding SymPy values. Returns ------- values : tuple of dict Correspondences between Symi and Sympy. Values[0] gives the basic function replacements, values[1] gives the operator replacements, values[2] gives the constants replacements values[3] gives the advances function replacements """ fcts = { "arccos": "acos", "arcsin": "asin", "arctan": "atan", "conj": "conjugate", "abs": "Abs", "int": "integrate", "des": "apart" } operators = {} constants = {"i": "I", "j": "J", "inf": "oo", "ipi": "I*pi", "e": "E"} advanced = { "Laplace": lambda __wild_sym__: laplace_transform(parse_expr(str(__wild_sym__)), parse_expr("t"), parse_expr("s"), noconds=True), "Linv": lambda __wild_sym__: inverse_laplace_transform(parse_expr( str(__wild_sym__)), parse_expr("s"), parse_expr("t"), noconds=True), "step": lambda __wild_sym__: Heaviside(__wild_sym__), "dirac": lambda __wild_sym__: DiracDelta(__wild_sym__), "sym": lambda __wild_sym__: Symbol(str(__wild_sym__)), } advanced["L"] = advanced["Laplace"] return fcts, operators, constants, advanced
def test_init(self): C_0, C_1 = symbols('C_0 C_1') state_vector = [C_0, C_1] t = Symbol('t') input_fluxes = { 0: Piecewise((1, t <= 1), (0, True)) + 1 * DiracDelta(3 - t), 1: Piecewise( (2, t <= 2), (0, True)) + 2 * DiracDelta(3 - t) + 4 * DiracDelta(4 - t) } output_fluxes = {0: 1 * C_0, 1: 1 * C_1} internal_fluxes = {} rm = ReservoirModel(state_vector, t, input_fluxes, output_fluxes, internal_fluxes) times = np.linspace(0, 5, 11) start_values = [5, 3] mr = ModelRun(rm, start_values=start_values, times=times) ref_split_data = [{ 'intensity': [0, 0], 'times': [0.0, 0.5, 1.0] }, { 'intensity': [0, 0], 'times': [1.0, 1.5, 2.0] }, { 'intensity': [0, 0], 'times': [2.0, 2.5, 3.0] }, { 'intensity': [1, 2], 'times': [3.0, 3.5, 4.0] }, { 'intensity': [0, 4], 'times': [4.0, 4.5, 5.0] }] self.assertTrue(mr.split_data, ref_split_data)
def __init__(self, state_vector, time_symbol, input_fluxes, output_fluxes, internal_fluxes, units=None, time_unit=None): self.state_vector = state_vector self.state_variables = [sv.name for sv in state_vector] self.time_symbol = time_symbol #self.output_fluxes = output_fluxes #self.internal_fluxes = internal_fluxes self.units = units self.time_unit = time_unit #self.input_fluxes = input_fluxes clean_input_fluxes = {} impulsive_input_fluxes = {} jump_times = [] impulsive_fluxes = {} for (input_pool, flux) in input_fluxes.items(): impulses, jumps = parse_input_function(flux, time_symbol) jump_times += jumps clean_flux = flux for impulse in impulses: impulse_time = impulse['time'] intensity = impulse['intensity'] clean_flux -= intensity * DiracDelta(-time_symbol + impulse_time) if not impulse_time in impulsive_fluxes.keys(): impulsive_fluxes[impulse_time] = {} impulsive_fluxes[impulse_time][input_pool] = intensity clean_input_fluxes[input_pool] = clean_flux self.clean_model = SmoothReservoirModel(state_vector, time_symbol, clean_input_fluxes, output_fluxes, internal_fluxes, units, time_unit) self.jump_times = sorted(set(jump_times)) self.impulsive_fluxes = impulsive_fluxes
def test_plot_sols(self): C_0, C_1 = symbols('C_0 C_1') state_vector = [C_0, C_1] t = Symbol('t') input_fluxes = { 0: Piecewise((1, t <= 1), (0, True)) + 1 * DiracDelta(3 - t), 1: Piecewise( (2, t <= 2), (0, True)) + 2 * DiracDelta(3 - t) + 4 * DiracDelta(4 - t) } output_fluxes = {0: 1 * C_0, 1: 1 * C_1 / (C_0 + 1)} internal_fluxes = {(0, 1): 1 * C_1} rm = ReservoirModel(state_vector, t, input_fluxes, output_fluxes, internal_fluxes) times = np.linspace(0, 10, 1001) start_values = [5, 0] mr = ModelRun(rm, start_values=start_values, times=times) fig = plt.figure() mr.plot_sols(fig) fig.savefig('testfig.pdf')
def doit(self, evaluate=True, **kwargs): expr, condition = self.expr, self.condition if condition is not None: # Recompute on new conditional expr expr = given(expr, condition, **kwargs) if not random_symbols(expr): return Lambda(x, DiracDelta(x - expr)) if (isinstance(expr, RandomSymbol) and hasattr(expr.pspace, 'distribution') and isinstance(pspace(expr), SinglePSpace)): return expr.pspace.distribution result = pspace(expr).compute_density(expr, **kwargs) if evaluate and hasattr(result, 'doit'): return result.doit() else: return result
def test_inverse_laplace_transform_delta(): from sympy import DiracDelta ILT = inverse_laplace_transform t = symbols('t') assert ILT(2, s, t) == 2*DiracDelta(t) assert ILT(2*exp(3*s) - 5*exp(-7*s), s, t) == \ 2*DiracDelta(t + 3) - 5*DiracDelta(t - 7) a = cos(sin(7)/2) assert ILT(a*exp(-3*s), s, t) == a*DiracDelta(t - 3) assert ILT(exp(2*s), s, t) == DiracDelta(t + 2) r = Symbol('r', real=True) assert ILT(exp(r*s), s, t) == DiracDelta(t + r)
def _eval_commutator_MultiBosonOp(self, other, **hints): if (self.name == other.name and self.normalization_type == other.normalization_type): if not self.is_annihilation and other.is_annihilation: if self.normalization_type == 'discrete': return -KroneckerDelta(self.mode, other.mode) elif self.normalization_type == 'continuous': return -DiracDelta(self.mode - other.mode) elif not self.is_annihilation and not other.is_annihilation: return Integer(0) elif self.is_annihilation and other.is_annihilation: return Integer(0) elif 'independent' in hints and hints['independent']: # [a, b] = 0 return Integer(0) return None
def JacM(t, y, *args): σ, β, γ, α, Λ, μ, ξ, κ, κ_old, τ_ξ, τ_σ, N, N_old, time, Is, Ss, Rs, pre, i, Es, Ds = args xx, yy = sp.symbols('xx yy') S = y[0] E = y[1] I = y[2] R = y[3] D = y[4] Dv = mv(sp.integrate(DiracDelta(xx), (xx, 0.0, R - τ_ξ)), pre) return [[ I * β * σ / N - I * β / N - μ, 0, S * β * σ / N - S * β / N, ξ * Dv, 0 ], [-I * β * σ / N + I * β / N, -α - μ, -S * β * σ / N + S * β / N, 0, 0], [ 0, α + μ, -γ * (N_old * (1 - κ_old) + (1 - N_old) * (1 - κ)) - γ - μ, 0, 0 ], [0, 0, γ + μ, -μ - ξ * Dv, 0], [0, 0, γ * (N_old * (1 - κ_old) + (1 - N_old) * (1 - κ)), 0, 0]]
def replace_dirac_delta(e, _n=0): """ Look for Integral of the form ∫ exp(I*k*x) dx and replace with 2*pi*DiracDelta(k) """ if _n > 20: warnings.warn("Too high level or recursion, aborting") return e if isinstance(e, Add): return Add(*[replace_dirac_delta(arg, _n=_n + 1) for arg in e.args]) if isinstance(e, Mul): return Mul(*[replace_dirac_delta(arg, _n=_n + 1) for arg in e.args]) if isinstance(e, Sum): nargs = [replace_dirac_delta(e.function, _n=_n + 1)] for lim in e.limits: nargs.append(lim) return Sum(*nargs) if isinstance(e, Integral): func = simplify(e.function) lims = e.limits if isinstance(func, exp) and len( lims[0]) == 3: # works only for definite integrals ex_s = simplify(func.exp) dvar, xa, xb = lims[0] if (isinstance(ex_s, Mul) and all([x in ex_s.args for x in [I, dvar]]) and (xa, xb) == (-oo, oo)): nvar = ex_s / (I * dvar) new_func = 2 * pi * DiracDelta(nvar) if len(lims) == 1: return new_func else: nargs = [new_func] for i in range(1, len(lims)): nargs.append(lims[i]) return Integral(*nargs) else: nargs = [replace_dirac_delta(e.function, _n=_n + 1)] for lim in e.limits: nargs.append(lim) return Integral(*nargs) return e
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))