TP3.sagews

Projet pluridisciplinaire TP3 : Les fonctions en Sage et en python

Dans ce TP, le but est d'approfondir l'utilisation des fonctions en python et en sage. Ce sera l'occasion de voir l'utilisation de quelques commandes spécifique à Sage qui permettent de résoudre de nombreuses équations.

Les fonctions mathématiques Sages

Comme nous l'avons vu au 1er TP, Sage permet de définir simplement des fonctions mathématiques à l'aide d'expressions symboliques comme suit :

f(x) = x^2
plot(f)

Ces fonctions possède un certain nombre de méthodes (comme integrate, derivative, etc...) listées en utilisant la tapant f. et tabulation

f.integrate(x)
f.derivative(x)

En particulier, il est possible d'obtenir le développement de Taylor à l'ordre N d'une fonction à l'aide de la commande taylor.

Définissez une fonction non polynomial continue et dérivable en 0 (par exemple sin(x)). Affichez cette fonction ainsi que son développement limité à l'ordre 1,2 et 3 au voisinage de 0 (avec des couleurs différentes).

Résolution des équations

Sage permet notamment de résoudre de manière exacte de nombreuses équations. Dans l'exemple ci-après, on considère une fonction polynomial dont on cherche les racines. Executez cet exemple.

f(x) = x**4-x**2-x-1
solve(f(x)==0,x)

La fonction solve renvoie la liste des solutions de notre équation. Il est également possible de résoudre des systèmes d'équations (même non linéaires) comme suit :

var('x1 x2 x3')
solve([x1+x2-x3 == 0, x2-x3==-3*x1**2+x3, x3==6*x2-x1],x1,x2,x3)

Remarque : L'instruction initiale permet de définir symboliquement 'x1', 'x2' et 'x3' comme des inconnues. Elle est indispensable pour définir le système qu'on souhaite résoudre.

Donner et résoudre un système permettant de trouver le (ou les) points d'intersections de 2 cercles définis par :

1. un cercle de centre (0,0) et de rayon 2
2. un cercle de centre (0.5,0.75) et de rayon 2.

Tracez ces deux cercles.

Mêmes questions dans le cas où le 2ème cercle a pour centre (3,5) et le même rayon. Commentez la réponse donnée par Sage.

Mêmes questions dans le cas où le 2ème cercle devient une ellipse (trouvez l'équation sur internet). Tracez les deux courbes (le cercle et l'ellipse)

Par ailleurs, lorsque l'on cherche les solutions d'une équation de type $f(x,y)=0$, on peut utiliser implicit_plot et voir sa solution de façon graphique.

var('y')
f(x,y) = x^2 - y^2
implicit_plot(f,(x,-2,2),(y,-2,2))

Utilisez implicit_plot pour afficher un cercle de rayon 1.

Le logiciel sage permet également de résoudre des équations différentielles. Executez l'exemple ci-dessous.

var('t')
x = function('x',t)
equation_differentielle = diff(x,t) == x
sol = desolve(equation_differentielle,x,ics=[0,1])
print sol

Expliquons un peu cet exemple. Ici, on commence par déclarer une variable 't' et une fonction x dépendant de t. La fonction x(t) est ainsi définie symboliquement et on peut l'utiliser pour écrire notre équation différentielle. La fonction diff(x,t) permet de dériver x par rapport à t. Pour obtenir une dérivée d'ordre supérieur, il suffit d'écrire diff(x,t,2) pour l'ordre 2 par exemple. De plus, le terme ics correspond à la définition des conditions initiales (Initial ConditionS). La première valeur de la liste est la valeur initiale de $t$ et la seconde celle de $x(t)$.

Résoudre l'équation différentielle $x^{''}(t) = 3x(t)-4$ avec comme condition initial $x(t=0)=1$ et $x'(t=0)=0$.

Nous propopns dans ce petit exercice de résoudre le problème suivant : une masse est accrochée à un ressort selon le schéma suivant

|Mur|--/\/\/\/\/\--($M$)

On note x(t) la possition de la masse à l'instant t. Le ressort a les caractéristiques suivantes :

• il est au repos lorsque la masse est à une distance $d>0$ du bord
• et il possède une raideur $k>0$

L'équation modèle vérifiée par $x(t)$, en supposant que la masse glisse parfaitement, est : $x^{''}(t) = -k(x(t)-d)$

Résoudre cette équation et afficher la solution. À l'aide de la commande animate, affichez une animation simple permettant de voir la masse (dessiner par exemple par un cercle) bouger au cours du temps. Pour les paramètres, prendre $d=1$ et $k=1$.

Fonctions pythons

Nous venons de (re)voir les fonctions mathématiques en Sage. Dans le TP précédent, nous avons abordé les fonctions pythons. Nous allons revoir un peu ce concept pour voir les différences avec les fonctions Sage (fonctions mathématiques). Commençons par un exemple simple : Ecrivez un appel de la fonction suivante pour qu'elle retourne 13.

def ma_fonction(x,y):
    resultat = x+y
    return resultat

print ma_fonction(3,1)

Définissez une fonction prenant en argument 2 nombres, et qui retourne

• la somme des 2 si le premier nombre est pair
• la différence des 2 si le premier nombre est impair

Indication : On pourra utiliser le symbole % pour connaître la parité d'un nombre

Les fonctions définies comme dans l'exemple précédent sont fondamentalement différentes des fonctions mathématiques que nous avons vues précédemment. Pour vous en convaincre executez le code suivant :

f(x) = x**2
type(f)
type(ma_fonction)

L'une des conséquences importante de cette différence est que les fonctions python ne possèdent pas les mêmes méthodes que les expressions symboliques définissant les fonctions Sage. Par conséquent, on ne peut pas utiliser des instructions du type integrate ou diff sur les fonctions python.

Écrire une fonction python qui prend en argument une fonction mathématique $f$ et un entier $N$, et qui renvoie le 'plot' du développement de taylor à l'ordre $N$ de $f$. On définira $f$ comme une fonction mathématique. Tester votre code en affichant sur un même graphique $f$ son développement de Taylor.

%html
<p>
    On considère une suite d'instructions données par une liste du type ['h','b','g','d'] indiquant une succesion de déplacement 'haut', 'bas', 'gauche' et 'droite'. Une boule placée en $(0,0)$ se déplace selon cette suite d'instructions. On suppose qu'à chaque déplacement, elle bouge d'une distance $1$.<br>
    <strong>Écrire une fonction prenant en paramètre une liste d'instructions et renvoyant la liste de 'plot' présentant les déplacements de la boule. Créer une animation de cette boule à l'aide de la commande <code>animate</code>.</strong>
</p>

On considère une suite d'instructions données par une liste du type ['h','b','g','d'] indiquant une succesion de déplacement 'haut', 'bas', 'gauche' et 'droite'. Une boule placée en $(0,0)$ se déplace selon cette suite d'instructions. On suppose qu'à chaque déplacement, elle bouge d'une distance $1$.
Écrire une fonction prenant en paramètre une liste d'instructions et renvoyant la liste de 'plot' présentant les déplacements de la boule. Créer une animation de cette boule à l'aide de la commande animate.

Simulation d'un système de $2$ masses oscillantes.

Revenons à notre système Masse - Ressort et essayons d'aller plus loin. On se propose maintenant d'étudier le cas de 2 masses liées entres elles par deux ressorts comme représentée ci-dessous :

|Mur|--/\/\/\/\/\--(M_1)--/\/\/\/\/\--(M_2)

On note cette fois $x_1(t)$ et $x_2(t)$ les positions des masses $M_1$ et $M_2$. Les deux ressorts ont les caractéristiques suivantes :

• le premier ressort à une raideur $k_1$ et est au repos lorsque sa longueur est égale à $d_1$,
• le second ressort à une raideur $k_2$ et est au repos lorsque sa longueur est égale à $d_2$.

Les équations vérifiées par $x_1$ et $x_2$ sont alors : $$\begin{cases} x^{''}_1(t) = -k_1 (x_1-d_1)+ k_2 (x_2 - x_1 -d_2)$8pt] x^{''}_2(t) = -k_2 (x_2 - x_1 -d_2) \end{cases}$$

Pour résoudre ce système d'équations, nous allons procéder en plusieurs étapes :

1. Nous allons le réécrire sous la forme d'un système différentiel d'ordre $1$ en introduisant deux variables $v_1 = x_1'$ et $v_2 = x_2'$
2. Ensuite, on va définir une fonction F(X), où $X = [ x_1,x_2,v_1,v_2]$ tel que $X'(t) = F(X(t))$. Cette fonction F renvoie un vecteur de $4$ éléments.

Définir une fonction python F qui prend en paramètre une liste de quatre variables $X = [x_1, x_2, v_1, v_2]$ et qui retourne $X'(t) = [x_1',x_2',v_1',v_2']$ selon les relations de l'équation différentielle.

k1=1; k2=1; d1 =1; d2 = 1;

Dans le modèle à une seule masse, nous avions effectué une résolution exacte de l'équation différentielle. C'est-à-dire que nous avions obtenu une formule pour $x(t)$. Pour ce nouveau modèle, nous allons faire une résolution numérique : nous allons calucler des valeurs de $x_1(t)$ et $x_2(t)$ à différents temps $t$ mais nous n'aurons pas de formule.

Pour cela, on utilise la fonction desolve_system_rk4 qui prend en paramètre un système d'équation différentielle de type : $$\begin{cases} a^{'}_1(t) = \dots $8pt] a^{'}_2(t) = \dots $8pt] a^{'}_3(t) = \dots $8pt] \dots\end{cases}$$ (Dans notre cas, le système porte sur quatre équations sur $x_1,x_2,v_1,v_2$)

La fonction desolve_system_rk4 prend en premier paramètre une liste contenant la du sytème d'équation et en second paramètre la liste des variables $[a_1,a_2,a_3, \dots]$. Il faudra aussi lui spécifier ivar la variable de dérivation ainsi que les conditions initiales $ics = (0,1,3,0,0)$ (la première valeur est la condition initiale en $t$).

Avec la commande desolve_system_rk4, résoudre l'équation différentielle $X^{'}(t) = F(X)$ en prenant comme condition initiale $\left(t, x_1(0),x_2(0),v_1(0),v_2(0)\right)=(0,1,3,0,0)$.

La fonction desolve_system_rk4 renvoie la solution de notre équation calculée numériquement en une série de temps $t=[t_0,t_1,\cdots,t_n]$. On obtient ainsi une liste dont chaque élément est un tableau composé de $[t_i, x_1(t_i), x_2(t_i), v_1(t_i),v_2(t_i)]$.

Affichez les solutions $x_1(t)$ et $x_2(t)$ obtenues (utilisez pour cela la commande line2d avec comme argument la liste des points $[t_i,x_1(t_i)]$). Comme précemment, créez une animation pour montrer le mouvement des deux masses au cours du temps.