3_SistemasLineales.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Sistemas de Ecuaciones Lineales\n",
    "\n",
    "En este capitulo visitaremos el tema de los métodos numéricos para resolver sistemas lineas de ecuaciones simulataneas. Para poder explicar cada método  necesitaremos algunos sistemas lineales de prueba.\n",
    "\n",
    "Un sistema lineal general de dos ecuaciones simulataneas y dos incognitas.\n",
    "$$ a_{11} x_1 + a_{12} x_2 = b_1 \\\\ \n",
    "a_{21} x_1 + a_{22} x_2 = b_2 $$\n",
    "\n",
    "El sistema anterior se puede escribir como una igualtad de de dos vectores:\n",
    "$$\n",
    "\\begin{gather}\n",
    " \\begin{bmatrix}\n",
    "  a_{11} x_1 + a_{12} x_2 \\\\\n",
    "  a_{21} x_1 + a_{22} x_2\n",
    " \\end{bmatrix}\n",
    " =\n",
    "  \\begin{bmatrix}\n",
    "   b_1\\\\\n",
    "   b_2 \n",
    "   \\end{bmatrix}\n",
    "\\end{gather}\n",
    "$$\n",
    "\n",
    "Se puede reescribir la combinacion lineal de incognitas en forma de un producto matricial:\n",
    "$$\n",
    "\\begin{gather}\n",
    " \\begin{bmatrix}\n",
    "  a_{11} & a_{12}\\\\\n",
    "  a_{21} & a_{22}\n",
    " \\end{bmatrix}\n",
    "  \\begin{bmatrix}\n",
    "  x_1\\\\\n",
    "  x_2\n",
    " \\end{bmatrix}\n",
    " =\n",
    "  \\begin{bmatrix}\n",
    "   b_1\\\\\n",
    "   b_2 \n",
    "   \\end{bmatrix}\n",
    "\\end{gather}\n",
    "$$\n",
    "Se puede reescribir en forma compacta y general como:\n",
    "\n",
    "$$\n",
    "\\mathbf A \\mathbf x=\\mathbf b\n",
    "$$\n",
    "\n",
    "Donde:\n",
    "$$\n",
    "\\mathbf A=  \n",
    " \\begin{bmatrix}\n",
    "  a_{11} & a_{12}\\\\\n",
    "  a_{21} & a_{22}\n",
    " \\end{bmatrix}\n",
    "$$\n",
    "\n",
    "$$\n",
    "\\mathbf x= \n",
    "\\begin{bmatrix}\n",
    "  x_1\\\\\n",
    "  x_2\n",
    " \\end{bmatrix}\n",
    "$$\n",
    "\n",
    "$$\n",
    "\\mathbf b=\n",
    "  \\begin{bmatrix}\n",
    "   b_1\\\\\n",
    "   b_2 \n",
    "   \\end{bmatrix} \n",
    "$$\n",
    " \n",
    "La matriz $\\mathbf A$ es conocida como la *matriz de coeficientes*, el vector $ \\mathbf x $ es conocido como el *vector de incognitas* y  $\\mathbf b$ el *vector de terminos libres*.\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Rango, independecia lineal, transformaciones lineales\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "## Matrizes o trnasformaciones lineales importantes e inversa\n",
    "El concepto de de transformacion lineal , es cualquier objeto u operacion que transforma un vector en otro vector. El producto matriz vector produce otro vector por lo tanto el sistema de ecuaciones lineales es una tranformacion linea.\n",
    "Comunmente existe multiple tipos y grupos de tranformaciones. A continuacion expondremos casos de tranformaciones lineal mas comunes\n",
    "### Identidad\n",
    "la matriz identidad posee la propiedad de transformar un vector a sis mismo. en esencia no altera el vector de entrada. es equivalente a al elmento 0 en la suma o el elemento 1 en la multiplicacion.\n",
    "Ejemplo de matriz identidad en 3  dimensiones.\n",
    "\n",
    "$$\n",
    "\\mathbf I=  \n",
    " \\begin{bmatrix}\n",
    "  1 & 0 & 0\\\\\n",
    "  0 & 1 & 0\\\\\n",
    "  0 & 0 & 1\n",
    " \\end{bmatrix}\n",
    "$$\n",
    "\n",
    "Se puede demostrar facilemente que la matriz que contiene 1 en la diagonal producira el mismo vector como $ \\mathbf I \\mathbf x= \\mathbf x$.\n",
    "\n",
    "La tranformacion inversa de la matriz identidad es ella misma $$ \\mathbf I^{-1} = \\mathbf I $$\n",
    "\n",
    "### Escalado\n",
    "La matriz que scala un vector estirandolo o comprimiendolo se conoce como scala y posee la siguiente estructura:\n",
    "$$\n",
    "\\mathbf S=  \n",
    " \\begin{bmatrix}\n",
    "  s_1 & 0 & 0\\\\\n",
    "  0 & s_2 & 0\\\\\n",
    "  0 & 0 & s_3\n",
    " \\end{bmatrix}\n",
    "$$\n",
    "En el caso de una escala homogenea $s_1=s_2=s_3=s$\n",
    "\n",
    "### Distorsion cortante\n",
    "$$\n",
    "\\mathbf F=  \n",
    " \\begin{bmatrix}\n",
    "  1 & s_{12} & 0\\\\\n",
    "  0 & 1 & 0\\\\\n",
    "  0 & 0 & 1\n",
    " \\end{bmatrix}\n",
    "$$\n",
    "\n",
    "### Rotacion\n",
    "Solo por mostrar un ejemplo la rotacion de un vector en el eje Z\n",
    "$$\n",
    "\\mathbf R_z =  \n",
    " \\begin{bmatrix}\n",
    "  cos(\\theta) & -sin(\\theta) & 0\\\\\n",
    "  sin(\\theta) & cos(\\theta) & 0\\\\\n",
    "  0 & 0 & 1\n",
    " \\end{bmatrix}\n",
    "$$\n",
    "\n",
    "### Matrices ortogonales\n",
    "Son matrices que sus inversas son su transpuesta\n",
    "$$ \\mathbf Q^{-1} = \\mathbf Q^T $$\n",
    "Como ejemplo clasico la matrices de rotacion son matrices ortogonales.\n",
    "\n",
    "\n",
    "### MAtrices simetricas\n",
    "Sus elementos son simetricos a lo largo de la diagonal(ejemplo scalaado)\n",
    "$$\n",
    "\\mathbf{Symm}=  \n",
    " \\begin{bmatrix}\n",
    "  x_1 & a & b\\\\\n",
    "  a & x_2 & c\\\\\n",
    "  b & c & x_3\n",
    " \\end{bmatrix}\n",
    "$$\n",
    "Esto implica $ M^T = M $\n",
    "\n",
    "### Matrices anti-simetricas\n",
    "Sus elementos son de signo opuesto a lo largo de la diagonal(ejemplo rotacion)\n",
    "$$\n",
    "symm=  \n",
    " \\begin{bmatrix}\n",
    "  x_1 & a & b\\\\\n",
    "  -a & x_2 & c\\\\\n",
    "  -b & -c & x_3\n",
    " \\end{bmatrix}\n",
    "$$\n",
    "Esto implica $ -K^T = K $\n",
    "\n",
    "### Projecciones\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "## Systemas lineales y algunas definiciones:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "x1 = np.array([1,2,3]) \n",
    "x2 = np.array([3,7,10])\n",
    "x3 = 2*x1\n",
    "x4 = np.array([1,2,3,42,9,4,7,10,1,10]) \n",
    "\n",
    "aa = np.array([1,2,3,4,5,6,7,8,9])\n",
    "aa = aa.reshape([3,3])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6],\n",
       "       [7, 8, 9]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "aa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "aa = aa - 5*np.eye(3)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0.],\n",
       "       [0., 0., 0.],\n",
       "       [0., 0., 0.]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros([3,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones([4,4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0., 0.],\n",
       "       [0., 1., 0., 0.],\n",
       "       [0., 0., 1., 0.],\n",
       "       [0., 0., 0., 1.]])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.eye(4)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 3],\n",
       "       [0, 0, 6],\n",
       "       [7, 8, 9]])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bb = np.array([[1,2,3],\n",
    "               [4,5,6],\n",
    "               [7,8,9]])  \n",
    "bb[0:2,0:2] = np.zeros((2,2))\n",
    "bb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Métodos Directos\n",
    "MEtodos que utilizan una cantidad finita y restablecidad de pasos para determinar la solucion de un sistema lineal. Estos metodos.\n",
    "## Reduccion Gausseana\n",
    "Este metodo utilizado para resolver sistemas lineales utilizando el concepto de transformaciones lineales, y con ol objetivo de reducir el sistema lineal.\n",
    "$$Ax = b$$\n",
    "$$\n",
    "A=  \n",
    " \\begin{bmatrix}\n",
    "  a & b & c\\\\\n",
    "  d & e & f\\\\\n",
    "  g & h & i\n",
    " \\end{bmatrix}\n",
    "$$\n",
    "\n",
    "$$\n",
    "b=  \n",
    " \\begin{bmatrix}\n",
    "  b_1\\\\\n",
    "  b_2\\\\\n",
    "  b_3\n",
    " \\end{bmatrix}\n",
    "$$\n",
    "\n",
    "La matriz aumentada:\n",
    "$$\n",
    "\\begin{array}{ccc|c}\n",
    "  a & b & c & b_1\\\\\n",
    "  d & e & f & b_2\\\\\n",
    "  g & h & i & b_3\n",
    "\\end{array}\n",
    "$$\n",
    "Paso 1: normalizar  la primera fila con el elemento diagonal\n",
    "\n",
    "$$\n",
    "\\begin{array}{ccc|c}\n",
    "  \\fbox 1 & \\frac{b}{a} & \\frac{c}{a} & \\frac{b_1}{a}\\\\\n",
    "  d & e & f & b_2\\\\\n",
    "  g & h & i & b_3\n",
    "\\end{array}\n",
    "$$\n",
    "\n",
    "Paso 2: eliminar los elementos debajo del primer elemento de la diagonal\n",
    "$fila_2 = fila_2 - d * fila_1$\n",
    "$$\n",
    "\\begin{array}{ccc|c}\n",
    "  1 & \\frac{b}{a} & \\frac{c}{a} & \\frac{b_1}{a}\\\\\n",
    "  \\fbox 0 & e - d \\frac{b}{a} & f - d \\frac{c}{a} &b_2 -  \\frac{d*b_1}{a} \\\\\n",
    "  \\fbox 0 & h - d*b/a & i - d*c/a\n",
    "\\end{array}\n",
    "$$\n",
    "\n",
    "Paso 3: nomalizar el segundo elemento de la diagonal\n",
    "\n",
    "$$\n",
    "\\begin{array}{ccc|c}\n",
    "  1 & b/a & c/a  & \\frac{b_1}{a}\\\\\n",
    "  0 & \\fbox 1 & \\frac{f - \\frac{d c}{a}}{e - \\frac{d b}{a}} & b_2 -  \\frac{d*b_1}{a}\\\\\n",
    "  0 & h - \\frac{d b}{a} & i - \\frac{d c}{a}\n",
    "\\end{array}\n",
    "$$\n",
    "\n",
    "Paso 3: Repetir el paso 2 con el siguiente elemento\n",
    "$$\n",
    "\\begin{array}{ccc|c}\n",
    "  1 & b/a & c/a & \\frac{b_1}{a}\\\\\n",
    "  0 & \\fbox 1 & \\frac{f - \\frac{d c}{a}}{e - \\frac{d b}{a}} &b_2 -  \\frac{d*b_1}{a}\\\\\n",
    "  0 & 0 & i - \\frac{d c}{a} - (\\frac{f - \\frac{d c}{a}}{e - \\frac{d b}{a}})(h - \\frac{d b}{a})\n",
    "\\end{array}\n",
    "$$\n",
    "\n",
    "Paso 4: Normalizar el ultimo elemento de la diagonal\n",
    "\\begin{array}{ccc|c}\n",
    "  1 & b/a & c/a & \\frac{b_1}{a}\\\\\n",
    "  0 & 1 & \\frac{f - \\frac{d c}{a}}{e - \\frac{d b}{a}} &b_2 -  \\frac{d*b_1}{a}\\\\\n",
    "  0 & 0 & \\fbox 1 & b'_3\n",
    "\\end{array}\n",
    "\n",
    "\n",
    "En este punto el sistema linea debe de tener un triangulo de ceros debajo de la diagonal, y una diagonal de 1. En este punto la matriy esta \"reducida\". El siguiente paso se conoce como *substitucion  inversa*, este proceso comienza desde el ultimo elemento y se remplaza n la eqcuaciones hasta resolver todas las incognitas.\n",
    "\n",
    "$$ x_3 =  b_3'$$\n",
    "\n",
    "Y remplazamos en la fila 2 el valor de $x_3$\n",
    "\n",
    "$$ x_2 = b'_2 - x_3*() $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Matriz de prueba\n",
    "A = np.array( [ [10.0,3  ,2],\n",
    "                [4   ,5  ,3],\n",
    "                [1   ,10 ,20] ] )\n",
    "\n",
    "b = np.array( [4, 6, 12] )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10.,  3.,  2.])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[0,:] #Primera fila"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4., 5., 3.])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[1,:] #Segunda fila"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1., 10., 20.])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[2,:] #tercera fila"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10.,  4.,  1.])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[:,0] #Primera columna"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Elemento a_2,2\n",
    "A[1,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10.,  3.,  2.],\n",
       "       [ 4.,  6.,  3.],\n",
       "       [ 1., 10., 20.]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Modificar elemento\n",
    "A[1,1] = 6\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Matriz aumentada (Augmented matrix)\n",
    "Ab = np.zeros([3,4])\n",
    "Ab[0:3, 0:3] = A\n",
    "Ab[:,3] = b\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A continuacion vamos a modificar la matriz para reducirla en su forma de triangulos de 0 utilizando el algoritmo de gauss:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1. ,  0.3,  0.2,  0.4],\n",
       "       [ 4. ,  6. ,  3. ,  6. ],\n",
       "       [ 1. , 10. , 20. , 12. ]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Paso1\n",
    "Ab[0] = Ab[0] / Ab[0,0]\n",
    "Ab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1. ,  0.3,  0.2,  0.4],\n",
       "       [ 0. ,  4.8,  2.2,  4.4],\n",
       "       [ 0. ,  9.7, 19.8, 11.6]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Paso 2\n",
    "Ab[1] = Ab[1] - Ab[1,0]*Ab[0]\n",
    "Ab[2] = Ab[2] - Ab[2,0]*Ab[0]\n",
    "Ab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.        ,  0.3       ,  0.2       ,  0.4       ],\n",
       "       [ 0.        ,  1.        ,  0.45833333,  0.91666667],\n",
       "       [ 0.        ,  9.7       , 19.8       , 11.6       ]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Paso 3\n",
    "Ab[1] = Ab[1] / Ab[1,1]\n",
    "Ab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.        ,  0.3       ,  0.2       ,  0.4       ],\n",
       "       [ 0.        ,  1.        ,  0.45833333,  0.91666667],\n",
       "       [ 0.        ,  0.        , 15.35416667,  2.70833333]])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#paso 4\n",
    "Ab[2] = Ab[2] - Ab[2,1]*Ab[1]\n",
    "Ab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.        , 0.3       , 0.2       , 0.4       ],\n",
       "       [0.        , 1.        , 0.45833333, 0.91666667],\n",
       "       [0.        , 0.        , 1.        , 0.17639077]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Paso 5\n",
    "Ab[2] = Ab[2] / Ab[2,2]\n",
    "Ab"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En las siguientes celdas vamos a resolver el sistema utilizand substitucion en reversa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.1763907734056987"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x3 = Ab[2,3]\n",
    "x3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8358208955223881"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x2 = Ab[1,3] - Ab[1,2]*x3\n",
    "x2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.11397557666214381"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x1 = Ab[0,3] - Ab[0,2]*x3 - Ab[0,1]*x2\n",
    "x1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.11397558, 0.8358209 , 0.17639077])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([x1,x2,x3])\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 4.,  6., 12.])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Demostracion\n",
    "A.dot(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Algoritmo general para la reducción gaussiana"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gauss(Ab):        \n",
    "    N = Ab.shape[0] #numero de filas\n",
    "\n",
    "    for i in range(N):\n",
    "        print(\"Fila#\"+str(i))\n",
    "        Ab[i] = Ab[i]/Ab[i,i] # Normalizacion de la fila cnel termino de la diagonal\n",
    "        print(str(Ab))\n",
    "        for j in range(i+1,N):\n",
    "            print(\"Reduccion de la fila#\"+str(j))\n",
    "            Ab[j] = Ab[j] - (Ab[j,i] * Ab[i]) #Reduccion\n",
    "            print(str(Ab))\n",
    "\n",
    "\n",
    "def substitucion(Ab):\n",
    "    #TODO: implmentar!\n",
    "    N = Ab.shape[0] #numero de filas\n",
    "    for i in range(N):\n",
    "        print(\"Iteration i=\"+str(i))\n",
    "        Ab[i] = Ab[i]/Ab[i,i] # Normalizacion de la fila con el termino de la diagonal\n",
    "        for j in range(i+1,N):\n",
    "            print(\"iteracion j=\"+str(j))\n",
    "            Ab[j] = Ab[j] - (Ab[j,i] * Ab[i]) #Reduccion\n",
    "            \n",
    "def gauss_jordan(Ab):\n",
    "    N = Ab.shape[0] #numero de filas\n",
    "    for i in range(N):\n",
    "        print(\"Fila#\"+str(i))\n",
    "        Ab[i] = Ab[i]/Ab[i,i] # Normalizacion de la fila cnel termino de la diagonal\n",
    "        for j in range(i+1,N):\n",
    "            #print(\"iteracion DOWN j=\"+str(j))\n",
    "            Ab[j] = Ab[j] - (Ab[j,i] * Ab[i]) #Reduccion\n",
    "            \n",
    "        for j in range(i):\n",
    "            #print(\"iteracion UP j=\"+str(j))\n",
    "            Ab[j] = Ab[j] - (Ab[j,i] * Ab[i]) #Reduccion\n",
    "            \n",
    "        print(Ab)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10.,  3.,  2.,  4.],\n",
       "       [ 4.,  5.,  3.,  6.],\n",
       "       [ 1., 10., 20., 12.]])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Ab_ = Ab.copy()\n",
    "Ab_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fila#0\n",
      "[[ 1.   0.3  0.2  0.4]\n",
      " [ 0.   3.8  2.2  4.4]\n",
      " [ 0.   9.7 19.8 11.6]]\n",
      "Fila#1\n",
      "[[ 1.          0.          0.02631579  0.05263158]\n",
      " [ 0.          1.          0.57894737  1.15789474]\n",
      " [ 0.          0.         14.18421053  0.36842105]]\n",
      "Fila#2\n",
      "[[1.         0.         0.         0.05194805]\n",
      " [0.         1.         0.         1.14285714]\n",
      " [0.         0.         1.         0.02597403]]\n"
     ]
    }
   ],
   "source": [
    "gauss_jordan(Ab_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10.,  3.,  2.,  1.,  0.,  0.],\n",
       "       [ 4.,  5.,  3.,  0.,  1.,  0.],\n",
       "       [ 1., 10., 20.,  0.,  0.,  1.]])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AA = np.zeros([3,6])\n",
    "AA[0:3 , 0:3] = A\n",
    "AA[0:3 , 3:] = np.eye(3)\n",
    "AA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fila#0\n",
      "[[ 1.   0.3  0.2  0.1  0.   0. ]\n",
      " [ 4.   5.   3.   0.   1.   0. ]\n",
      " [ 1.  10.  20.   0.   0.   1. ]]\n",
      "Reduccion de la fila#1\n",
      "[[ 1.   0.3  0.2  0.1  0.   0. ]\n",
      " [ 0.   3.8  2.2 -0.4  1.   0. ]\n",
      " [ 1.  10.  20.   0.   0.   1. ]]\n",
      "Reduccion de la fila#2\n",
      "[[ 1.   0.3  0.2  0.1  0.   0. ]\n",
      " [ 0.   3.8  2.2 -0.4  1.   0. ]\n",
      " [ 0.   9.7 19.8 -0.1  0.   1. ]]\n",
      "Fila#1\n",
      "[[ 1.          0.3         0.2         0.1         0.          0.        ]\n",
      " [ 0.          1.          0.57894737 -0.10526316  0.26315789  0.        ]\n",
      " [ 0.          9.7        19.8        -0.1         0.          1.        ]]\n",
      "Reduccion de la fila#2\n",
      "[[ 1.          0.3         0.2         0.1         0.          0.        ]\n",
      " [ 0.          1.          0.57894737 -0.10526316  0.26315789  0.        ]\n",
      " [ 0.          0.         14.18421053  0.92105263 -2.55263158  1.        ]]\n",
      "Fila#2\n",
      "[[ 1.          0.3         0.2         0.1         0.          0.        ]\n",
      " [ 0.          1.          0.57894737 -0.10526316  0.26315789  0.        ]\n",
      " [ 0.          0.          1.          0.06493506 -0.17996289  0.07050093]]\n"
     ]
    }
   ],
   "source": [
    "gauss(AA)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "Ainv = AA[:, 3:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.00000000e+00,  6.07153217e-18,  2.60208521e-17],\n",
       "       [ 4.85722573e-17,  1.00000000e+00, -2.77555756e-17],\n",
       "       [ 9.71445147e-17,  8.32667268e-17,  1.00000000e+00]])"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Ainv.dot(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10.,  3.,  2.,  1.,  0.,  0.],\n",
       "       [ 4.,  6.,  3.,  0.,  1.,  0.],\n",
       "       [ 1., 10., 20.,  0.,  0.,  1.]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_ = A.copy()\n",
    "AI = np.c_[A,np.eye(3,3)]\n",
    "AI"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration i=0\n",
      "[[ 1.   0.3  0.2  0.1  0.   0. ]\n",
      " [ 0.   4.8  2.2 -0.4  1.   0. ]\n",
      " [ 0.   9.7 19.8 -0.1  0.   1. ]]\n",
      "Iteration i=1\n",
      "[[ 1.          0.          0.0625      0.125      -0.0625      0.        ]\n",
      " [ 0.          1.          0.45833333 -0.08333333  0.20833333  0.        ]\n",
      " [ 0.          0.         15.35416667  0.70833333 -2.02083333  1.        ]]\n",
      "Iteration i=2\n",
      "[[ 1.          0.          0.          0.12211669 -0.05427408 -0.00407056]\n",
      " [ 0.          1.          0.         -0.10447761  0.26865672 -0.02985075]\n",
      " [ 0.          0.          1.          0.04613297 -0.13161465  0.0651289 ]]\n"
     ]
    }
   ],
   "source": [
    "gauss_jordan(AI)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Metodos iterativos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los métodos iterativos son aquellos que aproximan la solucion en cada paso del algoritmo. Por lo tanto una solucion iterativa es necesaria, ademas una condicion de salida. Estos métodos son preferidos para matrices muy grandes, donde los metodos directos acumula mucho error de truncamiento debido a los calculos que involucran operacion de coma flotante. Los metodos iterativos se enfocan en descomponer el sistema original en un sistema facil de invertir, en el caso mas simple el método de jacobi descompone la matriz de coeficientes en una componente diagonal y el resto."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Método de Jacobi\n",
    "El Metodo de jacobi en esencia descompone la matriz de coefficientes $\\mathbf A$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = D + P"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Método Gauss-Seidel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}