mathsoftware

8-SageCalculus-modified-checkpoint.ipynb (255164B)

---

 {
  "cells": [
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "# Symbolic expressions\n",
     "\n",
     "**Reference:** [[1](https://doc.sagemath.org/html/en/reference/calculus/sage/symbolic/expression.html)]\n",
     "\n",
     "Last time we saw the basics of symbolic expressions:\n",
     "* How to define and manipulate symbolic expressions\n",
     "* How to introduce new variables (in the Mathematical sense) with `var()`\n",
     "* How to solve equations and inequalities\n",
     "* Some of the Mathematical constants that are included in Sage, and how to approximate them using `n()`\n",
     "\n",
     "Here are some examples to remind you of these basic things:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 1,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "[\n",
       "x == -sqrt(-pi),\n",
       "x == sqrt(-pi)\n",
       "]\n",
       "[\n",
       "z == -sqrt(pi + x^2),\n",
       "z == sqrt(pi + x^2)\n",
       "]\n",
       "[[y < -2], [y > 1]]\n",
       "2*pi + e is approximately 9.00146713563863\n"
      ]
     }
    ],
    "source": [
     "var('y', 'z') # Define new variables (x is already defined by Sage)\n",
     "f = x^2 + pi\n",
     "g = y^2 + y - 2 > 0\n",
     "print( solve(f==0, x) )\n",
     "print( solve(z^2 - f, z) )\n",
     "print( solve(g, y) )\n",
     "print( 2*pi + e, \"is approximately\", n(2*pi + e) )"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Now we will see some more details about solving equations and manipulating their solutions."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Solving equations and inequalities\n",
     "\n",
     "**Reference** [[1](https://doc.sagemath.org/html/en/reference/calculus/sage/symbolic/expression.html)] for the details of `solve()` and `find_root()`, [[2](https://doc.sagemath.org/html/en/reference/calculus/sage/symbolic/relation.html#solving)] for examples.\n",
     "\n",
     "Other than equations and inequalities, we can also solve systems: it is enough to give Sage a list of expressions and a list of variables with respect to which we want to solve. For example the system\n",
     "\n",
     "\\begin{align*}\n",
     "    \\begin{cases}\n",
     "        x + y = 2 \\\\\n",
     "        2x - y = 6\n",
     "    \\end{cases}\n",
     "\\end{align*}\n",
     "\n",
     "Can be solved as"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 2,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
        "[[x == (8/3), y == (-2/3)]]"
       ]
      },
      "execution_count": 2,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "solve([x+y == 2, 2*x - y == 6], [x,y])"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "**Exercise.** Find the intersection of the circle of radius $2$ centered in the origin and the parabula of equation $y=x^2-2x+1$."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "**Solution:** the system is\n",
     "\\begin{align*}\n",
     "    \\begin{cases}\n",
     "    y^2 = x^2 - 2x +1\\\\\n",
     "    x^2 + y^2 = 4\n",
     "    \\end{cases}\n",
     "\\end{align*}"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
        "[[x == -1/2*sqrt(7) + 1/2, y == 1/2*sqrt(7) + 1/2], [x == 1/2*sqrt(7) + 1/2, y == -1/2*sqrt(7) + 1/2], [x == -1/2*sqrt(7) + 1/2, y == -1/2*sqrt(7) - 1/2], [x == 1/2*sqrt(7) + 1/2, y == 1/2*sqrt(7) - 1/2]]"
       ]
      },
      "execution_count": 5,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "var('y')\n",
     "eq1 =  y^2 == x^2-2*x+1\n",
     "eq2 =  x^2 + y^2 == 4\n",
     "solve([eq1, eq2], [x,y])"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### The set of solutions\n",
     "\n",
     "One would expect the result of `solve()` to be a list of solutions, but it is actually a list of expressions (technically it is not a list but a different type of Python collection, but this is not so important)"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "-3\n"
      ]
     }
    ],
    "source": [
     "solutions = solve(x^2-9 == 0, x)\n",
     "solutions[0] # This is the expression 'x == -3'\n",
     "\n",
     "# Using rhs() explained below\n",
     "print(solutions[0].rhs())"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "To read the actual solution without the `x ==` part you can use the `rhs()` or `lhs()` functions, which can be applied to any expression containing a relation operator (like `==`, `<`, `>=`...) and return the *right hand side* and *left hand side* of the expression, respectively"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "rhs: -y + 2\n",
       "lhs: x^2 + y\n"
      ]
     }
    ],
    "source": [
     "f =  x^2+y <= 2-y\n",
     "print(\"rhs:\", f.rhs())\n",
     "print(\"lhs:\", f.lhs())"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "When you solve an inequality or a system, the set of solutions can be more complicated to describe. In this case the result is a list containing lists of expressions that have to be `True` at the same time. It is easier to explain with an example:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 12,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "Simple inequality: [[x < -3], [x > 3]]\n",
       "System of inequalities:\n",
       " [\n",
       "[3 < x, x < 6],\n",
       "[x < -3]\n",
       "]\n"
      ]
     }
    ],
    "source": [
     "print(\"Simple inequality:\", solve(x^2-9 > 0, x))\n",
     "print(\"System of inequalities:\\n\", solve([x^2-9 > 0, x < 6], x))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "In the last example (system of inequalities), Sage is telling us that the system\n",
     "\\begin{align*}\n",
     "    \\begin{cases}\n",
     "        x^2-9 > 9 \\\\\n",
     "        x < 6\n",
     "    \\end{cases}\n",
     "\\end{align*}\n",
     "has two solutions:\n",
     "* $x$ is between $3$ and $6$;\n",
     "* $x$ is less than $-3$.\n",
     "\n",
     "Since in Sage (and in Python) expressions can have at most on relational operator like `<`, the first solution requires two expressions to be described. Hence the \"list of lists\".\n"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "**Exercise.** In the first exercise you were asked to solve a system of equations, but some of its solutions were complex numbers. Select only the real solutions and print them as pairs $(x,y)$."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 24,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "All solutions:\n",
       "[\n",
       "[x == (-1/2*I + 1/2), y == -sqrt(1/2*I + 4)],\n",
       "[x == (-1/2*I + 1/2), y == sqrt(1/2*I + 4)],\n",
       "[x == (1/2*I + 1/2), y == -sqrt(-1/2*I + 4)],\n",
       "[x == (1/2*I + 1/2), y == sqrt(-1/2*I + 4)]\n",
       "]\n"
      ]
     }
    ],
    "source": [
     "# We use a different equation because the first exercise only\n",
     "# had real solutions.\n",
     "var('y')\n",
     "eq1 =  y^2 == x^2-2*x+5\n",
     "eq2 =  x^2 + y^2 == 4\n",
     "solutions = solve([eq1, eq2], [x,y])\n",
     "\n",
     "print(\"All solutions:\")\n",
     "print(solutions)\n",
     "\n",
     "for s in solutions:\n",
     "    #print(\"One solutions is:\", s)\n",
     "    x0 = s[0].rhs()\n",
     "    y0 = s[1].rhs()\n",
     "    if x0 in RR and y0 in RR:\n",
     "        print((x0, y0))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "When solving a system of equations (not inequalities), you can use the option `solution_dict=True` to have the solutions arranged as a *dictionary*, which is a type of Python collection that we did not treat in this course"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 25,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
        "[{x: 8/3, y: -2/3}]"
       ]
      },
      "execution_count": 25,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "solve([x+y == 2, 2*x - y == 6], [x,y], solution_dict=True)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Alternative method for real roots: `find_root()`\n",
     "\n",
     "The `solve()` method is very useful when solving *symbolic* equations, for example when you have two variables and you want to solve for one of them in terms of the other. However, it does not always find explicit solutions.\n",
     "\n",
     "When you want to find an explicit, even if approximate, solution, it can be better to use `find_root()`. This function works *numerically*, which means that it finds an approximation of the root. It only works for real solutions and you need to specify an interval where you want the root to be searched:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 28,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "Using solve():\n",
       " [\n",
       "x == -e^x + 10\n",
       "]\n",
       "Using find_root(): 2.070579904980303\n"
      ]
     }
    ],
    "source": [
     "f = e^x + x - 10\n",
     "print(\"Using solve():\\n\", solve(f, x))\n",
     "print(\"Using find_root():\", f.find_root(0,10))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Evaluating functions\n",
     "\n",
     "If an expression contains only one variable you can evaluate it easily, even if it is not a function."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 29,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "1\n",
       "y + 3 > (y + 3)^2\n"
      ]
     }
    ],
    "source": [
     "var('y')\n",
     "f = x^2-3\n",
     "g = x > x^2\n",
     "\n",
     "print(f(2))\n",
     "print(g(3+y))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "If an expression contains more than one variable, you can specify a value for each of them and they will be substituted in alphabetic order. You can also specify a value only for some of the variables."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 32,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "-2 == 0\n",
       "3*y == 2\n"
      ]
     }
    ],
    "source": [
     "var('y','z')\n",
     "\n",
     "f = y*z^2 - y == z\n",
     "print(f(2, 0))\n",
     "print(f(z = 2))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Symbolic computations\n",
     "\n",
     "Sage can understand and simplify symbolic expressions such as sums (finite or infinite) and products. In the following cell, we compute the following sums using the [`sum()`](https://doc.sagemath.org/html/en/reference/calculus/sage/symbolic/expression.html#sage.symbolic.expression.Expression.sum) function:\n",
     "\n",
     "\\begin{align*}\n",
     "    \\begin{array}{llcc}\n",
     "        (1) & \\sum_{k=0}^nk                 &=&\\frac{n^2+n}{2}\\\\\n",
     "        (2) & \\sum_{k=0}^nk^4               &=&\\frac{6n^5+15n^4+10n^3-n}{30}\\\\\n",
     "        (3) & \\sum_{k=0}^n\\binom nk         &=& 2^n\\\\\n",
     "        (4) & \\sum_{k=0}^\\infty \\frac1{k^2} &=& \\frac{\\pi^2}{6}\n",
     "    \\end{array}\n",
     "\\end{align*}\n",
     "Recall that $\\binom nk=\\frac{n!}{k!(n-k)!}$"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 41,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "(1) 1/2*n^2 + 1/2*n\n",
       "(2) 1/5*n^5 + 1/2*n^4 + 1/3*n^3 - 1/30*n\n",
       "(3) 2^n\n",
       "(4) 1/6*pi^2\n"
      ]
     }
    ],
    "source": [
     "var('k', 'n') # Remember to declare all variables\n",
     "\n",
     "s = []\n",
     "s.append(  sum(k, k, 0, n)  )\n",
     "s.append(  sum(k^4, k, 0, n)  )\n",
     "s.append(  sum(binomial(n,k), k, 0, n) )\n",
     "s.append(  sum(1/k^2, k, 1, infinity)  )\n",
     "\n",
     "for i in range(len(s)):\n",
     "    print(\"({}) {}\".format(i+1, s[i]))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "An alternative notation is `expression.sum(k, a, b)`. There is an analogous [`prod()`](https://doc.sagemath.org/html/en/reference/calculus/sage/symbolic/expression.html#sage.symbolic.expression.Expression.prod) for products."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 43,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
        "factorial(n)^2"
       ]
      },
      "execution_count": 43,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "(x^2).prod(x, 1, n)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Sometimes Sage tries to keep an expression in its original form without expanding out sums and products. To change this behavior you can use the [`expand()`](https://doc.sagemath.org/html/en/reference/calculus/sage/symbolic/expression.html#sage.symbolic.expression.Expression.expand) function:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 44,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "(x + 1)^2 - (x - 1)^2\n",
       "4*x\n"
      ]
     }
    ],
    "source": [
     "f = (x+1)^2 - (x-1)^2\n",
     "print(f)\n",
     "print(f.expand())"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### The Symbolic Ring\n",
     "**Reference:** [[3](https://doc.sagemath.org/html/en/reference/calculus/sage/symbolic/ring.html)]\n",
     "\n",
     "The symbolic expressions that we have seen so far live in a ring called *symbolic ring* and denoted by `SR` in Sage. This ring works like the ring `ZZ` of integers or `RR` of reals numbers. In particular, you can define matrices and other objects using it as a \"basis\"."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 50,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "-b*c + a*d\n",
       "[(-a, 2)]\n"
      ]
     }
    ],
    "source": [
     "var('a', 'b', 'c', 'd')\n",
     "\n",
     "M = matrix([[a,b], [c,d]])\n",
     "print(M.determinant())\n",
     "\n",
     "polring.<x> = SR[]\n",
     "f = x^2 + 2*a*x + a^2\n",
     "print(f.roots())"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "**Exercise.** Compute the eigenvalues of the matrix\n",
     "\\begin{align*}\n",
     "\\begin{pmatrix}\n",
     "\\cos \\alpha & \\sin \\alpha\\\\\n",
     "-\\sin\\alpha & \\cos \\alpha\n",
     "\\end{pmatrix}\n",
     "\\end{align*}"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 55,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "-I\n"
      ]
     }
    ],
    "source": [
     "var('a')\n",
     "M = matrix([[cos(a), sin(a)], [-sin(a), cos(a)]])\n",
     "M.eigenvalues()\n",
     "lam = M.eigenvalues()[0]\n",
     "print(lam(pi/2))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "# Calculus\n",
     "**Reference:** [[4](https://doc.sagemath.org/html/en/reference/calculus/index.html)] for an overview, but most functions are described in [[1](https://doc.sagemath.org/html/en/reference/calculus/sage/symbolic/expression.html)]"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Limits and series\n",
     "\n",
     "**References:** [[5](https://doc.sagemath.org/html/en/reference/calculus/sage/calculus/calculus.html#sage.calculus.calculus.limit)] for limits, [[6](https://doc.sagemath.org/html/en/reference/calculus/sage/symbolic/expression.html#sage.symbolic.expression.Expression.series)] for series\n",
     "\n",
     "You can compute limits"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 59,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "1\n",
       "+Infinity\n"
      ]
     }
    ],
    "source": [
     "var('x')\n",
     "f = sin(x)/x\n",
     "#print(f(0)) # This one gives an error\n",
     "print( f.limit(x=0) )\n",
     "\n",
     "print( (e^(-x)).limit(x=-infinity) )"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "**Exercise.** Compute the constant $e$ using a limit."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 62,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
        "e^x"
       ]
      },
      "execution_count": 62,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "expression = (1+x/n)^n\n",
     "expression.limit(n=infinity)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "You can also specify a direction for the limit. If you don't, Sage assumes that you want to take a two-sided limit."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 63,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "und\n",
       "1\n",
       "-1\n"
      ]
     },
     {
      "data": {
       "image/png": "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\n",
       "text/plain": [
        "Graphics object consisting of 1 graphics primitive"
       ]
      },
      "execution_count": 63,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "f = abs(x)/x  # 1 if x>0, -1 if x<0\n",
     "print( f.limit(x=0) ) # undefined\n",
     "print( f.limit(x=0, dir=\"+\") )\n",
     "print( f.limit(x=0, dir=\"-\") )\n",
     "plot(f)"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 71,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "+Infinity\n",
       "+Infinity\n",
       "+Infinity\n"
      ]
     },
     {
      "data": {
       "image/png": "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\n",
       "text/plain": [
        "Graphics object consisting of 1 graphics primitive"
       ]
      },
      "execution_count": 71,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "f = 1/x^2\n",
     "print( f.limit(x=0) )\n",
     "print( f.limit(x=0, dir=\"+\") )\n",
     "print( f.limit(x=0, dir=\"-\") )\n",
     "plot(f, (x, -10, 10), ymax = 10, ymin = -10)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "There is also the alternative notation `limit(f, x, dir)` which does the same as `f.limit(x, dir)`."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "You can also compute series expansions up to any order. **Watch out:** the notation uses `==` instead of `=` as `limit()` does."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 81,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "1*(x - 1) + (-1/2)*(x - 1)^2 + 1/3*(x - 1)^3 + Order((x - 1)^4)\n",
       "1*x^2 + (-5/6)*x^4 + Order(x^6)\n"
      ]
     }
    ],
    "source": [
     "f = e^x\n",
     "g = sin(x) - 2*cos(x)\n",
     "h = log(x)\n",
     "\n",
     "#print(f.series(x==0, 5))\n",
     "#print(g.series(x==0, 7))\n",
     "print(h.series(x==1, 4))\n",
     "\n",
     "print((sin(x)^2*cos(x)).series(x==0, 6))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Derivatives\n",
     "**References:** [[7](https://doc.sagemath.org/html/en/reference/calculus/sage/symbolic/expression.html#sage.symbolic.expression.Expression.derivative)] and [[8](https://doc.sagemath.org/html/en/reference/calculus/sage/calculus/functional.html#sage.calculus.functional.derivative)] for derivatives, [[9](https://doc.sagemath.org/html/en/reference/calculus/sage/calculus/functions.html#sage.calculus.functions.jacobian)] for the Jacobian matrix and [[10](https://doc.sagemath.org/html/en/reference/calculus/sage/symbolic/expression.html#sage.symbolic.expression.Expression.hessian)] for the Hessian."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "When computing derivatives, you need to specify with respect to which variables you want to derive, except in case there is only one."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 84,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "8*y^3\n",
       "6*x^2 - 1\n"
      ]
     }
    ],
    "source": [
     "var('y')\n",
     "print( (x^2+2*y^4).derivative(y) ) # Alternative: derivative(f, y)\n",
     "print( (2*x^3-x+2).derivative() )"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "You can also compute higher order derivatives:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 85,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "6*x\n",
       "84*x^5*y + 10*y^4 + 24*x^2*y\n",
       "1680*x^3 + 48\n"
      ]
     }
    ],
    "source": [
     "print( (x^3).derivative(x, x) ) # Same as (x^3).derivative(x, 2)\n",
     "\n",
     "f = x^7*y^2 + x^4*y^2 - 2*x^3 + x^2*y^5 + y + 2\n",
     "print( f.derivative(x, x, y) )    # Twice in x, once in y\n",
     "print( f.derivative(x, 4, y, 2) ) # 4 times in x, twice in y"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Jacobian and Hessian matrices are also easy to compute:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 86,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "[-2*x + 2*y        2*x]\n",
       "[         0      3*y^2]\n",
       "[     y + 1      x + 1] \n",
       "\n",
       "[         2   -4*y + 1]\n",
       "[  -4*y + 1 -4*x + 6*y]\n"
      ]
     }
    ],
    "source": [
     "f = (-x^2 + 2*x*y, y^3, x+y+x*y)\n",
     "print( jacobian(f, [x,y]), \"\\n\" )\n",
     "\n",
     "g = x^2 + x*y + y^3 -2*x*y^2 -3\n",
     "print( g.hessian() )"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "*Note:* the notation `f.jacobian([x,y])` is also valid, but only if you specify that `f` is vector by declaring it as `f = vector([...])`."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Integrals\n",
     "**References:** [[11](https://doc.sagemath.org/html/en/reference/calculus/sage/symbolic/integration/integral.html)] for symbolic integration and [[12](https://doc.sagemath.org/html/en/reference/calculus/sage/calculus/integration.html)] for numerical methods.\n",
     "\n",
     "You should remember from high school or from your first calculus/analysis course that derivatives are easy, but integrals are hard.\n",
     "When using a computer software to solve your integrals, you have two choices:\n",
     "\n",
     "1. You can try to compute a primitive function exactly, and then (if you are computing a definite integral) substitute the endpoints of your integration interval to get the result. We can call this *symbolic integration*.\n",
     "2. You can get an *approximated* result with a *numerical method*. This method always gives some kind of result, but it cannot be used to compute indefinite integrals.\n",
     "\n",
     "Sage can do both of these things, although people that work in numerical analysis and use often the second method tend to prefer other programs, such as Matlab (or its open-source clone Octave)."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Symbolic integration\n",
     "\n",
     "Symbolic integrals work more or less like derivatives. You must specify an integration variable, but the endpoints of the integration interval are optional. If they are not given you get an indefinite integral."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 88,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "1/2*x^2 - cos(x)\n",
       "0\n",
       "1/2*pi^2 + 2\n"
      ]
     }
    ],
    "source": [
     "var('a', 'b')\n",
     "f = x + sin(x)\n",
     "print( f.integral(x) ) # Alternative: integral(f, x)\n",
     "print( f.integral(x, -10, 10) )\n",
     "print( f.integral(x, 0, pi) )"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Your endpoints can also be $\\pm\\infty$:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 89,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "1\n",
       "sqrt(pi)\n"
      ]
     }
    ],
    "source": [
     "print( integral(e^(-x),   x, 0,         infinity) )\n",
     "print( integral(e^(-x^2), x, -infinity, infinity) )"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "The last function is also an example of an integral that perhaps you might want to compute numerically. In fact:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 92,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "1/2*sqrt(pi)*erf(x)\n",
       "1/2*sqrt(pi)*erf(2) - 1/2*sqrt(pi)*erf(1)\n"
      ]
     }
    ],
    "source": [
     "print( integral(e^(-x^2), x) )\n",
     "print( integral(e^(-x^2), x, 1, 2) )"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Here `erf(x)` denotes the [error function](https://en.wikipedia.org/wiki/Error_function)."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Numerical integration\n",
     "\n",
     "In order to get an explicit value for the computations above, we can use a *numerical* method.\n",
     "\n",
     "The word \"numerical\" does not have much to do with numbers, but it refers to the fact that we are trying to compute explicit results rather than symbolic or algebraic ones. [Numerical analysis](https://en.wikipedia.org/wiki/Numerical_analysis) is the branch of mathematics that studies methods to approximate computations over the real or complex numbers. With these methods there is usually a trade-off between speed and precision.\n",
     "\n",
     "The Sage function [`numerical_integral()`](https://doc.sagemath.org/html/en/reference/calculus/sage/calculus/integration.html#sage.calculus.integration.numerical_integral) takes as a parameter a real-valued one-variable function and the integration endpoints, and it returns both an approximate value for the integral and an error estimate."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 93,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
        "(0.13525725794999466, 1.5016572202374808e-15)"
       ]
      },
      "execution_count": 93,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "numerical_integral(e^(-x^2), 1, 2)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "The result above means, in symbols\n",
     "\\begin{align*}\n",
     "\\int_1^2 e^{-x^2}\\mathrm dx = 0.13525725794999466 \\pm 1.5016572202374808\\times 10^{-15}\n",
     "\\end{align*}\n",
     "\n",
     "There is also a [`monte_carlo_integral()`](https://doc.sagemath.org/html/en/reference/calculus/sage/calculus/integration.html#sage.calculus.integration.monte_carlo_integral) method for functions with more than one variable."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "**Exercise.** Compute the area of the ellipse of equation $y^2+\\left(\\frac x3\\right)^2=1$."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "**Solution:** First, rewrite the equation as:\n",
     "\\begin{align*}\n",
     "y = \\sqrt{1- \\left(\\frac{x}{3}\\right)^2}\n",
     "\\end{align*}"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 104,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "image/png": "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\n",
       "text/plain": [
        "Graphics object consisting of 1 graphics primitive"
       ]
      },
      "metadata": {},
      "output_type": "display_data"
     },
     {
      "data": {
       "text/plain": [
        "3/2*pi"
       ]
      },
      "execution_count": 104,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "y = sqrt(1-(x/3)^2)\n",
     "show(plot(y, xmin=-3.1, xmax=3.1, ymin=-0.2, ymax=1.1))\n",
     "integral(y, x, -3, 3)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Differential equations\n",
     "**Reference:** [[13](https://doc.sagemath.org/html/en/reference/calculus/sage/calculus/desolvers.html)]\n",
     "\n",
     "A [differential equation](https://en.wikipedia.org/wiki/Differential_equation) is an equation involving an unknwon function and its derivatives. They can be of two kinds: *ordinary* differential equations ([ODE](https://en.wikipedia.org/wiki/Ordinary_differential_equation)) and *partial* differential equations ([PDE](https://en.wikipedia.org/wiki/Partial_differential_equation)). The latter involve multivariate functions and their partial derivatives.\n",
     "\n",
     "Differential equations are in general hard to solve *exactly* (or *symbolically*): even a simple equation of the form $f'(x)=g(x)$, where $g(x)$ is someknown function, requires solving the integral $\\int g(x)\\mathrm{d}x$ in order to find $f$, which as we know is not always easy!\n",
     "\n",
     "Theoretical results on differential equations usually ensure the existence and/or uniquess of a solution under certain conditions, but in general they do not give a way to solve them. There exits many methods to find approximate solutions, and some of them are implemented in Sage as well (see [[13](https://doc.sagemath.org/html/en/reference/calculus/sage/calculus/desolvers.html)]). However we will focus on the simple ODEs that can be solved exactly.\n",
     "\n",
     "Let's start with a simple example. Let's find all functions $f(x)$ such that $f'(x)=f(x)$. In order to do so, we need to use the `function()` construct, which allows us to define an \"unknwon\" function inside Sage, like we define variables with `var()`."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 108,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
        "_C*e^x"
       ]
      },
      "execution_count": 108,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "var('x')\n",
     "function('f')\n",
     "equation = derivative(f(x)) == f(x)\n",
     "desolve(equation, f(x)) # f(x) is the unknown function"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "As you can expect, they are all the functions $Ce^x$ for some constant $C$. The constant $C$ plays the same role as the constant in the solution of an integral, but in this case Sage writes it explicitly.\n",
     "\n",
     "We can also specify *initial conditions* for our function. For example we can impose that $f(0)=3$ as follows:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 109,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
        "3*e^x"
       ]
      },
      "execution_count": 109,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "desolve(equation, f(x), (0,3))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "You can also solve *second order* equations, that is equations where the second derivative also appears. In this case if you want to specify an initial condition you should write the triple of values $(x_0, f(x_0), f'(x_0))$."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 112,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
        "-1/2*I*sqrt(2)*sqrt(pi)*integrate(erf(1/2*I*sqrt(2)*x)*e^(-1/2*x^2), x)"
       ]
      },
      "execution_count": 112,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "equation = derivative(f(x), x, 2) + x*derivative(f(x)) == 1\n",
     "desolve(equation, f(x), (0, 0, 0))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "**Exercise.** Use Sage to find out the functions $f(x)$ that satisfy\n",
     "\\begin{align*}\n",
     "    \\begin{array}{rlcrl}\n",
     "        (A) &\n",
     "        \\begin{cases}\n",
     "            f(0)   &= 1\\\\\n",
     "            f'(0)  &= 0\\\\\n",
     "            f''(x) &= -f(x)\n",
     "        \\end{cases}\n",
     "        & \\qquad \\qquad &\n",
     "        (B) &\n",
     "        \\begin{cases}\n",
     "            f(0)   &= 0\\\\\n",
     "            f'(0)  &= 1\\\\\n",
     "            f''(x) &= -f(x)\n",
     "        \\end{cases}\n",
     "    \\end{array}\n",
     "\\end{align*}"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 116,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "cos(x)\n",
       "sin(x)\n",
       "_K2*cos(x) + _K1*sin(x)\n"
      ]
     }
    ],
    "source": [
     "eq = derivative(f(x), x, 2) == -f(x)\n",
     "conditions1 = (0,1,0)\n",
     "conditions2 = (0,0,1)\n",
     "print( desolve(eq, f(x), conditions1) )\n",
     "print( desolve(eq, f(x), conditions2) )\n",
     "print( desolve(eq, f(x)) )"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### A real-world example\n",
     "\n",
     "Differential equations have countless applications in Science, so it would be a shame not to see at least a simple one.\n",
     "\n",
     "Consider an object moving with constant acceleration $a$. Its velocity at time $t$ is described by the formula $v(t) = v(0) + at$. For example an object falling from the sky has acceleration $g\\sim 9.8 m/s^2$ towards the ground, so its velocity is $v(t) = -gt$.\n",
     "\n",
     "However in the real world you need to take into account the air's resistance, which depends (among other things) on the velocity of the object. In this case the acceleration $a(t)$ is not constant anymore, and it satisfies an equation of the form $a(t)=-g -kv(t)$, where $k$ is some constant that may depend on the shape and mass of the object (in practice it may be more complicated than this).\n",
     "\n",
     "Since the acceleration is the derivative of the velocity, we have a differential equation\n",
     "\\begin{align*}\n",
     "    v'(t) = -g -kv(t)\n",
     "\\end{align*}\n",
     "and we can try to solve it with Sage!"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 120,
    "metadata": {},
    "outputs": [],
    "source": [
     "var('t')\n",
     "function('v')\n",
     "g = 9.8\n",
     "k = 1.5\n",
     "conditions = (0, 0) # Start with velocity 0\n",
     "sol = desolve(derivative(v(t)) == -g -k*v(t), v(t), conditions)\n",
     "#plot(sol, xmin=0, xmax = 100)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "If you want to solve this equation symbolically (that is, keeping $g$ and $k$ in symbols) you need to specify that $t$ is the *independent variable* of the equation:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 121,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
        "-(g*e^(k*t) - g)*e^(-k*t)/k"
       ]
      },
      "execution_count": 121,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "var('t', 'g', 'k')\n",
     "function('v')\n",
     "conditions = (0, 0) # Start with velocity 0\n",
     "desolve(derivative(v(t)) == -g -k*v(t), v(t), conditions, ivar=t)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "# Basic data analysis and visualization\n",
     "\n",
     "## Statistics\n",
     "**References:** [[14](https://doc.sagemath.org/html/en/reference/stats/sage/stats/basic_stats.html)]\n",
     "\n",
     "Sage includes the most basic functions for statistical analysis."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 122,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "Values:\t [1, 2, 3, 3, -6, -2, 4, -1, 0, 2, 3, -4, 0]\n",
       "Mean:\t\t\t 5/13\n",
       "Median:\t\t\t 1\n",
       "Mode:\t\t\t [3]\n",
       "Standard deviation:\t 2*sqrt(29/13)\n",
       "Variance:\t\t 116/13\n",
       "Moving average (5): [3/5, 0, 2/5, -2/5, -1, 3/5, 8/5, 0, 1/5]\n"
      ]
     }
    ],
    "source": [
     "L = [1, 2, 3, 3, -6, -2, 4, -1, 0, 2, 3, -4, 0]\n",
     "\n",
     "print(\"Values:\\t\", L)\n",
     "\n",
     "print(\"Mean:\\t\\t\\t\",           mean(L))\n",
     "print(\"Median:\\t\\t\\t\",         median(L))\n",
     "print(\"Mode:\\t\\t\\t\",           mode(L))\n",
     "\n",
     "print(\"Standard deviation:\\t\", std(L))\n",
     "print(\"Variance:\\t\\t\",         variance(L))\n",
     "\n",
     "print(\"Moving average (5):\", moving_average(L,5))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "You can also compare your data to a probability distribution, see [this page](https://doc.sagemath.org/html/en/reference/probability/sage/probability/probability_distribution.html). If you need to do more advanced statistics you should consider using [R](https://www.r-project.org/); you can also use it inside Sage."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Plotting\n",
     "**Reference:** [[15](https://doc.sagemath.org/html/en/reference/plotting/index.html)], more specifically the subsection [[16](https://doc.sagemath.org/html/en/reference/plotting/sage/plot/plot.html)].\n",
     "\n",
     "Some Sage objects can be plotted:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 123,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "image/png": "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\n",
       "text/plain": [
        "Graphics object consisting of 1 graphics primitive"
       ]
      },
      "execution_count": 123,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "f = sin(x)\n",
     "plot(f)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Sage's plotting functions are based on Python's [matplotlib](https://matplotlib.org/).\n",
     "\n",
     "You can give a number of options to adjust the aspect of your plot, see [here](https://doc.sagemath.org/html/en/reference/plotting/sage/plot/plot.html#sage.plot.plot.plot). Let's see some of them:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 129,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "hello\n"
      ]
     },
     {
      "data": {
       "image/png": "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\n",
       "text/plain": [
        "Graphics object consisting of 1 graphics primitive"
       ]
      },
      "metadata": {},
      "output_type": "display_data"
     }
    ],
    "source": [
     "f = sin(x)\n",
     "p = plot(f,\n",
     "     -2*pi, 2*pi,                   # bounds for x\n",
     "     ymin  = -1.1, ymax = 1.1,      # bounds for y\n",
     "     color = \"red\",\n",
     "     title = \"The sin function\",\n",
     "    )\n",
     "print(\"hello\")\n",
     "show(p)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Some of the options are not described precisely in Sage's documentation, but you can find them on [matplotlib's documentation](https://matplotlib.org/stable/contents.html). You can find many examples online for adjusting your plot as you like!"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "If you need to plot more than one object at the time, you can sum two plots and show them together with `show()`:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 134,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "image/png": "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\n",
       "text/plain": [
        "Graphics object consisting of 2 graphics primitives"
       ]
      },
      "metadata": {},
      "output_type": "display_data"
     }
    ],
    "source": [
     "cosine      = plot(cos(x), (x,-pi/2,pi/2), color=\"red\")\n",
     "exponential = plot(exp(x), (x,-2,0.5))\n",
     "\n",
     "show(cosine + exponential) # works like print()"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Finally, there are other types of plots that you can use, like [scatter plots](https://doc.sagemath.org/html/en/reference/plotting/sage/plot/scatter_plot.html#sage.plot.scatter_plot.scatter_plot) and [bar charts](https://doc.sagemath.org/html/en/reference/plotting/sage/plot/bar_chart.html#sage.plot.bar_chart.bar_chart). You can also add [text](https://doc.sagemath.org/html/en/reference/plotting/sage/plot/text.html#sage.plot.text.text) to your plot:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 138,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "image/png": "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\n",
       "text/plain": [
        "Graphics object consisting of 3 graphics primitives"
       ]
      },
      "metadata": {},
      "output_type": "display_data"
     }
    ],
    "source": [
     "b = bar_chart(range(1,10))\n",
     "s = scatter_plot([(1,5), (4,2), (8,8), (4,7)],\n",
     "                 marker = \"*\",       # symbol\n",
     "                 markersize = 100,\n",
     "                 edgecolor  = \"green\",\n",
     "                 facecolor  = \"red\"\n",
     "                )\n",
     "t = text(\"wow, such plot!\", (1, 8), color=\"black\", fontsize=20)\n",
     "show(b + s + t)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Interpolation\n",
     "**References:** [[17](https://doc.sagemath.org/html/en/reference/polynomial_rings/sage/rings/polynomial/polynomial_ring.html#sage.rings.polynomial.polynomial_ring.PolynomialRing_field.lagrange_polynomial)] and [[18](https://doc.sagemath.org/html/en/reference/calculus/sage/calculus/interpolation.html)].\n",
     "\n",
     "When you need to work with a discrete set of data, like measurements of real-world quantities, it can be useful to visualize a \"smoothed out\" version of this data, for example by plotting a function that approximates it.\n",
     "\n",
     "One way to do so is finding the lowest-degree polynomial that passes through all your points. This is called [Lagrange Polynomial](https://en.wikipedia.org/wiki/Lagrange_polynomial)."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 139,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "image/png": "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\n",
       "text/plain": [
        "Graphics object consisting of 3 graphics primitives"
       ]
      },
      "metadata": {},
      "output_type": "display_data"
     }
    ],
    "source": [
     "points = [ (0,1), (1,2), (1.5,0), (2,4), (3,5) ]\n",
     "polring.<x> = QQ[] # you need to specify a polynomial ring\n",
     "lp = polring.lagrange_polynomial(points)\n",
     "show(scatter_plot(points, facecolor=\"red\")\n",
     "     + plot(lp, 0, 3) # slightly different notation for polynomials\n",
     "     + text(lp, (1,8), color=\"black\")\n",
     "    )"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "One can compute the Lagrange Polynomial over any base ring, and it has the advantage that it is a very \"nice\" function (continuous and differentiable as much as you like, with easily computable derivatives and primitives).\n",
     "\n",
     "However, it does not always give you good approximation of your data:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 142,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "image/png": "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\n",
       "text/plain": [
        "Graphics object consisting of 2 graphics primitives"
       ]
      },
      "metadata": {},
      "output_type": "display_data"
     }
    ],
    "source": [
     "R = [x/10 for x in range(-10,10)]\n",
     "L = [1/(1+25*x^2) for x in R]\n",
     "points = [(R[i], L[i]) for i in range(len(L))]\n",
     "polring.<x> = RR[]\n",
     "lp = polring.lagrange_polynomial(points)\n",
     "\n",
     "show(plot(lp, -0.92, 0.82) + scatter_plot(points))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "This particular example is called [Runge's phenomenon](https://en.wikipedia.org/wiki/Runge%27s_phenomenon). For a better approximation you can use a [spline](https://en.wikipedia.org/wiki/Spline_(mathematics)), which is a *piecewise* polynomial function:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 143,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "image/png": "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\n",
       "text/plain": [
        "Graphics object consisting of 2 graphics primitives"
       ]
      },
      "metadata": {},
      "output_type": "display_data"
     }
    ],
    "source": [
     "show(plot(spline(points), -1, 1) + scatter_plot(points))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "A detailed explanation of splines is a good topic for a course of numerical analysis. For this course it is enough that you know that they exist and they can be plotted."
    ]
   }
  ],
  "metadata": {
   "kernelspec": {
    "display_name": "SageMath 9.2",
    "language": "sage",
    "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.8.5"
   }
  },
  "nbformat": 4,
  "nbformat_minor": 4
 }