Symbolsk utregning (CAS)#

Bruk av CAS (Computer Algebra System) i Python#

Her er en liten oversikt over hva du kan gjøre i CAS-verktøyet i Python. Det stjernemerkede stoffet er for spesielt interesserte, og er ikke pensum.

from sympy import *

#x = symbols("x")
#y = symbols("y")

x, y = symbols("x y") #Definerer symboler/variabler
uttrykk = x + 2*y*x   #Definerer et uttrykk

Faktorisering#

factor(uttrykk)
\[\displaystyle x \left(2 y + 1\right)\]

Løse likninger#

\(x^2 - 4 = 0\). Løs med hensyn på x.

solve(x**2 - 4, x) # Kan utelate x her, fordi vi ikke har andre bokstaver i uttrykket

[-2, 2]

Løse likningssett#

Vi kan løse likningssett som er lineære ved å bruke funksjonen solve, og ikke-lineære likningssett ved å erstatte solve med nonlinsolve. Prinsippet er det samme.

from sympy import *

x,y,z = symbols('x,y,z')
likning1 = Eq(x + 2*y + 3*z, 6)
likning2 = Eq(y + 2*z, 2)
likning3 = Eq(x + 6*y + 2*z, 5) 
resultat = solve([likning1, likning2, likning3],(x,y,z)) # Bruker nonlinsolve ved ikke-lineære likninger
resultat

{x: 3, y: 0, z: 1}

Derivere#

Deriver \(x + 2yx\) med hensyn på x.

diff(uttrykk, x)
\[\displaystyle 2 y + 1\]

Difflikninger#

\(y'' - y = e^x\).

y = Function('y')
t = symbols('t')
difflikning = Eq(y(t).diff(t, t) - y(t), exp(t))
dsolve(difflikning, y(t))
\[\displaystyle y{\left(t \right)} = C_{2} e^{- t} + \left(C_{1} + \frac{t}{2}\right) e^{t}\]

Integrere (for elever med R2)*#

\[\int 4x^3 dx\]
uttrykk2 = 4*x**3
integrate(uttrykk2, x)
\[\displaystyle x^{4}\]

Bestemt integrasjon:

\[\int_{-\infty}^{\infty} cos(x^2) dx\]
integrate(cos(x**2), (x, -oo, oo))
\[\displaystyle \frac{\sqrt{2} \sqrt{\pi}}{2}\]

Vektorregning (R1 og R2)*#

For vektorregning anbefaler jeg å bruke innebygde numpy-funksjoner (ikke CAS):

import numpy as np

vektor1 = np.array([1,-1,0])
vektor2 = np.array([2,2,3])

prikkprodukt = np.dot(vektor1, vektor2) # Skalarprodukt
kryssprodukt = np.cross(vektor1, vektor2) # Vektorprodukt

Det er også mulig å bruke CAS-verktøyet i sympy:

from sympy.vector import CoordSys3D
N = CoordSys3D('N') # Lager et kartesisk koordinatsystem å plassere vektorene i
# N.i, N.j og N.k er basisvektorer i det kartesiske rommet

# Lager vektoren v = [2, 3, 4]
v = 2*N.i + 3*N.j + 4*N.k
# Lager vektoren v = [1, 2, 1]
u = N.i + 2*N.j + N.k

# Enkel vektoraddisjon
u + v
\[\displaystyle (3)\mathbf{\hat{i}_{N}} + (5)\mathbf{\hat{j}_{N}} + (5)\mathbf{\hat{k}_{N}}\]
v.cross(u) # Vektorprodukt
\[\displaystyle (-5)\mathbf{\hat{i}_{N}} + (2)\mathbf{\hat{j}_{N}} + \mathbf{\hat{k}_{N}}\]
v.dot(u) # Skalarprodukt
\[\displaystyle 12\]

Matematikk for spesielt interesserte**#

Nedenfor ser du eksempler på hvordan en kan gjøre litt lineær algebra og finne Taylor-rekker. Dette er ekstrastoff for de som allerede har litt kjennskap til matematikk på universitetsnivå.

Matriseregning** (lineær algebra)#

matrise = Matrix([[1,2],[3,4]])
matrise
\[\begin{split}\displaystyle \left[\begin{matrix}1 & 2\\3 & 4\end{matrix}\right]\end{split}\]
matrise.row(0)
# matrise.col(0)
\[\displaystyle \left[\begin{matrix}1 & 2\end{matrix}\right]\]
matrise.T # Transponer matrisen
matrise.rref() # Radreduser
matrise.eigenvals() # Egenverdier
matrise.eigenvects() # Egenvektorer
matrise.diagonalize() # Diagonalisering
matrise.det() # Determinanten
\[\displaystyle -2\]

Du kan også bruke numpy-biblioteket til lineær algebra:

m1 = np.array([[1,2],[3,4]])
m2 = np.array([[3,3],[5,5]])
egenverdi = np.linalg.eig(m1) # Egenverdier og egenvektorer
norm = np.linalg.norm(m1)
determinant = np.linalg.det(m1)
invers = np.linalg.inv(m1)
likning = np.linalg.solve(m1, m2)
likning2 = np.linalg.tensorsolve(m1, m2[:,0]) # Løser ax = b for x

Taylor-rekker**#

funksjon = exp(x)
funksjon.series(x, 0, 5)
\[\displaystyle 1 + x + \frac{x^{2}}{2} + \frac{x^{3}}{6} + \frac{x^{4}}{24} + O\left(x^{5}\right)\]
f = 1/cos(x)
f.series(x, 0, 10)
\[\displaystyle 1 + \frac{x^{2}}{2} + \frac{5 x^{4}}{24} + \frac{61 x^{6}}{720} + \frac{277 x^{8}}{8064} + O\left(x^{10}\right)\]