des exemples de suites - univers-ti-nspire.fr1.3 quelques propriétés de cette suite quelques...
TRANSCRIPT
Christian Vassard (IUFM Rouen)
11
Ch
ap
itre
Les exemples de suites ne manquent pas dans la littérature mathématique, notamment pour calculer
des valeurs approchées de constantes célèbres. Nous avons choisi ici d’en traiter trois, sans doute
parmi les plus connues, pour leur double intérêt mathématique et historique. Nous montrerons
combien les outils de la TI-Nspire sont particulièrement bien adaptés à leur étude.
Sommaire
Chapitre 11. Des exemples de suites ................................................................. 195
1. Algorithme de Héron d’Alexandrie ........................................................ 196
1.1 Le cadre historique ........................................................................ 196
1.2 Une suite à étudier ........................................................................ 198
1.3 Quelques propriétés 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 entière de la racine carrée .......................... 206
2. La suite de Fibonacci .............................................................................. 209
2.1 Quelques éléments historiques ................................................... 209
2.2 Mathématisation du problème ..................................................... 210
2.3 Un premier programme ................................................................ 211
2.4 L’approche par les matrices ......................................................... 214
2.5 Utilisation d’une formule explicite ................................................ 215
2.6 Récursivité et Fibonacci................................................................ 223
3. Calcul d’une valeur approchée de e. .................................................... 226
3.1 Quelques éléments d’histoire ...................................................... 226
3.2 Quelques points théoriques ......................................................... 226
3.3 Écriture d’une fonction .................................................................. 229
3.4 D’une suite à l’autre ....................................................................... 234
ANNEXE : une division améliorée ................................................................... 237
Chapitre 11.
Des exemples de
suites
196 Mathématiques et TI-Nspire
© T³ France 2010 / Photocopie autorisée
1. Algorithme de Héron d’Alexandrie
… ou comment calculer une valeur approchée d’une racine carrée… À tout seigneur tout honneur :
l’algorithme décrit est probablement un des plus anciens de l’histoire des mathématiques, connu en
particulier des Babyloniens. On le retrouve dans nombre de civilisations… Avec Héron, on dispose
d’un texte qui l’explicite, mettant l’accent sur l’idée d’approximations successives.
1.1 Le cadre historique
Héron d'Alexandrie (Ier siècle apr. J.-C.) est un mathématicien grec à la confluence de plusieurs
traditions. Commentateur d'Euclide, il connaît bien la grande tradition géométrique grecque : ainsi les
Métriques, dont est extrait le texte qui suit, font-elles abondamment usage des résultats d'Archimède.
Mais Héron n’est pas seulement un théoricien : parmi les différentes branches des mathématiques, il
mettait la mécanique au premier rang.
Le texte décrivant l’algorithme de Héron est tiré du célèbre Histoire d’algorithmes, Editions Belin,
1994, page 231 :
Puisque 720 n’a pas de côté rationnel, nous extrairons le côté avec une très petite différence
de la façon suivante. Comme le premier nombre carré plus grand que 720 est 729 qui a pour
côté 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-même donne 720
1
36, de sorte que la différence (sur les
carrés) est 1
36. Si nous voulons rendre cette différence inférieure encore à
1
36, nous mettrons
720 1
36 trouvé tout à l’heure à la place de 729 et en procédant de la même façon, nous
trouverons que la différence sur les carrés est beaucoup plus petite que 1
36.
Les métriques
On remarquera que l’on est très loin dans ce texte du formalisme moderne, avec par exemple
l’expression d’une suite clairement définie. Signalons aussi l’utilisation des quantièmes (c’est-à-dire
les inverses de l’unité et la fraction 2/3), à la manière égyptienne : par exemple 26 1
2 1
3 = 26 +
1
2 +
1
3.
On pourrait s’interroger sur la genèse d’un tel algorithme. Qu’est-ce qui permet de justifier un tel
calcul ? Ce qu’Héron ne dit pas d’ailleurs… Quelques éléments peuvent être donnés, mais il n’existe
pas de certitude en la matière.
Raisonnons le plus simplement possible. Héron part d’une valeur approchée par excès de 720 , soit
27, dont le carré fait 729.
Comme 272 > 720, on en déduit par division par 27 des deux membres de l’inégalité :
720
2727
.
Or le produit des deux nombres 27 et 720
27 donne 720 : nécessairement l’un est plus grand que 720
– on sait que c’est 27 –, et l’autre est plus petit – c’est donc 720
27, ce que confirme évidemment le
calcul approché de l’écran de la page suivante.
Des exemples de suites 197
© T³ France 2010 / Photocopie autorisée
Bilan : on dispose maintenant d’une valeur approchée par excès, 27, et d’une valeur approchée par
défaut de 720 , 720
27. La moyenne arithmétique des deux donne une autre valeur approchée, peut-
être plus précise...
720720
27 27
1 72027
2 27
Moyenne arithmétique qui bien sûr est plus petite que 27…
D’autre part, et c’est ce qui va permettre la réitération du processus, comme le suggère Héron, il se
trouve que cette moyenne conduit de nouveau à une valeur approchée… par excès.
Tout simplement d’ailleurs parce que la moyenne arithmétique de 27 et de 720
27 est plus grande1 que
leur moyenne géométrique, qui vaut précisément 720
27 72027
... L’écran ci-dessus montre aussi
ce résultat.
Le procédé, comme l’indique Héron, peut être poursuivi avec cette nouvelle valeur, et ainsi de suite
aussi loin que nécessaire... Ci-dessous, on saisit d’abord 27 en ligne de commande, puis :
1/2 . (ans+720./ans)2
Puis on appuie sur ·, puis de nouveau sur ·, autant de fois qu’on le souhaite :
1 Comparaison classique et générale entre ces deux moyennes... et fort bien connue à l’époque de Héron !
2 Remarquer le 720. ou 720.0 pour que le calcul soit approché.
198 Mathématiques et TI-Nspire
© T³ France 2010 / Photocopie autorisée
… et les calculs peuvent être menés aussi loin que l’on veut. On peut pressentir une convergence vers
720 , sans doute assez rapide.
1.2 Une suite à étudier
La méthode vue dans le cas particulier de 720 par Héron d’Alexandrie se généralise sans peine à
n’importe quel nombre réel a supérieur à 1, en remplaçant 720 par a dans la formule précédente.
Dans un langage moderne3, on va donc raisonner avec une suite (un).
En posant 1
( )2
ag x x
x
, pour x 0, elle est définie par :
sa valeur initiale u0 > a ;
et la relation de récurrence 1 ( )n nu g u pour n 0.
Le tableur se prête bien au calcul des termes, comme le montre l’écran suivant :
Dans la cellule A1, on note la chaîne de caractères « valeur de a », valeur que l’on rentre dans la
cellule B1, et qu’on mémorise dans la variable a. Le terme initial est choisi dans C14 et dans C2, il
reste à saisir la relation de récurrence :
=1/2.(c1+a/c1)
qu’on recopie sur quelques lignes vers le bas.
Notons que pour avoir des valeurs approchées des termes successifs, il suffit de mettre 3.0 (ou 3.)
dans la cellule C1 : comme d’habitude, le calcul à partir d’un nombre à virgule se fera pour la
calculatrice en mode approché. Sinon la calculatrice fonctionnera en mode exact.
3 Qui n’est pas du tout celui de Héron !
4 N’importe quelle valeur approchée par excès de la racine carrée de a convient, si l’on s’en tient au raisonnement précédent. Autrement dit
un nombre entier dont le carré dépasse a.
Des exemples de suites 199
© T³ France 2010 / Photocopie autorisée
1.3 Quelques propriétés de cette suite
Quelques propriétés de la suite peuvent alors être mises en évidence. Elles sont démontrées ci-après.
Proposition
La suite (un) est minorée par a .
Démonstration
Montrons d’abord que pour tout nombre réel x strictement positif :
1
2
ag x x a
x
5
.
En effet, l’inégalité précédente équivaut à :
2a
x ax
2 0a
x ax
2
0a
xx
Un carré étant toujours positif, cette dernière inégalité est évidente. Elle est d’ailleurs stricte si on
suppose x a .
La démonstration de la proposition peut alors se faire par récurrence. Il est clair que le premier terme
de la suite u0 est bien strictement supérieur à a ; si l’on suppose que pour un entier n arbitraire,
nu a , alors 1
1
2n n n
n
au g u u a
u
d’après le calcul précédent. Le résultat est donc
prouvé par récurrence.
Ceci garantit en particulier que un ne s’annule jamais, et donc que la suite est bien définie pour toute
valeur de n.
Remarquons que si le premier terme vérifie 00 u a , les termes qui suivent seront tous strictement
supérieur à a d’après le résultat précédent. Enfin si 0u a , alors pour tout entier naturel n,
nu a .
Proposition
La suite (un) est strictement décroissante.
Démonstration
Ce qui équivaut à démontrer que pour tout entier naturel n 1, un + 1 < un.
Différentes méthodes peuvent être utilisées.
Une simple, basée sur une propriété classique de la moyenne arithmétique.
On sait que, pour tout n, un > a . Donc, 1 1
nu a et
n
a aa
u a .
Par conséquent, 1
1
2n n
n
au u
u
, qui est la moyenne arithmétique de deux nombres distincts un et
n
a
u, est à ce titre inférieur strictement au plus grand de ces deux nombres, à savoir un.
5 Là encore, on peut voir que l’inégalité est trivialement vraie si l’on sait que la moyenne arithmétique de deux nombres positifs est toujours
plus grande que leur moyenne géométrique...
200 Mathématiques et TI-Nspire
© T³ France 2010 / Photocopie autorisée
Une deuxième méthode consiste à remarquer que, pour tout n entier naturel, nu a soit 2
nu a et
en divisant par un > 0, n
n
au
u . Par suite, 1
1 1
2 2n n n n n
n
au u u u u
u
.
Enfin, une troisième méthode plus classique consiste à étudier le signe de 1n nu u .
2 2 2
1
21
2 2 2 2
n nn n n
n n n n
n n n n
a u a uu a u a uau u u u
u u u u
On peut alors conclure immédiatement.
Bref la suite (un) est bien décroissante.
Proposition
La suite (un) converge vers a .
Démonstration
Décroissante et minorée, la suite est convergente. Elle converge vers un réel , qui est un point fixe de
la fonction g.
Il reste à résoudre l’équation x g x pour déterminer . Cette équation équivaut à :
1
2
ax x
x
soit 2
ax x
x ou
ax
x
… dont les solutions sont clairement a ou a .
Comme la suite est positive, nécessairement, = a et la suite (un) converge vers a .
1.4 Étude de la rapidité de convergence de cette suite
Le tableur laisse présager une convergence très rapide. En quelques itérations, on obtient les mêmes
décimales que celles renvoyées par la calculatrice. Qu’en est-il exactement ?
Convergence rapide
On a pour tout entier naturel n :
2
1
2 2
210
2 2
2 2
n nn n
n n
n n
n
u a u aau a u a
u u
u a u a
u a
Nous sommes maintenant en mesure de préciser la convergence.
De l’inégalité précédente, sachant aussi que a > 1, on déduit que pour tout entier naturel n :
102
n n
n
u a u a
u a
Comme lim 02
n
n
u a
, et d’après le théorème des gendarmes, on déduit que la suite 1n
n
u a
u a
converge vers 0 : ceci caractérise une convergence rapide.
Des exemples de suites 201
© T³ France 2010 / Photocopie autorisée
Plus précisément la convergence est ici quadratique. En effet, les calculs précédents ont montré que :
2
102
n
n
n
u au a
u
d’où l’on peut déduire que
1
2
10
2
n
nn
u a
uu a
et
1
2
1 1lim lim
2 2
n
n nn
n
u a
u au a
.
Concrètement, dans le calcul approché de a , le nombre de chiffres significatifs des termes de la
suite double à chaque itération. En effet si l’on connaît un avec une erreur inférieure à 10-p
, alors :
2
22
1
100 10
2 2
pn p
n
u au a
a a
et l’on peut dire que un + 1 est connu avec une erreur inférieure à 10–2p
.
Majoration de nu a
De la majoration obtenue au début du paragraphe, on peut déduire les inégalités suivantes :
1
2
2 2
1 1
2 4
22 2
1 1 2
2 8
43 3
2 2 4
2 16
84 4
3 3 8
2 2
21 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 au a u a
a a
u a u au a u a
a a
u a u au a u a
a a
u a u au a u a
a a
u a u au a u a
a a
2
1
1
2
2 2
20 0
1 1 20 donc
2 2
n
n
n
n
u a u au a u a
a a
En faisant le produit membre à membre des inégalités de droite entre nombres positifs, on
obtient après simplification6 :
6 Résultat que l’on peut prouver par récurrence, pour formaliser. Maintenant qu’on a la formule...
202 Mathématiques et TI-Nspire
© T³ France 2010 / Photocopie autorisée
1
2 2
0 01 2 4 ... 2 2 1
1 10
2 2
n n
n nnu a u a u a
a a
L’exposant 2n est un indicateur de la convergence quadratique signalée plus haut.
1.5 Une fonction pour la TI-Nspire
On peut déduire de cette étude un programme de calcul approché de a où a est un réel > 1. En
entrée, peuvent figurer la nombre a, dont on veut calculer la racine carrée, et l’erreur maximale e que
l’on souhaite pour le calcul.
Pour avoir la majoration la plus simple, on peut choisir le terme initial u0 = int 1a 7. Comme
0 1u a et a > 1, on peut alors écrire :
2 11
02
n
nu a
.
On peut donc effectuer le calcul des termes successifs de la suite (un) dans une boucle While, en
sortant lorsque
2 11
2
n
e. On peut aussi, pour information, renvoyer par Disp la valeur de n.
Le programme est donc le suivant :
Les résultats que l’on obtient sont très satisfaisants, avec de nombreuses décimales correctes et peu
d’itérations grâce à la convergence quadratique (/· pour un calcul approché ... ou mieux, on met
comme entrée, par exemple, 2.)
7 C’est notre seul appel à la fonction racine carrée... pour ceux qui trouveraient cela gênant, qu’ils se reportent au paragraphe 1.6…
Des exemples de suites 203
© T³ France 2010 / Photocopie autorisée
Cinq itérations pour obtenir un résultat avec autant de décimales pour 2 , il faut avouer que c’est
bien plus rapide que la lente et fastidieuse méthode qu’on nous enseignait autrefois pour calculer une
valeur approchée de n’importe quelle racine carrée d’entier !
Allons plus loin avec les possibilités arithmétiques de notre calculatrice, en demandant une
erreur e moindre que 10-300
:
On récupère les décimales avec int(10350.ans) : on hérite alors de la très grande puissance du calcul en
nombres entiers sur TI-Nspire.
En les recopiant avec mon traitement de texte favori, on obtient le terme u10 de la suite, dans lequel il
est facile de rajouter une virgule à la bonne place :
1,41421356237309504880168872420969807856967187537694807317667973799073247846210703
8850387534327641572735013846230912297024924836055850737212644121497099935831413222
6659275055927557999505011527820605714701095599716059702745345968620147285174186408
891986095523292304843087143214508397626036279952514079896872533965463318088296406
2061525835239505474575028
Le calcul d’erreur peut être fait. On sait d’après notre étude que : 300
102 2 10u
d’où l’on déduit l’encadrement suivant de 2 : 300
10 1010 2 u u
Sauf erreur de dénombrement, le « grand » 9 dans l’écriture précédente est le 300e chiffre après la
virgule du résultat obtenu et on est sûr que 2 est compris entre le nombre ci-dessus et le nombre
que l’on obtient en remplaçant le 9 par un 8.
Peut-on aller plus loin ? On risque, en multipliant le résultat par une puissance de 10 trop grande,
que le calcul ne puisse plus être mené en entiers-calculatrice ou que l’on se trouve en situation
d’overflow :
204 Mathématiques et TI-Nspire
© T³ France 2010 / Photocopie autorisée
La méthode précédente a des limites, mais elle est intéressante pour faire apparaître très facilement8
de nombreuses décimales, bien plus en tout cas que sur une calculatrice classique.
La plus grande fraction que l’on puisse faire apparaître avec cette fonction heron est obtenue en
une dizaine de secondes pour le calcul de 2 avec une précision moindre que 10-616
On dispose là d’une magnifique valeur approchée, avec beaucoup de décimales… mais on ne peut
rien en faire… La méthode précédente est inefficace. Il faut dire que le numérateur est une fraction
gigantesque possédant 784 chiffres !
Dommage d’abandonner un si magnifique résultat… car on peut faire agir notre fonction divex2 (voir
l’annexe de ce chapitre), stockée dans la bibliothèque division_dec pour récupérer par exemple 620
décimales de cette fraction. En ligne de commande, il faut saisir division_dec\divex2(ans,620), pour
obtenir le résultat dans une chaîne de caractère :
8 Par exemple lors d’un concours, CAPES ou autre.
Des exemples de suites 205
© T³ France 2010 / Photocopie autorisée
Le résultat copié dans le presse-papier et collé ci-dessous est impressionnant (le « grand » 6 est la
616e décimale) :
"1.4142135623730950488016887242096980785696718753769480731766797379907324784
621070388503875343276415727350138462309122970249248360558507372126441214970
999358314132226659275055927557999505011527820605714701095599716059702745345
968620147285174186408891986095523292304843087143214508397626036279952514079
896872533965463318088296406206152583523950547457502877599617298355752203375
318570113543746034084988471603868999706990048150305440277903164542478230684
929369186215805784631115966687130130156185689872372352885092648612494977154
218334204285686060146824720771435854874155657069677653720226485447015858801
6207584749226572260020…"
D’après l’erreur demandée et le fait que la suite décroisse vers sa limite, on peut être sûr que 2 est
compris entre ce nombre, dont nous n’avons d’ailleurs qu’une partie des décimales, et le nombre
obtenu en remplaçant le « grand » 6, qui est la 616e décimale, par un 5. Jolie performance !
Toujours plus, car l’erreur est en réalité plus petite ! On connaît ici la valeur de a, ici 2 : on se
souvient que l’erreur est en réalité majorée par :
2
02 1
1
2
n
nu a
a
… dont on peut calculer une valeur approchée, si l’on prend toutefois la précaution de séparer le
calcul en deux morceaux (pour cause d’underflow, avec un message d’avertissement cette fois en bas
de l’écran) :
Bref, le produit en question, c’est-à-dire l’erreur que l’on cherche à estimer, vaut approximativement
10,4 10 –1401
10 –1400
.
206 Mathématiques et TI-Nspire
© T³ France 2010 / Photocopie autorisée
Dans le calcul de u10, on peut donc s’attendre à avoir environ 1400 chiffres après 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 1400e chiffre après la virgule est un 1 en gras, rouge et agrandi ; par comparaison avec le premier
million de décimales sur le site http://antwrp.gsfc.nasa.gov/htmltest/gifcity/sqrt2.1mil, toutes les
décimales en italique, qui suivent ce 1, sont encore correctes, soit en tout 1567.
Bref, avec cette fonction très performante, et cette « modeste » calculatrice qu’est la TI-Nspire,
nous avons obtenu rien moins que 1567 décimales correctes dans le calcul approché de 2 .
Impressionnant quand même !
1.6 Calcul de la partie entière de la racine carrée
Les puristes râleront : comment ! mais pour utiliser la fonction heron, on a déjà besoin de la fonction
racine carrée de la calculatrice ! n’est-ce pas un peu gênant ?
Pas vraiment, pourrait-on ajouter, car on est en mesure d’améliorer considérablement cette fonction
de la TI-Nspire, qui par exemple n’est pas capable de renvoyer 1567 décimales correctes pour 2 .
Par ailleurs il est possible d’écrire soi-même une fonction – appelons-la intrc – qui donne la partie
entière de la racine carrée de tout nombre réel a 1... et donc le terme initial de la suite étudiée
précédemment... sans s’appuyer bien évidemment sur la fonction racine carrée de la TI-Nspire...
L’idée la plus simple est de faire quelques itérations de la suite précédente à partir d’une valeur
initiale à préciser, jusqu’à ce que la partie entière du résultat soit stabilisée. Cette valeur obtenue est
alors un bon candidat pour être la partie entière de la racine carrée de a : on peut toujours tester si
c’est bien le cas... Pour éviter que le calcul exact n’explose avec des fractions dépassant les capacités
arithmétiques de la calculatrice, on ne prend à chaque itération que la partie entière du résultat.
Or donc, quelle valeur initiale va-t-on prendre pour ces itérations d’approche ? La convergence étant
très rapide, point n’est besoin de partir trop près de a : des considérations sur le nombre de chiffres
de a permettent de majorer grossièrement a par une puissance de 10, valeur initiale que nous
choisirons pour la suite (un).
Des exemples de suites 207
© T³ France 2010 / Photocopie autorisée
Ainsi 123456 qui possède 6 chiffres est inférieur à 106 : sa racine carrée est majorée par 10
3 ; 1234567
qui possède 7 chiffres est inférieur à 107, donc sa racine carrée est majorée par 10
4. Plus
généralement, si p est le nombre de chiffres de a, sa racine carrée est majorée par 10 à la puissance la
valeur arrondie à l’entier le plus proche de 2
p, soit 10int(p/2+1/2).
Avant d’écrire une fonction, on peut observer ce qui se passe sur le tableur, avec des valeurs simples
de a :
On observe que la suite décroît jusqu’à être constante, ou encore décroît puis oscille entre deux
valeurs entières consécutives.
208 Mathématiques et TI-Nspire
© T³ France 2010 / Photocopie autorisée
Plus précisément, si nv a , alors 1
1 1int
2 2n n n n
n n
a av v v v
v v
, d’après les propriétés
signalées plus haut, ce qui veut dire que les valeurs de la suite vont strictement en décroissant. Or il
n’existe pas de suite strictement décroissante d’entiers.
On peut donc appeler p le plus petit entier naturel tel que 1p pv v .
Par contraposition, puisque 1p pv v , c’est que l’entier pv vérifie pv a . On en déduit que
intpv a .
D’autre part, 1
1
1
2p
p
av a
v
, d’après les propriétés vues plus haut. Donc
1
1
1int int
2p
p
av a
v
soit intpv a .
En conséquent, on a bien prouvé que intpv a .
Dans tous les cas, on doit donc poursuivre l’itération tant que les valeurs décroissent strictement : le
moment où la décroissance stricte n’a plus lieu correspond à une valeur up inférieure ou égal à a
qui est la partie entière de la racine carrée de a.
La fonction suivante s’appuie sur les remarques précédentes :
Les résultats renvoyés sont conformes à notre attente :
Des exemples de suites 209
© T³ France 2010 / Photocopie autorisée
La fonction intrc prend même en défaut la calculatrice avec le calcul de la partie entière de 250! ,
mémorisé 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 éléments historiques
Fibonacci, ou Léonard de Pise, (v 1170-v 1250) est un des plus grands mathématiciens du Moyen-
Âge. En 1202, il publie le Liber Abaci9, un traité sur le calcul fondé sur le système décimal, à 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 mentionnés par Fibonacci dans leur
écriture de l’époque. Léonard de Pise s’est fortement inspiré de pratiques répandues à l’époque dans
le monde arabe10
.
Dans ce même livre, il évoque le célèbre problème des lapins11
, conduisant à la célèbre suite qui porte
aujourd’hui son nom :
Un homme possède un couple de lapins dans un certain endroit et on veut savoir combien [de
couples de lapins] sont engendrés par ce couple en un an en sachant que c’est dans leur
nature en un mois de donner naissance à un autre couple, et le deuxième mois ceux qui sont
nés pourront engendrer à leur tour.12
Bref, combien de couples de lapins sont engendrés par un couple au bout d’un an ? Chaque couple
donne naissance à un autre couple chaque mois ; les petits lapins doivent attendre d’avoir deux mois
pour se reproduire.
9 Le livre de l’abaque, ou plus exactement le livre du calcul, car Fibonacci y décrit comment effectuer les calculs sans abaque mais avec les
chiffres indo-arabes du système décimal.
10 Il a parcouru avec son père l’Afrique du nord. Il a séjourné plus longuement à Béjaia (Bougie).
11 Pour la petite histoire, la gestation de la lapine est d’un mois, mais la maturité sexuelle est atteinte à 4 mois. Une portée comporte entre
deux et cinq lapereaux. Fibonacci n’est pas si loin de la réalité !
12 Traduction de ma part, depuis une traduction anglaise de 2002 du Liber Abaci.
210 Mathématiques et TI-Nspire
© T³ France 2010 / Photocopie autorisée
2.2 Mathématisation du problème
Appelons Fn le nombre de lapins à la fin du mois n. Il est clair que 0 1F et
1 1F .
L’évolution de la population est résumée par le dessin qui suit. Notons qu’en clair apparaissent les
lapins qui ne peuvent pas encore avoir de petits. Sont soulignés ceux qui sont en mesure de se
reproduire le mois suivant :
À la fin du deuxième mois, on dispose d’un couple qui a donné naissance à un autre couple : donc
2 2F . Sur ces deux couples, un seul se reproduira le mois suivant. À la fin du troisième mois, on
dispose de 3 couples, dont 2 vont se reproduire le mois suivant : 3 2F . À la fin du quatrième 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’à Fn et cherchons à calculer le terme
suivant Fn + 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 à Fn ;
augmenté du nombre de naissances au mois n + 1 : ce nombre est égal au nombre de couples
pubères, c’est-à-dire ayant la faculté de se reproduire ; il y en a clairement Fn–1 car ils doivent
avoir au moins deux mois.
Par conséquent, la suite vérifie la relation de récurrence, très simple et très classique :
1 1n n nF F F avec F1 = F2 = 1.
Les premiers termes peuvent être calculés sur le tableur :
Des exemples de suites 211
© T³ France 2010 / Photocopie autorisée
La réponse à Léonard de Pise est alors immédiate : au bout d’un an, c’est-à-dire à la fin du onzième
mois, on dispose de 144 lapins, à supposer qu’aucun ne finisse dans une casserole d’ici là...
Nous nous proposons dans la suite d’écrire une fonction, la plus efficace possible, permettant le calcul
d’un 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 Léonard, le terme F4000, si les possibilités de
notre calculatrice nous le permettent.
Évidemment, pour un tel nombre, le tableur, d’une part limité à 2500 lignes, d’autre part très vite
ralenti par la taille importante des nombres en jeu, ne nous est d’aucune utilité. Place à la
programmation !
2.3 Un premier programme
La fonction qui suit, basée sur la définition, donne le terme de rang n de la suite de Fibonacci.
Initialement, on a a = b = 1, ce qui correspond aux valeurs de 0F et de 1F . La variable c, dont la
fonction renvoie la valeur à la fin, est initialisée dès le début à 1 pour le cas où on n’entrerait pas dans
la boucle.
On entre dans la boucle pour des valeurs de n 2. Il faut être vigilant dans les affectations effectuées
pour ne pas perdre écraser intempestivement une valeur. Ainsi l’ordre 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 d’exécution sont acceptables : en un peu moins de 3
secondes, l’énorme F4748 est renvoyé : il possède quand même 993 chiffres.
Nous n’apporterons pas d’améliorations profondes à cette fonction, déjà suffisamment
performante. Toutefois, pour le plaisir de la programmation, on peut par exemple chercher à se
débarrasser de la variable auxiliaire c.
212 Mathématiques et TI-Nspire
© T³ France 2010 / Photocopie autorisée
Au départ a, b et a + b représentent trois valeurs consécutives de la suite de Fibonacci ; l’idée serait
donc de stocker directement a + b dans b… mais on perd la valeur b qui devrait être affectée à la
variable a. On peut en fait la récupérer simplement en calculant b – a (c’est-à-dire a + b – a).
Que renvoie la fonction en sortie ? Dans la version initiale, c’était c, c’est-à-dire a + b : ici il suffit de
renvoyer b, dans lequel on a mémorisé a + b.
Les résultats sont satisfaisants, mais l’amélioration en temps est imperceptible. L’un dans l’autre les
choses reviennent au même13
!
Une dernière idée consiste à faire les calculs avec deux variables a et b – on peut difficilement
envisager moins – et en gardant systématiquement dans a et b deux termes consécutifs 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 dérouleront selon cet algorithme les étapes suivantes :
Étapes : a b
0 F0 = 1 F1 = 1
1 F2 = 2 F3 = 3
2 F4 = 5 F5 = 8
3 F6 = 13 F7 = 21
4 F8 = 34 F9 = 55
5 F10 = 89 F11 = 144
… … …
13 Et le programme devient certainement moins lisible. Il faut se méfier des ruses qui rendent l’écriture du programme opaque…
Des exemples de suites 213
© T³ France 2010 / Photocopie autorisée
À chaque passage dans la boucle, on avance donc de deux nombres dans la suite de Fibonacci : c’est
comme si le « chat botté » avait enfilé des bottes de deux lieues.
Pour le calcul d’un Fn donné, on doit parcourir la boucle int2
n
fois : ainsi pour calculer 4F ou
5F ,
on parcourt deux fois la boucle, 4F est alors dans a et
5F est dans b.
La variable a contient toujours les termes de la suite d’indice pair et b les termes d’indice impair.
Voici une fonction qui tient compte de ces remarques :
Les résultats restent les mêmes que précédemment… mais F4748 semble être obtenu rapidement.
Estimation des temps d’exécution
Sur un seul calcul, il est bien difficile de départager les trois fonctions, même si l’on semble aller de
la plus lente à la plus rapide. Le programme test ci-dessous donne des résultats bien plus précis.
214 Mathématiques et TI-Nspire
© T³ France 2010 / Photocopie autorisée
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 même temps ; enfin avec fibo3(20), seulement
29 secondes sont nécessaires. C’est ce dernier programme qui est le plus rapide : l’image du chat botté
et de ses bottes de « deux lieues » n’est pas usurpée !
2.4 L’approche par les matrices
Changeons complètement de stratégie : passons à une vision matricielle de la relation de récurrence
qui définit 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 01
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 FF
F F F F F
Tout se joue donc sur le calcul de la puissance ne de la matrice
1 1
1 0M
.
Examinons d’ailleurs de plus près les coefficients des puissances de cette matrice :
On peut conjecturer que :
Pour tout entier naturel n supérieur ou égal à 2, 1
1 2
n nn
n n
F FM
F F
.
Démonstration
Ce résultat peut se démontrer par récurrence. Il est vrai pour n = 2 et n = 3. En effet,
2 12
1 0
2 1
1 1
F FM
F F
et 3 23
2 1
3 2
2 1
F FM
F F
.
Supposons que le résultat soit vrai pour un entier arbitraire n : on a alors 1
1 2
n nn
n n
F FM
F F
.
Par conséquent, 1 1 11
1 2 1 2 1 1
1 1
1 0
n n n n n n nn n
n n n n n n n
F F F F F F FM M M
F F F F F F F
, ce qui
prouve le résultat pour l’entier qui suit. La propriété est donc vraie pour tout n supérieur ou égal à 2.
Des exemples de suites 215
© T³ France 2010 / Photocopie autorisée
Le calcul du ne terme de la suite de Fibonacci se ramène donc à celui de la puissance n
e de la matrice
m de laquelle on extrait l’entier situé sur la première ligne et la première colonne.
Voici le programme, très court, qui s’en déduit.
Les résultats sont par contre spectaculaires : 4748F est obtenu très rapidement
La fonction test, précédemment écrite, et utilisée dans les mêmes conditions ne demande plus que 23
secondes : c’est la meilleure performance réalisée jusqu’à présent.
2.5 Utilisation d’une formule explicite
Expression de Fn en fonction de n
La démarche est classique et mérite d’être connue. Notons d’ores et déjà que l’on pourrait s’appuyer
sur l’algèbre linéaire et la structure d’espace vectoriel. Nous avons exclu cette démarche pour que la
démonstration reste accessible à un élève de lycée. Cette démonstration s’articule en plusieurs étapes.
Première étape : cherchons s’il existe une suite géométrique non nulle vérifiant la même relation de
récurrence que la suite de Fibonacci.
Soit (qn) une telle suite géométrique, évidemment de raison non nulle. On peut donc écrire pour tout
entier naturel n, 2 1n n nq q q , soit en divisant par q non nul, 2 1q q .
Un tel q est donc solution de l’équation du second degré q2 – q – 1 = 0.
On obtient bien deux valeurs possibles qui sont 1 5 1 5
et2 2
r s
.
216 Mathématiques et TI-Nspire
© T³ France 2010 / Photocopie autorisée
Deuxième étape : montrons que la suite (Fn) peut s’écrire pour tout entier naturel sous la forme n n
nF r s .
Si l’égalité est vraie pour tout n, elle l’est en particulier pour n = 0 ou 1, ce qui va permettre de
déterminer les valeurs possibles de et .
0
1
1
1
F
F r s
dont les solutions sont
1 s
r s
et
1r
r s
.
Ces valeurs conviennent-elles pour n’importe quel entier n ? Autrement dit, il reste à vérifier que l’on
a bien, pour tout entier naturel n, n n
nF r s .
Par construction, cette égalité est vérifiée pour n = 0 ou n = 1.
Supposons maintenant qu’elle soit vérifiée pour les entiers n et n + 1. Montrons qu’elle 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
Ce qu’il fallait prouver !
Troisième étape : quelle est l’expression de Fn ?
Tout d’abord, déterminons à l’aide de notre TI-Nspire les valeurs de 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 25
n n n
Des exemples de suites 217
© T³ France 2010 / Photocopie autorisée
En conclusion on peut écrire que
1 1
1 1 5 1 5
2 25
n n
nF .
Curieuse formule s’il en est, dont le résultat est entier, malgré les racines carrées qui interviennent !
On la doit à Binet en 1843, mais d’autres mathématiciens la connaissaient, semble-t-il, avant cette
date.
La fonction peut être directement définie en ligne de commande.
On obtient des résultats satisfaisants, mais demandant beaucoup plus de temps : c’est le prix d’un
calcul formel soumis à rude épreuve !
Mais pour des valeurs trop grandes de n (ci-dessous n = 300) apparaissent des problèmes de
ressources insuffisantes pour simplifier les expressions.
Lien avec le nombre d’or
Nous aurons besoin d’un lemme concernant la suite de Fibonacci pour prouver les résultats qui
suivent :
Lemme
Pour tout entier naturel n, 12
1 2 1n
n n nF F F
.
Démonstration
On peut écrire :
22 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
218 Mathématiques et TI-Nspire
© T³ France 2010 / Photocopie autorisée
Par conséquent, on peut écrire de proche en proche :
2 32 2 2 2
1 2 1 1 1 2 2 3 1
12 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 récurrence permettrait de formaliser cette démonstration… en
cachant ses ressorts principaux !
Considérons donc la suite (vn) définie pour tout entier naturel n par :
1nn
n
Fv
F
.
Nous poserons dans tout ce paragraphe 1 5
2
et
1 5 11
2
, en suivant d’ailleurs
des usages courants.
L’expression du terme général de la suite de Fibonacci en fonction de n nous permet d’écrire :
2 2
2 2 2
1
1 11 1 1
1 1
1 1
n n
n n n
nn n nn n n
n
Fv
F
.
Or il est clair que :
lim 0
n
n
car 1
.
Par conséquent, la suite (vn) est convergente et a pour limite 1 5
2
, qui n’est autre que le célèbre
nombre d’or.
Les premières valeurs de la suite (vn) sont données dans la feuille de calcul ci-après :
Des exemples de suites 219
© T³ France 2010 / Photocopie autorisée
Étudions maintenant la qualité de cette convergence.
Remarquons tout d’abord que la suite semble prendre alternativement des valeurs inférieures puis
supérieures au nombre d’or. Précisons ce dernier point.
Proposition
La suite extraite 2 pv est strictement croissante, tandis que la suite extraite 2 1pv est
strictement décroissante.
Démonstration
Tout est basé sur le résultat suivant, valable pour tout entier naturel n :
2 1 1 23 1 3 1 2 2 1 1 22
2 2 2 2
22 1 2 2 1
2 2 2
1
n n n n nn n n n n n n n n n n nn 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 FF F F F F F F F F F F Fv v
F F F F F F F F
F F F F F F F F
F F F F F F
Par conséquent, il est clair que :
si n = 2p,
2
2 2 2
2 2 2
10
p
p p
p p
v vF F
, ce qui prouve que 2 pv est strictement croissante ;
si n = 2p + 1,
2 1
2 3 2 1
2 1 2 3
10
p
p p
p p
v vF F
, ce qui prouve que 2 1pv est strictement décroissante.
Proposition
Les deux suites extraites 2 pv et 2 1pv sont adjacentes.
Démonstration
En effet :
22
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 1p
p p p p p
p p
p p p p p p p p
F F F F Fv v
F F F F F F F F
220 Mathématiques et TI-Nspire
© T³ France 2010 / Photocopie autorisée
…qui tend vers 0 quand n tend vers l’infini.
BILAN : grâce aux deux suites adjacentes mises en évidence, nous disposons de tous les éléments
pour écrire un programme donnant une valeur approchée du nombre d’or, en contrôlant l’erreur
commise. On a en effet, pour tout entier naturel p :
2 2 1p pv v
et les deux suites 2 pv et 2 1pv convergent vers . On dispose de l’encadrement suivant :
2 2 1 2
2 2 1
10 p p p
p p
v v vF F
.
D’où la fonction suivante, donnant une valeur approchée du nombre d’or avec une erreur moindre que
le réel er :
Plutôt que d’appeler deux fois notre performante fonction fibo3 – inutile perte de temps car les
calculs seraient alors recommencés deux fois depuis F0 et F1 –, 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 problème qui nous concerne. Par ailleurs le test de boucle
1 er
ab a été remplacé par
1ab
er, un peu plus rapide.
Remarquer la sortie, qui fait intervenir de façon artificielle la variable er : si er est saisie sous la
forme d’un « nombre à virgule » (0.0001 par exemple), le résultat renvoyé l’est aussi ; sinon (10-4
par
exemple) on récupère une valeur fractionnaire exacte (voir l’écran de gauche ci-dessous).
Comme d’habitude avec TI-Nspire, l’erreur peut être choisie très petite, en mode exact et on peut
alors récupérer les décimales comme on l’a déjà vu (écran de droite).
Si les erreurs deviennent trop petites, on finit par avoir des résultats en virgule flottante normalisée
avec 14 chiffres significatifs : on perd toute la précision. Une erreur moindre que 10-1000
posera
problème : le nombre est mis à 0 (underflow) et son inverse à l’infini. On ne sort plus de la boucle et
il faut interrompre la fonction (touche F12 de l’ordinateur14
).
14 Le mien en tout cas, un portable Acer.
Des exemples de suites 221
© T³ France 2010 / Photocopie autorisée
S’il s’agit de décrocher un record de précision, on peut faire beaucoup mieux, mais gérant soi-même
quelques calculs !
On se souvient que le plus grand nombre de Fibonacci que la TI-Nspire a pu calculer est F4748. Qu’à
cela ne tienne ! La plus précise valeur approchée de que l’on 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
numérateur ne peut pas être multiplié par 10 car il repasse en virgule flottante normalisée, ce qui
empêche l’utilisation de notre fonction divex2 (voir annexe de ce chapitre). On ne peut donc rien faire
de ce magnifique résultat, pas très parlant !
Anticipons donc l’utilisation de divex2 en cherchant un Fn tel que 10Fn soit encore exact pour la
calculatrice :
On y parvient avec F4743, ce qui nous conduit à prendre comme valeur approchée de le terme
v4742 = 4743
4742
F
F, avec une erreur moindre que
4743 4742
1
F F d’après les propriétés vues plus haut.
222 Mathématiques et TI-Nspire
© T³ France 2010 / Photocopie autorisée
Attention à l’underflow : l’erreur doit être calculée en 2 morceaux : elle est moindre que 10,8 10-1983
,
inférieure, pour faire simple à 10-1981
.
La valeur approchée de obtenue est alors :
soit un résultat possédant 2000 décimales :
"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"
Des exemples de suites 223
© T³ France 2010 / Photocopie autorisée
La valeur exacte est comprise entre le nombre précédent et le nombre que l’on obtient en remplaçant
le « grand » 1 (la 1981e décimale) par un 2. La bonne réponse est …172709191 433650137
15.
Performance plus qu’honorable pour une « simple » calculatrice !
2.6 Récursivité et Fibonacci
Évidemment l’écriture d’une fonction récursive est tout indiquée pour le calcul des termes d’une
suite récurrente. L’écriture d’une telle fonction est très simple, tellement qu’on a l’impression de
n’avoir rien écrit d’autre que la définition de la suite elle-même :
Il ne faut cependant pas s’attendre à une grande efficacité, bien moins importante en tout cas que celle
des précédentes fonctions :
Les temps de traitement, même pour des nombres petits (par exemple 25 ou 30), sont tellement
épouvantablement longs16
qu’ils en deviennent rédhibitoires.
La raison en est simple : les appels multiples à la fonction submergent la calculatrice sous le flot des
calculs et saturent très vite sa mémoire.
Pour fixer les idées, appelons an le nombre d’appels nécessaires au calcul de Fn17
. Cherchons donc à
déterminer par exemple a4 :
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. C’est bien sûr pire sur la calculatrice !
17 La première exécution de la fonction, provoquée par l’utilisateur, n’est pas considéré comme un appel.
224 Mathématiques et TI-Nspire
© T³ France 2010 / Photocopie autorisée
F4
F3 F2
F2 F1 F1 F0
F1 F0
On dénombre dans ce cas huit appels, autant que d’arêtes dans le graphe précédent, appels d’ailleurs
souvent redondants, de la fonction.
Le même graphique montre que pour F3, on aurait eu quatre appels et pour F2, on en aurait eu deux.
Pour F5, on peut imaginer le nombre d’appels : l’appel de F4 puis les a4 = 8 appels demandés pour le
calcul de F4 ainsi que l’appel de F3 puis les a3 = 4 appels demandés pour le calcul de F3, soit en tout
a4 + a3 + 2 = 8 + 4 + 2 = 14 appels.
Pour F6, on en aurait eu, en raisonnant de même : 14 + 8 + 2 = 24 appels.
On a plus généralement pour n entier naturel :
0 1
1 1
0, 0
2n n n
a a
a a a
La suite (an) est analogue à la suite de Fibonacci, dont la croissante est géométrique : pour un nombre
même relativement limité, on sature la mémoire par trop d’appels de la fonction.
Il existe des stratégies pour diminuer le nombre d’appels en utilisant d’autres formules, comme
celles qui suivent :
Proposition
Quel que soit l’entier naturel p, on a :
2
2 1 1
2 2
2 2 1
2p p p p
p p p
F F F F
F F F
Démonstration
Nous allons vérifier ces formules par récurrence.
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 F F F
F F F
.
Supposons la propriété démontrée pour l’entier p. On a donc :
2
2 1 1
2 2
2 2 1
2p p p p
p p p
F F F F
F F F
Des exemples de suites 225
© T³ France 2010 / Photocopie autorisée
Calculons pour commencer F2p + 3, dont vous voulons montrer que c’est égal à 2
1 2 12 p p pF F F
2 2 2 2
2 3 2 1 2 2 1 1 1 1
2 22 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
F F F F F F F F F F F
F F F F F F F F F F F
Par ailleurs, pour ce qui concerne F2p + 4, on a :
2 2 2
2 4 2 3 2 2 1 2 1 1
22
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 démontré la propriété pour l’entier qui suit p + 1.
Par conséquent, la propriété a bien été prouvée par récurrence.
En résulte une nouvelle fonction récursive, un peu plus performante que la précédente.
Les résultats obtenus sont conformes à ceux que l’on attendait.
La fonction est plus rapide car elle demande moins d’appels récursifs : à chaque entier n, on appelle
deux fois la fonction, comme précédemment, mais en faisant intervenir des indices de l’ordre de n/2.
On peut s’attendre à ce que la mémoire soit moins saturée que dans la fonction précédente.
Effectivement, on peut calculer Fn avec des indices grands sans saturation de la mémoire :
226 Mathématiques et TI-Nspire
© T³ France 2010 / Photocopie autorisée
3. Calcul d’une valeur approchée de e.
3.1 Quelques éléments d’histoire
Le calcul peut se faire à partir de la célèbre série suivante, dont on sait qu’elle converge vers e, la
célèbre base de la fonction logarithme népérien :
1 1 11 ...
1! 2! !nu
n .
Euler en avait d’ailleurs déjà donné une valeur approché précise dans son Introduction à l’analyse
infinitésimale (1748) :
3.2 Quelques points théoriques
Rappelons tout d’abord les raisons de la convergence de la suite (un).
Comme cette suite est très clairement strictement croissante, la seule question est de savoir si elle est
majorée ou non. Nous montrerons au préalable le résultat suivant :
Proposition
Pour tout entier naturel non nul i : 1! 2ii .
Démonstration
On peut remarquer que cette inégalité est vraie pour i = 0, 1, 2, 3, 4, 5.
Des exemples de suites 227
© T³ France 2010 / Photocopie autorisée
… la calculatrice le confirme pour ceux qui ne voudraient pas faire les calculs.
Procédons donc par récurrence. Supposons la propriété démontrée pour un entier arbitraire k supérieur
ou égal à 4 : on a donc 1! 2kk .
Montrons la propriété pour l’entier qui suit k + 1. Or :
1 11 ! ( 1) ! ( 1)2 2 2 2k k kk k k k
ce que l’on voulait prouver ! L’inégalité est bien prouvée par récurrence.
Proposition
Pour tout entier naturel non nul n, 3nu .
Démonstration
On peut écrire :
0 1 1
1
11
1 1 1 1 1 1 121 ... 1 ... 1 1 2 111! 2! ! 2 2 2 2
2
13 3
2
n
n n n
n
un
D’où il ressort que la suite (un) est majorée par 3.
Étant croissante et majorée, elle admet nécessairement une limite, qui est la base e des logarithmes
népériens18
.
Quelques précisions sur cette convergence
Considérons pour commencer un + p – un, où n et p sont deux entiers naturels non nuls :
2 1
1 1 1...
1 ! 2 ! !
1 1 1 11 ...
1 ! 2 2 3 2 ...
1 1 1 11 ...
1 ! 1 1 1
1 1 1 1 1
11 ! 1 ! 1 1 !1
1
n p n
p
u un n n p
n n n n n n p
n n n n
n
n n n nn
n
L’inégalité précédente est vraie pour tout entier naturel p non nul. En faisant tendre p vers l’infini, on
obtient :
1(0 )
!ne u
nn (1)
Par ailleurs, il est clair que
1
1 !ne u
n
.
18 Que la limite existe ne pose pas de problème, qu’elle soit la base de la fonction logarithme népérien reste à prouver. Voir un bon cours
d’analyse.
228 Mathématiques et TI-Nspire
© T³ France 2010 / Photocopie autorisée
Par conséquent, on obtient l’encadrement suivant de ne u :
Pour tout entier naturel n non nul,
1 1
1 ! !ne u
n nn
.
Cet encadrement va nous permettre de déterminer la rapidité de convergence de la suite (un). En effet,
en multipliant les inégalités précédentes par 1 !n , on obtient :
1 ! 1
1 1 !!
n
n nn e u
nn n
d’où l’on déduit : lim 1 ! 1nn
n e u
. En d’autres termes,
1
1 !ne u
n
Par conséquent,
1
1 ! 1
2 ! 2
n
n
ne u
e u n n, d’où l’on tire que 1 1
lim lim 02
n
n nn
e u
e u n
. Par suite :
La convergence de la suite (un) vers e est rapide.
Au demeurant cette convergence n’est pas superlinéaire (donc en particulier pas quadratique, comme
la convergence de l’algorithme de Héron). En effet, quel que soit le nombre réel r supérieur à 1 :
1 1
1
1 11
1
1 ! 1 ! 1 ! 1 !
2 ! 2 1 ! 2 2
1 ! 1!
2 2
r r r r
n
r
n
r rr
r
n n n n ne u
n n n n ne u
n n nn
n n
… dont il est clair que chaque facteur tend vers l’infini dans la mesure où r est strictement supérieur à
1.
Revenons maintenant aux inégalités (1) de la page précédente, qui peuvent s’écrire :
soit 1
!n nu e u
nn .
Elles suggèrent l’idée de travailler avec la suite (vn) définie, pour tout entier naturel n non nul, par :
1
!n nv u
nn .
Proposition
Les deux suites (un) et (vn) sont adjacentes.
Démonstration
La suite (un) est croissante, nous l’avons vu plus haut.
La suite (vn) est décroissante. 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 nv v u un n nn n n n nn
n n n n n n n n
n n n n n n n n n
Des exemples de suites 229
© T³ France 2010 / Photocopie autorisée
La calculatrice permet de contrôler la fin du calcul – on peut remarquer que les deux résultats sont
identiques – mais pas le début du même calcul, car elle peine avec les factorielles :
Par ailleurs, 1
lim lim 0!
n nn n
v unn
.
3.3 Écriture d’une fonction
Nous disposons de tous les éléments, notamment le fait que les deux suites soient adjacentes, pour
écrire une fonction renvoyant une valeur approchée de e et contrôlant l’erreur sur le résultat. En effet,
pour chaque étape n, on a l’encadrement suivant :
1
!n n nu e v u
nn
si bien que 1
0!
ne unn
. En d’autres termes, un est une valeur approchée par défaut de e à moins
de 1
!nn près.
La fonction suivante a comme paramètre d’entrée un majorant de l’erreur er que l’on souhaite sur le
résultat final.
Pourquoi ne pas utiliser une boucle Loop...Endloop : le test de sortie est reporté à la fin de la
boucle19
. 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 renvoyée par Disp pour information.
Même ruse que dans le paragraphe précédent : si er est saisi avec une virgule, le résultat sera
approché ; sinon il est exact.
19 On aurait pu utiliser While 1/(n.n!)>1/er en prenant garde toutefois d’initialiser n à 0 et u à 2.
230 Mathématiques et TI-Nspire
© T³ France 2010 / Photocopie autorisée
Cette fonction peut donc être utilisée comme précédemment tant en mode approché qu’en mode exact.
Ci-dessous quelques-uns des résultats obtenus.
Le dernier résultat (avec une erreur de 1.E-10) redescendu en ligne de commande montre les chiffres
de réserve, ce qui permet de voir que 2.71828182845 a été arrondi à 12 chiffres significatifs. Il faut
aussi être capable d’interpréter l’erreur et d’apprécier la « qualité » du résultat. On sait que la valeur
obtenue de un est une valeur approchée par défaut à moins de 10-10
près. On peut donc en déduire
l’encadrement 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 sûr des 9 premières décimales. Pas de propagation trop importante des erreurs
d’arrondis, étant donné la relativement faible valeur de n et le fait qu’on effectue des additions.
Examinons maintenant quelques exemples avec un calcul exact en fractions. Il suffit d’entrer une
erreur sous une forme qui ne contient pas de virgule. Comme les calculs sont effectués de manière
exacte, aucune propagation d’erreur d’arrondi n’intervient ici.
Les temps de calcul restent relativement raisonnables (moins de 2 secondes pour le dernier calcul),
car la TI-Nspire est très performante20
:
Il reste à exploiter ces résultats, comme on l’a déjà fait précédemment.
20 C’était moins le cas avec une Voyage 200.
Des exemples de suites 231
© T³ France 2010 / Photocopie autorisée
Tout d’abord, avec la méthode la plus simple, si l’on veut faire vite :
On reconnaît bien, sans la virgule évidemment, les premiers chiffres de la constante e. Un calcul
d’erreur semblable au précédent pourrait être fait.
Sinon, on peut utiliser divex2, pour demander 200 décimales :
Ce qui donne :
"2.7182818284590452353602874713526624977572470936999595749669676277240766303
535475945713821785251664274274663919320030599218174135966290435729003342952
60595630738132328627943490763233829880753195251019010328187143"
où l’on 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 ; l’encadrement est correct).
Bien que les calculs se fassent assez rapidement22
, cherchons quand même à optimiser notre
programme. Une première remarque s’impose : le calcul des factorielles est pénalisant 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 précédent : ainsi pour calculer 301! par exemple, il faut
recommencer depuis le début sans reprendre le calcul de 300!, qu’on vient juste d’effectuer…
Bref, on peut faire plus simple comme le montre la deuxième fonction suivante : les factorielles sont
calculées de proche en proche dans la variable f ; le test est inversé, ce qui allège un peu son
exécution…
21 Voir le site http://www.jlsigrist.com/e.html qui donne le premier million de décimales de e.
22 La calculatrice devient plus poussive avec 10-600 par exemple, 19 secondes, elle trainaille franchement pour 10-900, 56 secondes.
232 Mathématiques et TI-Nspire
© T³ France 2010 / Photocopie autorisée
Malheureusement le gain de temps est imperceptible, malgré les tentatives d’améliorations apportées.
Si le calcul reste lourd pour la calculatrice, c’est sans doute à cause des sommes de fractions avec des
dénominateurs de plus en plus grands.
C’est donc sur ce point qu’il faut concentrer nos efforts. Car il existe une stratégie bien plus efficace
qui va diminuer singulièrement le nombre de calculs à effectuer. Elle s’apparente à la méthode
d’évaluation des polynômes dite de Horner.
Ainsi par exemple pour calculer u10, au lieu d’effectuer les opérations comme elles se présentent :
1 11 ...
1! 10!
soit 10 additions et 9 + 8 + 7 +… + 1 = 45 multiplications,
il vaut mieux procéder de la façon équivalente :
1 1 1 1 1 1 11 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 très appréciable pour des indices
plus grands23
.
Mais cette méthode impose de connaître au préalable l’indice n duquel on va partir car le calcul a lieu
à l’envers à partir de cette valeur de n. Cette valeur de n est liée à la variable er en entrée.
Une première boucle s’impose, simplement pour déterminer l’indice lié à l’erreur choisie. On peut
ensuite dérouler le calcul de un selon le principe que l’on vient de décrire.
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
l’algorithme basique.
Des exemples de suites 233
© T³ France 2010 / Photocopie autorisée
Les résultats sont bien les mêmes que précédemment, dans un temps cette fois-ci beaucoup plus
rapide : la première réponse est donnée en à peu près 3 secondes ! Gain appréciable !
Le plus petite erreur que l’on puisse gérer, c’est 10-997
, avec un numérateur et un dénominateur de 992
chiffres. Comme n = 448, l’erreur commise est majorée par 1
448 448!
2,6 10
-998.
La fonction divex2 de la bibliothèque division_dec donne alors 1000 chiffres après la virgule de u448,
qui est une valeur approchée par défaut de e à moins de 2,62 10-998
près :
"2.7182818284590452353602874713526624977572470936999595749669676277240766303
535475945713821785251664274274663919320030599218174135966290435729003342952
605956307381323286279434907632338298807531952510190115738341879307021540891
499348841675092447614606680822648001684774118537423454424371075390777449920
695517027618386062613313845830007520449338265602976067371132007093287091274
437470472306969772093101416928368190255151086574637721112523897844250569536
967707854499699679468644549059879316368892300987931277361782154249992295763
514822082698951936680331825288693984964651058209392398294887933203625094431
173012381970684161403970198376793206832823764648042953118023287825098194558
153017567173613320698112509961818815930416903515988885193458072738667385894
228792284998920868058257492796104841984443634632449684875602336248270419786
232090021609902353043699418491463140934317381436405462531520961836908887070
167683964243781405927145635490613031072085103837505101157477041718986106873
969655212671546889570350093"
234 Mathématiques et TI-Nspire
© T³ France 2010 / Photocopie autorisée
Les 997 premières décimales sont bonnes si l’on s’en tient au même site que précédemment. L’erreur
est majorée par 2,62 10-998
près. Le réel e est donc compris entre le nombre précédent et le nombre
précédent augmenté de 2,62 10-998
, qui se termine donc par 350355…24
.
3.4 D’une suite à l’autre
À observer le résultat précédent, il semble bien que la suite (vn) soit une meilleure valeur
approchée de e que la suite (un). Montrons ce résultat.
Proposition
La suite (vn) converge vers e plus vite que la suite (un).
Démonstration
En d’autres termes, il suffit de démontrer que lim 0.n
nn
v e
u e
Cherchons d’abord à majorer le numérateur n nv e v e . Il suffit que l’on minore e par exemple
par un+1 :
1 1
1 1 10
! 1 ! 1 !
n n n n n n nv e v u v u u u
nn n n n
Par ailleurs, on a vu plus haut que
1 1
1 ! !ne u
n nn
, d’où l’on déduit :
1
! 1 !n
nn ne u
Par conséquent, en faisant le produit membre à membre de ces inégalités concernant des nombres
strictement positifs :
1 ! 1
1 !
n n
n n
v e nv e
u e e u n n n
ce qui prouve que lim 0.
n
nn
v e
u e
Comme nous l’avions pressenti, la suite (vn) converge donc plus vite vers e que la suite (un). Mais
l’encadrement obtenu plus haut,
10
1 !nv e
n n
, est à peine meilleur que celui dont on disposait
avec (un). Peut-on faire mieux ?
Si l’on observe la démonstration précédente, on se rend compte qu’elle est basée sur une minoration
de e.
Or, le moins que l’on puisse dire, c’est que ces minorations ne manquent pas ! Par exemple, on a aussi
2ne u , ce qui entraine :
2 2
1 1 10
! 1 ! 2 !
1 2 2 3 2 2 2 2
2 ! 2 ! 2 ! 1 2 !
nv enn 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 précédent, c’est …354… pour e.
Des exemples de suites 235
© T³ France 2010 / Photocopie autorisée
Le majorant est un peu meilleur, il équivaut à 3
2
!n n en l’infini.
Ou encore 3ne u et :
1 1 1 10
! 1 ! 2 ! 3 !
1 2 3 2 3 3
3 !
6 6
3 ! 1 2 3 !
nv enn 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 contrôle du calcul formel de la TI-Nspire25
.
Le majorant équivaut cette fois à 3
1
!n n en l’infini, ce qui constitue une petite amélioration de ce qu’on
avait avec un.
Nous pouvons donc adapter la fonction calcule3 à la lumière de ce qui précède. Nous sommes
simplement revenus à la factorielle dans la boucle initiale et nous avons modifié le majorant de
l’erreur conformément au résultat précédent :
Les résultats (voir ci-dessous) sont certes meilleurs, obtenus avec une valeur de n plus petite mais
finalement très proche de celle qu’on a obtenue avec calcule3.
25 Malheureusement, le calcul initial avec les factorielles ne renvoie rien de très exploitable.
236 Mathématiques et TI-Nspire
© T³ France 2010 / Photocopie autorisée
Bref, le jeu n’en vaut pas la chandelle : si elle est plus performante, cette nouvelle fonction n’est pas
pour autant très convaincante.
Nous ne parvenons même pas à égaler le record de décimales précédent : calcule3 renvoie pour 10-995
un résultat approché !
En conséquence, il n’est pas très rentable de chercher à améliorer la convergence de la suite (un), déjà
rapide il faut dire. Contentons-nous des presque mille décimales de e, obtenues avec u448 : c’est une
belle performance pour une « petite » calculatrice !
Des exemples de suites 237
© T³ France 2010 / Photocopie autorisée
ANNEXE : une division améliorée
Explicitons notre fonction divex2, qui permet de récupérer autant de décimales que l’on veut, ou
quasiment, d’un résultat, pourvu qu’il soit écrit sous forme fractionnaire. En entrée, la fonction prend
comme valeurs la fraction x considérée et le nombre n de chiffres après la virgule que l’on souhaite
pour le rationnel x. En sortie, elle renvoie le résultat attendu dans une chaîne de caractères.
Les étapes ne font que reprendre une division que l’on effectuerait à la main.
Tout d’abord, on récupère le numérateur et le dénominateur de x. Une première division euclidienne
donne alors la partie entière de x, que l’on mémorise, suivie d’un point décimal, dans la chaîne de
caractères rep.
Ensuite on enclenche les divisions successives, précisément celles que l’on 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 résultat obtenu est concaténé à la chaîne de caractères rep.
En théorie, pour un rationnel que la TI-Nspire mémorise de façon exacte, on pourra récupérer autant
de chiffres que l’on voudra par cette méthode. Voir par exemple ce qui suit, pour s’en convaincre.