csomag | |
---|---|
NumPy | Hatékony N-dimenziós tömb |
SciPy | Numerikus számítások |
Matplotlib | Grafikonok és rajzok |
IPython (Jupyter) | Interaktív notebook |
SymPy | Szimbolikus számítások |
Pandas | Adatbányászat |
%matplotlib inline
import sympy as sym
import math
import numpy as np
import matplotlib.pyplot as plt
import scipy
# grafikonok stílusának beállítása
plt.rcParams['figure.figsize'] = (20, 10)
A numerikus számítások célja, hogy a matematikai számításokat végezzünk hatékonyan.
Előnyök:
Hátrányok:
Részletes tutorial: https://docs.scipy.org/doc/scipy/reference/tutorial/
A háttérben sokszor Fortran fut.
Alcsomagok:
scipy.cluster | Vector quantization / Kmeans |
scipy.constants | Physical and mathematical constants |
scipy.fftpack | Fourier transform |
scipy.integrate | Integration routines |
scipy.interpolate | Interpolation |
scipy.io | Data input and output |
scipy.linalg | Linear algebra routines |
scipy.ndimage | n-dimensional image package |
scipy.odr | Orthogonal distance regression |
scipy.optimize | Optimization |
scipy.signal | Signal processing |
scipy.sparse | Sparse matrices |
scipy.spatial | Spatial data structures and algorithms |
scipy.special | Any special mathematical functions |
scipy.stats | Statistics |
A numpy lineáris algebra csomagját bővíti ki. Pár függvény hatékonyabb a háttérben.
Adott $A$ mátrixot írjunk fel $A=LU$ alakban, ahol $L$ alsó, $U$ pedig felső háromszög mátrix.
from scipy import linalg, optimize
from scipy.linalg import lu
A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
p, l, u = lu(A)
print(A,p,l,u, sep="\n")
print(A - p @ l @ u)
np.allclose(A - p @ l @ u, np.zeros((4, 4)))
Adott $A$ mátrixot írjunk fel $A=QR$ alakban, ahol $Q$ ortogonális, $R$ pedig felső háromszög mátrix.
A = np.random.randn(4, 4)
print(A)
q, r = linalg.qr(A)
print(q,r,sep='\n')
q @ q.T
q @ r
Oldjuk meg az $Ax=y$ egyeneletet.
A=np.array([[1,2],[3,4]])
y = np.array([[5.], [7.]])
x=np.linalg.solve(A, y)
x
A @ x
Számístuk ki $\int_a^b f$ értékét.
A scipy.integrate.quad(f, a, b)
integrálja $a$-tól $b$-ig az $f$ függvényt. Két értékkel tér vissza, az inregrálás eredményével és egy hibahatárral.
import scipy.integrate
f= lambda x:2*x
i = scipy.integrate.quad(f, 0, 1)
print(i)
import scipy.integrate
def f(x):
return 2*x
i = scipy.integrate.quad(f, 0, 1)
print(i)
f= lambda x:np.exp(-x**2)
i = scipy.integrate.quad(f, 0, 1)
print(i)
## szimbolikus számítással
xval = sym.Symbol('x')
sym.integrate(sym.exp(-xval ** 2), xval)
((sym.erf(1)-sym.erf(0))*np.pi**(1/2)/2).evalf()
#sym.integrate(sym.exp(sym.sin(-sym.log(xval ** 2+xval)-xval)), xval)
f= lambda x:np.exp(np.sin(-np.log(x ** 2+x)-x))
i = scipy.integrate.quad(f, 0, 1)
print(i)
Több változóban is tudunk integrálni a scipy.integrate.dblquad(func, a, b, gfun, hfun)
paranccsal. A gfun és hfun parancsok adják meg a belső integrál határait.
f = lambda x, y : 16*x*y
g = lambda x : 0
h = lambda y : math.sqrt(1-4*y**2)
i = scipy.integrate.dblquad(f, 0, 0.5, g, h)
print(i)
A fő gondolat:
Módszerek
Mi a különbség görbe illesztés és interpoláció között?
from scipy import interpolate
xg = np.linspace(0, 4, 12)
yg = np.cos(xg**2/3+4)
print (xg,'\n\n',yg)
figure, axis = plt.subplots(1, 1,figsize=(8,8))
axis.plot(xg, yg,'o')
plt.show()
f1 = interpolate.interp1d(xg, yg,kind = 'linear')
xnew = np.linspace(0, 4,100)
figure, axis = plt.subplots(1, 1,figsize=(8,8))
axis.plot(xg, yg, 'o')
axis.plot( xnew, f1(xnew), '-')
axis.legend(['data', 'linear'], loc = 'best')
plt.show()
f2 = interpolate.interp1d(xg, yg, kind = 'cubic')
xnew = np.linspace(0, 4,100)
#plt.plot(x, y, 'o', xnew, f(xnew), '-', xnew, f2(xnew), '--')
figure, axis = plt.subplots(1, 1,figsize=(8,8))
axis.plot(xg, yg, 'o')
#axis.plot( xnew, f1(xnew), '-')
axis.plot( xnew, f2(xnew), '--')
axis.legend(['data', 'cubic'], loc = 'best')
plt.show()
f = np.poly1d([5, 1])
x = np.linspace(0, 10, 30)
y = f(x) + 6*np.random.normal(size=len(x))
xn = np.linspace(0, 10, 200)
figure, axis = plt.subplots(1, 1,figsize=(6,6))
axis.plot(x, y, 'or')
plt.show()
a = np.vstack([x, np.ones(len(x))]).T
np.dot(np.linalg.inv(np.dot(a.T, a)), np.dot(a.T, y))
np.linalg.lstsq(a, y,rcond=None)[0]
np.polyfit(x, y, 1)
m, c = np.polyfit(x, y, 1)
yn = np.polyval([m, c], xn)
figure, axis = plt.subplots(1, 1,figsize=(6,6))
axis.plot(x, y, 'or')
axis.plot(xn, yn)
plt.show()
Keressük a $2x+3cos(x)$ függvény egy gyökét.
A scipy.optimize.root(fn,x0)
függvényt használhatjuk. A hátterben különböző iteratív módszerek futnak, amik folyamatosan javítanak a megoldáson. A második paraméter a kezdeti tipp a gyökre.
from scipy.optimize import root
def func(x):
return 2*x + 3 * np.cos(x)
sol = root(func,0)
print(sol)
func(-0.91485648)
sym.solveset( xval*2 + 2 * sym.cos(xval), xval) # a szimolikus megoldó csak széttárja a kezét.
Adott egy célfüggvény, amit bizonyos feltélek mellett szeretnék minimalizálni (maximalizálni). Például:
$$\min(x_0^3+x_1^2-x_2)$$Feltéve hogy: $$x_0^2+x_1^2=10 $$ $$x_0x_2\le4 $$ $$0\le x_0,x_1,x_2\le100$$
Legyen a kiindulási tipp (2,3,4)
from scipy.optimize import minimize
# cél és feltételek
def objective(x):
return x[0]**3+x[1]**2-x[2]
def constraint1(x):
return x[0]**2+x[1]**2-10.0
def constraint2(x):
return 4-x[0]*x[2]
#Kezdeti tipp
x0=np.array([2,3,4])
#Kezdeti érték
print("Cél függvény értéke a kiindulási pontban:",objective(x0))
# optimalizálás
b = (0.0,100.0)
bnds = (b, b, b)
con1 = {'type': 'eq', 'fun': constraint1}
con2 = {'type': 'ineq', 'fun': constraint2}
cons = ([con1,con2])
solution = minimize(objective,x0,method='SLSQP',bounds=bnds,constraints=cons)
x = solution.x
# show final objective
print('Cél függvény értéke: ' + str(objective(x)))
# print solution
print('Optimális értékek:')
print('x1 = ' + str(x[0]))
print('x2 = ' + str(x[1]))
print('x3 = ' + str(x[2]))
#Ellenőrzés
print(constraint1(x))
print(constraint2(x))
Oldjuk meg az $f'(x)=-kf(x)$ egyenletet.
Használhatjuk az scipy.integrate.odeint
függvényt.
import numpy as np
from scipy.integrate import odeint
import matplotlib.pyplot as plt
# függvény, ami visszatért a derivált értékével
def model(f,x):
k = 0.3
deri = -k * f
return deri
# kezdeti érték
f0 = 5
# x értékek, ahol ki akarjuk számolni a függvényt
x = np.linspace(0,20)
# egyenelet megoldása
f = odeint(model,f0,x)
# plot results
plt.plot(x,f)
plt.xlabel('x')
plt.ylabel('f(x)')
plt.show()
Adott egy ponthalmaz. Kössük össze azokat a pontpárokat, akikhez létezik olyan körlap, ami csak őket tartalmazza a ponthalmazból.
from scipy.spatial import Delaunay
points = np.random.rand(30, 2) # 30 random points in 2-D
tri = Delaunay(points)
import matplotlib.pyplot as plt
plt.triplot(points[:,0], points[:,1], tri.simplices.copy())
plt.plot(points[:,0], points[:,1], 'o')
plt.show()
Adott egy ponthalmaz, számítsuk ki a konvex burkát.
from scipy.spatial import ConvexHull
points = np.random.rand(30, 2) # 30 random points in 2-D
hull = ConvexHull(points)
plt.plot(points[:,0], points[:,1], 'o')
for simplex in hull.simplices:
plt.plot(points[simplex,0], points[simplex,1], 'k-')
plt.show()