%
% Python scripting language a obliczenia i symulacje
%
% praca egzaminacyjna z MOwNiTu
%
% Copyright (C) 2001 Marcin Owsiany
%


\documentclass[titlepage,a4paper,10pt]{article}
\parindent       0.0cm
\textwidth      15.5cm
\textheight     24.0cm
\topmargin      -.4cm
\oddsidemargin    .1cm
\evensidemargin   .1cm
\usepackage[MeX]{polski}
\usepackage[polish]{babel}
\usepackage[latin2]{inputenc}
\pagestyle{headings}
\usepackage{url}

\author{Marcin~Owsiany\\{\it porridge@debian.org}\\\url{http://student.uci.agh.edu.pl/~porridge/studia.pl.html}}
\title{Python scripting language a~obliczenia i~symulacje}
\date{czerwiec 2001}
\begin{document}
\maketitle

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\section{Charakterystyka języka i podstawowych pakietów}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\subsection{Kod}

Python jest językiem interpretowanym, ale przy uruchomieniu kod źródłowy zawsze jest kompilowany do {\it byte-code}-u.

Po skompilowaniu python próbuje zapisać {\it byte-code} do pliku z rozszerzeniem {\tt .pyc}. Jeśli mu się to uda, to przy następnym uruchomieniu skryptu ładowany jest gotowy {\it byte-code}, dzięki czemu unika się ponownego parsingu.

Python przyjmuje flagi wymuszające optymalizację, ale nie ma ona wpływu na szybkość działania kodu, a jedynie na czas ładowania do pamięci.

Python udostępnia też deterministyczny profiler (zawarty w moduły profile i pstats). Zawiera on dodatkowo narzędzia do generowania raportów na temat rezultatów operacji profilowania.

\subsection{Składnia Pythona}

Niżej wymieniłem niektóre cechy składni Pythona, dzięki którym kod aplikacji może być bardziej zwięzły niż w innych językach. Cechy te nie mają rzecz jasna wpływu na szybkość obliczeń, ale niejednokrotnie ułatwiają pisanie bardziej zwartego kodu:

\begin{itemize}

\item Równoczesne podstawienia.

\begin{tabular}{|p{10cm}|}\hline
\begin{verbatim}
>>> a, b = 1, 2
>>> a, b = b, a+b
>>> a
2
>>> b
3
>>>
\end{verbatim}\\\hline
\end{tabular}

\item Łączenie operacji porównania w łańcuchy. Na przykład {\tt a < b == c} jest tym samym, co {\tt a < b and b == c}, z tym wyjątkiem, że w pierwszym przypadku wyrażenie {\tt b} jest obliczane tylko raz.

\item Obsługa operacji symbolicznych. Pozwala to niekiedy uniknąć iteracji na rzecz zwięzłego wyrażenia.

\end{itemize}

A oto inne właściwości Pythona, o których trzeba pamiętać podczas obliczeń.

\begin{itemize}

\item Operatory {\tt and} i {\tt or} są ``leniwe'', podobnie jak w C. Należy o tym pamiętać na przykład przy pisaniu wyrażeń wykorzystujących efekty uboczne funkcji.

\item Przypisanie nie może nastąpić w wyrażeniu, inaczej niż ma to miejsce w języku C.

\end{itemize}

\subsection{Właściwości numeryczne języka}

\subsubsection{Porównywanie}

Obiekty różnych typów (poza typami numerycznymi) nigdy nie mogą być równe. Obiekty tej samej klasy zazwyczaj są domyślnie klasyfikowane jako różne, chyba że klasa definiuje specjalną metodę {\tt \_\_cmp\_\_()}, która umożliwia porównywanie.

\subsubsection{Typy numeryczne}

Istnieją cztery typy numeryczne:


\begin{description}

\item [Zwykłe liczby całkowite (plain integers).] Zwane zazwyczaj po prostu liczbami całkowitymi, są zaimplementowane przy pomocy typu {\tt long} w języku C, dzięki czemu mają conajmniej 32 bity precyzji.

\item [Długie liczby całkowite (long integers).] Mają nieograniczoną precyzję.

\item [Liczby zmiennoprzecinkowe (floating point numbers).] Są zaimplementowane przy pomocy typu {\tt double} w języku C. Ich precyzja zależy od konkretnej maszyny, na której jest zainstalowany Python.

\item [Liczby zespolone (complex numbers).] Posiadają część rzeczywistą i urojoną, z których każda zaimplementowana jest przy pomocy typu {\tt double} w języku C.

\end{description}


Liczby tworzy się używając literałów liczbowych lub przy pomocy wbudowanych funkcji i operatorów.

Czyste literały całkowite (w tym liczby ósemkowe i szestnastkowe) powodują utworzenie zwykłych liczb całkowitych (plain integers). Literały całkowite z przyrostkiem {\tt L} lub {\tt l} powodują utworzenie długich liczb całkowitych. Literały numeryczne zawierające kropkę dziesiętną lub symbol eksponenty powodują utworzenie liczby zmiennoprzecinkowej.

Część urojoną liczby zespolonej zapisuje się używając przyrostka ``j'' lub ``J''. Całą liczbę zespoloną z o częściach: rzeczywistej: $x$ i urojonej: $y$ zapisuje się $z = x + yj$ (lub $z = x + yJ$), o ile $x$ i $y$ są literałami, lub tworzy przy pomocy funkcji {\tt complex(x, y)}. Argumentami funkcji {\tt complex()} mogą być zmienne dowolnego typu numerycznego (w tym typu zespolonego).

Aby pobrać wartości części rzeczywistej i urojonej liczby zespolonej {\tt z} należy użyć odpowiednio konstrukcji {\tt z.real} i {\tt z.imag}.

Python w pełni obsługuje arytmetykę mieszaną: gdy operator dwuargumentowy ma operandy dwóch różnych typów, przed wykonaniem operacji operand ``mniejszego'' typu jest konwertowany na ten drugi typ (gdzie podana wyżej kolejność jest kolejnością od ``najmniejszego'' do ``największego''). Takiej samej reguły używa się przy wykonywaniu porównań. (Dzięki temu lista [1, 2] jest równa [1.0, 2.0] itd.) Aby wymusić konwersję można wykorzystać wbudowane funkcje {\tt int()}, {\tt long()}, {\tt float()} i {\tt complex()}.

Funkcje konwersji na liczbę zmiennoprzecinkową i całkowitą ({\tt float()}, {\tt int()} i {\tt long()}) nie działają dla liczb zespolonych, ponieważ po prostu nie ma jednoznacznego sposobu przekształcenia liczby zespolonej na rzeczywistą. Aby otrzymać (jako liczbę zmiennoprzecinkową) moduł liczby zespolonej {\tt z} należy użyć konstrukcji {\tt abs(z)}, a {\tt z.real} -- aby otrzymać część rzeczywistą.

Wszystkie typy numeryczne obsługują następujące operacje (podane w rosnącej kolejności priorytetów):

\subsubsection{Wyjątki związane z obliczeniami}
\begin{description}
\item [ArithmeticError] Klasa podstawowa dla wszystkich wyjątków związanych z obliczeniami.

\item [FloatingPointError] Występuje w przypadku błędu w operacji zmiennoprzecinkowej. Jest zawsze zdefiniowany, ale może być zgłoszony tylko jeśli Python został skonfigurowany z opcją --with-fpectl, lub gdy w pliku config.h jest zdefiniowany symbol {\tt WANT\_SIGFPE\_HANDLER}.

\item [OverflowError]  Zgłaszany gdy rezultat operacji arytmetycznej nie mieści się w reprezentacji. Nie może się to wydażyć w przypadku operacji na długich liczbach całkowitych (które prędzej zgłoszą {\tt MemoryError}, niż się poddadzą). Z powodu braku standaryzacji sprawdzania wyjątków związanych z arytmetyką zmiennoprzecinkową w C, nie jest sprawdzana również większość operacji zmiennoprzecinkowych. W przypadku zwykłych liczb całkowitych sprawdzane są wszystkie operacje mogące wywołać przepełnienie, oprócz przesunięcia w lewo, ponieważ w większości jego zastosowań zamiast zgłoszenia wyjątku woli się utratę bitów.

\item [ZeroDivisionError] Zgłaszany w przypadku gdy drugi operand dzielenia lub operacji modulo jest równy 0. Z tym wyjątkiem związany jest łańcuch określający typy operandów i rodzaj operacji.
\end{description}


\subsection{Moduł {\tt math}}

Zapewnia on dostęp do podstawowych funkcji matematycznych określonych w standardzie C. Nie obsługuje on jednak liczb zespolonych (obsługę tych liczb można znaleźć w module cmath). Zawiera on następujące funkcje:

\begin{itemize}
\item {\tt acos()}, {\tt asin()}, {\tt atan()}, {\tt atan2(y, x)} ({\tt atan(y / x)}) 
\item {\tt cos()}, {\tt cosh()}, {\tt sin()}, {\tt sinh()}, {\tt tan()}, {\tt tanh()}
\item {\tt exp()}
\item {\tt fabs(x)} (bezwzględna wartość liczby zmiennoprzecinkowej {\tt x})
\item {\tt ceil(x)} (sufit({\tt x}) jako liczba zmiennoprzecinkowa), {\tt floor()} (podłoga({\tt x}) jako liczba zmiennoprzecinkowa)
\item {\tt fmod(x, y)} (zwraca {\tt fmod(x, y)}, tak jak jest zdefiniowany przez bibliotekę C danej platformy. Uwaga: wyrażenie Pythona {\tt x \% y} może zwrócić inną wartość)
\item  {\tt frexp(x)} (zwraca mantysę i eksponent liczby {\tt x} jako parę {\tt (m, e)}, gdzie {\tt m} jest liczbą zmiennoprzecinkową, a {\tt e} jest liczbą całkowitą, taką że $x == m2^e$. Jeśli {\tt x} jest zerem, zwraca {\tt (0.0, 0)}, w przeciwnym wypadku $0.5 <= abs(m) < 1$)
\item {\tt hypot(x, y)} (odległość od środka euklidesowego układu współrzędnych, czyli $ \sqrt{x^2 + y^2}$)
\item {\tt ldexp(x, i)} ($x2^i$)
\item {\tt log(x)} (logarytm naturalny {\tt x}), {\tt log10()}
\item {\tt modf(x)} (zwraca ułamkową i całkowitą część {\tt x}. Obie części mają taki znak, jak {\tt x}. Część ułamkowa jest zwracana jako liczba zmiennoprzecinkowa)
\item {\tt pow(x, y)} ({\tt x} do potęgi {\tt y}), {\tt sqrt()}
\end{itemize}
Moduł ten zawiera także definicje dwóch stałych matematycznych: pi i e.

\subsection{Moduł {\tt cmath}}

Zawiera definicje podstawowych funkcji matematycznych dla liczb zespolonych. Funcje te są oddzielone od tych z `math', ponieważ niektórzy użytkownicy nie używają liczb zespolonych i wolą na przykład, aby $\sqrt{-1}$ zwróciło wyjątek zamiast liczby zespolonej. Funkcje te, to: {\tt acos()}, {\tt acosh()}, {\tt asin()}, {\tt asinh()}, {\tt atan()}, {\tt atanh()}, {\tt cos()}, {\tt cosh()}, {\tt exp()}, {\tt log()}, {\tt log10()}, {\tt sin()}, {\tt sinh()}, {\tt sqrt()}, {\tt tan()}, {\tt tanh()}. Wszystkie one zwracają liczbę zespoloną, nawet jeśli część urojona jest równa zero.

\subsection{Moduł {\tt random}}

Moduł ten zawiera implementacje generatorów liczb pseudolosowych różnych rozkładów. Dla zmiennych całkowitych dostępny jest jednstajny wybór z przedziału ({\tt randrange()}). Dla sekwencji -- jednostajny wybór losowego elementu ({\tt choice()}) i funkcja generująca losową permutację listy {\it in situ} ({\tt shuffle()}). Dla liczb zmiennoprzecinkowych dostępne są rozkłady: jednostajny ({\tt random()}, {\tt uniform()}), normalny ({\tt gauss()}, {\tt normalvariate()}), log-normalny ({\tt lognormvariate()}), wykładniczy ({\tt expovariate()}), gamma ({\tt gamma()}) i beta ({\tt betavariate()}). Do generowania rozkładów kątów można wykorzystać rozkład kołowy jednostajny ({\tt cunifvariate()}) lub von Misesa ({\tt vonmisesvariate()}). Dostępne są także rozkłady Pareto ({\tt patetovariate()}) i Weibulla ({\tt wiebullvariate()}).

Inne funkcje związane z generatorami to seed(), getstate(), setstate() i jumpahead().

Prawie wszystkie funkcje tego modułu wykorzystują podstawową funkcję random(), która generuje losową liczbę zmiennoprzecinkową wg. rozkładu jednostajnego z przedziału (nawias zamknięty) 0.0, 1.0 (nawias otwarty). Python używa standardowego generatora Wichmanna-Hilla, łącząc trzy czysto multiplikatywne generatory o modułach 30269, 30307 i 30323. Jego okres wynosi 6,953,607,871,644. Choć generator ten jest dużo lepszej jakości niż funkcja rand() dostarczana przez większość bibliotek C, teoretyczne możliwości są bardzo podobne do tych, które oferuje pojedynczy liniowy generator o dużym module. Nie nadaje się on jednak do wielu zastosowań, w szczególności zupełnie nie nadaje się do zastosowań kryptograficznych.

Należy pamiętać o tym, że funkcje te nie nadają się do użycia przez wiele wątków. Aby to było możliwe należy utworzyć kilka instancji ukrytej klasy Random, zawierające niezależne generatory i przekazać je do poszczególnych wątków.


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\section{NumPy - numerical extensions to Python}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

Standardowe typy danych i procedury Pythona nie nadają się do poważnych zastosowań numerycznych. Konieczne było opracowanie zoptymalizowanych pod względem typowych operacji numerycznych typów danych i procedur. Stworzony został \textit{Numerical Python}, zwany w skrócie \textit{NumPy}. Podczas rozwoju tego pakietu kierowano się podejściem zastosowanym w takich językach jak Basis, MATLAB, rodzina języków APL, FORTRAN, S, S+ i innych. To dziedzictwo będzie widoczne natychmiast dla użytkowników Pythona, którzy już zetknęli się z tymi językami.

Można śmiało powiedzieć, że dzięki temu pakietowi możliwości obliczeniowe Python-a zbliżają się do tych, które posiada MATLAB czy IDL.

Numeric Python składa się z kilku modułów:

\subsection{Numeric.py (z modułami pomocniczymi multiarray i umath)}

Moduł ten rozszerza numeryczne możliwości Pythona dodając dwa nowe typy danych: sekwencję {\em wydajnie} implementującą tablice wielowymiarowe (\texttt{multiarray}) oraz nowy typ funkcji, zwany funkcją uniwersalną (\texttt{ufunc}), który działa wydajnie na tych nowych tablicach, a także innych typach sekwencyjnych. Definiuje również zbiór funkcji służących do operowania na obiektach tych typów oraz przeprowadzania konwersji między nimi a standardowymi typami Pythona. Stanowi on rdzeń NumPy będący podstawą do tworzenia bardziej skomplikowanych pakietów.

\subsubsection{Obiekty tablic}

Są to jednolite kolekcje liczb tego samego typu, w których poszczególne liczby mogą się zmieniać podczas `życia' tablicy (w przeciwieństwie do wielkości samej tablicy). W niektórych zastosowaniach tablice liczb mogą zawierać pozycje niewłaściwe lub brakujące. W takim przypadku należy używać specjalnego pakietu opcjonalnego `\texttt{MA}'.

Operacje arytmetyczne na tych obiektach (tzn. z użyciem operatorów `+', `*' itp.) powodują wykonanie tych samych operacji na poszczególnych elementach tablicy i {\em nie} są odpowiednimi operacjami algebry liniowej.

Tablice posiadają takie atrybuty jak kształt (\texttt{shape}) - aby zmienić rozmiar tablicy wystarczy podstawić pod niego odpowiednią sekwencję, rząd - ilość wymiarów, czyli długość kształtu, kod typu -- określający zawierane elementy, itp. Dostępnych jest kilka typów numerycznych (o różnych precyzjach, zależnych od danej platformy - np. na maszynie klasy Pentium od 8-bitowej liczby całkowitej po 128-bitową liczbę zespoloną), typ \texttt{Character}, a także referencja do dowolnego typu obiektu Pythona.

\subsubsection{Funkcje uniwersalne}

Wykonują operacje na tablicach i innych sekwencjach, w większości między odpowiednimi operacjami.
Funkcja \texttt{array()} jest najprostszym sposobem utworzenia tablicy. Funkcja \texttt{resize()} tworzy nową tablicę o danym rozmiarze na podstawie istniejącej tablicy.


\subsubsection{Inne funkcje i cechy tablic}

Na elementach tablic {\it NumPy} można operować w podobny sposób jak na wbudowanym typie tablicowym Pythona.

Dostępne są też funkcje do manipulowania tablicami (np. transponowanie, sortowanie), wybierania części tablic na podstawie zawartości innych tablic, itd\dots

Python dokonuje automatycznego rzutowania typów tablic w przypadku niezgodności typów argumentów operatorów, na zasadach podobnych do tych przy rzutowaniu podczas standardowych operacji arytmetycznych na typach wbudowanych. Dostępna jest także funkcja \texttt{astype()} pozwalająca na dowolną konwersję, a także kilka innych służących do ograniczania wykorzystywanej pamięci, itp\dots

\subsubsection{Matrix.py}

Definiuje klasę \texttt{Matrix}, różniącą się tym od klasy tablicy (\texttt{Array}), że operator mnożenia `*' przeprowadza mnożenie macierzy, a operator potęgowania `**' jest zablokowany.

\subsubsection{MLab.py}

W założeniu jest to zbiór (obecnie ponad 30) funkcji, które mają zapewnić podstawową zgodność z MATLAB-em. Projekt zakłada maksymalne zbliżenie składni do tej z MATLAB-a.


\subsection{Dodatkowe pakiety NumPy}

Dostępne są także opcjonalne pakiety:

\subsubsection{LinearAlgebra.py}

Jest to prosty interfejs do niskopoziomowych procedur algebry liniowej udostępnianych przez bibliotekę LAPACK FORTRAN lub zgodną z nim bibliotekę C lapack\_lite.

Oto niektóre funkcje:
\begin{description}
\item \texttt{solve\_linear\_equations(a, b)} rozwiązuje układ równań liniowych z nieosobliwą macierzą kwadratową \texttt{a} i wektorem wyrazów wolnych \texttt{b}. Można rozwiązać jednocześnie kilka układów z różnymi wektorami wyrazów wolnych podając jako argument \texttt{b} tablicę dwuwymiarową (tzn. sekwencję wektorów).
\item \texttt{inverse(a)} odwraca nieosobliwą macierz kwadratową \texttt{a}.
\item \texttt{eigenvalues(a)} zwraca wartości własne macierzy kwadratowej \texttt{a}.
\item \texttt{generalized\_inverse(a, rcond=1e-10)} -- zwraca uogólnione odwrócenie (zwane też pseudo-odwróceniem albo odwróceniem Moore'a-Penrose'a) macierzy \texttt{a}.
\item \texttt{determinant(a)} zwraca wyznacznik kwadratowej macierzy \texttt{a}.
\end{description}

\subsubsection{FFT.py}

Jest to prosty interfejs do biblioteki FFTPACK FORTRAN przeprowadzającej szybką transformatę Fouriera rzeczywistych i zespolonych zbiorów danych. Ewentualnia jest biblioteka fftpack języka C, która jest oparta algorytmicznie na FFTPACK i udostępnia zgodny interfejs.

Na niektórych platformach można korzystać z optymalizowanych wersji tych bibliotek.

Moduł ten zawiera najczęściej używane procedury FFT:
\begin{description}
\item [\texttt{fft(dane, n=None, oś=-1)}] przeprowadza n-punktową dyskretną transformatę Fouriera danych,
\item [\texttt{inverse\_fft(dane, n=None, oś=-1)}] przeprowadza odwrotną dyskretną transformatę,
\item [\texttt{real\_fft(dane, n=None, oś=-1)}] 
\item [\texttt{inverse\_real\_fft(dane, n=None, oś=-1)}] podobnie, ale na danych rzeczywistych
\item [\texttt{fft2d(dane, n=None, osie=(-2,-1))}]
\item [\texttt{real\_fft2d(dane, n=None, osie=(-2,-1))}]  dwuwymiarowa FFT.
\end{description}

\subsubsection{RandomArray.py}

Moduł ten (w połączeniu z plikiem ranlibmodule.c) udostępnia interfejs wysokiego poziomu do modułu ranlib, zawierającego dobrej jakości implementację generator liczb losowych. Dzięki niemu można na przykład uzyskać w łatwy sposób całą tablicę liczb losowych o zadanym typie i parametrach rozkładu.

\subsubsection{RNG.py}

Ten moduł udostępnia niezależne strumienie liczb losowych. Dostępne są rozkłady: jednostajny, normalny, wykładniczy i log-normalny.
 
\subsubsection{MA.py}

Ten moduł udostępnia obsługę tablic przesłanianych (masked arrays), to znaczy posiadających nieznane lub niewłaściwe pola. Maska może zawierać jedynki, oznaczające elementy niewłaściwe. W takim przypadku moduł pilnuje, aby elementy te nie brały udziału w obliczeniach.

Moduł ten może okazać się bardzo pomocny w przypadku wykonywania obliczeń na niepełnych danych.

%%%%%%%%%%%%%%%%%%%%%%%%%%%

\section{Scientific Python}

%%%%%%%%%%%%%%%%%%%%%%%%%%%

Jest to pakiet modułów przydatnych przy obliczeniach naukowych. Do działania wymagana jest instalacja NumPy. Obecna wersja (2.2) zawiera szereg modułów zorganizowanych hierarhicznie. Oto ciekawsze z nich:

\subsection{Functions}

\subsubsection{Derivatives}

Ten moduł umożliwia automatyczne różniczkowanie funkcji o dowolnej liczbie zmiennych do dowolnego stopnia.

Bardziej wydajne liczenie pierwszych pochodnych umożliwia moduł {\tt FirstDerivatives}

\subsubsection{FindRoot}

Zawiera funkcję {\tt newtonRaphson(funkcja, lox, hix, xacc)}, która umożliwia znalezienie pierwiastka funkcji {\tt funkcja} w przedziale od {\tt lox} do {\tt hix} z dokładnością do +/- {\tt xacc}. Używany jest algorytm będący bezpieczną wersją algorytmu Newtona-Raphsona. {\tt funkcja} musi być funkcją tylko jednej zmiennej i może używać wyłącznie operacji zdefiniowanych dla obiektów DerivVar w module FirstDerivatives.

\subsubsection{Interpolation}

Zawiera definicję klasy InterpolatingFunction, reprezentującą funkcję n zmiennych o m-wymiarowych wartościach. Konstruktorem jest {\tt InterpolatingFunction(osie, wartości, default=None)}. {\tt osie} to sekwencja tablic jednowymiarowych, jedna na każdą zmienną funkcji, określające wartości zmiennych na każdej z osi. {\tt wartości} to tablica zawierająca wartości zmiennej na siatce. Wartość None zmiennej {\tt default} oznacza, że funkcja jest niezdefiniowana poza siatką i każda próba zbadania jej wartości tam spowoduje wyjątek.

Klasa ta posiada metody służące do pobierania wartości w dowolnym punkcie, liczenia funkcju pochodnych i całek tej funkcji.

Dostępna jest także klasa NetCDFInterpolatingFunction wykorzystująca pliki NetCDF do definicji punktów siatki funkcji.

\subsubsection{LeastSquares}

Umożliwia dopasowywanie do danych ogólnych funkcji nieliniowych lub wielomianów metodą najmniejszych kwadratów z użyciem algorytmu Levenberg'a-Marquardt'a i automatycznych pochodnych.

\subsubsection{Polynomial}

Zawiera klasę ułatwiającą reprezentację wielomianów dowolnej liczby zmiennych.

\subsubsection{Romberg}

Zawiera funkcje przeprowadzające całkowanie metodą trapezów oraz metodą Romberga.


\subsection{Geometry}

Zawiera klasy dotyczące wielkości i obiektów geometrycznych. Klasy te obejmują takie zagadnienia jak tensory, wektory, kule, płaszczyzny, stożki, koła, proste i kraty w przestrzeni trójwymiarowej. Dostępne są też klasy opisujące pola tensorowe, skalarne i wektorowe wraz z niezbędnymi metodami umożliwiającymi liczenie dywergencji, laplasjanów, gradientów itp. wielkości.

Oprócz tego dostępne są klasy opisujące różne przekształcenia.

\subsection{IO}

Zawiera funkcje umożliwiające łatwe zapisywanie do plików tekstowych i odczytywanie z nich tablic dwuwumiarowych, funkcje wejścia/wyjścia zgodne z FORTRAN-em, NetCDF i PDB (Protein Data Bank). Dla tego ostatniego formatu zdefiniowane są klasy opisujące cząsteczki różnego stopnia złożoności.


\subsection{MPI}

Moduł ten zawiera interfejs Pythona do Interfejsu Przekazywania Komunikatów (Message Passing Interface -- MPI). Istnienie takiego modułu pociąga za sobą jasno widoczne konsekwencje dla użyteczności Pythona w obliczeniach równoległych.

\subsection{Physics}

Zawiera różne moduły użyteczne przy prowadzeniu obliczeń i modelowaniu zjawisk fizycznych.

\subsubsection{PhysicalQuantities}

Zawiera typy danych reprezentujące wielkości fizyczne wraz z jednostkami. Zdefiniowane są operacje arytmetyczne, przy czym wynik będzie miał odpowiednią jednostkę. Wartości stałych fizycznych oparte są na wartościach zalecanych CODATA z 1986 roku.

\subsubsection{Potential}

Jest to jeszcze jeden moduł ułatwiający operacje na polach skalarnych, takie jak liczenie gradientów.

\subsection{Statistics}

Zawiera funkcje służące do liczenia różnych parametrów danych (takich jak wariancja, mediana itp.) oraz tworzenia histogramów.

\subsection{Threading}

Umożliwia zrównoleglenie obliczeń na maszynach wieloprocesorowych ze wspólną pamięcią.

\subsection{Visualization}

Dzięki temu modułowi można łatwo wizualizować obiekty trójwymiarowe przy pomocy różnych back-end'ów (VRML, VMD, VPython), ale korzystając z praktycznie identycznego interfejsu. Moduł ten jest zorientowany na wizualizację danych naukowych, przez co nie zawiera wielu wyszukanych obiektów 3D, podobnie jak skomplikowanych definicji powierzchni takich jak tekstury.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\section{PyLab -- rozszerzenia ze strony Travisa Oliphanta}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

Interfejs do biblioteki gist, dzięki któremu jej używanie staje się bardziej podobne do MATLAB-a.

\begin{description}
\item [PyLapack] niskopozioziomowy interfejs (autorstwa Konrada Hinsena) Pythona do całej biblioteki LAPACK. Aby go używać konieczne jest zainstalowanie bibliotek LAPACK i BLAS.

\item [SparsePy] moduł zawierający klasę implementującą macierze rzadkie w Pythonie. Atrybutami tej klasy są tablice (z modułu Numeric), a metody opierają się na bibliotekach SPARSEKIT2 autorstwa Yousefa Saada (w FORTRANIE) i SuperLU autorstwa Xiaoye Li i Jima Demmela (w C).

\item [Cephesmodule] udostępnia programistom Pythona większość funkcji specjalnych (jak funkcje eliptyczne i Bessela) z bibliotek cephes i amos. Implementuje te funkcje jako funkcje uniwersalne (ufunc), dzięki czemu można je wykonywać (bardzo szybko) na dowolnych tablicach. Udostępnia on także specjalną funkcję, dzięki której można tak `opakować' zwykłą funkcję działającą na skalarach, aby operowała na całych tablicach.

\item [Signaltools] projekt ten ma na celu przybliżenie możliwości obróbki sygnałów Pythona do tej, jaką posiadają inne systemy zorientowane na tablice, jak MATLAB.

\item [quadrature.py] moduł umożliwiający wykonywanie kwadratur Gaussa na skończonym obszarze z dowolnych funkcji Pythona.

\item [optimize.py] moduł zawierający procedury optymalizacyjne napisane w czystym Pythonie. Obecnie zawiera m.in. implementacje algorytmów: simpleksowego Neldera-Meada i quasi-Newtonowskiego Broydena-Fletchera-Goldfarba-Shanno.

\item [FFTW] interfejs do biblioteki FFTW (w C). Jest to bardzo szybka implementacja FFT (testy autora wskazują, że jest o około 18-25\% szybsza od fftpack-a). Zawiera również obsługę tablic wielowymiarowych (nie tylko 2D).
\end{description}

%%%%%%%%%%%%%%%%%%%

\section{Multipack}

%%%%%%%%%%%%%%%%%%%

Jest to interfejs dla NumPy do zbioru procedur w FORTRANIE -- ODEPACK, QUADPACK, MINPACK itd\dots Obecnie pakiet zawiera funkcje, dzięki którym można numerycznie:

\begin{itemize}
\item rozwiązać N równań nieliniowych z N niewiadomymi
\item zminimalizować m równań nieliniowych z n niewiadomymi (Levenberg-Marquardt)
\item zcałkować zwykłe równanie różniczkowe
\item zcałkować funkcję 1, 2 lub 3 zmiennych
\item dopasować spline 1 lub 2D do zbioru punktów i znaleźć pochodne, całki, interpolacje, itp. tych spline'ów
\end{itemize}

\section{Pysimplex}

Moduł ten zawiera podstawowe podstawowe narzędzia programowania symbolicznego służące do konstruowania, rozwiązywania i optymalizowania układów równań i nierówności liniowych. Zawiera on implementację klasycznego algorytmu optymalizacji liniowej SIMPLEX, a także filtr służący do analizowania i optymalizacji modeli liniowych zakodowanych w standardowym formacie MPS.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\section{Inne ciekawe moduły}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\subsection{real.py}

Jest to biblioteka definiująca klasę {\tt Real}, pozwalająca wyrażać dowolnie precyzyjne liczby, dzięki czemu można przeprowadzać obliczenia z `nieskończoną' precyzją. Każda liczba zawiera przybliżenie swojej precyzji. Udostępnione są metody pozwalające obliczać liczby z coraz większą ilością cyfr. {\tt real.py} pozwala

\begin{itemize}
\item liczyć z bardzo dużą precyzją, np. 1000 cyfr
\item liczyć na bardzo dużych lub bardzo małych liczbach - do około $10^500000000$
\item liczyć bez niespodziewanej utraty precyzji: gwarancja na każdą cyfrę.
\item liczyć z nieograniczoną precyzją, drukując cyfry w locie
\item drukować liczby zmiennoprzecinkowe z ich rzeczywistą dokładnością
\end{itemize}

\subsection{Pyfortran i FPIG}

-- umożliwiają łatwe łączenie kodu w Pythonie i Fortranie.

\subsection{surd i yarn}

-- moduły implementujące liczby wymierne

\subsection{PYML}

Jeden z interfejsów Pythona do Mathematica'i, wykorzystujący MathLink. Dzięki temu programista Pythona może obliczać wyrażenia Mathematica'i.


\subsection{Sparse Linear Equation Solver}

Ten moduł (autorstwa Neila Schemenauera) umożliwia rozwiązywanie rzadkich równań liniowych. Używa załączonej biblioteki Kennetha S. Kunderta Sparse1.3. Moduł ten przydaje się przy rozwiązywaniu dużych układów równań nieliniowych metodą Newtona-Raphsona.

\subsection{Inne}

Dostępnych jest jeszcze wiele najróżniejszych pakietów ułatwiających obliczenia lub integrujących Pythona z innymi narzędziami i językami programowania oraz ułatwiających różnego rodzaju obliczenia. Wszystkich nie sposób tutaj wymienić, można jednak podać kilka odnośników do stron zawierających te rozszerzenia.

\begin{description}
\item [Number Crunching and other Scientific Extensions and Tools] \url{http://www.python.org/topics/scicomp/numbercrunching.html}

\item [Math section of the Contributed Modules FTP site] \url{ftp://ftp.python.org/pub/python/contrib/Math/}

\item [Contributed Modules Web page] \url{http://www.python.org/download/Contributed.html#Math}

\item [Vaults of Parnassus] \url{http://www.vex.net/parnassus/apyllo.py/684222876}
\end{description}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\section{Narzędzia do wizualizacji}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

Oto niektóre moduły służące do wizualizacji danych, niezwiązane bezpośrednio z wyżej wymienionymi pakietami obliczeniowymi.

\begin{description}
\item [Mathematica.py] moduł generujący kod dla procedur rysujących wykresy Mathematica'i. Dzięki niemu można przy pomocy programu Mathematica rysować wykresy danych obliczonych w Pythonie.
\item [Gnuplot.py] interfejs do znanego programu do tworzenia wykresów -- gnuplot. Jest zorientowany obiektowo, dzięki czemu można ustawiać parametry wizualicji (style, kolory itp.) dla każdego zbioru danych osobno.
\item [grace\_np.py] interfejs do programu do tworzenia wykresów `Grace'. Na razie otwiera tylko potok do programu, przez który można wydawać mu komendy.
\item [BLT] rozszerzenie umożliwiające tworzenie wykresów X/Y i słupkowych z wykorzystaniem Tk
\item [DISLIN] wysokopoziomowa i łatwa w użyciu biblioteka pozwalająca na wizualizację danych w postaci krzywych, wykresów słupkowych, kołowych, kolorowych trójwymiarowych, powierzchni, konturów i map.
\item [gdmodule] umożliwia rysowanie prostych kształtów w formacie GIF
\item [PyOpenGL] interfejs do biblioteki OpenGL, który może posłużyć do stworzenia nowego narzędzia do wizualizacji
\end{description}

Więcej modułów do wizualizacji można znaleźć na stronach \url{http://www.python.org/topics/scicomp/plotting.html} lub \url{http://starship.python.net/crew/jhauser/plot-res.html}. O wszystkich nie sposób tutaj wspomnieć, z racji na ograniczone miejsce.


%%%%%%%%%%%%%%%%%%%%%%

\section{Podsumowanie}

%%%%%%%%%%%%%%%%%%%%%%

Python jako język interpretowany, bez możliwości optymalizacji kodu pod konkretną platformę jako taki nie nadaje się raczej do bardzo intensywnych obliczeń. Jednak ze względu na swoją elastyczną budowę, możliwość łączenia z gotowymi bibliotekami napisanymi w innych językach, a także na bardzo rozbudowane struktury danych i podejście obiektowe, bardzo dobrze służy jako ``klej'' łączący sprawdzone procedury numeryczne (napisane na przykład w FORTRANIE) z różnorodnymi narzędziami służącymi do wizualizacji. Można wywoływać dostarczone funkcje na danych, a dane wynikowe (po odpowiedniej obróbce) wysłać do odpowiedniego narzędzia do wizualizacji. Taka jest głównie rola języków skryptowych i tak Python jest używany na przykład przez fizyków z Los Alamos National Laboratory, gdzie był wykorzystywany przy obróbce danych pochodzących z kodu SPaSM \cite{spasm} służącego do modelowania dynamiki cząsteczek. 

\nocite{*}
\bibliography{referat}
\bibliographystyle{plain}
\end{document}