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. Les variables sont parfois substituées par des valeurs, ce qui correspond à évaluer la fonction.
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 :
var('x')
Pour deux variables x et y :
var('x y')
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.).
x*exp(y) - 1
f = x*exp(y) - 1
Évaluation/substitution. Pour évaluer l'expression symbolique, il faut préciser quelle variable doit être substituée.
f(y=0)
f(x=1)
f(x=0, y=1)
f(x=y)
Les expressions symboliques représentant souvent des fonctions, on veut parfois les dériver par rapport à l'une de leurs variables. Pour cela, on peut utiliser la fonction diff() :
diff est l'expression symbolique.var('x y')
f = x*exp(y) - 1
dfx = diff(f, x)
dfy = diff(f, y)
print(dfx)
print(dfy)
d2fx = diff(f, x, 2)
d2fx
Primitives. Pour calculer une primitive d'une fonction, on utilise la fonction integrate. Comme pour diff, le premier argument est la fonction dont on veut trouver une primitive, et le second est la variable.
var('x y')
g = x*exp(x)
integrate(g, x)
f = x*exp(y) - 1
integrate(f, y)
Intégrales. Pour calculer une intégrale, on utilise la même syntaxe en ajoutant les bornes d'intégration
integrate(sin(x), x, 0, pi)
Remarques importantes. Certaines fonctions n'ont pas de primitives/intégrales connues. On vous renvoie alors l'expression symbolique associée
f = sqrt(ln(x**2))
integrate(f, x)
D'autres passent par des fonctions "spéciales" :
f = exp(-x**2)
show(integrate(f, x))
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.
assume(y>0)
integrate(cos(x), x, -y, y)
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.
Par exemple, pour $$ \lim_{t \to a} \frac{1}{1-t} $$ avec différentes valeurs de $a$.
var('t')
h = 1/(1-t)
Si $a = 0$ (point de continuité) :
limit(h, t=0)
Si $a = 1$ (point de divergence) :
limit(h, t=1)
On peut préciser si on veut la limite à gauche ou à droite :
limit(h, t=1, dir="+")
limit(h, t=1, dir="-")
Sage calcule aussi les limites à l'infini :
limit(h, t=+oo)
Sommes finies. On déjà vu la fonction sum() pour sommer les éléments d'une liste. En réalité, elle permet de faire des calculs plus complexes. 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$).
var('n, m')
f = n**2
Si l'on souhaite calculer la somme des termes de $f(0)$ à $f(4)$, la syntaxe est la suivante :
somme = sum(f, n, 0, 4)
print(somme)
On note que le premier argument est l'expression symbolique à évaluer et somme. Le second est la variable. Puis, on donne la première et la dernière valeur que doit prendre la variable.
On peut également somme jusqu'à un entier non-déterminé représenté par une autre variable (ici $m$) :
somme = sum(f, n, 0, m)
print(somme)
Puis, en factorisant l'expression, on reconnaît la formule de sommation $$ \sum_{n=1}^m n^2 = \frac{m(m+1)(2m+1)}{6} $$
show(factor(somme))
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 :
var('n, m')
f = 2**(-n)
somme_geo = sum(f, n, 0, m)
print(somme_geo)
Et on peut en prendre la limite :
limit(somme, m=oo)
Il y a une syntaxe plus directe pour calculer cette série :
sum(f, n, 0, oo)
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.
var('x')
assume(abs(x)<1)
f = x**n
sum(f, n, 0, oo)
Sagemath permet la résolution de certaines équations différentielles. Pour cela, il faut utiliser la fonction desolve.
Prenons l'exemple de l'équation différentielle $$ y'(t) + \frac{1}{t}y(t) = 1 $$
On déclare d'abord y comme une variable de "type fonction" :
var('t')
y = function('y')(t)
Puis, on résout l'équation différentielle avec desolve :
desolve(diff(y,t) + y/t -1 , y)
On observe que Sagemath donne une expression avec une constante non-déterminée _C.
On peut ajouter les conditions initiales, par exemple $y(3) = 7$, avec la syntaxe suivante :
desolve(diff(y,t) + y/t -1 , y, [3,7])
Enfin, on peut également résoudre des équations d'ordre supérieur. Par exemple pour $y'' = y$ :
desolve(diff(y,t,2) - y, y)