9 Creando nuevos objetos.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ejemplo de creación de un nuevo tipo de objeto\n",
    "\n",
    "En `gap` todo son objetos. Podemos crear nuestros propios objetos con sus atributos, propiedades y métodos.\n",
    "\n",
    "Vamos a ver en este bloc un ejemplo de un objeto que represente un número racional. Esto ya existe en `gap` pero lo hacemos desde cero para ilustrar cómo se define una nueva clase.\n",
    "\n",
    "Todas las deficiones están en `ejemplo-objeto.g`, vamos a ir comentanto poco a poco lo que contiene este fichero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "Read(\"ejemplo-objeto.g\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creando el tipo de representación interna y la categoría del objeto\n",
    "\n",
    "Vamos a representar una fracción mediante su numerador y denominador. Es por ello que vamos a usar una representación nueva, `EsFraccionRep`, del tipo `IsAttributeStoringRep`, pues tendremos estos dos atributos almacenados en un racional. A la categoría (clase) le vamos a llamar `EsFraccion` y va a ser representable mediante `EsFraccionRep` y es una subcategoría de `IsAdditiveElement`, pues luego vamos a definir una función que sume fracciones. Por último definimos un nuevo tipo de dato que llamaremos `TipoFraccion`, que estará en la familia `FamiliaFracciones`.\n",
    "\n",
    "```\n",
    "DeclareRepresentation(\"EsFraccionRep\", IsAttributeStoringRep, []);\n",
    "DeclareCategory( \"EsFraccion\", EsFraccionRep and IsAdditiveElement);\n",
    "TipoFraccion:=NewType(NewFamily(\"FamiliaFracciones\"), EsFraccion);\n",
    "```\n",
    "\n",
    "## Declarando los atributos, propiedades y métodos\n",
    "\n",
    "Vamos a tener como atributos el numerador y el denominador. \n",
    "\n",
    "```\n",
    "DeclareAttribute(\"Numerador\", EsFraccion);\n",
    "DeclareAttribute(\"Denominador\", EsFraccion);\n",
    "```\n",
    "\n",
    "Como operaciones vamos a definir una simplificación y una suma (que podemos hacerlo al pertenecer nuestra categeoría a la de los elementos con suma). La suma no hace falta declararla, sólo tendremos que definir después un método apropiado.\n",
    " \n",
    "```\n",
    "DeclareOperation(\"Simplifica\", [EsFraccion]);\n",
    "```\n",
    "\n",
    "Vamos además a definir dos propiedades: ser positivo y ser no negativo.\n",
    "\n",
    "```\n",
    "DeclareProperty(\"EsPositivo\", EsFraccion);\n",
    "DeclareProperty(\"EsNoNegativo\", EsFraccion);\n",
    "```\n",
    "\n",
    "## Creando un objeto de tipo `EsFraccion` \n",
    "\n",
    "Vamos a dar una función que, a partir de dos enteros, nos devuelva una fracción.\n",
    "\n",
    "\n",
    "```\n",
    "Fraccion:=function(a,b)\n",
    "    local r;\n",
    "    if not(IsInt(a)) then \n",
    "        Error(\"El primer argumento debe ser un entero\");\n",
    "    fi;\n",
    "\n",
    "    if not(IsInt(b)) or (b=0) then \n",
    "        Error(\"El segundo argumento debe ser un entero no nulo\");\n",
    "    fi;\n",
    "    \n",
    "    r:=Objectify(TipoFraccion, rec());\n",
    "    SetNumerador(r,a);\n",
    "    SetDenominador(r,b);\n",
    "    return r;\n",
    "end;\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2 / 4"
      ]
     },
     "execution_count": 2,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r:=Fraccion(2,4);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Type: (FamiliaFracciones, [ IsComponentObjectRep, IsAttributeStoringRep, IsExtAElement, ... ]), data: fail,>"
      ]
     },
     "execution_count": 3,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "TypeObj(r);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 4,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "EsFraccion(r);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como podemos observar, al crear `r` devuelve `2 / 4`. Ésta es la forma en la que le hemos dicho que represente `r`, y lo que está devolviendo es el objeto `r`. Para ello hemos definido un método `ViewString` para fracciones.\n",
    "\n",
    "```\n",
    "InstallMethod(ViewString, \"mostrar fracciones\", [EsFraccion],\n",
    "    function(x)\n",
    "        return Concatenation(String(Numerador(x)),\" / \",String(Denominador(x)));\n",
    "end);\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para la salida de `Print` podemos definir `String`. \n",
    "\n",
    "```\n",
    "InstallMethod(String, \"fracciones a cadenas\", [EsFraccion],\n",
    "    function(x)\n",
    "        return Concatenation(String(Numerador(x)),\"/\",String(Denominador(x)));\n",
    "end);\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2/4"
     ]
    }
   ],
   "source": [
    "Print(r);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como la función `Fraccion` establece los atributos denominador y numerador, ya podemos pedirle a `gap` que nos los diga."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 6,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Numerador(r);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 7,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Denominador(r);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También hemos definido otra forma \"más bonita\" de representar `r`. Para ello hemos definido el método `Display` para fracciones.\n",
    "```\n",
    "InstallMethod(Display, \"mostrar racionales\", [EsFraccion],\n",
    "    function(x)\n",
    "        local l,s,i;\n",
    "\n",
    "        l:=Maximum(Length(String(Numerador(x))),Length(String(Denominador(x))));\n",
    "        s:=\"\";\n",
    "        for i in [1..l] do\n",
    "            Append(s,\"-\");\n",
    "        od;\n",
    "        Print(Numerador(x),\"\\n\");\n",
    "        Print(s,\"\\n\");\n",
    "        Print(Denominador(x),\"\\n\");\n",
    "        return;\n",
    "end);\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "-\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "Display(r);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las propiedades ser positivo o no negativo se pueden definir como sigue.\n",
    "\n",
    "```\n",
    "InstallMethod(EsPositivo, \"es positivo para fracciones\", [EsFraccion],\n",
    "    function(x)\n",
    "        return Numerador(x)*Denominador(x)>0;\n",
    "end);\n",
    "\n",
    "InstallMethod(EsNoNegativo, \"es positivo para fracciones\", [EsFraccion],\n",
    "    function(x)\n",
    "        return Numerador(x)*Denominador(x)>=0;\n",
    "end);\n",
    "```\n",
    "El hecho de que una fracción sea positiva implica que ésta es no negativa. Podemos por tanto indicarle esto a `gap` para que siempre que sepa que una fracción es positiva y le preguntemos si es negativa, no tenga que hacer ningún cálculo intermedio.\n",
    "```\n",
    "InstallTrueMethod(EsNoNegativo, EsPositivo);\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "TraceMethods([EsNoNegativo]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2 / 4"
      ]
     },
     "execution_count": 10,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r:=Fraccion(2,4);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#I  EsNoNegativo: es positivo para fracciones at ejemplo-objeto.g:31\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 11,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "EsNoNegativo(r);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como `EsNoNegativo` es una propiedad de `r`, si volvemos a preguntar si es no negativo no hará ninguna llamada a ninguna función, pues ya lo tiene almacenado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 12,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "EsNoNegativo(r);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lo mismo ocurre si primero hemos preguntado si es positivo. Le hemos dicho que eso implica ser no negativo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2 / 4"
      ]
     },
     "execution_count": 13,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r:=Fraccion(2,4);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 14,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "EsPositivo(r);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 15,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "EsNoNegativo(r);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "UntraceMethods([EsNoNegativo]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Definamos ahora una función que devuelva la fracción simplificada de una fracción dada.\n",
    "\n",
    "```\n",
    "InstallMethod(Simplifica, \"simplificación para fracciones\", [EsFraccion], \n",
    "    function(x)\n",
    "        local s, d;\n",
    "\n",
    "        d:=Gcd(Numerador(x),Denominador(x));\n",
    "        return Fraccion(Numerador(x)/d,Denominador(x)/d);\n",
    "end);\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1 / 2"
      ]
     },
     "execution_count": 17,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Simplifica(r);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2 / 4"
      ]
     },
     "execution_count": 18,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La igualdad de fracciones y la suma se pueden definir de la siguiente manera.\n",
    "\n",
    "```\n",
    "InstallMethod(\\=, \"igualdad para fracciones\", [EsFraccion, EsFraccion],\n",
    "    function(x,y)\n",
    "        return Numerador(x)*Denominador(y)=Numerador(y)*Denominador(x); \n",
    "end);\n",
    "\n",
    "InstallMethod(\\+, \"suma de fracciones\", [EsFraccion, EsFraccion],\n",
    "    function(x,y)\n",
    "        return Simplifica(Fraccion(Numerador(x)*Denominador(y)+ Numerador(y)*Denominador(x),Denominador(x)*Denominador(y)));\n",
    "end);\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 19,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Simplifica(r)=r;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1 / 1"
      ]
     },
     "execution_count": 20,
     "metadata": {
      "text/plain": ""
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r+r;"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "GAP 4",
   "language": "gap",
   "name": "gap-4"
  },
  "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
}