{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "091d96ec",
   "metadata": {},
   "source": [
    "# Práctica 1 (tutorial) de Cálculo (I+T)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9dbd454",
   "metadata": {},
   "source": [
    "Esta práctica tiene como objetivo que te familiarices (o repases) el trabajo con hojas de Sage. Si has trabajado con otras versiones de Sage, todo te resultará muy parecido.\n",
    "\n",
    "Los ejercicios de la práctica están marcados en color, pero puedes probar a modificar todo en la hoja para experimentar. Eso sí, en la hoja que vayas a entregar no hagas modificaciones aparte de lo que pidan los ejercicios."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c1cae0e",
   "metadata": {},
   "source": [
    "## Usando la interfaz"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db372de3",
   "metadata": {},
   "source": [
    "Las órdenes se dan a Sage a través de celdas (como el recuadro que hay debajo de este párrafo) donde se escribe el texto a ejecutar. Se ejecuta el contenido de una celda metiéndose en ella (saldrá un recuadro verde alrededor) y pulsando `〈shift〉+〈intro〉` o lo equivalente en tu dispositivo."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f8b1bde",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <strong>Ejercicio 1. </strong>\n",
    "    Ejecuta la celda siguiente. Luego cambia el número dentro del comando y ejecútala otra vez.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f3b0e36d",
   "metadata": {},
   "outputs": [],
   "source": [
    "factor(1234)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d1b38ab",
   "metadata": {},
   "source": [
    "Sage solo muestra el último resultado calculado en la celda. En el ejemplo siguiente se calculan varias cosas pero no se muestran todas, aunque se calculen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7e3e261e",
   "metadata": {},
   "outputs": [],
   "source": [
    "3+3\n",
    "4+4\n",
    "5+5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6d146c9",
   "metadata": {},
   "source": [
    "Si alguna vez quieres usar un comando pero no recuerdas bien su nombre, escribe las primeras letras y pulsa `Tabulador` o equivalente: Sage te lo completará, o bien te dará una lista si hay varias formas de completarlo.\n",
    "\n",
    "Por ejemplo, si queremos factorizar otro número pero no tenemos la línea de arriba para copiarla y pegar, podríamos escribir `fac` y completarlo. Prueba en esta celda vacía."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "155aa5e6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "21f20492",
   "metadata": {},
   "source": [
    "Puedes crear celdas con el `+` que aparece en la barra de arriba. También puedes reordenar celdas, borrar y fusionarlas, etc.\n",
    "\n",
    "Hay dos tipos de celdas, de cálculo y de texto. Puedes usar las de texto para añadir explicaciones de los cálculos. Se puede decorar el texto, añadir fórmulas matemáticas, etc. Puedes hacer clic doble en cualquier texto para ver el código que lo genera.\n",
    "\n",
    "* Las celdas de código tienen a la izquierda un marcador `In` con corchetes, y arriba hay un selector que dirá \"Code\".\n",
    "* Las celdas de texto no tienen marcador a la izquierda, y en el selector pone \"Markdown\"."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20f2311e",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <strong>Ejercicio 2. </strong>\n",
    "    Crea exactamente dos celdas entre los dos párrafos siguientes. La primera celda debe ser de texto y la segunda de código. En la primera escribe varias palabras, pon una de ellas entre asteriscos dobles (**) y ejecútala. En la segunda haz un cálculo y ejecútalo.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d03728b4",
   "metadata": {},
   "source": [
    "Párrafo 1..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3010a9e",
   "metadata": {},
   "source": [
    "Párrafo 2..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8f4882b",
   "metadata": {},
   "source": [
    "Finalmente, puedes pedirle a Sage información de uso de cada comando (en inglés). Si ejecutas la celda siguiente verás una descripción del comando: su sintaxis (qué poner entre paréntesis) y qué hace, con algún ejemplo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9b755b83",
   "metadata": {},
   "outputs": [],
   "source": [
    "factor?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df39e70d",
   "metadata": {},
   "source": [
    "## Calcular"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e9c43e6",
   "metadata": {},
   "source": [
    "Podemos utilizar Sage como cualquier (potente) calculadora científica."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a2bb2ddc",
   "metadata": {},
   "outputs": [],
   "source": [
    "5-5*3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9d427d62",
   "metadata": {},
   "outputs": [],
   "source": [
    "32.323/234.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71ec88e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "2^1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2eb76d59",
   "metadata": {},
   "outputs": [],
   "source": [
    "exp(5.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47a8bb3b",
   "metadata": {},
   "source": [
    "Sage trata de trabajar siempre sin redondeos. Ejecuta las celdas siguientes para verlo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ddc31eb3",
   "metadata": {},
   "outputs": [],
   "source": [
    "1/2+1/3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1ba52030",
   "metadata": {},
   "outputs": [],
   "source": [
    "sin(pi/4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c5af617",
   "metadata": {},
   "outputs": [],
   "source": [
    "(3/4)^23"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "56b619ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "2+pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "98995dd6",
   "metadata": {},
   "outputs": [],
   "source": [
    "e^3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f46c47d",
   "metadata": {},
   "source": [
    "Para forzar a Sage a trabajar numéricamente (aproximando), aplicamos`.n()` tras el número deseado (fíjate en que hay que añadir un punto). Si quieres hacerle esto a un cálculo complejo deberás ponerlo todo entre paréntesis y aproximar ese paréntesis. Una vez que se ha redondeado, los cálculos que usen ese resultado también serán aproximados."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71605390",
   "metadata": {},
   "outputs": [],
   "source": [
    "(e^3).n()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "560f94e2",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <strong>Ejercicio 3. </strong>\n",
    "    Calcula el seno de 90 de manera exacta (quizás no salga lo que esperas). Después calcúlalo aproximadamente. También calcula aproximadamente el valor de $\\frac{1-2^2}{1-2^2+2^3}$, que es -3/5 (al aproximar no te saldrá una fracción, claro).\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77f7d754",
   "metadata": {},
   "source": [
    "## Tipos de datos y variables"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b13066e",
   "metadata": {},
   "source": [
    "Para utilizar posteriormente el resultado de un cálculo, debemos guardarlo en una variable. Al hacerlo Sage no nos mostrará el resultado, porque lo que le pedimos no es enseñar el resultado sino guardarlo. Ejecuta la celda siguiente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e95b8a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "b = 2.0^4+1.0/5+exp(3.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47872321",
   "metadata": {},
   "source": [
    "Para ver el contenido de la variable, basta escribir su nombre y ejecutar la celda."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dbb6125d",
   "metadata": {},
   "outputs": [],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "525e3d35",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "    <strong>Importante:</strong>\n",
    "    aunque tengamos la definición de una variable escrita en la hoja, Sage no conocerá el valor hasta que la ejecutemos.\n",
    "</div>\n",
    "\n",
    "Por ejemplo, de las dos celdas siguientes sáltate la primera y ejecuta solo la segunda: nos dará un error. Aprovecha para leer el contenido del error, a ver si te da información sobre el problema que ha habido.\n",
    "\n",
    "Si ahora ejecutas la primera y la segunda celda en ese orden, todo funcionará como seguramente queríamos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bcdbfc8c",
   "metadata": {},
   "outputs": [],
   "source": [
    "valor = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d3e64ae4",
   "metadata": {},
   "outputs": [],
   "source": [
    "valor"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dfce2d3b",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "    <strong>Moraleja 1: </strong>\n",
    "    solo porque algo esté escrito en una celda no significa que Sage lo haya \"asimilado\".\n",
    "</div>\n",
    "\n",
    "<div class=\"alert alert-block alert-warning\">\n",
    "    <strong>Moraleja 2: </strong>\n",
    "    si ejecutas el código Sage en orden te evitarás problemas.\n",
    "</div>\n",
    "\n",
    "<div class=\"alert alert-block alert-warning\">\n",
    "    <strong>Moraleja 3: </strong>\n",
    "    cuando estés haciendo varios ejercicios en una hoja, muchos problemas se resuelven preguntándose ¿la variable que estoy usando ahora tenía algún valor en otr parte de la hoja?\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3b1926f",
   "metadata": {},
   "source": [
    "Si el resultado no es un número en coma flotante, Sage lo guarda de manera exacta, por lo que tendremos que utilizar `.n()` para ver su valor aproximado si eso es lo que queremos.\n",
    "\n",
    "Por eso, casi siempre es mejor guardar valores exactos; si guardamos uno aproximado todos los cálculos que hagamos con él irán acumulando cada vez más error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a9aba25b",
   "metadata": {},
   "outputs": [],
   "source": [
    "c = 2^4+1/5+exp(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "00926ae0",
   "metadata": {},
   "outputs": [],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c1a65dba",
   "metadata": {},
   "outputs": [],
   "source": [
    "c.n()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26cc06bc",
   "metadata": {},
   "source": [
    "Si asignamos un nuevo contenido a una variable, perdemos su valor anterior."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "79a97d76",
   "metadata": {},
   "outputs": [],
   "source": [
    "d = 0.1\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c78bbf6e",
   "metadata": {},
   "outputs": [],
   "source": [
    "d = 0.2\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0811e27",
   "metadata": {},
   "source": [
    "Podemos hacer las dos cosas a la vez: utilizar su valor y guardarlo de nuevo con el mismo nombre. Asegúrate de entender lo que hace la celda siguiente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6869b573",
   "metadata": {},
   "outputs": [],
   "source": [
    "d = d^2\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a990956",
   "metadata": {},
   "source": [
    "Ahora practicaremos la ejecución desordenada de celdas."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f907fad",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <strong>Ejercicio 4. </strong>\n",
    "    Crea una variable llamada n con el valor 1. En otra celda, calcula n+1 y asígnalo de nuevo a n. Ejecuta esa segunda celda varias veces para \"ir contando\". Muestra el valor final de n en una tercera celda. Si lo\n",
    "haces bien, quien vea tus cálculos pensará que pasa algo muy raro con Sage.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b3585e4",
   "metadata": {},
   "source": [
    "Sage también puede guardar otros objetos dentro de variables. Por ejemplo, A continuación unos vectores y matrices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6a5c305d",
   "metadata": {},
   "outputs": [],
   "source": [
    "v = vector([1,-1,1,1])\n",
    "v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53a40e46",
   "metadata": {},
   "outputs": [],
   "source": [
    "A = matrix([[1, 12, 123, 1234],[2, 23, 234, 2341],[3, 34, 341,3412], [4, 41, 412, 4123]])\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7deb903b",
   "metadata": {},
   "outputs": [],
   "source": [
    "v*A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "608f270f",
   "metadata": {},
   "outputs": [],
   "source": [
    "A^4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7b65a323",
   "metadata": {},
   "outputs": [],
   "source": [
    "det(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "016f196d",
   "metadata": {},
   "source": [
    "## Funciones matemáticas"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c750fb90",
   "metadata": {},
   "source": [
    "Podemos definir una función como lo haríamos en clase. Al ponerle `(x)` después del nombre de variable, Sage entiende que podremos evaluarla, y nos lo indica si le preguntamos por la variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3929eadf",
   "metadata": {},
   "outputs": [],
   "source": [
    "f(x) = x^3+x^2+3\n",
    "f"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "641dd468",
   "metadata": {},
   "source": [
    "Para evaluar la función en un punto, basta sustituir el valor donde pusimos la variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "60409f7f",
   "metadata": {},
   "outputs": [],
   "source": [
    "f(3.02)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2d5670c3",
   "metadata": {},
   "outputs": [],
   "source": [
    "f(pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f3f44a2",
   "metadata": {},
   "source": [
    "Podemos por ejemplo calcular la derivada, integral, etc. de la función, que también son funciones (evaluables). Esta vez lo hacemos con una sintaxis nueva: en vez de poner un comando de Sage y nuestro objeto entre paréntesis, ponemos ese objeto, un punto, y después la operación (siempre con paréntesis). Muchos cálculos básicos se pueden hacer con las dos sintaxis que hemos visto en esta práctica.\n",
    "\n",
    "Por cierto, en la segunda celda a continuación derivamos y evaluamos a la vez, fíjate que cada par de paréntesis vale para una cosa distinta."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eb625919",
   "metadata": {},
   "outputs": [],
   "source": [
    "f.diff(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aa1a7802",
   "metadata": {},
   "outputs": [],
   "source": [
    "f.diff(x)(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5cdd3c6c",
   "metadata": {},
   "outputs": [],
   "source": [
    "f.exp()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eabf811b",
   "metadata": {},
   "source": [
    "Para ver todas las operaciones que podemos hacer con una variable, podemos escribir su nombre seguido de un punto y pulsar `Tabulador`. Pruébalo a continuación con la función que hemos definido, deberías ver una (larga) lista Asegúrate antes de haber ejecutado la celda de arriba donde se guarda la función en la variable. También puedes escribir las primeras letras y autocompletar, como hicimos al principio de la práctica."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fa1da07c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "acaf20fd",
   "metadata": {},
   "source": [
    "Finalmente, hay otra manera de trabajar con funciones y sus variables. En vez de definir la variable con un paréntesis al lado de la función, definimos la variable por separado con `var`. Para evaluar necesitaremos decirle a Sage qué estamos sustituyendo, como en el ejemplo siguiente. Aunque parezca más complicado o más feo, a veces es mucho más conveniente hacerlo así. Posiblemente nos encontraremos situaciones así a lo largo del curso."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "65e48b31",
   "metadata": {},
   "outputs": [],
   "source": [
    "var('y')\n",
    "g = y+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "355c0fcc",
   "metadata": {},
   "outputs": [],
   "source": [
    "g(y=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb647a9e",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <strong>Ejercicio 5. </strong>\n",
    "    En una variable guarda la función coseno (quizás tengas que buscar cómo se llama en Sage). Evalúa la función en $\\pi/2$ (debería salirte un valor que conoces). Después calcula la derivada de la función en $\\pi/4$.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95ebeb89",
   "metadata": {},
   "source": [
    "## Representación gráfica"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d552153",
   "metadata": {},
   "source": [
    "Sage nos permite representar gráficamente todo tipo de objetos: gráficas de funciones, nubes de puntos, superficies en 3D...\n",
    "\n",
    "Empecemos dibujando la función seno entre $-\\pi/2$ y $\\pi/2$. Fíjate en el primer comando; sirve para limpiar la memoria de Sage, para no mezclar cosas antiguas (por ejemplo, a lo mejor ``x`` ha dejado de ser una variable)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fd16de27",
   "metadata": {},
   "outputs": [],
   "source": [
    "reset()\n",
    "f(x) = sin(x)\n",
    "plot(f(x), (x, -pi/2, pi/2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd4feb94",
   "metadata": {},
   "source": [
    "Es posible almacenar una representación gráfica y mostrarla luego usando `.show()`. Así podemos poner opciones adicionales de visualización; la más interesante es cambiar el tamaño como en el ejemplo siguiente. Por cierto,\n",
    "también se puede poner dentro de la misma función `plot`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f36267fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "p = plot(sin(x), (x, -pi/2, pi/2))\n",
    "a = 34\n",
    "b = a^2\n",
    "p.show(figsize=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ccdb692",
   "metadata": {},
   "source": [
    "Cambiemos el color y nombremos los ejes. Después el grosor y el tipo de línea."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bc769908",
   "metadata": {},
   "outputs": [],
   "source": [
    "p = plot(sin(x), (x,-pi/2, pi/2), axes_labels=['x','sin(x)'], color='purple')\n",
    "p.show(figsize=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9c6b2cee",
   "metadata": {},
   "outputs": [],
   "source": [
    "p = plot(sin(x), (x,-pi/2,pi/2), linestyle='--', thickness=5)\n",
    "p.show(figsize=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3ba840b",
   "metadata": {},
   "source": [
    "Se pueden hacer muchísimas cosas gráficas con Sage, pero no las necesitaremos. Puedes ver ejemplos en https://matplotlib.org/stable/gallery/index.html.\n",
    "\n",
    "Algo que sí te puede venir bien es dibujar puntos sueltos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f9210803",
   "metadata": {},
   "outputs": [],
   "source": [
    "point([(0,1), (1,1), (2,3)], figsize=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a94eb720",
   "metadata": {},
   "source": [
    "Es posible representar varias funciones (u otros objetos) en la misma gráfica: simplemente se \"suman\" los objetos. Aquí aprovechamos para ponerle una leyenda a uno de los objetos (no es mala idea si la gráfica está muy llena)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9e7dced1",
   "metadata": {},
   "outputs": [],
   "source": [
    "f(x) = sin(x)\n",
    "g(x) = cos(x)\n",
    "p = plot(f(x),(x,-pi/2,pi/2), color='black')\n",
    "q = plot(g(x), (x,-pi/2, pi/2), color='red')\n",
    "r = point([(0,1), (pi/4,sqrt(2)/2), (pi/2,0)], size=50, color='green', legend_label='puntos importantes')\n",
    "s = p + q + r\n",
    "s.show(figsize=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "173fffd5",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <strong>Ejercicio 6. </strong>\n",
    "    Representa en una misma gráfica las siguientes funciones en el intervalo [0,1], cada una con un estilo diferente. Marca también los puntos de corte entre las funciones (basta hacerlo aproximadamente). Hazlo en tamaño intermedio (entre el tamaño por defecto y el pequeño de los ejemplos) para que se distingan los puntos.\n",
    "$$\n",
    "    3\\,cos(\\pi x),\\qquad 1-e^x,\\qquad \\frac{1}{1+x}\n",
    "$$\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff032dc9",
   "metadata": {},
   "source": [
    "## Consejos para trabajar con Sage"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ecc64b2",
   "metadata": {},
   "source": [
    "* Cuando tengas varios ejercicios en una hoja, trabaja cada uno independientemente, pero ten en cuenta que todo está en una misma hoja. Por ejemplo, si dices `x=3` y más adelante quieres usar `x` como la variable de una función, puedes tener problemas. Puedes usar la función `reset()` para limpiar la memoria de Sage al principio de cada ejercicio, o usar `var` para borrar una variable.\n",
    "* Sage da información sobre los errores que se encuentra. A veces esa información te ayudará y a veces no. Revisa cada línea de código y divide el código en trozos para ver si los resultados intermedios son lo que deberían ser.\n",
    "* Para demostrar que sabes lo que estás haciendo, usa suficientes explicaciones en celdas de texto. Por otra parte, no entregues cosas innecesarias (como un cálculo con resultado muy largo que tú no has mirado después, o imágenes más grandes de lo necesario)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a21c0236",
   "metadata": {},
   "source": [
    "Aquí termina el tutorial. Cuando hayas completado los ejercicios, sigue las instrucciones de entrega en el aula virtual."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "SageMath",
   "language": "python",
   "name": "sagemath"
  },
  "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.13.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}