W_03c_Uklady_rownan.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Eliminacja Gaussa-Jordana"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 6.  1.  4. 12.  1.  4.]\n",
      " [ 4.  4.  2.  3.  5.  4.]\n",
      " [ 1.  1.  1.  7.  1.  6.]\n",
      " [ 1.  1.  9.  1.  3.  7.]\n",
      " [ 1.  1.  5.  3. 17.  2.]]\n",
      "[[ 1.     0.167  0.667  2.     0.167  0.667]\n",
      " [ 0.     3.333 -0.667 -5.     4.333  1.333]\n",
      " [ 0.     0.833  0.333  5.     0.833  5.333]\n",
      " [ 0.     0.833  8.333 -1.     2.833  6.333]\n",
      " [ 0.     0.833  4.333  1.    16.833  1.333]]\n",
      "\n",
      "[[ 1.    0.    0.7   2.25 -0.05  0.6 ]\n",
      " [ 0.    1.   -0.2  -1.5   1.3   0.4 ]\n",
      " [ 0.    0.    0.5   6.25 -0.25  5.  ]\n",
      " [ 0.    0.    8.5   0.25  1.75  6.  ]\n",
      " [ 0.    0.    4.5   2.25 15.75  1.  ]]\n",
      "\n",
      "[[   1.     0.     0.    -6.5    0.3   -6.4]\n",
      " [   0.     1.     0.     1.     1.2    2.4]\n",
      " [   0.     0.     1.    12.5   -0.5   10. ]\n",
      " [   0.     0.     0.  -106.     6.   -79. ]\n",
      " [   0.     0.     0.   -54.    18.   -44. ]]\n",
      "\n",
      "[[ 1.     0.     0.     0.    -0.068 -1.556]\n",
      " [ 0.     1.     0.     0.     1.257  1.655]\n",
      " [ 0.     0.     1.     0.     0.208  0.684]\n",
      " [-0.    -0.    -0.     1.    -0.057  0.745]\n",
      " [ 0.     0.     0.     0.    14.943 -3.755]]\n",
      "\n",
      "[[ 1.     0.     0.     0.     0.    -1.573]\n",
      " [ 0.     1.     0.     0.     0.     1.97 ]\n",
      " [ 0.     0.     1.     0.     0.     0.736]\n",
      " [ 0.     0.     0.     1.     0.     0.731]\n",
      " [ 0.     0.     0.     0.     1.    -0.251]]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "x=np.array([[6,1,4,12,1,4],[4,4,2,3,5,4],[1,1,1,7,1,6],[1,1,9,1,3,7],[1,1,5,3,17,2]], dtype=float)\n",
    "\n",
    "print(x)\n",
    "for i in range(0,len(x)):\n",
    "    x[i][:]=(x[i][:])/x[i][i]\n",
    "    \n",
    "    for j in range(0,len(x)):\n",
    "        if i!=j:            \n",
    "            t=x[i][:]*x[j][i]\n",
    "            x[j][:]=x[j][:]-t\n",
    "            t=x[i][:]*x[j][i]\n",
    "            x[j][:]=x[j][:]-t\n",
    "    print(x.round(3)) \n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Eliminacja Gaussa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dane wejściowe: \n",
      " [[ 6.  1.  4. 12.  1.  4.]\n",
      " [ 4.  4.  2.  3.  5.  4.]\n",
      " [ 1.  1.  1.  7.  1.  6.]\n",
      " [ 1.  1.  9.  1.  3.  7.]\n",
      " [ 1.  1.  5.  3. 17.  2.]]\n",
      "\n",
      "Macierz trójkątna: \n",
      " [[   6.       1.       4.      12.       1.       4.   ]\n",
      " [   0.       3.333   -0.667   -5.       4.333    1.333]\n",
      " [   0.       0.       0.5      6.25    -0.25     5.   ]\n",
      " [   0.       0.       0.    -106.       6.     -79.   ]\n",
      " [   0.       0.       0.       0.      14.943   -3.755]]\n",
      "\n",
      "Rozwiązania: \n",
      " [-1.57272727  1.97045455  0.73611111  0.73106061 -0.25126263]\n"
     ]
    }
   ],
   "source": [
    "x=np.array([[6,1,4,12,1,4],[4,4,2,3,5,4],[1,1,1,7,1,6],[1,1,9,1,3,7],[1,1,5,3,17,2]], dtype=float)\n",
    "print(\"Dane wejściowe: \\n\",x)\n",
    "print()\n",
    "\n",
    "# Obliczenie macierzy trójkątnej:\n",
    "for i in range(0,len(x)):\n",
    "    \n",
    "    for j in range(0,len(x)):\n",
    "        \n",
    "        if i<j:            \n",
    "            t=x[i][:]*x[j][i]/x[i][i]\n",
    "            x[j][:]=x[j][:]-t\n",
    "            t=x[i][:]*x[j][i]\n",
    "            x[j][:]=x[j][:]-t\n",
    "\n",
    "print(\"Macierz trójkątna: \\n\",x.round(3))\n",
    "print()\n",
    "\n",
    "# Wyznaczenie rozwiązań:\n",
    "w=np.zeros(5)\n",
    "b=x[:,5]\n",
    "w[4]=b[4]/x[len(x)-1][4]\n",
    "\n",
    "for i in range(3,-1,-1):\n",
    "    \n",
    "    s=0\n",
    "    for j in range(i+1,len(x)):\n",
    "        s+=w[j]*x[i][j]    \n",
    "        \n",
    "    w[i]=(b[i]-s)/x[i][i]\n",
    "    \n",
    "print(\"Rozwiązania: \\n\", w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Dekompozycja LU\n",
    "\n",
    "$$\\left[ \\begin{matrix}a_{11}&a_{12}&a_{13}\\\\ a_{21}&a_{22}&a_{23}\\\\ a_{31}&a_{32}&a_{33}\\\\ \\end{matrix} \\right]  =\\left[ \\begin{matrix}1&0&0\\\\ l_{21}&1&0\\\\ l_{31}&l_{32}&1\\\\ \\end{matrix} \\right]  \\cdot \\left[ \\begin{matrix}u_{11}&u_{12}&u_{13}\\\\ 0&u_{22}&u_{23}\\\\ 0&0&u_{33}\\\\ \\end{matrix} \\right]  $$\n",
    "\n",
    "\n",
    "$$u_{ij}=a_{ij}-\\sum^{i-1}_{k=1} l_{ik}u_{kj},\\  i\\eqslantless j\\  \\  \\  \\  \\  \\  \\  \\  \\  l_{ij}=\\frac{1}{u_{ij}} (a_{ij}-\\sum^{j-1}_{k=1} l_{ik}u_{kj}),\\  j\\  <i\\  {}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. Metoda Jacobiego (iteracyjna)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 7.11110202 -3.22220342]\n"
     ]
    }
   ],
   "source": [
    "def jacobi(A,b,N=25,x=None):\n",
    "    \"\"\"Solves the equation Ax=b via the Jacobi iterative method.\"\"\"\n",
    "    # Create an initial guess if needed                                                                                                                                                            \n",
    "    if x is None:\n",
    "        x = np.zeros(len(A[0]))\n",
    "\n",
    "    # Create a vector of the diagonal elements of A                                                                                                                                                \n",
    "    # and subtract them from A                                                                                                                                                                     \n",
    "    D = np.diag(A)\n",
    "    R = A - np.diagflat(D)\n",
    "\n",
    "    # Iterate for N times                                                                                                                                                                          \n",
    "    for i in range(N):\n",
    "        x = (b - np.dot(R,x)) / D\n",
    "    return x\n",
    "\n",
    "A = np.array([[2.0,1.0],[5.0,7.0]])\n",
    "b = np.array([11.0,13.0])\n",
    "guess = np.array([1.0,1.0])\n",
    "\n",
    "sol = jacobi(A,b,N=25,x=guess)\n",
    "\n",
    "print(sol)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}