PCL1 de math�matiques by vRSYrP

VIEWS: 8 PAGES: 14

									                                    PCL1 de mathématiques

                                       Année 2002-2003

                Utilisation de la calculatrice – Michèle Artaud et Joël Denisot

                                 SEANCE 2 – 5 DECEMBRE 2002

                                    Programme de la séance

1. Résumé de l’épisode précédent

2. Calculs et valeurs approchées

3. Algorithmique et programmation (suite)


1. RESUME DE L’EPISODE PRECEDENT

                               Le contenu de la séance en amphi

1. Ce que l’on attend d’un candidat au CAPES à l’écrit et à l’oral

2. Algorithmique et programmation

disponible sur les pages mathématiques du site de l’IUFM d’Aix-Marseille : www.aix-
mrs.iufm.fr\formations\filieres\mat\index.html


2. CALCULS ET VALEURS APPROCHEES

2.1. Expérimentation numérique

                                                        ln ex 
                                                          1
On considère ici la fonction définie sur  par f(x) =              .
                                                           ex

Calcul de grandes valeurs de f de façon à avoir une idée de sa limite en +.




La limite en + semble être 0.
                                        ln ex 
                                          1                                 ln(1 X)
De fait, on a que la limite en + de               est égale à la limite de          en 0 et vaut
                                           ex                                 X
donc 1.

Une calculatrice comme la TI-83 travaille avec des nombres décimaux en affichant 10 chiffres
et en conservant 13 chiffres.

Ainsi




Et




La TI-89 affiche quant à elle 12 chiffres et travaille avec 14 chiffres ; de plus, dans un certain
nombre de calculs, elle peut travailler en mode « exact ». (Cela dit, dans le cas de la fonction
précédente, elle aboutit au même résultat que la TI-83.)




Regardons alors ce qu’il se passe dans le calcul de l’expression algébrique précédente en
décomposant les calculs.
2.2. Une règle de gestion des calculs

Compte tenu de ce qui précède, il faut prendre garde lorsqu’on additionne de ne pas
additionner des nombres dont les ordres de grandeurs sont trop éloignés. Une règle simple est
d’additionner les nombres dans l’ordre croissant de leur ordre de grandeur (en particulier
lorsque l’on a à déterminer la valeur approchée de la somme d’une série dont le terme général
est une suite décroissant vers 0).

Par exemple, avec une TI-83 la séquence suivante 10-14 + 10-14 + 10-14+ 10-14+ 10-14+ 10-14+
10-14+ 10-14+ 10-14+ 10-14+1 =c 1,0000000000001 (la machine affiche 1 mais la séquence de
calcul (Ans – 1)*1000 donne 1E–10) alors que 1 + 10-14 + 10-14 + 10-14+ 10-14+ 10-14+ 10-14+
10-14+ 10-14+ 10-14+ 10-14 =c 1 (la séquence de calcul précédente affiche 0).

Cela s’explique par le codage des nombres dans la machine qui peut être formalisé de la façon
suivante (les cases grisées ne sont pas prise en compte par la machine dans les chaînes de
calculs) :
1+ 10–14 :
1    .    0     0    0        0   0   0   0   0   0   0   0   0   0   0
+
0    .    0     0    0        0   0   0   0   0   0   0   0   0   0   1
=
1    .    0     0    0        0   0   0   0   0   0   0   0   0   0   1

Et donc c’est assimilé à 0.

Alors que 10–14 + 10–14 donne :
                                  1       –   1   4
+
                                  1       –   1   4
=
                                  2       –   1   4
2.3. Valeurs approchées, valeurs décimales approchées

Soit a un nombre réel donné. Dans les énoncés suivants k, p et m désignent des entiers.

a’ est une approximation (ou valeur approchée) de a à la précision k 10–p
si a’ – a  k 10–p, où 1  k < 10.

La valeur décimale approchée à 10–p près par défaut de a est le plus grand nombre a’ de la
forme m 10–p tel que a’  a.

La valeur décimale approchée à 10–p près par excès de a est le plus petit nombre a’ de la
forme m 10–p tel que a < a’.

On a donc : m 10–p  a  (m+1) 10–p  m 10–p est la valeur décimale approchée à 10–p près
par défaut de a et (m+1) 10–p est la valeur décimale approchée à 10–p près par excès de a.

Remarque : m est donc la partie entière du nombre a 10p.

Exemple

Déterminer une valeur approchée de la racine de x3/3 – x – 1 = 0 à la précision 10-3.
Déterminer la valeur décimale approchée à 10-3 près par excès de cette même racine.


Notons  la racine.
Le programme Dicho vu à la séance précédente avec A = 0,001 donne :




On obtient donc que : 2,10351 <  < 2,10450.

Tout nombre décimal de l’intervalle ]2,10351 ; 2,10450[ est une valeur approchée de  à la
précision 10-3.

En revanche, l’encadrement précédent permet d’obtenir que 2,104 (qui est le seul nombre de
la forme m 10-3, m entier, à appartenir à l’intervalle précédent) est une valeur décimale
approchée à 10-3 près de  sans que l’on sache si c’est la valeur décimale par défaut ou par
excès.

Il faut prendre une précision 10-4 pour conclure :
2,104 est la valeur décimale approchée par excès à 10-3 près de .

On peut remarquer que, avec A = 0,01, on obtenait les valeurs décimales approchées par
excès et par défaut à 10-2 près de 




                                                      2,10 <  < 2,11.


3. ALGORITHMIQUE ET PROGRAMMATION (SUITE)


EXERCICE 1 :
1. Etablir un algorithme permettant d’approximer la racine de x3/3 – x – 1 = 0 localisée dans
l’intervalle [2 ; 2,5] par la méthode de Newton, puis écrire et tester le programme
correspondant.
2. Modifier l’algorithme dichotomie de façon à ce qu’il dépendent des trois paramètres : les
bornes de l’intervalle, la fonction dont on cherche une racine, la précision de
l’approximation ; écrire et tester le programme correspondant.

Question 1
Rappelons la représentation graphique de la fonction f x  x3/3 – x – 1 sur [2 ; 2.5]




La méthode de Newton consiste à remplacer l’arc par la tangente à la courbe au point (a ;
f(a)), ou (b, f(b)) puis de réitérer le procédé en prenant le point (x1, f(x1)) où x1 est l’abscisse
du point d’intersection de la tangente avec l’axe des abscisses (voir ci-dessous).




Elle aboutit donc à la définition de la suite xn+1 = xn – f(xn)/f’(xn), x0 = a ou x0 = b.
On a le théorème de convergence globale suivant :
Si f  C2[a, b] vérifie :
(1) f(a) f(b) < 0
(2)  x  [a, b] f’(x)  0 (stricte monotonie)
(3)  x  [a, b] f”(x)  0 (concavité dans le même sens)
Alors en choisissant x0  [a, b] tel que f(x0)f”(x0) > 0, la suite (xn) définie par x0 et xn+1 = xn –
f(xn)/f’(xn), converge vers l’unique solution  de f(x) = 0 dans [a, b].

Pour une démonstration de ce théorème, voir R. Théodor. Initiation à l’analyse numérique.
Paris : Masson, 1986. pp. 26-29.

Remarque : la condition f(x0)f”(x0) > 0 permet d’assurer que l’on reste dans l’intervalle [a, b]
comme le suggère le contre-exemple suivant.




Dans le cas qui nous occupe, f” étant positive sur l’intervalle [2 ; 2,5], il convient de prendre
x0 = 2,5.

Dans le cas où f” est positive, la suite est décroissante convergeant vers la racine et on a la
                                                  n
majoration suivante : xn+1 –   (1/q)(q(x0 – ))2 , avec q = sup[a, b]|f”|/(2 inf[a, b]|f’|).
Voir par exemple B. Balaguer. La leçon d’analyse au CAPES de mathématiques. Paris :
ellipses, 1999. Pages 324-325.

On a donc ici q = 5/(2x3) = 5/6 et comme (x0 – ) est inférieur à 1/2, on prendra pour test
                    n
d’arrêt (6/5)(5/12)2  E, où E est la précision voulue.

Algorithme Newton (x3/3 – x – 1 = 0)
E, A réels
N entier
Début
Connaître E, précision
2,5  A
0N
tant que (6/5)*(5/12)^(2^N) > E faire
   A – f(A)/f’(A)  A
   N+1N
fintantque
Restituer A
Restituer N
Fin
Programme TI-89
Input « précision e= », e
2,5  a
0n
x^3/3 – x – 1  f(x)
x^2 – 1  g(x)
While (6/5)*(5/12)^(2^n) > e
   a – f(a)/g(a)  a
   n+1n
Endwhile
Disp « a = », a
Disp « n = », n
End


Question 2

Algorithme DICHOTOMIE 0
Y et Z bornes de l’intervalle, réels
X milieu de l’intervalle, réel
A précision de l’approximation, réel
Début
2Y
2,25 Z
0,01 A
tant que Z – Y  A faire
(Y+Z)/2 X
Si X3/3 – X – 1  0
       Alors XY
       Sinon XZ
finsi

fintantque

Restituer Y et Z
fin.

On suppose que la racine est localisée sur un intervalle [y, z] où la fonction est strictement
monotone et tel que la dérivée est non nulle en y ou en z.

La première modification est de demander d’entrer les bornes, la précision. Il faut ensuite
adapter le traitement au cas d’une fonction qui peut être croissante ou décroissante. Le choix
fait dans l’algorithme DICHOTOMIE1 est de tester la croissance de f. On peut s’en dispenser en
testant le signe du produit f(y)f(m) ou celui du produit f(z)f(m) : voir l’algorithme
DICHOTOMIE2.
Algorithme DICHOTOMIE1                          Algorithme DICHOTOMIE2
Y et Z bornes de l’intervalle, réels            Y et Z bornes de l’intervalle, réels
M milieu de l’intervalle, réel                  M milieu de l’intervalle, réel
A précision de l’approximation, réel            A précision de l’approximation, réel
Début                                           Début
Connaître Y                                     Connaître Y
Connaître Z                                     Connaître Z
Connaître A                                     Connaître A
Connaître f(x)                                  Connaître f(x)
f’(x)  g(x)
Si Y > Z faire                                  Si Y > Z faire
   YT                                             YT
   ZY                                             ZY
   TZ                                             TZ
finsi                                           finsi
Si g(Y) > 0 ou g(Z) > 0
Alors C= 1
Sinon
C=0
tant que Z – Y  A et f(M)0 faire              tant que Z – Y  A et f(M)0 faire
   (Y+Z)/2M                                       (Y+Z)/2 M
      Si (f(M)  0 et C= 1) ou (f(M)  0 et C         Si f(M)f(Y)  0
      = 0)                                            Alors MZ
      Alors MY                                       Sinon MY
      Sinon MZ                                       finsi
      finsi                                        fintantque
   fintantque
                                                Si f(M)0
Si f(M)0                                       Alors restituer Y et Z
Alors restituer Y et Z                          Sinon restituer M
Sinon restituer M
fin.                                            fin.


On trouvera ci-dessous le programme correspondant à l’algorithme DICHOTOMIE1.
On ne peut pas demander d’entrer la fonction par l’instruction Input f(x), Input devant être
suivi d’un nom de variable. Pour rendre le programme indépendant de la fonction, on entre au
préalable la fonction en f et sa dérivée en g dans l’écran [HOME] (choix fait ci-dessous) ou en
Y1 et Y2 dans l’éditeur [Y=]. (On peut utiliser directement d(f(x), x) pour les TI-89).
Programme TI-89/92

Programme DICHO1
Prgm
Input “y=”, y
Input “z=”, z
Input “a=”, a
If y > z
    yt
    zy
    tz
EndIf
If g(y) > 0 or g(z) > 0
Then c= 1
Else
c=0
EndIf
1m
If c = 1
Then
While z – y  a and f(m)0
    (y+z)/2m
       If f(m)  0
       Then my
       Else mz
       EndIf
    EndWhile
Else
While z – y  a and f(m)0
    (y+z)/2m
       If f(m)  0
       Then mz
       Else my
       EndIf
    EndWhile
EndIf
If f(m) = 0 Then
Disp « m= », m
Else
Disp « y= », y
Disp « z= », z
EndIf
Endprgm
Exercice 2 : Améliorer le programme FACTPREM de façon à obtenir l’exposant de chaque
diviseur et à diminuer le temps de calcul. Le programmer et le tester sur votre calculatrice.


Traduction TI83+
Version itérative avec les listes : La liste L1 joue le rôle de la liste FACT.
On initialise la liste L1 à { 0 } car la liste vide n'est pas admise...
Puis on rajoute au fur et à mesure les diviseurs avec leur multiplicité en début de liste de façon à
laisser le zéro en fin de liste, puis en fin de programme, on supprime ce zéro gênant en enlevant 1 à la
dimension de L1.

PROGRAM FACTPREM
:Input N
:0K
:{0} L1
:While fPart(N/2)=0
:K+1K
:N/2N
:End
: If K 0
:Then
:augment( { 2, K } , L1)L1
:End
:3D
: While D * D  N
:0K
:While fPart(N/D)=0
:K+1K
:N/DN
:End
: If K  0
:Then
:augment( { D, K } , L1)L1
:End
:D+2D
:End
: If N  1
:Then
:augment( { N, 1 } , L1)L1
:End
: dim(L1) – 1dim(L1)
: DispL1
TI-89/92                     CASIO
:fprem(n)                    ”N''? N
:Prgm                        100Dim List 1
:Local fact,k,d,i            0K
:0k                         0I
:{}fact                     While N-Int(N/2)*2 =0
:While mod(n,2)=0            K+1K
:k+1k                       N/2N
:n/2n                       WhileEnd
:EndWhile                    If K0
:If k0 Then                 Then 2List 1[1]
:augment({2,k},fact) fact   KList 1[2]
:EndIf                       2I
:3d                         IfEnd
:While d*dn                 3D
:0k                         While D*DN
:While mod(n,d)=0            0K
:k+1k                       While N-Int(N/D)*D=0
:n/dn                       K+1K
:EndWhile                    N/DN
:If k0 Then                 WhileEnd
:augment({d,k},fact) fact   If K0
:EndIf                       Then I+2I
:d+2d                       DList 1[I-1]
:EndWhile                    KList 1[I]
:If n1 Then                 IfEnd
:augment({n,1},fact) fact   D+2D
:EndIf                       WhileEnd
:Disp fact                   If N1
:Endprgm                     Then I+2I
                             NList 1[I-1]
                             1List 1[I]
                             IfEnd
                             I
                             List 1 

								
To top