Une remarque sur le matériel

Une version locale [1] de DGPad a été utilisée sur un Raspberry Pi connecté sur le vidéoprojecteur, avec alternance entre les deux claviers :

• le clavier virtuel de DGPad, cliqué avec la souris du Raspberry Pi ;
• le clavier du Raspberry Pi.

On passe de l’un à l’autre en cliquant sur l’icône que voici :

(enfin pas l’icône ci-dessus dans cet article, la version qui est dans DGPad !)

L’algorithme de résolution des équations du second degré est une fonction ayant trois réels en entrée (a, b et c, les coefficients de l’équation) et calculant un tableau de deux réels, qui sont les deux solutions de l’équation. On doit donc commencer par cliquer [2] sur l’icône que voici :

Cela permet alors de créer des expressions. La première s’appelle, par défaut, « E1 ». On lui donne une valeur, par exemple 1, mais surtout, on définit un intervalle auquel appartient ce nombre, en précisant les bornes dudit intervalle :

On voit ci-dessus qu’au passage a été fournie une description, et que l’expression E1 a été renommée a. Ceci a été fait en cliquant sur l’icône :

On peut d’ailleurs en profiter pour donner un incrément de 0,01 à a. Haha ! Ah ? Ce n’est pas obligatoire mais on est moins surpris par l’affichage des variables lorsqu’on connaît cet incrément. Ceci dit, pour que l’expression soit effectivement dans la figure, on clique sur l’icône

Ensuite, on fait pareil pour créer une expression b∈[-5 ;5] et une expression c∈[-4 ;4]. Le fichier ressemble à quelque chose comme ceci (ne pas hésiter à manipuler les curseurs, il sont là pour ça) :

En fait, le plus long est fait, il ne reste plus qu’à écrire l’algorithme suivant en JavaScript :

• On calcule Δ=b²-4×a×c ;
• On calcule, si possible, une de ses racines carrées (typiquement, celle qui est positive) ; soit r cette racine ;
• On calcule (-b-r)/(2a) et (-b+r)/(2a) qui sont les deux solutions de l’équation ax²+bx+c=0 ; on les place dans une liste qui sera l’objet renvoyé par l’expression-algorithme.

Pour cela, on va créer une nouvelle expression, au besoin en cliquant sur

On y écrit

Delta=b*b-4*a*c

Et déjà, l’expression est égale à 8 (dans l’exemple ci-dessus). En effet, la seule chose qui ait été calculée par l’expression est Δ qui est donc, par défaut, considéré comme la valeur retournée par l’algorithme. Ce principe s’illustrera dans la suite de la construction :

Si c’est avant le point-virgule final, c’est du JavaScript ; si c’est après le point-virgule final, c’est du DGPad

Du coup, en ajoutant simplement un point-virgule final, la valeur affichée par l’expression est «  ??? » :

Delta=b*b-4*a*c;

Ensuite on calcule r :

Delta=b*b-4*a*c; r=Math.sqrt(Delta)

On voit alors s’afficher, en guise de valeur prise par l’expression, la racine de la valeur précédente (avec les réglages initiaux de a, b et c ça donne √8≈2,82). En effet, la définition de r apparaît après le point-virgule et est considérée comme la valeur à retourner. Ensuite il suffit de rajouter un second point-virgule final et le faire suivre de la valeur à retourner. Celle-ci est un tableau contenant (-b-r)/(2*a) comme premier élément, et (-b+r)/(2*a) comme second élément :

Delta=b*b-4*a*c; r=Math.sqrt(Delta); [(-b-r)/(2*a),(-b+r)/(2*a)]

Le résultat, après validation, est ceci :

Essayez maintenant de manipuler les curseurs ci-dessus et regardant comment évolue la solution ; par exemple

• amenez a sur 1, b sur -2 et c sur 1 pour résoudre x²-2x+1=0 soit (x-1)²=0 ; que voit-on ?
• amenez maintenant c sur 1,5 : L’affichage obtenu est à interpréter comme « les solutions ne sont pas des nombres » [3] (ou plus précisément, pas des nombres réels).
• amenez b sur -2 et c sur 1, mais a sur 0 pour obtenir l’équation -2x+1=0 : La solution 1/2 n’est pas affichée, mais elle est considérée comme indéterminée à cause de la division de 0 par 0. L’autre solution est devenue infinie ce qui est cohérent. On voit d’ailleurs ce mouvement vers l’infini et vers 0,5 en approchant doucement de 0 pour le curseur a. Le résultat n’a rien de surprenant du point de vue algorithmique : Un algorithme de résolution des équations du second degré n’est pas adapté à la résolution des équations du premier degré. On peut cependant y remédier en créant un algorithme de résolution plus générale avec un test :

Delta=b*b-4*a*c; r=Math.sqrt(Delta); if(a==0){S=[-c/b]}else{S=[(-b-r)/(2*a),(-b+r)/(2*a)]};S

Il est bien entendu tout-à-fait possible de faire un test sur le signe de Δ pour par exemple envoyer un tableau vide si Δ est négatif et un tableau ne comprenant qu’une solution si celle-ci est unique (c’est-à-dire si Δ est nul). Il est aussi possible d’enrichir la figure en ajoutant l’expression

a*x*x+b*x+c

qui fait apparaître l’outil suivant :

En bougeant les curseurs on voit que lorsque a tend vers 0, la parabole tend vers une droite, et qu’elle ne coupe pas l’axe des abscisses si Δ est négatif. Pour dessiner les axes de coordonnées c’est en bas :

Mais plutôt que de compliquer la figure, on peut la simplifier. Voici les modifications à apporter :

• Considérer Δ comme un nombre complexe de partie imaginaire nulle, en l’écrivant comme un tableau dont le premier élément est b²-4ac et le second élément, 0 ;
• Remplacer sqrt (racine carrée réelle) par csqrt (racines carrées complexes) ; r devient alors un tableau de deux nombres : Les fameuses racines carrées ;
• utiliser l’algèbre linéaire des tableaux pour calculer (-b+r)/(2a) où désigne les deux racines. Pour que des tableaux s’additionnent correctement, il faut remplacer le nombre b par un tableau dont les deux éléments sont égaux à b.

L’expression résolvant l’équation du second degré devient alors

Delta=[b*b-4*a*c,0];r=Math.csqrt(Delta);([-b,-b]+r)/(2*a)

Du coup, comme la valeur renvoyée est un tableau de points, DGPad demande si on ne veut pas dessiner ces points, soit seuls, soit par un segment les joignant :

En choisissant l’option « segment », on a ceci :

Augmentez le curseur c jusqu’à ce que Δ devienne négatif et observez le résultat :-D

Voici le dossier « DGPad en local » qui a été utilisé sur le Raspberry Pi de la présentation :