directmeths_Jacobi_GS_SOR.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Las matrices del problema son:\n",
      "[4. 2. 3.]   [ x0 ]   [ 8.0 ]\n",
      "[ 3. -5.  2.]   [ x1 ] = [ -14.0 ]\n",
      "[-2.  3.  8.]   [ x2 ]   [ 27.0 ]\n",
      " \n",
      "\n",
      "###### METODO DE JACOBI ######\n",
      "Los valores obtenidos, con un error aparente:   6.74054333984163e-06 < 1e-05 ,  fueron:\n",
      "\n",
      "[-0.9999846437721662, 3.000002372548024, 2.000009737969384]\n",
      "\n",
      "Este resultado fue alcanzado con  61  iteraciones\n",
      "\n",
      "\n",
      "###### METODO DE GAUSS-SEIDEL ######\n",
      "Los valores obtenidos, con un error aparente:   5.620655875365208e-06 < 1e-05 (epsilon dado),  fueron:\n",
      "\n",
      "[-0.9999986879098, 3.000000702152568, 2.000000064715337]\n",
      "\n",
      "Este resultado fue alcanzado con  13  iteraciones\n",
      "\n",
      "\n",
      "###### METODO SOR ######\n",
      "Para w= 0.5\n",
      "Los valores obtenidos, con un error aparente:   4.723224866732558e-06 < 1e-05 (epsilon dado),  fueron:\n",
      "\n",
      "[-0.9999920626418239, 3.0000023332008197, 2.0000032212333845]\n",
      "\n",
      "Este resultado fue alcanzado con  21  iteraciones\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#! /usr/bin/python3\n",
    "\n",
    "from numpy import *\n",
    "\n",
    "import matplotlib.pyplot as plt # from pylab import plot,show\n",
    "from matplotlib.pyplot import figure\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "### METODO DE JACOBI ###\n",
    "def imprimir_problema(M,N):\n",
    "    lineas = len(M)\n",
    "    #creando matriz de variables\n",
    "    X=[]\n",
    "    linea_igual = lineas % 2\n",
    "    if linea_igual != 0 :\n",
    "        linea_igual = 0.5 + lineas/2\n",
    "    for k in range(lineas):\n",
    "        p= \"x\"+str(k)\n",
    "        X.append(p)\n",
    "    for i in range (lineas):\n",
    "        if i == (linea_igual-1):\n",
    "            print(M[i],\" \",\"[\",X[i],\"]\",\"=\",\"[\",N[i],\"]\")\n",
    "        else : \n",
    "            print(M[i],\" \",\"[\",X[i],\"]\",\" \",\"[\",N[i],\"]\") \n",
    "    return \" \"\n",
    "\n",
    "#Sea la matriz del problema\n",
    "\n",
    "A=array([(4.0,2.0,3.0),\n",
    "         (3.0,-5.0,2.0),\n",
    "         (-2.0,3.0,8.0)])\n",
    "         \n",
    "B=array([8.0,-14.0,27.0])\n",
    "\n",
    "def e_ap(xup,xlow):                  #funcion para el error aparente\n",
    "    return abs((xup-xlow)/xlow)\n",
    "    \n",
    "\n",
    "def met_jacobi(M,N):\n",
    "    #dividimos la matriz principal en matrices D, L y U\n",
    "    limite = len(M)\n",
    "    dim_M = M.shape\n",
    "    #inicializamos las matrices\n",
    "    D = zeros(limite) #la hacemos un solo vector con los valores de diagonal\n",
    "    L = zeros(dim_M) #con tamaño dim_M=(rangoM,rangoM) por ser M cuadrada\n",
    "    U = zeros(dim_M) \n",
    "    \n",
    "    #Lista de errores\n",
    "    err_jacobi=[]\n",
    "    \n",
    "    #llenamos las matrices\n",
    "    \n",
    "    #para la matriz D\n",
    "    for i in range(limite):\n",
    "        D[i] = M[i][i]\n",
    "    #print(D) \n",
    "    \n",
    "    #para la matriz U\n",
    "    for i in range(limite):\n",
    "        for j in range (i+1,limite):\n",
    "            U[i][j] = M[i][j]\n",
    "    #print(U) \n",
    "    \n",
    "    #para la matriz L\n",
    "    for i in range(limite):\n",
    "        for j in range (i+1,limite):\n",
    "            L[j][i] = M[j][i]\n",
    "    #print(L) \n",
    "      \n",
    "    SUM= L + U\n",
    "    #print(SUM)\n",
    "    \n",
    "    X=[] #array para almacenar los valores de (x, y, z)\n",
    "        \n",
    "    #la 1era iteracion es especial pues debemos comenzar con un \"guess value\"\n",
    "    #generalizamos para n  e igualamos a 0. En este ejercicio: (x0,y0,z0) = (0,0,0)\n",
    "    \n",
    "    for j in range(limite):\n",
    "        x = N[j]/D[j]\n",
    "        X.append(x)\n",
    "    i=len(X)  \n",
    "        \n",
    "    #por lo anterior, esta parte siempre emperazará desde la 2da iteración\n",
    "    epsilon =  0.00001\n",
    "    err_it = 1\n",
    "    iteracion=1 #pues ya se hizo la primera iteracion igualando a 0\n",
    "    \n",
    "    while err_it > epsilon :\n",
    "        for k in range (limite):\n",
    "            y = (N - dot(SUM,X[0:i]))/ D\n",
    "            \n",
    "        #buscamos el error, analizamos solo para el valor de x\n",
    "        err_it= e_ap(y[0],X[0])\n",
    "#         err_it2= inner(y[0],X[0])\n",
    "#         plt.plot(err_it2)\n",
    "        err_jacobi.append(err_it)\n",
    "        \n",
    "        X=[] #vaciamos X y luego le agregamos los nuevos valores de y para la nueva iteracion\n",
    "        #ingresamos los valores de y a la lista X\n",
    "        for j in range (limite):\n",
    "            X.append(y[j])\n",
    "        y=[] #vaciamos y    \n",
    "        iteracion += 1  \n",
    "        #print(X,\"__\",iteracion,err_it)  #decomentar para ver la evolucion según se varía epsilon\n",
    "    \n",
    "    print(\"Los valores obtenidos, con un error aparente:  \",err_it,\"<\",epsilon,\",  fueron:\")\n",
    "    print(\"\")\n",
    "    print(X)\n",
    "    print(\"\")\n",
    "    print(\"Este resultado fue alcanzado con \",iteracion,\" iteraciones\")\n",
    "    plt.plot(err_jacobi, label = \"Jacobi\")\n",
    "    return(\"\")\n",
    "\n",
    "###METODO de GAUS-SEIDEL###\n",
    "def met_GS(M,N):\n",
    "    #dividimos la matriz principal en matrices D, L y U\n",
    "    limite = len(M)\n",
    "    dim_M = M.shape\n",
    "    #inicializamos las matrices\n",
    "    D = zeros(limite) #la hacemos un solo vector con los valores de diagonal\n",
    "    L = zeros(dim_M) \n",
    "    U = zeros(dim_M) \n",
    "    \n",
    "    #Lista de errores\n",
    "    err_GS=[]\n",
    "    \n",
    "    #llenamos las matrices\n",
    "    \n",
    "    #para la matriz D\n",
    "    for i in range(limite):\n",
    "        D[i] = M[i][i]\n",
    "    #print(D) \n",
    "    \n",
    "    #para la matriz U\n",
    "    for i in range(limite):\n",
    "        for j in range (i+1,limite):\n",
    "            U[i][j] = M[i][j]\n",
    "    #print(U) \n",
    "    \n",
    "    #Ahora L será lower + diagonal\n",
    "    L = M - U\n",
    "        \n",
    "    X=[] #array para almacenar los valores de (x, y, z)\n",
    "        \n",
    "    #la 1era iteracion es especial pues debemos comenzar con un \"guess value\"\n",
    "    #generalizamos para n=(limite). Para este este ejercicio: (x0,y0,z0) = (0,0,0)\n",
    "    \n",
    "    for j in range(limite):\n",
    "        x = 0\n",
    "        X.append(x)\n",
    "    i=len(X) \n",
    "        \n",
    "    #por lo anterior, esta parte siempre emperazará desde la 2da iteración\n",
    "    epsilon =  0.00001\n",
    "    err_it = 1 #inicializamos para que pueda ingresar al while\n",
    "    iteracion=1 #pues ya se hizo la primera iteracion igualando a 0\n",
    "    \n",
    "    while err_it > epsilon :\n",
    "        for k in range (limite):\n",
    "            y= dot(linalg.inv(L), N - dot(U, X[0:i]))\n",
    "            \n",
    "        #buscamos el error, analizamos solo para el valor de x\n",
    "        err_it= e_ap(y[0],X[0])\n",
    "#         err_it2= inner(y[0],X[0])\n",
    "#         plt.plot(err_it2)\n",
    "        err_GS.append(err_it)\n",
    "        \n",
    "        \n",
    "        X=[] #vaciamos X y luego le agregamos los nuevos valores de y para la nueva iteracion\n",
    "        #ingresamos los valores de y a la lista X\n",
    "        for j in range (limite):\n",
    "            X.append(y[j])\n",
    "        #print(y,X,iteracion,err_it) #decomentar para ver la evolucion según se varía epsilon          \n",
    "        y=[] #vaciamos y    \n",
    "        iteracion += 1  \n",
    "   \n",
    "    print(\"Los valores obtenidos, con un error aparente:  \",err_it,\"<\",epsilon,\"(epsilon dado),  fueron:\")\n",
    "    print(\"\")\n",
    "    print(X)\n",
    "    print(\"\")\n",
    "    print(\"Este resultado fue alcanzado con \",iteracion-1,\" iteraciones\")\n",
    "    plt.plot(err_GS, label = \"Gauss-Seidel\")\n",
    "    return(\"\")\n",
    "\n",
    "\n",
    "##METODO SOR###\n",
    "#Para SOR usamos el mismo código de G-S pero con modificaciones para poder añadir w\n",
    "\n",
    "def met_SOR(M,N,omega):\n",
    "    \n",
    "    limite = len(M)\n",
    "    dim_M = M.shape\n",
    "   \n",
    "    D = zeros(dim_M) \n",
    "    L = zeros(dim_M) \n",
    "    U = zeros(dim_M) \n",
    "    \n",
    "    err_SOR=[]\n",
    "    \n",
    "    #para la matriz D\n",
    "    for i in range(limite):\n",
    "        D[i][i] = M[i][i]\n",
    "    \n",
    "    #para la matriz U\n",
    "    for i in range(limite):\n",
    "        for j in range (i+1,limite):\n",
    "            U[i][j] = M[i][j]\n",
    "    #print(U) \n",
    "    \n",
    "    #para la matriz L\n",
    "    for i in range(limite):\n",
    "        for j in range (i+1,limite):\n",
    "            L[j][i] = M[j][i]\n",
    "    #print(L) \n",
    "    \n",
    "    #Ahora L será lower + diagonal\n",
    "    Lx = D + omega*L\n",
    "    \n",
    "    X=[] #array para almacenar los valores de (x, y, z)\n",
    "        \n",
    "    #la 1era iteracion es especial pues debemos comenzar con un \"guess value\"\n",
    "    #generalizamos para n pero en este ejercicio haremos (x0,y0,z0) = (0,0,0)\n",
    "    \n",
    "    for j in range(limite):\n",
    "        x = 0\n",
    "        X.append(x)\n",
    "    i=len(X) \n",
    "        \n",
    "    #por lo anterior, esta parte siempre emperazará desde la 2da iteración\n",
    "    epsilon =  0.00001\n",
    "    err_it = 1\n",
    "    iteracion=1\n",
    "    \n",
    "    while err_it > epsilon :\n",
    "        for k in range (limite):\n",
    "            y= dot(linalg.inv(Lx), N - dot((1-omega)*L+U, X[0:i]))\n",
    "            \n",
    "        #buscamos el error, analizamos solo para el valor de x\n",
    "        err_it= e_ap(y[0],X[0])\n",
    "#         err_it2= inner(y[0],X[0])\n",
    "#         plt.plot(err_it2)\n",
    "        err_SOR.append(err_it)\n",
    "        \n",
    "        \n",
    "        X=[] #vaciamos X y luego le agregamos los nuevos valores de y para la nueva iteracion\n",
    "        #ingresamos los valores de y a la lista X\n",
    "        for j in range (limite):\n",
    "            X.append(y[j])\n",
    "        #print(y,X,iteracion,err_it) #decomentar para ver la evolucion según se varía epsilon          \n",
    "        y=[] #vaciamos y    \n",
    "        iteracion += 1 \n",
    "        \n",
    "        \n",
    "        \n",
    "    print(\"Para w=\",omega)\n",
    "    print(\"Los valores obtenidos, con un error aparente:  \",err_it,\"<\",epsilon,\"(epsilon dado),  fueron:\")\n",
    "    print(\"\")\n",
    "    print(X)\n",
    "    print(\"\")\n",
    "    print(\"Este resultado fue alcanzado con \",iteracion-1,\" iteraciones\")\n",
    "    plt.plot(err_SOR, label = \"SOR w=\"+str(omega))\n",
    "    return(\"\")\n",
    "\n",
    "\n",
    "print(\"Las matrices del problema son:\")\n",
    "print(imprimir_problema(A,B))\n",
    "print(\"\")\n",
    "print(\"###### METODO DE JACOBI ######\")\n",
    "print(met_jacobi(A,B))  \n",
    "print(\"\")\n",
    "print(\"###### METODO DE GAUSS-SEIDEL ######\")\n",
    "print(met_GS(A,B))\n",
    "print(\"\")\n",
    "print(\"###### METODO SOR ######\")\n",
    "w=0.5 \n",
    "print(met_SOR(A,B,w))\n",
    "#se comprueba que si w=1 -->se genera el mismo resultado que G-S, debería generar la misma gráfica\n",
    "#print(met_SOR(A,B,1)) #decomentar para observar la superposicion de gráfica\n",
    "\n",
    "\n",
    "plt.yscale('log')\n",
    "plt.legend()\n",
    "plt.grid()\n",
    "plt.ylabel('error (%)')\n",
    "plt.xlabel('iteraciones')\n",
    "plt.show()\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "########################\n",
      "METODOS DE OPTIMIZACIÓN\n",
      "########################\n",
      "Usamos la siguientes matrices para poder mostrar los métodos de optimización\n",
      "[ 2. -1.  0.]   [ x0 ]   [ 8.0 ]\n",
      "[-1.  2. -1.]   [ x1 ] = [ -14.0 ]\n",
      "[ 0. -1.  2.]   [ x2 ]   [ 27.0 ]\n",
      " \n",
      "Siendo la matriz principal SPD\n",
      "\n",
      "Mostramos los resultado hallados con el método de gauss-seidel\n",
      "\n",
      "###### METODO DE GAUSS-SEIDEL ######\n",
      "Los valores obtenidos, con un error aparente:   5.639181297024967e-06 < 1e-05 (epsilon dado),  fueron:\n",
      "\n",
      "[5.749967575073242, 3.499967575073242, 15.249983787536621]\n",
      "\n",
      "Este resultado fue alcanzado con  19  iteraciones\n",
      "\n",
      "\n",
      "Comparamos con los resultados obtenidos para máximo descenso\n",
      "\n",
      "###### METODO DE MAXIMO DESCENSO ######\n",
      "Los valores obtenidos, con un error aparente:   5.647781973542085e-06 < 1e-05 (epsilon dado),  fueron:\n",
      "\n",
      "[ 5.74920876  3.49924104 15.24920876]\n",
      "\n",
      "Este resultado fue alcanzado con  26  iteraciones\n",
      "\n",
      "###### METODO DE GRADIENTE CONJUGADO ######\n",
      "Los valores obtenidos, con un error aparente:   7.76772787047671e-06 < 1e-05 (epsilon dado),  fueron:\n",
      "\n",
      "[ 5.75010516  3.50000861 15.25009855]\n",
      "\n",
      "Este resultado fue alcanzado con  62  iteraciones\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Se observa una cierta divergencia en los errores para estos últimos métodos\n",
      "FIN\n"
     ]
    }
   ],
   "source": [
    "\n",
    "print(\"########################\")\n",
    "print(\"METODOS DE OPTIMIZACIÓN\")\n",
    "print(\"########################\")\n",
    "## METODOS DE OPTIMIZACION\n",
    "\n",
    "### METODO MAXIMO DESCENSO\n",
    "\n",
    "\n",
    "K=array([(2.0,-1.0,0),\n",
    "         (-1.0,2.0,-1.0),\n",
    "         (0.0,-1.0,2.0)])\n",
    "    \n",
    "B=array([8.0,-14.0,27.0])\n",
    "\n",
    "#método encontrado en internet que verifica si la matriz, solo usa la biblioteca numpy \n",
    "#fuente: https://stackoverflow.com/questions/16266720/find-out-if-matrix-is-positive-definite-with-numpy\n",
    "\n",
    "def is_pos_def(M):\n",
    "    if array_equal(M, M.T):\n",
    "        try:\n",
    "            linalg.cholesky(M) #como se vio, solo matrices del tipo SPD cumplen cholesky\n",
    "            return True\n",
    "        except linalg.LinAlgError:\n",
    "            return False\n",
    "    else:\n",
    "        return False\n",
    "\n",
    "#print(is_pos_def(K)) #output para K : True\n",
    "\n",
    "def max_des(M,N):\n",
    "    lim = len (M)\n",
    "    X=zeros(lim)\n",
    "    for k in range(lim):\n",
    "        X[k] = 1            #cambiar si se desea un \"initial_guess\" diferente\n",
    "   \n",
    "    err_it=1\n",
    "    err_grad=[]\n",
    "    epsilon= 0.00001\n",
    "    iteracion=1 #contando el initial guess\n",
    "    \n",
    "    while err_it > epsilon:\n",
    "        \n",
    "        r= N - dot(M,X)\n",
    "        \n",
    "        alfa = dot(r.T,r)/dot(r.T,dot(M,r))\n",
    "        \n",
    "        Xnew = X + alfa*r\n",
    "        \n",
    "        err_it=e_ap(Xnew[0],X[0])\n",
    "        err_grad.append(err_it)\n",
    "        \n",
    "        X=Xnew\n",
    "        iteracion += 1 \n",
    "        \n",
    "    print(\"Los valores obtenidos, con un error aparente:  \",err_it,\"<\",epsilon,\"(epsilon dado),  fueron:\")\n",
    "    print(\"\")\n",
    "    print(Xnew)\n",
    "    print(\"\")\n",
    "    print(\"Este resultado fue alcanzado con \",iteracion-1,\" iteraciones\")\n",
    "    plt.plot(err_grad, label = \"Máximo descenso\")\n",
    "    return(\"\")\n",
    "    \n",
    "def grad_conj(M,N):\n",
    "    lim = len (M)\n",
    "    X=zeros(lim)\n",
    "    for k in range(lim):\n",
    "        X[k] = 1            #cambiar si se desea un \"initial_guess\" diferente\n",
    "   \n",
    "    err_it=1\n",
    "    err_conj=[]\n",
    "    epsilon= 0.00001\n",
    "    iteracion=1 #contando el initial guess\n",
    "    \n",
    "    r = N - dot(M,X) #inicio r\n",
    "    \n",
    "    beta = dot(r.T,r)\n",
    "    \n",
    "    d = r\n",
    "    \n",
    "    while err_it > epsilon:\n",
    "        \n",
    "        z = dot(M,d)\n",
    "        \n",
    "        alfa = beta/dot(d.T,z)\n",
    "        \n",
    "        Xnew = X + alfa*d\n",
    "        \n",
    "        r = r -alfa*z\n",
    "        \n",
    "        y=beta\n",
    "        \n",
    "        beta=dot(r.T,r)\n",
    "        \n",
    "        alfa = -beta/y\n",
    "        \n",
    "        d = -r + alfa*d\n",
    "                \n",
    "        err_it=e_ap(Xnew[0],X[0]) #por conveniencia, solo analizamos el error en x\n",
    "        err_conj.append(err_it)\n",
    "#         err_it2= inner(y[0],X[0])\n",
    "#         plt.plot(err_it2, label = \"inner Grad conj\")\n",
    "\n",
    "        X=Xnew\n",
    "        \n",
    "        iteracion += 1 \n",
    "        \n",
    "    print(\"Los valores obtenidos, con un error aparente:  \",err_it,\"<\",epsilon,\"(epsilon dado),  fueron:\")\n",
    "    print(\"\")\n",
    "    print(Xnew)\n",
    "    print(\"\")\n",
    "    print(\"Este resultado fue alcanzado con \",iteracion-1,\" iteraciones\")\n",
    "    plt.plot(err_conj, label = \"Grad conj\")\n",
    "    return(\"\")\n",
    "    \n",
    "    \n",
    "print(\"Usamos la siguientes matrices para poder mostrar los métodos de optimización\")\n",
    "print(imprimir_problema(K,B))\n",
    "print(\"Siendo la matriz principal SPD\") #simétrica positiva definida\n",
    "print(\"\")\n",
    "print(\"Mostramos los resultado hallados con el método de gauss-seidel\")#para poder comparar con los nuevos resultados\n",
    "print(\"\")\n",
    "print(\"###### METODO DE GAUSS-SEIDEL ######\")\n",
    "print(met_GS(K,B))\n",
    "print(\"\")\n",
    "print(\"Comparamos con los resultados obtenidos para máximo descenso\")\n",
    "print(\"\")\n",
    "print(\"###### METODO DE MAXIMO DESCENSO ######\")\n",
    "print(max_des(K,B)) \n",
    "print(\"###### METODO DE GRADIENTE CONJUGADO ######\")\n",
    "print(grad_conj(K,B)) \n",
    "\n",
    "\n",
    "plt.yscale('log')\n",
    "plt.legend()\n",
    "plt.grid()\n",
    "plt.ylabel('error (%)')\n",
    "plt.xlabel('iteraciones')\n",
    "plt.show()\n",
    "\n",
    "print(\"Se observa una cierta divergencia en los errores para estos últimos métodos\")\n",
    "print(\"FIN\")"
   ]
  }
 ],
 "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}