import sympy as sp
sp.init_printing()
# for older SymPy versions:
#%load_ext sympy.interactive.ipythonprinting
# for even older IPython/SymPy versions:
#%load_ext sympyprinting
x, y = sp.symbols("x y")
(sp.pi + x) ** 2
expr = ((x + y)**2 * (x + 1))
expr
sp.expand(expr)
sp.diff(sp.cos(x**2)**2 / (1 + x), x)
x = sp.symbols('x', positive=True)
x > 0
sp.sqrt(x ** 2)
sp.sqrt(y ** 2)
sp.exp(sp.I * sp.pi)
sp.oo
a, b, c = sp.symbols("a, b, c")
sp.expand(sp.sin(a + b))
sp.expand(sp.sin(a + b), trig=True)
sp.simplify(sp.sin(x)**2 + sp.cos(x)**2)
sp.factor(x**3 + 6 * x**2 + 11*x + 6)
sp.simplify(sp.cos(x) / sp.sin(x))
expr1 = 1 / ((a + 1) * (a + 2))
expr1
expr1.is_rational_function()
True
sp.apart(expr1)
z = sp.symbols('z')
f = sp.sin(x * y) + sp.cos(y * z)
f
sp.integrate(f, x)
sp.integrate(f, y)
sp.integrate(sp.exp(-x**2), x)
sp.integrate(sp.exp(-x**2), (x, -sp.oo, sp.oo))
sp.integrate(x + sp.sinh(x), x)
sp.diff(_, x)
sp.limit(sp.sin(sp.pi * x) / x, x, 0)
4 * sp.atan(1)
n = sp.symbols('n')
expr = (-1)**n / (2 * n + 1)
expr
sp.summation(expr, (n, 0, sp.oo))
sp.series(sp.atan(x), x, n=13)
expr = 1 / (x + y)
expr
expr.series(x)
sp.series(sp.exp(x), x)
sp.summation(1 / sp.factorial(n), (n, 0, sp.oo))
expr = (1 + 1/n) ** n
expr
sp.limit(expr, n, sp.oo)
sp.pi.evalf(100)
sp.solve(x**4 - x**2 - 1, x)
sp.solve([x + y - 1, x - y - 1], [x,y])
sp.solve([x + y - a, x - y - c], [x,y])
sp.symbols('m:q')
sp.symbols('r:5')
m = sp.symbols('m')
M = sp.Matrix([[1, m], [3, 4]])
M
M.inv()
A = sp.Matrix(sp.symbols("m:2:2")).reshape(2, 2)
A
A[1, 0]
b = sp.Matrix(sp.symbols("b:2"))
b
A**2
A * b
A.det()
A.inv()
M = sp.Matrix(4, 4, lambda i, j: i * j + 1)
M
M.eigenvals()
M = sp.Matrix(4, 4, lambda i, j: i * j + 2)
M
M.eigenvals()
M = sp.Matrix(4, 4, lambda i, j: i * j + 3)
M
M.eigenvals()
x = sp.symbols('x')
M = sp.Matrix(4, 4, lambda i, j: i * j + x)
M
M.eigenvals()
f = sp.Piecewise((0, x <= -1), (sp.Rational(1, 2), x < 1), (0, True))
f
#sp.integrate(f.subs(x, x - y) * f(x), y)
sp.integrate(sp.Heaviside(x + 1) / 2 - sp.Heaviside(x - 1) / 2, (x, -10, -5))
q = sp.Piecewise((0, x < 0), (x, x < 1), (0, True))
q
q.args
f = sp.Lambda(x, sp.exp(-x**2))
f
conv = sp.Integral(f(x-y)*f(y), (y, -sp.oo, sp.oo))
conv
conv.subs(x, 0)
l = sp.lambdify(x, sp.Integral(f(x), (x, -sp.oo, sp.oo)))
#l(3) # doesn't work!
l
<function numpy.<lambda>>
l = sp.lambdify(x, sp.Integral(f(x), (x, -sp.oo, sp.oo)), "sympy")
l
<function <lambda>>
l(x)
# Convolute two "one-piece" functions. Arguments F and G
# are tuples in form (h(x) , a_h, b_h), where h(x) is
# the function and [a_h, b_h) is the range where the functions
# are non-zero.
def convolute_onepiece(x, F, G):
f, a_f, b_f = F
g, a_g, b_g = G
f = sp.S(f)
g = sp.S(g)
# make sure ranges are in order, swap values if necessary
if b_f - a_f > b_g - a_g:
f, a_f, b_f, g, a_g, b_g = g, a_g, b_g, f, a_f, b_f
y = sp.Dummy('y')
i = sp.integrate(f.subs(x, y) * g.subs(x, x-y), y)
return [
(i.subs(y, x-a_g) - i.subs(y, a_f), a_f+a_g, b_f+a_g),
(i.subs(y, b_f) - i.subs(y, a_f), b_f+a_g, a_f+b_g),
(i.subs(y, b_f) - i.subs(y, x-b_g), a_f+b_g, b_f+b_g) ]
# Two "flat" functions, uniform centered PDFs
F = 0.5, -1, 1
G = 0.05, -10, 10
convolute_onepiece(sp.abc.x, F, G)
from sympy import Derivative as D
x, y, z, t = sp.symbols("x y z t")
c = sp.symbols("c", real=True)
Phi = sp.Function('Phi')
F, R, T, X, Y, Z, u = map(sp.Function, 'FRTXYZu')
r, theta, z = sp.symbols('r theta z')
eq = sp.Eq(D(F(x, y, z), x) + D(F(x, y, z), y) + D(F(x, y, z), z))
eq
sp.pde_separate_mul(eq, F(x, y, z), [Y(y), u(x, z)])
sp.pde_separate_mul(eq, F(x, y, z), [X(x), Y(y), Z(z)])
# wave equation
wave = sp.Eq(D(u(x, t), t, t), c**2*D(u(x, t), x, x))
wave
sp.pde_separate_mul(wave, u(x, t), [X(x), T(t)])
# Laplace equation in cylindrical coords
eq = sp.Eq(1/r * D(Phi(r, theta, z), r) + D(Phi(r, theta, z), r, 2) +
1/r**2 * D(Phi(r, theta, z), theta, 2) + D(Phi(r, theta, z), z, 2))
eq
# Separate z
sp.pde_separate_mul(eq, Phi(r, theta, z), [Z(z), u(theta, r)])
# Lets use the result to create a new equation...
eq = sp.Eq(_[1], c)
eq
# ...and separate theta...
sp.pde_separate_mul(eq, u(theta, r), [T(theta), R(r)])
# ...or r...
sp.pde_separate_mul(eq, u(theta, r), [R(r), T(theta)])