CALCULATRICES (III)

1
UNIVERSITE PARIS 7 DENIS DIDEROT
UFR DE MATHEMATIQUES
PREPARATION CAPES 2003-2004
CALCULATRICES (III)
De nombreux calculs sur les calculatrices actuelles, en particulier les calculatrices formelles, ne
nécessitent pas de programmation. Les langages de programmation dépendant des calculatrices, on
s'intéressera d'abord aux algorithmes et à leurs structures avant d’aborder la programmation. On a choisi
cependant l’expression des algorithmes dans un langage le plus proche possible des langages utilisés dans
les calculatrices pour faciliter les traductions nécessaires. D’autre part, ayant en vue l’oral du CAPES, on
n’a pas cherché la sophistication mais l’efficacité et l’économie.
I. STRUCTURES ALGORITHMIQUES ET PROGRAMMATION
Considérons l’exemple suivant : écrire un programme qui calcule la somme des carrés des n premiers
entiers1. Les deux algorithmes suivants peuvent servir de base à un tel programme :
Algorithme 1 :
Entrée : N (entier positif)
Initialisation : S := 0
Pour K allant de 1 à N, pas de 1
S ← S+K2
Finpour
Rendre S
Sortie : Somme
Algorithme 2 :
Entrée : N (entier positif)
Initialisation : S := 0
Tantque N > 0
S ← S+N2
N ← N − 1
Fintantque
Rendre S
Sortie : Somme
On retrouve dans ces deux algorithmes des étapes (entrée, initialisation, boucle, sortie) qui vont se
traduire de la façon suivante au niveau de la programmation :
Entrée de données
C’est ce qui correspond aux entrées de l’algorithme. Cela se traduit par une instruction de programmation
qui suspend l’exécution jusqu'à la frappe de valeurs pour les entrées par l'utilisateur. Ici il y a une seule
entrée, l’entier N. Sa valeur est affectée à la variable N.
Initialisation des variables :
Un algorithme fait en général intervenir plusieurs variables. Ici les variables N et S (algorithme 2), les
variables N, S et K (algorithme 1). Certaines doivent être initialisées. C’est le cas ici de la variable S à
laquelle on affecte la valeur 0. L’écriture standard pour une telle affectation est S := 0 (ou S ← 0).
Affichage de données :
C’est ce qui correspond aux sorties de l’algorithme. Ceci se traduit par une instruction d’affichage. A
l'écran, pour les deux algorithmes, on fait ici afficher la valeur de S. On peut aussi faire afficher d'autres
types d'objets, notamment des chaînes de caractères.
Structure d'itération ou boucle :
Elle est ici présentée sous deux formes :
• Pour < variable, valeur initiale, valeur finale, incrément > : < Instructions > : FinPour (algorithme 1)
• Tantque < condition > : < Instructions > : Fintantque (algorithme 2).
1 Avec une calculatrice symbolique, il n’est bien sûr pas nécessaire d’écrire un programme pour calculer une telle somme
()
Σ(k2,k,0,N)

2
La première forme suppose que le nombre de boucles soit connu à l’avance, ce qui est le cas ici.
On ne trouve pas en revanche dans ces deux algorithmes très simples une structure fondamentale qui est
la structure conditionnelle :
Structure conditionnelle :
Si < condition > alors : < Instructions > : sinon : < Instructions > : FinSi
II. ADAPTATION AUX CALCULATRICES
Cette adaptation va dépendre des modèles de calculatrices. Les modèles récents se rapprochant de plus
en plus des écritures algorithmiques codifiées ci−dessus.
Entrée de données :
Elle se fait via Input et Prompt sur les modèles Texas, via ?→ sur Casio. Il est utile de faire afficher
sur l'écran à quelle variable correspond la donnée demandée : Prompt le fait automatiquement (ex :
prompt N se traduit par l’affichage ?N). Sinon faire : Input "N=", N (Texas), "N="?→N (Casio)
Initialisation des variables :
Se fait avec STO pour les Texas et avec la flèche →pour les Casio
Affichage de données :
Se fait avec Disp sur Texas. Sur Casio, après le nom de la variable, taper la touche triangle noir
Structures d'itération :
La structure Pour < variable, valeur initiale, valeur finale, incrément > : < Instructions > : FinPour se
traduit par :
For variable (valeur initiale, valeur finale, incrément)
<Instructions>
EndFor
avec des petites variantes suivant les modèles. L'incrément est facultatif s'il est de 1. Par exemple, sur
Casio 99** :
For <valeur initiale>→<nom de la variable>to <valeur finale>Step
<valeur du pas>
<Instructions>
Next
avec là encore, Step facultatif si le pas est de 1.
Pour ce qui est des boucles intégrant une condition, les machines anciennes avaient seulement une
structure de saut inconditionnel de la forme :
Label <numéro>
<Instructions>
Goto <numéro>
La structure Tantque < Condition > : < Instructions > : Fintantque se programmait alors de la façon
suivante :
Label 1
Si non <Condition>
Goto 1
Label 2
Pour les machines récentes, la structure :
While <Condition>
<Instructions>
EndWhile
(ou ses variantes suivant les modèles) est la structure fondamentale et elle traduit directement
l'algorithme. Mais les machines proposent aussi d'autres structures.

3
Sur TI :
Repeat Condition
<Instructions>
End
Cette forme permet la répétition d’un groupe d'instructions jusqu'à ce que la condition soit vraie, mais la
condition est examinée quand <instructions> a été exécuté, ce qui fait que le groupe d'instructions
qui suit Repeat est exécuté au moins une fois.
Sur Casio 99** :
Do <Instructions>
LpWhile Condition
Les instructions suivant Do sont répétées tant que la condition est vraie comme pour While… EndWhile.
Mais comme la condition est en fin, elle est testée après exécution du bloc d'instructions intérieur à la
boucle.
Sur TI, on a aussi une boucle simple :
Loop < Instructions>
EndLoop
dont on peut sortir avec un instruction Exit via la syntaxe :
Loop <Instructions>
If Condition
Exit
EndLoop
Par exemple :
: Loop
: Prompt a,b
: If f(a)*f(b)>0
: Exit
: EndLoop,
Sur Casio, la commande Break à l'intérieur d'une boucle interrompt l'exécution de la boucle et fait sauter
à l'instruction suivant la fin de la boucle.
Conditionnelles :
Les calculatrices les plus simples avaient seulement un saut conditionnel du type :
If <Condition>
<Instruction 1>
<Instruction 2>
ou (Casio) :
<Condition>⇒<Instruction 1>
<Instruction 2>
l'instruction 1 n'étant effectuée que si la condition est satisfaite. Les machines actuelles ont des structures
de programmation qui correspondent exactement à la structure : Si < Condition > alors < Instructions >
sinon < Instructions > FinSi, sous la forme :
If <Condition>Then
<Instructions>
Else <Instructions>
EndIf
ou des formes très voisines, et elles permettent de plus l'imbrication des ces structures.
Par exemple, les TI89 et 92 comportent des structures :
If <Condition 1> Then
<Instructions 1>
Elseif <Condition 2> Then
Instruction 1 est
exécutée si Condition
est vraie et instruction
2sinon.

4
<Instructions 2>
Esle <Instructions 3>
EndIf
Les conditions peuvent être des combinaisons logiques de conditons.
Remarques :
1. Il est prudent de déclarer comme locales les variables internes à un programme car ces variables
peuvent avoir déjà dans la machine une affectation.
2. Vous pouvez aussi définir des fonctions par programmation. Par exemple, pour la somme des
carrées des n premiers entiers, cela donnera sur les TI89 et 92 :
: sommeca(n)
: Func
: Local s
:Ifn≥0 Then
:0→s
: While n≥0
: s+n^2→s
:n−1→n
: EndWhile
: Return s
: Else
: "n doit etre positif"
: End
Dans l'application HOME, vous demandez les valeurs de la fonction de façon usuelle, en tapant :
sommeca(10) par exemple pour avoir la somme des carrés des dix premiers entiers. La frappe de
sommeca(−1) renverra : undef.

5
III. QUELQUES EXEMPLES D’ALGORITHMES EN ANALYSE
1. Programmes sur les suites :
Rappelons qu’il n'est pas nécessaire avec les machines graphiques actuelles de programmer pour obtenir
des valeurs d'une suite. Des programmes peuvent cependant être utiles lorsque des calculs doivent être
itérés, tant qu'une condition est satisfaite, et que l'on ne sait donc pas exactement les termes que l'on veut
calculer.
Exemple 1 : La suite est définie par une récurrence de la forme un+1 = f(un). Elle converge et les termes
de la suite sont tels que deux termes consécutifs soient situés de part et d'autre de la limite. Alors, pour
approcher  avec une précision ε donnée, il suffit de calculer un jusqu'à ce que un − un−1 soit en valeur
absolue inférieur à ε . Bien sûr, la même condition ne garantit absolument pas que c'est le cas, si l'on sait
simplement que la suite est convergente.
Entrées : la valeur initiale U0 et la précision P (correspondant à ε = 10
−
p)
Variables locales : X, Y, I
Initialisation : X := U0 ; N := 0
Y ← f(X)
I ← ABS(Y − X)
Tanque I > 10^-p
X ← Y
Y ← f(X)
I ← ABS(Y − X)
N ← N + 1
FinTantque
Rendre N, X, Y
Sortie : N, uN et vN
Remarque :
la fonction f peut être systématiquement
stockée dans Y1 de Y= ou définie dans
HOME (si l’on souhaite travailler en
calcul exact) , ce qui n'oblige pas à
modifier le programme quand on change
de fonction.
Cet algorithme s'adapte sans difficulté à
des suites du type un+1 = f(n,un)
Exemple 2 :
Adapter cet algorithme à l'étude de deux suites adjacentes imbriquées :
 un+1=f(un, vn)
vn+1=g(un, vn)
Entrées : valeurs initiales U0, V0 et précision P
Initialisation : X := U0 ; Y := V0 ; I := ABS(Y − X) ; N := 0
Tanque I > 10^-P
Z ← F(X,Y)
Y ← G(X,Y)
X ← Z
N ← N+1
I ← ABS(Y − X)
FinTanque
Rendre N, X, Y
Sortie : N, uN et vN tels que uN−vN≤10-p
Voir CAPES 1995 1
è
re épreuve :
a0=a, b0=b, an+1= an+ bn
2 et bn+1= anbn
Démontrer que ces suites sont
convergentes et qu'elles ont la même
limite.
Les programmer.