Des notes destinées à éclaircir certains points
ou à apporter d'intéressants suppléments d'information
sont programmées pour apparaître lorsqu'on passe le curseur de souris
sur des icônes telles que
          
Pour des raisons de sécurité, certains navigateurs
bloquent l'apparition de ces notes (programmées en JavaScript) .
Des précieuses informations, exercices, réponses, aidant à comprendre,
à se repérer, à étendre ses connaisances sont alors perdues.

AUTORISEZ DONC VOTRE NAVIGATEUR A OUVRIR CES SCRIPTS !

Résolution d'une équation par encadrements successifs

Accueil
du Site

 
Avant 
Après

OBJECTIF

Donner un exemple de résolution d'équation par algorithme.

Une étude mathématique de l'équation doit préalablement montrer qu'elle a bien une solution dans un intervalle [A ; B] de la variable.
L'exercice est utile si cette solution ne peut pas (ou très difficilement) être trouvée par le calcul mathématique direct.

Une machine ne peut pas donner la valeur exacte de la solution.
Mais elle peut affirmer que la solution se trouve ou non entre deux valeurs qui lui sont soumises.
Quitte à ce que ces valeurs soient aussi proches qu'il est souhaitable en fonction de la précision recherchée.
On notera E l'écart maximal entre ces deux valeurs souhaité.

Le problème est posé ici de cette manière.
Une fonction de x est démontrée continue et croissante dans un intervalle [A ; B] de la variable.
On a démontreé qu'entre x=A et x=B la fonction traverse la valeur que nous notons "V".

L'algorithme est le suivant.:

Initialisation

On réserve des emplacements mémore (on dit des variables)
pour des nombres notés (A,B,C,E)

On donne à la variable A la valeur de la borne inférieure de l'intervalle
dans lequel se trouve la solution d'après l'étude mathématique.
(ex. A=0)
.
On donne à la variable B la valeur de la borne supérieure de ce même intervalle
(es. B=1)..

On fixe la précision avec laquelle on souhaite faire le calcul
en donnant à la variable E la valeur de l'écart maximal souhaité.
(ex. E=0,005)

Algorithme

Réserver une variable C
Tant que (B-A)>E
Faire
{
C = (A+B)/2
Si ( F(C) < Val) alors A reçoit la valeur C
Sinon B reçoit la valeur C
}
Fin du "Tant que...Faire"
Afficher C

//Facultativement, afficher A,B,C,E

Explication

A chaque exécution du "Faire tant que..."
On donne à x la valeur de test "milieu" de l'intervalle [A ; B]

On calcule F(x) pour cette valeur

  • Si F(x) < Val alors x est inférieur à la solution cherchée :
    Il faut augmenter la valeur de la borne inférieure : A prend la valeur de C=(A+B)/2
  • F(x) >Val alors x est supérieur à la solution cherchée
    Il faut diminuer la valeur de la borne supérieure : B prend la valeur de C=(A+B)/2

Recherche algorithmique d'une solution
pour une équation particulière.
Fonction
A(x)=(cos x+1).sin x

Une étude mathématique a montré que cette fonction est :

  • Nullle pour x =0
  • Croît jusqu'à A( / 3) ~1,299 ; son maximum. ( / 3 ~ 1,047 )
  • Puis décroît jusqu'à : A( / 2) =1 ; ( / 2 ~ 1,570 )
    Ici : Val = 1;
  • Qu'elle traverse la valeur 1 pour x dans l'intervalle ]0,1[
x
0
x=?
1
/3 ~ 1,047
/2 ~ 1,570
A(x)
0
1
 
~1,29 Max
1

Nous cherchons la solution de A(x) = 1 pour x dans l'intervalle ]0,1[

Ecrire un algorithme calculant cette solution par interpolations successives
dans l'intervalle ]0,1[ et avec une tolérance E=0.005
Fourchette E ( modifiable )
A
B
B - A
(A+B) / 2
F(C)
n

Le formulaire pour entrée-sortie des données

Ci dessous la partie de script correspondant à la déclaration des différents objets de formulaire
(Boutons pour faire avancer ou reculer - affichages des valeurs, etc.)
Je n'y ai pas porté les éléments de présentation tels que les cadres des tableaux.
Voir cours sur formulaires dans ce même site en :
.

<script language="JavaScript">

<form action="" name="FormCalcul" onFocus='raz()'>

<input type="text" name="nb_E" value="0.005" > //Pour entrer la précison E
<input type="text" name="nb_A" value="0.0"> //Pour afficher la borne A
<input type="text" name="nb_B" value="1.0"> //Pour afficher la borne B
<input type="text" name="B_A"> //Pour afficher B-A
<input type="text" name="nb_C" value="0.5"> //Pour afficher C=(B-A)/2
<input type="text" name="F_de_C)"> //Pour afficher F(C)
<input type="button" name="Bout_Ar" value="Un pas en arri&egrave;re" onClick=PasArriere()>
<input type="button" name="Bout_Av" value="Un pas en avant" onClick=UneSeuleInterpolation()>
<input type="button" name="Bout_RAZ" value="RAZ" onClick=raz() >
<input type="button" name="Bout_Fin" value="D'un seul coup" onClick=CalculDirect()>

</form>

</script>

Remarque : "value" représente soit le texte affiché dans les fenêtres d'affichage des valeurs ; soit le texte apparaissant sur les boutons

.Observez les appels aux fonctions qui traitent les divers boutons lorsqu'ils sont cliqués.

onClick=UneSeuleInterpolation() ; //Calcule et affiche le pas suivant de l'algorithme
onClick=PasArriere() ; //Affiche, sans la recalculer, l'itération précédente mémorisée à chaque pas.
onClick=CalculDirect() ; //Calcule directement le résultat final sans afficher chacune des étapes.
onClick=raz() ; // Calcule et affiche les valeurs de l'état initial au démarrage.


Algorithme complet
La fonction CalculDirect() que nous allons écrire, permet de faire d'un seul coup toutes les Interpolations
jusqu'à obtenir une solution comprise dans la fourchette entrée dans E.
Bouton déclencheur : [D'un seul coup]

//----------------------------------------------------------
function CalculDirect(){
raz(); //Remise à zéro de toutes les variables sauf E

//Initialisation
var e = document.FormCalcul.nb_E.value;
var a= eval( document.FormCalcul.nb_A.value );
var b= eval( document.FormCalcul.nb_B.value );
var c ; var A;
var a_,b_;

//Boucle faire...tant que
   do{

      /Mémorisation de l'itération précédente pour affichage en fin de boucle
      a_= a; b_= b;

      c =(a+b)/2;
      A= F(c);
      if( A < 1 ) a=c; else b=c;
      nb_n_++;

   }
   while((b - a) > e)

//Restitution de l'itération précédente pour affichage en fin de boucle
a = a_; b = b_; nb_n_--;

//Affichage en fin de boucle
document.FormCalcul.nb_n.value = nb_n_;
document.FormCalcul.nb_A.value = a;
document.FormCalcul.nb_B.value = b;
document.FormCalcul.B_A.value = b-a;
document.FormCalcul.nb_C.value = c;
document.FormCalcul.F_de_C.value = F( (a+b)/2 ) ;

alert("Fini");
}
//----------------------------------------------------------



Fonction : UneSeuleInterpolation ( )
Cette séquence permet de réaliser une seule interpolation à partir des valeurs de A et B contenues dans les fenêtres du formulaire.
Ceci pour observer pas à pas l'évolution du calcul.
Bouton déclencheur : [Un pas en avant]
//----------------------------------------------------------
function UneSeuleInterpolation() {
var e = eval(document.FormCalcul.nb_E.value);

// ATTENTION ! (document.FormCalcul.nb_E.value) peut être interprété comme une chaîne de caractères.
// Pour la convertir en nombre, écrire :
e = eval(document.FormCalcul.nb_E.value);

if( isNaN(e) ) {document.FormCalcul.nb_E.value="Nombre incorrect"; return;}
// isNan(e) "is not a number" détecte une entrée erronée.

var a= eval( document.FormCalcul.nb_A.value ); //Le même problème de type de donnée
var b= eval( document.FormCalcul.nb_B.value );
var c ; var A;

if((b - a) > e) {
c = (a+b)/2;
A= F(c);
if( A < 1 ) a=c; else b=c;
c=(a+b)/2;
A= F(c);

//Affichages
document.FormCalcul.nb_A.value = a;
document.FormCalcul.nb_B.value = b;
document.FormCalcul.B_A.value = b-a;
document.FormCalcul.nb_C.value = c;
document.FormCalcul.F_de_C.value = A;
document.FormCalcul.nb_n.value=++nb_n_;
}
else alert("Non ! Déjà : B-A < E ");
}
//----------------------------------------------------------


Fonction PasArrière( )
Cette fonction permet de revenir à l'itération précédente.
Le principe de programmation est de repartir de la situation initiale
et de refaire toutes les itérations jusqu'à celle qui précède l'itération de laquelle on part.
Bouton déclencheur : [ Un pas en arrière ]

// Fonction "PasArriere()"
//----------------------------------------------------------
function PasArriere(){

if(nb_n_== 0){ alert("NON ! n = 0"); return;}

var n0 = nb_n_; //Numéro de la séquence actuelle

//Initialisation des variables
var e = document.FormCalcul.nb_E.value;
raz(); //Remise de toutes les variables A,B,C,nb_n_, à zéro sauf E=e

//Entrée des données
var a= eval( document.FormCalcul.nb_A.value );
var b= eval( document.FormCalcul.nb_B.value );
var c,A;
var a_,b_;

//Boucle faire...tant que
   
do
   {
   //Mémorisation de l'itération précédente pour affichage final
   a_ = a; b_ = b;

   c= (a+b)/2 ;
   A = F(c);
   if( A < 1 ) a=c; else b=c;
   nb_n_++;
   }
   while( ((b-a) > e)&&(nb_n_< n0) );

////Restitution de l'itération précédente pour affichage final
a=a_;b=b_; nb_n_--;

//Affichage
document.FormCalcul.nb_A.value = a;
document.FormCalcul.nb_B.value = b;
document.FormCalcul.B_A.value = b-a;
document.FormCalcul.nb_C.value = (a+b)/2;
document.FormCalcul.F_de_C.value = F( (a+b)/2 );
document.FormCalcul.nb_n.value = nb_n_;
}

//----------------------------------------------------------

Fonctions diverses

// Fonction étudiée
//----------------------------------------------------------------------------
function F(x) { return (Math.cos(x)+1)*Math.sin(x) }
//----------------------------------------------------------------------------

Fonction raz() - Remise à zéro. Initialisation de toutes les variables sauf E (la fourchette) qui peut être fixée par l'utilisateur.
Bouton déclencheur : [ RAZ ].

//----------------------------------------------------------------------------
//Variables globales, c'est à dire qu'elles sont vues de toutes les procédures
var nb_n_= 0;

//---------------------------------------------------
//Remise à zéro de toutes les variables
//A placer dans la balise : < body> onload="raz()" bgcolor="#66CCFF" ...etc...</body>
//Pour qu'elle s'exécute au moment du chargement de la page.

function raz(){
document.FormCalcul.nb_A.value=0.0;
document.FormCalcul.nb_B.value=1.0;
document.FormCalcul.B_A.value=1.0;
document.FormCalcul.nb_C.value=eval((document.FormCalcul.nb_A.value+document.FormCalcul.nb_B.value)/2);
document.FormCalcul.nb_n.value=nb_n_= 0;
document.FormCalcul.F_de_C.value=F(document.FormCalcul.nb_C.value);
nb_n_=0;
}
//NOTE : E ne doit pas être réinitialisé car l'opérateur peut choisir de le changer.

//----------------------------------------------------------------------------


Orientation

Le langage "JavaScipt" Cours pour débutants et Cours structuré. Sommaire :
Application : Résolution d'une équation par encadrements successifs (orienté exploitation)
Application : Résolution d'une équation par encadrements successifs (programmation)
Application : Animation d'images
Application : Grapheur cartésien
Application : Grapheur paramétrique
Application : Grapheur polaire
Un site très intéressant pour les "matheux-informaticiens"
Accès à la page d'accueil générale du site :