Cet article explique comment, sur une calculette HP-15C :

• programmer une suite récurrente;
• calculer un terme quelconque;
• calculer la somme des premiers termes;
• calculer un seuil : le rang minimal pour que les termes de la suite passe un seuil donné.

On traite cela avec l'exemple de la suite (uₙ) définie pour tout entier naturel n par :

Programmer la suite

Il suffit de programmer la fonction f définie par uₙ₊₁ = f(uₙ), à savoir f(x) = 0,1x²−3x−6.

g P/R

   000 {             }
   001 {    42 21  0 } f LBL 0
   002 {       44  1 } STO 1
   003 {           2 } 2
   004 {          14 } y^x
   005 {          48 } .
   006 {           1 } 1
   007 {          20 } ×
   008 {       45  1 } RCL 1
   009 {           3 } 3
   010 {          20 } ×
   011 {          30 } -
   012 {           6 } 6
   013 {          30 } -
   014 {       43 32 } g RTN

g P/R

Une fois sorti du mode programme, on stocke le premier terme uₒ = 1 dans le registre Rₒ :

1 STO 0

En tapant au clavier GSB 0, on peut déjà calculer u₁. Si on recommence GSB 0, on calcule u₂, etc.

Calculer un terme quelconque de la suite

On veut par exemple calculer u₉. On utilise le programme suivant commençant par f LBL A, sans effacer la définition de la suite déjà entrée :

   000 {             }
   001 {    42 21 11 } f LBL A
   002 {           1 } 1
   003 {           0 } 0
   004 {           0 } 0
   005 {           0 } 0
   006 {          10 } ÷
   007 {       44 25 } STO I
   008 {       45  0 } RCL 0
   009 {    42 21  1 } f LBL 1
   010 {    42  6 25 } f ISG I
   011 {       22  2 } GTO 2
   012 {       43 32 } g RTN
   013 {    42 21  2 } f LBL 2
   014 {       32  0 } GSB 0
   015 {       22  1 } GTO 1
   016 {    42 21  0 } f LBL 0
   017 {       44  1 } STO 1
   018 {           2 } 2
   019 {          14 } y^x
   020 {          48 } .
   021 {           1 } 1
   022 {          20 } ×
   023 {       45  1 } RCL 1
   024 {           3 } 3
   025 {          20 } ×
   026 {          30 } -
   027 {           6 } 6
   028 {          30 } -
   029 {       43 32 } g RTN

On met ensuite 9 dans la pile, et on lance f A. On obtient que u₉ ≃ 56794,1620.

Quelques explications sur le programme :

• Le programme commence par diviser 9 par 1000, puis on stocke le résultat dans le registre Index R_I, qui contient donc 0,009. La partie entière de R_I est le compteur de boucle. L'incrément par défaut est 1.
• L'instruction f ISG I incrémente R_I puis le compare à 9. Tant qu'il est plus petit ou égal, le programme effectue le bloc d'instructions compris entre f LBL 2 et GTO 1, à savoir ici le simple GSB 0, qui calcule comme on l'a vu précédemment le terme suivant de la suite.
• Quand le test est faux, c'est à dire que le compteur de boucle R_I dépasse 9, on le programme effectue le bloc d'instructions compris entre GTO 2 et f LBl 0, à savoir ici le simple g RTN. Cette instruction termine le programme.
• Il n'y a rien d'autre à faire : le dernier nombre calculé qui se trouve dans la pile est justement le résultat cherché !
• On peut vérifier en tapant RCL I que le compteur (la partie entière du registre R_I) est 10. On a bien dépassé 9 et le programme s'est bien arrêté quand il le fallait.

Calculer la somme des premiers termes

On veut calculer la somme des termes de la suite, de uₒ jusqu'à u₉ : uₒ+u₁+...+u₉.

On utilise le même programme, en y insérant quelques lignes :

   000 {             }
   001 {    42 21 11 } f LBL A
   002 {           1 } 1
   003 {           0 } 0
   004 {           0 } 0
   005 {           0 } 0
   006 {          10 } ÷
   007 {       44 25 } STO I
   008 {       45  0 } RCL 0
   009 {       44  2 } STO 2
   010 {    42 21  1 } f LBL 1
   011 {    42  6 25 } f ISG I
   012 {       22  2 } GTO 2
   013 {       45  2 } RCL 2
   014 {          34 } x↔y
   015 {       43 32 } g RTN
   016 {    42 21  2 } f LBL 2
   017 {       32  0 } GSB 0
   018 {    44 40  2 } STO + 2
   019 {       22  1 } GTO 1
   020 {    42 21  0 } f LBL 0
   021 {       44  1 } STO 1
   022 {           2 } 2
   023 {          14 } y^x
   024 {          48 } .
   025 {           1 } 1
   026 {          20 } ×
   027 {       45  1 } RCL 1
   028 {           3 } 3
   029 {          20 } ×
   030 {          30 } -
   031 {           6 } 6
   032 {          30 } -
   033 {       43 32 } g RTN

L'utilisation est identique : on met 9 dans la pile, et on lance f A. On obtient toujours que u₉ ≃ 56794,1620. Mais en consultant le deuxième registre de la pile opérationnelle (Y) avec la touche x↔y, on lit la somme cherchée uₒ+u₁+...+u₉ ≃ 57696,9281.

Quelles différences y voit-on ?

• La première est à l'ajout de la ligne 9, STO 2, qui initialise le registre R₂ à la valeur de uₒ. Ce registre contiendra les sommes partielles et, une fois le programme terminé, il contiendra la somme terminale voulue.
• La deuxième est l'ajout à la ligne 18, STO + 2 : on met à jour le registre R₂ en lui ajoutant le terme courant de la suite calculé par GSB 0.
• Enfin la dernière modification est aux lignes 13 et 14 pour que lors de l'affichage final, la somme voulue soit mise dans le deuxième registre de la pile (Y).

Calcul de seuil

On cherche le plus petit rang n, tel que, par exemple, uₙ ⩾ 200. On suppose ici qu'il est possible de trouver cette valeur. On suppose que l'on a déjà programmé la suite sur la calculatrice, comme dans les programmes précédents, enfin que le premier terme est toujours stocké dans le registre Rₒ.

   000 {             }
   001 {    42 21 11 } f LBL A
   002 {       44  2 } STO 2
   003 {           0 } 0
   004 {       44 25 } STO I
   005 {       45  0 } RCL 0
   006 {    42 21  1 } f LBL 1
   007 {       45  2 } RCL 2
   008 {       43 10 } g x≤y
   009 {       22  2 } GTO 2
   010 {          34 } x↔y
   011 {       32  0 } GSB 0
   012 {           1 } 1
   013 {    44 40 25 } STO + I
   014 {          34 } x↔y
   015 {       22  1 } GTO 1
   016 {    42 21  2 } f LBL 2
   017 {       45 25 } RCL I
   018 {       43 32 } g RTN
   019 {    42 21  0 } f LBL 0
   020 {       44  1 } STO 1
   021 {           2 } 2
   022 {          14 } y^x
   023 {          48 } .
   024 {           1 } 1
   025 {          20 } ×
   026 {       45  1 } RCL 1
   027 {           3 } 3
   028 {          20 } ×
   029 {          30 } -
   030 {           6 } 6
   031 {          30 } -
   032 {       43 32 } g RTN

On met le nombre 200 dans le premier registre de la pile opérationnelle (X) et on lance la programme par f LBL A. On obtient n = 8. En faisant défiler les registres de la pile opérationnelle (touche R↓), on retrouve la valeur du seuil et la valeur du dernier terme de la suite calculé : u₈ = 768,8081 :

T: 1,0000
Z: 768,8081
Y: 200,0000
X: 8,0000

Le programme n'est pas essentiellement différent des précédents, si ce n'est que le test de comparaison se fait maintenant sur les termes calculés et non leurs rangs :

• Le registre R₂ contient la valeur du seuil : 200.
• Le registre R_I est toujours le compteur de boucles : il est incrémenté ici par les lignes 12 et 13 : 1 STO + I.
• L'instruction g x≤y permet de comparer les deux premiers registres de la pile (X et Y), qui sont toujours avant cette instruction le terme courant de la suite et le seuil.
• Dès que le seuil est dépassé, on passe au bloc d'instructions commençant f LBL 0 (ligne 16) et on rappelle le dernier R_I pour qu'il soit au sommet de la pile.

Pour une suite strictement décroissante (au moins à partir d'un certain rang), et lorsque l'on cherche le plus petit rang n tel que uₙ ⩽ A, la seule modification à apporter est le changement de la ligne 8 (g x≤y) par le test g TEST 9 qui est la comparaison x≥y.