Knihovny pro fyzikalni vypocty

1. Knihovny pro fyzikalni vypocty Milan Holec FJFI CVUT v Praze

2. Fortran Fortran je nejstarsi dosud stale pouzivany jazyk.Pravdepodobne diky rychlosti,vykonu a dostupnosti osvedcenych a rozsahlych knihoven.

3. Na ukazku uplne jednoduchy program, ktery jen nacte ze vstupu 3 hodnoty ve stupnich Celsia,doplni dalsich 6 a nakonec vypise 9 hodnot ve Fahrenheitove stupnici. V 1. casti je deklarace promenych V 2. casti je nacteni hodnot ze vstupu Ve 3. casti je doplneni hodnot a konverze na Fahren. Ve 4. casti je vypsani hodnot na obrazovku KOMENTAR: U druheho cyklu je pouzita tzn. “navest”...100 a prikaz continue program Convert implicit none ! --------------------------Deklarace real*4 tempC(9)/9*0/, tempF(1:9), K integer*2 ZERO_SHIFT, i, j parameter(ZERO_SHIFT=32,K = 9./5.) ! ------------------------------Input write(*,*) “3X teplota v Celsius..." do i=1,9,4 read*, tempC(i) end do ! ----------------------------Compute do i=2,4 j = i + 4 tempC(i) = (tempC(i-1) + tempC(i+1))/2 tempC(j) = (tempC(j-1) + tempC(j+1))/2 end do !forall(i=1:9:2) tempC(i) = tempC(10-i) do 100, i=1,9 tempF(i) = K * tempC(i)+ ZERO_SHIFT ! -----------------------------Output print*, “Odpovidajici konverze je” print*, tempF(i), “F stupnu“ 100 continue end SYNTAXE FORTRANU

4. FFT Knihovna pro rekursivni Fourierovu transformaci http://faculty.prairiestate.edu/skifowit/fft/

5. Takto vypada diskretni F transformace Jeji narocnost je O(N^2). Vyuzitim Cooley-Tukey algoritmu,ktery je zalozen na trhani sumy po lichych a sudych clenech se da narocnost snizit az na O(n*lnN). Podminkou je jen rozdeleni def.oboru fce na N=2^m dilku(koeficientu) 100 J = 1 N1 = N - 1 DO 104, I = 1, N1 IF ( I .GE. J ) GOTO 101 XT = X(J) X(J) = X(I) X(I) = XT 101 K = N / 2 102 IF ( K .GE. J ) GOTO 103 J = J - K K = K / 2 GOTO 102 103 J = J + K 104 CONTINUE Kde X(J) je prvni cast sumy a X(I) je druha cast sumy. Na ne se opet rekurzivne aplikuje deleni na dve casti ALGORITMUS FFT

6. STANDARTNI KNIHOVNY

7. L-M interaction Maxwell-Schrödinger Model Interakce latky a laseru a propagace zareni Metodou site

8. L-M interaction Intensivni ultra-kratky laserovy paprsek interaguje s vodikovym plynem H2+ ve vakuu Model popisuje sireni radiacniho zareni plynem. Z fyzikalniho hlediska jde o polarizaci molekul el.polem. Tim jsou svazany Maxwellovi makroskopicke rovnice s Schrödingerovou rovnici dynamiky Kde P(r`,t) je polarizace molekuly

9. SCHEMA EXPERIMENTU

10. SCHEMA POLARIZACE

11. RESONANCE • Pro zkoumani sireni el.vlny je dulezita resonance cyklotronove frekvence elektronu v potencialu jadra.Kdyz laserovym pulsem spravne excitujeme elektron dochazi k ionizaci... • A naslednym navedenim elektronu zpet k jadru se emituje zareni o nekolikanasobne frekvenci nez puvodni...

12. DIFFERENCE VELICIN • Pouzite vztahy pro differencni metodu parcialnich diff.rovnic • Z vyjadreni derivace polarizace • ziskame z Yee schematu zavislost el.intenzity • Vlnovou fci muzeme dle Crank-Nicolsonova schematu zapsat

13. NUMERICKA METODA • Pres slozitost sparovani makroskopickych rovnic el.mag. pole • a kvantove mechanicke rovnice je uloha resena pouze jednoduchou differencni metodou.Cilem je vyjadrit co nejpresneji Polarizaci • Musime resit odpovidajici pocet parcialnich diff. rovnic dle poctu bunek

14. REFERENCE • http://www.fortran.com/tools.html • standartni knihovny ke stazeni + priklady a implementace • http://www.cse.yorku.ca/~roumani/fortran/index.html • Strucny guide pro zaklady fortranu a compilator pro windows • http://faculty.prairiestate.edu/skifowit/fft/ • Home web knihoven pro Fast Fourier Transformation • http://en.wikipedia.org/wiki/ • Obecne informace o cemkoliv • http://cpc.cs.qub.ac.uk/cpc/ • Robustni databaze knihoven napsanych vetsinou ve fortranu

26. STL - Kontejnery • Asociativní kontejnery - odebírání • podle klíče • size_type set::erase( T x) • size_typemultiset::erase( T x) • size_typemap::erase( K x) • size_typemultimap::erase( K x) • odebere všechny prvky s klíčem ekvivalentním zadanému x • vrací počet odebraných prvků • operace má logaritmickou složitost • vzhledem k velikosti kontejneru • plus lineární k počtu odebraných prvků • po operaci budou dříve existující iterátory neplatné

27. STL - Kontejnery • Asociativní kontejnery - odebírání • podle iterátoru - jeden prvek • void set::erase( iteratorp) • void multiset::erase( iteratorp) • void map::erase( iteratorp) • void multimap::erase( iteratorp) • odebere prvek na který odkazuje iterátor p • p nesmí být rovno end() • operace má konstantní složitost • rozumí se amortizovaná složitost • po operaci budou dříve existující iterátory neplatné

28. STL - Kontejnery • Asociativní kontejnery - odebírání • podle iterátoru - interval • void set::erase( iteratorp, iterator e) • void multiset::erase( iteratorp, iterator e) • void map::erase( iteratorp, iterator e) • void multimap::erase( iteratorp, iterator e) • vyjme všechny prvky mezi p a e, včetně p a vyjma e • p nesmí být rovno end() • operace má složitost logaritmickou vůči velikosti kontejneru • plus lineární vůči počtu odebraných prvků • po operaci budou dříve existující iterátory neplatné

29. STL - Kontejnery • map - operator [ ] • T & map::operator[]( K x) • { return (*((insert(make_pair( x, T()))).first)).second; } • Vrátí referenci na hodnotovou (second) složku prvku s klíčem ekvivalentním x • Pokud takový prvek neexistuje, vytvoří jej • Jeho hodnotová složka bude T() • Tento operátor je možno používat pro vkládání, přepisování i čtení prvků kontejneru • Kontejner map se chová jako asociativní pole (perl, PHP,...) • Pozor: To neplatí u sekvenčních kontejnerů • Po této operaci (i v případě čtení) mohou být všechny iterátory odkazující na tento kontejner neplatné

30. STL – Ostatní • <algorithm.h> <algorithm> - užitečné algoritmy (for_each, sort, next_permutation, ...) • <functional.h> <functional> - podpora funktorů • <iterator.h> <iterator> - podpora iterátorů • <memory.h> <memory> - alokátory pro kontejnery • <numeric.h> <numeric> - jednoduchá matematika na prvcích kontejnerů • <utility.h> <utility> - pomocné konstrukce (pair,...)

31. STL – Algoritmy • Šablona funkce for_each • <algorithm> • template<class InputIterator, class Function> • Function for_each( • InputIterator first, • InputIterator last, • Function f); • first a last jsou iterátory, určující procházený úsek nějakého kontejneru (všetně first, mimo last) • f je buďto • globální funkce (ukazatel na funkci), nebo • funktor, tj. třída obsahující operator() • Funkce f (případně metoda operator()) je zavolána na každý prvek v zadaném intervalu • prvek se předává jako * iterator, což může být odkazem • funkce f tedy může modifikovat prvky seznamu

32. STL – Algoritmy • Šablona funkce for_each • <algorithm> • template<class InputIterator, class Function> • Function for_each( • InputIterator first, • InputIterator last, • Function f) • { • for (; first != last; ++first) • f( * first); • return f; • } • Skutečná implementace může využívat specifických vlastností procházených kontejnerů • Viz parciální specializace • Bude tedy rychlejší, než ručně psaný for cyklus! • Takto napsanou šablonu lze zkompilovat pro jakékoliv f, na které lze aplikovat operátor (), tedy jak pro funkci, tak pro funktor

33. STL – Algoritmy • Použití funkce for_each • void my_function( double & x) • { • x += 1; • } • void increment( list< double> & c) • { • for_each( c.begin(), c.end(), my_function); • }

34. STL – Algoritmy • Použití funkce for_each • class my_functor { • public: • double v; • void operator()( double & x) • { x += v; } • my_functor( double p) : v( p) {} • }; • void add( list< double> & c, double value) • { • for_each( c.begin(), c.end(), my_functor( value)); • }

35. STL – Algoritmy • Použití funkce for_each • class my_functor { • public: • double s; • void operator()( const double & x) • { s += x; } • my_functor() : s( 0.0) {} • }; • double sum( const list< double> & c) • { • my_functor f; • f = for_each( c.begin(), c.end(), f); • return f.s; • }

36. STL – Algoritmy • Použití funkce for_each • class my_functor { • public: • double s; • void operator()( const double & x) • { s += x; } • my_functor() : s( 0.0) {} • }; • double sum( const list< double> & c) • { • my_functor f; • for_each( c.begin(), c.end(), f); • return f.s; • } • Pozor: f se předává hodnotou - tato implementace vždy vrací 0.0

37. STL – Algoritmy • Použití funkce for_each • class my_functor { • public: • double s; • void operator()( const double & x) • { s += x; } • my_functor() : s( 0.0) {} • }; • double sum( const list< double> & c) • { • return for_each( c.begin(), c.end(), my_functor()).s; • }

38. STL – Algoritmy • Šablona funkce find • <algorithm> • template<class InputIterator, class T> • InputIteratorfind( • InputIterator first, • InputIterator last, • const T & value) • { • for (; first != last; ++first) • if ( * first == value ) • break; • return first; • }

39. STL – Algoritmy • Šablona funkce find_if • <algorithm> • template<class InputIterator, class Predicate> • InputIteratorfind_if( • InputIterator first, • InputIterator last, • Predicate pred) • { • for (; first != last; ++first) • if ( pred( * first) ) • break; • return first; • } • Predikát pred může být funkce nebo funktor

40. STL – Algoritmy • Přehled algoritmů • Průchod kontejnerem • for_each • Čtení kontejnerů • find, find_if - první prvek s danou vlastností • find_end - poslední výskyt druhé sekvence v první • find_first_of - první výskyt některého prvku druhé sekvence v první • adjacent_find - první prvek ekvivalentní sousednímu • count, count_if - počet prvků s danou vlastností • mismatch - první odlišnost dvou sekvencí • equal - test shody dvou sekvencí • search - první výskyt druhé sekvence v první • search_n - první n-násobný výskyt dané hodnoty

41. STL – Algoritmy • Přehled algoritmů • Swap • swap - výměna obsahu dvou objektů • Pomocí parciální/explicitní specializace bývá implementována rychleji, než kopírování • Modifikace kontejnerů výměnou prvků • swap_ranges - výměna obsahu dvou sekvencí (volá swap) • iter_swap - výměna obsahu dvou jednoprvkových sekvencí • Modifikace kontejnerů permutací (voláním swap) • partition, stable_partition - přemístění prvků s danou vlastností dopředu • random_shuffle - náhodná permutace dle zadaného náhodného generátoru • reverse - otočení posloupnosti • rotate, rotate_copy - rotace prvků

42. STL – Algoritmy • Přehled algoritmů • Modifikace kontejnerů přiřazením • copy, copy_backward - kopie první sekvence do druhé • transform - aplikace zadané unární/binární operace na každý prvek první/první a druhé sekvence a zapsání výsledku do druhé/třetí sekvence • replace, replace_if - nahrazení prvků s danou vlastností jinou hodnotou • replace_copy, replace_copy_if - kopie s nahrazením • fill, fill_n - naplnění sekvence danou hodnotou • generate, generate_n - naplnění sekvence z daného generátoru • Modifikace kontejnerů odebráním • remove, remove_if - smazání prvků s danou vlastností • unique, unique_copy - smazání opakujících se sousedních prvků • vhodné pro setříděné nebo asociativní kontejnery • Pozor: Tyto funkce neprodlužují ani nezkracují kontejner

43. STL – Algoritmy • Přehled algoritmů • Pozor: Algoritmy neprodlužují ani nezkracují kontejner • vector< int> a, b; • a.push_back( 1); a.push_back( 2); a.push_back( 3); • copy( a.begin(), a.end(), b.begin()); // ilegální použití • Pro tyto účely existují "vkládající iterátory" • <iterator> obsahuje tyto funkce vracející iterátory • back_inserter( K) - iterátor vkládající na konec kontejneru K • front_inserter( K) - iterátor vkládající na začátek kontejneru K • inserter( K, I) - iterátor vkládající před iterátor I do kontejneru K • tyto iterátory jsou pouze výstupní • lze je použít jako cíl ve funkcích typu copy • copy( a.begin(), a.end(), back_inserter( b));

44. STL – Algoritmy • Přehled algoritmů • min, max - minimum a maximum ze dvou hodnot • Třídění a spol. • sort, stable_sort - třídění • partial_sort, partial_sort_copy, nth_element - polotovary třídění • push_heap, pop_heap, make_heap, sort_heap - operace na haldě • min_element, max_element • lexicographical_compare • next_permutation, prev_permutation • Operace na setříděných kontejnerech • lower_bound, upper_bound, equal_range - hledání prvku • binary_search - test na přítomnost prvku • includes - test podmnožinovosti • merge, inplace_merge - sjednocení s opakováním • set_union, set_intersection - sjednocení, průnik • set_difference, set_symmetric_difference - množinový rozdíl

45. iostream vstupní a výstupní proudy

46. iostream • #include <iostream> • #include <iomanip> • using namespace std; • f() • { • int X; • double Y; • cin >> X >> Y; • cout << "X = " << hex << setw(4) << X << ", Y = " << Y << endl; • } • Manipulátory • hex - šestnáctkový výpis, setw - počet míst • platí pro daný stream (cout) trvale (do další změny) • endl - vloží oddělovač řádek

47. stringstream • #include <string> • #include <sstream> • #include <iomanip> • using namespace std; • string f( int a) • { • ostringstream x; • x << "a = " << a; • return x.str(); • } • <sstream> - *stringstream – spolupracuje se std::string • <strstream> - *strstream – spolupracuje s char *

48. iostream • Hlavičkové soubory • <fstream.h> <fstream> - souborový vstup a výstup (ifstream, ofstream, fstream) • <iomanip.h> <iomanip> - manipulátory pro nastavení parametrů formátovaného vstupu a výstupu (setw, setprecision, setfill, setbase, ...) • <ios.h> <ios> - základní funkce abstraktního souboru, základní nastavení formátu (hex, left, ...) • <iostream.h> <iostream> - standardní vstup a výstup (cin, cout, cerr) • <istream.h> <istream> - abstraktní vstupní a kombinované médium (istream, iostream) • <ostream.h> <ostream> - abstraktní výstupní médium (ostream) • <sstream.h> <sstream> - vnitřní paměť jako médium (istringstream, ostringstream, stringstream)

49. iostream • Abstraktní rozhraní • basic_...<T> jsou šablony • T = char - 8-bitové znakové sady • typedef: ios, istream, ostream, iostream, streambuf • T = wchar_t - 16-bitové znakové sady • typedef: wios, wistream, wostream, wiostream, wstreambuf dědičnost virtuální dědičnost nastavení formátovače ios_base ukazatel stav média basic_ios<T> basic_streambuf<T> virtuální funkce čtení a zápisu basic_istream<T> basic_ostream<T> přímé a formátované čtení přímý a formátovaný zápis basic_iostream<T>

50. iostream • Abstraktní rozhraní • funkce, které potřebují zapisovat, dostávají basic_ostream<T>& • void zapis_neco( ostream & o) • { • o << neco; • } dědičnost virtuální dědičnost nastavení formátovače ios_base stav média basic_ios<T> basic_ostream<T> přímý a formátovaný zápis