1 Primeros pasos.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Primeros pasos con `GAP`\n",
    "\n",
    "`gap` es un entorno de cálculo algebraico discreto. Tiene un núcleo implementado en `c` y dispone aparte de librerías escritas en su propio lenguaje de programación. \n",
    "\n",
    "Este lenguaje es de tipo procedural, por lo que aquellas personas que han programado en `pascal`, `c`, `maple`, ... no tienen problemas en adaptarse. En la página oficial de [gap](https://www.gap-system.org) se puede encontrar abundante información concerniente a instalación en distintas plataformas, tutoriales, manuales, paquetes.\n",
    "\n",
    "Los paquetes pasan por un proceso de arbitraje similar al de las revistas científicas. Primero son depositados (y accesibles al público en la página oficial) y si se aceptan pasan a ser parte de la distribución. Aún así muchos instaladores incluyen los paquetes depositados. \n",
    "\n",
    "`gap` ha sido mantenido a lo largo de su historia por varias universidades, y se nutre de las contribuciones que hacen los usuarios en forma de paquetes para fines más específicos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## La línea de comandos\n",
    "\n",
    "`gap` es un lenguaje interpretado (aunque tiene un compilador). Se pueden hacer operaciones directamente en la línea de comandos o bien se pueden leer ficheros con guiones escritos con un editor de textos. \n",
    "\n",
    "Normalmente se invoca usando el comando `gap`, aunque dependiendo del sistema operativo pueden haber distintas alternativas. Una vez iniciado el intérprete aparece una línea de comandos con el siguiente aspecto.\n",
    "\n",
    "```gap\n",
    "gap>\n",
    "```\n",
    "\n",
    "Para la edición de las entradas que queramos evaluar se pueden utilizar las flechas junto con las teclas de inicio y fin. Además existe la posibilidad de usar combinaciones de teclas similares a las de empleadas en un shell de unix (`ctr-[b,f,p,n,a,e]`). El tabulador sirve para completar comandos a partir del texto que hayamos introducido en ese momento. Así teclear `Gcd+TAB` da como resultado:\n",
    "\n",
    "```\n",
    "gap> Gcd\n",
    "    Gcd\n",
    "    GcdCoeffs\n",
    "    GcdInt\n",
    "    GcdOp\n",
    "    GcdRepresentation\n",
    "    GcdRepresentationOp\n",
    "    Gcdex\n",
    "```\n",
    "\n",
    "Para salir de la línea de comandos podemos usar el comando `quit;`, o bien pulsar `ctr-d`.\n",
    "\n",
    "El final de línea no se indica con el retorno de carro, sino con `;` (para evaluar, se pulsa `enter`). Esto permite escribir sentencias de varias líneas.\n",
    "\n",
    "```gap\n",
    "gap> 1+\n",
    "> 2;\n",
    "3\n",
    "```\n",
    "En `jupyter` para evaluar hay que pulsar `mayúscula+enter`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 1,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1+\n",
    "2;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La sesión de trabajo se puede almacenar en un fichero para su posterior edición usando el comando `LogTo`. Con `LogTo(\"pruebas/log\");` guardamos en el fichero `log` en la carpeta `pruebas`. Con `LogTo();` interrumpimos la grabación."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos leer una secuencia de comandos (guión) con la orden `Read` (en este ejemplo `uno.g` contiene sólamente `a:=1;`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "Read(\"pruebas/uno.g\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 3,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nótese que las barras son de la forma `/`, incluso en windows.\n",
    "\n",
    "A la ayuda se accede usando el signo de cierre de interrogación. Por ejmeplo, `?LogTo` muestra ayuda sobre dicho comando."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las operaciones de suma y producto dependen de los argumentos que les acompañen. Así pueden representar suma de enteros, o de matrices, o de subespacios vectoriales... El producto puede significar incluso la composición de dos permutaciones, y el elevado (`^`) la imagen de un punto por una permutación."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 2, 4, 3 ]"
      ]
     },
     "execution_count": 9,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1,2,3]+[1,2];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1,5,2)"
      ]
     },
     "execution_count": 10,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1,2)*(2,5);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 11,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1^(1,2,3);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los símbolos `=`, `<`, `>`, `<=`, `> =` y `<>` sirven para denotar igualdad, ser mayor, menor, menor o igual, mayor o igual y distinto, respectivamente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 12,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2=1+1;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 13,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1,2]<[3];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 14,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1,2]>[1,3];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 15,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1<>1;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Identificadores\n",
    "\n",
    "Si vamos a utilizar un objeto varias veces, podemos por comodidad asignarle un nombre. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1024"
      ]
     },
     "execution_count": 16,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a:=2^10;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si queremos inhibir la salida, escribimos un punto y coma extra al final de la asignación."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "b:=a;;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos visualizar las variables definidas hasta el momento de la siguiente forma."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Error, Variable: 'NamesUserGVars' must have a value\n",
      "not in any function at stream:1\n"
     ]
    }
   ],
   "source": [
    "NamesUserGVars();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las variables en `gap` no tienen tipo, las características del objeto al que se refieren se guardan en el propio objeto. De hecho, podemos reutilizar una misma variable para denotar distintos tipos de datos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 18,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a:=1;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1,2)"
      ]
     },
     "execution_count": 19,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a:=(1,2);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 1, 2 ]"
      ]
     },
     "execution_count": 20,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a:=[1,2];"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El identificador `last` se usa para hacer referencia a la última salida (también existen `last2` y `last3`)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En `gap` se ha establecido el convenio de escribir las variables globales y las utilizadas en las librerías empezando con mayúsculas.\n",
    "\n",
    "Las funciones también son objetos, y se pueden definir de varias formas. Podemos utilizar un procedimiento clásico."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "function( x ) ... end"
      ]
     },
     "execution_count": 21,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f:=function(x)\n",
    "    return x^2;\n",
    "end;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 22,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(3);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y también podemos usar notación estilo $\\lambda$-cálculo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "function( x ) ... end"
      ]
     },
     "execution_count": 23,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 24,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g:=x->x^2;\n",
    "g(3);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Listas\n",
    "\n",
    "Las listas en `gap` se escriben, como ya hemos visto en algunos ejemplos arriba como una secuencia de elementos delimitada por corchetes. Dichas secuencias no tienen por qué ser homogéneas. Al trabajar con listas tenemos que prestar atención a algunas funciones que son 'destructivas', a saber, modifican alguno de los argumentos que se les pasa. Esto se debe en parte a que cuando uno asigna un identificador a una lista, no lo hace al objeto como tal, si no a su posición en la memoria."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 1, \"a\" ]"
      ]
     },
     "execution_count": 25,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a:=[1,\"a\"];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 1, \"a\" ]"
      ]
     },
     "execution_count": 26,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b:=a;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 27,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b[2]:=3;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 1, 3 ]"
      ]
     },
     "execution_count": 28,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como hemos visto en este ejemplo `lista[n]` accede al `n`-ésimo elemento de la lista (empezando por 1; en otros lenguajes la primera posición es la correspondiente al índice 0)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos usar el comando `ShallowCopy` para hacer una copia de una lista, creando un objeto nuevo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 1, \"a\" ]"
      ]
     },
     "execution_count": 29,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a:=[1,\"a\"];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 1, \"a\" ]"
      ]
     },
     "execution_count": 30,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b:=ShallowCopy(a);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 31,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b[2]:=3;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 1, 3 ]"
      ]
     },
     "execution_count": 32,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 1, \"a\" ]"
      ]
     },
     "execution_count": 33,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hay multitud de formas para definir y modificar listas, ponemos unos ejemplos a continuación."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 1, \"a\" ]"
      ]
     },
     "execution_count": 34,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a:=[1,\"a\"];"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para añadirle a `a` los elementos de otra lista, podemos usar `Append`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "Append(a,[2,3]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 1, \"a\", 2, 3 ]"
      ]
     },
     "execution_count": 36,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si lo que queremos es añadir un elemento al final, usamos `Add`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "Add(a,5);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 1, \"a\", 2, 3, 5 ]"
      ]
     },
     "execution_count": 38,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Concatenation` devuelve una lista nueva a partir de dos dadas, concatenándolas y sin modificarlas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 1, \"a\", 2, 3, 5, 8, 9 ]"
      ]
     },
     "execution_count": 39,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Concatenation(a,[8,9]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 1, \"a\", 2, 3, 5 ]"
      ]
     },
     "execution_count": 40,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Filtered` lo podemos usar para filtrar los elementos de una lista que cumplan una condición."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97 ]"
      ]
     },
     "execution_count": 41,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l:=Filtered([1..100],IsPrime);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También podemos aplicar una función a todos los elementos de una lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 4, 9, 25, 49, 121, 169, 289, 361, 529, 841, 961, 1369, 1681, 1849, 2209, 2809, 3481, 3721, 4489, 5041, 5329, 6241, 6889, 7921, 9409 ]"
      ]
     },
     "execution_count": 42,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "List(l,x->x^2);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A veces es conveniente usar conjuntos en vez de listas, pues sus elementos se ordenan (si son comparables entre sí) y la pertenencia de un elemento es más rápida de resolver. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 1, 2, 1, 2 ]"
      ]
     },
     "execution_count": 43,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a:=[1,2,1,2];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 1, 2 ]"
      ]
     },
     "execution_count": 44,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Set(a);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 1, 2, 1, 2 ]"
      ]
     },
     "execution_count": 45,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 46,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 in a;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hay ciertos comandos que dan como salida un conjunto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 1, 2 ]"
      ]
     },
     "execution_count": 47,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a:=[1,2];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 2, 3 ]"
      ]
     },
     "execution_count": 48,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b:=[2,3];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 1, 2, 3 ]"
      ]
     },
     "execution_count": 49,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u:=Union(a,b);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 50,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IsSet(u);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 2 ]"
      ]
     },
     "execution_count": 51,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Intersection(a,b);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Rangos\n",
    "\n",
    "El uso de `..` se puede usar de varias formas, y captura la idea de rango."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 ]"
      ]
     },
     "execution_count": 52,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l:=[1..20];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 3, 5, 7, 9 ]"
      ]
     },
     "execution_count": 53,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l{[3,5..9]};"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400 ]"
      ]
     },
     "execution_count": 54,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lc:=List(l,x->x^2);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 400, 361, 324, 289, 256, 225, 196, 169, 144, 121, 100 ]"
      ]
     },
     "execution_count": 55,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lc{[20,19..10]};"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Registros\n",
    "\n",
    "En `gap` podemos crear registros con campos personalizados utilizando `rec`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "rec( a := 1, b := \"2\" )"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r:=rec(a:=1,b:=\"2\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos añadir nuevos campos, o modificar los existentes, simplemente asignándoles un valor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "rec( d := 1, e := 3 )"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.c:=rec(d:=1,e:=3);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "rec( a := 1, b := \"2\", c := rec( d := 1, e := 3 ) )"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 59,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.a:=5;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "rec( a := 5, b := \"2\", c := rec( d := 1, e := 3 ) )"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para acceder al valor de un campo, utilizamos `.`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 61,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.c.d;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos ver los campos definidos con `RecNames`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ \"b\", \"a\", \"c\" ]"
      ]
     },
     "execution_count": 62,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "RecNames(r);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O ver si un campo está asignado o no"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 63,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IsBound(r.g);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "Unbind(r.b);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "rec( a := 5, c := rec( d := 1, e := 3 ) )"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Al igual que en listas, si queremos hacer una copia, es recomendable utilizar `ShallowCopy`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "rec( a := 5, c := rec( d := 1, e := 3 ) )"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rr:=ShallowCopy(r);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 67,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rr.c.d:=4;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "rec( a := 5, c := rec( d := 4, e := 3 ) )"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El problema aquí es que `r` contiene a su vez otro registro. Para evitar esto, utilizamos `StructuralCopy`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "rec( a := 5, c := rec( d := 4, e := 3 ) )"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rr:=StructuralCopy(r);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 70,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rr.c.d:=1;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "rec( a := 5, c := rec( d := 4, e := 3 ) )"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "rec( a := 5, c := rec( d := 1, e := 3 ) )"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rr;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Algunos ejemplos de programación\n",
    "\n",
    "En `gap` se pueden utilizar comandos como `for`, `while`, `repeat` .. `until` para hacer bucles.  \n",
    "\n",
    "Veamos cómo definir el factorial de distintas formas, utilizando distintos estilos de implementación."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "function( x ) ... end"
      ]
     },
     "execution_count": 73,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f:=function(x)\n",
    "    local p, i; #variable local para el producto parcial y contador\n",
    "    \n",
    "    p:=1;\n",
    "    for i in [1..x] do\n",
    "        p:=p*i;\n",
    "    od; #final de bucle\n",
    "    \n",
    "    return p; #salida\n",
    "end;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 74,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(3);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De forma recursiva..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "function( x ) ... end"
      ]
     },
     "execution_count": 75,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f:=function(x)\n",
    "\n",
    "    if x=0 then\n",
    "        return 1;\n",
    "    fi;\n",
    "    \n",
    "    return x*f(x-1);\n",
    "end;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000"
      ]
     },
     "execution_count": 76,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(100);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usando funciones específicas de listas y $\\lambda$-expresiones ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "function( x ) ... end"
      ]
     },
     "execution_count": 77,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f:=x->Product([1..x]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "57133839564458545904789328652610540031895535786011264182548375833179829124845398393126574488675311145377107878746854204162666250198684504466355949195922066574942592095735778929325357290444962472405416790722118445437122269675520000000000000000000000000000000000000"
      ]
     },
     "execution_count": 78,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(150);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calculamos ahora el primer entero perfecto y los enteros perfectos entre 1 y 100000. Para ello usaremos `First`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "function( x ) ... end"
      ]
     },
     "execution_count": 79,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "es_perfecto:=x->(Sum(DivisorsInt(x))=2*x);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 80,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "First([1..200],es_perfecto);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 6, 28, 496 ]"
      ]
     },
     "execution_count": 81,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Filtered([1..1000],es_perfecto);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Veamos si todos los números entre 100 y 500 son perfectos, o  si hay alguno."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 82,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ForAll([100..500], es_perfecto);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 83,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ForAny([100..500], es_perfecto);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hacemos algo parecido con los pares de números amigos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "function( x, y ) ... end"
      ]
     },
     "execution_count": 92,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "son_amigos:=function(x,y)\n",
    "    local dx, dy; #divisores de x e y\n",
    "    \n",
    "    if x=y or IsPrime(x) then \n",
    "        return false;\n",
    "    fi; #queremos buscar parejas distintas y que no sean primos\n",
    "    dx:=List(DivisorsInt(x)); \n",
    "    Remove(dx);; #le quitamos x\n",
    "    dy:=List(DivisorsInt(y));\n",
    "    Remove(dy);; #le quitamos y\n",
    "    return (Sum(dx)=y) and (x=Sum(dy));\n",
    "end;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para ver qué números entre 1 y 50 tienen amigos, escribimos, por ejemplo, lo siguiente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 220 ]"
      ]
     },
     "execution_count": 93,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l:=Filtered([1..250],x->ForAny([1..500],y->son_amigos(x,y)));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ [ 220, 284 ] ]"
      ]
     },
     "execution_count": 95,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "List(l,x->[x,First([1..550],y->son_amigos(x,y))]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si queremos buscar en una lista más grande, podemos usar iteradores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<object>"
      ]
     },
     "execution_count": 102,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l:=IteratorOfCartesianProduct([1..1500],[1..1500]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 220, 284 ]\n",
      "[ 1184, 1210 ]\n"
     ]
    }
   ],
   "source": [
    "for x in l do\n",
    "if (x[1]<x[2]) and son_amigos(x[1],x[2]) then\n",
    "    Print(x,\"\\n\");\n",
    "fi;\n",
    "od;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "GAP 4 (native)",
   "language": "gap",
   "name": "gap-native"
  },
  "language_info": {
   "codemirror_mode": "gap",
   "file_extension": ".g",
   "mimetype": "text/x-gap",
   "name": "GAP 4",
   "nbconvert_exporter": "",
   "pygments_lexer": "gap",
   "version": "4.10.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}