diff --git a/notebooks/power_iteration.ipynb b/notebooks/power_iteration.ipynb
new file mode 100644
index 0000000..47f47f0
--- /dev/null
+++ b/notebooks/power_iteration.ipynb
@@ -0,0 +1,1285 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "a07f0708",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import numpy as np\n",
+ "import pandas as pd\n",
+ "\n",
+ "np.set_printoptions(precision=6, suppress=True)\n",
+ "\n",
+ "def plot_matrix(matrix, title):\n",
+ "\n",
+ " print(f\"\\n{title}\")\n",
+ "\n",
+ " display(\n",
+ " pd.DataFrame(matrix)\n",
+ " )"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "183961c5",
+ "metadata": {},
+ "source": [
+ "# Metoda potęgowa oraz rozkład SVD macierzy\n",
+ "\n",
+ "---\n",
+ "\n",
+ "*Autorzy: Maja Byrecka, Michał Kowalczyk*\n",
+ "\n",
+ "*Język: Python3*\n",
+ "\n",
+ "---\n",
+ "\n",
+ "## Cel zadania\n",
+ "\n",
+ "Celem zadania jest:\n",
+ "\n",
+ "1. Implementacja metody potęgowej dla macierzy $3 \\times 3$,\n",
+ "2. Implementacja rozkładu SVD na podstawie wartości i wektorów własnych,\n",
+ "3. Analiza zbieżności metody potęgowej dla różnych norm,\n",
+ "4. Porównanie własnej implementacji SVD z implementacją biblioteczną NumPy.\n",
+ "\n",
+ "---\n",
+ "\n",
+ "# Dekompozycja SVD - przypomnienie\n",
+ "\n",
+ "## Teoria\n",
+ "\n",
+ "**Dekompozycja SVD** *(ang. Singular Value Decomposition)* stanowi jedno z fundamentalnych narzędzi algebry liniowej, umożliwiające faktoryzację dowolnej macierzy rzeczywistej lub zespolonej do postaci iloczynu trzech macierzy: ortogonalnych (lub unitarnych) oraz diagonalnej zawierającej wartości osobliwe. Dzięki swojej ogólności i stabilności numerycznej SVD znajduje szerokie zastosowanie w analizie danych, uczeniu maszynowym, przetwarzaniu sygnałów oraz kompresji informacji. Rozkład SVD przedstawia macierz $A$ w postaci:\n",
+ "\n",
+ "$$\n",
+ "A = U \\Sigma V^T\n",
+ "$$\n",
+ "\n",
+ "gdzie:\n",
+ "\n",
+ "- $U$ — macierz ortogonalna lewych wektorów singularnych,\n",
+ "- $\\Sigma$ — diagonalna macierz wartości singularnych,\n",
+ "- $V$ — macierz ortogonalna prawych wektorów singularnych.\n",
+ "\n",
+ "Wartości singularne są pierwiastkami wartości własnych macierzy:\n",
+ "\n",
+ "$$\n",
+ "AA^T\n",
+ "$$\n",
+ "\n",
+ "natomiast macierz $U$ składa się z wektorów własnych macierzy $AA^T$.\n",
+ "\n",
+ "Macierz $V$ można wyznaczyć korzystając ze wzoru:\n",
+ "\n",
+ "$$\n",
+ "V = A^T U \\Sigma^{-1}\n",
+ "$$\n",
+ "\n",
+ "Szczególne znaczenie rozkładu wynika z jego zdolności do ujawniania struktury macierzy, w tym jej rzędu, przestrzeni rozpiętych przez kolumny i wiersze, a także dominujących kierunków zmienności. W praktyce wykorzystywany jest m.in. w redukcji wymiarowości (np. PCA), filtracji szumu, rozwiązywaniu układów równań liniowych o złej kondycji oraz w systemach rekomendacyjnych.\n",
+ "\n",
+ "## Praktyczne zastosowania\n",
+ "\n",
+ "Najważniejsze zastosowania SVD obejmują:\n",
+ "\n",
+ "* **Redukcja wymiarowości danych** - PCA (Principal Component Analysis) - algorytm pozwalający na zmniejszenie liczby cech, eliminację szumu, wizualizację danych wielowymiarowych\n",
+ "* **Kompresja obrazów** - zachowanie jedynie największych wartości singularnych pozwala znacząco zmniejszyć rozmiar danych przy zachowaniu dobrej jakości obrazu\n",
+ "* **Systemy rekomendacyjne** - platformy takie jak Netflix czy Spotify wykorzystują metody oparte na SVD do przewidywania preferencji użytkowników na podstawie niepełnych danych\n",
+ "* **Przetwarzanie języka naturalnego (NLP)** - w analizie semantycznej tekstów pozwalającej wykrywać ukryte zależności pomiędzy słowami i dokumentami, powszechne są algorytmy oparte na SVD np. LSA (Latent Semantic Analysis)\n",
+ "* **Rozwiązywanie źle uwarunkowanych układów równań**\n",
+ "\n",
+ "## Pseudokod\n",
+ "\n",
+ "1. Oblicz macierz:\n",
+ "\n",
+ "$$\n",
+ "AA^T\n",
+ "$$\n",
+ "\n",
+ "2. Wyznacz wartości własne oraz wektory własne macierzy $AA^T$.\n",
+ "\n",
+ "3. Zbuduj macierz:\n",
+ "\n",
+ "$$\n",
+ "U\n",
+ "$$\n",
+ "\n",
+ "z wektorów własnych.\n",
+ "\n",
+ "4. Oblicz wartości singularne:\n",
+ "\n",
+ "$$\n",
+ "\\sigma_i = \\sqrt{\\lambda_i}\n",
+ "$$\n",
+ "\n",
+ "5. Utwórz diagonalną macierz:\n",
+ "\n",
+ "$$\n",
+ "D\n",
+ "$$\n",
+ "\n",
+ "6. Oblicz:\n",
+ "\n",
+ "$$\n",
+ "V = A^TUD^{-1}\n",
+ "$$\n",
+ "\n",
+ "7. Zweryfikuj:\n",
+ "\n",
+ "$$\n",
+ "A \\approx UDV^T\n",
+ "$$\n",
+ "\n",
+ "## Złożoność obliczeniowa\n",
+ "\n",
+ "Pod względem obliczeniowym pełna dekompozycja SVD dla macierzy o wymiarach m×n ma złożoność rzędu `O(mn*min(m,n))`, co w przypadku dużych zbiorów danych może stanowić istotne ograniczenie. **W związku z tym stosuje się liczne algorytmy przybliżone i iteracyjne, takie jak metody oparte na losowaniu czy dekompozycje częściowe, które znacząco redukują koszt obliczeń przy zachowaniu użytecznej dokładności.**\n",
+ "\n",
+ "# Metoda potęgowa\n",
+ "\n",
+ "## Teoria\n",
+ "\n",
+ "Metoda potęgowa (Power Method) jest iteracyjnym algorytmem numerycznym służącym do wyznaczania dominującej wartości własnej macierzy, czyli wartości własnej o największym module oraz odpowiadającego jej wektora własnego.\n",
+ "\n",
+ "Dla macierzy:\n",
+ "\n",
+ "$$\n",
+ "A \\in \\mathbb{R}^{n \\times n}\n",
+ "$$\n",
+ "\n",
+ "oraz początkowego wektora:\n",
+ "\n",
+ "$$\n",
+ "z^{(0)}\n",
+ "$$\n",
+ "\n",
+ "algorytm wykonuje iteracje:\n",
+ "\n",
+ "$$\n",
+ "w^{(k)} = A z^{(k)}\n",
+ "$$\n",
+ "\n",
+ "$$\n",
+ "\\lambda^{(k)} = \\max_i |w_i^{(k)}|\n",
+ "$$\n",
+ "\n",
+ "$$\n",
+ "z^{(k+1)} = \\frac{w^{(k)}}{\\lambda^{(k)}}\n",
+ "$$\n",
+ "\n",
+ "W każdej iteracji obliczany jest błąd:\n",
+ "\n",
+ "$$\n",
+ "error^{(k)} =\n",
+ "\\left\\|\n",
+ "Az^{(k)} - \\lambda^{(k)} z^{(k)}\n",
+ "\\right\\|_p\n",
+ "$$\n",
+ "\n",
+ "gdzie:\n",
+ "\n",
+ "- $||\\cdot||_p$ oznacza normę $p$,\n",
+ "- $\\lambda^{(k)}$ jest przybliżeniem dominującej wartości własnej.\n",
+ "\n",
+ "Iteracje są wykonywane aż do spełnienia warunku:\n",
+ "\n",
+ "$$\n",
+ "error^{(k)} < \\varepsilon\n",
+ "$$\n",
+ "\n",
+ "## Zastosowania metody potęgowej\n",
+ "\n",
+ "Metoda potęgowa wykorzystywana jest przede wszystkim do wyznaczania dominującej wartości własnej macierzy. W praktyce znajduje zastosowanie między innymi w:\n",
+ "\n",
+ "- analizie stabilności układów dynamicznych\n",
+ "- grafice komputerowej\n",
+ "- symulacjach fizycznych\n",
+ "- analizie sieci i grafów\n",
+ "- algorytmach rankingowych\n",
+ "\n",
+ "Metoda potęgowa jest szczególnie cenna dla dużych macierzy rzadkich, ponieważ pozwala iteracyjnie wyznaczyć najważniejszą wartość własną bez konieczności pełnej diagonalizacji macierzy.\n",
+ "\n",
+ "## Pseudokod metody potęgowej\n",
+ "\n",
+ "### Wejście\n",
+ "\n",
+ "- macierz $A$,\n",
+ "- dokładność $\\varepsilon$,\n",
+ "- norma $||\\cdot||_p$.\n",
+ "\n",
+ "### Algorytm\n",
+ "\n",
+ "1. Wylosuj wektor początkowy:\n",
+ "\n",
+ "$$\n",
+ "z^{(0)} \\in (0,1)^n\n",
+ "$$\n",
+ "\n",
+ "2. Oblicz:\n",
+ "\n",
+ "$$\n",
+ "w^{(0)} = A z^{(0)}\n",
+ "$$\n",
+ "\n",
+ "3. Wyznacz:\n",
+ "\n",
+ "$$\n",
+ "\\lambda^{(0)} = \\max_i |w_i^{(0)}|\n",
+ "$$\n",
+ "\n",
+ "4. Oblicz błąd:\n",
+ "\n",
+ "$$\n",
+ "error =\n",
+ "||Az^{(0)} - \\lambda^{(0)}z^{(0)}||_p\n",
+ "$$\n",
+ "\n",
+ "5. Jeżeli:\n",
+ "\n",
+ "$$\n",
+ "error < 10^{-8}\n",
+ "$$\n",
+ "\n",
+ "to wróć do punktu 1.\n",
+ "\n",
+ "6. Wykonuj iteracyjnie:\n",
+ "\n",
+ "$$\n",
+ "w^{(k)} = A z^{(k)}\n",
+ "$$\n",
+ "\n",
+ "$$\n",
+ "\\lambda^{(k)} = \\max_i |w_i^{(k)}|\n",
+ "$$\n",
+ "\n",
+ "$$\n",
+ "z^{(k+1)} =\n",
+ "\\frac{w^{(k)}}{\\lambda^{(k)}}\n",
+ "$$\n",
+ "\n",
+ "7. Oblicz:\n",
+ "\n",
+ "$$\n",
+ "error^{(k)} =\n",
+ "||Az^{(k)} - \\lambda^{(k)}z^{(k)}||_p\n",
+ "$$\n",
+ "\n",
+ "8. Jeżeli:\n",
+ "\n",
+ "$$\n",
+ "error^{(k)} < \\varepsilon\n",
+ "$$\n",
+ "\n",
+ "zakończ algorytm."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "ad8e0f39",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def power_method(A, z_init=None, epsilon=1e-8, p=2, max_iter=1000, verbose=False):\n",
+ " n = A.shape[0]\n",
+ " norm_ord = np.inf if p == 'inf' or p == np.inf else p\n",
+ " \n",
+ " # 1a, 1b: Inicjalizacja wektora początkowego z0\n",
+ " if z_init is None:\n",
+ " while True:\n",
+ " # Sposób na ścisły przedział otwarty (0, 1) wg polecenia (1a)\n",
+ " z = np.random.uniform(1e-10, 0.9999999999, size=n) \n",
+ " w = A @ z\n",
+ " \n",
+ " # Właściwe maxi(w0i) - zachowuje oryginalny znak!\n",
+ " lambda_est = w[np.argmax(np.abs(w))] \n",
+ " \n",
+ " # (1b) error = ||Az0 - maxi(w0i)z0||_p\n",
+ " error = np.linalg.norm(w - lambda_est * z, ord=norm_ord) \n",
+ " \n",
+ " if error >= 1e-8:\n",
+ " break\n",
+ " else:\n",
+ " z = z_init.copy()\n",
+ "\n",
+ " errors = []\n",
+ " \n",
+ " # (1c) iteracja\n",
+ " for iteration in range(max_iter):\n",
+ " w = A @ z\n",
+ " \n",
+ " # Poprawione znajdowanie lambda (z zachowaniem znaku)\n",
+ " lambda_est = w[np.argmax(np.abs(w))]\n",
+ " \n",
+ " # Szybkie obliczanie błędu (zgodne z poleceniem i bez niepotrzebnego A @ z_new)\n",
+ " error = np.linalg.norm(w - lambda_est * z, ord=norm_ord)\n",
+ " errors.append(error)\n",
+ " \n",
+ " if verbose and (iteration < 3 or (iteration + 1) % 100 == 0):\n",
+ " print(f\"Iteracja: {iteration+1} | Przybliżona lambda: {lambda_est:.6f} | Błąd: {error:.6e}\")\n",
+ " \n",
+ " if error < epsilon:\n",
+ " # Ponieważ error bazuje na obecnym 'z', z_new liczymy po jego teście\n",
+ " z_new = w / lambda_est \n",
+ " break\n",
+ " \n",
+ " # Krok na następną iterację\n",
+ " z_new = w / lambda_est\n",
+ " z = z_new\n",
+ " \n",
+ " eigenvector = z_new / np.linalg.norm(z_new)\n",
+ " \n",
+ " return lambda_est, eigenvector, errors"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "76511a3d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def compute_svd(A, verbose=True):\n",
+ "\n",
+ " # Macierz A*A^T\n",
+ " AAT = A @ A.T\n",
+ "\n",
+ " # Wartości i wektory własne\n",
+ " eigenvalues, eigenvectors = np.linalg.eigh(AAT)\n",
+ "\n",
+ " # Sortowanie malejąco\n",
+ " idx = eigenvalues.argsort()[::-1]\n",
+ "\n",
+ " eigenvalues = eigenvalues[idx]\n",
+ " eigenvectors = eigenvectors[:, idx]\n",
+ "\n",
+ " # Macierz U\n",
+ " U = eigenvectors\n",
+ "\n",
+ " # Wartości singularne\n",
+ " singular_values = np.sqrt(np.maximum(eigenvalues, 0))\n",
+ "\n",
+ " # Macierz diagonalna D\n",
+ " D = np.diag(singular_values)\n",
+ "\n",
+ " # Pseudoinwersja D\n",
+ " D_inv = np.linalg.pinv(D)\n",
+ "\n",
+ " # Wyznaczenie V\n",
+ " V = A.T @ U @ D_inv\n",
+ "\n",
+ " if verbose:\n",
+ " plot_matrix(A, \"Macierz A\")\n",
+ " plot_matrix(AAT, \"Macierz A*A^T\")\n",
+ "\n",
+ " print(\"\\nWartości własne:\")\n",
+ " print(eigenvalues)\n",
+ "\n",
+ " plot_matrix(U, \"Macierz U\")\n",
+ " plot_matrix(D, \"Macierz D\")\n",
+ " plot_matrix(V.T, \"Macierz V^T\")\n",
+ "\n",
+ " return U, D, V.T"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "f877fce4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def run_experiment(verbose=True):\n",
+ "\n",
+ " # Losowa macierz 3x3\n",
+ " A = np.random.uniform(-10, 10, size=(3,3))\n",
+ "\n",
+ " if verbose:\n",
+ " plot_matrix(A, \"Wylosowana macierz A\")\n",
+ "\n",
+ " # Punkt 1 - metoda potęgowa\n",
+ " eigenvalue, eigenvector, errors = power_method(\n",
+ " A,\n",
+ " epsilon=1e-8,\n",
+ " p=2,\n",
+ " verbose=verbose\n",
+ " )\n",
+ "\n",
+ " if verbose:\n",
+ " print(\"\\nDominująca wartość własna:\")\n",
+ " print(eigenvalue)\n",
+ " print(\"\\nDominujący wektor własny:\")\n",
+ " display(\n",
+ " pd.DataFrame(eigenvector.reshape(-1,1))\n",
+ " )\n",
+ "\n",
+ " # Punkt 2 - SVD\n",
+ " U, D, VT = compute_svd(A, verbose=verbose)\n",
+ "\n",
+ " return {\n",
+ " \"A\": A,\n",
+ " \"eigenvalue\": eigenvalue,\n",
+ " \"eigenvector\": eigenvector,\n",
+ " \"U\": U,\n",
+ " \"D\": D,\n",
+ " \"VT\": VT\n",
+ " }"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "5e31c8a0",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n",
+ "Wylosowana macierz A\n"
+ ]
+ },
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " 0 | \n",
+ " 1 | \n",
+ " 2 | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 0 | \n",
+ " 2.948182 | \n",
+ " -9.761605 | \n",
+ " -5.837821 | \n",
+ "
\n",
+ " \n",
+ " | 1 | \n",
+ " 3.704893 | \n",
+ " -0.714923 | \n",
+ " -8.012874 | \n",
+ "
\n",
+ " \n",
+ " | 2 | \n",
+ " 5.982814 | \n",
+ " -6.209973 | \n",
+ " -8.985768 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " 0 | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 0 | \n",
+ " 0.574147 | \n",
+ "
\n",
+ " \n",
+ " | 1 | \n",
+ " 0.448447 | \n",
+ "
\n",
+ " \n",
+ " | 2 | \n",
+ " 0.685018 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " 0 | \n",
+ " 1 | \n",
+ " 2 | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 0 | \n",
+ " 2.948182 | \n",
+ " -9.761605 | \n",
+ " -5.837821 | \n",
+ "
\n",
+ " \n",
+ " | 1 | \n",
+ " 3.704893 | \n",
+ " -0.714923 | \n",
+ " -8.012874 | \n",
+ "
\n",
+ " \n",
+ " | 2 | \n",
+ " 5.982814 | \n",
+ " -6.209973 | \n",
+ " -8.985768 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " 0 | \n",
+ " 1 | \n",
+ " 2 | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 0 | \n",
+ " 138.060867 | \n",
+ " 64.679220 | \n",
+ " 130.715032 | \n",
+ "
\n",
+ " \n",
+ " | 1 | \n",
+ " 64.679220 | \n",
+ " 78.443490 | \n",
+ " 98.607156 | \n",
+ "
\n",
+ " \n",
+ " | 2 | \n",
+ " 130.715032 | \n",
+ " 98.607156 | \n",
+ " 155.101841 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " 0 | \n",
+ " 1 | \n",
+ " 2 | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 0 | \n",
+ " -0.600876 | \n",
+ " -0.682758 | \n",
+ " -0.415678 | \n",
+ "
\n",
+ " \n",
+ " | 1 | \n",
+ " -0.419210 | \n",
+ " 0.711938 | \n",
+ " -0.563389 | \n",
+ "
\n",
+ " \n",
+ " | 2 | \n",
+ " -0.680596 | \n",
+ " 0.164271 | \n",
+ " 0.714006 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " 0 | \n",
+ " 1 | \n",
+ " 2 | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 0 | \n",
+ " 18.20007 | \n",
+ " 0.000000 | \n",
+ " 0.00000 | \n",
+ "
\n",
+ " \n",
+ " | 1 | \n",
+ " 0.00000 | \n",
+ " 6.258399 | \n",
+ " 0.00000 | \n",
+ "
\n",
+ " \n",
+ " | 2 | \n",
+ " 0.00000 | \n",
+ " 0.000000 | \n",
+ " 1.09366 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " 0 | \n",
+ " 1 | \n",
+ " 2 | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 0 | \n",
+ " -0.406399 | \n",
+ " 0.570970 | \n",
+ " 0.713325 | \n",
+ "
\n",
+ " \n",
+ " | 1 | \n",
+ " 0.256864 | \n",
+ " 0.820613 | \n",
+ " -0.510505 | \n",
+ "
\n",
+ " \n",
+ " | 2 | \n",
+ " 0.876847 | \n",
+ " 0.024242 | \n",
+ " 0.480158 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "