Add abstract and toc as separate text files

abstract.txt

@@ -0,0 +1,22 @@
+Praca pod tytułem "Optymalizacja oprogramowania do detekcji splątania kwantowego" dotyczy
+optymalizacji wydajności programu CSSFinder, służącego do detekcji splątania kwantowego.
+Program ten jest oparty o algorytm Gilberta i dokonuje analizy stanu kwantowego opisanego
+macierzą gęstości. Celem pracy była znacząca redukcja czasu wykonania programu, aby umożliwić
+analizę większej ilości stanów kwantowych.
+W ramach tej pracy rozpatruję wydajność czasową pięciu alternatywnych implementacji algorytmu.
+Trzy z nich powstały w języku Python w oparciu o bibliotekę NumPy, dwie w języku Rust z
+użyciem biblioteki Ndarray. Poszczególne implementacje sięgały również po dodatkowe rozwiązania
+pozwalające na skrócenie czasu pracy. Oprócz efektów zmiany narzędzi, wykorzystanych do
+zaimplementowania programu, badałem również wpływ precyzji wykorzystywanych liczb
+zmiennoprzecinkowych na wydajność. Każda z implementacji powstała w dwóch wariantach.
+Pierwszy został oparty o liczby podwójnej precyzji, a drugi wykorzystywał liczby podwójnej
+precyzji. Do testów wykorzystano sześć macierzy gęstości o różnych rozmiarach, wszystkie
+pomiary powtarzano pięciokrotnie.
+Udało mi się osiągnąć znaczące skrócenie czasu pracy programu. Najwydajniejsza implementacja,
+z pośród napisanych w języku Python, była do 4.3× szybsza dla układu 6 kubitów względem
+oryginalnego programu, niezależnie od precyzji obliczeń.
+W przypadku wariantów napisanych z użyciem języka Rust największe skrócenie czasu pracy
+wyniosło 7.4× dla układu 6 kubitów, w przypadku obliczeń pojedynczej precyzji.
+W przypadku mniejszych układów skrócenie czasu pracy było również istotne i zostało
+opisane w pracy.
+Stworzony kod został opublikowany w serwisach GitHub oraz PyPI na licencji MIT.

toc.txt

@@ -0,0 +1,54 @@
+1   Wstęp..............................................................................3
+    1.1 Działanie Programu.............................................................3
+    1.2 Cel pracy......................................................................4
+    1.3 Przyczyny przystąpienia do optymalizacji.......................................5
+2   Narzędzia..........................................................................5
+    2.1 Kompilacja AOT.................................................................5
+    2.2 Kompilacja JIT.................................................................6
+    2.3 Selekcja narzędzi..............................................................7
+        2.3.1 Python i NumPy...........................................................7
+        2.3.2 Python i NumPy z AOT.....................................................7
+        2.3.3 Python i NumPy z JIT.....................................................8
+        2.3.4 Rust i Ndarray...........................................................8
+        2.3.5 Rust i Ndarray z OpenBLAS................................................9
+3   Metody.............................................................................9
+    3.1 Modularyzacja..................................................................9
+    3.2 Dane testowe..................................................................10
+    3.3 Środowisko testowe............................................................11
+    3.4 Profilowanie..................................................................11
+    3.5 Precyzja obliczeń.............................................................12
+    3.6 Wykresy.......................................................................13
+4   Wyniki............................................................................13
+    4.1 Wstępne profilowanie..........................................................13
+    4.2 Wstępnie pomiary wydajności...................................................15
+    4.3 Pomiary z podwójną precyzją...................................................16
+        4.3.1 Python i NumPy..........................................................17
+        4.3.2 Python i NumPy z AOT....................................................17
+        4.3.3 Python i NumPy z JIT....................................................19
+        4.3.4 Rust i Ndarray..........................................................20
+        4.3.5 Rust i Ndarray z OpenBLAS...............................................20
+    4.4 Pomiary z pojedyncza precyzją.................................................21
+        4.4.1 Python i NumPy..........................................................21
+        4.4.2 Python i NumPy z AOT....................................................22
+        4.4.3 Python i NumPy z JIT....................................................22
+        4.4.4 Rust i Ndarray..........................................................24
+        4.4.5 Rust i Ndarray z OpenBLAS...............................................24
+    4.5 Zestawienia dla macierzy......................................................25
+        4.5.1 Macierz ρ1 (32 × 32)....................................................25
+        4.5.2 Macierz ρ2 (4 × 4)......................................................26
+        4.5.3 Macierz ρ3 (8 × 8)......................................................27
+        4.5.4 Macierz ρ4 (16 × 16)....................................................27
+        4.5.5 Macierz ρ5 (32 × 32)....................................................27
+        4.5.6 Macierz ρ6 (64 × 64)....................................................28
+    4.6 Profilowanie Rust z OpenBLAS..................................................29
+5   Dyskusja..........................................................................30
+    5.1 Podsumowanie..................................................................30
+    5.2 Kontynuacja...................................................................31
+    5.3 Pominięte narzędzia...........................................................32
+        5.3.1 PyTorch i TensorFlow....................................................32
+        5.3.2 PyPy....................................................................32
+        5.3.3 C/C++...................................................................32
+6   Wnioski...........................................................................33
+    6.1 Podsumowanie..................................................................33
+    6.2 Kod...........................................................................33
+Odwołania.............................................................................35