Des exemples de suites - univers-ti-nspire.fr1.3 Quelques propriétés de cette suite Quelques...

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


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é.



… 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.



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...



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.



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...



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…



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 :



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.



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

.



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).

http://antwrp.gsfc.nasa.gov/htmltest/gifcity/sqrt2.1mil



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.



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 :



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.



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 :



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.



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…



À 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.



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.



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

.



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



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



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 :



É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



…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.



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.



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"



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.

http://www.nombredor.be/html/decimales_du_nombre_d_or.html



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



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



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 :



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.



… 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.



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



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.



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.



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.

http://www.jlsigrist.com/e.html



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.



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"



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.



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.



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 !



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.

Des exemples de suites - univers-ti-nspire.fr1.3 Quelques propriétés de cette suite Quelques...

Documents

Transcript of Des exemples de suites - univers-ti-nspire.fr1.3 Quelques propriétés de cette suite Quelques...