def test_euler_interface(): x = Function('x') y = Symbol('y') t = Symbol('t') pytest.raises(TypeError, lambda: euler()) pytest.raises(TypeError, lambda: euler(diff(x(t), t)*y(t), [x(t), y])) pytest.raises(ValueError, lambda: euler(diff(x(t), t)*x(y), [x(t), x(y)])) pytest.raises(TypeError, lambda: euler(diff(x(t), t)**2, x(0))) pytest.raises(TypeError, lambda: euler(1, y)) assert euler(diff(x(t), t)**2/2, {x(t)}) == [Eq(-diff(x(t), t, t), 0)] assert euler(diff(x(t), t)**2/2, x(t), {t}) == [Eq(-diff(x(t), t, t), 0)]
def test_pde_separate_add(): x, y, z, t = symbols("x,y,z,t") F, T, X, Y, Z, u = map(Function, 'FTXYZu') eq = Eq(diff(u(x, t), x), diff(u(x, t), t) * exp(u(x, t))) res = pde_separate_add(eq, u(x, t), [X(x), T(t)]) assert res == [diff(X(x), x) * exp(-X(x)), diff(T(t), t) * exp(T(t))] eq = Eq(u(x, y).diff(x), -exp(u(x, y).diff(y))) res = pde_separate_add(eq, u(x, y), [X(x), Y(y)]) assert res == [diff(X(x), x), -exp(diff(Y(y), y))]
def test_dice(): # TODO: Make iid method! X, Y, Z = Die('X', 6), Die('Y', 6), Die('Z', 6) a, b = symbols('a b') assert E(X) == 3 + Rational(1, 2) assert variance(X) == Rational(35, 12) assert E(X + Y) == 7 assert E(X + X) == 7 assert E(a * X + b) == a * E(X) + b assert variance(X + Y) == variance(X) + variance(Y) == cmoment(X + Y, 2) assert variance(X + X) == 4 * variance(X) == cmoment(X + X, 2) assert cmoment(X, 0) == 1 assert cmoment(4 * X, 3) == 64 * cmoment(X, 3) assert covariance(X, Y) == 0 assert covariance(X, X + Y) == variance(X) assert density(Eq(cos(X * pi), 1))[True] == Rational(1, 2) assert correlation(X, Y) == 0 assert correlation(X, Y) == correlation(Y, X) assert smoment(X + Y, 3) == skewness(X + Y) assert smoment(X, 0) == 1 assert P(X > 3) == Rational(1, 2) assert P(2 * X > 6) == Rational(1, 2) assert P(X > Y) == Rational(5, 12) assert P(Eq(X, Y)) == P(Eq(X, 1)) assert E(X, X > 3) == 5 == moment(X, 1, 0, X > 3) assert E(X, Y > 3) == E(X) == moment(X, 1, 0, Y > 3) assert E(X + Y, Eq(X, Y)) == E(2 * X) assert moment(X, 0) == 1 assert moment(5 * X, 2) == 25 * moment(X, 2) assert P(X > 3, X > 3) == 1 assert P(X > Y, Eq(Y, 6)) == 0 assert P(Eq(X + Y, 12)) == Rational(1, 36) assert P(Eq(X + Y, 12), Eq(X, 6)) == Rational(1, 6) assert density(X + Y) == density(Y + Z) != density(X + X) d = density(2 * X + Y**Z) assert d[22] == Rational(1, 108) and d[4100] == Rational( 1, 216) and 3130 not in d assert pspace(X).domain.as_boolean() == Or( *[Eq(X.symbol, i) for i in [1, 2, 3, 4, 5, 6]]) assert where(X > 3).set == FiniteSet(4, 5, 6) X = Die('X', 2) x = X.symbol assert X.pspace.compute_cdf(X) == {1: Rational(1, 2), 2: 1} assert X.pspace.sorted_cdf(X) == [(1, Rational(1, 2)), (2, 1)] assert X.pspace.compute_density(X)(1) == Rational(1, 2) assert X.pspace.compute_density(X)(0) == 0 assert X.pspace.compute_density(X)(8) == 0 assert X.pspace.density == x
def test_m_loops(): # Note: an Octave programmer would probably vectorize this across one or # more dimensions. Also, size(A) would be used rather than passing in m # and n. Perhaps users would expect us to vectorize automatically here? # Or is it possible to represent such things using IndexedBase? n, m = symbols('n m', integer=True) A = IndexedBase('A') x = IndexedBase('x') y = IndexedBase('y') i = Idx('i', m) j = Idx('j', n) result, = codegen(('mat_vec_mult', Eq(y[i], A[i, j] * x[j])), 'Octave', header=False, empty=False) source = result[1] expected = ('function y = mat_vec_mult(A, m, n, x)\n' ' for i = 1:m\n' ' y(i) = 0;\n' ' end\n' ' for i = 1:m\n' ' for j = 1:n\n' ' y(i) = %(rhs)s + y(i);\n' ' end\n' ' end\n' 'end\n') assert (source == expected % { 'rhs': 'A(%s, %s).*x(j)' % (i, j) } or source == expected % { 'rhs': 'x(j).*A(%s, %s)' % (i, j) }) result, = codegen(('mat_vec_mult', Eq(y[i], A[i, j] * x[j])), 'Octave', header=False, empty=False, argument_sequence=[x, A, m, n]) source = result[1] expected = ('function y = mat_vec_mult(x, A, m, n)\n' ' for i = 1:m\n' ' y(i) = 0;\n' ' end\n' ' for i = 1:m\n' ' for j = 1:n\n' ' y(i) = %(rhs)s + y(i);\n' ' end\n' ' end\n' 'end\n') assert (source == expected % { 'rhs': 'A(%s, %s).*x(j)' % (i, j) } or source == expected % { 'rhs': 'x(j).*A(%s, %s)' % (i, j) })
def test_deltasummation_mul_x_kd(): assert ds(x*Kd(i, j), (j, 1, 3)) == \ Piecewise((x, And(Integer(1) <= i, i <= 3)), (0, True)) assert ds(x * Kd(i, j), (j, 1, 1)) == Piecewise((x, Eq(i, 1)), (0, True)) assert ds(x * Kd(i, j), (j, 2, 2)) == Piecewise((x, Eq(i, 2)), (0, True)) assert ds(x * Kd(i, j), (j, 3, 3)) == Piecewise((x, Eq(i, 3)), (0, True)) assert ds(x*Kd(i, j), (j, 1, k)) == \ Piecewise((x, And(Integer(1) <= i, i <= k)), (0, True)) assert ds(x*Kd(i, j), (j, k, 3)) == \ Piecewise((x, And(k <= i, i <= 3)), (0, True)) assert ds(x*Kd(i, j), (j, k, l)) == \ Piecewise((x, And(k <= i, i <= l)), (0, True))
def test_sho_lagrangian(): m = Symbol('m') k = Symbol('k') x = f(t) L = m * diff(x, t)**2 / 2 - k * x**2 / 2 eqna = Eq(diff(L, x), diff(L, diff(x, t), t)) eqnb = Eq(-k * x, m * diff(x, t, t)) assert eqna == eqnb assert diff(L, x, t) == diff(L, t, x) assert diff(L, diff(x, t), t) == m * diff(x, t, 2) assert diff(L, t, diff(x, t)) == -k * x + m * diff(x, t, 2)
def test_parallel_dict_from_expr(): assert parallel_dict_from_expr([Eq(x, 1), Eq(x**2, 2)]) == ([{ (0, ): -Integer(1), (1, ): Integer(1) }, { (0, ): -Integer(2), (2, ): Integer(1) }], (x, )) pytest.raises(PolynomialError, lambda: parallel_dict_from_expr([A * B - B * A]))
def test_exceptions(): cg = OctaveCodeGen() r = cg.routine('test', Eq(y, x), argument_sequence=[x, y], global_vars=None) bad_r = Routine(r.name, [r.arguments[0], InOutArgument(y, y, y)], r.results, r.local_vars, r.global_vars) pytest.raises(CodeGenError, lambda: cg.write([bad_r], 'test')) pytest.raises(ValueError, lambda: cg.routine('test', [], None, None)) pytest.raises(CodeGenError, lambda: cg.routine('test', Eq(sin(y), x), None, None))
def test_mathml_relational(): mml_1 = mp._print(Eq(x, 1)) assert mml_1.nodeName == 'apply' assert mml_1.childNodes[0].nodeName == 'eq' assert mml_1.childNodes[1].nodeName == 'ci' assert mml_1.childNodes[1].childNodes[0].nodeValue == 'x' assert mml_1.childNodes[2].nodeName == 'cn' assert mml_1.childNodes[2].childNodes[0].nodeValue == '1' mml_2 = mp._print(Ne(1, x)) assert mml_2.nodeName == 'apply' assert mml_2.childNodes[0].nodeName == 'neq' assert mml_2.childNodes[1].nodeName == 'cn' assert mml_2.childNodes[1].childNodes[0].nodeValue == '1' assert mml_2.childNodes[2].nodeName == 'ci' assert mml_2.childNodes[2].childNodes[0].nodeValue == 'x' mml_3 = mp._print(Ge(1, x)) assert mml_3.nodeName == 'apply' assert mml_3.childNodes[0].nodeName == 'geq' assert mml_3.childNodes[1].nodeName == 'cn' assert mml_3.childNodes[1].childNodes[0].nodeValue == '1' assert mml_3.childNodes[2].nodeName == 'ci' assert mml_3.childNodes[2].childNodes[0].nodeValue == 'x' mml_4 = mp._print(Lt(1, x)) assert mml_4.nodeName == 'apply' assert mml_4.childNodes[0].nodeName == 'lt' assert mml_4.childNodes[1].nodeName == 'cn' assert mml_4.childNodes[1].childNodes[0].nodeValue == '1' assert mml_4.childNodes[2].nodeName == 'ci' assert mml_4.childNodes[2].childNodes[0].nodeValue == 'x'
def test_reduce_piecewise_inequalities(): e = abs(x - 5) < 3 ans = (Integer(2) < x) & (x < 8) assert reduce_inequalities(e) == ans assert reduce_inequalities(e, x) == ans assert reduce_inequalities(abs(x - 5)) == Eq(x, 5) assert reduce_inequalities( abs(2 * x + 3) >= 8) == ((Rational(5, 2) <= x) | (x <= -Rational(11, 2))) assert reduce_inequalities( abs(x - 4) + abs(3 * x - 5) < 7) == (Rational(1, 2) < x) & (x < 4) assert reduce_inequalities(abs(x - 4) + abs(3*abs(x) - 5) < 7) == \ ((Integer(-2) < x) & (x < -1)) | ((Rational(1, 2) < x) & (x < 4)) nr = Symbol('nr', extended_real=False) pytest.raises(TypeError, lambda: reduce_inequalities(abs(nr - 5) < 3)) # sympy/sympy#10198 assert reduce_inequalities(-1 + 1/abs(1/x - 1) < 0) == \ ((Integer(0) < x) & (x < Rational(1, 2))) | (x < 0) assert reduce_inequalities(-1 + 1/abs(-1/x - 1) < 0) == \ ((-Rational(1, 2) < x) & (x < 0)) | (Integer(0) < x) # sympy/sympy#10255 assert reduce_inequalities(Piecewise((1, x < 1), (3, True)) > 1) == \ (Integer(1) <= x) assert reduce_inequalities(Piecewise((x**2, x < 0), (2*x, True)) < 1) == \ (Integer(-1) < x) & (x < Rational(1, 2))
def test_density(): x = Symbol('x') l = Symbol('l', positive=True) rate = Beta(l, 2, 3) X = Poisson(x, rate) assert isinstance(pspace(X), ProductPSpace) assert density(X, Eq(rate, rate.symbol)) == PoissonDistribution(l)
def test_doit(): p = Symbol('p', positive=True) n = Symbol('n', negative=True) np = Symbol('np', nonpositive=True) nn = Symbol('nn', nonnegative=True) assert Gt(p, 0).doit() is true assert Gt(p, 1).doit() == Gt(p, 1) assert Ge(p, 0).doit() is true assert Le(p, 0).doit() is false assert Lt(n, 0).doit() is true assert Le(np, 0).doit() is true assert Gt(nn, 0).doit() == Gt(nn, 0) assert Lt(nn, 0).doit() is false assert Eq(x, 0).doit() == Eq(x, 0)
def test_pde_separate_add(): x, y, z, t = symbols("x,y,z,t") F, T, X, Y, Z, u = map(Function, 'FTXYZu') eq = Eq(D(u(x, t), x), D(u(x, t), t) * exp(u(x, t))) res = pde_separate_add(eq, u(x, t), [X(x), T(t)]) assert res == [D(X(x), x) * exp(-X(x)), D(T(t), t) * exp(T(t))]
def test_pde_classify(): # When more number of hints are added, add tests for classifying here. f, g = symbols('f g', cls=Function) u = f(x, y) eq1 = a * u + b * u.diff(x) + c * u.diff(y) eq2 = 3 * u + 2 * u.diff(x) + u.diff(y) eq3 = a * u + b * u.diff(x) + 2 * u.diff(y) eq4 = x * u + u.diff(x) + 3 * u.diff(y) eq5 = x**2 * u + x * u.diff(x) + x * y * u.diff(y) eq6 = y * x**2 * u + y * u.diff(x) + u.diff(y) for eq in [eq1, eq2, eq3]: assert classify_pde(eq) == ('1st_linear_constant_coeff_homogeneous', ) for eq in [eq4, eq5, eq6]: assert classify_pde(eq) == ('1st_linear_variable_coeff', ) # coverage tests assert classify_pde(eq, u) == ('1st_linear_variable_coeff', ) assert classify_pde(eq, g(x, y)) == () assert classify_pde(eq, g(x, y), dict=True) == { 'default': None, 'order': 0 } assert classify_pde(u.diff(x) + I * u.diff(y) + y) == () assert classify_pde(u.diff(x, y) + x) == () assert classify_pde(x * u.diff(x) + u * u.diff(y) + y) == () assert classify_pde(x * u.diff(x) + u * u.diff(y) + y, dict=True) == { 'default': None, 'ordered_hints': (), 'order': 1 } assert classify_pde(2 * u.diff(x, y, y)) == () eq = Eq(1 + (2 * (u.diff(x) / u)) + (3 * (u.diff(y) / u)), 0) assert classify_pde(eq) == ('1st_linear_constant_coeff_homogeneous', )
def test_reduce_piecewise_inequalities(): e = abs(x - 5) < 3 ans = And(Lt(2, x), Lt(x, 8)) assert reduce_inequalities(e) == ans assert reduce_inequalities(e, x) == ans assert reduce_inequalities(abs(x - 5)) == Eq(x, 5) assert reduce_inequalities( abs(2*x + 3) >= 8) == Or(And(Le(Rational(5, 2), x), Lt(x, oo)), And(Le(x, -Rational(11, 2)), Lt(-oo, x))) assert reduce_inequalities(abs(x - 4) + abs( 3*x - 5) < 7) == And(Lt(Rational(1, 2), x), Lt(x, 4)) assert reduce_inequalities(abs(x - 4) + abs(3*abs(x) - 5) < 7) == \ Or(And(Integer(-2) < x, x < -1), And(Rational(1, 2) < x, x < 4)) nr = Symbol('nr', extended_real=False) pytest.raises(TypeError, lambda: reduce_inequalities(abs(nr - 5) < 3)) # sympy/sympy#10198 assert reduce_inequalities(-1 + 1/abs(1/x - 1) < 0) == \ Or(And(S.Zero < x, x < S.Half), And(-oo < x, x < S.Zero)) # sympy/sympy#10255 assert reduce_inequalities(Piecewise((1, x < 1), (3, True)) > 1) == \ And(S.One <= x, x < oo) assert reduce_inequalities(Piecewise((x**2, x < 0), (2*x, x >= 0)) < 1) == \ And(-S.One < x, x < S.Half)
def deltaproduct(f, limit): """Handle products containing a KroneckerDelta. See Also ======== deltasummation diofant.functions.special.tensor_functions.KroneckerDelta diofant.concrete.products.product """ from diofant.concrete.products import product if ((limit[2] - limit[1]) < 0) is S.true: return S.One if not f.has(KroneckerDelta): return product(f, limit) if f.is_Add: # Identify the term in the Add that has a simple KroneckerDelta delta = None terms = [] for arg in sorted(f.args, key=default_sort_key): if delta is None and _has_simple_delta(arg, limit[0]): delta = arg else: terms.append(arg) newexpr = f.func(*terms) k = Dummy("kprime", integer=True) if isinstance(limit[1], int) and isinstance(limit[2], int): result = deltaproduct(newexpr, limit) + sum( deltaproduct(newexpr, (limit[0], limit[1], ik - 1)) * delta.subs(limit[0], ik) * deltaproduct(newexpr, (limit[0], ik + 1, limit[2])) for ik in range(int(limit[1]), int(limit[2] + 1))) else: result = deltaproduct(newexpr, limit) + deltasummation( deltaproduct(newexpr, (limit[0], limit[1], k - 1)) * delta.subs(limit[0], k) * deltaproduct(newexpr, (limit[0], k + 1, limit[2])), (k, limit[1], limit[2]), no_piecewise=_has_simple_delta(newexpr, limit[0])) return _remove_multiple_delta(result) delta, _ = _extract_delta(f, limit[0]) if not delta: g = _expand_delta(f, limit[0]) if f != g: from diofant import factor try: return factor(deltaproduct(g, limit)) except AssertionError: return deltaproduct(g, limit) return product(f, limit) from diofant import Eq c = Eq(limit[2], limit[1] - 1) return _remove_multiple_delta(f.subs(limit[0], limit[1])*KroneckerDelta(limit[2], limit[1])) + \ S.One*_simplify_delta(KroneckerDelta(limit[2], limit[1] - 1))
def test_m_tensor_loops_multiple_contractions(): # see comments in previous test about vectorizing n, m, o, p = symbols('n m o p', integer=True) A = IndexedBase('A') B = IndexedBase('B') y = IndexedBase('y') i = Idx('i', m) j = Idx('j', n) k = Idx('k', o) l = Idx('l', p) result, = codegen(('tensorthing', Eq(y[i], B[j, k, l] * A[i, j, k, l])), 'Octave', header=False, empty=False) source = result[1] expected = ('function y = tensorthing(A, B, m, n, o, p)\n' ' for i = 1:m\n' ' y(i) = 0;\n' ' end\n' ' for i = 1:m\n' ' for j = 1:n\n' ' for k = 1:o\n' ' for l = 1:p\n' ' y(i) = y(i) + B(j, k, l).*A(i, j, k, l);\n' ' end\n' ' end\n' ' end\n' ' end\n' 'end\n') assert source == expected
def test_deltasummation_mul_x_add_y_kd(): assert ds(x*(y + Kd(i, j)), (j, 1, 3)) == \ Piecewise((3*x*y + x, And(Integer(1) <= i, i <= 3)), (3*x*y, True)) assert ds(x*(y + Kd(i, j)), (j, 1, 1)) == \ Piecewise((x*y + x, Eq(i, 1)), (x*y, True)) assert ds(x*(y + Kd(i, j)), (j, 2, 2)) == \ Piecewise((x*y + x, Eq(i, 2)), (x*y, True)) assert ds(x*(y + Kd(i, j)), (j, 3, 3)) == \ Piecewise((x*y + x, Eq(i, 3)), (x*y, True)) assert ds(x*(y + Kd(i, j)), (j, 1, k)) == \ Piecewise((k*x*y + x, And(Integer(1) <= i, i <= k)), (k*x*y, True)) assert ds(x*(y + Kd(i, j)), (j, k, 3)) == \ Piecewise(((4 - k)*x*y + x, And(k <= i, i <= 3)), ((4 - k)*x*y, True)) assert ds(x * (y + Kd(i, j)), (j, k, l)) == Piecewise( ((l - k + 1) * x * y + x, And(k <= i, i <= l)), ((l - k + 1) * x * y, True))
def test_coins(): C, D = Coin('C'), Coin('D') H, T = symbols('H, T') assert P(Eq(C, D)) == Rational(1, 2) assert density(Tuple(C, D)) == {(H, H): Rational(1, 4), (H, T): Rational(1, 4), (T, H): Rational(1, 4), (T, T): Rational(1, 4)} assert dict(density(C).items()) == {H: Rational(1, 2), T: Rational(1, 2)} F = Coin('F', Rational(1, 10)) assert P(Eq(F, H)) == Rational(1, 10) d = pspace(C).domain assert d.as_boolean() == Or(Eq(C.symbol, H), Eq(C.symbol, T)) pytest.raises(ValueError, lambda: P(C > D)) # Can't intelligently compare H to T
def test_matplotlib2(): name = 'test2' plot_implicit(And(y > cos(x), Or(y > x, Eq(y, x))), show=False).save(tmp_file(name)) # Test plots which cannot be rendered using the adaptive algorithm # TODO: catch the warning. plot_implicit(Eq(y, re(cos(x) + I * sin(x))), show=False).save(tmp_file(name)) with warnings.catch_warnings(record=True) as w: plot_implicit(x**2 - 1, legend='An implicit plot', show=False).save(tmp_file(name)) assert len(w) == 1 assert issubclass(w[-1].category, UserWarning) assert 'No labelled objects found' in str(w[0].message)
def test_rewrite(): x = Symbol('x', extended_real=True) assert Heaviside(x).rewrite(Piecewise) == \ Piecewise((1, x > 0), (Rational(1, 2), Eq(x, 0)), (0, True)) assert Heaviside(y).rewrite(Piecewise) == Heaviside(y) assert Heaviside(x).rewrite(sign) == (sign(x)+1)/2 assert Heaviside(y).rewrite(sign) == Heaviside(y)
def test_euler_high_order(): # an example from hep-th/0309038 m = Symbol('m') k = Symbol('k') x = Function('x') y = Function('y') t = Symbol('t') L = (m * D(x(t), t)**2 / 2 + m * D(y(t), t)**2 / 2 - k * D(x(t), t) * D(y(t), t, t) + k * D(y(t), t) * D(x(t), t, t)) assert euler(L, [x(t), y(t)]) == [ Eq(2 * k * D(y(t), t, t, t) - m * D(x(t), t, t)), Eq(-2 * k * D(x(t), t, t, t) - m * D(y(t), t, t)) ] w = Symbol('w') L = D(x(t, w), t, w)**2 / 2 assert euler(L) == [Eq(D(x(t, w), t, t, w, w))]
def test_euler_sineg(): psi = Function('psi') t = Symbol('t') x = Symbol('x') L = D(psi(t, x), t)**2 / 2 - D(psi(t, x), x)**2 / 2 + cos(psi(t, x)) assert euler(L, psi(t, x), [t, x]) == [ Eq(-sin(psi(t, x)) - D(psi(t, x), t, t) + D(psi(t, x), x, x)) ]
def test_relational_bool_output(): # https://github.com/sympy/sympy/issues/5931 pytest.raises(TypeError, lambda: bool(x > 3)) pytest.raises(TypeError, lambda: bool(x >= 3)) pytest.raises(TypeError, lambda: bool(x < 3)) pytest.raises(TypeError, lambda: bool(x <= 3)) pytest.raises(TypeError, lambda: bool(Eq(x, 3))) pytest.raises(TypeError, lambda: bool(Ne(x, 3)))
def test_FiniteRV(): F = FiniteRV('F', {1: S.Half, 2: S.One/4, 3: S.One/4}) assert dict(density(F).items()) == {Integer(1): S.Half, Integer(2): S.One/4, Integer(3): S.One/4} assert P(F >= 2) == S.Half assert pspace(F).domain.as_boolean() == Or( *[Eq(F.symbol, i) for i in [1, 2, 3]])
def test_FiniteRV(): F = FiniteRV('F', {1: Rational(1, 2), 2: Rational(1, 4), 3: Rational(1, 4)}) assert dict(density(F).items()) == {1: Rational(1, 2), 2: Rational(1, 4), 3: Rational(1, 4)} assert P(F >= 2) == Rational(1, 2) assert pspace(F).domain.as_boolean() == Or( *[Eq(F.symbol, i) for i in [1, 2, 3]])
def test_deltasummation_basic_symbolic(): assert ds(Kd(exp(i), 0), (i, 1, 3)) == 0 assert ds(Kd(exp(i), 0), (i, -1, 3)) == 0 assert ds(Kd(exp(i), 1), (i, 0, 3)) == 1 assert ds(Kd(exp(i), 1), (i, 1, 3)) == 0 assert ds(Kd(exp(i), 1), (i, -10, 3)) == 1 assert ds(Kd(i, j), (j, 1, 3)) == \ Piecewise((1, And(Integer(1) <= i, i <= 3)), (0, True)) assert ds(Kd(i, j), (j, 1, 1)) == Piecewise((1, Eq(i, 1)), (0, True)) assert ds(Kd(i, j), (j, 2, 2)) == Piecewise((1, Eq(i, 2)), (0, True)) assert ds(Kd(i, j), (j, 3, 3)) == Piecewise((1, Eq(i, 3)), (0, True)) assert ds(Kd(i, j), (j, 1, k)) == \ Piecewise((1, And(Integer(1) <= i, i <= k)), (0, True)) assert ds(Kd(i, j), (j, k, 3)) == \ Piecewise((1, And(k <= i, i <= 3)), (0, True)) assert ds(Kd(i, j), (j, k, l)) == \ Piecewise((1, And(k <= i, i <= l)), (0, True))
def given(expr, condition=None, **kwargs): """ Conditional Random Expression From a random expression and a condition on that expression creates a new probability space from the condition and returns the same expression on that conditional probability space. Examples ======== >>> from diofant.stats import given, density, Die >>> X = Die('X', 6) >>> Y = given(X, X > 3) >>> density(Y).dict {4: 1/3, 5: 1/3, 6: 1/3} Following convention, if the condition is a random symbol then that symbol is considered fixed. >>> from diofant.stats import Normal >>> from diofant import pprint >>> from diofant.abc import z >>> X = Normal('X', 0, 1) >>> Y = Normal('Y', 0, 1) >>> pprint(density(X + Y, Y)(z), use_unicode=False) 2 -(-Y + z) ----------- ___ 2 \/ 2 *E ------------------ ____ 2*\/ pi """ if not random_symbols(condition) or pspace_independent(expr, condition): return expr if isinstance(condition, RandomSymbol): condition = Eq(condition, condition.symbol) condsymbols = random_symbols(condition) if (isinstance(condition, Equality) and len(condsymbols) == 1 and not isinstance(pspace(expr).domain, ConditionalDomain)): rv = tuple(condsymbols)[0] results = solve(condition, rv) return sum(expr.subs(rv, res) for res in results) # Get full probability space of both the expression and the condition fullspace = pspace(Tuple(expr, condition)) # Build new space given the condition space = fullspace.conditional_space(condition, **kwargs) # Dictionary to swap out RandomSymbols in expr with new RandomSymbols # That point to the new conditional space swapdict = rs_swap(fullspace.values, space.values) # Swap random variables in the expression expr = expr.xreplace(swapdict) return expr
def main(): r, phi, theta = symbols("r,phi,theta") Xi = Function('Xi') R, Phi, Theta, u = map(Function, ['R', 'Phi', 'Theta', 'u']) C1, C2 = symbols('C1,C2') pprint( "Separation of variables in Laplace equation in spherical coordinates") pprint("Laplace equation in spherical coordinates:") eq = Eq( D(Xi(r, phi, theta), r, 2) + 2 / r * D(Xi(r, phi, theta), r) + 1 / (r**2 * sin(phi)**2) * D(Xi(r, phi, theta), theta, 2) + cos(phi) / (r**2 * sin(phi)) * D(Xi(r, phi, theta), phi) + 1 / r**2 * D(Xi(r, phi, theta), phi, 2)) pprint(eq) pprint("We can either separate this equation in regards with variable r:") res_r = pde_separate(eq, Xi(r, phi, theta), [R(r), u(phi, theta)]) pprint(res_r) pprint("Or separate it in regards of theta:") res_theta = pde_separate(eq, Xi(r, phi, theta), [Theta(theta), u(r, phi)]) pprint(res_theta) res_phi = pde_separate(eq, Xi(r, phi, theta), [Phi(phi), u(r, theta)]) pprint("But we cannot separate it in regards of variable phi: ") pprint("Result: %s" % res_phi) pprint("\n\nSo let's make theta dependent part equal with -C1:") eq_theta = Eq(res_theta[0], -C1) pprint(eq_theta) pprint("\nThis also means that second part is also equal to -C1:") eq_left = Eq(res_theta[1], -C1) pprint(eq_left) pprint("\nLets try to separate phi again :)") res_theta = pde_separate(eq_left, u(r, phi), [Phi(phi), R(r)]) pprint("\nThis time it is successful:") pprint(res_theta) pprint("\n\nSo our final equations with separated variables are:") pprint(eq_theta) pprint(Eq(res_theta[0], C2)) pprint(Eq(res_theta[1], C2))
def test_integrate_hyperexponential_returns_piecewise(): a, b = symbols('a b') DE = DifferentialExtension(a**x, x) assert integrate_hyperexponential(DE.fa, DE.fd, DE) == (Piecewise( (x, Eq(log(a), 0)), (exp(x * log(a)) / log(a), True)), 0, True) DE = DifferentialExtension(a**(b * x), x) assert integrate_hyperexponential(DE.fa, DE.fd, DE) == (Piecewise( (x, Eq(b * log(a), 0)), (exp(b * x * log(a)) / (b * log(a)), True)), 0, True) DE = DifferentialExtension(exp(a * x), x) assert integrate_hyperexponential(DE.fa, DE.fd, DE) == (Piecewise( (x, Eq(a, 0)), (exp(a * x) / a, True)), 0, True) DE = DifferentialExtension(x * exp(a * x), x) assert integrate_hyperexponential(DE.fa, DE.fd, DE) == (Piecewise( (x**2 / 2, Eq(a**3, 0)), ((x * a**2 - a) * exp(a * x) / a**3, True)), 0, True) DE = DifferentialExtension(x**2 * exp(a * x), x) assert integrate_hyperexponential(DE.fa, DE.fd, DE) == (Piecewise( (x**3 / 3, Eq(a**6, 0)), ((x**2 * a**5 - 2 * x * a**4 + 2 * a**3) * exp(a * x) / a**6, True)), 0, True) DE = DifferentialExtension(x**y + z, y) assert integrate_hyperexponential(DE.fa, DE.fd, DE) == (Piecewise( (y, Eq(log(x), 0)), (exp(log(x) * y) / log(x), True)), z, True) DE = DifferentialExtension(x**y + z + x**(2 * y), y) assert integrate_hyperexponential(DE.fa, DE.fd, DE) == (Piecewise( (2 * y, Eq(2 * log(x)**2, 0)), ((exp(2 * log(x) * y) * log(x) + 2 * exp(log(x) * y) * log(x)) / (2 * log(x)**2), True)), z, True)