Lecc01-Secc1.1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lección 01 - Sección 1.1\n",
    "========================\n",
    "\n",
    "**Author:** Marcos Bujosa\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\n",
    "\\newcommand{\\R}[1][{}]{{\\mathbb{R}}^{#1}}\n",
    "\\newcommand{\\Z}[1][{}]{{\\mathbb{Z}}^{#1}}\n",
    "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n",
    "\\newcommand{\\getItem}{\\pmb{\\mid}}\n",
    "\\newcommand{\\getitemR}[1]{\\getItem{#1}}\n",
    "\\newcommand{\\getitemL}[1]{{#1}\\getItem}\n",
    "\\newcommand{\\elemR}[2]{{#1}^{\\phantom{\\T}}_{\\getitemR{#2}}} \n",
    "\\newcommand{\\elemRP}[2]{{\\big(#1\\big)}^{\\phantom{\\T}}_{\\getitemR{#2}}} \n",
    "\\newcommand{\\elemRPE}[2]{\\big({#1}^{\\phantom{\\T}}_{\\getitemR{#2}}\\big)}\n",
    "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n",
    "\\newcommand{\\Vect}[2][{}]{{\\boldsymbol{#2}}_{#1}}\n",
    "\\newcommand{\\eleVR}[2]  {\\elemR  {\\Vect{#1}}{#2}}\t % con subindices\n",
    "\\newcommand{\\eleVRP}[2] {\\elemRP {\\Vect{#1}}{#2}}      % con subindices y paréntesis interior\n",
    "\\newcommand{\\eleVRPE}[2]{\\elemRPE{\\Vect{#1}}{#2}}      % con subindices y paréntesis exterior\n",
    "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n",
    "\\newcommand{\\VectC}[2][{}]  {\\elemR  {\\Mat{#2}}{#1}}   % con subindices\n",
    "\\newcommand{\\VectCP}[2][{}] {\\elemRP {\\Mat{#2}}{#1}}   % con subindices y paréntesis\n",
    "\\newcommand{\\VectCPE}[2][{}]{\\elemRPE{\\Mat{#2}}{#1}}   % con subindices y paréntesis exterior\n",
    "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n",
    "\\newcommand{\\mat}[1]{\\mathbf{#1}}\n",
    "\\newcommand{\\Mat} [2][{}]{{\\mat{#2}}_{#1}} \n",
    "\\newcommand{\\T}{\\intercal}\n",
    "\\newcommand{\\MatT}[2][{}]{{\\mat{#2}}^{\\T}_{#1}}\n",
    "\\newcommand{\\VectCC}[2][{}]   {\\elemRR {\\Mat{#2}}{#1}}   % con ()\n",
    "\\newcommand{\\VectCCC}[2][{}]  {\\elemRRR{\\Mat{#2}}{#1}}   % con texto \"col\"\n",
    "%SELECCIÓNA de FILAS y COlUMNAS DE UNA MATRIZ TRANSPUESTA PARA GENERAR UN VECTOR DE Rn\n",
    "\\newcommand{\\VectTC}[2][{}]   {\\elemR{\\MatT{#2}\\!}{#1}}  % con subindices\n",
    "\\newcommand{\\VectTCC}[2][{}]  {\\elemRR{ \\MatT{#2}}{#1}}  % con ()\n",
    "\\newcommand{\\VectTCCC}[2][{}] {\\elemRRR{\\MatT{#2}}{#1}}  % con texto \"col\"\n",
    "\\newcommand{\\dotprod}[2][{}] {\\Vect{#1}\\cdot\\Vect{#2}}\n",
    "$\n",
    "\n",
    "[NAcAL](https://github.com/mbujosab/nacallib) es un módulo de Python que implementa literalmente lo expuesto\n",
    "en el [libro](https://mbujosab.github.io/CursoDeAlgebraLineal/libro.pdf). Así, usted puede experimentar con Python empleando una\n",
    "notación similar a la empleada en clase. El [libro](https://mbujosab.github.io/CursoDeAlgebraLineal/libro.pdf) y el módulo [NAcAL](https://github.com/mbujosab/nacallib)\n",
    "son dependientes el uno del otro y se complementan mutuamente (la\n",
    "escritura de libro ha condicionado la escritura del módulo y\n",
    "viceversa).\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Primer paso para usar [NAcAL](https://github.com/mbujosab/nacallib)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para poder usar [NAcAL](https://github.com/mbujosab/nacallib) es necesario importar el módulo:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from nacal import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Los vectores son listas de números\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Antes de empezar, vea el vídeo:* [Definición de vector de $\\R[n]$ y\n",
    " notación](https://ucmdrive.ucm.es/s/7RQbRDWf8N33K8f) *y lea la introducción a la Lección 1 así como la Sección\n",
    " 1.1 del [libro](https://mbujosab.github.io/CursoDeAlgebraLineal/libro.pdf#chapter.1).*\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Definiendo vectores\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el [libro](https://mbujosab.github.io/CursoDeAlgebraLineal/libro.pdf#section.1.1) se indica que encerrando entre paréntesis una lista de $n$\n",
    "números expresamos un vector de $\\R[n]$; por ejemplo encerrando la\n",
    "lista 20, 10, 15 entre paréntesis expresamos un vector de $\\R[3]$\n",
    "\n",
    "$$\\begin{pmatrix}20,&10,&15,\\end{pmatrix}$$\n",
    "\n",
    "Para definir un vector en [NAcAL](https://github.com/mbujosab/nacallib) es necesario indicar la\n",
    "correspondiente [lista](https://docs.python.org/es/3/tutorial/introduction.html#lists)  de números como argumento de la clase\n",
    "`Vector()`. Por ejemplo, con la lista `[20, 10, 15]` obtenemos\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAACUAAAA9CAIAAACleTeiAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAEPElEQVRYw71Z732yMBDOy68DgCOEDZARQieIjoCdgDJC7ATUESgTKCNQJkBGiGzQ98P5i2dCUqSlz6cS5C73N5en5MuOpmm+HoeUUkppe+sRC97f38uyJLPAGLO+s1lGKcUrx+MxiiKQ1XWd9opSKoRQK0KINE1HJY/ro5Qej0f1WBSFEKJpGiEEISSKIiy6LMssywghZVmq9SiK8KNLnxCCMaaFRP0NvlKWZVkGf3POfd/HHsKPVn1SSkKII1OyLFOCoihSW2mahhCCvcIYU7ux6kvTVDNOA+ccYiOlxI6FKOAowg60XCUPGQdCQURZltrO0jTV0oQxpq3c1YMQglK6Xq9tybzf77MsC4IANg77U6CU+r6PV9I0PRwOl8tFrdzpOxwOaZralH1+ftZ1vdvt1Erf99pvVqsVftxsNiB2pP6guh2tgTGG3x6PR+33aZpqpQnxxmEm+IVW45oyM66EEJyBnHPzQzBD7eNJGVpVFZStCXBL0zSQcuC3zWbDOX97e4vjmFJ6OBzyPLf1tqqqXl9fCa5crXpwwZlScElAxxn9VqW0cinBQr+WAeTgXT20baul8i8CfHA6nW71UNc1pXQhfSC5bdurvvP5TAiJ43hRfZBrntK8nH1hGN7ZB21iOX0gHLTc9EFUF3Xp5XK56QOrF03Rvu+90bY7itPplCQJJJe2Hobhfr93fAt9/KpPSukuPpD4/Pxc17V5Qg3DwDnP8/zj48MmAeRLKQm0XUen1hqbdkTY5hcNRVHA+erhw9ANs0DzPFc9Os/zYRigidj8KaX0sL0PATYKZz0hZL1eU0qhyGz+HIbB02aC6ajrWjvNGWPfpp43OgdMwZT55Tf9OWV+sdo3JWtMa4ZhwB/2fc85d8Tv2l9w2KcjSRJIcbwhd5MKguA6vwzDMMOfU+YXLH+1Wj3NaIN4Xu37frvdRlEkhHAMynpU3HeGnwPmsSzLPDWckz+B95P4TYeKnwfJurR9IJ9S6oHav7HP931v6ckFd6KrfaDPPLh/3Z9hGN70TZwq5kHN7x4eZh6dX3a73T8ERzPr+x6seppi3+l0enl5Gf0BXMHx0Gfibn6H+vd9/9sWY84vNhJptLkURXG7H8VxrO6S0+eX6cFTF09PjQLaYTYRu90uSZIgCEZHUwBwTdfoYm5mlPFyEApFUcDFXEpJKbUNlThYBK+64+EmMGDCNG/VXddhS278y3a7nU14quiafbGqKsyIeviwHobB0WXcPV11ZHNsZIypecXD84jv+3dckBPn8xlvrm1bkwu7XC51Xd9xVhrz+e0dQMWPc66yoOs63/dNQsgUOMIP2piUoigw4SmlBJVAC5pMlslQzuE/H51ZXPwn7HrUMzPAGNOMm8pfzzNuEn89ys/PgE3CuL6u66bceG0QQoxyk1Z9kI0muz7x/zkajz5JH8Rghr6u6xwk8X+QILbYHYwiBAAAAABJRU5ErkJggg==\n",
      "text/html": [
       "<p style=\"text-align:center;\">$\\begin{pmatrix}20\\\\ 10\\\\ 15\\end{pmatrix}$</p>"
      ],
      "text/latex": [
       "$\\begin{pmatrix}20\\\\ 10\\\\ 15\\end{pmatrix}$"
      ],
      "text/plain": [
       "Vector([20, 10, 15])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Vector( [20, 10, 15] )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Obtendremos idéntico resultado si en lugar de usar una [lista](https://ellibrodepython.com/listas-en-python), usamos\n",
    "la siguiente [tupla](https://ellibrodepython.com/tuplas-python) `(20, 10, 15)`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAACUAAAA9CAIAAACleTeiAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAEPElEQVRYw71Z732yMBDOy68DgCOEDZARQieIjoCdgDJC7ATUESgTKCNQJkBGiGzQ98P5i2dCUqSlz6cS5C73N5en5MuOpmm+HoeUUkppe+sRC97f38uyJLPAGLO+s1lGKcUrx+MxiiKQ1XWd9opSKoRQK0KINE1HJY/ro5Qej0f1WBSFEKJpGiEEISSKIiy6LMssywghZVmq9SiK8KNLnxCCMaaFRP0NvlKWZVkGf3POfd/HHsKPVn1SSkKII1OyLFOCoihSW2mahhCCvcIYU7ux6kvTVDNOA+ccYiOlxI6FKOAowg60XCUPGQdCQURZltrO0jTV0oQxpq3c1YMQglK6Xq9tybzf77MsC4IANg77U6CU+r6PV9I0PRwOl8tFrdzpOxwOaZralH1+ftZ1vdvt1Erf99pvVqsVftxsNiB2pP6guh2tgTGG3x6PR+33aZpqpQnxxmEm+IVW45oyM66EEJyBnHPzQzBD7eNJGVpVFZStCXBL0zSQcuC3zWbDOX97e4vjmFJ6OBzyPLf1tqqqXl9fCa5crXpwwZlScElAxxn9VqW0cinBQr+WAeTgXT20baul8i8CfHA6nW71UNc1pXQhfSC5bdurvvP5TAiJ43hRfZBrntK8nH1hGN7ZB21iOX0gHLTc9EFUF3Xp5XK56QOrF03Rvu+90bY7itPplCQJJJe2Hobhfr93fAt9/KpPSukuPpD4/Pxc17V5Qg3DwDnP8/zj48MmAeRLKQm0XUen1hqbdkTY5hcNRVHA+erhw9ANs0DzPFc9Os/zYRigidj8KaX0sL0PATYKZz0hZL1eU0qhyGz+HIbB02aC6ajrWjvNGWPfpp43OgdMwZT55Tf9OWV+sdo3JWtMa4ZhwB/2fc85d8Tv2l9w2KcjSRJIcbwhd5MKguA6vwzDMMOfU+YXLH+1Wj3NaIN4Xu37frvdRlEkhHAMynpU3HeGnwPmsSzLPDWckz+B95P4TYeKnwfJurR9IJ9S6oHav7HP931v6ckFd6KrfaDPPLh/3Z9hGN70TZwq5kHN7x4eZh6dX3a73T8ERzPr+x6seppi3+l0enl5Gf0BXMHx0Gfibn6H+vd9/9sWY84vNhJptLkURXG7H8VxrO6S0+eX6cFTF09PjQLaYTYRu90uSZIgCEZHUwBwTdfoYm5mlPFyEApFUcDFXEpJKbUNlThYBK+64+EmMGDCNG/VXddhS278y3a7nU14quiafbGqKsyIeviwHobB0WXcPV11ZHNsZIypecXD84jv+3dckBPn8xlvrm1bkwu7XC51Xd9xVhrz+e0dQMWPc66yoOs63/dNQsgUOMIP2piUoigw4SmlBJVAC5pMlslQzuE/H51ZXPwn7HrUMzPAGNOMm8pfzzNuEn89ys/PgE3CuL6u66bceG0QQoxyk1Z9kI0muz7x/zkajz5JH8Rghr6u6xwk8X+QILbYHYwiBAAAAABJRU5ErkJggg==\n",
      "text/html": [
       "<p style=\"text-align:center;\">$\\begin{pmatrix}20\\\\ 10\\\\ 15\\end{pmatrix}$</p>"
      ],
      "text/latex": [
       "$\\begin{pmatrix}20\\\\ 10\\\\ 15\\end{pmatrix}$"
      ],
      "text/plain": [
       "Vector([20, 10, 15])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = (20, 10, 15)\n",
    "Vector( a )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La lista de números correspondiente a cada `Vector` está almacenada en\n",
    "el atributo `.lista`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "v = Vector( [0,1,2,3,4,5] )\n",
    "print(v.lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Realmente no es necesario usar la función `print()`, basta con escribir\n",
    "`v.lista` para ver la lista asociada al vector `v`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v.lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Haciendo copias de un vector\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si al invocar `Vector` usamos como argumento otro vector obtenemos una copia de éste\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAACUAAAA9CAIAAACleTeiAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAEPElEQVRYw71Z732yMBDOy68DgCOEDZARQieIjoCdgDJC7ATUESgTKCNQJkBGiGzQ98P5i2dCUqSlz6cS5C73N5en5MuOpmm+HoeUUkppe+sRC97f38uyJLPAGLO+s1lGKcUrx+MxiiKQ1XWd9opSKoRQK0KINE1HJY/ro5Qej0f1WBSFEKJpGiEEISSKIiy6LMssywghZVmq9SiK8KNLnxCCMaaFRP0NvlKWZVkGf3POfd/HHsKPVn1SSkKII1OyLFOCoihSW2mahhCCvcIYU7ux6kvTVDNOA+ccYiOlxI6FKOAowg60XCUPGQdCQURZltrO0jTV0oQxpq3c1YMQglK6Xq9tybzf77MsC4IANg77U6CU+r6PV9I0PRwOl8tFrdzpOxwOaZralH1+ftZ1vdvt1Erf99pvVqsVftxsNiB2pP6guh2tgTGG3x6PR+33aZpqpQnxxmEm+IVW45oyM66EEJyBnHPzQzBD7eNJGVpVFZStCXBL0zSQcuC3zWbDOX97e4vjmFJ6OBzyPLf1tqqqXl9fCa5crXpwwZlScElAxxn9VqW0cinBQr+WAeTgXT20baul8i8CfHA6nW71UNc1pXQhfSC5bdurvvP5TAiJ43hRfZBrntK8nH1hGN7ZB21iOX0gHLTc9EFUF3Xp5XK56QOrF03Rvu+90bY7itPplCQJJJe2Hobhfr93fAt9/KpPSukuPpD4/Pxc17V5Qg3DwDnP8/zj48MmAeRLKQm0XUen1hqbdkTY5hcNRVHA+erhw9ANs0DzPFc9Os/zYRigidj8KaX0sL0PATYKZz0hZL1eU0qhyGz+HIbB02aC6ajrWjvNGWPfpp43OgdMwZT55Tf9OWV+sdo3JWtMa4ZhwB/2fc85d8Tv2l9w2KcjSRJIcbwhd5MKguA6vwzDMMOfU+YXLH+1Wj3NaIN4Xu37frvdRlEkhHAMynpU3HeGnwPmsSzLPDWckz+B95P4TYeKnwfJurR9IJ9S6oHav7HP931v6ckFd6KrfaDPPLh/3Z9hGN70TZwq5kHN7x4eZh6dX3a73T8ERzPr+x6seppi3+l0enl5Gf0BXMHx0Gfibn6H+vd9/9sWY84vNhJptLkURXG7H8VxrO6S0+eX6cFTF09PjQLaYTYRu90uSZIgCEZHUwBwTdfoYm5mlPFyEApFUcDFXEpJKbUNlThYBK+64+EmMGDCNG/VXddhS278y3a7nU14quiafbGqKsyIeviwHobB0WXcPV11ZHNsZIypecXD84jv+3dckBPn8xlvrm1bkwu7XC51Xd9xVhrz+e0dQMWPc66yoOs63/dNQsgUOMIP2piUoigw4SmlBJVAC5pMlslQzuE/H51ZXPwn7HrUMzPAGNOMm8pfzzNuEn89ys/PgE3CuL6u66bceG0QQoxyk1Z9kI0muz7x/zkajz5JH8Rghr6u6xwk8X+QILbYHYwiBAAAAABJRU5ErkJggg==\n",
      "text/html": [
       "<p style=\"text-align:center;\">$\\begin{pmatrix}20\\\\ 10\\\\ 15\\end{pmatrix}$</p>"
      ],
      "text/latex": [
       "$\\begin{pmatrix}20\\\\ 10\\\\ 15\\end{pmatrix}$"
      ],
      "text/plain": [
       "Vector([20, 10, 15])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = Vector( a )\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La función `type()` de Python devuelve el tipo de cada objeto\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "nacal.nacal.Vector"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Representación de Vectores: el atributo `.rpr` de la clase `Vector`\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cuando el entorno de trabajo es un Notebook de Jupyter, [NAcAL](https://github.com/mbujosab/nacallib) muestra\n",
    "los vectores en forma de columna por defecto. Pero podemos indicar a\n",
    "Python que queremos una representación horizontal del `Vector`, basta\n",
    "asignar el valor `'fila'` al atributo `rpr`. *Tenga en cuenta que esto\n",
    "solo afecta a la representación* (el vector no cambia ya que la lista\n",
    "de números asociada sigue siendo la misma).\n",
    "\n",
    "Hagamos una copia de `a` con representación `fila`:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fila\n"
     ]
    }
   ],
   "source": [
    "x = Vector( a, rpr='fila' )\n",
    "print(x.rpr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pintemos el vector:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAGcAAAAUCAIAAAAflbTBAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAC6klEQVRYw+1Y7XWjOhCd9UkBQAlyB5gSRCrALkHpQKEEJRVwXALpQFEJQAVIJQg6YH9MVtbKhn3PdsjZPbm/QB9cdGeYD35M0wS/oLXebrfwjd8xDEMcx/7Ixl29vb11Xfet0TniOH5+fh6G4TQ0TdM0TX3fM8YmD1LKNE0BgFLa930wRQgRQkx3gpTynGUdIsaYLxAh5OJGa21RFO72Q7U0Ta21brSqKiFE0zRCCABI09RNCSHquuacA0Bd17cfgxCCbxyotg4RYwyJEE3TzD0Bl51Uk1IGjuYrSCl1Liml5JzjdVEUURTdxQVQGp90NaLg4Mtwngioi5Rygcm9tO+STdMAwMLG/466roPDrEb0v1SjlKIzbgBAKZXn+VwsNMYcDgdMJRgacXy32xFCPiOBrEaEeHp6yvM8juM8z7XWCysppcfjEQAe2rZ1H/xFdF2H1lZKJUkSPMUYc/djrEaEIZtSut1uh2HIsuzx8XFBuDRN0Vs3xpgoiubWvby8cM7R7NZaa22QcRb2Xo3ViNDRsESN45hzbox5f3+fW5wkCRrvwVobGNahbVullP+Uc4PP7b0RqxH5yLIMAMZxnFsQRRHObsZxnDNjWZbokM7g4zj6xZ4xpiiKuzhX4FnrEF2cXYhXznIbp1+APM+FEH4ngRkDKzhHg+7dtm3btvey+WpEWms/inVdRwjZ7XZzRE70hyRJzi2w3+8BoGkazAMo836/L4ri9fU1yzJCyPF4LMsSZxljXddZa4N+7WqsQ1SW5TiOGIK01kIIpdQC0em77Ps+qCGxFAyAdY21FtusNE39AgrFrarqujKqqqqgOVmHCPskSiljjDHm9wwXieq6ppR+VLlRFPlvfB2wNZk+H19IxDnHkQ0AHA4H55lXI4oi7L0+G19IpJTCpLTBrw9L3huBcXQFfAmR1jpJko//j84bF9r9P+KWvX8LkS8RuFH//9E3zn80+THupFrf91fnpn8b1togLfwE62bUKzhqxXMAAAAASUVORK5CYII=\n",
      "text/html": [
       "<p style=\"text-align:center;\">$\\begin{pmatrix}20,& 10,& 15,\\end{pmatrix}$</p>"
      ],
      "text/latex": [
       "$\\begin{pmatrix}20,& 10,& 15,\\end{pmatrix}$"
      ],
      "text/plain": [
       "Vector([20, 10, 15])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para cambiar la representación de un vector previamente definido,\n",
    "basta cambiar el valor de su atributo `rpr`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "col\n"
     ]
    }
   ],
   "source": [
    "x.rpr = 'col' # cualquier valor distinto de la cadena 'fila' representará en columna\n",
    "print(x.rpr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como el atributo `rpr` ya no es `'fila'` ahora el vector `x` es\n",
    "representado en vertical:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAACUAAAA9CAIAAACleTeiAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAEPElEQVRYw71Z732yMBDOy68DgCOEDZARQieIjoCdgDJC7ATUESgTKCNQJkBGiGzQ98P5i2dCUqSlz6cS5C73N5en5MuOpmm+HoeUUkppe+sRC97f38uyJLPAGLO+s1lGKcUrx+MxiiKQ1XWd9opSKoRQK0KINE1HJY/ro5Qej0f1WBSFEKJpGiEEISSKIiy6LMssywghZVmq9SiK8KNLnxCCMaaFRP0NvlKWZVkGf3POfd/HHsKPVn1SSkKII1OyLFOCoihSW2mahhCCvcIYU7ux6kvTVDNOA+ccYiOlxI6FKOAowg60XCUPGQdCQURZltrO0jTV0oQxpq3c1YMQglK6Xq9tybzf77MsC4IANg77U6CU+r6PV9I0PRwOl8tFrdzpOxwOaZralH1+ftZ1vdvt1Erf99pvVqsVftxsNiB2pP6guh2tgTGG3x6PR+33aZpqpQnxxmEm+IVW45oyM66EEJyBnHPzQzBD7eNJGVpVFZStCXBL0zSQcuC3zWbDOX97e4vjmFJ6OBzyPLf1tqqqXl9fCa5crXpwwZlScElAxxn9VqW0cinBQr+WAeTgXT20baul8i8CfHA6nW71UNc1pXQhfSC5bdurvvP5TAiJ43hRfZBrntK8nH1hGN7ZB21iOX0gHLTc9EFUF3Xp5XK56QOrF03Rvu+90bY7itPplCQJJJe2Hobhfr93fAt9/KpPSukuPpD4/Pxc17V5Qg3DwDnP8/zj48MmAeRLKQm0XUen1hqbdkTY5hcNRVHA+erhw9ANs0DzPFc9Os/zYRigidj8KaX0sL0PATYKZz0hZL1eU0qhyGz+HIbB02aC6ajrWjvNGWPfpp43OgdMwZT55Tf9OWV+sdo3JWtMa4ZhwB/2fc85d8Tv2l9w2KcjSRJIcbwhd5MKguA6vwzDMMOfU+YXLH+1Wj3NaIN4Xu37frvdRlEkhHAMynpU3HeGnwPmsSzLPDWckz+B95P4TYeKnwfJurR9IJ9S6oHav7HP931v6ckFd6KrfaDPPLh/3Z9hGN70TZwq5kHN7x4eZh6dX3a73T8ERzPr+x6seppi3+l0enl5Gf0BXMHx0Gfibn6H+vd9/9sWY84vNhJptLkURXG7H8VxrO6S0+eX6cFTF09PjQLaYTYRu90uSZIgCEZHUwBwTdfoYm5mlPFyEApFUcDFXEpJKbUNlThYBK+64+EmMGDCNG/VXddhS278y3a7nU14quiafbGqKsyIeviwHobB0WXcPV11ZHNsZIypecXD84jv+3dckBPn8xlvrm1bkwu7XC51Xd9xVhrz+e0dQMWPc66yoOs63/dNQsgUOMIP2piUoigw4SmlBJVAC5pMlslQzuE/H51ZXPwn7HrUMzPAGNOMm8pfzzNuEn89ys/PgE3CuL6u66bceG0QQoxyk1Z9kI0muz7x/zkajz5JH8Rghr6u6xwk8X+QILbYHYwiBAAAAABJRU5ErkJggg==\n",
      "text/html": [
       "<p style=\"text-align:center;\">$\\begin{pmatrix}20\\\\ 10\\\\ 15\\end{pmatrix}$</p>"
      ],
      "text/latex": [
       "$\\begin{pmatrix}20\\\\ 10\\\\ 15\\end{pmatrix}$"
      ],
      "text/plain": [
       "Vector([20, 10, 15])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Representación de `Vector()` en una consola\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La representación en consola se limita a indicar en modo <u>texto</u> que\n",
    "el objeto es un vector, y muestra la lista de números correspondiente\n",
    "a cada vector. Podemos ver dicha representación con la función\n",
    "`print()`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vector([20, 10, 15])\n"
     ]
    }
   ],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Atributos `.lista` y `.n`\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ya hemos visto que [NAcAL](https://github.com/mbujosab/nacallib) almacena la lista ordenada de números de cada\n",
    "`Vector` en el correspondiente atributo `.lista` de dicho `Vector`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[20, 10, 15]\n"
     ]
    }
   ],
   "source": [
    "print(x.lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Además, el atributo `.n` indica el número de elementos de la lista del\n",
    "`Vector`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v = Vector( (2, 4, 6) )\n",
    "v.n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Método `.sis()`\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el [libro](https://mbujosab.github.io/CursoDeAlgebraLineal/libro.pdf#section.1.1) se define un vector como un sistema (i.e., una lista\n",
    "ordenada) de números y se describe la correspondiente notación para\n",
    "los sistemas en general.\n",
    "\n",
    "Podemos recuperar la representación de un `Vector` como `Sistema`\n",
    "genérico con el método `.sis()`. El método `.sis()` devuelve el vector\n",
    "en forma de `Sistema` genérico y por tanto usa la correspondiente\n",
    "representación (es decir, entre corchetes y con los elementos seguidos\n",
    "por puntos y comas tal y como se indica en el [libro](https://mbujosab.github.io/CursoDeAlgebraLineal/libro.pdf#chapter.1)).\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAGAAAAAUCAIAAAD9Sa+4AAAACXBIWXMAAA7EAAAOxAGVKw4bAAACaklEQVRYw+2Y0Y2rMBBFzWoLgJRgOgBKMKnAUIKhAsslQCqAlJB0AC4BqAAowbiDfR+WkAUEbULktx+5XyNGcJJhPL7YKoqCcw4AiOM4iiLwEQBlWc41sTDG9/v9U5S1pmnKsuxrnajr2vd9y7LCMByGYZFyXTfP87f8grqu1wgDlCRJLE2u6+7c/r3uLinl9XrlnDPG4jhu21al8jyHEGKMGWMQwiPrsa7rNE3HcVynzFCyLIMQqngOtoUx/tEkhJhjhBAAQMVVVVFKVYwxtm3757AopQAAnWiGQgj5zY1CCErpcok5jjPHnufZtq1ixhhjbI6llHVdH2z+IAgWV8xQntLXTm4cxziO1bjSa+f7PoSw6zoAgOu6ZVm+aygaoMxjKAxDx3H08bRJ+d55Std1TdMAADjnp9NJTyGE1NqeW+y4zFDUykAIua47TVMQBOfzWdVok/KwQHmeU0rV+xRCCCH0LIRQXZlH+HGZoaj2mecJpTRNU7XTbVK2C9S2LedcX//rvWDxtt8iM5T1hJJSPjeDGGO3201/k1JKNSPmf4IxPt4yi34xQNnM7uz0GwUKwzDLMn07C8NQeQf9ufv+6gWZoQzDoJvGrusghL7v/9YoKmPWNI0az6rJoyjCGF8ulyAIIITX63XejJMkIYTsAJ6SAYruHoZhyLJMfXY9pOhGUXmqhZStEkJ4nqe2gKqqdDOJEHrNwhVF4XmebuEMUIQQGGOEECGEENL3/SOKMopLJ/2s+r5/i9/9g5RtJ/2CCCEGvq3/F+VogTjn7/rs/puUz3nQ8+dBHy07SEWfI9fFkauU0vO8fy2MOI9H8TSIAAAAAElFTkSuQmCC\n",
      "text/html": [
       "<p style=\"text-align:center;\">$\\begin{bmatrix}20;& 10;& 15;\\end{bmatrix}$</p>"
      ],
      "text/latex": [
       "$\\begin{bmatrix}20;& 10;& 15;\\end{bmatrix}$"
      ],
      "text/plain": [
       "Sistema([20; 10; 15;])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.sis()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La representación en modo consola indica explícitamente que `x.sis()`\n",
    "es un sistema\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sistema([20; 10; 15;])\n"
     ]
    }
   ],
   "source": [
    "print(x.sis())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La función `type()` también nos lo dice\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "nacal.nacal.Sistema"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x.sis())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Componentes no enteras: fracciones y números irracionales\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por una parte, con `fracc(a,b)` generamos la fracción\n",
    "$\\frac{a}{b}$. Por otra, el módulo [Sympy](https://www.sympy.org/es/index.html) (que [NAcAL](https://github.com/mbujosab/nacallib) carga por defecto)\n",
    "tiene implementados muchos números irracionales. Generemos un vector\n",
    "con distintos tipos de números:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAJgAAAAVCAIAAAA1jrBwAAAACXBIWXMAAA7EAAAOxAGVKw4bAAADjElEQVRo3uVa67WiMBDOeiwAKQFuBdESYgdICZQQKCHXCpASYgeBEoAKgBIgHbA/xsUsD/VcL4HdO3/0BHSGeXwz8+mvtm3RHynL0rZt9LOlaRrTNKeuqu5a1sjdbqeebLp31+s1z/OVePNyuRyPx/1+r1+167rttKzEP7vdzvf9pmn+SrG2bYui8DyvM7eu63YF4jgO51ynRiEEY6z9F6Sua8dx7hkGLxhjNXjDFDAMQ390HccpikKnRkKIGlSMMUKIEKLZjBeFMdYl+hYhFMfx4XBQMZdzrkaRc04I6YHyrBLHcRRFQRDo7NlxHBNCOmyXUkZRlCRJEASu62ZZtrZ27vu+bdun0+kGrYQQIcSLeapNiqIghFBKFylHFX4guusEWEJImqY3aH1sJaUUbl0klpZlLd4dKaWGYawzkIwxGG42WZZZljVVvGVZSik1T48diOV53mHd3HI+n33fH71UVZXrujpXC1XKsvR9fwrYMcZpmiKEtlVVGYYx9aVBEDDGNEN/kiSMMUKIlPJyuXz79w/X5SzLYK4ZlTzPwVlzi23bVVUNx0zXdadqyTTN20fCMJxqgWmaqgPufyDQdzHGw/F4aiZnjIVhqME2zjko4pzDyFLX9VNIL4oCOuNWSjlVkUEQhGH4PlB4nvfghsPhMIVpc0gYhh8fH1mWdTkOzWV0Js+yLEmSOI41eMAwDJg/OefX6xUhVNf1A46pq8j7g41WpBBC/7D6il++ZdJTH+1BORJCNG/P6povhHg663UVuTFNs67r0XJ0HGeYobOuUy8G+00zGGNJkpRl+bgcj8cjY6x3aW4PwHAA76WUamhGVd8BtSiKIRBDbx8mI0wEsyYpkIVqWxqevG8Gxhim9qlydByHEBIqAhzKrB7oNUUhBCAtrH+jqoGrue2RQ/rN87zRMQcCPGvz55xjjFUVw5P3zQAfCSFGCQdK6bBWIPCzeiAMw57bMcYYY5h9RlVTSmH9RRC217lpz/PmppUppUNzeyfvm2FZ1tcIZA0eeF01xhh44A3kWhRFL4K4YRjalvRZzQBO5AsE8oIe6Kkuy9I0TdiJNwih/X5vWdbrPXxuokdK+fTkfTNOp9Pn5+fXPrvID6VD1efz+U7XqO39aWnrIV17o83wZCnud1Wqe+TwRoWap3zYgpm4woJYUHXTNHmeq0TKViX61vOHnSGj8ZTj+FECf/VQT34D16mta4B47XAAAAAASUVORK5CYII=\n",
      "text/html": [
       "<p style=\"text-align:center;\">$\\begin{pmatrix}7,& - \\frac{3}{11},& \\sqrt{2},& - \\pi,\\end{pmatrix}$</p>"
      ],
      "text/latex": [
       "$\\begin{pmatrix}7,& - \\frac{3}{11},& \\sqrt{2},& - \\pi,\\end{pmatrix}$"
      ],
      "text/plain": [
       "Vector([7, -3/11, sqrt(2), -pi])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v = Vector( [7, fracc(-3, 11), sympy.sqrt(2), -sympy.pi], 'fila' )\n",
    "v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Seleccionando componentes de un `Vector`\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos seleccionar componentes con el operador **barra vertical** \n",
    "(en un teclado español es la combinación de teclas `[Alt Gr] + [1]`).\n",
    "\n",
    "Por ejemplo, seleccionemos la tercera componente del vector\n",
    "$\\Vect{a}$, es decir $\\eleVR{a}{3}$\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n"
     ]
    }
   ],
   "source": [
    "a = Vector( [10, 20, 30, 40, 50] )\n",
    "print(a|3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y ahora su quinta componente\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a|5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La barra vertical funciona por ambos lados del `Vector()` como\n",
    "selector de sus componentes\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3|a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cada elemento de un vector es un número. Con la función `type()`\n",
    "podemos ver qué el tipo de número es cada uno de los elementos. Por\n",
    "ejemplo, podemos ver el tipo de cada elemento de $\\Vect{v}$ (todos\n",
    "ellos distintos tipos de números).\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAANAAAAAVCAIAAAC44/ckAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAEoElEQVRo3u1b7XmqMBROfToAMkLsBNER4gbREdINwBFSJ4gdIW5gGQGYIDBCZAPvj3Mv5vIlhRLt054/bQMmh5eT97znxD5dLhf0z7IsWywW6Gfb+Xz2fb/tqg3Xr/UBcz6f2yOz8rfj8Zim6YM4ejgc1uv1crl0v/R2u720228Mfcrm83kYhufz+b8te7lctNac8xJWY8zlAYwxppRyueLpdBJCXH7t68wYwxi77lj4QQixg6weqp7nuY9CxpjW2uWKlFI7+AghCCFKqWM3pthIGOObe+l0OtUftg0HpRTGGCFkx1OjCSFK4kAwo01vMJdtjDEppWOAGGNxHN+L3qSUQog4joUQCCFCyPeNNnjfQRAghNoyBkQkkIsdVW04SCmVUlprGL8Zyhjja8BRSk+nU89978y01pTSIAjuQm82nVNKS+3xHbmtxJAx5nlex80QlPaz98GBEHLzNVFKgT7+ll3dTjhmGjvmyp1xR/UWBEH3e3pks8VSHMcIoQ5yUUpVAq4PDp7ndRMWsCxk0VmSJCWX1i3LsqIoHFeLSZLAL2mawq5yYPv9PgzDxkt5nm+3W5etBNuyLAvDsMTks1NBqQh/LpdLjPHgXkQjDq+vr7vdbr1ed3+WEALhPsvz3PO8tvt2ux3QrEuLomiz2RwOhzzPD4fDl8+fZVk9xEEXN1qapqBUprbFYvH09OT/b6vVavCej6Ko0lOklOZ5Psy9Cg5hGM7nc4wxY+zmZ33f/7uulLJNosVxfLMA+V4GurBeATDG2vKIEMJNwaSUgoWUUpChjDEjU7mUsvKwQogOvdWRUhtx0FoDH1WKzkbkQbk9F0XRxnC73U5KOT5BcM47blitVm25bAqTUr68vCRJUnIGiIpKQ7y8FEXRx8eHAwQ8z9tsNlBIHo9HePEdZx7982CdbAaInEYcFovF29sbCBLOeQcNXxdtYzhoyThmoD4P/yXVqP1oHfRGKXXcfbTbpNCqGFkJVRiLc97RUwR+qT9yNw43axGb4Wa+7xtjGumtnpuTJBmmXntaz6Ac6YYQIooiUHId9LZer4UQlUtTIyCEKOukoijsVzNgadDytvAyxpTH5T1na8TBPq0CEl2tVh1OXhOp1rouFCBm60ENynrSTQ+HbLZcqI+Md4MQArKjjd4YY5RSaRm0TCdFoCLagJ+UUtCWGrY0sAZMwjkvO1yQ5St94DrDNeIghCiloTEGY1zO0+akUgqyCoI+SuUOznljuQCBOKmIVkoRQuwl6iPj3YB3aTdF6/3PikGAToqAlLICOyGEEALZatjSxhgIgnIeG9VKeoUiowyGNhy01owxqE8rB0JtTgZBAG1OBOHV/4yccz718XYQBBWP6yPj3cAYDzsgdoDAAy490skyuGcQs+/v7z1lged5zpqxk7oBve9G9fawCDwI+J91Mssy3/dBO87KBnR/QTr1wUNRFDdHxrux2WygpB9gd/mi3t2XHuzkfr+/Fi62PLzJlm4OVSslQn3kXme7P3bpMU5WDqlndoq5eY70INvrZxLMd+S28/mcpqnd2H+2u8aP8w8N9W74+J77r7k3+Iq5PfIHJ365DKBnkbAAAAAASUVORK5CYII=\n",
      "text/html": [
       "<p style=\"text-align:center;\">$\\begin{pmatrix}7,& - \\frac{3}{11},& \\sqrt{2},& - \\pi,& 0.123,\\end{pmatrix}$</p>"
      ],
      "text/latex": [
       "$\\begin{pmatrix}7,& - \\frac{3}{11},& \\sqrt{2},& - \\pi,& 0.123,\\end{pmatrix}$"
      ],
      "text/plain": [
       "Vector([7, -3/11, sqrt(2), -pi, 0.123])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v = Vector( [7, fracc(-3, 11), sympy.sqrt(2), -sympy.pi, 0.123], 'fila' )\n",
    "v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type( v|1 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sympy.core.numbers.Rational"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type( v|2 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sympy.core.power.Pow"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type( v|3 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sympy.core.mul.Mul"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type( v|4 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type( v|5 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Definiendo un vector a partir de las componentes de otro\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Léase la Sección 1.A del apéndice de la Lección 1 del [libro](https://mbujosab.github.io/CursoDeAlgebraLineal/libro.pdf#section.alph1.1.Alph1).*\n",
    "\n",
    "Cuando seleccionamos varios componentes de un `Vector` con una tupla\n",
    "obtenemos un `Vector`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/html": [
       "<p style=\"text-align:center;\">$\\begin{pmatrix}10\\\\ 20\\\\ 30\\\\ 40\\\\ 50\\end{pmatrix}$</p>"
      ],
      "text/latex": [
       "$\\begin{pmatrix}10\\\\ 20\\\\ 30\\\\ 40\\\\ 50\\end{pmatrix}$"
      ],
      "text/plain": [
       "Vector([10, 20, 30, 40, 50])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Definamos un *sub-vector* de `a`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAACUAAAA9CAIAAACleTeiAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAEcElEQVRYw71Z7326PhBO+XQAcITQCbAjxE6QOkLYgDJC7ATKCOgEwgiUCTAjRDbo78X5ideQYOy3/u6VRLknl/v35CTffum67vt+0VprrX3fRsQju92urmvyK2GMeb/zWUYptRaPxyNjbBiG6TqlVEppVqSUQginZjcepfR4PFoaYX8WnpSyruuiKAghdV2b9SzL8OMcnpSSMTZdB6XYN8fjsSgK+Mw5j+MYnxB+9OJprQkhzkgBd2K8LMvMY9d1hBB8KowxsxsvnhDCadwUT2udZZnlBexF2IEVqz/i83w+V1UlpQwJwrZtF4uFFZZKKfO4XC4ZY2VZ4t/8wJNSUkqXy2UIHuQZXqGUxnGMV4QQVVWdz2c3XlVVQojwPMPWgFgWv7+/g1oH3n6/H8dxBm9qzTiOeO9KKc659RbnHNeNK15d15TSJEkCjVutVuACvKE0Ta2frdfrvu9Pp5NdXwgh0/DFst1urXgDa+q67rpOCOHMIjgVE7fEZK6VPU48nHAmJQghWZbNvEspNZlDcO34foxATPzIv77vrVD+Q4EzaJrmGi9t25qK/OcCmvu+v+BB8Ly+vj4UD8pbZJAfZx8kydU+KBOPwwPlgHLFA68+9EjP5/MVb1oa/jxElVKRs+xOZb/fp2n69PQEJRhL0zRpmm42m5nXoY5f8LTW88m32+2g+kgpD4cDVr3ZbMZx5JyXZbnf730aQL/WmkDlnLIxn2RZZsrsDH9x1l4p5aXLhOPFcWxK5Tx/mXKRoigibO9NyfO8LEvoRND5TP9aLpeUUkgy33mO4xhZXdQnHx8fSZJQSk1HvclfnBI5ecBUNptN13Va65eXlzzPA/mLFZ9a6+fw8zRB//n5CS3mJn/x2odpyLys12vYaSB/wfZc6gt2u1MspdBMAvkLliRJyDAM4GpfAkgpDRsAs8xFJIS/4GwRQjzfPEDOedd1aZpCDazr2hDiqqqUUuv1OssyKWUIUX6+6eE0TX2FKkmSr6+vQDIOXozAc4FZ+O9yiZdxHB8KA/oXi0UEZj7aPlOlI4D9f+yL4zh6NHPBWXuxD/CuV4qHnWeaple8EFbxazH8PcJkZqbtPSGxilYIf1FKgVXPgfbBVRuTO9OnoCmWZUkpnbIpm78bljBTQn3DokD+Ape97XZ7vY8xxmbYjg8vkL9AD4HBVGSogNXMpi5crVZJkqxWKzifcP4CsybweoQnem3b+thxURRN0yillFJvb2938Ze2bc3lKzK7i+PYh5fnOewuSZKiKJRSTdME8pfT6YTHHhEmCiEDT9gp1KcQ/nI4HPBENMJ9dRzHm1XGVN5A/tK2LWPsylcs7jwdiQzDgGeekIjOEQrn3DkMwYNQYgXuNCs45yY1h2GI49jwlJv8ZaqQTLdj5ZDWGiCFEEIIbOvN+Ys1obxv/nmvQFmx5p+O+S4+sX8Rxphl3H3z63uNC5pfO+fzvxCfBjfeMAzhN1DnCU1zYw4PbsDz48mZ/3OsOXoQHvjgF3jDMMz8f/QfxXuSeuEAoJAAAAAASUVORK5CYII=\n",
      "text/html": [
       "<p style=\"text-align:center;\">$\\begin{pmatrix}10\\\\ 30\\\\ 50\\end{pmatrix}$</p>"
      ],
      "text/latex": [
       "$\\begin{pmatrix}10\\\\ 30\\\\ 50\\end{pmatrix}$"
      ],
      "text/plain": [
       "Vector([10, 30, 50])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a|(1,3,5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Definamos ahora otro vector completamente nuevo\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAACUAAACNCAIAAAC/syTXAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAFOklEQVRo3u1bPXLyPBDe12FSZmRmcgFxA0OfRnAChyOYGzgcQbwncDiCyQlsN+kZTmDUpzGedCkyfMXyCUX+wdg48xbaCktYj3a1u3pgduFYLdvt9ni9ZFmWZVnVrAUV8vr6GoYhtBLGWOVclWaUUvnoeZ76ijp1PB6jKKKUcs7lCOfc87zSlQelm5jP50EQqCOcc0qpxJPjq9WKUuq67nK5pJQ+Pz8DwMvLy3g83mw2+HhBP845Y0wdqdpsFEW+7+Nn13UJIaqF1EcpUDxtANA8pQrPcRzpGtvtFgCiKJKzjDG5m0o8z/M05XAQxwkhjLE0TXFnjuOoX9NOEXeg+SpcVO54PAZBIDEopegvYRgWza5ZgjGmjfzA831f872ioB9FURQEgaYf51wzIEaUquKP+Fuv15rrF2UymQBAnucAIITQZofDofqI/rler0v8s7iXKp9Em+MH9fue56HZVXFdVzUDqBOlxkzTVF0FA/H0MoBqQNd1i6+jGnKFM572srqK9Is0TQkh0qFc1wWAMAy3263neaX5Fn1Q+i2oVlKjR30BIdH9VF0xJADAcZzSd2WcSJOC9MyqXNpd0Ad/+OdutyOEQD+CNojjGABOeEmSqFn4toIr73a7E95+v5eB1R8epjdLIven32g0+qEfpon+8HBxRDnj4an2atLD4XDGQ617dVEhhFWadksljuPpdIrOpY2PRqPValXzLubxE16WZfXBhyvOZrMkSbSp1WqV5znyl81mU7UCrp9lGWDmvHjtyRykXgg1/KX01uScW4fDoeEZFAN0uVwul0v5Oc9zTCJV9syyzFL1vUpwo7Zt4+N4PKaUYpBV2TPPcwvvixaSJIl2mzPGLrqeVcoDmgj+TtCCrMpOZ3t+fn4CwNfXVwsVL/IXTT4+PqyHhwcAuL+/b6KQpk2e56q7CSHwxq86v/v7+5M95bE3l+l0ii6ubqg+Sdm2PeiSpVzX/fv372QyoZSu12sZGzUyaJEGVb4qhJjP547jcM7H4/HlJdI0xZ0e+xSJYsHvisG7Md7d3d3T01N/5EzmHUQZfH9/v7+/Pz4+9oqXZRmi/MPn14W/XIfXnb+0yS9d+Eub/NKFv9wg/q7iLzfA68Rf2oVUc/5ym/zSnL+0yS9V/EUeoRACfbiX/NKCv1zNJwx/MfzF8BfDXwx/MfzF8BfDXwx/MfzF8AnDXwx/MfzF8BfDXwx/MfzF8BeDZ/iL4S+Gvxj+8u/xl8FwOPR9v67i/Ub85YTS3D+xxkr6Z8P63Zvdf534C9Y398dfcP3hcPjr/AV9rFgzf1vBw/Z938KAbV2F1vJ+aHd+zUWenwUAhJC+9cP1KaUWwv6OfoQQC3qu3FUz0Uk/xCte3De352g0OuM1rKptJ7J+3QKlmLfq24vF4o8iWtJqwl+EEKjVoKF+V/UfafKjfh3jHxtvagr8r+0/KiaXIAjO/QjY63MtXn3/kdoSAv+3eFiSCmjFnMUjnE6ntm1LCtqcv2CvFZ76GQ8pSdW14Pt+HMdCCCHEbDa7ir8kSSK5nSV3RwipwlssFrg727Z93xdCxHHckL/s9/s8z2Wb0fl+n8/nTRr+ruo/AoC3tzdQOgIt9bLO8/xilpGZt2H9bpIkjLFzva7qSISQYktQl/4j3FwYhuX9Y5zzYlR06T8qLljSH6fFUJf+I61Dr2n/XxfOUtf/h1tWLdZFGGOaciV4pf2b7ZRr1L8p7V7TD9ZEqlaAKrrfpOOjSjjnVT9IoObXSWl7XpN+Zq3PshEenkG7vwJrmiT/A510EywfM+hPAAAAAElFTkSuQmCC\n",
      "text/html": [
       "<p style=\"text-align:center;\">$\\begin{pmatrix}50\\\\ 10\\\\ 10\\\\ 10\\\\ 10\\\\ 10\\\\ 50\\end{pmatrix}$</p>"
      ],
      "text/latex": [
       "$\\begin{pmatrix}50\\\\ 10\\\\ 10\\\\ 10\\\\ 10\\\\ 10\\\\ 50\\end{pmatrix}$"
      ],
      "text/plain": [
       "Vector([50, 10, 10, 10, 10, 10, 50])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a|(5,1,1,1,1,1,5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De esta manera podemos reordenar las componentes de un vector de manera muy sencilla\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/html": [
       "<p style=\"text-align:center;\">$\\begin{pmatrix}50\\\\ 40\\\\ 30\\\\ 20\\\\ 10\\end{pmatrix}$</p>"
      ],
      "text/latex": [
       "$\\begin{pmatrix}50\\\\ 40\\\\ 30\\\\ 20\\\\ 10\\end{pmatrix}$"
      ],
      "text/plain": [
       "Vector([50, 40, 30, 20, 10])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a|(5,4,3,2,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Definición de algunos vectores especiales\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Con `V0(n)` generamos un vector nulo de `n` componentes\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAB0AAAA9CAIAAADeXfVuAAAACXBIWXMAAA7EAAAOxAGVKw4bAAADh0lEQVRYw61Y73XCIBC/x+sA6Ahkg+gIdAN0BEbIcwTSCWxGSDtBzAipE8SMgGxgP5yPIIGEVu+TIfjLcf9+3MEtLl3XzbzVWmutY28JROTz87Oua5gVznn0XUxTxpi32DQNY0wpZVeUUlLKIEIYlzHWNI27opSq67ooCgCo69qu53nuPs7hKqU4556mRVHgbyEEpdQ9mfsYxdVaA4DnsTzPrYu6rgMA9zScc/vVKK6U0lNWa53nuWcl18r4JS82YFHZuq69L0kpPXdxzr2VhzhTSjHGNpuNu4hx6q4wxiil7oqUsqqq6/VqVx5wq6qSUk5jcRgGb2W9XruPu90O/x6IX8yCaQo1TeOtSyn7vve2CSFcN4D7YpoL900ArseFENM9qJb9HsT+7OmC6dB1nZQyWDfQBzZOwD2sl2NeqAFAnuexPRh/1hR3XEzQ23OCPn+Is/P57IXOPwTPdDqdxjhr25Yx9iQuIpzP5zvu5XIBgO12+xJcTGtiv/C8vlmWPeiL6fQ8LoIg2oiLVn+JKa7X64iLp3hJSAzDQIJlJSin0ynLsrIsZ/ZgPbrjaq0Xg7csS2OMEOJwOHx9fcW2IY7WmgCAMcare1NNtda73a4sSyFEsJa6YowBrBexSpbCb9OqVhQFcfUPCrLAarXCx81mwxjDII3ZwRhDPI6ZStu2npU454uuJkFe+Su/efFw99u8HVL4LaqvS6XTFDLGuBuGYUAGidn3nm+uW6by/v6OBONaZj45V6vV2xhxcRFCfHx8bLdbxlhVVYfDYS5yAdbr9VtKBldVNQzDfr/P81wp5V1cgvK26AE818/PT4oGGDmUUoKWXYzivwpJsW+6WPsSVPtV+tpqQxD+tfpSSsmrmM3NzLu+iIts/xI7ZFk24iay0bzYexNxye55fhuGAbVM1TeF3x7uTcgflFKvOUns36Y3++PxON5TOeex3en8hjUPr+zEUotXZP/Bb9h7Ygklbmfetu0z/Na2rb2UEqsFpTSIm8hvl8vFGGOvFmP/tt/vYwOHFH77/v52JxLEJQVjzDTrEvmtbVvO+chnrkMppcFWa7F/Q0O5gwjwAiUYbYv92/SPgX5+GpuL/Zs3OUiaPyzKtIEOz0sopfMTLk84556yqfOdeWWT5juxedRMTxzcGcbt+37+pm1PFpwZRHFvt9vxeIyNDWLzpCRctN3M277vZ+aTv9eihjZxChHiAAAAAElFTkSuQmCC\n",
      "text/html": [
       "<p style=\"text-align:center;\">$\\begin{pmatrix}0\\\\ 0\\\\ 0\\end{pmatrix}$</p>"
      ],
      "text/latex": [
       "$\\begin{pmatrix}0\\\\ 0\\\\ 0\\end{pmatrix}$"
      ],
      "text/plain": [
       "Vector([0, 0, 0])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "V0(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQkAAAAUCAIAAAARNV/CAAAACXBIWXMAAA7EAAAOxAGVKw4bAAACpklEQVRo3u2bP7LqIBTGz817TTqSJWBpR7ZAdqAugSWopXa6A7W8ZdxBZAkkKzCxtCPZAa/gvlwmzrxRL48GvooE+AW/mTNy+POhlIK/appmMplAUJB/6rouSRLzTTSUzudzXdfBoyA/lSTJarXqum4cG03TcM7n87nZ+nK5TCaT/X5v5dt2aR4Cg4H/m7Zerxljw+OvzWYDAHmef35+xnE8VOz3+ziOEULb7XY6nU6n058Myy7NQ2Aw0IGBcRzfbrf7/f5Vq5Qqy5IxpgyVZblcLnV5NpshhNQPZJfmITAY6NJAjLEugFKKUlqWpVlNCJFS6rIQAgBGDV6SXZqHwGCgSwMppUIIpVQEAJzzPM/NhF2nJvoxyzKM8dtpul2ah8BgoGMDKaWn0wkAoqqqMMZmHec8TdNR67Zt3xuZXZqHwGCgYwMJIfq/JWrbFiFk1kkppZTmG4zxqM3zskvzEBgMdGxgmqY6ciIp5SiqAOAxqh7bPC+7NA+BwUCXBiKE+r4HgKjv+1EMYYz7vjc3Qdq2nc1m7w3LLs1DYDDQsYHfYXM4HCilo1QdAIY1L73sNeT4OoV/SXZpHgKDgS4NvF6vem8DiqIghIyqdVQVRSGEYIwN/QkhegL30sjs0jwEBgNdGiiE0BsgcL1eH7dCpJS6GyHEXAnW+fvhcHhpZHZpHgKDgS4NLIpCz6R+64O3o0OISZJUVfU4FcuyjDGmM5XnZZfmITAY6NJAIQSlFPRZw8ViwTl/8jMIId3TiuzSPAQGA63TOOd6DhYBAGNMbwQ+qSzLLP5UuzQPgcFAi7SmadI0/brFpOdYZoLyD7235uCG5iEwGGidZgbCx3Dvbz6fn89nCAryVZfLpa7r1WqlH7/v/e12u+PxGAwK8lNd15mBAQB/AIt/uxHbxDs0AAAAAElFTkSuQmCC\n",
      "text/html": [
       "<p style=\"text-align:center;\">$\\begin{pmatrix}0,& 0,& 0,& 0,& 0,& 0,& 0,& 0,& 0,& 0,\\end{pmatrix}$</p>"
      ],
      "text/latex": [
       "$\\begin{pmatrix}0,& 0,& 0,& 0,& 0,& 0,& 0,& 0,& 0,& 0,\\end{pmatrix}$"
      ],
      "text/plain": [
       "Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "V0(10, 'fila')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Con con el signo `-` delante de un vector, obtenemos su opuesto\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAACkAAAA9CAIAAAC/RdcsAAAACXBIWXMAAA7EAAAOxAGVKw4bAAADyElEQVRYw71Z23WDMAxVOR3AYQSzAWQEZwPDCIxAM4LpBIERaCYIjECYgDKCYQP6oRxwCKRgEvSV8LqWfCXL19BOW57n7TqTUkopp+4aMGFRFCVJAquNMTZ5b8pjSqmGo5fLxbZthCzLsm1bIYTv+6MPj2NTSi+Xy1Lg0+kkhMjzXAgBALZt43XbtpMkmYUthGCM6c1u9xtD3UWREPI/tpQSANazLAgCFY8xFgTBP9i+7+s5PTDOuTrNeZ4DwIDz8A6nkTEDJMbYgHQwCJQevR8ZczqdBhcxY9UBfar5Fsfx8XgcJGFd177vP8ng/X7/9fXV/b1er1mWpWk6eMx1XYToH34yLj1jjE19hHPeJd5dzDnn6wPOGHtCF3QPa85dzM/ncxAEa8onRjXPc2Q1AJimiRfV+no+n29h72ohAGjUMpWnj6N5rKaU0i7soL7Zvt+QtnfrWFEUhBB4v+FKg1lww86yjFK6ATaiFEVxw/79/cU03QwbyWh0o9jGb8uy7vyuqmozbARCxB4bWbBZ2Ou67rExGptRvaqqHlvD0jS1LCsMw0VvmabZY0spNZI7DMOmaTjnx+Px5+dn/ouIJaU0AKBpGhzLIo+llK7rhmGILcrSoTdNA9irLF3BbNvuFkpM1vlrAa5mQRAYahxmWl3XALDb7fCv4ziUUkzZ+TFvmsZAvxdZlmWDOWKMaRDWULk303CXNUjZ+ZFDrBvXlsZ8NC2XsrX3G6dwfmFqmkZ9paoqzvmi+b7VNZU4c+xwOAAAbrq6WVhaFne73WefbUuMc/79/b3f7ymlo531P5kNYJrmp141jeO4qirP82zbFkI4jqPxkU8NjmDErter3rgxRwghBs60RpavN0NvvtdYN98Gur+l390KYuAQtvebEGJs2ampNfHmN2Jjp7xZzC3L6rG1O6el1u2BDLV5W//dNE0dx/n4+DgcDlOBrKoKvX2l31EUFUURx7EQIssyz/Men7nbA2EfQwhZLy9N6WsD4REAUI0xOs2k27Brm7oY2rY92hNga4UjM7qmZ7Akr0+k0ZijxnhbcNVec1T1fJW+9ji5oF6dEnxfoq+1bVuWpephv357npckSRRFb9LXUOW5U9QHDOwEqHfoa4wxNZtgMBmPau+r9DUspSqlPtq2Vbd3Qghttruui7tDtXHu9LWRjz8OTU9l+1dfo5QKIbbQz0fL2TP9HF0nhLxEQh/wYOD0i89Lnjg967xkzTnRkxo3+rVx7LIsX3KAgFHknC84H8PDrpW5juxRxfq52DhPK7HLsnxyEPEHoQuHdkYmJIIAAAAASUVORK5CYII=\n",
      "text/html": [
       "<p style=\"text-align:center;\">$\\begin{pmatrix}-2\\\\ 0\\\\ -2\\end{pmatrix}$</p>"
      ],
      "text/latex": [
       "$\\begin{pmatrix}-2\\\\ 0\\\\ -2\\end{pmatrix}$"
      ],
      "text/plain": [
       "Vector([-2, 0, -2])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = Vector( [2, 0, 2] )\n",
    "-a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Igualdad de vectores\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Dos vectores son iguales si lo son las correspondientes listas\n",
    "ordenadas de números* (independientemente de si la representación es\n",
    "vertical u horizontal).\n",
    "\n",
    "Recuerde que con `v = Vector( a )` generamos un vector cuya\n",
    "representación es en forma de columna y cuya lista de componentes es\n",
    "la de `a`; y que con `w = Vector( a, rpr='fila' )` generamos otro\n",
    "vector cuya representación es en forma de fila. Veamos si, pese a su\n",
    "diferente representación, ambos vectores son iguales.\n",
    "\n",
    "El operador `==` comprueba si dos objetos son iguales (`True`) o si no\n",
    "lo son (`False`):\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v = Vector( a )\n",
    "w = Vector( a, rpr='fila' )\n",
    "v == w"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = Vector( [-2, 0, -2] )\n",
    "a == -b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dos vectores nulos con diferente número de componentes no son iguales\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "V0(2) == V0(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Con `!=` comprobamos si es verdadero que dos vectores son distintos\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a != b      # ¿son distintos?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ayuda\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Con el comando `help(objeto)` obtenemos ayuda sobre el `objeto` y sus\n",
    "procedimientos asociados\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class Vector in module nacal.nacal:\n",
      "\n",
      "class Vector(Sistema)\n",
      " |  Vector(data, rpr='columna')\n",
      " |  \n",
      " |  Clase Vector(Sistema)\n",
      " |  \n",
      " |  Vector es un Sistema de números u objetos del módulo Sympy. Se puede\n",
      " |  instanciar con una lista, tupla o Sistema. Si se instancia con un Vector\n",
      " |  se crea una copia del mismo. El atributo 'rpr' indica al entorno Jupyter \n",
      " |  si el vector debe ser escrito como fila o como columna.\n",
      " |  \n",
      " |  Parámetros:\n",
      " |      sis (list, tuple, Sistema, Vector) : Lista, tupla o Sistema de \n",
      " |          objetos de tipo int, float o sympy.Basic, o bien otro Vector.\n",
      " |      rpr (str) : Representación en Jupyter ('columna' por defecto).\n",
      " |          Si rpr='fila' el vector se representa en forma de fila. \n",
      " |  \n",
      " |  Atributos:\n",
      " |      n     (int)    : número de elementos de la lista.\n",
      " |      rpr   (str)    : modo de representación en Jupyter.\n",
      " |  \n",
      " |  Atributos heredados de la clase Sistema:\n",
      " |      lista (list)   : list con los elementos.\n",
      " |  \n",
      " |  Ejemplos:\n",
      " |  >>> # Instanciación a partir de una lista, tupla o Sistema de números\n",
      " |  >>> Vector( [1,2,3] )           # con lista\n",
      " |  >>> Vector( (1,2,3) )           # con tupla\n",
      " |  >>> Vector( Sistema( [1,2,3] ) )# con Sistema\n",
      " |  >>> Vector( Vector ( [1,2,3] ) )# a partir de otro Vector\n",
      " |  \n",
      " |  Vector([1,2,3])\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      Vector\n",
      " |      Sistema\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __init__(self, data, rpr='columna')\n",
      " |      Inicializa Vector con una lista, tupla o Sistema\n",
      " |  \n",
      " |  __rand__(self, t)\n",
      " |      Hace exactamente lo mismo que el método __and__ por la derecha.\n",
      " |  \n",
      " |  __repr__(self)\n",
      " |      Muestra el vector en su representación Python\n",
      " |  \n",
      " |  __ror__(self, i)\n",
      " |      Hace exactamente lo mismo que el método __or__ por la derecha.\n",
      " |  \n",
      " |  diag(self)\n",
      " |      Crea una Matrix diagonal cuya diagonal es self\n",
      " |  \n",
      " |  latex(self)\n",
      " |      Construye el comando LaTeX para representar un Vector\n",
      " |  \n",
      " |  norma(self)\n",
      " |      Devuelve un múltiplo de un vector (no nulo) pero norma uno\n",
      " |  \n",
      " |  normalizado(self)\n",
      " |      Devuelve un múltiplo de un vector (no nulo) pero norma uno\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from Sistema:\n",
      " |  \n",
      " |  __add__(self, other)\n",
      " |      Devuelve el Sistema resultante de sumar dos Sistemas\n",
      " |      \n",
      " |      Parámetros: \n",
      " |          other (Sistema): Otro sistema del mismo tipo y misma longitud\n",
      " |      \n",
      " |      Ejemplos:\n",
      " |      >>> Sistema([10, 20, 30]) + Sistema([-1, 1, 1])\n",
      " |      \n",
      " |      Sistema([9, 21, 31]) \n",
      " |      >>> Vector([10, 20, 30]) + Vector([-1, 1, 1])\n",
      " |      \n",
      " |      Vector([9, 21, 31]) \n",
      " |      >>> Matrix([[1,5],[5,1]]) + Matrix([[1,0],[0,1]]) \n",
      " |      \n",
      " |      Matrix([Vector([2, 5]); Vector([5, 2])])\n",
      " |  \n",
      " |  __and__(self, t)\n",
      " |      Transforma los elementos de un Sistema S\n",
      " |      \n",
      " |      Atributos:\n",
      " |          t (T): transformaciones a aplicar sobre un Sistema S\n",
      " |      Ejemplos:\n",
      " |      >>>  S & T({1,3})                # Intercambia los elementos 1º y 3º\n",
      " |      >>>  S & T((5,1))                # Multiplica por 5 el primer elemento\n",
      " |      >>>  S & T((5,2,1))              # Suma 5 veces el elem. 1º al elem. 2º\n",
      " |      >>>  S & T([{1,3},(5,1),(5,2,1)])# Aplica la secuencia de transformac.\n",
      " |                   # sobre los elementos de S y en el orden de la lista\n",
      " |  \n",
      " |  __eq__(self, other)\n",
      " |      Indica si es cierto que dos Sistemas son iguales\n",
      " |  \n",
      " |  __getitem__(self, i)\n",
      " |      Devuelve el i-ésimo coeficiente del Sistema\n",
      " |  \n",
      " |  __len__(self)\n",
      " |      Número de elementos del Sistema\n",
      " |  \n",
      " |  __mul__(self, x)\n",
      " |      Multiplica un Sistema por un número, Vector o una Matrix a su derecha\n",
      " |      \n",
      " |      Parámetros:\n",
      " |          x (int, float o sympy.Basic): Escalar por el que se multiplica\n",
      " |            (Vector): con tantos componentes como el Sistema\n",
      " |            (Matrix): con tantas filas como componentes tiene el Sistema\n",
      " |      \n",
      " |      Resultado:\n",
      " |          Sistema del mismo tipo: Si x es int, float o sympy.Basic, devuelve \n",
      " |             el Sistema que resulta de multiplicar cada componente por x\n",
      " |          Objeto del mismo tipo de los componentes del Sistema: Si x es Vector,\n",
      " |             devuelve una combinación lineal de los componentes del Sistema, \n",
      " |             donde los componentes de x son los coeficientes de la combinación.\n",
      " |          Sistema del mismo tipo: Si x es Matrix, devuelve un Sistema cuyas \n",
      " |             componentes son combinación lineal de las componentes originales.\n",
      " |             \n",
      " |      Ejemplos:\n",
      " |      >>> # Producto por un número\n",
      " |      >>> Vector([10, 20, 30]) * 3\n",
      " |      \n",
      " |      Vector([30, 60, 90])\n",
      " |      >>> Matrix([[1,2],[3,4]]) * 10\n",
      " |      \n",
      " |      Matrix([[10,20],[30,40]])\n",
      " |      >>> # Producto por un Vector\n",
      " |      >>> Vector([10, 20, 30]) * Vector([1, 1, 1])\n",
      " |      \n",
      " |      60\n",
      " |      >>> Matrix([Vector([1, 3]), Vector([2, 4])]) * Vector([1, 1])\n",
      " |      \n",
      " |      Vector([3, 7])\n",
      " |      >>> # Producto por una Matrix\n",
      " |      >>> Vector([1,1,1])*Matrix( ( [1,1,1], [2,4,8], [3,-1,0] ) )\n",
      " |      \n",
      " |      Vector([6, 4, 9])\n",
      " |      >>> Matrix([Vector([1, 3]), Vector([2, 4])]) * Matrix([Vector([1,1])]))\n",
      " |      \n",
      " |      Matrix([Vector([3, 7])])\n",
      " |  \n",
      " |  __ne__(self, other)\n",
      " |      Indica si es cierto que dos Sistemas son distintos\n",
      " |  \n",
      " |  __neg__(self)\n",
      " |      Devuelve el opuesto de un Sistema\n",
      " |  \n",
      " |  __or__(self, j)\n",
      " |      Extrae el j-ésimo componente del Sistema; o crea un Sistema con los\n",
      " |      elementos indicados (los índices comienzan por el número 1)\n",
      " |      \n",
      " |      Parámetros:\n",
      " |          j (int, list, tuple, slice): Índice (o lista de índices) del \n",
      " |                elementos (o elementos) a seleccionar\n",
      " |      \n",
      " |      Resultado:\n",
      " |                ?: Si j es int, devuelve el elemento j-ésimo del Sistema.\n",
      " |          Sistema: Si j es list, tuple o slice devuelve el Sistema formado por\n",
      " |                los elementos indicados en la lista, tupla o slice de índices.\n",
      " |      \n",
      " |      Ejemplos:\n",
      " |      >>> # Extrae el j-ésimo elemento del Sistema \n",
      " |      >>> Sistema([Vector([1,0]), Vector([0,2]), Vector([3,0])]) | 2\n",
      " |      \n",
      " |      Vector([0, 2])\n",
      " |      >>> # Sistema formado por los elementos indicados en la lista (o tupla)\n",
      " |      >>> Sistema([Vector([1,0]), Vector([0,2]), Vector([3,0])]) | [2,1]\n",
      " |      >>> Sistema([Vector([1,0]), Vector([0,2]), Vector([3,0])]) | (2,1)\n",
      " |      \n",
      " |      [Vector([0, 2]); Vector([1, 0])]\n",
      " |      >>> # Sistema formado por los elementos indicados en el slice\n",
      " |      >>> Sistema([Vector([1,0]), Vector([0,2]), Vector([3,0])]) | slice(1,3,2)\n",
      " |      \n",
      " |      [Vector([1, 0]), Vector([3, 0])]\n",
      " |  \n",
      " |  __reversed__(self)\n",
      " |      Devuelve el reverso de un Sistema\n",
      " |  \n",
      " |  __rmul__(self, x)\n",
      " |      Multiplica un Sistema por un número a su izquierda\n",
      " |      \n",
      " |      Parámetros:\n",
      " |          x (int, float o sympy.Basic): Escalar por el que se multiplica\n",
      " |      Resultado:\n",
      " |          Sistema resultante de multiplicar cada componente por x\n",
      " |      Ejemplo:\n",
      " |      >>> 3 * Sistema([10, 20, 30]) \n",
      " |      \n",
      " |      Sistema([30, 60, 90])\n",
      " |  \n",
      " |  __setitem__(self, i, value)\n",
      " |      Modifica el i-ésimo coeficiente del Sistema\n",
      " |  \n",
      " |  __sub__(self, other)\n",
      " |      Devuelve el Sistema resultante de restar dos Sistemas\n",
      " |      \n",
      " |      Parámetros: \n",
      " |          other (Sistema): Otro sistema del mismo tipo y misma longitud\n",
      " |      \n",
      " |      Ejemplos:\n",
      " |      >>> Sistema([10, 20, 30]) - Sistema([1, 1, -1])\n",
      " |      \n",
      " |      Sistema([9, 19, 31])\n",
      " |      >>> Vector([10, 20, 30]) - Vector([1, 1, -1])\n",
      " |      \n",
      " |      Vector([9, 19, 31])\n",
      " |      >>> Matrix([[1,5],[5,1]]) - Matrix([[1,0],[0,1]]) \n",
      " |      \n",
      " |      Matrix([Vector([0, 5]); Vector([5, 0])])\n",
      " |  \n",
      " |  concatena(self, other, c=0)\n",
      " |      Concatena dos Sistemas\n",
      " |  \n",
      " |  copy(self)\n",
      " |      Copia la lista de otro Sistema\n",
      " |  \n",
      " |  de_composicion_uniforme(self)\n",
      " |      Indica si es cierto que todos los elementos son del mismo tipo\n",
      " |  \n",
      " |  es_nulo(self, sust=[])\n",
      " |      Indica si es cierto que el Sistema es nulo\n",
      " |  \n",
      " |  factor(self)\n",
      " |  \n",
      " |  junta(self, l)\n",
      " |      Junta una lista o tupla de Sistemas en uno solo concatenando las\n",
      " |      correspondientes listas de los distintos Sistemas\n",
      " |  \n",
      " |  no_es_nulo(self, sust=[])\n",
      " |      Indica si es cierto que el Sistema no es nulo\n",
      " |  \n",
      " |  simplify(self)\n",
      " |  \n",
      " |  sis(self)\n",
      " |  \n",
      " |  subs(self, s=[])\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from Sistema:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from Sistema:\n",
      " |  \n",
      " |  __hash__ = None\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(Vector)"
   ]
  }
 ],
 "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.2"
  },
  "org": [
   null,
   null
  ]
 },
 "nbformat": 4,
 "nbformat_minor": 1
}