Informatika2-2016/Gyakorlat13Megold

A MathWikiből
(Változatok közti eltérés)
 
(egy szerkesztő 5 közbeeső változata nincs mutatva)
2. sor: 2. sor:
 
Ismerkedésképp néhány egyszerű feladat.
 
Ismerkedésképp néhány egyszerű feladat.
 
# Hozzunk létre egy 10 hosszú, csupa 0 vektort! Módosítsuk a 4. elemét 1-re! ''(zeros)''
 
# Hozzunk létre egy 10 hosszú, csupa 0 vektort! Módosítsuk a 4. elemét 1-re! ''(zeros)''
import numpy as np
+
<python>
L = np.zeros(10)
+
import numpy as np
L[3] = 1
+
L = np.zeros(10)
 +
L[3] = 1
 +
</python>
 
# Hozzunk létre egy 3x3-as mátrixot, 0-tól 8-ig növekvő számokkal! ''(reshape)''
 
# Hozzunk létre egy 3x3-as mátrixot, 0-tól 8-ig növekvő számokkal! ''(reshape)''
 
  M = np.arange(9).reshape(3,3)
 
  M = np.arange(9).reshape(3,3)
 
# Hozzunk létre egy 30 hosszú listát véletlen számokkal 0 és 1 között! Számoljuk ki az elemek átlagát és a szórását! ''(rand, mean, std)''
 
# Hozzunk létre egy 30 hosszú listát véletlen számokkal 0 és 1 között! Számoljuk ki az elemek átlagát és a szórását! ''(rand, mean, std)''
 +
<python>
 +
R = np.random.rand(30)
 +
print R.mean()
 +
print R.std()
 +
</python>
 
## Hozzunk lérte egy 30 hosszú listát véletlen számokkal -3 és 2 között!
 
## Hozzunk lérte egy 30 hosszú listát véletlen számokkal -3 és 2 között!
 +
<python>
 +
R = np.random.rand(30)
 +
R = R * 5
 +
R = R - 3
 +
</python>
 
# Hozzunk létre egy véletlen, 5 dimenziós egységvektort! Először egy véletlen vektor, majd gondoskodjunk róla, hogy egység hosszú legyen!
 
# Hozzunk létre egy véletlen, 5 dimenziós egységvektort! Először egy véletlen vektor, majd gondoskodjunk róla, hogy egység hosszú legyen!
 
+
<python>
 
+
E = np.random.rand(5)
 
+
E = E / np.sqrt((E.dot(E)))
 +
</python>
  
 
==Monte-Carlo==
 
==Monte-Carlo==
 
Generáljunk 500,000 véletlen pontot a <math>[0,2]\times[0,4]</math> téglalapba. Szánoljuk meg, hogy hány olyan <math>(x,y)</math> pont van, ahol <math>x^2<y</math>. Ez alapján becsüljük meg az <math>\int_0^2x^2</math> értékét! Segítség az előadás végén.  
 
Generáljunk 500,000 véletlen pontot a <math>[0,2]\times[0,4]</math> téglalapba. Szánoljuk meg, hogy hány olyan <math>(x,y)</math> pont van, ahol <math>x^2<y</math>. Ez alapján becsüljük meg az <math>\int_0^2x^2</math> értékét! Segítség az előadás végén.  
 +
<python>
 +
import numpy as np
 +
x = np.random.rand(500000) * 2
 +
y = np.random.rand(500000) * 4
 +
L = np.where(x ** 2 > y)[0]
 +
print len(L) / float(len(x)) * 2 * 4
 +
</python>
 
* Most ugyanezt csináljuk meg, csak a véletlent zárjuk ki belőle! Osszuk fel a <math>[0,2]</math> és a <math>[0,4]</math> intervallumokat egyenletesen a linspace függvénnyel. A meshgrid és a ravel segítségével létrehozzuk a <math>[0,2]\times[0,4]</math> rácspontjait. Most ezekre a pontokra csináljuk meg a Monte-Carlot!
 
* Most ugyanezt csináljuk meg, csak a véletlent zárjuk ki belőle! Osszuk fel a <math>[0,2]</math> és a <math>[0,4]</math> intervallumokat egyenletesen a linspace függvénnyel. A meshgrid és a ravel segítségével létrehozzuk a <math>[0,2]\times[0,4]</math> rácspontjait. Most ezekre a pontokra csináljuk meg a Monte-Carlot!
 +
<python>
 +
import numpy as np
 +
x = np.linspace(0, 2, 500)
 +
y = np.linspace(0, 4, 500)
 +
L = np.meshgrid(x, y)
 +
L[0] = np.ravel(L[0])
 +
L[1] = np.ravel(L[1])
 +
K = np.where(L[0] ** 2 > L[1])[0]
 +
print len(K) / float(len(L[0])) * 2 * 4
 +
</python>
 
==Numerikus integrál==
 
==Numerikus integrál==
 
Számoljuk ki az <math>e^{-x^2}</math> függvény integrálját a <math>[-2,5]</math>intervallumon téglalap módszerrel!
 
Számoljuk ki az <math>e^{-x^2}</math> függvény integrálját a <math>[-2,5]</math>intervallumon téglalap módszerrel!
 +
<python>
 +
I = np.arange(-2, 5, 0.01)
 +
I = np.exp(-1 * (I ** 2))
 +
print np.sum(I * 0.01)
 +
</python>
 
==Gradiens módszer==
 
==Gradiens módszer==
 
Egy kétváltozós függvény minimumát a következőképp közelítjük. Elindulunk egy <math>(x_0,y_0)</math> pontból, majd <math>\nabla f(x,y)\cdot \epsilon</math>-t kivonunk belőle. Ezt csináljuk addig, amíg a lépés abszolútértéke 0.0001 alatt nem lesz. Írjuk meg numpy segítségével az <math>f(x,y)=x^2+y^2</math> függvény minimumkeresését! <math>\epsilon = 0.01, (x_0,y_0)=(-1,-1)</math>!
 
Egy kétváltozós függvény minimumát a következőképp közelítjük. Elindulunk egy <math>(x_0,y_0)</math> pontból, majd <math>\nabla f(x,y)\cdot \epsilon</math>-t kivonunk belőle. Ezt csináljuk addig, amíg a lépés abszolútértéke 0.0001 alatt nem lesz. Írjuk meg numpy segítségével az <math>f(x,y)=x^2+y^2</math> függvény minimumkeresését! <math>\epsilon = 0.01, (x_0,y_0)=(-1,-1)</math>!
 
* Tároljuk el a lépéseket egy tömbben és plotoljuk ki a pontokat a matplotlib segítségével!
 
* Tároljuk el a lépéseket egy tömbben és plotoljuk ki a pontokat a matplotlib segítségével!
==Gauss-elimináció kézzel==
+
<python>
Oldjuk meg Gauss-eliminációval az
+
def grad(x, y):
* <math>3x_1-x_2+x_3-x_4+2x_5=13</math>
+
    return np.array([2 * x, 2 * y])
* <math> x_1-2x_2+3x_3-x_4=5</math>
+
L = []
* <math>x_1-x_2-x_3-x_4-x_5=-1</math>
+
x0 = -1
* <math>x_2-2x_3+x_4-4x_5=-7</math>
+
y0 = -1
* <math>x_1+x_3+3x_4-x_5=5</math> egyenletrendszert!
+
eps = 0.01
 +
while np.sqrt(grad(x0, y0).dot(grad(x0, y0))) * eps > 0.001:
 +
    [x0, y0] = np.array([x0, y0]) - grad(x0, y0) * eps
 +
    L.append([x0, y0])
 +
print L[-1]
 +
</python>

A lap jelenlegi, 2016. május 16., 11:50-kori változata

Tartalomjegyzék

Bevezető

Ismerkedésképp néhány egyszerű feladat.

  1. Hozzunk létre egy 10 hosszú, csupa 0 vektort! Módosítsuk a 4. elemét 1-re! (zeros)
import numpy as np
L = np.zeros(10)
L[3] = 1
  1. Hozzunk létre egy 3x3-as mátrixot, 0-tól 8-ig növekvő számokkal! (reshape)
M = np.arange(9).reshape(3,3)
  1. Hozzunk létre egy 30 hosszú listát véletlen számokkal 0 és 1 között! Számoljuk ki az elemek átlagát és a szórását! (rand, mean, std)
R = np.random.rand(30)
print R.mean()
print R.std()
    1. Hozzunk lérte egy 30 hosszú listát véletlen számokkal -3 és 2 között!
R = np.random.rand(30)
R = R * 5
R = R - 3
  1. Hozzunk létre egy véletlen, 5 dimenziós egységvektort! Először egy véletlen vektor, majd gondoskodjunk róla, hogy egység hosszú legyen!
E = np.random.rand(5)
E = E / np.sqrt((E.dot(E)))

Monte-Carlo

Generáljunk 500,000 véletlen pontot a [0,2]\times[0,4] téglalapba. Szánoljuk meg, hogy hány olyan (x,y) pont van, ahol x2 < y. Ez alapján becsüljük meg az \int_0^2x^2 értékét! Segítség az előadás végén.

import numpy as np
x = np.random.rand(500000) * 2
y = np.random.rand(500000) * 4
L = np.where(x ** 2 > y)[0]
print len(L) / float(len(x)) * 2 * 4
  • Most ugyanezt csináljuk meg, csak a véletlent zárjuk ki belőle! Osszuk fel a [0,2] és a [0,4] intervallumokat egyenletesen a linspace függvénnyel. A meshgrid és a ravel segítségével létrehozzuk a [0,2]\times[0,4] rácspontjait. Most ezekre a pontokra csináljuk meg a Monte-Carlot!
import numpy as np
x = np.linspace(0, 2, 500)
y = np.linspace(0, 4, 500)
L = np.meshgrid(x, y)
L[0] = np.ravel(L[0])
L[1] = np.ravel(L[1])
K = np.where(L[0] ** 2 > L[1])[0]
print len(K) / float(len(L[0])) * 2 * 4

Numerikus integrál

Számoljuk ki az e^{-x^2} függvény integrálját a [ − 2,5]intervallumon téglalap módszerrel!

I = np.arange(-2, 5, 0.01)
I = np.exp(-1 * (I ** 2))
print np.sum(I * 0.01)

Gradiens módszer

Egy kétváltozós függvény minimumát a következőképp közelítjük. Elindulunk egy (x0,y0) pontból, majd \nabla f(x,y)\cdot \epsilon-t kivonunk belőle. Ezt csináljuk addig, amíg a lépés abszolútértéke 0.0001 alatt nem lesz. Írjuk meg numpy segítségével az f(x,y) = x2 + y2 függvény minimumkeresését! ε = 0.01,(x0,y0) = ( − 1, − 1)!

  • Tároljuk el a lépéseket egy tömbben és plotoljuk ki a pontokat a matplotlib segítségével!
def grad(x, y):
    return np.array([2 * x, 2 * y])
L = []
x0 = -1
y0 = -1
eps = 0.01
while np.sqrt(grad(x0, y0).dot(grad(x0, y0))) * eps > 0.001:
    [x0, y0] = np.array([x0, y0]) - grad(x0, y0) * eps
    L.append([x0, y0])
print L[-1]
Személyes eszközök