{ "cells": [ { "cell_type": "markdown", "id": "d95678f4", "metadata": {}, "source": [ "# Séance 9\n", "\n", "\n", "```{admonition} Objectifs\n", "* Expressions symboliques\n", "* Fonctions : dérivation, intégration, limites\n", "* Sommes, produits et séries\n", "```\n", "\n", "\n", "\n", "\n", "## Expressions symboliques\n", "\n", "Avec Sagemath, on peut construire des fonctions comme des **expressions symboliques**. Ces expressions sont composées de valeurs (par exemple, des entiers), et de **variables** (au sens mathématique). Les variables pourront ensuite être **substituées** par des valeurs, ce qui correspond à évaluer la fonction.\n", "\n", "**Création de variables.** Pour créer les variables d'une expression symbolique, on utilise le mot-clef `var`. La syntaxe est particulière. Pour une variable `x` :" ] }, { "cell_type": "code", "execution_count": null, "id": "0f76d90a", "metadata": {}, "outputs": [], "source": [ "var('x')" ] }, { "cell_type": "markdown", "id": "4aa6c345", "metadata": {}, "source": [ "**Déclaration d'une expression symbolique.** On peut ensuite créer une expression symbolique en fonction de ces variables, à partir des opérateurs usuels (`+`, `*`, etc.) ou de certaines fonctions mathématiques déjà implantées dans Sagemath (`exp`, `log`, `sin`, etc.)." ] }, { "cell_type": "code", "execution_count": null, "id": "66f97b6a", "metadata": {}, "outputs": [], "source": [ "var('x')\n", "var('y')\n", "\n", "f = x*exp(y) - 1\n", "print(f)\n", "# show(f)" ] }, { "cell_type": "markdown", "id": "63f37780", "metadata": {}, "source": [ "**Substitution.** L'évaluation d'une fonction correspond à la **substitution d'une variable par une valeur**, dans l'expression symbolique associée. Pour effectuer cette substitution, on doit bien préciser quelle variable doit être substituée, et par quoi.\n", "\n", "Par exemple, si l'on souhaite obtenir l'expression symbolique résultant de la substitution de $y$ par $0$ dans $f$, on entre :" ] }, { "cell_type": "code", "execution_count": null, "id": "cbb4ea92", "metadata": {}, "outputs": [], "source": [ "f(y=0)" ] }, { "cell_type": "markdown", "id": "a281beb4", "metadata": {}, "source": [ "Notons que l'expression obtenue dépend encore de la variable $x$.\n", "\n", "De même :" ] }, { "cell_type": "code", "execution_count": null, "id": "9199903a", "metadata": {}, "outputs": [], "source": [ "f(x=1)" ] }, { "cell_type": "markdown", "id": "42fbcd5c", "metadata": {}, "source": [ "On peut aussi substituer plusieurs variables simultanément :" ] }, { "cell_type": "code", "execution_count": null, "id": "a396a9d1", "metadata": {}, "outputs": [], "source": [ "f(x=0, y=1)" ] }, { "cell_type": "markdown", "id": "f8ca2ddb", "metadata": {}, "source": [ "Ou faire une substitution d'une variable par une autre (attention à l'ordre) :" ] }, { "cell_type": "code", "execution_count": null, "id": "362efef6", "metadata": {}, "outputs": [], "source": [ "f(y=x)" ] }, { "cell_type": "markdown", "id": "7e21809c", "metadata": {}, "source": [ "**Développement, factorisation.** Certaines méthodes permettent de modifier la forme de l'expression symbolique. Par exemple, `expand` permet de faire une dévéloppement de toutes les formes factorisées :" ] }, { "cell_type": "code", "execution_count": null, "id": "54dc4300", "metadata": {}, "outputs": [], "source": [ "f = (x+1)**3 + (x+1)*x + x**2\n", "print(f)\n", "print(f.expand())" ] }, { "cell_type": "markdown", "id": "810c040f", "metadata": {}, "source": [ "À l'opposé, la méthode `factor()` permet de factoriser l'expression :" ] }, { "cell_type": "code", "execution_count": null, "id": "c1291f17", "metadata": {}, "outputs": [], "source": [ "g = x**3 + 3*x**2 + 2*x\n", "print(g)\n", "print(g.factor())" ] }, { "cell_type": "markdown", "id": "11976e04", "metadata": {}, "source": [ "Il existe également une méthode `full_simplify()` qui permet de \"simplifier\" des expressions, c'est-à-dire d'en réduire le nombre d'éléments, en appliquant certaines règles de calcul. Voici des exemples :" ] }, { "cell_type": "code", "execution_count": null, "id": "0e3d0ad0", "metadata": {}, "outputs": [], "source": [ "a = (sqrt(2)-1)*(sqrt(2)+1)\n", "print(a)\n", "a = a.full_simplify()\n", "print(a)" ] }, { "cell_type": "code", "execution_count": null, "id": "be9d4905", "metadata": {}, "outputs": [], "source": [ "b = sin(x)**2 + cos(x)**2\n", "print(b)\n", "b = b.full_simplify()\n", "print(b)" ] }, { "cell_type": "markdown", "id": "d7f73ede", "metadata": {}, "source": [ "**Équations et évaluation logique.** Enfin, il est possible de créer des **équations**, en une ou plusieurs variables, sous la forme d'expressions symboliques." ] }, { "cell_type": "code", "execution_count": null, "id": "3a803fc0", "metadata": {}, "outputs": [], "source": [ "equation = (x**3 == 3*x**2 - 2*x)\n", "print(equation)" ] }, { "cell_type": "markdown", "id": "a4b5ca16", "metadata": {}, "source": [ "Ces équations peuvent ensuite être résolues, grâce à la méthode `solve`, qui prend pour paramètre la variable de résolution :" ] }, { "cell_type": "code", "execution_count": null, "id": "aeff8522", "metadata": {}, "outputs": [], "source": [ "solutions = equation.solve(x)\n", "print(solutions)" ] }, { "cell_type": "markdown", "id": "4beb2637", "metadata": {}, "source": [ "On observe que les solutions retournées sont encore exprimées sous la forme d'équations. Si l'on souhaite obtenir les valeurs correspondantes, on peut utiliser les méthodes d'accès `rhs()` (*right-hand side*, partie droite de l'équation) ou `lhs()` (*left-hand side*, partie gauche)." ] }, { "cell_type": "code", "execution_count": null, "id": "ba541bc1", "metadata": {}, "outputs": [], "source": [ "valeurs = [ sol.rhs() for sol in solutions ]\n", "print(valeurs)" ] }, { "cell_type": "markdown", "id": "be9292b3", "metadata": {}, "source": [ "Un autre exemple :" ] }, { "cell_type": "code", "execution_count": null, "id": "09a7c7a8", "metadata": {}, "outputs": [], "source": [ "var('a')\n", "equation = (x**2 == 2*a*x - a**2)\n", "print(equation)\n", "\n", "solutions = equation.solve(x)\n", "print(solutions)\n", "\n", "valeurs = [ sol.rhs() for sol in solutions ]\n", "print(valeurs)" ] }, { "cell_type": "markdown", "id": "3f9f9f90", "metadata": {}, "source": [ "On peut ensuite vérifier si deux expressions symboliques sont équivalentes. Pour cela, on convertit l'expression en une valeur booléenne :" ] }, { "cell_type": "code", "execution_count": null, "id": "fe099ab7", "metadata": {}, "outputs": [], "source": [ "equation = (cos(2*x) == 2*cos(x)**2 - 1)\n", "print(equation)\n", "\n", "b = bool(equation)\n", "print(b)" ] }, { "cell_type": "markdown", "id": "38b61842", "metadata": {}, "source": [ "**Remarque.** Il est possible de restreindre une variable à un certain domaine de définition, grâce au mot-clef `assume`. Cela peut être utile pour la résolution d'équations, pour la simplification, et on le verra par la suite, pour le calcul d'expressions symboliques plus générales. Donnons ici un exemple :" ] }, { "cell_type": "code", "execution_count": null, "id": "22feaeaa", "metadata": {}, "outputs": [], "source": [ "var('t')\n", "f = e**t\n", "\n", "equation = (f > 1)\n", "b = bool(equation)\n", "print(b)\n", "\n", "assume(t > 0)\n", "c = bool(equation)\n", "print(c)" ] }, { "cell_type": "markdown", "id": "2875ac9e", "metadata": {}, "source": [ "## Fonctions\n", "\n", "Les expressions symboliques vont nous permettre de représenter certaines **fonctions** mathématiques, d'une ou de plusieurs variables, et de les manipuler comme telles.\n", "\n", "\n", "### Calcul élémentaire\n", "\n", "**Opérations élémentaires.** On peut ainsi appliquer des opérations usuelles sur les fonctions (addition, multiplication, ... et même composition !)" ] }, { "cell_type": "code", "execution_count": null, "id": "ca5893b5", "metadata": {}, "outputs": [], "source": [ "var('x')\n", "var('y')\n", "f = x*exp(y) - 1\n", "g = 2*x + log(x)\n", "print(f + g)\n", "print(f*g)\n", "print(f/g)\n", "print(f(y=g))" ] }, { "cell_type": "markdown", "id": "a356b474", "metadata": {}, "source": [ "### Dérivation et intégration\n", "\n", "**Dérivation.** On peut vouloir **dériver** des fonctions par rapport à l'une de leurs variables. Pour cela, on peut utiliser la fonction `diff()` :\n", "- Le premier argument de `diff` est l'expression symbolique.\n", "- Ensuite, on ajoute la variable selon laquelle la dérivation doit être faite. \n", "- Enfin, de manière optionnelle, l'ordre de dérivation.\n", "\n", "\n", "Avec une variable, sur la fonction $g : x \\mapsto 2x + {\\rm ln}(x)$ :" ] }, { "cell_type": "code", "execution_count": null, "id": "5beeec9f", "metadata": {}, "outputs": [], "source": [ "g = 2*x + log(x)\n", "g_prime = diff(g, x)\n", "g_seconde = diff(g, x, 2)\n", "\n", "print(g_prime)\n", "print(g_seconde)" ] }, { "cell_type": "markdown", "id": "4cb8d412", "metadata": {}, "source": [ "Avec 2 variables :" ] }, { "cell_type": "code", "execution_count": null, "id": "633cfc75", "metadata": {}, "outputs": [], "source": [ "var('x')\n", "var('y')\n", "f = x*exp(y) - 1\n", "\n", "dfx = diff(f, x)\n", "dfy = diff(f, y)\n", "print(dfx)\n", "print(dfy)" ] }, { "cell_type": "markdown", "id": "cc965d7a", "metadata": {}, "source": [ "**Primitives.** Pour calculer **une** primitive d'une fonction, on utilise la fonction `integral`. Comme pour `diff`, le premier argument est la fonction dont on veut trouver une primitive, et le second est la variable." ] }, { "cell_type": "code", "execution_count": null, "id": "1438f682", "metadata": {}, "outputs": [], "source": [ "g = x*exp(x)\n", "u = integral(g, x)\n", "print(u)" ] }, { "cell_type": "markdown", "id": "eeea530a", "metadata": {}, "source": [ "**Intégrales.** Pour calculer une intégrale, on utilise la même syntaxe en ajoutant les bornes d'intégration :" ] }, { "cell_type": "code", "execution_count": null, "id": "3bbdab8b", "metadata": {}, "outputs": [], "source": [ "integral(sin(x), x, 0, pi)" ] }, { "cell_type": "markdown", "id": "adb2332b", "metadata": {}, "source": [ "**Remarque importante.** Certaines fonctions n'ont pas de primitives/intégrales connues. On vous renvoie alors l'expression symbolique associée" ] }, { "cell_type": "code", "execution_count": null, "id": "412659c9", "metadata": {}, "outputs": [], "source": [ "f = sqrt(ln(x**2))\n", "integral(f, x)" ] }, { "cell_type": "markdown", "id": "a9d3b850", "metadata": {}, "source": [ "D'autres passent par des fonctions \"spéciales\" :" ] }, { "cell_type": "code", "execution_count": null, "id": "478dce11", "metadata": {}, "outputs": [], "source": [ "f = exp(-x**2)\n", "print(f)\n", "print(integral(f, x))\n", "# erf?" ] }, { "cell_type": "markdown", "id": "fd77c484", "metadata": {}, "source": [ "**Remarque avancée.** On peut même placer une variable dans les bornes, mais il faut faire comprendre à Sagemath que cette variable ne peut pas prendre n'importe quelle valeur." ] }, { "cell_type": "code", "execution_count": null, "id": "bfbae48e", "metadata": {}, "outputs": [], "source": [ "assume(y>0)\n", "integral(cos(x), x, -y, y)" ] }, { "cell_type": "markdown", "id": "7eaf17ed", "metadata": {}, "source": [ "### Calcul de limites\n", "\n", "Sagemath permet de calcul de **limites**. Pour cela, on peut utiliser la fonction `limit`. Le premier argument est l'expression symbolique. Le second est de la forme `x=a`, où `x` est la variable et `a` la valeur vers laquelle on souhaite tendre.\n", "\n", "Par exemple, pour\n", "\n", "$$\n", " \\lim_{t \\to a} \\frac{1}{1-t}\n", "$$\n", "\n", "avec différentes valeurs de $a$." ] }, { "cell_type": "code", "execution_count": null, "id": "c85fea89", "metadata": {}, "outputs": [], "source": [ "var('t')\n", "h = 1/(1-t)" ] }, { "cell_type": "markdown", "id": "2e8a71e7", "metadata": {}, "source": [ "Si $a = 0$ (point de continuité) :" ] }, { "cell_type": "code", "execution_count": null, "id": "068cea6f", "metadata": {}, "outputs": [], "source": [ "limit(h, t=0)" ] }, { "cell_type": "markdown", "id": "49405f2b", "metadata": {}, "source": [ "Si $a = 1$ (point de divergence) :" ] }, { "cell_type": "code", "execution_count": null, "id": "0a8557fb", "metadata": {}, "outputs": [], "source": [ "limit(h, t=1)" ] }, { "cell_type": "markdown", "id": "3f2300c3", "metadata": {}, "source": [ "On peut préciser si on veut la limite à gauche ou à droite :" ] }, { "cell_type": "code", "execution_count": null, "id": "d6c39e4e", "metadata": {}, "outputs": [], "source": [ "print(\"À droite :\", limit(h, t=1, dir=\"+\"))\n", "print(\"À gauche :\", limit(h, t=1, dir=\"-\"))" ] }, { "cell_type": "markdown", "id": "fc9ed2e5", "metadata": {}, "source": [ "Sagemath calcule enfin les limites à l'infini :" ] }, { "cell_type": "code", "execution_count": null, "id": "2e518fff", "metadata": {}, "outputs": [], "source": [ "print(limit(h, t=+infinity))\n", "print(limit(h, t=+oo))" ] }, { "cell_type": "markdown", "id": "87a4d783", "metadata": {}, "source": [ "## Sommes et séries\n", "\n", "**Sommes partielles (finies).** La fonction `sum()` permet de sommer les éléments d'une liste :" ] }, { "cell_type": "code", "execution_count": null, "id": "c15c4c7e", "metadata": {}, "outputs": [], "source": [ "L = [1, 8, 1/3]\n", "print(sum(L))" ] }, { "cell_type": "markdown", "id": "149b6d24", "metadata": {}, "source": [ "Ici, on va l'uiliser pour faire des calculs symboliques. Par exemple, on peut effectuer la somme des termes d'une suite. Pour cela, on déclare une variable `n` et une fonction de `n` (ici, $f(n) = n^2$)." ] }, { "cell_type": "code", "execution_count": null, "id": "3da1cb13", "metadata": {}, "outputs": [], "source": [ "var('n')\n", "f = n**2" ] }, { "cell_type": "markdown", "id": "1369969f", "metadata": {}, "source": [ "Puis, si l'on souhaite calculer la somme des termes de $f(0)$ à $f(4)$, la syntaxe est la suivante :" ] }, { "cell_type": "code", "execution_count": null, "id": "89581d96", "metadata": {}, "outputs": [], "source": [ "somme = sum(f, n, 0, 4)\n", "print(somme)" ] }, { "cell_type": "markdown", "id": "b99df2ea", "metadata": {}, "source": [ "On note que le premier argument est l'expression symbolique à évaluer et à sommer. Le second est la variable. Puis, on donne la première et la dernière valeur que doit prendre la variable.\n", "\n", "On peut également somme jusqu'à un **entier non-déterminé** représenté par une autre variable (ici $m$) :" ] }, { "cell_type": "code", "execution_count": null, "id": "77132c75", "metadata": {}, "outputs": [], "source": [ "var('m')\n", "somme = sum(f, n, 0, m)\n", "print(somme)\n", "# show(somme)" ] }, { "cell_type": "markdown", "id": "2091d40b", "metadata": {}, "source": [ "Puis, en factorisant l'expression, on reconnaît la formule de sommation\n", "\n", "$$\n", " \\sum_{n=1}^m n^2 = \\frac{m(m+1)(2m+1)}{6} \n", "$$" ] }, { "cell_type": "code", "execution_count": null, "id": "a8fd1f2e", "metadata": {}, "outputs": [], "source": [ "print(factor(somme))" ] }, { "cell_type": "markdown", "id": "e35650de", "metadata": {}, "source": [ "**Séries.** Sagemath permet également de calcul de somme infinies : les **séries**. Par exemple, pour la série géométrique, les sommes partielles (jusque $m$) sont :" ] }, { "cell_type": "code", "execution_count": null, "id": "3a2f6498", "metadata": {}, "outputs": [], "source": [ "var('n')\n", "var('m')\n", "f = 2**(-n)\n", "\n", "somme_geo = sum(f, n, 0, m)\n", "print(somme_geo)\n", "# show(somme_geo)" ] }, { "cell_type": "markdown", "id": "f6e215c1", "metadata": {}, "source": [ "Et on peut en prendre la limite :" ] }, { "cell_type": "code", "execution_count": null, "id": "50cdd0cf", "metadata": {}, "outputs": [], "source": [ "limit(somme_geo, m=oo)" ] }, { "cell_type": "markdown", "id": "7dfbeeaa", "metadata": {}, "source": [ "Il y a une syntaxe plus directe pour calculer cette série :" ] }, { "cell_type": "code", "execution_count": null, "id": "ff328425", "metadata": {}, "outputs": [], "source": [ "sum(f, n, 0, oo)" ] }, { "cell_type": "markdown", "id": "2f494f37", "metadata": {}, "source": [ "On peut même calculer la série dans un cadre plus général ($x$ quelconque au lieu de $1/2$). Il faut simplement préciser les conditions qui permettent à la série de converger." ] }, { "cell_type": "code", "execution_count": null, "id": "db7b850e", "metadata": {}, "outputs": [], "source": [ "var('x')\n", "assume(abs(x)<1)\n", "\n", "f = x**n\n", "sum(f, n, 0, +oo)" ] }, { "cell_type": "markdown", "id": "92724479", "metadata": {}, "source": [ "## Affichage 3D\n", "\n", "Pour l'affichage 3D, il y a la fonction `plot3d` :" ] }, { "cell_type": "code", "execution_count": null, "id": "7bc66709", "metadata": {}, "outputs": [], "source": [ "var('x y') # ici, je déclare mes variables x et y (la syntaxe est très spéciale...)\n", "plot3d(x**2 + y**2, [-2, 2], [-2, 2], opacity=0.8)" ] }, { "cell_type": "code", "execution_count": null, "id": "f7a60b05", "metadata": {}, "outputs": [], "source": [ "P = plot3d(sqrt(8*(x**2 + y**2)), [-10, 10], [-10, 10], opacity=0.5, frame=False)\n", "Q = plot3d(x + 0.5*y + 12, [-10, 10], [-10, 10], opacity=0.5, frame=False, color=\"red\")\n", "P+Q" ] }, { "cell_type": "markdown", "id": "411a0499", "metadata": {}, "source": [ "## Récapitulatif des instructions à connaître\n", "\n", "**Tableau récapitulatif** des instructions à connaître pour les expressions symboliques :\n", "\n", "| Méthode, fonction, instruction | Description |\n", "|:---:|:---:|\n", "| `var('x')` | Crée un symbole `x` (qui peut être vu comme une variable mathématique) |\n", "| `+`, `-`, `*`, `/`, `**` | Opérations arithmétiques élémentaires |\n", "| `f(x=4)` | Substitue `x` par `4` dans l'expression symbolique `f` (évalue $f$ en $4$) |\n", "| `f.expand()` | Développe l'expression symbolique `f` |\n", "| `f.factor()` | Factorise l'expression symbolique `f` |\n", "| `f.full_simplify()` | Simplifie l'expression symbolique `f` |\n", "| `f == g` | Crée l'équation correspondant à l'égalité entre les expressions `f` et `g` |\n", "| `eq.solve(x)` | Résout selon `x` l'équation `eq` |\n", "| `eq.rhs()` et `eq.lhs()` | Membre de droite et membre de gauche d'une équation `eq` |\n", "\n", "\n", "\n", "\n", "**Tableau récapitulatif** des instructions à connaître pour les fonctions (définies commes des expressions symboliques) :\n", "\n", "| Méthode, fonction, instruction | Description |\n", "|:---:|:---:|\n", "| `diff(f, x, n)` | Fonction `f` dérivée `n` fois selon la variable `x` |\n", "| `integral(f, x)` | Primitive de `f` selon la variable `x` |\n", "| `integral(f, x, a, b)` | Intégrale entre `a` et `b` de `f` selon la variable `x` : $\\int_a^b f(x)dx$ |\n", "| `limit(f, x=a)` | Limite de `f` lorsque `x` tend vers `a` |\n", "| `limit(f, x=a, dir=\"+\")` | Limite de `f` lorsque `x` tend vers `a` par valeurs supérieures (`dir=\"-\"` pour les valeurs inférieures) |\n", "| `infinity` ou `oo` | Symbole infini |\n", "| `sum(L)` | Somme des termes d'une liste |\n", "| `sum(f, n, a, b)` | Calcul de $\\sum_{n=a}^b f(n)$ |" ] } ], "metadata": { "kernelspec": { "display_name": "Sagemath", "language": "python", "name": "sagemath" } }, "nbformat": 4, "nbformat_minor": 5 }