Introduction à la programmation sur TI-nspire

Geneviève Savard et Chantal Trottier

École de technologie supérieure
11 juin 2012

Table des matières

Résumé .............................................................................................................................................. 1
Références ......................................................................................................................................... 1
Fonctions VS programmes ................................................................................................................ 2
Arrêter un programme ou une fonction............................................................................................. 2
Variables globales et locales ............................................................................................................. 2
Types de données et de variables ...................................................................................................... 3
Exemple 1 : création d’une fonction à partir de l’éditeur ................................................................. 4
Exemple 2 : création d’un programme à partir de l’éditeur .............................................................. 6
Exemple 3 : programme de mathématiques financières de Louis Parent pour GIA400 ................. 10
Exemple 4 : passage d’une fonction en paramètre .......................................................................... 12
Exemple 5 : création d’une fonction sur la voyage 200 (programmation dynamique)................... 13

Résumé
Dans plusieurs de nos cours, il peut être très pratique de créer des programmes sur la TI. La présence
des menus dans l'éditeur de programmes nous simplifie la tâche. Nous aborderons les sujets suivants à
l'aide d'exemples. Création de petits programmes et fonctions. Comment les rendre accessibles à partir
de tous documents. Exploration du menu de l'éditeur de programmes ([Menu] [9]). Vérificateur de
syntaxe, variables locales et globales, opérateurs de contrôle (If Then Else, For, While, etc.), réglages
du programme (degrés, radians, nombre de décimales, etc.), entrées / sorties.

Références
Documentation complète de TI-nspire, chapitre sur la programmation (pages 513-546)
http://seg-apps.etsmtl.ca/nspire/documentation/TI-NSpire_SS_Guide_FR.pdf. Les passages
entre guillemets ci-dessous en sont extraits.
Site TI-Basic Developer, TI-nspire programming http://tibasicdev.wikidot.com/nspire.
« Although the Nspire makes good use of form and screen resolution, the programming is very limited compared to
older versions. This article is meant to give you a brief overview of the programming in the Nspire and how older
versions are preferable if you want to program.» « In truth, the only real application for programs is the use of
math and probability programs. Although the thought of games is conceivable, it would be futile to even attempt
making something even like pong or another simple game. Even creating a guessing game is almost impossible. »
Le site Internet de l’ÉTS sur l’utilisation de la TI–nspire CAS http://seg-apps.etsmtl.ca/nspire/
TI-89/TI-92 Plus Tip List 10.0 http://cb.mty.itesm.mx/talleres/tecnologias/sesion07/doug-
burkett-tip-list-v10.pdf Plusieurs de ces trucs sont encore très pertinents sur la TI-nspire.
Fonctions VS programmes
Une fonction retourne un résultat; ce résultat peut être directement utilisé dans une autre fonc-
tion ou expression. Un programme ne retourne pas de valeur; il peut afficher du texte, créer ou
modifier des variables globales mais ne peut être utilisé dans une autre fonction ou expression.
Les programmes peuvent uniquement être exécutés dans l'application Calculs. Au contraire, les
fonctions peuvent être utilisées dans les applications Calculs, Éditeur mathématique, Tableur &
listes, Graphiques & géométrie et Données & statistiques.

Arrêter un programme ou une fonction

« L'exécution d'un programme se poursuit jusqu'à ce que la dernière instruction ou qu'une commande Stop soit
atteinte. L'exécution d'une fonction se poursuit jusqu'à ce qu'une commande Return soit atteinte.
Pour arrêter manuellement un programme ou une fonction,
Windows® : maintenez enfoncée la touche F12 et appuyez sur Enter plusieurs fois.
Macintosh® : maintenez enfoncée la touche F5 et appuyez sur Enter plusieurs fois.
Unité : maintenez enfoncée la touche On et appuyez sur Enter plusieurs fois. »

Variables globales et locales

Un programme ou une fonction peut utiliser des variables globales déjà définies par l’utilisateur
avant d’appeler le programme.
Par exemple, en MAT145, on définit la fonction Gauche(a,b,n) qui retourne la somme de
gauche de la fonction f (déjà définie et non pas passée en paramètre lors de l’appel de la fonc-
tion) pour l’intervalle [a, b] divisé en n sous-intervalles.
« Un programme ou une fonction peut faire référence à des variables créées au préalable. Cette mé-
thode nécessite que les utilisateurs se rappellent du nom des variables et affectent des valeurs à celles-
ci avant d'utiliser l'objet. »
Un programme peut demander des valeurs à l’utilisateur via des boîtes de dialogue.
« Vous pouvez utiliser les commandes Request et RequestStr dans un programme pour marquer une
pause dans celui-ci et afficher une boîte de dialogue invitant l'utilisateur à fournir des informations. Cette
méthode ne nécessite pas que les utilisateurs se rappellent du nom des variables ni de l'ordre dans
lequel elles doivent être utilisées. »
Un programme (mais pas une fonction) peut créer des variables globales; il suffit de ne pas les
déclarer locales. (Cependant, il est risqué de créer ainsi des variables qui traîneront et cela
pourrait porter à confusion par la suite, surtout si les variables sont nommées n, x ou y! Il est
préférable d’utiliser des noms plus longs et explicites.)
Un programme peut modifier une variable globale; une fonction ne peut pas le faire.
Il faut initialiser les variables locales.
Attention ! « Remarque (CAS) : les fonctions et les programmes ne peuvent pas utiliser une variable
locale pour effectuer des calculs symboliques. » Par exemple, si x est déclarée comme variable lo-
cale, il sera impossible de dériver f(x) par rapport à x. Si on veut dériver par rapport à x à
l’intérieur d’un programme, x doit alors être une variable globale avec le risque d’être déjà af-
fectée, ce qui modifiera le résultat de la dérivée. Pour éviter ce problème, on peut désaffecter la
variable x avec la commande DelVar. Cependant, la valeur préalable de x ne sera plus dispo-
nible pour l’utilisateur.

2 Introduction à la programmation sur TI-nspire

Geneviève Savard et Chantal Trottier, ÉTS
Types de données et de variables
Les types des variables ne sont pas explicitement déclarés en TI-Basic. On n’a pas à gérer les types, à
distinguer un entier d’un réel par exemple. Pourrait-on le faire? Si on tient à vérifier le type d’une va-
riable, on utilise la commande getType( ).
Les types de données pouvant être enregistrés dans une variable sont les suivants :
nombre
fonction
matrice (les vecteurs sont considérés comme des matrices par la TI)
liste
expression (algébrique ou booléenne)
chaîne de caractères

3 Introduction à la programmation sur TI-nspire

Geneviève Savard et Chantal Trottier, ÉTS
Exemple 1 : création d’une fonction à partir de l’éditeur
Nous allons créer une fonction qui permet de trouver, s’il existe, l'inverse modulaire d'un entier a pour
la multiplication modulo n, c’est-à-dire un nombre entier x entre 1 et n-1 tel que a×x = 1 (mod n). Une
telle fonction est très utile en arithmétique modulaire.

1. Ouvrir l’éditeur : [menu] [9] [1] [1] et créer une fonction.

2. Par défaut, l’écran sera alors divisé. C’est pratique à l’ordinateur, mais trop petit sur la calculatrice.
Il est donc préférable de dégrouper ces deux pages : [doc] [5] [8] ou [ctrl] [6].

4 Introduction à la programmation sur TI-nspire

Geneviève Savard et Chantal Trottier, ÉTS
Écrire le code à l’aide des menus. Ici, nous avons ajouté des commentaires.

Il aurait été sage de

préciser dans les
commentaires le type
et la plage de
données permise
pour chacune des
variables. Ici, a et n
doivent être des
entiers, a>0 et n>1.

3. Vérifier la syntaxe et enregistrer : [menu] [2] [1] ou [ctrl] [B]

4. Vérification du fonctionnement dans la fenêtre Calculs.

Vérifions que la fonction invmod(3,5) retourne bien 2, car 3×2=1 (en arithmétique modulo 5). De
plus, vérifions que la fonction retourne undef pour l’inverse de 8 modulo 10 (puisqu’un tel inverse
n’existe pas comme on s’en convainc en testant toutes les possibilités: 8×0=0, 8×1=8, 8×2=6,
8×3=4, 8×4=2, 8×5=0, 8×6=8, 8×7=6, 8×8=4, 8×9=2; jamais 1 comme résultat).

Finalement, vérifions qu’on peut utiliser notre fonction dans une autre fonction de la TI.

5 Introduction à la programmation sur TI-nspire

Geneviève Savard et Chantal Trottier, ÉTS
5. Pour pouvoir utiliser notre nouvelle fonction à partir de n’importe quel classeur, nous devons
a. enregistrer le classeur dans MyLib
b. rafraîchir les bibliothèques pour avoir accès aux fonctions dans le catalogue.
Pour plus de détails, consulter le texte Utilisation de fonctions dans divers classeurs sur le site de
l’ÉTS sur l’utilisation de la TI–nspire CAS
http://seg-apps.etsmtl.ca/nspire/documents/librairie%20publique.pdf

Exemple 2 : création d’un programme à partir de l’éditeur

Reprenons le même exemple de recherche de l'inverse modulaire d'un entier a pour la multiplication
modulo n, mais sous forme de programme. Dans ce programme, nous avons choisi d’utiliser des boîtes
de dialogue plutôt que des paramètres. Ça évite à l’utilisateur du programme d’avoir à se souvenir de
l’ordre des entrées des paramètres (d’abord a, puis ensuite n).

1. Ouvrir l’éditeur de programmes: [menu] [9] [1] [1]

2. Créer un programme

6 Introduction à la programmation sur TI-nspire

Geneviève Savard et Chantal Trottier, ÉTS
3. Encore une fois, par défaut, l’écran sera alors divisé. Il est préférable de dégrouper ces deux pages :
[doc] [5] [8] ou [ctrl] [6].

4. Écrire le code à l’aide des menus.

Remarque : outre l’utilisation des boîtes de dialogues, le code diffère légèrement de celui utilisé pour la
fonction de l’exemple précédent : nous avons utilisé une variable booléenne (invtr) comme condition
dans le While.

Nous avons utilisé des boîtes de

dialogues pour saisir les
nombres a et n.

Nous avons utilisé une variable

booléenne (invtro) comme con-
dition dans le While.

5. Vérifier la syntaxe et enregistrer : [menu] [2] [1] ou [ctrl] [B]

6. Vérifier le fonctionnement dans la fenêtre Calculs.

Effectuons les mêmes calculs que précédemment. D’abord l’inverse de 3 modulo 5 doit être 2.
Ensuite 8 ne possède pas d’inverse modulo 10.

7 Introduction à la programmation sur TI-nspire

Geneviève Savard et Chantal Trottier, ÉTS
Remarquons que nous ne pouvons pas utiliser ce programme dans une fonction. Nous pouvons cepen-
dant copier les résultats obtenus pour les réutiliser.

7. Pour pouvoir utiliser notre nouveau programme à partir de n’importe quel classeur, nous devons
a. enregistrer le classeur dans MyLib
b. rafraîchir les bibliothèques pour avoir accès au programme dans le catalogue. : [doc] [6]

8 Introduction à la programmation sur TI-nspire

Geneviève Savard et Chantal Trottier, ÉTS
 Nous ne voyons pas tout le
commentaire que nous avions entré,
seulement les 40 premiers caractères.

9 Introduction à la programmation sur TI-nspire

Geneviève Savard et Chantal Trottier, ÉTS
Exemple 3 : programme de mathématiques financières de Louis Parent pour GIA400

Problème: Quels sont l’espérance et l’écart-type du taux de rendement interne (TRI)? Quelle est la pro-
babilité que le TRI soit inférieur au taux de rendement minimal acceptable (TRAM)? Approximation du
deuxième moment par expansion de la série de Taylor (explications détaillées dans l’article Estimation
de la moyenne et de l’écart-type du taux de rendement interne d’un projet sujet à des erreurs de prévi-
sion et à leurs propagations dans le temps: Une approche sur TI-nspire, de Louis Parent).

10 Introduction à la programmation sur TI-nspire

Geneviève Savard et Chantal Trottier, ÉTS
11 Introduction à la programmation sur TI-nspire
Geneviève Savard et Chantal Trottier, ÉTS
Utilisation du programme

Exemple 4 : passage d’une fonction en paramètre

Il arrive que l’on veuille créer une fonction ou un programme qui recevra une fonction en paramètre.
C’est possible de le faire, mais la syntaxe est quelque peu surprenante à première vue. En fait, on passe
le nom de la fonction en paramètre (entre guillemets) et ensuite le programme ira chercher et utiliser la
fonction portant ce nom. Vite, un exemple !

12 Introduction à la programmation sur TI-nspire

Geneviève Savard et Chantal Trottier, ÉTS
Exemple 5 : création d’une fonction sur la voyage 200 (programmation dynamique)

Voici comment implémenter sur la TI-voyage 200 une fonction permettant d’obtenir le nombre minimal
de pièces de monnaie totalisant un certain montant. Ici, les différentes pièces sont 1 sou, 5 sous et 8
sous (cet exemple a été préparé pour le cours Mat210). C’est un problème de relation de récurrence.

Bien sûr, on peut utiliser le mode sequence de la TI et y entrer directement la relation de récurrence et
les conditions initiales. On pourra ensuite obtenir n’importe quel terme de la suite. Mais l’algorithme
récursif ainsi créé est très lent car pour calculer le nieme terme, il doit calculer trois termes précédents et
pour chacun de ces termes il doit en calculer 3 autres. Les termes de la suite sont donc calculés
plusieurs fois. L’algorithme présenté ici est beaucoup plus efficace car il calcule une seule fois chaque
terme (en commençant par le début de la suite) et le place en mémoire dans une liste. Il utilise ensuite
cette information pour calculer les termes suivants. C’est un exemple de programmation dynamique.
La programmation dynamique est une méthode ascendante, contrairement à diviser-pour-régner, une
méthode descendante aussi vue en MAT210.

Voici l’algorithme utilisé.

Pour calculer le nombre de pièces pour un montant n, on crée un tableau de n + 1 éléments. On écrira
dans chaque case i, le nombre minimal de pièces nécessaires pour représenter le montant ( i - 1). Notez
que dans l’implémentation en C, la case i désignera le montant i. La case 0 correspondant au montant
0 et la case n au montant n. Mais pour la TI, les cases vont de 1 à n + 1 alors on ajuste l’algorithme.

Ouvrir l’éditeur de programmes et y créer une nouvelle fonction nommée minpiece

13 Introduction à la programmation sur TI-nspire

Geneviève Savard et Chantal Trottier, ÉTS
Entrer le code

14 Introduction à la programmation sur TI-nspire

Geneviève Savard et Chantal Trottier, ÉTS
Utiliser la fonction
Dans le menu Home, appeler la fonction minpiece(15) et placer le résultat dans la variable t. L’élément
16 de la liste t est le nombre minimal de pièces de 1, 5 ou 8 sous qui totalise 15 sous. On voit ici que ce
nombre est 3. Il faut au moins 3 pièces de monnaie pour totaliser 15 sous.

N. B. Pour savoir quelles pièces utiliser pour obtenir 15 sous avec le moins de pièces possible, on procède par soustraction.
Puisque l’élément 8 (16-8) de la liste est 3, on déduit qu’il faut aussi 3 pièces pour totaliser 7 sous. Si on ajoute une pièce de
8 sous, il faudra ainsi 4 pièces pour totaliser 15 sous, ce qui n’est pas minimal. Puisque l’élément 11 (16-5) de la liste est 2,
on déduit qu’il faut 2 pièces pour totaliser 10 sous. Si on ajoute une pièce de 5 sous, il faudra ainsi 3 pièces pour totaliser 15
sous, ce qui est minimal. Nous savons donc qu’une configuration optimale consiste à utiliser au moins une pièce de 5 sous.
On continue ainsi jusqu’à l’obtention d’un 0. Il faudra donc 3 pièces de 5 sous pour totaliser 15 sous avec le moins de
pièces possible.

Remarquons qu’un algorithme vorace aurait utilisé 4 pièces pour totaliser 15 sous : 8 + 5 + 1 + 1=13.
Un tel algorithme prend à chaque fois la pièce de plus haute valeur qui est inférieure ou égale au
montant restant.
Cette fonction reçoit un nombre
n entier et une liste d de valeurs
entières en ordre croissant (par
Truc pour placer exemple, des valeurs de pièces
plusieurs instructions de monnaie).
sur la même ligne.
Elle retourne le nombre de
valeurs qui doivent être utilisées
pour totaliser le nombre n si on
prend à chaque fois « les plus
grandes bouchées ».

15 = 8 + 5 + 1 + 1, donc 4
« bouchées » pour totaliser 15.

N.B. Aucune vérification n’est

effectuée quant au type des
paramètres. Nous ne nous
assurons pas que n est un entier
positif.

On peut démontrer que pour le système monétaire canadien (pièces de 1, 5, 10, 25, 100 et 200 sous),
l’algorithme vorace donne toujours le nombre minimal de pièces requises pour totaliser une somme donnée.

15 Introduction à la programmation sur TI-nspire

Geneviève Savard et Chantal Trottier, ÉTS