TI-Nspire Chap14 Qs

Chapitre
14
Chapitre 14.
Programmation
sur TI-Nspire CAS
Ce chapitre permet de dcouvrir les fonctionnalits de la programmation sur TI-Nspire CAS.

Il est complt par le chapitre 15 qui donne des informations sur les bibliothques de programmes.
Sommaire
1.
Introduction ........................................................................................................... 2
2.
Un exemple dalgorithme.................................................................................... 2
3.
Lcriture dun programme ................................................................................. 3

3.1 Transmission des arguments ..................................................................... 3
3.2 Ouverture de lditeur de programme sur une nouvelle page .............. 4
3.3 Ouverture de lditeur de programme dans un partage dcran........... 5
3.4 Affichage dun texte ou dun rsultat......................................................... 5
3.5 Variables locales .......................................................................................... 6
3.6 Premires affectations ................................................................................ 6
3.7 Structures conditionnelles .......................................................................... 7
3.8 Structure itratives....................................................................................... 8
3.9 Interruption dun programme.................................................................... 12
3.10 Insrer un commentaire ............................................................................ 12
3.11 Quelques dernires retouches................................................................. 13
3.12 Fermeture de lditeur de programme .................................................... 14
3.13 Modification ultrieure dun programme ................................................. 15
3.14 Ouverture automatique de lditeur en cas derreur ............................. 15
4. Programme ou fonction ? ................................................................................. 16
4.1 Diffrence entre fonctions et programmes............................................. 16
4.2 Linstruction Return.................................................................................... 17
4.3 Return implicite........................................................................................... 18
4.4 Syntaxe abrge ........................................................................................ 18
5. Rcursivit .......................................................................................................... 18
5.1 Un premier exemple .................................................................................. 19
5.2 Un exemple plus subtil : le problme des tours de Hano. .................. 19
5.3 Les risques de la programmation rcursive........................................... 21
6. Domaine dexistence des programmes et des fonctions............................. 22
7.
Lutilisation de Tableur & listes ........................................................................ 23
Annexe A Interactions avec lapplication Graphiques & gomtrie.................. 26

Annexe B. Syntaxes TI-Nspire CAS et Maple....................................................... 31
Philippe Fortin (Lyce Louis Barthou Pau) / Roland Poms (Lyce Ren Cassin Bayonne)
TI-Nspire CAS en prpa
1. Introduction
Les utilisateurs dj habitus la programmation sur calculatrice seront sans doute un peu surpris par
les possibilits offertes par la version 1.4 (t 2008) de la TI-Nspire CAS. On dispose dun outil trs
performant, mais dans le mme temps on ne retrouve pas certaines instructions plutt classiques sur les
calculatrices comme par exemple Input ou Prompt, ce qui peut ncessiter un petit apprentissage.
TI-Nspire CAS rend possible la construction de fonctions ou de programmes trs volus, comme on
peut le voir par exemple dans le chapitre 11 sur les sries de Fourier. En particulier, ces programmes
pourront utiliser toutes les ressources du calcul formel, tout en tant capables dinteragir avec le
contenu dun cran graphique 1 .
Le contenu de ce chapitre dcrit lutilisation de la version 1.4, sortie pendant lt 2008. Il est
important de le prciser car il est probable que la programmation sur TI-Nspire CAS sera encore
amene voluer dans les mois ou annes venir, et que dautres fonctionnalits lui seront ajoutes.
Des mises jour de ce chapitre seront publies si ncessaire lors de la sortie de ces futures versions.
La version 1.4 de TI-Nspire permet dj de couvrir les besoins du programme des classes
scientifiques, par contre il est certain quelle ne permet pas (pas encore !) lcriture dun jeu interactif
utilisant toutes les ressources de laffichage graphique
2. Un exemple dalgorithme
Connaissez-vous la mthode de rsolution dune quation par dichotomie ? On considre une fonction
f continue, strictement monotone sur un segment a, b , telle que f a et f b soient non nuls, et
de signes diffrents. Il sagit donc dune fonction strictement croissante telle que f a 0 et
f b 0 , ou dune fonction strictement dcroissante telle que f a 0 et f b 0 .
Dans ce cas, il existe une unique valeur x0 a, b telle que f x0 0 .

Comment la trouver ? Lide est de tester ce qui se passe au point c
ab
afin de rduire la taille de
2
lintervalle dans lequel se trouve cette solution.
Si on a beaucoup de chance, f c 0 et notre problme est rsolu !
Dans le cas contraire, on peut tre dans lune des deux situations suivantes :
o
f a et f c sont de signes opposs, et x0 a, c
f a et f c sont de mme signes, et x0 b, c
Le nouvel intervalle dans lequel se trouve x0 ( a, c ou c, b ) est deux fois plus petit que a, b .
Si on ritre le procd, on obtiendra un intervalle dont la taille sera nouveau divise par 2 (et donc 4
fois plus petit que lintervalle de dpart), la fois suivante, la taille aura t divise par 8.
Aprs n tapes, on aura trouv x0 (si on a eu de la chance), ou on pourra affirmer quil se trouve dans
un intervalle dont lamplitude sera gale
ba
2n
Ce dernier point est trait en dtail la fin de ce chapitre.
T France 2008 / Photocopie autorise
Programmation sur TI-Nspire CAS
En seulement 10 tapes, lintervalle de recherche initial aura t remplac par un intervalle 210 1024
fois plus petit. En 10 tapes supplmentaires, on aura un intervalle nouveau divis en 1024. Par
exemple, si lcart initial entre a et b tait gal 1, on est certain davoir en 20 tapes un
encadrement de x0 106 prs.
Voici un exemple dutilisation de cet algorithme.
Nous recherchons ici une valeur approche de 2 . Cest la solution positive de lquation x 2 2 0 .
On considre donc f x x 2 2 . Cette fonction est croissante sur . f 1 0 et f 2 0 .
On a donc x0 1, 2 . Voici les premires tapes de lalgorithme dcrit ci-dessus.
Signe de f c
Conclusion
1.50
1.502 2 0.25 0
1 x0 1.5
1.5
1.25
1.252 2 0.4375 0
1.25 x0 1.5
1.25
1.5
1.375
1.3752 2 0.109375 0
1.375 x0 1.5
1.375
1.5
1.4375
1.43752 2 0.066406 0
1.375 x0 1.4375
3. Lcriture dun programme

Nous allons voir prsent comment cela peut tre trait par un programme.
Nous supposerons ici que la fonction utiliser a pralablement t dfinie dans f1. Cela peut par
exemple se faire dans lcran Graphiques & gomtrie.
3.1 Transmission des arguments

Avant daller plus loin, il peut tre ncessaire de prciser un point. Nous devons communiquer au
programme les deux valeurs initiales utiliser pour a et b. Il nexiste pas de moyen de demander ces
valeurs au cours de lexcution de celui-ci, car des instructions comme Input ou Prompt ne sont pas
disponibles dans les versions actuelles de TI-Nspire.
On va donc utiliser une autre mthode : le passage de ces valeurs en arguments lors de lappel.
Par exemple, pour commencer lalgorithme avec les valeurs 1 et 2, si le nom de notre programme est
par exemple dicho, nous entrerons la commande d i c h o ( 1 , 2 ) .
On retrouve ce mode de fonctionnement dans un logiciel comme Maple, couramment utilis en
classe prpa. Cela ne constitue en rien une particularit de TI-Nspire CAS.
Ce point tant clairci, nous pouvons passer la suite !
3.2 Ouverture de lditeur de programme sur une nouvelle page

Commenons par ouvrir lditeur de programmes. Lorsque lon travaille sur lunit nomade, et non sur
lordinateur, il est souvent prfrable dutiliser cet diteur sur une pleine page (mais il est aussi
possible de le faire dans un partage dcran voir paragraphe 3.3, page 5).
Nous allons donc insrer une premire page avec lapplication Calculs, puis partir de cette page,
utiliser le menu Outils, accessible par / c pour insrer une autre page avec lditeur de
programmes.
Saisir le nom choisi. Nous verrons par la suite quoi correspondent les deux rubriques suivantes.
Nous devons ensuite indiquer le nom des paramtres utiliss lors de lappel de ce programme. Ici, il y
en a deux, contenant les valeurs initiales de a et b. Nous pouvons choisir les noms a0 et b0.
Observer la prsence du caractre * droite du nom d i c h o dans le haut de lcran. Il indique que le
contenu du programme a t modifi, mais na pas t encore sauvegard dans le classeur.
Si vous souhaitez le faire ds maintenant, appuyez sur /B (B : build).
Cela provoquera un contrle de la syntaxe utilise et la sauvegarde si tout est en ordre. Dans le cas
contraire, on obtient un message derreur. En cas doubli du raccourci utiliser, appuyer sur la touche
b, puis utiliser le second choix 2:Vrifier la syntaxe et enregistrer.
3.3 Ouverture de lditeur de programme dans un partage dcran

On peut aussi ouvrir lditeur de programme depuis lapplication Calculs, en provoquant un partage
dcran. Appuyer sur la touche b puis slectionner Fonctions et programmes, diteur de
programmes. On obtient ensuite la mme bote de dialogue que prcdemment, puis lditeur de
programme souvre dans un partage dcran.
3.4 Affichage dun texte ou dun rsultat

Linstruction Disp permet dafficher un texte ( placer entre guillemets) ou une expression. Il est
possible dafficher plusieurs lments dans une mme instruction : il suffit de les sparer par une
virgule.
Lcran de gauche montre ce que lon obtient aprs la saisie (avec le symbole * indiquant que le
programme a t modifi), lcran de droite est obtenu aprs avoir utilis /B.
Pour entrer cette instruction, on peut la saisir directement ou appuyer sur la touche b, puis utiliser
le second choix 6:E/S (entres / sorties), qui contient pour linstant seulement linstruction Disp.
Revenons sur la page prcdente (Calculs) pour faire un premier essai :
Jusquici, tout va bien Il nous reste apprendre notre programme faire cette rsolution.
3.5 Variables locales

Lorsque lon construit un programme, on doit dcider des variables que nous allons utiliser, et les
indiquer au programme. Cela se fait au moyen de linstruction Local. Ici, nous allons utiliser 3
variables : a et b seront les bornes de lintervalle, et c le point situ au centre de celui-ci.
Le programme pourrait fonctionner sans cette instruction Local, mais dans ce cas toutes les oprations
faites sur a, b et c affecteraient les variables de mme nom pouvant exister par ailleurs dans cette
activit, lextrieur de ce programme.
On dit dans ce cas que le programme manipule les variables globales a, b et c.
Un utilisateur de ce programme, ne connaissant pas le nom des variables choisies lintrieur de celuici risquerait donc de modifier accidentellement des valeurs mmorises dans a, b et c en lanant un
appel au programme dicho.
A linverse, si on utilise cette instruction Local, les variables a, b et c deviennent des variables locales
ce programme. Elles nexistent que pendant son excution, et leur valeur na aucune influence sur
celle des variables globales de mme nom pouvant exister par ailleurs dans lactivit.
3.6 Premires affectations

La premire chose faire consiste placer dans a et b les valeurs transmises en paramtres ce
programme. Nous allons ensuite calculer la valeur de c, et lafficher.
Nous pouvons tester ces premires modifications (ne pas oublier dutiliser /B pour les valider)
3.7 Structures conditionnelles

TI-Nspire permet lutilisation des structures suivantes :
If
Condition Then
Instruction1
...
Instruction n
EndIf
Dans le cas o une seule instruction doit tre excute lorsque la condition est vrifie, il est possible
dutiliser la syntaxe abrge :
If
Condition : Instruction
Dans le cas o un traitement spcifique doit tre rserv au cas o la condition nest pas vrifie, on
utilise la structure
If
Condition Then
Instruction1
...
Instruction n
Else
Autre-Instruction1
...
Autre-Instruction n
EndIf
Enfin, dans le cas o plusieurs cas sont possibles, on peut utiliser la structure :
Condition Then
Instruction1
...
Instruction n
ElseIf AutreCondition Then
Autre-Instruction1
...
Autre-Instruction n
ElseIf AutreCondition Then
Autre-Instruction1
...
Autre-Instruction n
...
If
Else
Autre-Instruction1
...
Autre-Instruction n
EndIf
On trouvera ces diffrentes structures dans le menu Contrle :
Lutilisation de ces modles est trs pratique car elle insre directement lensemble du bloc et donc
reprsente un rel gain de temps par rapport lutilisation du clavier de lunit nomade. Elle vite
aussi les erreurs qui peuvent se produire quand on oublie lun des lments (comme par exemple un
EndIf). Pour entrer la construction avec ElseIf, on utilise le modle IfThenElseEndIf puis on
insre autant de blocs ElseIf then que ncessaire.
Pour notre programme, il y a 3 cas possibles. Nous devons calculer limage de c , puis,
Si f c 0 , alors cest termin
Si le signe de f c est le mme que celui de f a , alors on remplace a par c .
Si le signe de f c est le mme que celui de f b , alors on remplace b par c .
Comment tester que f x et f y sont de mme signe ? Une mthode possible consiste faire le
produit, puis de tester si ce produit est bien positif.
Les lignes suivantes de notre programme pourraient donc scrire :

If f1(c)=0 then
Disp c, " est solution !"
ElseIf f1(a)f1(c)>0 then
a:=c
Else
b:=c
EndIf
Disp "[a,b]=",[a,b]
3.8 Structures itratives

En fait, on ne veut pas faire lopration quune seule fois, on veut la rpter, jusqu ce que lintervalle
fasse une taille suffisamment rduite.
Une premire approche consiste fixer le nombre dtapes effectuer. Par exemple, on pourrait
dcider que le programme fera systmatiquement 30 itrations.
Dans ce cas, on peut utiliser la structure suivante :
For
compteur, dbut, fin

Instruction1
...
Instruction n
EndFor
On trouvera galement cette structure dans le menu Contrle ce qui en facilite la saisie sur lunit
nomade.
Par exemple, si nous souhaitons faire 30 itrations, nous pouvons crire :

For i,1,30
c:=(a+b)/2
If f1(c)=0 then
a:=c
Else
b:=c
EndIf
Disp "[a,b]=",[a,b]
EndFor
Attention, si on choisit cette option, on introduit une nouvelle variable i quil faut penser rajouter la
liste de nos variables locales. Il reste rgler un autre point : lorsque lon a la chance de trouver la
bonne solution, il est bien sr inutile de continuer, et il faut sortir immdiatement de la boucle.
Cela peut se faire laide de linstruction Exit, que vous trouverez dans le menu Transferts.
On va donc crire :
For i,1,30
c:=(a+b)/2
If f1(c)=0 then
Exit
a:=c
Else
b:=c
EndIf
Disp "[a,b]=",[a,b]
EndFor
Une autre approche consiste continuer rpter les oprations tant quune condition est vrifie
(taille de lintervalle trop grande et solution non trouve).
Dans ce cas, on utilise la structure suivante :
condition
Instruction1
...
Instruction n
While
EndWhile
10
On trouvera cette structure dans le menu Contrle :
La condition peut sexprimer avec les connecteurs logiques habituels and, or, not
Rappelons galement que la TI-Nspire CAS permet galement dutiliser directement des conditions
sexprimant sous la forme dune encadrement, comme par exemple v1 x v 2 .
Sur lunit nomade, les symboles , et sobtiennent par /<, /= et />.
Ici, on continue tant que b a

On va donc utiliser les lignes suivantes :
While abs(b-a)>e
c:=(a+b)/2
If f1(c)=0 then
a:=c
b:=c
ElseIf f1(a)f1(b)>0 then
a:=c
Else
b:=c
EndIf
Disp "[a,b]=",[a,b]
EndWhile
Lorsque lon a la chance que c soit solution, on remplace a et b par celle-ci, et la condition b a
nest plus satisfaite. Il devient donc inutile dutiliser Exit pour mettre fin la boucle.
Define dicho(a0,b0,e)
Prgm
Local a,b,c
a:=a0
b:=b0
Disp "Rsolution de ",f1(x)=0
Disp "Dans ",[a0,b0]
Le programme se poursuit sur la page suivante
11
While abs(b-a)>e
c:=(a+b)/2
If f1(c)=0 then
a:=c
b:=c
a:=c
Else
b:=c
EndIf
Disp "[a,b]=",[a,b]
c:=(a+b)/2
EndWhile
EndPrgm
Il sutilise prsent avec trois arguments : la valeur initiale de a, celle de b, et la prcision souhaite.
Voici par exemple la rsolution de lquation avec une prcision de 102 :
Informations complmentaires sur les structures itratives
La syntaxe gnrale de la boucle For est la suivante :

For
compteur, dbut, fin, pas

Instruction1
...
Instruction n
EndFor
Elle permet de faire varier le compteur de la valeur fixe par pas.

Par exemple :
For i,0,30,5
Disp i
EndFor
affiche les nombres 0, 5, 10, 15, 20, 25, 30.

Les boucles For EndFor et While EndWhile devraient permettre de couvrir vos besoins courants.
Il existe galement une autre structure Loop EndLoop.
Elle sutilise sous la forme :
Loop
Instruction1
...
Instruction n
EndLoop
12
A priori, cela cre une boucle sans fin, et il est ncessaire de prvoir au moins une instruction
conditionnelle permettant de sortir de cette boucle !
Par exemple
i:=0
Loop
Disp i
i:=i+5
if i=30:Exit
EndLoop
est totalement quivalent

For i,0,30,5
Disp i
EndFor
Il est naturellement plus simple dutiliser cette seconde syntaxe !
3.9 Interruption dun programme

Linstruction Stop permet de mettre fin immdiatement lexcution dun programme. Elle sera
gnralement place dans une instruction conditionnelle, ce qui permettra de mettre fin de manire
anticipe lexcution dun programme quand certaines conditions sont vrifies.
Dans le cas de la rsolution par dichotomie, il serait prudent de commencer par tester que
f (a ) f (b) 0 , et de mettre fin au programme aprs affichage dun message derreur si ce nest pas le
cas. Pour cela, on peut rajouter les lignes suivantes au dbut du programme :
if f1(a0)f1(b0)>0 then
Disp "Erreur, f(a) et f(b) sont de mme signe"
Stop
EndIf
3.10 Insrer un commentaire

Pour ajouter un commentaire dans un programme, Appuyez sur b, utiliser le menu Action, puis
choisir Insrer une annotation. On peut aussi slectionner le caractre dans la table des symboles.
Une ligne commenant par sera ignore. Cela permet de placer des explications dans le texte dun
programme, sans que cela intervienne sur son excution.
Nous verrons une utilisation particulirement intressante de dans le chapitre 15.
13
3.11 Quelques dernires retouches

viter une boucle sans fin !
La version actuelle de notre programme prsente un srieux dfaut

La condition darrt de la boucle porte sur la comparaison b a e . Tant que cette proprit est vraie,
on continue A priori, cela peut sembler sans risque puisque la valeur de b a est divise par 2
chaque tape On peut donc esprer que lon finira bien par avoir b a plus petit que e 1012 , ou
mme que e 1050 . Mais que se passera-t-il si on lance ce programme avec un troisime argument
nul, ou ngatif. Dans ce cas, la condition b a e sera en permanence vrifie, et la boucle
continuera donc indfiniment, ce qui est bien sr trs gnant !
Comment lviter ? Tout simplement en ajoutant un test au dbut du programme :
if e0 then
Disp "Erreur, le troisime argument doit tre positif"
Stop
EndIf
On obtient le symbole en utilisant /<

Si vous oubliez dajouter cette ligne, et lancez lexcution du programme avec un appel du type
d i c h o ( 1 . , 2 . , 0 ) , vous obtiendrez lcran suivant :
Appuyez sur la touche w afin de quitter cette boucle sans fin.

Optimisation
La version actuelle du programme calcule f 1 a chaque tape, pour simplement tester le signe. Il
suffirait pour cela dutiliser la valeur de f 1 a0 puisque le signe sera ensuite toujours le mme. En
utilisant une variable locale supplmentaire dans laquelle on pourra mmoriser la valeur de f 1 a0 on
peut viter ces calculs inutiles. On peut de mme viter de calculer deux fois f c chaque itration.
Scurisation du fonctionnement du programme
Pour linstant, rien ninterdit de donner des valeurs exactes aux arguments dappel.
14
Voici par exemple le type de rsultat obtenu si on utilise d i c h o ( 1 , 2 , 0 . 0 0 0 0 0 1 ) (sans point dcimal
pour les valeurs initiales de a et b) au lieu de d i c h o ( 1 . , 2 . , 0 . 0 0 0 0 0 1 ) :
Tous les calculs ont t faits sous forme symbolique, mais il est bien peu probable que ce soit ce qui
t attendu par lutilisateur de ce programme de recherche de la valeur approche de la solution dune
quation !
Pour lviter, il suffit de modifier deux lignes dans le dbut du programme en crivant
a:=approx(a0)
b:=approx(b0)
3.12 Fermeture de lditeur de programme

Pour refermer lditeur de programme appuyer sur b et slectionner Action, Fermer.
Cela referme lditeur en supprimant la page dans laquelle cet diteur tait utilis, ou le partage
dcran, dans le cas o lon avait choisi douvrir cet diteur sur une page contenant dautres
applications.
15
3.13 Modification ultrieure dun programme

Pour diter nouveau un programme (afin den modifier le contenu) demander louverture de lditeur
de programme (dans une nouvelle page, ou dans un partage dcran), en choisissant cette fois loption
Ouvrir.
On obtient ensuite une liste permettant de choisir le programme que lon souhaite ouvrir.
3.14 Ouverture automatique de lditeur en cas derreur

Si lutilisation dun programme provoque une erreur, on obtient une bote de dialogue proposant
ldition du programme. Il suffit de slectionner ce choix pour
Si le programme est dj en cours ddition, aller sur la page correspondante.
Si ce nest pas le cas, ouvrir un partage dcran avec lditeur de programmes.
Dans les deux cas le curseur sera plac lendroit o lerreur sest produite.
16
4. Programme ou fonction ?
Dans ce qui prcde, nous avons dfini un programme dont le rle tait dafficher les diffrentes
tapes dune dichotomie. Il est galement possible de dfinir des fonctions.
4.1 Diffrence entre fonctions et programmes

Le tableau ci-dessous permet de mettre en vidence certaines similitudes mais aussi certaines
diffrences.
Programmes
Fonctions
Un programme permet deffectuer une suite

doprations de faon automatique.
Les arguments ncessaires au fonctionnement de
ce programme doivent tre transmis lors de
lappel de ce programme.
Une fonction effectue une ou plusieurs oprations

partir des arguments qui lui sont transmis, mais
retourne de plus un rsultat destin une
utilisation ultrieure comme le font toutes les
fonctions usuelles prdfinies : sinus, cosinus,
racine carre ou autres.
Une fonction retourne un rsultat unique,
dpendant des arguments utiliss. Il est cependant
possible de retourner plusieurs valeurs condition
de les placer dans une liste, tout comme le fait la
fonction zeros.
Linstruction Disp permet dafficher des rsultats Une fonction peut aussi utiliser Disp pour afficher
obtenus pendant lexcution du programme.
les tapes du calcul 2 .
Il est gnralement recommand dutiliser des
variables locales, mais il reste possible dagir sur
des variables globales dans les cas o lon
souhaite effectivement le faire. Par exemple, le
programme sur les sries de Fourier prsent dans
le chapitre 11 dfinit des variables globales qui
seront utilisables une fois lexcution du
programme termine.
Une fonction ne peut pas modifier la valeur dune

variable globale. Toute variable dont la valeur est
modifie dans une fonction doit donc tre
obligatoirement dclare comme tant locale.
Par exemple, une variable servant dindex dans
une boucle For EndFor devra obligatoirement
tre dclare dans une instruction Local.
Un programme peut aussi inclure des instructions

permettant de dfinir le mode de fonctionnement
de la TI-Nspire (calcul exact ou approch, degrs
ou radians, nombre de dcimales) ou contenir des
instructions delvar permettant deffacer certaines
variables.
Les instructions composant une fonction ne

peuvent pas comporter un appel une commande
agissant sur le mode de fonctionnement de la
TI-Nspire, dappel une procdure intgre au
systme pouvant modifier des variables globales,
comme LU, QR, SortA, SortD, ni comporter
dappel un programme.
Le choix du type fonction simpose chaque fois que lon cherche construire un algorithme
permettant dobtenir un rsultat qui pourra tre utilis dans un calcul ultrieur.
Ce point constitue une diffrence majeure par rapport aux calculatrices de type TI-89 ou Voyage
200. Cest une amlioration particulirement intressante.
17
4.2 Linstruction Return

Nous allons voir dans ce paragraphe comment crire une fonction retournant la valeur de la racine
dune quation par dichotomie. La syntaxe est trs proche de celle du programme, mais comporte des
diffrences quil est ncessaire de bien comprendre.
La plus importante est que lon renvoie une valeur, et quil faut donc un moyen dindiquer quelle est
cette valeur.
Linstruction Return permet de le faire de manire explicite. On lutilise sous la forme Return rsultat
Voici par exemple la version minimale du programme ou de la fonction utilisant la mthode de
recherche par dichotomie (sans les contrles de validit sur les diffrents arguments) :
Version programme
Define dicho(a0,b0,e)=
Prgm
Local a,b,c,fa,fc
Disp "dans ",[a0,b0]
a:=approx(a0)
b:=approx(b0)
fa:=f1(a)
While abs(b-a)>e
c:=(a+b)/2
fc:=f1(c)
If fc=0 Then
Disp c," est solution"
Stop
ElseIf fa*fc>0 Then
a:=c
Else
b:=c
EndIf
Disp [a,b]
EndWhile
EndPrgm
Version fonction
Define fdicho(a0,b0,e)=
Func
Local a,b,c,fa,fc
Disp "dans ",[a0,b0]
a:=approx(a0)
b:=approx(b0)
fa:=f1(a)
While abs(b-a)>e
c:=(a+b)/2
fc:=f1(c)
If fc=0 Then
Disp c," est solution"
Return c
ElseIf fa*fc>0 Then
a:=c
Else
b:=c
EndIf
Disp [a,b]
EndWhile
Return(a+b)/2
EndFunc
En fait, il ny a que deux diffrences entre la version Programme et la version Fonction.

1. Le bloc Prgm EndPrgm est remplac par un bloc Func EndFunc
2. Une nouvelle instruction, spcifique aux fonctions, permet dinterrompre le droulement de la
fonction et de renvoyer la valeur calcule. Il sagit de linstruction Return. Dans le cas prsent,
ce rsultat pourra tre de diffrentes natures : une chane de caractres en cas derreur, ou une
valeur numrique en cas de fonctionnement normal.
En fait, la diffrence majeure est quil est possible dutiliser le rsultat renvoy par la fonction fdicho
alors que lon ne peut rien faire des rsultats obtenus au cours de lexcution du programme dicho (mis
part, ventuellement, les utiliser manuellement dans une opration de copier / coller).
Par exemple, linstruction s : = 1 + d i c h o ( 0 , 1 , 0 . 0 0 1 ) provoque un message derreur, alors que
s : = 1 + f d i c h o ( 0 , 1 , 0 . 0 0 1 ) est utilisable de la mme manire que s : = 1 + c o s ( 5 ) .
Dans le second cas, la fonction fdicho sera excute (avec affichage des tapes intermdiaires), puis la
valeur obtenue sera ajoute 1, et le rsultat stock dans s .
18
4.3 Return implicite

Dans le cas dune fonction plus simple, il nest pas toujours ncessaire dutiliser explicitement
linstruction Return. Par dfaut, cest le dernier rsultat obtenu avant la fin de lexcution de cette
fonction qui est retourn.
Voici un exemple :
Define u(n)=
Func
if mod(n,2)=0 then
2n+1
Else
3n-1
EndIf
EndFunc
Cette fonction retourne la valeur 2n 1 si n est un nombre pair, et la valeur 3n 1 dans le cas
contraire.
Ce qui est crit ici est strictement quivalent
Define u(n)=
Func
if mod(n,2)=0 then
Return 2n+1
Else
Return 3n-1
EndIf
EndFunc
4.4 Syntaxe abrge

Dans le cas o la fonction ne ncessite quune seule instruction pour indiquer le calcul effectuer, on
peut au choix utiliser lune des syntaxes suivantes :
Define
nomfonct(var1,var2, ...)= Func

Return instruction
EndFunc
Ou plus simplement,
Define
nomfonct(var1,var2, ...)= Func

instruction
EndFunc
Ou mme, encore plus simplement,

nomfonct(var1,var2, ...) := instruction
Cette dernire criture peut tre privilgie lorsque lon travaille sur lunit nomade TI-Nspire pour
dfinir une fonction dont le calcul ne ncessite quune instruction.
Bien noter lutilisation dun simple signe = dans Define, mais de := dans le dernier cas.
Par exemple, la fonction de lexemple prcdent aurait aussi pu tre dfinie par :
u(n):=when(mod(n,2)=0,2n+1,3n-1)
5. Rcursivit
Une fonction qui sappelle elle-mme est appele une fonction rcursive. Cela permet dobtenir des
dfinitions qui peuvent tre extrmement simples.
19
5.1 Un premier exemple

Par exemple, si on souhaite dfinir la suite dfinie par
u0 1
n , un 1 exp( n.un )
On a le choix entre lcriture dune boucle (approche itrative) ou lcriture dune fonction rcursive.
Voici la premire version :
Define u(n)=
Func
Local v,k
v:=1
For k,1,n
v:=exp(-(k-1)*v)
EndFor
Return v
EndFunc
Lide consiste calculer les termes de proche en proche. La variable v va contenir le terme de rang k,
pour k variant de 1 n.
Si n 0 , la boucle ne sera pas du tout effectue, et on en restera la valeur de v fixe au dbut de la
fonction. La valeur retourne sera donc 1. Ce qui est le rsultat attendu.
Si n 0 , on va entrer dans la boucle, avec initialement u0 dans v.
1. Pour k 1 , on va remplacer v par exp 1 1 .v , ce qui correspondra au terme u1 .

2. Pour k 2 , on va remplacer v par exp 2 1 .v , ce qui correspondra au terme u2 .
3.
Pour comprendre le calcul effectu, il est ncessaire de voir que cette suite peut aussi tre dfinie par :
u0 1
*
n , un exp( n 1 .un 1 )
A la fin de la boucle, la variable v contiendra bien la valeur de un .
Voici prsent la version rcursive, totalement immdiate :
Define u(n)=
Func
Local v
if n=0 then
Return 1
Else
Return exp(-(n-1)u(n-1))
EndIf
EndFunc
Cette version est la traduction exacte de la dfinition par rcurrence du terme un
5.2 Un exemple plus subtil : le problme des tours de Hano.

On dispose de trois piquets. On veut dplacer une pile de n disques situs sur un premier piquet vers le
troisime. Ces disques sont de tailles croissantes. On s'interdit de placer un disque sur un disque plus
petit. On peut en revanche utiliser le deuxime piquet pour y placer les disques de faon temporaire.
Quels sont les dplacements effectuer ?
20
Description rcursive de lalgorithme :
Pour dplacer n disques d'un piquet a vers un piquet b, on procde de la

faon suivante :
S'il n'y a qu'un disque dplacer, il suffit de noter le numro du piquet de
dpart et le numro du piquet d'arrive.
Sinon,
1. On dplace les n-1 premiers disques du piquet a vers le piquet
intermdiaire c.
2. On dplace le dernier disque (le plus gros) de a vers b
3. On termine en dplaant les n 1 disques de c vers b.
Il suffit ensuite de remarquer que si a et b reprsentent les numros de deux

piquets, alors le troisime porte toujours le numro c 6 a b . (Par
exemple, si a 1 et b 3 , c 6 1 3 2 .)
On peut en dduire le texte du programme ( gauche) ou de la fonction ( droite) utiliser :

Ce programme affiche les dplacements.
Les arguments sont : le nombre de disques, le
numro du piquet, et le numro de celui darrive.
Cette fonction utilise les mmes arguments et

affiche aussi les tapes. De plus, elle retourne
galement le nombre doprations ncessaires.
Define deplace(n,a,b) = Prgm

If n=1 Then
Disp a," ",b
Else
deplace(n-1,a,6-a-b)
deplace(1,a,b)
deplace(n-1,6-a-b,b)
EndIf
EndPrgm
Define hanoi(n,a,b) = Func

Local n1,n2,n3
If n=1 Then
Disp a," ",b
Return 1
Else
n1:=hanoi(n-1,a,6-a-b)
n2:=hanoi(1,a,b)
n3:=hanoi(n-1,6-a-b,b)
Return n1+n2+n3
EndIf
EndFunc
On retrouve les 7 dplacements de lillustration ci-dessus. La fonction permet de vrifier quavec une
pile de 4 disques, 15 dplacements sont ncessaires, puis 31 pour 5 disques et 63 pour 6
Vous aurez peut-tre dj reconnu le dbut dune suite assez classique
En fait, il est facile de dterminer le nombre de dplacements ncessaires. Pour dplacer n 1 disques,
il est ncessaire den dplacer n, puis 1, puis encore n, do un 1 un 1 un 2un 1 .
u1 1
La suite est donc dfinie par les relations
.
n , un 1 2un 1
21
On peut montrer (par rcurrence, ou en sintressant vn un 1 ), que : n , un 2n 1 .
5.3 Les risques de la programmation rcursive

Lapparente simplicit de lcriture dun programme rcursif peut en masquer la complexit
dexcution. Dans certains cas, le choix dune programmation rcursive peut savrer extrmement
pnalisante. Ceci est expliqu dans le chapitre 8, sur les suites et les sries. Voir le paragraphe 2.1
Il faut aussi faire attention au risque de boucle sans fin que peut prsenter une criture rcursive.
Reprenons lexemple de la fonction calculant les termes dune suite dfinie par rcurrence :
Define u(n)=
Func
Local v
If n=0 then
Return 1
Else
EndIf
EndFunc
Que se passera-t-il si lon demande par erreur le calcul de la valeur pour n 1 ?

La fonction va chercher calculer limage de n 1 , donc de 2 , et donc celle de 3 , etc
Il ne restera plus que la solution dappuyer sur la touche w pour interrompre ces calculs !
On retrouvera le mme problme si on part dune valeur non entire, comme par exemple 1.5 : la
fonction a besoin de calculer limage de 0.5, et donc celles de 0.5 , 1.5 , 2.5 On entre l aussi
dans une suite dappels sans fin. Il pourrait donc tre prudent, mme si ce nest pas strictement
indispensable de commencer tester que largument donn lors de lappel du programme est bien un
entier positif Cela peut par exemple tre fait par la fonction suivante :
Define is_posint (n)=
Func
If getType(n)"NUM" then
Return false
Else
Return (n0 and int(n)=n)
EndIf
EndFunc
On commence par sassurer que largument est bien un nombre, et, si cest le cas, on renvoie la valeur
obtenue en testant si ce nombre est positif ou nul, et sil est gal sa partie entire (donc entier).
Pour le premier test (est-ce bien un nombre ?), nous avons utilis GetType. Si var dsigne le nom
dune variable, lappel de GetType(var) retournera la chane de caractres indique ci-dessous :
Nombres entiers, nombres dcimaux, nombres rationnels
"NUM"
Nombres rels exprims sous forme exacte et nappartenant pas la

catgorie prcdente (comme par exemple 1 2 ), nombres complexes,
expressions mathmatiques
"EXPR"
Liste dlments
"LIST"
Matrices
"MATRIX"
Chanes de caractres
"STRING"
22
On peut prsent crire notre fonction sous la forme :

Define u(n)=
Func
Local v
if not is_posint(n) then
Return "Erreur"
ElseIf n=0 then
Return 1
Else
EndIf
EndFunc
Dans lexemple ci-dessus, nous avons dabord appris TI-Nspire reconnatre les entiers positifs
laide dune fonction auxiliaire, puis nous avons utilis cette fonction pour simplifier lcriture de la
fonction principale. Ce type dapproche, o lon dcompose un traitement parfois complexe en
oprations plus simples est un moyen efficace daborder la programmation dun algorithme.
6. Domaine dexistence des programmes et des fonctions

Les calculatrices ordinaires travaillent dans un environnement unique, et toutes les variables,
fonctions ou programmes qui ont t crs sont accessibles tout instant. TI-Nspire CAS est un outil
volu qui travaille avec une logique diffrente. Les objets sont crs dans une Activit prsente dans
un Classeur, et nexistent plus en dehors 3 . Par exemple, si on cre deux variables a et b ainsi quune
fonction dans la premire activit dun classeur, aucun de ces objets ne sera accessible dans une autre.
Ce type dorganisation nest pas spcifique TI-Nspire, et tout ceci est sans doute dj familier aux
utilisateurs dautres logiciels dj utiliss dans les classes prparatoires, comme Maple.
23
Il existe heureusement un moyen de rendre accessible un ensemble de fonctions ou de programmes

utiles tous les classeurs. La solution propose par TI-Nspire CAS, la cration de bibliothques de
programmes, sera tudie dans le chapitre 15.
7. Lutilisation de Tableur & listes

Dans de nombreux cas, lutilisation de lapplication Tableur & listes permet dviter lcriture dune
fonction ou dun programme ! Nous en avons vu un premier exemple dans le chapitre 1, avec le calcul
des termes de la suite de Fibonacci. Pour mettre en place lalgorithme de dichotomie tudi dans ce
chapitre, on ouvre un page Graphiques & gomtrie, et on y dfinit f1. On ouvre ensuite une page avec
lapplication Tableur & listes, et on place les deux valeurs initiales 1 et 2 dans les cellules a 1 et b 1 .
Dans c 1 , on crit = ( a 1 + b 1 ) / 2 et dans d 1 , on inscrit = f 1 ( c 1 ) .
La ligne suivante va contenir les formules ncessaires pour effectuer la premire tape.
Oublions pour linstant le cas particulier o lon aurait la chance dobtenir la bonne valeur directement
(en fait, il est impossible que cela arrive ici : le nombre recherch est irrationnel).
Si le signe de d 1 est le mme que celui de f 1 ( a 1 ) , c'est--dire si le produit des deux est positif,
on doit remplacer a par c, c'est--dire placer dans a 2 le contenu actuellement prsent dans c 1 .
Dans le cas contraire, on doit placer dans a 2 la valeur de a qui tait prsente dans a 1 .
Pour obtenir ce comportement, on crit la formule suivante dans a 2 :

=when(f1(a1)d10,c1,a1)
On procde de manire analogue dans la cellule b 2 , o lon crit : w h e n ( f 1 ( b 1 ) d 1 0 , c 1 , b 1 )

Dans la cellule c 2 , on place la formule = ( a 2 + b 2 ) / 2 et dans la cellule d 2 , on crit = f 1 ( c 2 ) .
On nest pas vritablement oblig dcrire ces deux formules. Il suffit de recopier les cellules c 1 et d 1
dans c 2 et d 2 . Comme sur tout autre tableur, le contenu initial (qui faisait rfrence des cellules
situes sur la ligne 1) est adapt pour faire maintenant rfrence des cellules situes sur la ligne 2.
On obtient ainsi un tableau comportant les deux lignes suivantes :
24
Placez le curseur en a 2 , appuyez sur la touche g, et tout en maintenant cette touche enfonce,
dplacez-vous vers la droite de manire slectionner les cellules a 2 d 2 . Ouvrez alors le menu
contextuel par /b, et slectionnez Saisie rapide, de manire obtenir lcran ci-dessous :
Il suffit ensuite de se dplacer vers le bas avec le Nav Pad pour dfinir la zone dans laquelle on
souhaite recopier les formules. On termine en appuyant sur le bouton central :
Remontez ensuite sur les premires lignes du tableur pour revoir les tapes de lalgorithme.
25
Les rsultats obtenus dans les cellules des 2 premires colonnes de la ligne 11 correspondent la fin
de la dixime tape.
Ils montrent que 1.41406 x0 1.41504 .
Pour plus de prcision, tendez le contenu des cellules a11, b11, c11 et d11 aux 10 lignes suivantes.
On obtient ainsi x0 1.41421

Une fois cre, cette feuille de calcul est utilisable avec toute autre fonction continue, strictement
monotone sur un intervalle a, b , et prenant en a et en b des valeurs de signes opposs.
Cherchons par exemple la racine de x cos x 0 . Compte-tenu de la reprsentation graphique, nous
partons cette fois de lintervalle 0,1 . Il suffit de modifier le contenu des cellules a 1 et b 1 .
Lensemble du tableau est mis jour, et on peut suivre les tapes en faisant dfiler les crans vers le
bas.
Comme dans lapplication Calculs, utilisez /3 et /9 pour parcourir les calculs :
26
Annexe A
Interactions avec lapplication Graphiques & gomtrie
La lecture de cette section nest absolument pas indispensable pour une utilisation classique de la
TI-Nspire.
Son contenu sadresse plutt des utilisateurs dj expriments, souhaitant aller plus loin dans
lutilisation de ce produit.
A priori, la TI-Nspire ne dispose pas dinstructions permettant de faire des constructions graphiques. Il
semble donc difficile de pouvoir parvenir au rsultat annonc dans le titre !
Il est cependant possible davoir certaines interactions en utilisant les ides suivantes :
Si une courbe reprsentant une fonction a t construite dans un cran Graphique & gomtrie,
alors il sera possible de modifier le trac de cette courbe en redfinissant cette fonction depuis
un programme.
Si un nuage de points, isols ou relis par des segments de droites, est dfini par 2 listes, et est
reprsent dans Graphique & gomtrie, alors il sera possible dagir sur cette reprsentation en
redfinissant le contenu de ces deux listes.
Il est possible de lier les variables dfinissant les valeurs extrmes sur les axes, ou les
graduations. Il sera possible de modifier ces valeurs depuis un programme, et donc de
modifier le cadrage.
Nous allons prsent voir un programme utilisant ces diffrentes mthodes.

Celui-ci est destin illustrer la mthode des rectangles.
Lappel de ce programme devra provoquer une mise jour de lcran Graphiques & Gomtrie, afin
dafficher la fonction que lon souhaite tudier, ainsi que les rectangles utiliss.
Sur une TI-89 ou une voyage 200, on utiliserait des instructions graphiques spcialises pour faire ce
travail. La mthode que lon va utiliser avec la version 1.4 de TI-Nspire, qui ne dispose pas de ces
instructions, est radicalement diffrente.
On va construire ces rectangles sous la forme dun nuage de points relis par des segments de droites.
Pour cela, nous devons dterminer les coordonnes des sommets, et les placer dans deux listes (une
pour les abscisses, lautre pour les ordonnes).
Voici un exemple, avec 4 rectangles, permettant de comprendre la nature de ces listes.
Le tableau ci-dessous donne les coordonnes des diffrents
points :
x0
0
x0
x1
x1
x1
x2
x2
x2
x3
x3
x3
x4
x4
y1
y1
y2
y2
y3
y3
y4
y4
Le nuage de points sera donc dfini par les listes :

l1 {x0 , x0 , x1 , x1 , x1 , x2 , x2 , x2 , x3 , x3 , x3 , x4 , x4 , x0 }
l1 {0, y1 , y1 ,0, y2 , y2 ,0, y3 , y3 ,0, y4 , y4 ,0,0}
x0
0
27
Voici prsent un programme qui va se charger de la construction de ces listes, et qui dfinira
galement lexpression que lon souhaite placer dans f1.
Define rectangles(ex,a,b,n)=
Prgm
Local h,lx,ly
Dfinition de la fonction f1
expr("Define f1(x)="&string(ex))
Calcul du pas de la subdivision
h :=(b-a)/n
Construction de la liste des valeurs Xk de la subdivision
lx:=seq(a+k*h,k,0,n)
Liste des images des Xk pour k compris entre 0 et n-1
ly:=f1(seq(a+k*h,k,0,n-1))
Construction de la liste des abscisses des points
l1:={lx[1],lx[1]}
For i,2,n+1
l1:=augment(l1,{lx[i],lx[i],lx[i]})
EndFor
Construction de la liste des ordonnes des points
l2:={}
For i,1,n
l2:=augment(l2,{0,ly[i],ly[i]})
EndFor
l2:=augment(l2,{0,0})
EndPrgm
Voici quelques explications sur les instructions utilises par ce programme.

1. Dfinition de f1
La premire instruction, qui fait appel expr et string, est plutt mystrieuse ! Supposons par
exemple que lon entre la commande r e c t a n g l e s ( c o s ( x ) , 0 , 1 , 1 0 ) . La variable ex contiendra donc
lexpression cos x .
La fonction string opre la conversion en une chaine de caractres, lutilisation de s t r i n g ( e x ) permet
donc dobtenir la chaine de caractres " c o s ( x ) " .
Loprateur & permet de rassembler deux chaines de caractres en une chaine unique.
"Define f1(x)="&string(ex)
construit la chaine de caractres "Define f1(x)=cos(x))".

La commande expr permet ensuite dvaluer le contenu de cette chaine de caractres : tout se passe
comme si on entrait directement la commande quelle contient : D e f i n e f 1 ( x ) = c o s ( x ) .
En rsum, on a bien dfini la fonction f1 partir du premier argument transmis au programme.
28
2. Liste des xi
On utilise le constructeur seq(expression, var, val1, val2) qui permet de construire la liste dfinie par
expression dpendant de la variable var quand var varie entre val1 et val2 avec un pas de 1.
3. Liste des yi
TI-Nspire permet le calcul direct de limage dune liste. En particulier f1(liste) retourne la liste des
images des lments de liste.
4. Construction des listes des abscisses et des ordonnes des points Pi
Lutilisation de augment(liste1,liste2) retourne la liste obtenue en ajoutant les lments de liste2 la

suite de ceux de liste1.
Nous allons maintenant pouvoir construire un classeur illustrant la mthode des rectangles.
1. On dfinit le programme ci-dessus, en y ajoutant les instructions permettant de calculer la
n 1
ba
somme h f xk , avec h
ainsi que la valeur de lintgrale.
n
k 0
2. On insre une page Calculs, et on y lance une premire fois lexcution du programme.
3. On partage lcran en 2 et on ouvre lapplication Graphiques & gomtrie.
29
4. Dans cette application Graphiques & gomtrie, on demande la reprsentation de la fonction

f1. On obtient ainsi la reprsentation de la fonction dfinie lors de lappel du programme.
5. On choisit le mode Nuages de points , et on demande la reprsentation des listes l1 et l2.
6. On obtient un nuage de points non connects. On slectionne ce nuage, affiche le menu
contextuel, et choisit Attributs. Le premier attribut permet de contrler la taille des points
(choisir la plus petite), le rglage du second attribut permet de choisir de les relier.
7. On a ainsi obtenu une premire construction de la courbe et de la premire srie de rectangles
dans ce classeur. On peut le sauver en vue dun usage ultrieur.
8. Par la suite, il suffira douvrir nouveau ce classeur, et de relancer le programme rectangles
avec les arguments souhaits. Tous les lments de la partie graphique seront alors
reconstruits : la courbe, et les rectangles associs.
Vous retrouverez cette activit sur le site Internet www.univers-ti-nspire.fr. La version propose sur ce
site permet de visualiser le calcul des rectangles dfinis partir de la valeur de limage de lextrmit
gauche ou droite de lintervalle xi , xi 1 , ou de limage du centre de cet intervalle.
On peut constater exprimentalement que lapproximation est bien meilleure dans ce dernier cas 4 .
Ces programmes sont capables dadapter automatiquement le cadrage. La mthode utilise est dcrite
sur la page suivante.
Une tude thorique permet de montrer que, si la fonction vrifie certaines hypothses, lerreur est en
A
B
si on choisit lextrmit gauche ou droite, et en 2 si on choisit les centres des intervalles.
n
n
En particulier, partir dune certaine valeur de n, si on double le nombre de points, lerreur est
approximativement divise par 2 dans le premier cas, et par 4 dans le second.
30
1. Dans lcran Graphiques & gomtrie avec lequel on souhaite interagir, on se place
successivement sur chacune des 4 valeurs indiquant les valeurs minimales et maximales sur
chaque axe. Si ces valeurs ne sont pas affiches, placer le curseur sur lun des axes, ouvrir le
menu contextuel accessible par /b, slectionner Attributs, et modifier la valeur du
dernier, qui permet de masquer ou dafficher les valeurs extrmes.
2. Pour chacune delles, on ouvre le menu contextuel. On utilise ensuite loption Stocker ce qui
permet de placer des valeurs dans des variables que lon pourra par exemple nommer xmin,
xmax, ymin et ymax.
3. Une fois la liaison effectue, le nombre slectionn passe en gras, et on peut vrifier que tout
se passe bien en modifiant ces diffrentes valeurs depuis un cran Calculs.
Une fois que cette liaison a t tablie, il devient possible de piloter le cadrage depuis un programme
en modifiant la valeur de ces variables. Cest la mthode qui est utilise dans le classeur
methode_rectangles.tns que vous pourrez tlcharger sur le site www.univers-ti-nspire.fr.
Vous trouverez galement sur ce site un mulateur 3D (en mode fil de fer) qui a t cr en utilisant
ces diffrentes techniques.
31
Annexe B. Syntaxes TI-Nspire CAS et Maple 5

Dfinition dune fonction
TI-Nspire CAS
Define f(var1, var2, ) = func
local var1, var2, var3
instruction1
instruction2
...
instructionk
Maple
f:=proc(var1, var2, )
local var1, var2, var3 ;
instruction1 ;
instruction2 ;
...
instructionk
EndFunc
End
Return val
RETURN (val)
Affichage dun ou plusieurs rsultats

TI-Nspire CAS
Disp expr1,
expr2, expr3
Maple
Print (expr1,
expr2, expr3)
Structure de boucles
TI-Nspire CAS
Loop
Do
instruction1
instruction1 ;
...
...
instructionk
Endloop
var, dbut, fin

instruction1
For
...
instructionk
EndFor
var, dbut, fin, pas

instruction1
For
...
instructionk
instructionk
od
var from dbut to fin do

instruction1 ;
for
...
instructionk
od
var from dbut to fin by pas do

instruction1 ;
for
...
instructionk
EndFor
od
While condition
while condition do
instruction1 ;
instruction1
...
instructionk
...
instructionk
EndWhile
od
For var, dbut, fin, pas

if not condition : Exit
for var from dbut to

while condition do
instruction1 ;
instruction1
...
instructionk
EndFor
Maple
Maple est une marque dpose de Waterloo Maple Inc.
...
instructionk
od
fin by pas
32
Structure conditionnelles
TI-Nspire CAS
if condition then
Maple
if condition then
instruction1 ;
instruction2 ;
instruction1
instruction2
...
...
instructionk
instructionk
EndIf
fi
if condition then
if condition then
instruction1 ;
instruction1
...
...
instructionk
instructionk
Else
else
instruction1
instruction1 ;
...
...
instructionk
instructionk
EndIf
fi
if condition1 then
instruction1
...
if condition1 then
instruction1 ;
...
instructionk
ElseIf condition2 then
instruction1
instructionk
elif condition2 then

instruction1 ;
...
...
instructionk
ElseIf
...
...
...
...
instructionk
elif ...
...
Else
else
instruction1
instruction1 ;
...
...
instructionk
EndIf
instructionk
fi
Fonctions et programmes
Dans Maple, il ny a pas de distinction entre fonctions et programmes. On dfinit des procdures qui
retournent une valeur, et qui peuvent agir sur des variables globales, sous rserve que celles-ci figurent
dans une instruction global var1, var2, var3 ;
Si on ne souhaite pas quune valeur soit retourne et affiche lors de la fin dexcution de la procdure
quand elle est directement utilise dans une feuille de calcul, il faut retourner la valeur NULL.
Voici, juste titre dexemple, une procdure Maple, affichant la liste des carrs des entiers de 1 n,
mmorisant dans la variable globale sc la somme de ces entiers et ne retournant pas de valeur, ainsi
que le programme quivalent pour TI-Nspire CAS.
Define u(n)= Prgm
Local i
For i,1,n
disp i^2
sc:=sc+i^2
EndIf
EndPrgm
carres:=proc(n)
local i;
global sumcarres
for i from 1 to n do
print (i^2)
sc:= sc+i^2
od;
RETURN(NULL)
end

TI-Nspire Chap14 Qs

Transféré par

Informations du document

Description :

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Description :

Droits d'auteur :

Formats disponibles

TI-Nspire Chap14 Qs

Transféré par

Description :

Droits d'auteur :

Formats disponibles

Chapitre

Ce chapitre permet de dcouvrir les fonctionnalits de la programmation sur TI-Nspire CAS.

Lcriture dun programme ................................................................................. 3

Lutilisation de Tableur & listes ........................................................................ 23

Annexe A Interactions avec lapplication Graphiques & gomtrie.................. 26

TI-Nspire CAS en prpa

Dans ce cas, il existe une unique valeur x0 a, b telle que f x0 0 .

lintervalle dans lequel se trouve cette solution.

Si on a beaucoup de chance, f c 0 et notre problme est rsolu !

f a et f c sont de signes opposs, et x0 a, c

f a et f c sont de mme signes, et x0 b, c

Ce dernier point est trait en dtail la fin de ce chapitre.

T France 2008 / Photocopie autorise

Programmation sur TI-Nspire CAS

3. Lcriture dun programme

3.1 Transmission des arguments

T France 2008 / Photocopie autorise

TI-Nspire CAS en prpa

3.2 Ouverture de lditeur de programme sur une nouvelle page

T France 2008 / Photocopie autorise

Programmation sur TI-Nspire CAS

3.3 Ouverture de lditeur de programme dans un partage dcran

3.4 Affichage dun texte ou dun rsultat

T France 2008 / Photocopie autorise

TI-Nspire CAS en prpa

3.5 Variables locales

3.6 Premires affectations

T France 2008 / Photocopie autorise

Programmation sur TI-Nspire CAS

3.7 Structures conditionnelles

T France 2008 / Photocopie autorise

TI-Nspire CAS en prpa

On trouvera ces diffrentes structures dans le menu Contrle :

Si f c 0 , alors cest termin

Si le signe de f c est le mme que celui de f a , alors on remplace a par c .

Si le signe de f c est le mme que celui de f b , alors on remplace b par c .

Les lignes suivantes de notre programme pourraient donc scrire :

3.8 Structures itratives

compteur, dbut, fin

T France 2008 / Photocopie autorise

Programmation sur TI-Nspire CAS

Par exemple, si nous souhaitons faire 30 itrations, nous pouvons crire :

T France 2008 / Photocopie autorise

TI-Nspire CAS en prpa

On trouvera cette structure dans le menu Contrle :

Ici, on continue tant que b a

Le programme se poursuit sur la page suivante

T France 2008 / Photocopie autorise

Programmation sur TI-Nspire CAS

Informations complmentaires sur les structures itratives

La syntaxe gnrale de la boucle For est la suivante :

compteur, dbut, fin, pas

Elle permet de faire varier le compteur de la valeur fixe par pas.

affiche les nombres 0, 5, 10, 15, 20, 25, 30.

T France 2008 / Photocopie autorise

TI-Nspire CAS en prpa

est totalement quivalent

Il est naturellement plus simple dutiliser cette seconde syntaxe !

3.9 Interruption dun programme

3.10 Insrer un commentaire

Nous verrons une utilisation particulirement intressante de dans le chapitre 15.