11 Quelqsuites TNS21

Christian Vassard (IUFM Rouen)
11
C
h
a
p
i
t
r
e

Les exemples de suites ne manquent pas dans la littrature mathmatique, notamment pour calculer
des valeurs approches de constantes clbres. Nous avons choisi ici den traiter trois, sans doute
parmi les plus connues, pour leur double intrt mathmatique et historique. Nous montrerons
combien les outils de la TI-Nspire sont particulirement bien adapts leur tude.
Sommaire
Chapitre 11. Des exemples de suites ................................................................. 195
1. Algorithme de Hron dAlexandrie ........................................................ 196
1.1 Le cadre historique ........................................................................ 196
1.2 Une suite tudier ........................................................................ 198
1.3 Quelques proprits de cette suite ............................................. 199
1.4 tude de la rapidit de convergence de cette suite ................. 200
1.5 Une fonction pour la TI-Nspire .................................................... 202
1.6 Calcul de la partie entire de la racine carre .......................... 206
2. La suite de Fibonacci .............................................................................. 209
2.1 Quelques lments historiques ................................................... 209
2.2 Mathmatisation du problme ..................................................... 210
2.3 Un premier programme ................................................................ 211
2.4 Lapproche par les matrices ......................................................... 214
2.5 Utilisation dune formule explicite ................................................ 215
2.6 Rcursivit et Fibonacci................................................................ 223
3. Calcul dune valeur approche de e. .................................................... 226
3.1 Quelques lments dhistoire ...................................................... 226
3.2 Quelques points thoriques ......................................................... 226
3.3 criture dune fonction .................................................................. 229
3.4 Dune suite lautre ....................................................................... 234
ANNEXE : une division amliore ................................................................... 237

Chapitre 11.
Des exemples de
suites
196 Mathmatiques et TI-Nspire

T France 2010 / Photocopie autorise
1. Algorithme de Hron dAlexandrie
ou comment calculer une valeur approche dune racine carre tout seigneur tout honneur :
lalgorithme dcrit est probablement un des plus anciens de lhistoire des mathmatiques, connu en
particulier des Babyloniens. On le retrouve dans nombre de civilisations Avec Hron, on dispose
dun texte qui lexplicite, mettant laccent sur lide dapproximations successives.
1.1 Le cadre historique
Hron d'Alexandrie (I
er
sicle apr. J.-C.) est un mathmaticien grec la confluence de plusieurs
traditions. Commentateur d'Euclide, il connat bien la grande tradition gomtrique grecque : ainsi les
Mtriques, dont est extrait le texte qui suit, font-elles abondamment usage des rsultats d'Archimde.
Mais Hron nest pas seulement un thoricien : parmi les diffrentes branches des mathmatiques, il
mettait la mcanique au premier rang.
Le texte dcrivant lalgorithme de Hron est tir du clbre Histoire dalgorithmes, Editions Belin,
1994, page 231 :
Puisque 720 na pas de ct rationnel, nous extrairons le ct avec une trs petite diffrence
de la faon suivante. Comme le premier nombre carr plus grand que 720 est 729 qui a pour
ct 27, divise 720 par 27 ; cela fait 26 et
2
3
; ajoute 27, cela fait 53
2
3
; prends-en la moiti,
cela fait 26
1
2

1
3
multipli par lui-mme donne 720
1
36
, de sorte que la diffrence (sur les
carrs) est
1
36
. Si nous voulons rendre cette diffrence infrieure encore
1
36
, nous mettrons
720
1
36
trouv tout lheure la place de 729 et en procdant de la mme faon, nous
trouverons que la diffrence sur les carrs est beaucoup plus petite que
1
36
.
Les mtriques
On remarquera que lon est trs loin dans ce texte du formalisme moderne, avec par exemple
lexpression dune suite clairement dfinie. Signalons aussi lutilisation des quantimes (cest--dire
les inverses de lunit et la fraction 2/3), la manire gyptienne : par exemple 26
1
2

1
3
= 26 +
1
2
+
1
3
.
On pourrait sinterroger sur la gense dun tel algorithme. Quest-ce qui permet de justifier un tel
calcul ? Ce quHron ne dit pas dailleurs Quelques lments peuvent tre donns, mais il nexiste
pas de certitude en la matire.
Raisonnons le plus simplement possible. Hron part dune valeur approche par excs de 720 , soit
27, dont le carr fait 729.
Comme 27
2
> 720, on en dduit par division par 27 des deux membres de lingalit :

720
27
27
> .
Or le produit des deux nombres 27 et
720
27
donne 720 : ncessairement lun est plus grand que 720
on sait que cest 27 , et lautre est plus petit cest donc
720
27
, ce que confirme videmment le
calcul approch de lcran de la page suivante.
Des exemples de suites 197

Bilan : on dispose maintenant dune valeur approche par excs, 27, et dune valeur approche par
dfaut de 720 ,
720
27
. La moyenne arithmtique des deux donne une autre valeur approche, peut-
tre plus prcise...
720
720
27
27
1 720
27
2 27
| |
+
|
\ .

Moyenne arithmtique qui bien sr est plus petite que 27
Dautre part, et cest ce qui va permettre la ritration du processus, comme le suggre Hron, il se
trouve que cette moyenne conduit de nouveau une valeur approche par excs.
Tout simplement dailleurs parce que la moyenne arithmtique de 27 et de
720
27
est plus grande
1
que
leur moyenne gomtrique, qui vaut prcisment
720
27 720
27
= ... Lcran ci-dessus montre aussi
ce rsultat.
Le procd, comme lindique Hron, peut tre poursuivi avec cette nouvelle valeur, et ainsi de suite
aussi loin que ncessaire... Ci-dessous, on saisit dabord 27 en ligne de commande, puis :
1/2 . (ans+720./ans)
2

Puis on appuie sur , puis de nouveau sur , autant de fois quon le souhaite :

1
Comparaison classique et gnrale entre ces deux moyennes... et fort bien connue lpoque de Hron !
2
Remarquer le 720. ou 720.0 pour que le calcul soit approch.

et les calculs peuvent tre mens aussi loin que lon veut. On peut pressentir une convergence vers
720 , sans doute assez rapide.
1.2 Une suite tudier
La mthode vue dans le cas particulier de 720 par Hron dAlexandrie se gnralise sans peine
nimporte quel nombre rel a suprieur 1, en remplaant 720 par a dans la formule prcdente.
Dans un langage moderne
3
, on va donc raisonner avec une suite (u
n
).
En posant
1
( )
2
a
g x x
x
| |
= +
|
\ .
, pour x = 0, elle est dfinie par :
sa valeur initiale u
0
> a ;
et la relation de rcurrence
1
( )
n n
u g u
+
= pour n 0.
Le tableur se prte bien au calcul des termes, comme le montre lcran suivant :

Dans la cellule A1, on note la chane de caractres valeur de a , valeur que lon rentre dans la
cellule B1, et quon mmorise dans la variable a. Le terme initial est choisi dans C1
4
et dans C2, il
reste saisir la relation de rcurrence :
=1/2
.
(c1+a/c1)
quon recopie sur quelques lignes vers le bas.
Notons que pour avoir des valeurs approches des termes successifs, il suffit de mettre 3.0 (ou 3.)
dans la cellule C1 : comme dhabitude, le calcul partir dun nombre virgule se fera pour la
calculatrice en mode approch. Sinon la calculatrice fonctionnera en mode exact.

3
Qui nest pas du tout celui de Hron !
4
Nimporte quelle valeur approche par excs de la racine carre de a convient, si lon sen tient au raisonnement prcdent. Autrement dit
un nombre entier dont le carr dpasse a.
1.3 Quelques proprits de cette suite
Quelques proprits de la suite peuvent alors tre mises en vidence. Elles sont dmontres ci-aprs.
Proposition
La suite (u
n
) est minore par a .
Dmonstration
Montrons dabord que pour tout nombre rel x strictement positif :
( )
1
2
a
g x x a
x
| |
= + >
|
\ .
5
.
En effet, lingalit prcdente quivaut :
2
a
x a
x
+ > 2 0
a
x a
x
+ >
2
0
a
x
x
| |
>
|
|
\ .

Un carr tant toujours positif, cette dernire ingalit est vidente. Elle est dailleurs stricte si on
suppose x = a .
La dmonstration de la proposition peut alors se faire par rcurrence. Il est clair que le premier terme
de la suite u
0
est bien strictement suprieur a ; si lon suppose que pour un entier n arbitraire,
n
u a > , alors ( )
1
1
2
n n n
n
a
u g u u a
u
+
| |
= = + >
|
\ .
daprs le calcul prcdent. Le rsultat est donc
prouv par rcurrence.
Ceci garantit en particulier que u
n
ne sannule jamais, et donc que la suite est bien dfinie pour toute
valeur de n.
Remarquons que si le premier terme vrifie
0
0 u a < < , les termes qui suivent seront tous strictement
suprieur a daprs le rsultat prcdent. Enfin si
0
u a = , alors pour tout entier naturel n,
n
u a = .
Proposition
La suite (u
n
) est strictement dcroissante.
Dmonstration
Ce qui quivaut dmontrer que pour tout entier naturel n 1, u
n + 1
< u
n
.
Diffrentes mthodes peuvent tre utilises.
Une simple, base sur une proprit classique de la moyenne arithmtique.
On sait que, pour tout n, u
n
> a . Donc,
1 1
n
u a
< et
n
a a
a
u a
< = .
Par consquent,
1
1
2
n n
n
a
u u
u
+
| |
= +
|
\ .
, qui est la moyenne arithmtique de deux nombres distincts u
n
et
n
a
u
, est ce titre infrieur strictement au plus grand de ces deux nombres, savoir u
n
.

5
L encore, on peut voir que lingalit est trivialement vraie si lon sait que la moyenne arithmtique de deux nombres positifs est toujours
plus grande que leur moyenne gomtrique...

Une deuxime mthode consiste remarquer que, pour tout n entier naturel,
n
u a > soit
2
n
u a > et
en divisant par u
n
> 0,
n
n
a
u
u
> . Par suite, ( )
1
1 1
2 2
n n n n n
n
a
u u u u u
u
+
| |
= + < + =
|
\ .
.
Enfin, une troisime mthode plus classique consiste tudier le signe de
1 n n
u u
+
.
( )( )
2 2 2
1
2 1
2 2 2 2
n n
n n n
n n n n
n n n n
a u a u
u a u a u a
u u u u
u u u u
+
+
| | +
= + = = =
|
\ .

On peut alors conclure immdiatement.
Bref la suite (u
n
) est bien dcroissante.
Proposition
La suite (u
n
) converge vers a .
Dmonstration
Dcroissante et minore, la suite est convergente. Elle converge vers un rel , qui est un point fixe de
la fonction g.
Il reste rsoudre lquation ( ) x g x = pour dterminer . Cette quation quivaut :
1
2
a
x x
x
| |
= +
|
\ .
soit 2
a
x x
x
= + ou
a
x
x
=
dont les solutions sont clairement a ou a .
Comme la suite est positive, ncessairement, = a et la suite (u
n
) converge vers a .
1.4 tude de la rapidit de convergence de cette suite
Le tableur laisse prsager une convergence trs rapide. En quelques itrations, on obtient les mmes
dcimales que celles renvoyes par la calculatrice. Quen est-il exactement ?
- Convergence rapide
On a pour tout entier naturel n :
( ) ( )
2
1
2 2
2 1
0
2 2
2 2
n n
n n
n n
n n
n
u a u a a
u a u a
u u
u a u a
u a
+
| | +
s = + =
|
\ .

= s

Nous sommes maintenant en mesure de prciser la convergence.
De lingalit prcdente, sachant aussi que a > 1, on dduit que pour tout entier naturel n :
1
0
2
n n
n
u a u a
u a
+

s s

Comme lim 0
2
n
n
u a
+
= , et daprs le thorme des gendarmes, on dduit que la suite

1 n
n
u a
u a
+
| |
|
|
\ .

converge vers 0 : ceci caractrise une convergence rapide.
Plus prcisment la convergence est ici quadratique. En effet, les calculs prcdents ont montr que :
( )
2
1
0
2
n
n
n
u a
u a
u
+
s =
do lon peut dduire que
( )
1
2
1
0
2
n
n
n
u a
u
u a
+

s =
et
( )
1
2
1 1
lim lim
2 2
n
n n
n
n
u a
u a
u a
+
+ +
| |
|
= = e
|
|
\ .
.
Concrtement, dans le calcul approch de a , le nombre de chiffres significatifs des termes de la
suite double chaque itration. En effet si lon connat u
n
avec une erreur infrieure 10
-p
, alors :
( )
2
2
2
1
10
0 10
2 2
p
n
p
n
u a
u a
a a
< < < <

et lon peut dire que u
n + 1
est connu avec une erreur infrieure 10
2p
.
- Majoration de
n
u a
De la majoration obtenue au dbut du paragraphe, on peut dduire les ingalits suivantes :
( )
( )
( )
( )
( )
( )
( )
( )
( )
( )
( )
( )
( )
( )
( )
( )
( )
( )
( )
1
2
2 2
1 1
2 4
2
2 2
1 1 2
2 8
4
3 3
2 2 4
2 16
8
4 4
3 3 8
2 2
2
1 1
2 2
0 donc
2 2
0 donc
2
2
0 donc
2
2
0 donc
2
2
...
0 donc
2
2
n
n
n n
n n
n n
n n
n n
n n
n n
n n
u a u a
u a u a
a a
u a u a
u a u a
a
a
u a u a
u a u a
a
a
u a u a
u a u a
a
a
u a u a
u a u a
a
a

s s s

s s s

s s s

s s s

s s s
( )
( )
( )
( )
2
1
1
2
2 2
2
0 0
1 1
2
0 donc
2
2
n
n
n
n
u a u a
u a u a
a
a

s s s

En faisant le produit membre membre des ingalits de droite entre nombres positifs, on
obtient aprs simplification
6
:

6
Rsultat que lon peut prouver par rcurrence, pour formaliser. Maintenant quon a la formule...

( )
( ) ( )
( ) 1
2 2
0 0
1 2 4 ... 2 2 1
1 1
0
2 2
n n
n n n
u a u a u a
a a
+ + + +
s s =

Lexposant 2
n
est un indicateur de la convergence quadratique signale plus haut.
1.5 Une fonction pour la TI-Nspire
- On peut dduire de cette tude un programme de calcul approch de a o a est un rel > 1. En
entre, peuvent figurer la nombre a, dont on veut calculer la racine carre, et lerreur maximale e que
lon souhaite pour le calcul.
Pour avoir la majoration la plus simple, on peut choisir le terme initial u
0
=
( )
int 1 a +
7
. Comme
0
1 u a < et a > 1, on peut alors crire :
2 1
1
0
2
n
n
u a

| |
s s
|
\ .
.
On peut donc effectuer le calcul des termes successifs de la suite (u
n
) dans une boucle While, en
sortant lorsque
2 1
1
2
n
| |
|
\ .
e. On peut aussi, pour information, renvoyer par Disp la valeur de n.
Le programme est donc le suivant :

Les rsultats que lon obtient sont trs satisfaisants, avec de nombreuses dcimales correctes et peu
ditrations grce la convergence quadratique (/ pour un calcul approch ... ou mieux, on met
comme entre, par exemple, 2.)

7
Cest notre seul appel la fonction racine carre... pour ceux qui trouveraient cela gnant, quils se reportent au paragraphe 1.6
Cinq itrations pour obtenir un rsultat avec autant de dcimales pour 2 , il faut avouer que cest
bien plus rapide que la lente et fastidieuse mthode quon nous enseignait autrefois pour calculer une
valeur approche de nimporte quelle racine carre dentier !
- Allons plus loin avec les possibilits arithmtiques de notre calculatrice, en demandant une
erreur e moindre que 10
-300
:

On rcupre les dcimales avec int(10
350.
ans) : on hrite alors de la trs grande puissance du calcul en
nombres entiers sur TI-Nspire.
En les recopiant avec mon traitement de texte favori, on obtient le terme u
10

de la suite, dans lequel il
est facile de rajouter une virgule la bonne place :
1,41421356237309504880168872420969807856967187537694807317667973799073247846210703
8850387534327641572735013846230912297024924836055850737212644121497099935831413222
6659275055927557999505011527820605714701095599716059702745345968620147285174186408
891986095523292304843087143214508397626036279952514079896872533965463318088296406
2061525835239505474575028
Le calcul derreur peut tre fait. On sait daprs notre tude que :
300
10
2 2 10 u

s s +
do lon dduit lencadrement suivant de 2 :
300
10 10
10 2
s s u u
Sauf erreur de dnombrement, le grand 9 dans lcriture prcdente est le 300
e
chiffre aprs la
virgule du rsultat obtenu et on est sr que 2 est compris entre le nombre ci-dessus et le nombre
que lon obtient en remplaant le 9 par un 8.
- Peut-on aller plus loin ? On risque, en multipliant le rsultat par une puissance de 10 trop grande,
que le calcul ne puisse plus tre men en entiers-calculatrice ou que lon se trouve en situation
doverflow :


La mthode prcdente a des limites, mais elle est intressante pour faire apparatre trs facilement
8

de nombreuses dcimales, bien plus en tout cas que sur une calculatrice classique.
- La plus grande fraction que lon puisse faire apparatre avec cette fonction heron est obtenue en
une dizaine de secondes pour le calcul de 2 avec une prcision moindre que 10
-616

On dispose l dune magnifique valeur approche, avec beaucoup de dcimales mais on ne peut
rien en faire La mthode prcdente est inefficace. Il faut dire que le numrateur est une fraction
gigantesque possdant 784 chiffres !

Dommage dabandonner un si magnifique rsultat car on peut faire agir notre fonction divex2 (voir
lannexe de ce chapitre), stocke dans la bibliothque division_dec pour rcuprer par exemple 620
dcimales de cette fraction. En ligne de commande, il faut saisir division_dec\divex2(ans,620), pour
obtenir le rsultat dans une chane de caractre :

8
Par exemple lors dun concours, CAPES ou autre.
Le rsultat copi dans le presse-papier et coll ci-dessous est impressionnant (le grand 6 est la
616
e
dcimale) :
"1.4142135623730950488016887242096980785696718753769480731766797379907324784
621070388503875343276415727350138462309122970249248360558507372126441214970
999358314132226659275055927557999505011527820605714701095599716059702745345
968620147285174186408891986095523292304843087143214508397626036279952514079
896872533965463318088296406206152583523950547457502877599617298355752203375
318570113543746034084988471603868999706990048150305440277903164542478230684
929369186215805784631115966687130130156185689872372352885092648612494977154
218334204285686060146824720771435854874155657069677653720226485447015858801
6207584749226572260020"
Daprs lerreur demande et le fait que la suite dcroisse vers sa limite, on peut tre sr que 2 est
compris entre ce nombre, dont nous navons dailleurs quune partie des dcimales, et le nombre
obtenu en remplaant le grand 6, qui est la 616
e
dcimale, par un 5. Jolie performance !
- Toujours plus, car lerreur est en ralit plus petite ! On connat ici la valeur de a, ici 2 : on se
souvient que lerreur est en ralit majore par :
( )
( )
2
0
2 1
1
2
n
n
u a
a

dont on peut calculer une valeur approche, si lon prend toutefois la prcaution de sparer le
calcul en deux morceaux (pour cause dunderflow, avec un message davertissement cette fois en bas
de lcran) :

Bref, le produit en question, cest--dire lerreur que lon cherche estimer, vaut approximativement
10,4 10
1401
~ 10
1400
.

Dans le calcul de u
10
, on peut donc sattendre avoir environ 1400 chiffres aprs la virgule exacts :
"1.4142135623730950488016887242096980785696718753769480731766797379907324784621070
3885038753432764157273501384623091229702492483605585073721264412149709993583141322
2665927505592755799950501152782060571470109559971605970274534596862014728517418640
8891986095523292304843087143214508397626036279952514079896872533965463318088296406
2061525835239505474575028775996172983557522033753185701135437460340849884716038689
9970699004815030544027790316454247823068492936918621580578463111596668713013015618
5689872372352885092648612494977154218334204285686060146824720771435854874155657069
6776537202264854470158588016207584749226572260020855844665214583988939443709265918
0031138824646815708263010059485870400318648034219489727829064104507263688131373985
5256117322040245091227700226941127573627280495738108967504018369868368450725799364
7290607629969413804756548237289971803268024744206292691248590521810044598421505911
2024944134172853147810580360337107730918286931471017111168391658172688941975871658
2152128229518488472089694633862891562882765952635140542267653239694617511291602408
7155101351504553812875600526314680171274026539694702403005174953188629256313851881
6347800156936917688185237868405228783762938921430065586956868596459515550164472450
9836896036887323114389415576651040883914292338113206052433629485317049915771756228
5497414389991880217624309652065642118273167262575395947172559346372386322614827426
222086711558395999265211762526989175409881593486400834570851814722318142040704265
0905653233339843645786579679651926729239987536661721598257886026336361782749599421
9403777753681826473737617674512347059203186921"
Le 1400
e
chiffre aprs la virgule est un 1 en gras, rouge et agrandi ; par comparaison avec le premier
million de dcimales sur le site http://antwrp.gsfc.nasa.gov/htmltest/gifcity/sqrt2.1mil, toutes les
dcimales en italique, qui suivent ce 1, sont encore correctes, soit en tout 1567.
Bref, avec cette fonction trs performante, et cette modeste calculatrice quest la TI-Nspire,
nous avons obtenu rien moins que 1567 dcimales correctes dans le calcul approch de 2 .
Impressionnant quand mme !
1.6 Calcul de la partie entire de la racine carre
Les puristes rleront : comment ! mais pour utiliser la fonction heron, on a dj besoin de la fonction
racine carre de la calculatrice ! nest-ce pas un peu gnant ?
Pas vraiment, pourrait-on ajouter, car on est en mesure damliorer considrablement cette fonction
de la TI-Nspire, qui par exemple nest pas capable de renvoyer 1567 dcimales correctes pour 2 .
Par ailleurs il est possible dcrire soi-mme une fonction appelons-la intrc qui donne la partie
entire de la racine carre de tout nombre rel a 1... et donc le terme initial de la suite tudie
prcdemment... sans sappuyer bien videmment sur la fonction racine carre de la TI-Nspire...
Lide la plus simple est de faire quelques itrations de la suite prcdente partir dune valeur
initiale prciser, jusqu ce que la partie entire du rsultat soit stabilise. Cette valeur obtenue est
alors un bon candidat pour tre la partie entire de la racine carre de a : on peut toujours tester si
cest bien le cas... Pour viter que le calcul exact nexplose avec des fractions dpassant les capacits
arithmtiques de la calculatrice, on ne prend chaque itration que la partie entire du rsultat.
Or donc, quelle valeur initiale va-t-on prendre pour ces itrations dapproche ? La convergence tant
trs rapide, point nest besoin de partir trop prs de a : des considrations sur le nombre de chiffres
de a permettent de majorer grossirement a par une puissance de 10, valeur initiale que nous
choisirons pour la suite (u
n
).
Ainsi 123456 qui possde 6 chiffres est infrieur 10
6
: sa racine carre est majore par 10
3
; 1234567
qui possde 7 chiffres est infrieur 10
7
, donc sa racine carre est majore par 10
4
. Plus
gnralement, si p est le nombre de chiffres de a, sa racine carre est majore par 10 la puissance la
valeur arrondie lentier le plus proche de
2
p
, soit 10
int(p/2+1/2)
.
Avant dcrire une fonction, on peut observer ce qui se passe sur le tableur, avec des valeurs simples
de a :

On observe que la suite dcrot jusqu tre constante, ou encore dcrot puis oscille entre deux
valeurs entires conscutives.

Plus prcisment, si
n
v a > , alors
1
1 1
int
2 2
n n n n
n n
a a
v v v v
v v
+
| | | | | |
= + s + <
| | |
|
\ . \ . \ .
, daprs les proprits
signales plus haut, ce qui veut dire que les valeurs de la suite vont strictement en dcroissant. Or il
nexiste pas de suite strictement dcroissante dentiers.
On peut donc appeler p le plus petit entier naturel tel que
1 p p
v v
+
> .
Par contraposition, puisque
1 p p
v v
+
> , cest que lentier
p
v vrifie
p
v a s . On en dduit que
( )
int
p
v a s .
Dautre part,
1
1
1
2
p
p
a
v a
v
| |
+ > |
|
\ .
, daprs les proprits vues plus haut. Donc
( ) 1
1
1
int int
2
p
p
a
v a
v
| | | |
+ > | |
| |
\ . \ .
soit
( )
int >
p
v a .
En consquent, on a bien prouv que
( )
int
p
v a = .
Dans tous les cas, on doit donc poursuivre litration tant que les valeurs dcroissent strictement : le
moment o la dcroissance stricte na plus lieu correspond une valeur u
p
infrieure ou gal a
qui est la partie entire de la racine carre de a.
La fonction suivante sappuie sur les remarques prcdentes :

Les rsultats renvoys sont conformes notre attente :

La fonction intrc prend mme en dfaut la calculatrice avec le calcul de la partie entire de 250! ,
mmoris dans une variable val :

On peut donc dans notre fonction heron, substituer int(\a) intrc(a), et il ne sera fait nulle part
appel la fonction racine de la calculatrice.
2. La suite de Fibonacci
2.1 Quelques lments historiques
Fibonacci, ou Lonard de Pise, (v 1170-v 1250) est un des plus grands mathmaticiens du Moyen-
ge. En 1202, il publie le Liber Abaci
9
, un trait sur le calcul fond sur le systme dcimal, une
poque o tout l'Occident utilisait encore les chiffres romains et calculait sur abaque. Ci-dessous une
page de ce trait sur laquelle nous avons soulign les 10 chiffres mentionns par Fibonacci dans leur
criture de lpoque. Lonard de Pise sest fortement inspir de pratiques rpandues lpoque dans
le monde arabe
10
.

Dans ce mme livre, il voque le clbre problme des lapins
11
, conduisant la clbre suite qui porte
aujourdhui son nom :
Un homme possde un couple de lapins dans un certain endroit et on veut savoir combien [de
couples de lapins] sont engendrs par ce couple en un an en sachant que cest dans leur
nature en un mois de donner naissance un autre couple, et le deuxime mois ceux qui sont
ns pourront engendrer leur tour.
12

Bref, combien de couples de lapins sont engendrs par un couple au bout dun an ? Chaque couple
donne naissance un autre couple chaque mois ; les petits lapins doivent attendre davoir deux mois
pour se reproduire.

9
Le livre de labaque, ou plus exactement le livre du calcul, car Fibonacci y dcrit comment effectuer les calculs sans abaque mais avec les
chiffres indo-arabes du systme dcimal.
10
Il a parcouru avec son pre lAfrique du nord. Il a sjourn plus longuement Bjaia (Bougie).
11
Pour la petite histoire, la gestation de la lapine est dun mois, mais la maturit sexuelle est atteinte 4 mois. Une porte comporte entre
deux et cinq lapereaux. Fibonacci nest pas si loin de la ralit !
12
Traduction de ma part, depuis une traduction anglaise de 2002 du Liber Abaci.

2.2 Mathmatisation du problme
Appelons F
n
le nombre de lapins la fin du mois n. Il est clair que
0
1 F = et
1
1 F = .
Lvolution de la population est rsume par le dessin qui suit. Notons quen clair apparaissent les
lapins qui ne peuvent pas encore avoir de petits. Sont souligns ceux qui sont en mesure de se
reproduire le mois suivant :

la fin du deuxime mois, on dispose dun couple qui a donn naissance un autre couple : donc
2
2 F = . Sur ces deux couples, un seul se reproduira le mois suivant. la fin du troisime mois, on
dispose de 3 couples, dont 2 vont se reproduire le mois suivant :
3
2 F = . la fin du quatrime mois,
on dispose de 2 2 1 5 + = couples dont 3 vont se reproduire. Etc.
Supposons maintenant connus tous les termes de la suite jusqu F
n
et cherchons calculer le terme
suivant F
n + 1
. Le nombre de lapins au mois n + 1 sera une somme de deux termes :
le nombre de lapins au mois n, qui est clairement gal F
n
;
augment du nombre de naissances au mois n + 1 : ce nombre est gal au nombre de couples
pubres, cest--dire ayant la facult de se reproduire ; il y en a clairement F
n1
car ils doivent
avoir au moins deux mois.
Par consquent, la suite vrifie la relation de rcurrence, trs simple et trs classique :
1 1 n n n
F F F
+
= + avec F
1
= F
2
= 1.
Les premiers termes peuvent tre calculs sur le tableur :

La rponse Lonard de Pise est alors immdiate : au bout dun an, cest--dire la fin du onzime
mois, on dispose de 144 lapins, supposer quaucun ne finisse dans une casserole dici l...
Nous nous proposons dans la suite dcrire une fonction, la plus efficace possible, permettant le calcul
dun terme de rang n quelconque de la suite de Fibonacci : par exemple, comme nos moyens de calcul
individuels sont autrement plus puissants que ceux de Lonard, le terme F
4000
, si les possibilits de
notre calculatrice nous le permettent.
videmment, pour un tel nombre, le tableur, dune part limit 2500 lignes, dautre part trs vite
ralenti par la taille importante des nombres en jeu, ne nous est daucune utilit. Place la
programmation !
2.3 Un premier programme
- La fonction qui suit, base sur la dfinition, donne le terme de rang n de la suite de Fibonacci.
Initialement, on a a = b = 1, ce qui correspond aux valeurs de
0
F et de
1
F . La variable c, dont la
fonction renvoie la valeur la fin, est initialise ds le dbut 1 pour le cas o on nentrerait pas dans
la boucle.
On entre dans la boucle pour des valeurs de n 2. Il faut tre vigilant dans les affectations effectues
pour ne pas perdre craser intempestivement une valeur. Ainsi lordre des affectations ba puis cb
est important et non le contraire qui mettrait la valeur b dans les trois variables a, b et c.

La fonction est certes basique mais les temps dexcution sont acceptables : en un peu moins de 3
secondes, lnorme F
4748
est renvoy : il possde quand mme 993 chiffres.

- Nous napporterons pas damliorations profondes cette fonction, dj suffisamment
performante. Toutefois, pour le plaisir de la programmation, on peut par exemple chercher se
dbarrasser de la variable auxiliaire c.

Au dpart a, b et a + b reprsentent trois valeurs conscutives de la suite de Fibonacci ; lide serait
donc de stocker directement a + b dans b mais on perd la valeur b qui devrait tre affecte la
variable a. On peut en fait la rcuprer simplement en calculant b a (cest--dire a + b a).
Que renvoie la fonction en sortie ? Dans la version initiale, ctait c, cest--dire a + b : ici il suffit de
renvoyer b, dans lequel on a mmoris a + b.

Les rsultats sont satisfaisants, mais lamlioration en temps est imperceptible. Lun dans lautre les
choses reviennent au mme
13
!

- Une dernire ide consiste faire les calculs avec deux variables a et b on peut difficilement
envisager moins et en gardant systmatiquement dans a et b deux termes conscutifs de la suite de
Fibonacci. chaque tape, on stocke a + b dans la variable a et de nouveau a + b avec la nouvelle
valeur de a dans la variable b.
Se drouleront selon cet algorithme les tapes suivantes :
tapes : a b
0 F
0
= 1 F
1
= 1
1 F
2
= 2 F
3
= 3
2 F
4
= 5 F
5
= 8
3 F
6
= 13 F
7
= 21
4 F
8
= 34 F
9
= 55
5 F
10
= 89 F
11
= 144

13
Et le programme devient certainement moins lisible. Il faut se mfier des ruses qui rendent lcriture du programme opaque
chaque passage dans la boucle, on avance donc de deux nombres dans la suite de Fibonacci : cest
comme si le chat bott avait enfil des bottes de deux lieues.
Pour le calcul dun F
n
donn, on doit parcourir la boucle int
2
n | |
|
\ .
fois : ainsi pour calculer
4
F ou
5
F ,
on parcourt deux fois la boucle,
4
F est alors dans a et
5
F est dans b.
La variable a contient toujours les termes de la suite dindice pair et b les termes dindice impair.
Voici une fonction qui tient compte de ces remarques :

Les rsultats restent les mmes que prcdemment mais F
4748
semble tre obtenu rapidement.

- Estimation des temps dexcution
Sur un seul calcul, il est bien difficile de dpartager les trois fonctions, mme si lon semble aller de
la plus lente la plus rapide. Le programme test ci-dessous donne des rsultats bien plus prcis.


Avec fibo1(20), il demande 56 secondes, soit un peu plus de 2,5 secondes par nombre ; avec
fibo2(20), il demande 52 secondes, soit quasiment le mme temps ; enfin avec fibo3(20), seulement
29 secondes sont ncessaires. Cest ce dernier programme qui est le plus rapide : limage du chat bott
et de ses bottes de deux lieues nest pas usurpe !
2.4 Lapproche par les matrices
Changeons compltement de stratgie : passons une vision matricielle de la relation de rcurrence
qui dfinit la suite de Fibonacci. On peut en effet crire pour tout entier naturel n :
1 2
1
1 1
1 0
n n
n n
F F
F F
+ +
+
| | | | | |
=
| | |
\ .\ . \ .

Par suite, de proche en proche :
2 1
1 2 0 1
1 2 3 2 1
1 1 1 1 1 1 1 1 1 1 1
...
1 0 1 0 1 0 1 0 1 0 1
n n n
n n n
n n n
F F F F F
F F F F F

| | | | | | | | | | | | | | | | | | | | | |
= = = = = =
| | | | | | | | | | |
\ . \ . \ . \ . \ . \ . \ . \ . \ . \ . \ .

Tout se joue donc sur le calcul de la puissance n
e
de la matrice
1 1
1 0
M
| |
=
|
\ .
.
Examinons dailleurs de plus prs les coefficients des puissances de cette matrice :

On peut conjecturer que :
Pour tout entier naturel n suprieur ou gal 2,
1
1 2
n n n
n n
F F
M
F F

| |
=
|
\ .
.
Dmonstration
Ce rsultat peut se dmontrer par rcurrence. Il est vrai pour n = 2 et n = 3. En effet,
2 1 2
1 0
2 1
1 1
F F
M
F F
| | | |
= =
| |
\ . \ .
et
3 2 3
2 1
3 2
2 1
F F
M
F F
| | | |
= =
| |
\ . \ .
.
Supposons que le rsultat soit vrai pour un entier arbitraire n : on a alors
1
1 2
n n n
n n
F F
M
F F

| |
=
|
\ .
.
Par consquent,
1 1 1 1
1 2 1 2 1 1
1 1
1 0
n n n n n n n n n
n n n n n n n
F F F F F F F
M M M
F F F F F F F
+ +

+ | | | | | | | |
= = = =
| | | |
+
\ . \ . \ . \ .
, ce qui
prouve le rsultat pour lentier qui suit. La proprit est donc vraie pour tout n suprieur ou gal 2.
Le calcul du n
e
terme de la suite de Fibonacci se ramne donc celui de la puissance n
e
de la matrice
m de laquelle on extrait lentier situ sur la premire ligne et la premire colonne.
Voici le programme, trs court, qui sen dduit.

Les rsultats sont par contre spectaculaires :
4748
F est obtenu trs rapidement

La fonction test, prcdemment crite, et utilise dans les mmes conditions ne demande plus que 23
secondes : cest la meilleure performance ralise jusqu prsent.
2.5 Utilisation dune formule explicite
- Expression de F
n
en fonction de n
La dmarche est classique et mrite dtre connue. Notons dores et dj que lon pourrait sappuyer
sur lalgbre linaire et la structure despace vectoriel. Nous avons exclu cette dmarche pour que la
dmonstration reste accessible un lve de lyce. Cette dmonstration sarticule en plusieurs tapes.
Premire tape : cherchons sil existe une suite gomtrique non nulle vrifiant la mme relation de
rcurrence que la suite de Fibonacci.
Soit (q
n
) une telle suite gomtrique, videmment de raison non nulle. On peut donc crire pour tout
entier naturel n,
2 1 n n n
q q q
+ +
= + , soit en divisant par q non nul,
2
1 q q = + .
Un tel q est donc solution de lquation du second degr q
2
q 1 = 0.

On obtient bien deux valeurs possibles qui sont
1 5 1 5
et
2 2
r s
+
= = .

Deuxime tape : montrons que la suite (F
n
) peut scrire pour tout entier naturel sous la forme
n n
n
F r s o | = + .
Si lgalit est vraie pour tout n, elle lest en particulier pour n = 0 ou 1, ce qui va permettre de
dterminer les valeurs possibles de o et |.
0
1
1
1
F
F r s
o |
o |
= = +
= = +
dont les solutions sont

1 s
r s
o

=
et
1 r
r s
|

=
.

Ces valeurs conviennent-elles pour nimporte quel entier n ? Autrement dit, il reste vrifier que lon
a bien, pour tout entier naturel n,
n n
n
F r s o | = + .
Par construction, cette galit est vrifie pour n = 0 ou n = 1.
Supposons maintenant quelle soit vrifie pour les entiers n et n + 1. Montrons quelle est vraie pour
n + 2.
( ) ( )
1 1 1 1
2 1
2 2
n n n n n n n n
n n n
n n
F F F r s r s r r s s
r s
o | o | o |
o |
+ + + +
+ +
+ +
= + = + + + = + + +
= +

Ce quil fallait prouver !
Troisime tape : quelle est lexpression de F
n
?
Tout dabord, dterminons laide de notre TI-Nspire les valeurs de o et | :

Par suite :
1
1 5 1 5 1 5 1 5 5 5 1 5 5 5 1 5
2 10 2 2 10 2 10 2 10 2
5 5 1 1 5 5 5 1 1 5
5 2 2 5 2 2
5 1 5 5 1 5
5 2 5 2
+
| || | | || | | || | | || |
+ + +
= + + = +
| | | | | | | |
| | | | | | | |
\ .\ . \ .\ . \ .\ . \ .\ .
| || | | || |
+ +
= +
| | | |
| | | |
\ .\ . \ .\ .
| | | |
+
=
| |
|
\ . \ .
n n n n
n
n n
n
F
1 1 1
1 1 5 1 5
2 2 5
+ + +
| |
| | | |
+
|
=
| |
| | |
|
\ . \ .
\ .
n n n

En conclusion on peut crire que
1 1
1 1 5 1 5
2 2 5
+ +
| |
| | | |
+
|
=
| |
| |
|
\ . \ .
\ .
n n
n
F .
Curieuse formule sil en est, dont le rsultat est entier, malgr les racines carres qui interviennent !
On la doit Binet en 1843, mais dautres mathmaticiens la connaissaient, semble-t-il, avant cette
date.
- La fonction peut tre directement dfinie en ligne de commande.

On obtient des rsultats satisfaisants, mais demandant beaucoup plus de temps : cest le prix dun
calcul formel soumis rude preuve !
Mais pour des valeurs trop grandes de n (ci-dessous n = 300) apparaissent des problmes de
ressources insuffisantes pour simplifier les expressions.

- Lien avec le nombre dor
Nous aurons besoin dun lemme concernant la suite de Fibonacci pour prouver les rsultats qui
suivent :
Lemme
Pour tout entier naturel n, ( )
1
2
1 2
1
n
n n n
F F F
+
+ +
= .
Dmonstration
On peut crire :
( ) ( ) ( )
( ) ( ) ( )
( ) ( )
2
2 2 2 2
1 2 1 1 1 1 1
2 2 2 2
1 1 1 1 1 1
2 2 2 2
1 1 1 1 1 1
2
2 2
n n n n n n n n n n n n n n n
n n n n n n n n n n n n n
n n n n n n n n n n n
F F F F F F F F F F F F F F F
F F F F F F F F F F F F F
F F F F F F F F F F F
+ + + +
+
+
= + + = + +
= + + = + +
= + = + =


Par consquent, on peut crire de proche en proche :
( ) ( ) ( ) ( ) ( )
( ) ( ) ( ) ( ) ( )
2 3
2 2 2 2
1 2 1 1 1 2 2 3 1
1
2 2
1 0 2
1 1
...
1 1 1 1 2 1
n n n n n n n n n n n n
n n n
F F F F F F F F F F F F
F F F
+ + +
+
= = =
=
= = =

videmment, un raisonnement par rcurrence permettrait de formaliser cette dmonstration en
cachant ses ressorts principaux !
Considrons donc la suite (v
n
) dfinie pour tout entier naturel n par :
1 n
n
n
F
v
F
+
= .
Nous poserons dans tout ce paragraphe
1 5
2
+
= et
1 5 1
1
2

= = = , en suivant dailleurs
des usages courants.
Lexpression du terme gnral de la suite de Fibonacci en fonction de n nous permet dcrire :
2 2
2 2 2
1
1 1 1 1 1
1 1
1 1
n n
n n n
n
n n n n n n
n
F
v
F

+ +
+ + +
+
+ + + + +
| | | |

| |
\ . \ .
= = = =
| | | |

| |
\ . \ .
.
Or il est clair que :
lim 0
n
n
+
| |
=
|
\ .
car 1
< .
Par consquent, la suite (v
n
) est convergente et a pour limite
1 5
2
+
= , qui nest autre que le clbre
nombre dor.

Les premires valeurs de la suite (v
n
) sont donnes dans la feuille de calcul ci-aprs :

tudions maintenant la qualit de cette convergence.
Remarquons tout dabord que la suite semble prendre alternativement des valeurs infrieures puis
suprieures au nombre dor. Prcisons ce dernier point.
Proposition
La suite extraite
( )
2 p
v est strictement croissante, tandis que la suite extraite
( )
2 1 p
v
+
est
strictement dcroissante.
Dmonstration
Tout est bas sur le rsultat suivant, valable pour tout entier naturel n :
( )
( ) ( )
2 1 1 2 3 1 3 1 2 2 1 1 2
2
2 2 2 2
2
2 1 2 2 1
2 2 2
1
n n n n n n n n n n n n n n n n n
n n
n n n n n n n n
n
n n n n n n n n
n n n n n n
F F F F F F F F F F F F F F F F F
v v
F F F F F F F F
F F F F F F F F
F F F F F F
+ + + + + + + + + + + + +
+
+ + + +
+ + + + +
+ + +
+ +
= = = =

= = =

Par consquent, il est clair que :
si n = 2p,
( )
2
2 2 2
2 2 2
1
0
p
p p
p p
v v
F F
+
+
= > , ce qui prouve que

( )
2 p
v est strictement croissante ;
si n = 2p + 1,
( )
2 1
2 3 2 1
2 1 2 3
1
0
p
p p
p p
v v
F F
+
+ +
+ +
= < , ce qui prouve que

( )
2 1 p
v
+
est strictement dcroissante.
Proposition
Les deux suites extraites
( )
2 p
v et
( )
2 1 p
v
+
sont adjacentes.
Dmonstration
En effet :
( )
2
2
2 2 2 1 2 2 2 2 1
2 1 2
2 1 2 2 2 1 2 2 1 2 2 1
1
1
p
p p p p p
p p
p p p p p p p p
F F F F F
v v
F F F F F F F F
+ + + +
+
+ + + +

= = = =

qui tend vers 0 quand n tend vers linfini.
BILAN : grce aux deux suites adjacentes mises en vidence, nous disposons de tous les lments
pour crire un programme donnant une valeur approche du nombre dor, en contrlant lerreur
commise. On a en effet, pour tout entier naturel p :
2 2 1 p p
v v
+
s s
et les deux suites
( )
2 p
v et
( )
2 1 p
v
+
convergent vers . On dispose de lencadrement suivant :
2 2 1 2
2 2 1
1
0
p p p
p p
v v v
F F
+
+
s s s .
Do la fonction suivante, donnant une valeur approche du nombre dor avec une erreur moindre que
le rel er :

Plutt que dappeler deux fois notre performante fonction fibo3 inutile perte de temps car les
calculs seraient alors recommencs deux fois depuis F
0
et F
1
, on en a repris les instructions
principales : on se souvient que a contient les termes de rang pair et b les termes de rang impair de la
suite de Fibonacci, ce qui est parfait pour le problme qui nous concerne. Par ailleurs le test de boucle
1
s er
ab
a t remplac par
1
> ab
er
, un peu plus rapide.
Remarquer la sortie, qui fait intervenir de faon artificielle la variable er : si er est saisie sous la
forme dun nombre virgule (0.0001 par exemple), le rsultat renvoy lest aussi ; sinon (10
-4
par
exemple) on rcupre une valeur fractionnaire exacte (voir lcran de gauche ci-dessous).
Comme dhabitude avec TI-Nspire, lerreur peut tre choisie trs petite, en mode exact et on peut
alors rcuprer les dcimales comme on la dj vu (cran de droite).

Si les erreurs deviennent trop petites, on finit par avoir des rsultats en virgule flottante normalise
avec 14 chiffres significatifs : on perd toute la prcision. Une erreur moindre que 10
-1000
posera
problme : le nombre est mis 0 (underflow) et son inverse linfini. On ne sort plus de la boucle et
il faut interrompre la fonction (touche F12 de lordinateur
14
).

14
Le mien en tout cas, un portable Acer.

Sil sagit de dcrocher un record de prcision, on peut faire beaucoup mieux, mais grant soi-mme
quelques calculs !
On se souvient que le plus grand nombre de Fibonacci que la TI-Nspire a pu calculer est F
4748
. Qu
cela ne tienne ! La plus prcise valeur approche de que lon puisse avoir est donc
4747
4746
F
F
avec une
erreur moindre que
4747 4746
1
F F
. Si le calcul est certes possible la fraction est gigantesque , son
numrateur ne peut pas tre multipli par 10 car il repasse en virgule flottante normalise, ce qui
empche lutilisation de notre fonction divex2 (voir annexe de ce chapitre). On ne peut donc rien faire
de ce magnifique rsultat, pas trs parlant !

Anticipons donc lutilisation de divex2 en cherchant un F
n
tel que 10F
n
soit encore exact pour la
calculatrice :

On y parvient avec F
4743
, ce qui nous conduit prendre comme valeur approche de le terme
v
4742
=
4743
4742
F
F
, avec une erreur moindre que
4743 4742
1
F F
daprs les proprits vues plus haut.


Attention lunderflow : lerreur doit tre calcule en 2 morceaux : elle est moindre que 10,8 10
-1983
,
infrieure, pour faire simple 10
-1981
.
La valeur approche de obtenue est alors :

soit un rsultat possdant 2000 dcimales :
"1.618033988749894848204586834365638117720309179805762862135448622705260462818
902449707207204189391137484754088075386891752126633862223536931793180060766726
354433389086595939582905638322661319928290267880675208766892501711696207032221
043216269548626296313614438149758701220340805887954454749246185695364864449241
044320771344947049565846788509874339442212544877066478091588460749988712400765
217057517978834166256249407589069704000281210427621771117778053153171410117046
665991466979873176135600670874807101317952368942752194843530567830022878569978
297783478458782289110976250030269615617002504643382437764861028383126833037242
926752631165339247316711121158818638513316203840052221657912866752946549068113
171599343235973494985090409476213222981017261070596116456299098162905552085247
903524060201727997471753427775927786256194320827505131218156285512224809394712
341451702237358057727861600868838295230459264787801788992199027077690389532196
819861514378031499741106926088674296226757560523172777520353613936210767389376
455606060592165894667595519004005559089502295309423124823552122124154440064703
405657347976639723949499465845788730396230903750339938562102423690251386804145
779956981224457471780341731264532204163972321340444494873023154176768937521030
687378803441700939544096279558986787232095124268935573097045095956844017555198
819218020640529055189349475926007348522821010881946445442223188913192946896220
023014437702699230078030852611807545192887705021096842493627135925187607778846
658361502389134933331223105339232136243192637289106705033992822652635562090297
986424727597725655086154875435748264718141451270006023890162077732244994353088
999095016803281121943204819643876758633147985719113978153978074761507722117508
269458639320456520989698555678141069683728840587461033781054443909436835835813
811311689938555769754841491445341509129540700501947754861630754226417293946803
673198058618339183285991303960720144559504497792120761247856459161608370594987
86006970189409886400764436170933416489777860058682771"
La valeur exacte est comprise entre le nombre prcdent et le nombre que lon obtient en remplaant
le grand 1 (la 1981
e
dcimale) par un 2. La bonne rponse est 172709191 433650137
15
.
Performance plus quhonorable pour une simple calculatrice !
2.6 Rcursivit et Fibonacci
- videmment lcriture dune fonction rcursive est tout indique pour le calcul des termes dune
suite rcurrente. Lcriture dune telle fonction est trs simple, tellement quon a limpression de
navoir rien crit dautre que la dfinition de la suite elle-mme :

Il ne faut cependant pas sattendre une grande efficacit, bien moins importante en tout cas que celle
des prcdentes fonctions :

Les temps de traitement, mme pour des nombres petits (par exemple 25 ou 30), sont tellement
pouvantablement longs
16
quils en deviennent rdhibitoires.
La raison en est simple : les appels multiples la fonction submergent la calculatrice sous le flot des
calculs et saturent trs vite sa mmoire.
Pour fixer les ides, appelons a
n
le nombre dappels ncessaires au calcul de F
n
17
. Cherchons donc
dterminer par exemple a
4
:

15
Selon le site http://www.nombredor.be/html/decimales_du_nombre_d_or.html.
16
Ici sur ordinateur. On a interrompu le calcul pour n = 30. Cest bien sr pire sur la calculatrice !
17
La premire excution de la fonction, provoque par lutilisateur, nest pas considr comme un appel.

F
4

F
3
F
2

F
2
F
1
F
1
F
0

F
1
F
0

On dnombre dans ce cas huit appels, autant que dartes dans le graphe prcdent, appels dailleurs
souvent redondants, de la fonction.
Le mme graphique montre que pour F
3
, on aurait eu quatre appels et pour F
2
, on en aurait eu deux.
Pour F
5
, on peut imaginer le nombre dappels : lappel de F
4
puis les a
4
= 8 appels demands pour le
calcul de F
4
ainsi que lappel de F
3
puis les a
3
= 4 appels demands pour le calcul de F
3
, soit en tout
a
4
+ a
3
+ 2 = 8 + 4 + 2 = 14 appels.
Pour F
6
, on en aurait eu, en raisonnant de mme : 14 + 8 + 2 = 24 appels.
On a plus gnralement pour n entier naturel :
0 1
1 1
0, 0
2
n n n
a a
a a a
+
= =
= + +

La suite (a
n
) est analogue la suite de Fibonacci, dont la croissante est gomtrique : pour un nombre
mme relativement limit, on sature la mmoire par trop dappels de la fonction.
- Il existe des stratgies pour diminuer le nombre dappels en utilisant dautres formules, comme
celles qui suivent :
Proposition
Quel que soit lentier naturel p, on a :

2
2 1 1
2 2
2 2 1
2
p p p p
p p p
F F F F
F F F
+ +
+ +
=
= +

Dmonstration
Nous allons vrifier ces formules par rcurrence.
Elles sont toutes les deux vraies pour p = 0 ou p = 1. En effet
2 2
1 0 1 0
2 2 2 2
2 0 1
2 car 1 = 2 1 1 1
car 2 = 1 1
F F F F
F F F
=
= + +
et
2 2
3 1 2 1
2 2 2 2
4 1 2
2 car 3 = 2 1 2 1
car 5 = 1 2
F FF F
F F F
=
= + +
.
Supposons la proprit dmontre pour lentier p. On a donc :
2
2 1 1
2 2
2 2 1
2
p p p p
p p p
F F F F
F F F
+ +
+ +
=
= +

Calculons pour commencer F
2p + 3
, dont vous voulons montrer que cest gal
2
1 2 1
2
p p p
F F F
+ + +

( ) ( )
2 2 2 2
2 3 2 1 2 2 1 1 1 1
2 2
2 2 2 2 2
1 2 2 2 1 1 2 1
2 2
2
p p p p p p p p p p p
p p p p p p p p p p p
+ + + + + + +
+ + + + + + + +
= + = + + = +
= + = = =

Par ailleurs, pour ce qui concerne F
2p + 4
, on a :
( )
2 2 2
2 4 2 3 2 2 1 2 1 1
2
2
1 2 1 2 2 1
2 2
2 1
2
2 2
p p p p p p p p
p p p p p p p
p p
F F F F F F F F
F F F F F F F
F F
+ + + + + + +
+ + + + + +
+ +
= + = + +
= + = +
= +

On a bien dmontr la proprit pour lentier qui suit p + 1.
Par consquent, la proprit a bien t prouve par rcurrence.
En rsulte une nouvelle fonction rcursive, un peu plus performante que la prcdente.

Les rsultats obtenus sont conformes ceux que lon attendait.

La fonction est plus rapide car elle demande moins dappels rcursifs : chaque entier n, on appelle
deux fois la fonction, comme prcdemment, mais en faisant intervenir des indices de lordre de n/2.
On peut sattendre ce que la mmoire soit moins sature que dans la fonction prcdente.
Effectivement, on peut calculer F
n
avec des indices grands sans saturation de la mmoire :


3. Calcul dune valeur approche de e.
3.1 Quelques lments dhistoire
Le calcul peut se faire partir de la clbre srie suivante, dont on sait quelle converge vers e, la
clbre base de la fonction logarithme nprien :
1 1 1
1 ...
1! 2! !
n
u
n
= + + + + .
Euler en avait dailleurs dj donn une valeur approch prcise dans son Introduction lanalyse
infinitsimale (1748) :

3.2 Quelques points thoriques
- Rappelons tout dabord les raisons de la convergence de la suite (u
n
).
Comme cette suite est trs clairement strictement croissante, la seule question est de savoir si elle est
majore ou non. Nous montrerons au pralable le rsultat suivant :
Proposition
Pour tout entier naturel non nul i :
1
! 2
i
i

> .
Dmonstration
On peut remarquer que cette ingalit est vraie pour i = 0, 1, 2, 3, 4, 5.

la calculatrice le confirme pour ceux qui ne voudraient pas faire les calculs.
Procdons donc par rcurrence. Supposons la proprit dmontre pour un entier arbitraire k suprieur
ou gal 4 : on a donc
1
! 2
k
k

> .
Montrons la proprit pour lentier qui suit k + 1. Or :
( )
1 1
1 ! ( 1) ! ( 1)2 2 2 2
k k k
k k k k

+ = + > + > =
ce que lon voulait prouver ! Lingalit est bien prouve par rcurrence.
Proposition
Pour tout entier naturel non nul n, 3
n
u s .
Dmonstration
On peut crire :
0 1 1
1
1
1
1 1 1 1 1 1 1
2
1 ... 1 ... 1 1 2 1
1
1! 2! ! 2 2 2 2
2
1
3 3
2
n
n n n
n
u
n

| |
= + + + + s + + + + = + = +
|
\ .
= s

Do il ressort que la suite (u
n
) est majore par 3.
tant croissante et majore, elle admet ncessairement une limite, qui est la base e des logarithmes
npriens
18
.
- Quelques prcisions sur cette convergence
Considrons pour commencer u
n + p
u
n
, o n et p sont deux entiers naturels non nuls :
( ) ( ) ( )
( ) ( ) ( )( ) ( ) ( )
( ) ( )
( ) ( )
( ) ( )
2 1
1 1 1
...
1 ! 2 ! !
1 1 1 1
1 ...
1 ! 2 2 3 2 ...
1 1 1 1
1 ...
1 ! 1
1 1
1 1 1 1 1
1
1 ! 1 ! 1 1 !
1
1
n p n
p
u u
n n n p
n n n n n n p
n n
n n
n
n n n nn
n
+
= + + +
+ + +
| |
= + + + +
|
|
+ + + + + +
\ .
| |
| s + + + +
|
+ +
+ +
\ .
+
s = =
+ + +
+

Lingalit prcdente est vraie pour tout entier naturel p non nul. En faisant tendre p vers linfini, on
obtient :
1
(0 )
!
n
e u
nn
s s (1)
Par ailleurs, il est clair que
( )
1
1 !
n
e u
n
s
+
.

18
Que la limite existe ne pose pas de problme, quelle soit la base de la fonction logarithme nprien reste prouver. Voir un bon cours
danalyse.

Par consquent, on obtient lencadrement suivant de
n
e u :
Pour tout entier naturel n non nul,
( )
1 1
1 ! !
n
e u
n nn
s s
+
.
Cet encadrement va nous permettre de dterminer la rapidit de convergence de la suite (u
n
). En effet,
en multipliant les ingalits prcdentes par ( ) 1 ! n + , on obtient :
( ) ( )
( ) 1 !
1
1 1 !
!
n
n
n
n e u
nn n
+
+
s + s =
do lon dduit : ( ) ( ) lim 1 ! 1
n
n
n e u
+
+ = . En dautres termes,
( )
1
1 !
n
e u
n
+

Par consquent,
( )
( )
1
1 !
1
2 ! 2
+
+
=
+ +
n
n
n e u
e u n n
, do lon tire que
1
1
lim lim 0
2
n
n n
n
e u
e u n
+
+ +
= =
+
. Par suite :
La convergence de la suite (u
n
) vers e est rapide.
Au demeurant cette convergence nest pas superlinaire (donc en particulier pas quadratique, comme
la convergence de lalgorithme de Hron). En effet, quel que soit le nombre rel r suprieur 1 :
( )
( ) ( )
( )
( ) ( )
( )( )
( ) ( )
( )
( ) ( )
( ) ( )
1 1
1
1 1
1
1
1 ! 1 ! 1 ! 1 !
2 ! 2 1 ! 2 2
1 ! 1
!
2 2
r r r r
n
r
n
r r
r
r
n n n n n
e u
n n n n n
e u
n n n
n
n n

+

+ + + +
= = =
+ + + + +
+ +
= =
+ +

dont il est clair que chaque facteur tend vers linfini dans la mesure o r est strictement suprieur
1.
Revenons maintenant aux ingalits (1) de la page prcdente, qui peuvent scrire :
soit
1
!
n n
u e u
nn
s s + .
Elles suggrent lide de travailler avec la suite (v
n
) dfinie, pour tout entier naturel n non nul, par :

1
!
n n
v u
nn
= + .
Proposition
Les deux suites (u
n
) et (v
n
) sont adjacentes.
Dmonstration
La suite (u
n
) est croissante, nous lavons vu plus haut.
La suite (v
n
) est dcroissante. En effet :
( )( ) ( ) ( )( )
( ) ( )
( )( ) ( )( ) ( )( )
1 1
2
2 2
1 1 1 1 1
1 1 ! ! 1 ! 1 1 ! !
1 1
2 2 1 1
1 1 ! 1 1 ! 1 1 !
n n n n
v v u u
n n nn n n n nn
n n n n
n n n n
n n n n n n n n n
+ +
= + = +
+ + + + +
+ + +
+
= = =
+ + + + + +

La calculatrice permet de contrler la fin du calcul on peut remarquer que les deux rsultats sont
identiques mais pas le dbut du mme calcul, car elle peine avec les factorielles :

Par ailleurs, ( )
1
lim lim 0
!
n n
n n
v u
nn
+ +
= = .
3.3 criture dune fonction
Nous disposons de tous les lments, notamment le fait que les deux suites soient adjacentes, pour
crire une fonction renvoyant une valeur approche de e et contrlant lerreur sur le rsultat. En effet,
pour chaque tape n, on a lencadrement suivant :
1
!
n n n
u e v u
nn
< < = +
si bien que
1
0
!
n
e u
nn
< < . En dautres termes, u
n
est une valeur approche par dfaut de e moins
de
1
! nn
prs.
La fonction suivante a comme paramtre dentre un majorant de lerreur er que lon souhaite sur le
rsultat final.
Pourquoi ne pas utiliser une boucle Loop...Endloop : le test de sortie est report la fin de la
boucle
19
. Il faut cumuler dans la variable u la valeur de 1/n!, pour un indice n donn, puis seulement
sortir lorsque
1
!
< er
nn
et retourner u. La valeur de n est alors renvoye par Disp pour information.
Mme ruse que dans le paragraphe prcdent : si er est saisi avec une virgule, le rsultat sera
approch ; sinon il est exact.

19
On aurait pu utiliser While 1/(n.n!)>1/er en prenant garde toutefois dinitialiser n 0 et u 2.

Cette fonction peut donc tre utilise comme prcdemment tant en mode approch quen mode exact.
Ci-dessous quelques-uns des rsultats obtenus.

Le dernier rsultat (avec une erreur de 1.E-10) redescendu en ligne de commande montre les chiffres
de rserve, ce qui permet de voir que 2.71828182845 a t arrondi 12 chiffres significatifs. Il faut
aussi tre capable dinterprter lerreur et dapprcier la qualit du rsultat. On sait que la valeur
obtenue de u
n
est une valeur approche par dfaut moins de 10
-10
prs. On peut donc en dduire
lencadrement suivant de e :
2,718 281 828 446 8 < e < 2,718 281 828 446 8 + 10
-10
= 2,718 281 828 546 8
On est donc dans ce cas sr des 9 premires dcimales. Pas de propagation trop importante des erreurs
darrondis, tant donn la relativement faible valeur de n et le fait quon effectue des additions.
Examinons maintenant quelques exemples avec un calcul exact en fractions. Il suffit dentrer une
erreur sous une forme qui ne contient pas de virgule. Comme les calculs sont effectus de manire
exacte, aucune propagation derreur darrondi nintervient ici.
Les temps de calcul restent relativement raisonnables (moins de 2 secondes pour le dernier calcul),
car la TI-Nspire est trs performante
20
:

Il reste exploiter ces rsultats, comme on la dj fait prcdemment.

20
Ctait moins le cas avec une Voyage 200.
Tout dabord, avec la mthode la plus simple, si lon veut faire vite :

On reconnat bien, sans la virgule videmment, les premiers chiffres de la constante e. Un calcul
derreur semblable au prcdent pourrait tre fait.
Sinon, on peut utiliser divex2, pour demander 200 dcimales :

Ce qui donne :
"2.7182818284590452353602874713526624977572470936999595749669676277240766303
535475945713821785251664274274663919320030599218174135966290435729003342952
60595630738132328627943490763233829880753195251019010328187143"
o lon remplace le grand 1 par un 2 pour avoir un encadrement de e (valeur exacte 1157
21
au
lieu du 1032 que la calculatrice renvoie ; lencadrement est correct).
- Bien que les calculs se fassent assez rapidement
22
, cherchons quand mme optimiser notre
programme. Une premire remarque simpose : le calcul des factorielles est pnalisant pour le calcul
de chacun des termes et dans une moindre mesure pour le test de sortie de boucle. chaque tape, on
ignore purement et simplement le calcul prcdent : ainsi pour calculer 301! par exemple, il faut
recommencer depuis le dbut sans reprendre le calcul de 300!, quon vient juste deffectuer
Bref, on peut faire plus simple comme le montre la deuxime fonction suivante : les factorielles sont
calcules de proche en proche dans la variable f ; le test est invers, ce qui allge un peu son
excution

21
Voir le site http://www.jlsigrist.com/e.html qui donne le premier million de dcimales de e.
22
La calculatrice devient plus poussive avec 10
-600
par exemple, 19 secondes, elle trainaille franchement pour 10
-900
, 56 secondes.


Malheureusement le gain de temps est imperceptible, malgr les tentatives damliorations apportes.
Si le calcul reste lourd pour la calculatrice, cest sans doute cause des sommes de fractions avec des
dnominateurs de plus en plus grands.
Cest donc sur ce point quil faut concentrer nos efforts. Car il existe une stratgie bien plus efficace
qui va diminuer singulirement le nombre de calculs effectuer. Elle sapparente la mthode
dvaluation des polynmes dite de Horner.
Ainsi par exemple pour calculer u
10
, au lieu deffectuer les oprations comme elles se prsentent :
1 1
1 ...
1! 10!
+ + +
soit 10 additions et 9 + 8 + 7 + + 1 = 45 multiplications,
il vaut mieux procder de la faon quivalente :
1 1 1 1 1 1 1
1 1 1 1 1 ... 1 1
10 9 8 7 6 2 1
| | | | | | | | | | | |
| + + + + + + + | | | | |
| | |
\ . \ . \ . \ . \ . \ .

qui ne demande que 10 additions et 9 multiplications. Le gain est trs apprciable pour des indices
plus grands
23
.
Mais cette mthode impose de connatre au pralable lindice n duquel on va partir car le calcul a lieu
lenvers partir de cette valeur de n. Cette valeur de n est lie la variable er en entre.
Une premire boucle simpose, simplement pour dterminer lindice li lerreur choisie. On peut
ensuite drouler le calcul de u
n
selon le principe que lon vient de dcrire.
La fonction est la suivante :

23
Pour un indice n quelconque, on aurait n additions et n 1 multiplications, contre n additions et
( ) 1
2
n n
multiplications pour
lalgorithme basique.
Les rsultats sont bien les mmes que prcdemment, dans un temps cette fois-ci beaucoup plus
rapide : la premire rponse est donne en peu prs 3 secondes ! Gain apprciable !

Le plus petite erreur que lon puisse grer, cest 10
-997
, avec un numrateur et un dnominateur de 992
chiffres. Comme n = 448, lerreur commise est majore par
1
448 448!
~
2,6 10
-998
.

La fonction divex2 de la bibliothque division_dec donne alors 1000 chiffres aprs la virgule de u
448
,
qui est une valeur approche par dfaut de e moins de 2,62 10
-998
prs :
"2.7182818284590452353602874713526624977572470936999595749669676277240766303
535475945713821785251664274274663919320030599218174135966290435729003342952
605956307381323286279434907632338298807531952510190115738341879307021540891
499348841675092447614606680822648001684774118537423454424371075390777449920
695517027618386062613313845830007520449338265602976067371132007093287091274
437470472306969772093101416928368190255151086574637721112523897844250569536
967707854499699679468644549059879316368892300987931277361782154249992295763
514822082698951936680331825288693984964651058209392398294887933203625094431
173012381970684161403970198376793206832823764648042953118023287825098194558
153017567173613320698112509961818815930416903515988885193458072738667385894
228792284998920868058257492796104841984443634632449684875602336248270419786
232090021609902353043699418491463140934317381436405462531520961836908887070
167683964243781405927145635490613031072085103837505101157477041718986106873
969655212671546889570350093"

Les 997 premires dcimales sont bonnes si lon sen tient au mme site que prcdemment. Lerreur
est majore par 2,62 10
-998
prs. Le rel e est donc compris entre le nombre prcdent et le nombre
prcdent augment de 2,62 10
-998
, qui se termine donc par 350355
24
.
3.4 Dune suite lautre
- observer le rsultat prcdent, il semble bien que la suite (v
n
) soit une meilleure valeur
approche de e que la suite (u
n
). Montrons ce rsultat.
Proposition
La suite (v
n
) converge vers e plus vite que la suite (u
n
).
Dmonstration
En dautres termes, il suffit de dmontrer que lim 0.
n
n
n
v e
u e
+

Cherchons dabord majorer le numrateur
n n
v e v e = . Il suffit que lon minore e par exemple
par u
n+1
:
( ) ( )
1 1
1 1 1
0
! 1 ! 1 !
+ +
< < = + = =
+ +
n n n n n n n
v e v u v u u u
nn n n n

Par ailleurs, on a vu plus haut que
( )
1 1
1 ! !
n
e u
n nn
s s
+
, do lon dduit :
( )
1
! 1 !
n
nn n
e u
s s +

Par consquent, en faisant le produit membre membre de ces ingalits concernant des nombres
strictement positifs :
( )
( )
1 !
1
1 !
n n
n n
v e n v e
u e e u n n n
+
= s =
+
ce qui prouve que lim 0.
n
n
n
v e
u e
+

Comme nous lavions pressenti, la suite (v
n
) converge donc plus vite vers e que la suite (u
n
). Mais
lencadrement obtenu plus haut,
( )
1
0
1 !
n
v e
n n
< <
+
, est peine meilleur que celui dont on disposait
avec (u
n
). Peut-on faire mieux ?
Si lon observe la dmonstration prcdente, on se rend compte quelle est base sur une minoration
de e.
Or, le moins que lon puisse dire, cest que ces minorations ne manquent pas ! Par exemple, on a aussi
2 n
e u
+
> , ce qui entraine :
( ) ( )
( )( ) ( )
( ) ( ) ( ) ( )( )
2 2
1 1 1
0
! 1 ! 2 !
1 2 2
3 2 2 2 2
2 ! 2 ! 2 ! 1 2 !
n
v e
nn n n
n n n n n
n n n n n
n n n n n n n n n n
< <
+ +
+ + +
+ +
= = = =
+ + + + +

24
Selon le site prcdent, cest 354 pour e.
Le majorant est un peu meilleur, il quivaut
3
2
! n n
en linfini.
Ou encore
3 n
e u
+
> et :
( ) ( ) ( )
( )( )( ) ( )( ) ( )
( )
( ) ( )( )( )
1 1 1 1
0
! 1 ! 2 ! 3 !
1 2 3 2 3 3
3 !
6 6
3 ! 1 2 3 !
n
v e
nn n n n
n n n n n n n n n
n n
n n
n n n n n n n
< <
+ + +
+ + + + + +
=
+
+ +
= =
+ + + +

avec le contrle du calcul formel de la TI-Nspire
25
.

Le majorant quivaut cette fois
3
1
! n n
en linfini, ce qui constitue une petite amlioration de ce quon
avait avec u
n
.
- Nous pouvons donc adapter la fonction calcule3 la lumire de ce qui prcde. Nous sommes
simplement revenus la factorielle dans la boucle initiale et nous avons modifi le majorant de
lerreur conformment au rsultat prcdent :

Les rsultats (voir ci-dessous) sont certes meilleurs, obtenus avec une valeur de n plus petite mais
finalement trs proche de celle quon a obtenue avec calcule3.

25
Malheureusement, le calcul initial avec les factorielles ne renvoie rien de trs exploitable.


Bref, le jeu nen vaut pas la chandelle : si elle est plus performante, cette nouvelle fonction nest pas
pour autant trs convaincante.
Nous ne parvenons mme pas galer le record de dcimales prcdent : calcule3 renvoie pour 10
-995

un rsultat approch !

En consquence, il nest pas trs rentable de chercher amliorer la convergence de la suite (u
n
), dj
rapide il faut dire. Contentons-nous des presque mille dcimales de e, obtenues avec u
448
: cest une
belle performance pour une petite calculatrice !
ANNEXE : une division amliore
Explicitons notre fonction divex2, qui permet de rcuprer autant de dcimales que lon veut, ou
quasiment, dun rsultat, pourvu quil soit crit sous forme fractionnaire. En entre, la fonction prend
comme valeurs la fraction x considre et le nombre n de chiffres aprs la virgule que lon souhaite
pour le rationnel x. En sortie, elle renvoie le rsultat attendu dans une chane de caractres.

Les tapes ne font que reprendre une division que lon effectuerait la main.
Tout dabord, on rcupre le numrateur et le dnominateur de x. Une premire division euclidienne
donne alors la partie entire de x, que lon mmorise, suivie dun point dcimal, dans la chane de
caractres rep.
Ensuite on enclenche les divisions successives, prcisment celles que lon ferait sur une feuille de
papier : le reste est multipli par 10 ( on abaisse un 0 ) puis stock dans a ; on le divise ensuite par
b ; le rsultat obtenu est concatn la chane de caractres rep.
En thorie, pour un rationnel que la TI-Nspire mmorise de faon exacte, on pourra rcuprer autant
de chiffres que lon voudra par cette mthode. Voir par exemple ce qui suit, pour sen convaincre.

11 Quelqsuites TNS21

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

11 Quelqsuites TNS21

Transféré par

Droits d'auteur :

Formats disponibles

Christian Vassard (IUFM Rouen)

= , et daprs le thorme des gendarmes, on dduit que la suite

< < < <

dont les solutions sont

= > , ce qui prouve que

= < , ce qui prouve que

Vous aimerez peut-être aussi