#!/usr/bin/env python
# coding: utf-8

# # 5. előadás

# Tartalom: Numpy modul bevezetése és használata, diagramok megjelenítése numpy felhasználásával

# A `numpy` egy széles körben elterjedt Python modul, aminek a segítségével különféle numerikus számításokat végezhetünk, különösen a különféle 1 és több dimenziós adatszerkezetek tekintetében, mint vektorok és mátrixok. A modulban több hasznos, a vektorok és mátrixok esetén értelmezett művelet meg van valósítva, ezek magas hatékonysággal működnek.

# A `numpy` telepíthető a `pip install numpy` paranccsal, de például a `matplotlib` csomag telepítése során automatikusan települ.

# A `numpy` modult a következő módon importáljuk:

# In[1]:


import numpy as np


# A `numpy` segítségével több módon lehetséges tömb adatszerkezetet létrehozni. Az `array` metódus segítségével 1 és több dimenziós tömböket hozhatunk létre, az elemeinek felsorolásával.

# A v változóban egy 1 dimenziós, 3 elemű tömb (vektor) lesz.

# In[2]:


v = np.array([1, 2, 3])


# In[3]:


print(v)


# In[4]:


v


# Az M változóba egy 2 dimenziós, 4 elemű tömb (mátrix) lesz.

# In[5]:


M = np.array([[1.0, 2.0], [3.0, 4.0]])


# In[6]:


print(M)


# In[7]:


M


# A `shape` metódus segítségével megtudhatjuk egy tömb dimenzióit és méreteit. Látható, hogy a visszatérési értéke egy tuple.

# In[8]:


v.shape


# In[9]:


M.shape


# Ahogy azt már tanultuk, tuple esetén hivatkozhatunk az egyes értékekre is.

# In[10]:


M.shape[1]


# A size metódus megadja, hogy az adatszerkezet hány elemet tartalmaz összesen.

# In[11]:


v.size


# In[12]:


M.size


# A `shape` és `size` a következő módon is használható.

# In[13]:


np.shape(v)


# In[14]:


np.size(v)


# In[15]:


np.shape(M)


# In[16]:


np.size(M)


# Egy `numpy` tömbtől lekérdezhető annak adattípusa a `dtype` metódus segítségével.

# In[17]:


v.dtype


# In[18]:


M.dtype


# Az egyes elemeket indexeléssel érhetjük el.

# In[19]:


v[0]


# Hasonló módon változtathatók egy tömb elemei.

# In[20]:


v[0] = 42
v


# De a típusa nem módosítható.

# In[21]:


v[0] = 3.6 #Egész számra fogja kényszeríteni.
v


# ```python
# v[0] = "abc" # Nem tudja egész számként megfeleltetni, hibát kapunk.
# 
# ValueError 
# ----> 1 v[0] = "abc" 
# 
# ValueError: invalid literal for int() with base 10: 'abc'
# ```

# In[22]:


v #Ezért v értékei változatlanok.


# A listák esetén tanult indexelési lehetőségek `numpy` tömbök esetén is ugyanúgy működnek.

# Például kérhetjük a tömböt elemeinek fordított sorrendjében.

# In[23]:


v[::-1]


# Ha több dimenziós adatszerkezetet használunk, azt úgy fogjuk fel mint egy 1 dimenziós szerkezetet, ami további 1 dimenziós szerkezeteket tartalmaz. Ebből kifolyólag a következő kódsor az M mátrix két sorát "cseréli fel".

# In[24]:


M[::-1]


# A következő sor pedig a két oszlopát fordítja meg.

# In[25]:


M[::, ::-1]


# Az `arange` metódus segítségével is generálhatunk `numpy` tömböt.

# In[26]:


x = np.arange(0, 10, 1) #paraméterek: start, stop, lépésköz
x


# In[27]:


x = np.arange(0, 1, 0.01)
x


# In[28]:


x = np.arange(5, 0, -1)
x


# Lehetőségünk van arra is, hogy véletlenszerű értékekkel feltöltött tömböt generáljunk a megadott méretben. A tömb értékei a [0;1] tartományba fognak esni.

# In[29]:


r1 = np.random.random([3, 8])
print(r1)


# In[30]:


import matplotlib.pyplot as plt
get_ipython().run_line_magic('matplotlib', 'inline')
plt.imshow(r1)
plt.colorbar()
plt.show()


# In[31]:


plt.figure(1, figsize=(10,4))
plt.subplot(221)
plt.imshow(r1)
plt.subplot(222)
plt.imshow(r1[:, ::-1])
plt.subplot(223)
plt.imshow(r1[::-1, :])
plt.subplot(224)
plt.imshow(r1[::-1, ::-1])
plt.show()


# Hogyan tudunk tetszőleges [min; max] tartományba generálni véletlen értékeket?

# In[32]:


min = 10
max = 13
np.random.random([5, 3]) * (max - min) + min


# Ahogy a fenti példa is mutatja, `numpy` tömbök esetén az alapvető matematikai műveletek tagonként értendők. Tehát, ha egy `numpy` tömböt szorzunk, osztunk, összeadunk vagy kivonunk egy skalárral, akkor azt tagonként végzi el.

# In[33]:


M * 10


# In[34]:


M / 10


# In[35]:


M + 10


# In[36]:


M - 10


# Ugyanez igaz, ha a vektorokat és mátrixokat szorzunk egymással. Itt tagonkénti szorzás fog végbemenni.

# In[37]:


v * v


# In[38]:


M * M


# Vektor és mátrix között is értelmezett a szorzás, de ügyeljünk az adatszerkezetek méreteire.

# ```python
# M * v # Nem fog működni, a méretük nem összeegyeztethető.
# 
# ---------------------------------------------------------------------------
# ValueError 
# ----> 1 M * v 
# 
# ValueError: operands could not be broadcast together with shapes (2,2) (3,)
# ```

# A szorzás itt is tagonként történik.

# In[39]:


b = np.array([1, 2])


# In[40]:


M * b


# Ha a mátrixok és vektorok klasszikus értelemben vett szorzását akarjuk végrehajtani, akkor azt a `dot` függvény hívásával tehetjük meg.

# In[41]:


M.dot(M)


# In[42]:


M.dot(b)


# A `min` és `max` fügvényekkel kérhetjük az adott szerkezet legkisebb és legnagyobb értékét.

# In[43]:


np.min(M)


# In[44]:


np.max(M)


# Az értékeket összegezhetjük a `sum` fügvénnyel.

# In[45]:


np.sum(M)


# Az átlagot pedig a `mean` függvénnyel számíthatjuk.

# In[46]:


np.mean(M)


# Numpy tömböket is megjeleníthetünk diagaramok segítségével. A felhasználásuk ugyanolyan módon történik, mint azt már a listák esetén tanultuk.

# In[47]:


import matplotlib.pyplot as plt

get_ipython().run_line_magic('matplotlib', 'inline')

x = np.arange(1000)
y = np.random.random([1000])

plt.plot(x, y, "g")
plt.show()
plt.hist(y, 20, density=True) # hisztogram, gyakorisági sűrűség
plt.show()


# A `density=True` a hisztogram érékeinek normalizálására szolgál.
# 
# ### Emlékeztetőül (valszám)
# 
# Az `x` valószínűségi változó **normális eloszlású** akkor, ha sűrűségfüggvénye:
# 
# $ f(x) = 
# \frac{1}{{\sigma \sqrt {2\pi\sigma^2} }}
# e^{{(x-\mu)^2} / {2\sigma^2}} 
# $
# 
# A következő jelölésekkel: $\sigma^2$ (sigma) a szórásnégyzet; $\mu$ (mu) pedig a középérték.
# 
# A normális eloszlás egyik fő tulajdonsága, hogy a középértéktől 1 sigma távolságra esik az összes előfordulás 68%-a, 2 sigma távolságra pedig az összes előfordulás 95%-a.

# In[48]:


mu = 10 # középérték 
sigma = 5 # szórás
s = np.random.normal(mu, sigma, 1000)
plt.plot(s, "g")
plt.show()
plt.hist(s, 20, density = True)
plt.show()


# Itt már látszik a normál eloszlást jellemző harnaggörbe, de jelenítsük ezt meg pontosabban.
# 
# A $ f(x) = 
# \frac{1}{{\sigma \sqrt {2\pi\sigma^2} }}
# e^{{(x-\mu)^2} / {2\sigma^2}} 
# $ képlet pythonban így formalizálható:
# 
# 
# ```python
# ys = 1/(sigma * np.sqrt(2 * np.pi)) * np.exp(-(xs - mu)**2 / (2 * sigma**2))
# ```

# In[49]:


xs = np.arange(mu - 3*sigma, mu + 3*sigma, 0.1)
ys = 1/(sigma * np.sqrt(2 * np.pi)) * np.exp(-(xs - mu)**2 / (2 * sigma**2))
plt.hist(s, 20, density = True)
plt.plot(xs, ys, "r", linewidth = 4)
plt.show()


# ## _Used sources_ / Felhasznált források
# - [Shannon Turner: Python lessons repository](https://github.com/shannonturner/python-lessons) MIT license (c) Shannon Turner 2013-2014
# - [Siki Zoltán: Python mogyoróhéjban](http://www.agt.bme.hu/gis/python/python_oktato.pdf) GNU FDL license (c) Siki Zoltán
# - [BME AUT](https://github.com/bmeaut) MIT License Copyright (c) BME AUT 2016-2018
# 
# ## További olvasnivaló:
# - https://en.wikipedia.org/wiki/Normal_distribution