# Programovanie

Letná škola FKS 2018

Maťo Gažo, Fero Dráček
(& vykradnuté materiály od Mateja Badina, Feriho Hermana, Kuba, Peťa, Jarných škôl FX a kade-tade po internete)

V tomto kurze si ukážeme základy programovania a naučíme sa programovať matematiku a fyziku.
Takéto vedomosti sú skvelé a budete vďaka nim: 
* vedieť efektívnejšie robiť domáce úlohy
* kvalitnejšie riešiť seminárové a olympiádové príklady
* lepšie rozumieť svetu (IT je dnes na trhu najrýchlejšie rozvíjajúcim sa odvetvím)

Počítač je blbý a treba mu všetko povedať a vysvetliť. Komunikovať sa s ním dá na viacerých úrovniach, my budeme používať Python. Python (názov odvodený z Monty Python's Flying Circus) je všeobecný programovací jazyk, ktorým sa dajú vytvárať webové stránky ako aj robiť seriózne vedecké výpočty. To znamená, že naučiť sa ho nie je na škodu a možno vás raz bude živiť.

Rozhranie, v ktorom píšeme kód, sa volá Jupyter Notebook. Je to prostredie navrhnuté tak, aby sa dalo programovať doslova v prehliadači a aby sa kód dal kúskovať. Pre zbehnutie kúskov programu stačí stlačiť Shift+Enter. 



# Dátové typy a operátory

### Čísla

 podľa očakávaní, vracia trojku


```python
3
```




    3




```python
2+3 # scitanie
```




    5




```python
6-2 # odcitanie
```




    4




```python
10*2 # nasobenie
```




    20




```python
35/5 # delenie
```




    7.0




```python
5//3 # celociselne delenie TODO je toto treba?
```




    1




```python
7%3 # modulo
```




    1




```python
2**3 # umocnovanie
```




    8




```python
4 * (2 + 3) # poradie dodrzane
```




    20



### Logické výrazy


```python
1 == 1 # logicka rovnost
```




    True




```python
2 != 3 # logicka nerovnost
```




    True




```python
1 < 10
```




    True




```python
1 > 10
```




    False




```python
2 <= 2
```




    True



# Premenné

Toto je premenná.

Po stlačení Shift+Enter program v okienku zbehne a premenná sa uloží do pamäte (RAMky, všetko sa deje na RAMke).


```python
a = 2
```

Teraz s ňou možno pracovať ako s bežným číslom.


```python
2 * a
```




    4




```python
a + a
```




    4




```python
a + a*a
```




    6



Možno ju aj umocniť.


```python
a**3
```




    8



Pridajme druhú premennú.


```python
b = 5
```

Nasledovné výpočty dopadnú podľa očakávaní.


```python
a + b
```




    7




```python
a * b
```




    10




```python
b**a
```




    25



Reálne čísla môžeme zobrazovať aj vo vedeckej forme: $2.3\times 10^{-3}$.


```python
d = 2.3e-3
```

# Funkcie

Spravme si jednoduchú funkciu, ktorá za nás sčíta dve čísla, aby sme sa s tým už nemuseli trápiť my:


```python
def scitaj(a, b):
    return a + b
```


```python
scitaj(10, 12) # vrati sucet
```




    22



Funkcia funguje na celých aj reálnych číslach.

Naša sčítacia funkcia má __štyri podstatné veci__:
1. `def`: toto slovo definuje funkciu.
2. dvojbodka na konci prvého riadku, odtiaľ začína definícia.
3. Odsadenie kódu vnútri funkcie o štyri medzery.
4. Samotný kód. V ňom sa môže diať čokoľvek, Python ho postupne prechádza.
5. `return`: kľúčová vec. Za toto slovo sa píše, čo je output funkcie.

### Úloha 1
Napíšte funkciu `priemer`, ktorá zoberie dve čísla (výšky dvoch chlapcov) a vypočíta ich priemernú výšku.

Ak máš úlohu hotovú, prihlás sa vedúcemu.


```python
# Tvoje riesenie:
def priemer(prvy, druhy):
    return ((prvy+druhy)/2)

priemer(90,20)

```




    55.0



# Poďme na fyziku

V tomto momente môžeme začať používať Python ako sofistikovanejšiu kalkulačku a počítať ňou základné fyzikálne problémy. 
Jednoduchý príklad s ktorým začneme: dostanete zadaných niekoľko fyziklánych konštánt ako **premenné**.
Predstavte si, že máte za úlohou vypočítať nejakú fyzikálnu veličinu pre niekoľko zadaných hodnôt. Veľmi pohodné je napísať si funkciu, do ktorej vždy zadáme počiatočné hodnoty.

Zadané konštanty


```python
kb=1.38064852e-23           # Boltzmanova konštanta
G=6.67408e-11               # Gravitačná konštanta
```

## Úloha 2
Napíšte funkciu kotrá spočíta gravitačnú silu medzi dvomi telesami pre zadanú vzdialenosť $r$ a hmotnosti $m_1$ a $m_2$.

Pripomíname, vzorec pre výpočet gravitačnej  sily je
$F=G \frac{m_1 m_2}{r^2}$


```python
# Tvoje riesenie:

def Sila(m_1, m_2, r):
    F=G* m_1*m_2/r**2
    return (F)

Sila(10,10,100)
```




    6.67408e-13



## Úloha 3
Napíšte funkciu kotrá spočíta tlak v nádobe s objemom $V$, teplotou $T$ v ktorej je $N$ častíc.

Pripomíname, vzorec pre výpočet tlaku je
$p=\frac{N kb T}{V}$


```python
# tvoje riesenie:
def tlak(N,T,V):
    p=N*kb*T/V
    return p

tlak(6e23, 270,1)
```




    2236.6506024



## Úloha 4
Napíšte funkciu ktorá vráti výslednú rýchlosť dvoch guličiek po dokonale pružnej zrážke. Funkciu má mať ako vstupné argumenty hmotnosti $m_1$, $m_2$ a rýchlosti $u_1$ a $u_2$ guličiek pred zrážkou. Výstupom budú nové rýchlosti $v_1$ a $v_2$. 

Hint: Využitím zákonu zachovania energie prídeme ku nasledujúcim výrazom pre nové rýchlosti.

$v_1=\frac{u_1 (m_1-m_2)+2 m_2u_2}{m_1+m_2}$

$v_2=\frac{u_2 (m_2-m_1)+2 m_1u_1}{m_1+m_2}$


```python
# tvoje riesenie:
def zrazka(m_1,m_2,u_1,u_2):
    return ((u_1 *(m_1-m_2)+2*m_2*u_2)/(m_1+m_2),(u_2 *(m_2-m_1)+2* m_1*u_1)/(m_1+m_2))

zrazka(1,1,10,-10)
```




    (-10.0, 10.0)



# Zoznamy

Zatiaľ sme sa zoznámili s číslami (celé, reálne), stringami a trochu aj logickými hodnotami.
Zo všetkých týchto prvkov vieme vytvárať množiny, v informatickom jazyku `zoznamy`.

Na úvod sa teda pozrieme, ako s vytvára zoznam (po anglicky `list`). Takúto vec všeobecne nazývame dátová štruktúra.


```python
li = [] # prazdny list
```


```python
ve = [4, 2, 3] # list s cislami
```


```python
ve
```




    [4, 2, 3]




```python
ve[0] # indexovat zaciname nulou!
```




    4




```python
ve[1]
```




    2




```python
ve[-1] # vybratie posledneho prvku
```




    3




```python
w = [5, 10, 15]
```

Čo sa sa stane, ak zoznamy sčítame? Spoja sa.


```python
ve + w
```




    [4, 2, 3, 5, 10, 15]



Môžeme ich násobiť?


```python
ve * ve
```

Smola, nemôžeme. Ale všimnime si, aká užitočná je chybová hláška. Jasne nám hovorí, že nemožno násobiť `list`y.

So zoznamami môžeme robiť rôzne iné užitočné veci. Napríklad ich sčítať.


```python
sum(ve)
```




    9



Alebo zistiť dĺžku:


```python
len(ve)
```




    3



Alebo ich utriediť:

Alebo na koniec pridať nový prvok:


```python
ve.append(10)
ve
```




    [4, 2, 3, 10]



Alebo odobrať:

### Interval


Zoznam možno zadefinovať cez rozsah:


```python
range(10)
type(range(10))
```




    range




```python
list(range(10))
```




    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]




```python
list(range(3, 9))
```




    [3, 4, 5, 6, 7, 8]



## Úloha 5
Spočítajte:
* súčet všetkých čísel od 1 do 1000.

Vytvorte zoznam `letnaskola`, ktorý bude obsahovať vašich 5 obľúbených celých čísel. 
* Pridajte na koniec zoznamu číslo 100
* Prepíšte prvé číslo v zozname tak, aby sa rovnalo poslednému v zozname.
* Vypočítajte súčet prvého čísla, posledného čísla a dĺžky zoznamu.


```python
# Tvoje riesenie:
zoznam = list(range(1,1001))
print(sum(zoznam))

letnaskola = [1,1995,12,6,42]
print(letnaskola)
letnaskola.append(100)
print(letnaskola)
letnaskola[0] = letnaskola[len(letnaskola)-1]
print(letnaskola)

print(letnaskola[0]+letnaskola[len(letnaskola)-1], len(letnaskola))
```

    500500
    [1, 1995, 12, 6, 42]
    [1, 1995, 12, 6, 42, 100]
    [100, 1995, 12, 6, 42, 100]
    200 6


# For cyklus

Indexy zoznamu môžeme postupne prechádzať. For cyklus je tzv. `iterátor`, ktorý iteruje cez zoznam.


```python
for i in [3,2,5,6]:
    print(i)
```

    2
    5
    7
    8
    10
    11
    14
    18
    20
    25



```python
for i in  [3,2,5,6]:
    print(i**2)
```

    9
    4
    25
    36


Ako úspešne vytvoriť For cyklus? Podobne, ako pri funkciách:

* `for`: toto slovo je na začiatku.
* `i`: iterovana velicina
* `in`: pred zoznamom, cez ktorý prechádzame (iterujeme).
* dvojbodka na konci prvého riadku.
* kod, ktory sa cykli sa odsadzuje o štyri medzery.

Za pomoci for cyklu môžeme takisto sčítať čísla. Napr. čísla od 0 do 100:


```python
suma = 0

for i in range(101):   # uvedomme si, preco tam je 101 a nie 100
    suma = suma + i      # skratene sum += i
    
print(suma)
```

    5050


## Hľadanie hodnoty zlatého rezu $\varphi$

Jednoduché cvičenie na oboznámenie sa s tzv. selfkonzistentným problémom a for cyklom.
Zlatý rez je možné nájsť ako riešienie rovnice
$x=1+1/x$
Jej riešenie vieme hladať postupným iterovaním


```python
x = 1;

for i in range (0,20):
    x = 1+1/x
    print (x)
```

    2.0
    1.5
    1.6666666666666665
    1.6
    1.625
    1.6153846153846154
    1.619047619047619
    1.6176470588235294
    1.6181818181818182
    1.6179775280898876
    1.6180555555555556
    1.6180257510729614
    1.6180371352785146
    1.6180327868852458
    1.618034447821682
    1.618033813400125
    1.6180340557275543
    1.6180339631667064
    1.6180339985218035
    1.618033985017358


## Úloha 6
Spočítajte súčet druhých mocnín všetkých nepárnych čísel od 1 do 100 s využitím for cyklu.


```python
# Tvoje riesenie:
suma = 0
for i in range(50):
    suma = suma + (2*i+1)**2
print(suma)
```

    166650


## Úloha 7
### Dvojhlavý tank (FKS 30.2.2.A2)
Nevieme odkiaľ, no máme bombastický tank, ktorý má dve hlavne namierené opačným smerom – samozrejme tak, že nemieria proti sebe ;-). V tanku je
$N = 42$ nábojov s hmotnosťou $m= 20$ kg. Tank s nábojmi váži dokopy
$M= 43$ t. Potom tank začne strieľať striedavo z hlavní náboje rýchlosťou v= 1 000 m s frekvenciou strieľania $f= 0.2$ Hz. Keďže tank je nezabrzdený a dobre naolejovaný, začne sa pohybovať. 
Ako ďaleko od pôvodného miesta vystrelí posledný náboj? Akej veľkej chyby by sme sa dopustili,
ak by sme zanedbali zmenu celkovej hmotnosti tanku počas strieľania?

Hint: http://old.fks.sk/archiv/2014_15/30vzorakyLeto2.pdf , strana 10


```python
x=0
m=20
Mtank=[43000]
vtank=[0]
v=-1000
f=0.2
for i in range(43):
    x=x+vtank[-1]*1/f
    vtank.append(vtank[-1]-m*v/(Mtank[-1]-m))
    Mtank.append(Mtank[-1]-m)
    v=-v
print(x)

```

    48.83697212654822


# Podmienky

Pochopíme ich na príklade. Zmeňte `a` a zistite, čo to spraví.


```python
a = 5

if a == 3:
    print("cislo a je rovne trom.")
elif a == 5:
    print("cislo a je rovne piatim")
else:
    print("cislo a nie je rovne trom ani piatim.")
```

    cislo a je rovne piatim


Za pomoci podmienky teraz môžeme z for cyklu vypísať napr. len párne čísla. Párne číslo identifikujeme ako také, ktoré po delení dvomi dáva zvyšok nula.

Pre zvyšok po delení sa používa percento:


```python
for i in range(10):
    if i % 2 == 0:
        print(i)
```

    0
    2
    4
    6
    8


Cyklus mozeme zastavit, ak sa porusi nejaka podmienka


```python
for i in range(20):
    print(i)
    if i>10:
        print('Koniec.')
        break
```

    0
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    Koniec.


## Hľadanie hodnoty Ludolfovho čísla $\pi$
Pomocou Monte Carlo metódy integrovania sa naučíme ako napríklad vypočítať $\pi$.
Nasledujúce príkazy vygenerujú zoznam náhodných čísel od nula po jeden



```python
import random as rnd
import numpy as np

NOP = 50000

CoordXList = [];
CoordYList = [];

for j in range (NOP):
    CoordXList.append(rnd.random())
    CoordYList.append(rnd.random())
```

Tieto dva zoznamy použijeme ako $x$-ové a $y$-ové súradnice bodov v rovnine. Kedže náhodné rozdelenie bodov je rovnomerné, tak pomer bodov, ktoré sa nachádzajú vnútri štvrťkružnice s polomerom jedna ku všetkým bodom musí byť rovnaký ako pomer plochy štvrťkruhu a štvroca. 
Teda $$\frac{\frac{1}{4}\pi 1^2}{1^2}\stackrel{!}{=}\frac{N_{in}}{NOP}.$$
Nasledujúce dve bunky vygenerujú obrázok rozloženia bodov a stvrťkružnicu


```python
CircPhi = np.arange(0,np.pi/2,0.01)
```


```python
import matplotlib.pyplot as plt
f1=plt.figure(figsize=(7,7))

plt.plot(
    CoordXList,
    CoordYList,
    color = "red",
    linestyle= "none",
    marker = ","
)
plt.plot(np.cos(CircPhi),np.sin(CircPhi))
#plt.axis([0, 1, 0, 1])
#plt.axes().set_aspect('equal', 'datalim')
plt.show(f1)
```

## Úloha 8
Teraz je vašou úlohou spočítať $\pi$. Hint: bod je vnútri štvrťkružnice pokiaľ platí $x^2+y^2<1.$


```python
#vase riesenie
NumIn = 0

for j in range (NOP):
    
    #if (CoordXList[j] - 0.5)*(CoordXList[j] - 0.5) + (CoordYList[j] - 0.5)*(CoordYList[j] - 0.5) < 0.25:
    if CoordXList[j]*CoordXList[j] + CoordYList[j]*CoordYList[j] <= 1:
        
        NumIn = NumIn + 1;   
```


```python
NumIn/NOP*4
```




    3.14768



# Numerické sčítavanie

Vo fyzike je často užitočné rozdeliť si problém na malé časti.


## Úloha 9
Teraz je vašou úlohou vymyslieť ako spočítať gravitačné pole od jednorozmernej usečky o výške h nad stredom úsečky.
 Úsečka má hmotnosť  $M$ a dĺžku $L$. 

Úsečku si rozdelíte na $N$ malých dielov. Hmotnosť jedného takého dieliku je potom   
$$dm=\frac{M}{N}$$

Vzdialenosť takéhoto bodu od stedu úsečky $x$.
Potom gravitačná pole od toho malého kúsku v žiadanom bode je:
$$\vec{\Delta g}=-G \frac{\Delta m}{r^3}\vec{r}.$$
Rozdrobené na $y$-ovú a $x$-ovú zložku:
$$\Delta g_y=-G \frac{\Delta m}{(x^2+h^2)}\cos(\phi)=-G \frac{\Delta m}{(x^2+h^2)}\frac{h}{\sqrt{x^2=h^2}},$$
respektíve 
$$\Delta g_x=-G \frac{\Delta m}{(x^2+h^2)}\sin(\phi)=-G \frac{\Delta m}{(x^2+h^2)}\frac{x}{\sqrt{x^2+h^2}},$$
Vašou úlohou je rozdeliť takúto úsečku a sčítať príspevky od všetkých malých kúskov. Premyslite si že kedže sme v strede úsečky, $x$-ové príspevky sa navzájom vynulujú.
Ak vám to príde príliš jednoduché, tak možte naprogramovať program ktorých spočíta gravitačné pole nad lubovoľným bodom




```python
N=1000
M=1000
L=2
h=1

#vase riesenie
g=0
for i in range(-int(N/2),int(N/2)):
    g=g+G*M/N*(i/N)/((i/N)**2+h**2)**(3/2)
g    
    




```




    -2.3877914507634306e-11



# Obiehanie Zeme okolo Slnka

Fyziku (dúfam!) všetci poznáme.

* gravitačná sila:
$$ \mathbf F(\mathbf r) = -\frac{G m M}{r^3} \mathbf r $$

### Eulerov algoritmus (zlý)
$$\begin{align}
a(t) &= F(t)/m \\
v(t+dt) &= v(t) + a(t) dt \\
x(t+dt) &= x(t) + v(t) dt \\
\end{align}$$

### Verletov algoritmus (dobrý)
$$ x(t+dt) = 2 x(t) - x(t-dt) + a(t) dt^2 $$


```python
from numpy.linalg import norm

G = 6.67e-11
Ms = 2e30
Mz = 6e24
dt = 86400.0
N = int(365*86400.0/dt)
#print(N)

R0 = 1.5e11
r_list = np.zeros((N, 2))
r_list[0] = [R0, 0.0]     # mozno miesat listy s ndarray

v0 = 29.7e3
v_list = np.zeros((N, 2))
v_list[0] = [0.0, v0]

# sila medzi planetami
def force(A, r):
    return -A / norm(r)**3 * r

# Verletova integracia
def verlet_step(r_n, r_nm1, a, dt):  # r_nm1 -- r n minus 1
    return 2*r_n - r_nm1 + a*dt**2

# prvy krok je specialny
a = force(G*Ms, r_list[0])
r_list[1] = r_list[0] + v_list[0]*dt + a*dt**2/2


# riesenie pohybovych rovnic
for i in range(2, N):
    a = force(G*Ms, r_list[i-1])
    r_list[i] = verlet_step(r_list[i-1], r_list[i-2], a, dt)
    
    
plt.plot(r_list[:, 0], r_list[:, 1])
plt.xlim([-2e11, 2e11])
plt.ylim([-2e11, 2e11])
plt.xlabel("$x$", fontsize=20)
plt.ylabel("$y$", fontsize=20)
plt.gca().set_aspect('equal', adjustable='box')
#plt.axis("equal")
plt.show()
```

## Pridajme Mesiac


```python
Mm = 7.3e22
R0m = R0 + 384e6
v0m = v0 + 1e3
rm_list = np.zeros((N, 2))
rm_list[0] = [R0m, 0.0]
vm_list = np.zeros((N, 2))
vm_list[0] = [0.0, v0m]

# prvy Verletov krok
am = force(G*Ms, rm_list[0]) + force(G*Mz, rm_list[0] - r_list[0])
rm_list[1] = rm_list[0] + vm_list[0]*dt + am*dt**2/2

# riesenie pohybovych rovnic
for i in range(2, N):
    a = force(G*Ms, r_list[i-1]) - force(G*Mm, rm_list[i-1]-r_list[i-1])
    am = force(G*Ms, rm_list[i-1]) + force(G*Mz, rm_list[i-1]-r_list[i-1])
    r_list[i] = verlet_step(r_list[i-1], r_list[i-2], a, dt)
    rm_list[i] = verlet_step(rm_list[i-1], rm_list[i-2], am, dt)
    
plt.plot(r_list[:, 0], r_list[:, 1])
plt.plot(rm_list[:, 0], rm_list[:, 1])
plt.xlabel("$x$", fontsize=20)
plt.ylabel("$y$", fontsize=20)
plt.gca().set_aspect('equal', adjustable='box')
plt.xlim([-2e11, 2e11])
plt.ylim([-2e11, 2e11])
plt.show()         # mesiac moc nevidno, ale vieme, ze tam je
```

## Úloha pre Vás: Treba pridať Mars :)
Pridajte Mars!

## Matematické kyvadlo s odporom 
Nasimulujte matematické kyvadlo s odporom $\gamma$,
$$ \ddot \theta = -\frac g l \sin\theta -\gamma \theta^2,$$
za pomoci metódy `odeint`.

Alebo pád telesa v odporovom prostredí:
$$ a = -g - kv^2.$$


```python
from scipy.integrate import odeint

def F(y, t, g, k):
    return [y[1], g -k*y[1]**2]

N = 101
k = 1.0
g = 10.0
t = np.linspace(0, 1, N)
y0 = [0.0, 0.0]
y = odeint(F, y0, t, args=(g, k))

plt.plot(t, y[:, 1])
plt.xlabel("$t$", fontsize=20)
plt.ylabel("$v(t)$", fontsize=20)
plt.show()
```

## Harmonický oscilátor pomocou metódy Leapfrog (modifikácia Verletovho algoritmu)


```python
N = 10000
t = linspace(0,100,N)
dt = t[1] - t[0]

# Funkcie
def integrate(F,x0,v0,gamma):
    x = zeros(N)
    v = zeros(N)
    E = zeros(N)    
    
    # Počiatočné podmienky
    x[0] = x0
    v[0] = v0
    
    # Integrovanie rovníc pomocou metódy Leapfrog (wiki)
    fac1 = 1.0 - 0.5*gamma*dt
    fac2 = 1.0/(1.0 + 0.5*gamma*dt)
    
    for i in range(N-1):
         v[i + 1] = fac1*fac2*v[i] - fac2*dt*x[i] + fac2*dt*F[i]
         x[i + 1] = x[i] + dt*v[i + 1]
         E[i] += 0.5*(x[i]**2 + ((v[i] + v[i+1])/2.0)**2)
    
    E[-1] = 0.5*(x[-1]**2 + v[-1]**2)
    
    # Vrátime riešenie
    return x,v,E
```


```python
# Pozrime sa na tri rôzne počiatočné podmienky
F = zeros(N)
x1,v1,E1 = integrate(F,0.0,1.0,0.0) # x0 = 0.0, v0 = 1.0, gamma = 0.0
x2,v2,E2 = integrate(F,0.0,1.0,0.05) # x0 = 0.0, v0 = 1.0, gamma = 0.01
x3,v3,E3 = integrate(F,0.0,1.0,0.4) # x0 = 0.0, v0 = 1.0, gamma = 0.5

# Nakreslime si grafy

plt.rcParams["axes.grid"] = True
plt.rcParams['font.size'] = 14
plt.rcParams['axes.labelsize'] = 18
plt.figure()
plt.subplot(211)
plt.plot(t,x1)
plt.plot(t,x2)
plt.plot(t,x3)
plt.ylabel("x(t)")

plt.subplot(212)
plt.plot(t,E1,label=r"$\gamma = 0.0$")
plt.plot(t,E2,label=r"$\gamma = 0.01$")
plt.plot(t,E3,label=r"$\gamma = 0.5$")
plt.ylim(0,0.55)
plt.ylabel("E(t)")

plt.xlabel("Čas")
plt.legend(loc="center right")

plt.tight_layout()
```

A čo ak bude oscilátor aj tlmenný?


```python
def force(f0,t,w,T):
          return f0*cos(w*t)*exp(-t**2/T**2) 

F1 = zeros(N)
F2 = zeros(N)
F3 = zeros(N)
for i in range(N-1):
    F1[i] = force(1.0,t[i] - 20.0,1.0,10.0)
    F2[i] = force(1.0,t[i] - 20.0,0.9,10.0)
    F3[i] = force(1.0,t[i] - 20.0,0.8,10.0)
```


```python
x1,v1,E1 = integrate(F1,0.0,0.0,0.0)
x2,v2,E2 = integrate(F1,0.0,0.0,0.01)
x3,v3,E3 = integrate(F1,0.0,0.0,0.1)

plt.figure()
plt.subplot(211)
plt.plot(t,x1)
plt.plot(t,x2)
plt.plot(t,x3)
plt.ylabel("x(t)")

plt.subplot(212)
plt.plot(t,E1,label=r"$\gamma = 0$")
plt.plot(t,E2,label=r"$\gamma = 0.01$")
plt.plot(t,E3,label=r"$\gamma = 0.1$")
pt.ylabel("E(t)")

plt.xlabel("Time")
plt.rcParams['legend.fontsize'] = 14.0
plt.legend(loc="upper left")

plt.show()
```


```python

```

284cf508cce5828af010d7a7dbe2dcd99eb0c76a
ipynb
Jupyter Notebook
Programko_vzor.ipynb
matoga/LetnaSkolaFKS_notebooks
26faa2d30ee942e18246fe466d9bf42f16cc1433
MIT
Programko_vzor.ipynb
matoga/LetnaSkolaFKS_notebooks
26faa2d30ee942e18246fe466d9bf42f16cc1433
MIT
Programko_vzor.ipynb
matoga/LetnaSkolaFKS_notebooks
26faa2d30ee942e18246fe466d9bf42f16cc1433
MIT
Qwen/Qwen-72B
1. YES
2. YES