import sympy

sympy.init_printing()

from sympy import I, oo, pi

x = sympy.Symbol("x")

y = sympy.Symbol("y", real=True)

y.is_real

x.is_real is None

sympy.Symbol("z", imaginary=True).is_real

x = sympy.Symbol("x")

y = sympy.Symbol("y", positive=True)

sympy.sqrt(x**2)

sympy.sqrt(y**2)

n1, n2, n3 = (
    sympy.Symbol("n"),
    sympy.Symbol("n", integer=True),
    sympy.Symbol("n", odd=True),
)

sympy.cos(n1 * pi)

sympy.cos(n2 * pi)

sympy.cos(n3 * pi)

a, b, c = sympy.symbols("a, b, c", negative=True)

d, e, f = sympy.symbols("d, e, f", positive=True)

i = sympy.Integer(19)

"i = {} [type {}]".format(i, type(i))

i.is_Integer, i.is_real, i.is_odd

f = sympy.Float(2.3)

"f = {} [type {}]".format(f, type(f))

f.is_Integer, f.is_real, f.is_odd

i, f = sympy.sympify(19), sympy.sympify(2.3)

type(i)

type(f)

n = sympy.Symbol("n", integer=True)

n.is_integer, n.is_Integer, n.is_positive, n.is_Symbol

i = sympy.Integer(19)

i.is_integer, i.is_Integer, i.is_positive, i.is_Symbol

i**50

sympy.factorial(100)

"%.25f" % 0.3  # create a string represention with 25 decimals

sympy.Float(0.3, 25)

sympy.Float("0.3", 25)

sympy.Rational(11, 13)

r1 = sympy.Rational(2, 3)

r2 = sympy.Rational(4, 5)

r1 * r2

r1 / r2

x, y, z = sympy.symbols("x, y, z")

f = sympy.Function("f")

type(f)

f(x)

g = sympy.Function("g")(x, y, z)

g

g.free_symbols

sympy.sin

sympy.sin(x)

sympy.sin(pi * 1.5)

n = sympy.Symbol("n", integer=True)

sympy.sin(pi * n)

h = sympy.Lambda(x, x**2)

h

h(5)

h(1 + x)

x = sympy.Symbol("x")

e = 1 + 2 * x**2 + 3 * x**3

e

e.args

e.args[1]

e.args[1].args[1]

e.args[1].args[1].args[0]

e.args[1].args[1].args[0].args

expr = 2 * (x**2 - x) - x * (x + 1)

expr

sympy.simplify(expr)

expr.simplify()

expr

expr = 2 * sympy.cos(x) * sympy.sin(x)

expr

sympy.trigsimp(expr)

expr = sympy.exp(x) * sympy.exp(y)

expr

sympy.powsimp(expr)

expr = (x + 1) * (x + 2)

sympy.expand(expr)

sympy.sin(x + y).expand(trig=True)

a, b = sympy.symbols("a, b", positive=True)

sympy.log(a * b).expand(log=True)

sympy.exp(I * a + b).expand(complex=True)

sympy.expand((a * b) ** x, power_exp=True)

sympy.exp(I * (a - b) * x).expand(power_exp=True)

sympy.exp((a - b) * x).expand(power_exp=True)

sympy.factor(x**2 - 1)

sympy.factor(x * sympy.cos(y) + sympy.sin(z) * x)

sympy.logcombine(sympy.log(a) - sympy.log(b))

expr = x + y + x * y * z

expr.factor()

expr.collect(x)

expr.collect(y)

expr = sympy.cos(x + y) + sympy.sin(x - y)

expr.expand(trig=True).collect([sympy.cos(x), sympy.sin(x)]).collect(
    sympy.cos(y) - sympy.sin(y)
)

sympy.apart(1 / (x**2 + 3 * x + 2), x)

sympy.together(1 / (y * x + y) + 1 / (1 + x))

sympy.cancel(y / (y * x + y))

(x + y).subs(x, y)

sympy.sin(x * sympy.exp(x)).subs(x, y)

sympy.sin(x * z).subs({z: sympy.exp(y), x: y, sympy.sin: sympy.cos})

expr = x * y + z**2 * x

values = {x: 1.25, y: 0.4, z: 3.2}

expr.subs(values)

sympy.N(1 + pi)

sympy.N(pi, 50)

(x + 1 / pi).evalf(7)

expr = sympy.sin(pi * x * sympy.exp(x))

[expr.subs(x, xx).evalf(3) for xx in range(0, 10)]

expr_func = sympy.lambdify(x, expr)

expr_func(1.0)

expr_func = sympy.lambdify(x, expr, "numpy")

import numpy as np

xvalues = np.arange(0, 10)

expr_func(xvalues)

f = sympy.Function("f")(x)

sympy.diff(f, x)

sympy.diff(f, x, x)

sympy.diff(f, x, 3)

g = sympy.Function("g")(x, y)

g.diff(x, y)

g.diff(x, 3, y, 2)  # equivalent to s.diff(g, x, x, x, y, y)

expr = x**4 + x**3 + x**2 + x + 1

expr.diff(x)

expr.diff(x, x)

expr = (x + 1) ** 3 * y**2 * (z - 1)

expr.diff(x, y, z)

expr = sympy.sin(x * y) * sympy.cos(x / 2)

expr.diff(x)

expr = sympy.functions.special.polynomials.hermite(x, 0)

expr.diff(x).doit()

d = sympy.Derivative(sympy.exp(sympy.cos(x)), x)

d

d.doit()

a, b = sympy.symbols("a, b")
x, y = sympy.symbols("x, y")
f = sympy.Function("f")(x)

sympy.integrate(f)

sympy.integrate(f, (x, a, b))

sympy.integrate(sympy.sin(x))

sympy.integrate(sympy.sin(x), (x, a, b))

sympy.integrate(sympy.exp(-(x**2)), (x, 0, oo))

a, b, c = sympy.symbols("a, b, c", positive=True)

sympy.integrate(a * sympy.exp(-(((x - b) / c) ** 2)), (x, -oo, oo))

sympy.integrate(sympy.sin(x * sympy.cos(x)))

expr = sympy.sin(x * sympy.exp(y))

sympy.integrate(expr, x)

expr = (x + y) ** 2

sympy.integrate(expr, x)

sympy.integrate(expr, x, y)

sympy.integrate(expr, (x, 0, 1), (y, 0, 1))

x = sympy.Symbol("x")

f = sympy.Function("f")(x)

sympy.series(f, x)

x0 = sympy.Symbol("{x_0}")

f.series(x, x0, n=2)

f.series(x, x0, n=2).removeO()

sympy.cos(x).series()

sympy.sin(x).series()

sympy.exp(x).series()

(1 / (1 + x)).series()

expr = sympy.cos(x) / (1 + sympy.sin(x * y))

expr.series(x, n=4)

expr.series(y, n=4)

expr.series(y).removeO().series(x).removeO().expand()

sympy.limit(sympy.sin(x) / x, x, 0)

f = sympy.Function("f")
x, h = sympy.symbols("x, h")

diff_limit = (f(x + h) - f(x)) / h

sympy.limit(diff_limit.subs(f, sympy.cos), h, 0)

sympy.limit(diff_limit.subs(f, sympy.sin), h, 0)

expr = (x**2 - 3 * x) / (2 * x - 2)

p = sympy.limit(expr / x, x, oo)

q = sympy.limit(expr - p * x, x, oo)

p, q

n = sympy.symbols("n", integer=True)

x = sympy.Sum(1 / (n**2), (n, 1, oo))

x

x.doit()

x = sympy.Product(n, (n, 1, 7))

x

x.doit()

x = sympy.Symbol("x")

sympy.Sum((x) ** n / (sympy.factorial(n)), (n, 1, oo)).doit().simplify()

x = sympy.symbols("x")

sympy.solve(x**2 + 2 * x - 3)

a, b, c = sympy.symbols("a, b, c")

sympy.solve(a * x**2 + b * x + c, x)

sympy.solve(sympy.sin(x) - sympy.cos(x), x)

sympy.solve(sympy.exp(x) + 2 * x, x)

sympy.solve(x**5 - x**2 + 1, x)

1  # s.solve(s.tan(x) - x, x)

eq1 = x + 2 * y - 1
eq2 = x - y + 1

sympy.solve([eq1, eq2], [x, y], dict=True)

eq1 = x**2 - y
eq2 = y**2 - x

sols = sympy.solve([eq1, eq2], [x, y], dict=True)

sols

[eq1.subs(sol).simplify() == 0 and eq2.subs(sol).simplify() == 0 for sol in sols]

sympy.Matrix([1, 2])

sympy.Matrix([[1, 2]])

sympy.Matrix([[1, 2], [3, 4]])

sympy.Matrix(3, 4, lambda m, n: 10 * m + n)

a, b, c, d = sympy.symbols("a, b, c, d")

M = sympy.Matrix([[a, b], [c, d]])

M

M * M

x = sympy.Matrix(sympy.symbols("x_1, x_2"))

M * x

p, q = sympy.symbols("p, q")

M = sympy.Matrix([[1, p], [q, 1]])

M

b = sympy.Matrix(sympy.symbols("b_1, b_2"))

b

x = M.solve(b)
x

x = M.LUsolve(b)

x

x = M.inv() * b

x