Martin Šach

Lisp - dotimes

19:42 22.06.2010 | Štítek: Programování

(dotimes (i 10 3) 
   (print i) 
) 
;0 
;1 
;2 
;3 
;4 
;5 
;6 
;7 
;8 
;9 
;3 - 3 je navratova hodnota 



(dotimes (i 10) 
   (print i) 
) 
;0 
;1 
;2 
;3 
;4 
;5 
;6 
;7 
;8 
;9 
;nil - zde sme nespecifikovali navratovou hodnotu, takze navratovou hodnotou je nil

OOP v PHP 5

19:53 22.06.2010 | Štítek: PHP

• v PHP je možné procedurální programování i objektově orientované programování
• základní jednotkovou OOP je třída
• ve třídách si definujeme proměnné a metody
• proměnné reprezentují data, metody operace s daty
• konstruktor se zavolá při vytváření objektu, takže je to prostředek k tomu, jak automaticky zavolat nějaké akce na objektu
• pro konstruktor se implementuje metoda __construct()
• obdobou __destruct() pro desktruktor
• klíčové slovo static - při použití půjde o třídní položky
• statické metody nejsou přístupné pomocí $this->; takto jsou dostupné jen normální metody (to samé pro proměnné)
• ve třídě lze pro statické používat self:: místo $this->
• pokud není u metod specifikována viditelnost, tak je defaultní public
• třídní konstanty normálně pomocí klíčového slova const; např. const pi = 3.14;
• přístupuje se k ním jako ke statických proměnným - tedy např. self::pi
• ve standardním PHP jsou 2 cesty, jak přiřazovat data do proměnné - hodnotou nebo referencí
• hodnoty jsou běžné při používání jednoduchých typů
• i u jednoduchých lze ale využít referenci - např: $a=1; $B =& $a;
• u objektů se používají reference
• když chceme udělat kopii objektu, voláme clone; např. $objekt2= clone $objekt1;
• parent pro přístup k původním položkám základní třídy
• ohledně rozhraní jsou podstatná klíčová slova implements a interface
• __construct() a __destruct jsou zástupci tzv. magických metod
•  další magické metody: __call(), __get(), __set() - dovolují přistupovat k metodám a proměnným objektům, které nebyly explicitně definovány
• dále __toString(), což je obdoba toString() z Javy
• call() - má dva parametry a je zavoláno, když je na objektu zavolána metody, kterou objekt vůbec neobsahuje
• .__get() a __set() - gettery a settery pro proměnné, které třída vůbec neobsahuje, ale díky tomuto vlastně obsahovat začne; pokud přiřadíme hodnotu do proměnné, která ve třídě vůbec není, volá se metoda __set
• __sleep je voláno předtím, než je objekt serializován; vhodné např. pro automatické ukončování DB spojení a vyčištění resources* __wake je naopak pro případy, když je voláno unserialize()

Lisp - funcall

20:01 22.06.2010 | Štítek: Programování

(funcall '+ 1 2 3 4 5) ;15 
(funcall + 1 2 3 4 5) ;chyba 
(setf funkce '+) ;+ 
funkce ; + 
(funcall funkce 1 2 3 4) ;10 
(funcall funkce '(1 2 3 4)) ; chyba 

;struktura funcall: (funcall Fn Arg1 Arg2 ... Argn) 

(funcall + 2 3) ; ko 
(funcall '+ 2 3) ; 5 
(funcall '+ 3 4 5 6 7) ;25 

(defun mojePlus (m n) 
   (+ m n) 
) 

(funcall 'mojePlus 3 4) ; 7 
(funcall 'mojePlus 3 4 5) ; ko, mojePlus umi pracovat jen s dvema argumenty 

(defun mojePlus(seznam) 
   (cond 
      ((null (cdr seznam)) (car seznam)) 
      (t (+ (car seznam)(mojePlus (cdr seznam)))) 
   ) 
) 

(defun mojePlus2 (&rest b) 
   (cond 
      ((null b) nil) 
      (t (mojePlus b)) 
   ) 
) 

(funcall 'mojePlus2 1 2 3 4) ;10 
(funcall 'mojePlus 1 2 3 4) ; ko, spatny pocet argumentu, chce to jen 1 argument

Lisp - struktury

20:11 22.06.2010 | Štítek: Programování

(defstruct clovek 
   (vek 0) ; defaultni hodnota je 0 
   rodneCislo ; defaultni hodnota je nil 
);defstruct 

(setf a (make-clovek)) ; #S(CLOVEK :VEK 0 :RODNECISLO NIL) 

(a-rodneCislo) ; ko Undefined operator A-RODNECISLO 
(clovek-rodneCislo) ; ko 

(defun praotec-cech () 
  (make-clovek :vek 1400)) ; praotec-cech 

(praotec-cech-vek); ko Undefined operator PRAOTEC-CECH-VEK 

(setf praotec (praotec-cech)) ;#S(CLOVEK :VEK 1400 :RODNECISLO NIL) 
(print praotec) ; #S(CLOVEK :VEK 1400 :RODNECISLO NIL) 
(print praotec-vek) ; ko variable PRAOTEC-VEK is unbound. 

Tak tyto letmé pokusy, jak fungují struktury nic moc. Zkusme to znova:

(defstruct clovek 
   (vek 0) 
   rodneCislo 
) ;defstruct 

(defvar pokusnyClovek (make-clovek)) ; POKUSNYCLOVEK 
(print pokusnyClovek) ;#S(CLOVEK :VEK 0 :RODNECISLO NIL) 
(pokusnyClovek :rodneCislo 123456789) ; ko, undefined operator pokusnyClovek 
(setf pokusnyClovek :rodneCislo 123456789); ko Odd number of args to SET 
(setf pokusnyClovek-rodneCislo 123456789) ;123456789 
(print pokusnyClovek) ;#S(CLOVEK :VEK 0 :RODNECISLO NIL) 

(setf (clovek-rodneCislo pokusnyClovek) 123456) ;123456 
(print pokusnyClovek) ;OK tohle je to, co chceme #S(CLOVEK :VEK 0 :RODNECISLO 123456) 
(setf (clovek-vek pokusnyClovek) 99) ; 99 
(print pokusnyClovek) ;#S(CLOVEK :VEK 99 :RODNECISLO 123456) 
(print (clovek-vek pokusnyClovek)) ;99 
(print (clovek-rodneCislo pokusnyClovek));123456 

-rozšíříme předchozí:

(defstruct (muz 
   (:include clovek) 

);muz 
   ;(rodneCislo 50) );defstruct 

(defvar pokusnyMuz (make-clovek)) ;POKUSNYMUZ 
(print pokusnyMuz) ;#S(CLOVEK :VEK 0 :RODNECISLO NIL) 
(setf (muz-vek pokusnyMuz) 40); ko 
(setf (clovek-vek pokusnyMuz) 30); 
(print pokusnyMuz) ; #S(CLOVEK :VEK 30 :RODNECISLO NIL) 

Zavedli jsme si muže, ale co umí, jsme si ještě nevyzkoušeli, protože sem místo make-muz dal make-clovek. Rozšiřujme tedy dál:

(defstruct (zena 
   (:include clovek) 
     );zena 
     (velikostPrsu 1) 
);defstruct 

(defvar pokusnaZena (make-clovek)) ;pokusnaZena 
(print pokusnaZena) ;#S(CLOVEK :VEK 0 :RODNECISLO NIL) 

(defvar zenaPokus (make-zena)) 
(print zenaPokus) ; #S(ZENA :VEK 0 :RODNECISLO NIL :VELIKOSTPRSU 1) 
(print pokusnyMuz) ; #S(CLOVEK :VEK 30 :RODNECISLO NIL) 

(defvar muzPokus (make-muz)) 
(print muzPokus) ;#S(MUZ :VEK 0 :RODNECISLO NIL) 
(setf (muz-vek muzPokus) 15) ; 15 
(print muzPokus) ;#S(MUZ :VEK 15 :RODNECISLO NIL) 
(setf (clovek-vek muzPokus) 14) 
(print muzPokus) 
(setf (clovek-velikostPrsu zenaPokus) 3) ; ko 
(setf (zena-velikostPrsu zenaPokus) 4) 
(print zenaPokus) ; #S(ZENA :VEK 0 :RODNECISLO NIL :VELIKOSTPRSU 4) 
 

A další tuning. Pro struktury jsou totiž k dispozici různé defaultní funkce, tak si je zkusíme nějak změnit:

(defstruct (neandrtalec 
           (:include clovek) 
           (:conc-name n-) ; nemusime psat nendrtalec-vek, ale staci jen n-vek 
      (:constructor new-neandrtalec) ;misto make-neandrtalec, se musi napsat new-neandrtalec 
      (:predicate is-neandrtalec?) ; nahrada za neandrtalec-p 
      (:copier clone-neandrtalec) ; defaultne je copy-neandrtalec 
           (:print-function (lambda (struct stream d) 
              (format stream "#   (pocetParneru 0 :type number) 
   (semLesba t :read-only t) 
) ;defstruct 

(defmethod nastavVek5 ((l lesba)) 
    (setf (lesba-vek l) 5) 
) 

(setf pokusLesba (make-lesba)); #S(LESBA :VEK 21 :RODNECISLO NIL :POCETPARNERU 0 :SEMLESBA T) 
(nastavVek5 pokusLesba) ;5 
(print pokusLesba) ;#S(LESBA :VEK 5 :RODNECISLO NIL :POCETPARNERU 0 :SEMLESBA T) 
 

Výpočet velikostí všech podstromů paralelně

20:22 22.06.2010 | Štítek: Počítače

(Výpisky z přednášky předmětu Paralelní systémy a algoritmy. Dále neopravováno.)

• algoritmus pro výpočet velikostí všech podstromů paralelně
• počítají se uzly včetně lokálního kořeně
• počítá se velikost celého podstromu, co je pode mnou
• list je podstrom o velikosti 1
• 2 metody výpočtu
• jedna metoda předpokládá, že spočtu rodiče (předešlý algoritmus), a pak jestliže vim, že mám rodiče, tak se podívám na rank hrany, která vede k rodiči, pak se podívám na hranu opačnou, udělám rozdíl; přičtu jedničku vydělim 2 - každá hrana jdoucí z uzlu nahoru se navštíví jednou, ale jdeme i tam, takže každá hrana se na tom podílí dvojkou
• jde to udělat i jinak; nemusíme tu mít k dispozici znalost rodičů; plyne z pozorování; označim si všechny hrany jdoucí nahoru jedničkou, dolu nulou, velikost podsdtromu je počet hran jdoucích dolu; je to dáno tím, že každý uzel má jednu hranu, která do něj vstupuje shora
• je zde PSS - paralel sufix sum
• tato 2 řešení nemají stejnou složitost
• třetí varianta je párování zárovek
• hlavinu každé zárovky spočteme tak: otevírací závorce přiřadíme jedna, uzavírací -1; představme si DFS průchod

Lisp - Výstup na obrazovku

20:33 22.06.2010 | Štítek: Programování

(format "text") ; chyba 
(format t "text") ; vypise text a navratovou hodnotu nil 
(format nil "text") ; vypise text a nevypise navratovou hodnotu nil 
(format nil "text" x) ;chyba 
(format nil "Text" 'x) ; vypise text 
x ; vypise text, protoze v predeslem prikazu doslo k ulozeni textu do promenne text 
(format t "text" 'x) ; vypise text a nil 
x ; vypise  novy text vlozeny do x a nil 
(setf y 123) ; y=123 
(format t "y=~s" y) ; vypise y=123 a nil 
(format nil "y=~s" y) vypise y=123 

(princ y) ; vypise 123 a 123 - jedno je vypis, druhe je navratova hodnota 
(print 2) ; vypise 2, navratova hodnota je 2, oproti princ dela za textem enter 

(format nil "druha mocnina cisla ~S je ~S" 3 (* 3 3)) ; vypise: druha mocnina cisla 3 je 9 

; princ má takovouto strukturu: (princ 

NetBeans

20:44 22.06.2010

• je to především javovské IDE
• multiplatformní  - běží to všude, kde bě?ž JDK 
• lze změnit L&F
• je to i platforma - lze vzít Netbeans jako základ a postavit na nich vlastní aplikaci, tj. nemusíme psát hodně kódu, který je již napsaný
• je to i komunita
• v roce 1996 začatý jako studentský projekt na Matfyzu, pak vznikla firma, kterou později koupil Sun
• jde si tam přiinstalovat Profiler, který pomáhá, když máme problémy s výkonem
• Matisse - komponenta pro vytváření GUI pomocí "kreslení" - GUI builder
• dostupný SQL editor
• GroupLayout - dobrý layout; je v tom Matisu, je to od JDK 6
• CVS - verzovací systém; projekt se importuje do CVS
• jsou i jiné systémy pro verzování - např. na Update Center
• moduly - do Netbeans si můžu přidat vlastní modul (projekt) - tj. vlastně to, jak bylo řečeno, že Netbeans můžeme využít jako základ pro své aplikace
• při novém projektu dát Modul Project
• Netbeans jsou velmi modulární - všechno je takový plug-in
• my si některé z těch modulů můžeme vzít a použít je ve své aplikaci
• vlatní aplikace - create standalone aplication - zůstanou jen důležité části, z nich lze potom i nadále odstraňovat zbytečnosti procházením stromu projectu; přidávání přes properties
• NetBeans IDE je Open Source vývojové prostředí pro jazyk Java
• firma Sun Microsystems v roce 2000
• vývojové prostředí je vytvářeno v jazyce Java 
• vývojové prostředí může podporovat jakýkoliv jazyk
• vývojové prostředí je bezplatně šiřitelný produkt, který je možné používat bez jakýchkoliv omezení
• NetBeans Platform je modulární a rozšiřitelný základ pro použití při vytváření rozsáhlých aplikací
• nezávislí dodavatelé SW nabízejí moduly pro integraci do této platformy
• oba produkty jsou vyvíjeny pod licencí Open Source a je možné je bezplatně používat v komerčním i nekomerčním prostředí
• zdrojový kód je dostupný pod licencí Common Development and Distribution Licence (CDDL)

Programovací techniky

20:55 22.06.2010 | Štítek: Počítače

(výpisky z přednášky)

• 60. léta - objevily se první multiprogramové či pseudoparalelní systémy
• Programy, psané s paralelními konstrukcemi, nemusí nutně být spracovávány paralelně, ale mohou být implementovány jednoduše v pseudoparalelním prostředí
• proces, pro naše účely definován jako instance programu či část programu, který je plánován pro nezávislé provádění
• vlákno (thread) označuje samostatnou posloupnost po sobě jdoucích operací
• pojmy proces a vlákno odli?ovat, proces se vnitřně nedělil, ale dnes je stále více programů vícevláknových ímultithread), tj. v kontextu jednoho procesu může zároveň běžet více vláken a vlákno je základní plánovací entitou pro plánovač operačního systému. Vlákna jednoho procesu sdílí adresní prostor.
• Zásadním rozdílem mezi multithreadovým a multiprocesovým multitaskingem je důsledkem sdílené paměti nižší režie při přepínání, obdobně i vytváření a rušení vlákna a samozřejme i úspora paměti
• stavy procesu: executing, blocked, waiting
• Každý proces ve výpočetním systému má svůj deskriptor, který je udržován v aktuálním stavu JOS. Ka?dý proces má svoji identifikační číslo pid. Správu procesů má ve své režii plánovač procesů, který odpovídá za efektivní využití strojového času.Ten eviduje o každém procesu jeho aktuální stav globálně i v detailech. Globální stav řídí přidělování procesoru podle stavového diagramu procesů
• důvody čekání: V/V operace, nedostatek paměti, pozastavení procesu na jeho vlastní žádost, čekání do dokončení procesu
• fronty pro čekající a blokovaný; Fronty jsou implementovány jako řetězené seznamy deskriptorů procesů. Každý proces má svoji tzv. dispečerskou prioritu, která se dynamicky mění. Procesu aktivnímu priorita klesá, procesům čekajícím roste. Fronty jsou uspořádány ve smyslu priorit - procesy s vyšší prioritou předbíhají procesy s prioritou nižší
• Každý z procesorů může být individuálně přidělen procesu a může mít svou vlastní frontu
• některé procesory provádějí stejné instrukce na svých množinách dat synchronně. Takové systémy se označují jako SIMD (single-instruction, multiple-data).
• V jiných architekturách mohou pracovat procesory nezávisle, příkladem je architektura MIMD (multiple-instruction, multiple-data), kde se dokonce principielně nevyžaduje stejná rychlost procesorů
• může být sdílena i paměť
• Systém s centrální pamětí, společnou pro všechny procesory, se nazývá systém se sdílenou pamětí (shared-memory), zatímco systém, kde má ka?dý procesor svou paměť, se nazývá systém s distribuovanou pamětí (distributed-memory, ka?dý procesor má vlastní paměť)
• kompromis: každý procesor má vlastní paměťový prostor + sdílenou paměť pro meziprocesorovou komunikaci
• Operační systém může přiřadit ve výpočetním systému se sdílenou pamětí části této fyzické paměti exkluzivně jednotlivým procesorům, další část paměti na simulaci komunikačních kanálů mezi procesory, a tím vytvořit navenek systém s distribuovanou pamětí
• Operační systém musí poskytovat:
• prostředky pro tvorbu a rušení procesů
• prostředky pro správu více procesorů a procesů, přiřazování procesů procesorům nebo metody pro rezervaci procesorů pro použití konkrétním programem
• u systému se sdílenou pamětí mechanizmus pro vzájemně exkluzivní sdílení paměti, užitý jak pro synchronizaci procesů, tak i meziprocesní komunikaci
• u systému s distribuovanou pamětí mechanizmus pro tvorbu a správu komunikačních kanálů mezi procesory, používanými jak pro synchronizaci procesů, tak i meziprocesní komunikaci
• Nejjednodušší z možností využití více procesorů pro účely paralelního zpracování je ponechat na překladači a jeho optimalizačních metodách spolu s operačním systémem rozhodování o přiřazení a využití procesorů. Tato metoda nezaji??uje optimální řešení
• Jsou dva základní způsoby vzniku nového procesu:
• 1) běžící proces vytvoří kopii sebe sama. Procesy mohou provádět odlišný kód; označované jako SPMD (single-programming, multiple-data)

• 2) segment kódu je explicitně spojen s novým procesem, proto různé procesy vykonávají různý kód - metoda MPMD (multiple-programming,multiple-data). Typický případ je fork-join model, kde proces vytváří několik potomků, každého s vlastním kódem (fork), a pak čeká na ukončení procesů potomků (join)

• paralelismus na úrovni příkazů
• paralelismus na úrovni procedur

• paralelismus na úrovni programu - v tomto případě se procesy mohou stát pouze celé programy; typické pro systému MPMD typu

• UNIX - systémová volání pomocí fork() - má za následek vytvoření kompletní a přesné kopie volajícího procesu, včetně všech proměnných a dat v okamžiku volání. Rozlišit mezi rodičem a potomkem lze uvnitř programu na základě návratové hodnoty volání fork() - v potomku vrací fork() nulu, zatímco rodiči vrací fork() číslo procesu potomka. Testováním této návratové hodnoty lze diferencovat mezi kódem, prováděným dále rodičem a kódem, prováděným dále potomkem; Synchronizace procesů rodiče a potomka lze dosáhnout voláním wait, které pozastavuje proces rodiče až do ukončení procesu potomka; konec pomocí exit

• uváznutí - deadlock - dva či více procesů čekají na provedení operace, která ale nemůže nastat (nebo? je součástí taktéž čekajícího procesu)
• K odstranění některých úskalí při užívání semaforů byl zaveden tzv. monitor
• operační systém může přerušit proces mezi libovolnými dvěma instrukcemi
• strojové instrukce typu TestAndSet, což je strojová instrukce, která testuje a zároveň v případě úspěchu inkrementuje nebo dekrementuje příslušnou paměťovou buňku
• starvation - hladovění

• Paralelismus v neprocedurálních jazycích:
• spíše ve stádiu experimentů
• v Prologu AND-paralelimus (vyhodnocování více hodnot paralelně procesy potomků), OR-paralelismus (paralelně běží více alternativních procesů)

EREW PRAM QuickSort

21:11 22.06.2010 | Štítek: Počítače

(výpisky z přednášky, které neprošly korekcí)

• erew pram paralelní quicksort - je celá řada paralelních algoritmů na tohle téma; lze to založit na segmentovém výpočtu; po první otočce máme 3 segmenty - o těch nevíme, jak jsou veliké
• použijeme prefixový součet na 2 úrovních; na první úrovni je to použito pro rozdistribuování pivotů (každý segment musí mít pivota); rozdistribuovat pivot lze pomocí prefixového součtu; co je to za operaci, že číslo a se šíří zleva doprava na konec segmentu; a + b = a
• každý segment se po jedné otočce rozpadne na 3 podsekgmenty
• z toho, že je přirozeně rekurzivní, plyne, že lze i celkem dobře paralelizovat
• lze špatně zvolit medián; takže složitost n log n se pomalu natahuje na n^2 u sekvenčního; takto to paralelizovat je na nic, protože jeden by mohl být velký a druhý malý; správně je to přes segmentový prefixový výpočet
• v rámci každého segmentu si zvolim medián
• musíme zhustit všechna čísla menší než nějaký ten medián; dochází k rekurzivnímu opakování operace zhuštění
• jak vymyslet medián? Může to být např. první prvek v segmentu; ostatním to sdělím pomocí prefixového součtu; ta operace, co ten přesun zařídí, má charakter a + b = a - první prvek se rozšíří do hranic segmentu, a dál ne

• zase tu nějak musíme zareagovat na ty problémy s pivotem, abychom většinu čísel neměly na jedné straně
• aby to bylo správnější, udělá se to přes segmentový prefixový výpočet
• sekvenční QuickSort vyrábí intervaly čísel menších než medián, stejných a větších, a to samé u všech segmentů
• vlastně se tu zhušťují čísla v každém segmentu, kde potřebuju dát na jednu stranu čísla menší a na druhou stranu čísla větší
• tedy dochází tu k postupnému rekurzivnímu provádění zhuštění
• operace, která zařídí šíření hodnoty až na hranice segmenu je a+b=a - tím dosáhnu rozšíření prvního prvku segmenu do hranic a dál ne

Výpisky z přednášky o síle, energii a gravitaci

22:00 22.06.2011

(jde o přepis z přednášky; text může obsahovat chyby a špatně formátované indexy a mocniny)

Derivace

• f' = lim (h -> 0) z ( f(x+h) - f(x) )/h
• vezmu funkční hodnotu v místě x a v místě o něco dál (plus h) - udělám rozdíl (na ose y) - můžeme to označit jako delta t; na ose x máme delta x
• přírůstek funkce lomeno rozdílem na ose x; když s tím jdeme k nekonečně malým hodnotám, dostaneme směrnici tečny; úhel mezi touto tečnou a osou x je alfa; tg alfa = delta t / delta x
• toto je zbytečně složitý zápis; zavedeme si, že delta znamená konečný přírůstek a d nekonečně malý přírůstek; do toho d jsme schovali tu limitu
• lim (delta x -> 0) = delta t / delta x = dt / dx
• můžeme tedy napsat, že f' = dt / dx
• df = f' dx 
• delta f je přibližně f' delta x
• př: Kruh o poloměru r; S(r) = pí r2
• dS = S' dr
• dS = 2 pí r dr
• když chceme Lagrangeovu větu, budeme mít konečné přírůstky, ale přibližně delta S = 2 pí r delta r
• vlastně kolem toho našeho kruhu uděláme "křužnici", její nekonečně malá šířka je dr, její délka je 2 pí r; dS = 2 pí r dr - vlastně k obvodu jsme přidali nějakou plochu navíc
• 1 diferenciál je přesný vztah za cenu, že pracuju s nekonečně malými hodnotami
• Lagrangeova věta dává přibližné, ale praktické hodnoty; vždyť tady bychom ani přesný obdélník dostat nemohli, protože čím jsem dál od středu kruhu, tím je obvod větší

Funkce více proměnných

• f(x,y,...,n,o,...,ž)
• budu chtít zjistit, jak se ta funkce mění, když měním jendotlivé proměnné, tj. vlastně měním jen jednu a ostatní jsou stejnéo, takže se dostávám k parciálním derivacím, kdy se derivuje jen podle jedné proměnné
• df = vt/vx dx + vt/vy dy + ..., kde v je označení pro parciální derivace
• Lagrangeova věta bude vypadat takto: delta f = vt/vx delta x + ... vt/vž delta ž
• př.: válec výšky h a poloměru r, jeho objem je funkcí 2 proměnných V(r,h)
• V = pí r2 h
• dV = vV/vr dr + vV/vh dh = 2pí r h dr + pí r2 dv
• delta V = 2 pí r h delta r + pí r2 delta h
• když ten plášť rozvinu jako do šířky, že by by ta šířka válce byla pak větší, tak h zůstává stejné a r se zvětší o dr; 2 pí r h dr
• když bych to změnil nahoře, tedy válec by byl jakoby vyšší, čili byl přidán proužek o téměř nulové výšce a o šířce válce; změna o dh
• delta V = pí r2 d h
• když ty přírůstky budou konečné, tak to přestane fungovat
• ale když si zkusím zvětšit všechny strany, tak vlastně dostávám rohy, kde se to nezvětšilo a kde mi vzniká takový zub - je to proto přibližné, ty kousky v rohu se nezahrnují
• v počítači musíme použít co nejmenší konečné přírůstky

Síla a energie

• tlačíme těleso silou F po dráze l
• A = F l ; vykonaná práce je síla krát dráha; tohle je vzorec ještě ze základky
• na střední škole jsme připustili, že ta síla působí jiným směrem, že např. máme nějaký kvádr na podložce, který aby se pohyboval do prava, tak my ho táhneme, a je to pro nás přirozené, že ho táhneme směrem někam mezi nahoru a do prava; mezi podloužkou a směrem síly F je úhel alfa; vzorec pro sílu pak je A = F l cos alfa
• síla i dráha mají nějaký směr
• vektor krát vektor krát cosinus úhlu je skalární součin, tedy můžeme napsat A = F^ * l^ , kde stříškou značím vektory
• na vysoké už se to definovalo pomocí derivací, protože ta síla se může dynamicky měnit během dráhy a ta nemusí být rovná; můžeme si to rozsekat na menší kousíčky, kde je to statické a tam to počítat jako na střední; celková práce je pak posčítání, což je integrál dA = F^ dl^ ; A = integrál z F^ dl^
• na počítači to budeme dělat přes cyklus, což je ale v podstatě integrál
• skalární součin vektorů lze zapsat jako a^ * b^ = ax*bx + ay*by + az*bz
• dA = F^ dl^ = Fxdx + Fydy + Fzdz
• Fxdx je vA/vx z Langrangeovy funkce; v značím parciální derivaci
• tedy Fx = vA/vx, Fy = vA/vy, Fz = vA/vz
• fyzikové zavádějí pojem potenciální energie dWp = -dA
• Fx = -vW_p/vx ; Fy = vWp/vy ; Fz = -vWp/vz (v jsou parciální derivace)
• toto je vztah mezi potencionální energií a silou, je to dlouhé, takže to zapíšeme jako F^ = -vWp/vx^ = - grad Wp
• mínus gradient vlastně míří k minimu funkce
• mějme funkci s nějakým klikatým průběhem, a vezmeme-li si na ní vždycky nějaký bod, tak síla v tomto bodě bude vždycky působit k lokálnímu minimu
• když do ďolíčku, nebude na něj působit síla
• kmity když - při ďolíčkách, protože při jeho průchodu je setrvačná energie, takže se dostaneme dál, a pak se vrací
• kmity očekáváme tam, kde je minimum potenciální energie
• dokonalý ďolíček má parabolu (x2); harmonické oscilace mají parabolický průběh potenciální energie, kdy je minimum ve tvaru paraboly
• př.: Wp = 1/2 k x2 = a x2 ; F = -dWp/dx = - k x
• síla je úměrná výchylce a má opačný směr
• potenciální energie je jedna veličina, síla 3, takže preferujeme potenciální
• m x^ = F^ , kde ' je první derivace podle času
• toto jsou ale vlastně 3 rovnice, máme tam vektor
• v = dx/dt = x'
• a = dv/dt = v' = x
• m x = -vWp/vx ; my = -vWp/vy ; mz = -vWp/vz
• toto pak většinou počítáme při výpočtech
• nejjednodušší potenciální je nulová, pak lineární, pak parabolická

• př: Coulombův zákon; máme náboj Q ve středu souřadnicové soustavy a náboj q, který se pohybuje kolem, tak potenciální energie je rovná Wp = (q Q)/(4 pí epsilion0 r)
• Fx = -vWp/vx = - v/vx (q Q)/(4 pí eplison0 r) = - q Q / (4 pí epsilon0) * v/vx * 1/odmocnina(x2 + y2 + z2 ) = -(q Q v)/(4 pí epsilon0 vx)*(x2 + y2 + z2 )-1/2 * 2x * (-1/2) * (x2 + y2 + z2)-3/2 = q*Q/ (4 pí epsilon0)* x/(x2 + y2 + z2)3/2
• Fy = Q q / (4 pí epsilon0) * y/(x2 + y2 + z2 )3/2
• Fz = Q q / (4 pí epsilon0) * z/(z2 + y2 + x2 )3/2
• toto je Coulombův zákon, s kterým lze na počítači počítat
• F = odmocnina (Fx2 + Fy2 + Fz2)

Gravitace a tíže

• gravitační zákon vypadá podobně jako u těch nábojů
• Wp je příbližně m M / r =
• W p = -G m M/r
• konstanta úměrnosti se značí G a je to F = F m M /r2
• y = 1/x je hyperbola
• čím jsme dál od železa, tím je gravitace větší, a čím jsme blíž, tím to roste, ale k nule; díky tomu je vesmír, protože všechno ostatní je plus a dohromady je to 0
• E = Wp + h Y

Pohyb při povrchu Země

• mějme systém souřadnic, kde na jední ose je Wp a na druhé vzdálenost od středu Země; povrch je od středu vzdálená cca 6400 km; křivka pro závislost má tvar hyperboly; když si s ní uděláme točnu při těch 6400 km, tak prostě kousek od povrchu lze tu hyperbolu stotožnit s přímkou, protože se to zas tak moc nezmění
• tomu nahrazení přímkou se říká tíže (nahrazení lineární závislostí)
• potenciální energie v tíži je Wpt = m g h
• ta tíže je ještě zvrácenější než gravitace, neroste k nule, ale k nekonečnu, v linearizaci je chyba, platí to pouze při povrchu do cca 10 km; tíže je pouze rozvoj
• tedy pro pohyby v blízkosti tělesa to lze použít, ale pro pád meteoritu nikoli