structures de données
4.2.1 Les boucles
Les boucles d’énumération
Une boucle d’énumération effectue les mêmes calculs pour toutes les valeurs entières d’un indicek∈ {a· · ·b}; l’exemple suivant affiche le débutde la table de multiplication par 7 :
sage: for k in [1..5]:
... print 7*k # bloc qui contient une seule instruction 7
14 21 28 35
Note : lorsque l’on utiliseSagedans un terminal, la saisie d’un tel bloc doit se terminer par une ligne vide supplémentaire.
Les deux-points «:» à la fin de la première ligne introduisent le bloc d’instructions qui est évalué pour chaque valeur successive 1, 2, 3, 4 et 5 de la variablek. À chaque itérationSageaffiche le produit 7×kpar l’intermédiaire de la commande print.
Sur cet exemple le bloc des instructions répétées contient une seule instruction (print) qui est saisie de façon décalée par rapport au mot-clef for. Un bloc composé de plusieurs instructions est caractérisé par des instructions saisies les unes sous les autres avec la même indentation.
La définition des blocs est importante, les deux programmes ci-dessous diffèrent uniquement par l’indentation d’une ligne, et aboutissent à des résultats différents :
sage: S = 0 sage: S = 0
sage: for k in [1..3]: sage: for k in [1..3]:
... S = S+k ... S = S+k
sage: S = 2*S ... S = 2*S
sage: S sage: S
Dans le premier cas l’instruction S = 2*Sest effectuée une seule fois à la fin de la boucle, alors qu’elle est effectuée à chaque itération dans le second cas, d’où des résultats bien différents :
S= (0 + 1 + 2 + 3)·2 = 12 S = ((((0 + 1)·2) + 2)·2 + 3)·2 = 22 Cette boucle sert entre autre à calculer un terme donné d’une suite récurrente et est illustrée dans les exemples placés à la fin de cette section.
BR
OUILLON
Boucles tant que
L’autre famille de boucles est constituée des boucles tant que. Comme les boucles d’énumérationfor, celles-ci évaluent un certain nombre de fois les mêmes instructions ; en revanche le nombre de répétitions n’est pas fixé au début de la boucle mais dépend de la réalisation d’une condition.
La boucletant que, comme son nom l’indique, exécute des instructions tant qu’une condition est réalisée, l’exemple suivant calcule la somme des carrés des entiers naturels dont l’exponentielle est inférieure ou égale à 106, soit 0 + 1 + 4 + 9 +..+ 132 :
sage: S = 0 ; k = 0 # La somme S commence à 0 sage: while e^k <= 10^6: # e^13 <= 10^6 < e^14
... S = S + k^2 # ajout des carrés k^2
... k = k + 1 # une ligne vide est nécessaire ...
sage: S 819
La dernière instruction renvoie la valeur de la variableSet affiche le résultat :
S= X
k∈N ek≤106
k2 =
13
X
k=0
k2= 819, e13≈442413≤106 < e14≈1202604.
Le bloc d’instructions ci-dessous comporte deux instructions d’affectations, la première additionne le nouveau terme, et la seconde passe à l’indice suivant.
Ces deux instructions sont bien placées les unes sous les autres et indentées de la même façon à l’intérieur de la structurewhile.1
L’exemple suivant est un autre exemple typique de la boucle tant que. Il consiste à rechercher, pour un nombre x≥1, l’unique valeurn∈Nvérifiant 2n−1 ≤x < 2n qui est le plus petit entier vérifiant x <2n. Le programme ci-dessous comparex à 2n dont la valeur est successivement 1, 2, 4, 8, etc. ; il effectue ce calcul pourx= 104 :
sage: x = 10^4; u = 1; n = 0
sage: while u <= x: n = n+1; u = 2*u # ou n += 1; u *= 2 sage: n
14
Tant que la condition 2n≤x est vérifiée, ce programme calcule les nouvelles valeurs n+ 1 et 2n+1 = 2·2n des deux variables n et uet les mémorise à la place den et 2n. Cette boucle se termine lorsque la condition n’est plus vérifiée, c’est-à-dire pour x <2n :
x= 104, min{n∈N|x≤2n}= 14, 213= 8192, 214= 16384.
1. Lors de la saisie dans un terminal une ligne vide est nécessaire pour clore la définition du bloc d’instructions de la boucle, avant de demander la valeur de la variableS. Cette condition n’est pas nécessaire en utilisantSagepar l’intermédiaire d’un navigateur internet et sera sous-entendue dans la suite.
BR
OUILLON
Le corps d’une boucletant que n’est pas effectué lorsque l’évaluation du test est faux dès la première évaluation.
Les blocs de commandes simples peuvent aussi être saisis sur une ligne à la suite des deux-points «:» sans définir un nouveau bloc indenté à partir de la ligne suivante.
Exemples d’application aux suites et aux séries
La bouclefor permet de calculer facilement un terme donné d’une suite récurrente, soit par exemple cette suite récurrente :
u0 = 1, ∀n∈N un+1= 1 1 +u2n.
Le programme ci-dessous détermine une approximation numérique du terme un pour n= 10 ; la variable Uest modifiée à chaque itération de la boucle pour passer de la valeurun−1 à un en suivant la formule de récurrence. La première itération calcule u1 à partir de u0 pour n = 1, la deuxième fait de même deu1 à u2 quand n= 2, et la dernière des nitérations modifie la variable Upour passer de un−1 à un :
sage: U = 1.0
sage: for n in [1..20]:
... U = 1 / (1 + U^2) ...
sage: U
0.682360434761105
Le même programme avec l’entier U = 1 à la place de l’approximation numérique U = 1.0 sur la première ligne fait des calculs exacts sur les fractions rationnelles ; le résultat exactu10 est une fraction avec plus d’une centaine de chiffres, etu20 en comporte plusieurs centaines de milliers. Les calculs exacts sont intéressants lorsque les erreurs d’arrondis se cumulent dans les approximations numériques. Sinon, à la main commeà la machine les opérations sur les approximations numériques d’une dizaine de décimales sont plus rapides que celles sur des entiers ou des rationnels faisant intervenir 500, 1000 chiffres, ou plus.
Les sommes ou les produits peuvent être mis sous forme de suites récur-rentes et se calculent de la même manière :
Sn=
n
X
k=1
(2k)(2k+ 1) = 2·3 + 4·5 +· · ·+ (2n)(2n+ 1), S0= 0, Sn=Sn−1+ (2n)(2n+ 1) pour n∈N∗.
La méthode de programmation de cette série est celle des suites récurrentes ; le programme effectue des sommes successives à partir de 0 en additionnant les termes pourk= 0,k= 1, jusqu’à k=n :
BR
Cet exemple illustre une méthode générale de programmation d’une somme, mais, dans ce cas simple, le calcul formel aboutit au résultat en toute généralité :
sage: n, k = var('n k') ; res = sum(2*k*(2*k+1), k, 1, n) sage: res, factor(res) # résultat développé puis factorisé (4/3*n^3 + 3*n^2 + 5/3*n, 1/3*(n + 1)*(4*n + 5)*n)
Ces résultats peuvent aussi être obtenus avecun papier et un crayon à partir de sommes bien connues :
n
Exemples d’approximation de limites de suites
La boucle d’énumération permet de calculer un terme donné d’une suite ou d’une série, la boucletant queest au contraire bien adaptée pour approcher numériquement une limite de suite.
Si une suite (an)n∈N converge vers ` ∈ R, les termes an sont voisins de` pourn assez grand. Il est donc possible d’approcher `par un certain terme an, et le problème mathématique consiste alors à majorer plus ou moins facilement l’erreur|`−an|. Cette majoration est immédiate pour des suites (un)n∈N et (vn)n∈N adjacentes :
les deux suites convergent vers la même limite `,
∀p∈N up ≤ lim
n→+∞un=`= lim
n→+∞vn≤vp,
`−up+v2 p≤ vp−u2 p.
Une étude mathématique prouve que les deux suites ci-dessous sont adjacentes et convergent vers√
ablorsque 0< a < b: u0 =a, v0 =b > a, un+1= 2unvn
un+vn
, vn+1= un+vn
2 .
BR
OUILLON
La limite commune de ces deux suites porte le nom de moyenne arithmético-harmoniques du fait que la moyenne arithmétique de deux nombresaet b est la moyenne au sens usuel (a+b)/2 et la moyenne harmonique h est l’inverse de la moyenne des inverses : 1/h= (1/a+ 1/b)/2 = (a+b)/2ab.
Le programme suivant effectue la vérification sur des valeurs numériques particulières :
sage: U = 2.0; V = 50.0;
sage: while V-U >= 1.0e-6: # remplace le rationnel 10^-6 ... temp = U
... U = 2 * U * V / (U + V) ... V = (temp + V) / 2 ...
sage: U, V
(9.99999999989..., 10.0000000001...)
Les valeurs deun+1 et devn+1 dépendent deun et vn; pour cette raison la boucle principale de ce programme fait intervenir une variable intermédiaire appelée ici temp de façon à ce que les nouvelles valeurs un+1, vn+1 de U, Vdépendent des deux valeurs précédentes un, vn. Les deux premiers blocs ci-dessous définissent les deux mêmes suites alors que le dernier construit deux autres suites (u0n)n et (vn0)n; l’affectation parallèle évite d’utiliser une variable intermédiaire :
temp = 2*U*V/(U+V) U, V = 2*U*V/(U+V), (U+V)/2 U = 2*U*V/(U+V)
V = (U+V)/2 V = (U+V)/2
U = temp (affectation parallèle) u0n+1 = u2u0 0nvn0 n+vn0
vn+10 = u
0 n+1+v0n
2
La sérieSn=Pnk=0(−1)kak est alternée dès que la suite (an)n∈N est décrois-sante et de limite nulle, ceci signifie que les deux suites extraites (S2n)n∈N et (S2n+1)n∈N sont adjacentes de même limite notée `. La suite (Sn)n∈N
converge donc aussi vers cette limite etS2p+1≤`= limn→+∞Sn≤S2p. Le programme suivant illustre ce résultat pour la suiteak = 1/k3 à partir dek= 1, en mémorisant dans deux variablesUetVles deux termes successifs S2n etS2n+1 de la série qui encadrent la limite :
sage: U = 0.0 # la somme S0 est vide, de valeur nulle sage: V =-1.0 # S1 = -1/1^3
sage: n = 0 # U et V contiennent S(2n) et S(2n+1) sage: while U-V >= 1.0e-6:
... n = n+1 # n+ = 1 est équivalent ... U = V + 1/(2*n)^3 # passage de S(2n-1) à S(2n) ... V = U - 1/(2*n+1)^3 # passage de S(2n) à S(2n+1) ...
sage: V, U
(-0.901543155458595, -0.901542184868447)
BR
OUILLON
La boucle principale du programme modifie la valeur de n pour passer à l’indice suivant tant que les deux valeurs S2n et S2n+1 ne sont pas assez proches l’une de l’autre. Il est donc nécessaire d’employer deux variablesUetV pour mémoriser ces deux termes successifs ; le corps de la boucle détermine à partir deS2n−1 successivementS2n etS2n+1, d’où les affectations croisées à Uet à V.
Le programme se termine lorsque deux termes consécutifsS2n+1 etS2n qui encadrent la limite sont suffisamment proches l’un de l’autre, l’erreur d’approximation est 0≤a2n+1=S2n−S2n+1 ≤10−6.
Les programmes sont similaires pour les séries alternées associées à ces suites :
1
logk à partir du rang 2, 1
k, 1
k2, 1
k4, e−klnk = 1/kk. Ces suites tendent plus ou moins vite vers 0 et l’approximation de la limite de ces séries demande selon les cas plus ou moins de calculs.
La recherche d’une précision de 3, 10, 20 ou 100 décimales sur les limites de ces séries consiste à résoudre les inéquations suivantes :
1/logn≤10−3 ⇐⇒n≥e(103) ≈1.97 10434
1/n≤10−3 ⇐⇒n≥103 1/n≤10−10 ⇐⇒n≥1010 1/n2 ≤10−3 ⇐⇒n≥√
103 ≈32 1/n2 ≤10−10 ⇐⇒n≥105 1/n4 ≤10−3 ⇐⇒n≥(103)1/4≈6 1/n4 ≤10−10 ⇐⇒n≥317 e−nlogn≤10−3 ⇐⇒n≥5 e−nlogn≤10−10 ⇐⇒n≥10
1/n2 ≤10−20 ⇐⇒n≥1010 1/n2≤10−100 ⇐⇒n≥1050 1/n4 ≤10−20 ⇐⇒n≥105 1/n4≤10−100 ⇐⇒n≥1025 e−nlogn≤10−20 ⇐⇒n≥17 e−nlogn≤10−100 ⇐⇒n≥57 Dans les cas les plus simples la résolution de ces inéquations détermine donc un indicen à partir duquel la valeurSn permet approcher la limite `de la série, ainsi une boucle d’énumération for est aussi possible. Au contraire une boucle while est nécessaire dès que la résolution algébrique en n de l’inéquationan≤10−p s’avère impossible.
Un programme Sageeffectue de 105 à 107 opérations élémentaires par seconde. Un programme optimisé pour un processeur standard peut effectuer de l’ordre de 109 opérations par seconde.
Certaines approximations des limites précédentes demandent trop de calculs pour être obtenues directement, notamment dès que l’indice n dé-passe un ordre de grandeur de 1010 ou 1012. Une étude mathématique plus approfondie peut parfois permettre de déterminer la limite ou de l’approcher
BR
OUILLON
par d’autres méthodes, ainsi en est-il des séries de Riemann :
n→+∞lim
Par ailleurs Sagepeut calculer formellement certaines de ces séries et déter-mine une approximation deζ(3) avec 1200 décimales en quelques secondes en effectuant bien moins d’opérations que les 10400 nécessaires par l’application directe de la définition :
sage: k = var('k') ; sum((-1)^k/k, k, 1, +oo)
L’autre instruction composée concerne les tests : les instructions effectuées dépendent de la valeur booléenne d’une condition. La structure et deux