blocks-from-sympy-doc.org

General

from sympy import *

x = symbols('x')
a = Integral(cos(x)*exp(x), x)
a.doit()

sqrt(3)

y = symbols('y')
expr = x + 2*y
expr-x

expanded = expand(x*expr)
expanded

factor(expanded)

diff(cos(x)*exp(x), x)

integrate(exp(x)*sin(x) + exp(x)*cos(x),x)

integrate(sin(x**2), (x, -oo, oo))

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

solve(x**2 - 2, x)

solve(x**2 - 2, x)

y = Function(’y’)
t = symbols('t')
dsolve(Eq(y(t).diff(t, t) - y(t), exp(t)), y(t))

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

besselj(nu, z).rewrite(jn)

latex(Integral(cos(x)**2, (x, 0, pi)))

expr = x + 1
expr.subs(x, 2)

Matrices

M = Matrix([[1, 3], [-2, 3]])
N = Matrix([[0, 3], [0, 7]])
M+N,M*N,M**2,M**-1,M.T

p = M.charpoly(x)
factor(p)

p.subs(x,0)

Permutations

a*b means a is applied first.

from sympy.combinatorics import Permutation 
a = Permutation([0, 2, 1])
b = Permutation([1, 2, 0])
a,b,a*b

Groups

see http://docs.sympy.org/latest/modules/combinatorics/named_groups.html

from sympy.combinatorics.named_groups import SymmetricGroup

G=SymmetricGroup(3)
list(G.elements)

def char_function(G, g, i, j):
    elems = list(G.elements)
    n = len(elems)
    if g*elems[i] == elems[j]:
        return 1
    else:
        return 0

def regular_representation(G):
    elems = list(G.elements)
    n = len(elems)
    def char_function(i, j):
        if elems[i]*g == elems[j]:
            return 1
        else:
            return 0
    mydict = {}
    for g in elems:
        mydict[g] = Matrix(n, n, char_function)
    return mydict

from sympy.combinatorics.named_groups import DihedralGroup
#H=SymmetricGroup(3)
H=DihedralGroup(4)
rep=regular_representation(H)
len(H.elements)

for g in list(H.elements):
    for h in list(H.elements):
        if rep[g*h] != rep[g]*rep[h]:
            print(g,h,"Wrong!")
        else:
            print(g,h,"Correct!")

rep[list(H.elements)[0]]