|
Introduction
à la programmation et élaboration de la liste
utilisée
Retour Projet
Avant de
commencer notre Tpe en septembre, nous n’avions
jamais utilisé nos calculatrices pour faire
autre chose que des opérations ... Nous avons
donc dû étudier de prés les fonctions qu’elles
possédaient (et le nombre est considérable...!).
Nous vous donnons donc quelques explications sur
celles qui nous ont été utiles (pour ceux qui
comme nous découvrent la programmation ...).
Quelques notions de langage TI-BASIC
Pour concevoir ce programme, on a donc utilisé
notre calculatrice TI-89, et on a dû, n’ayant
jamais programmé ni les uns ni les autres, apprendre
quelques bases de ce langage (en espérant que
les utilisateurs confirmés du langage TI Basic
ne nous en voudrons pas trop si quelques erreurs
se sont glissées dans l'explication qui suit
...).
¤
L’éditeur de programme
Il nous donne la trame de fond du programme.
On peut aussi choisir de faire une fonction,
mais nous, nous utilisons le programme. Nous
avons donc :
Title( ) : nous avons
ici mis tpe4, et on peut inclure une expression
dans les parenthèses pour que celle ci soit
utilisée dans le programme, mais cela ne nous
sert à rien dans notre programme.
Prgm : qui nous
annonce le début du programme.
....
EndPrgm : qui annonce
la fin du programme
Cette
trame donne simplement la forme au programme.
Retour en haut de
page
¤ La
boite de dialogue
Elle nous sert pour demander à la calculatrice
de traiter un certain nombre de groupes de 4
chiffres (à partir de la liste). Elle est de la
forme
Dialog
...
EndDlog. Elle demande l'indice de début
(c'est-à-dire le rang de début du traitement des
nombres de la liste) et l'indice de fin grâce à
l’instruction Request. Ces indices de
début qui sont considérés comme des expressions
sont transformés en variables pour être
utilisables dans le programme.
Retour en haut de page
¤ Les
différentes boucles utilisées
ÞLa
boucle For:
C'est une
boucle qui permet de réitérer une opération un
certain nombre de fois. Elle est de la forme :
For
compteur, début, fin,
pas
Instruction
1
Instruction 2
......
Instruction n
EndFor
Nous
utilisons pour compteur l’indice de rang des
nombres dans la liste. Le début correspond donc
à l’indice de début donner dans la boite de
dialogue, et la fin à l’indice de fin. Le pas
n’est pas mis puisqu’il est de 1 (c'est-à-dire
que l’on prend tous les nombres dans leur ordre
de placement sans en omettre aucun). Il n’est
donc pas nécessaire de le noter, il se met
automatiquement à 1.
Cette
structure est la trame du programme puisque
seule la boite de dialogue n’est pas une instruction
incluse dans cette boucle.
ÞLa
boucle Si ... Alors ... Autres cas ... Sinon ...
:
Elle est
utilisée plusieurs fois dans le programme. C’est
une boucle de condition qui permet d’exécuter
des instructions suivant les conditions que
remplit l’expression utilisée. Elle est de la
forme :
If
condition Then
Instruction 1
....
Instruction n
ElseIf
Autre condition
Then
Instruction 1
....
Instruction n
...
ElseIf
Autre condition
Then
Instruction 1
....
Instruction n
Else
Instruction 1
....
Instruction n
EndIf
Les blocs
d’instruction peuvent être différents à chaque
condition. C’est le cas dans notre programme.
Cette boucle est utilisée plusieurs fois, pour
des utilisations similaires mais avec des
variables différentes.
Retour
en haut de page
¤
Les étiquettes
Elles sont utilisées pour faire des « sauts »
dans le programme. Elles renvoient à des blocs
d’instructions qui sont inclus antérieurement,
ou postérieurement dans le programme.
L’instruction Lbl NomDeLabel donne
l’arrivée du « saut », et l’instruction de
départ pour cette étiquette est Goto
NomDeLabel.
¤
Instructions
indépendantes
On a aussi utilisé plusieurs instructions qui ne
sont pas des structures, mais qui sont inclus
dans ces structures.
Ainsi, on
a pu utiliser les instructions suivantes :
PartEnt(Variable)>>Variable
: qui permet de prendre la partie entière d’un
nombre .
exp(Expression)>>Variable
: qui permet de transformer une expression en
variable.
liste[Indice]>>Variable
: qui permet d’aller chercher le groupe de 4
chiffres correspondant à l’indice dans la liste
et le transformer en variable pour pouvoir
travailler dessus .
Text
« »
: qui
permet d’afficher un cadre de texte.
reste(Variable,
Diviseur)>>Variable
: qui permet de prendre le reste de la division
de le variable par le diviseur donné,et de le
retransformer en variable.
mod(Variable,
Diviseur)>>Variable
: même fonction que celle d’avant .
Pause
: qui permet de faire une pause dans le
programme. Le programme redémarre lorsque l’on
appuie sur la touche Entrée.
NouvProb
: qui permet d’effacer toutes les variables
définies par des lettres de l’alphabet.
SupVar
Variable
1, Variable 2, ..., Variable n :
qui permet d’effacé toutes les autres variables.
Ces deux fonctions permettent de recommencer
la boucle avec de nouvelles variables.
Retour en haut de page
ü
Elaboration de la liste pour le programme
Le
programme fonctionne donc avec une liste
composée de 750 nombres eux-mêmes composés de 4
chiffres. On a pu établir cette liste en prenant
les 3000 premières décimales du Nombre d’Or
(
[1+√
(5)] /2 )
dont voici les 40 premières :
1.6180339887498948482045868343656381177203
liste des 3000
décimales
A chaque
nombre de 4 chiffres est associé un indice dans
la liste. Voici les 10 premiers nombres de cette
liste (nous avons volontairement omis le chiffre
avant la virgule).
|
Indice |
Nombre
(variable g) |
|
1 |
6180 |
|
2 |
3398 |
|
3 |
8749 |
|
4 |
8948 |
|
5 |
4820 |
|
6 |
4586 |
|
7 |
8343 |
|
8 |
6563 |
|
9 |
8117 |
|
10 |
7203 |
Cette
liste nous permet de générer des notes qui sont
donc obtenues seulement par l’utilisation de
lois et principes mathématiques sur le Nombre
d’Or.
Maintenant, vous voilà prêt à subir la suite et
l’application à la musique ...
Retour en haut de page
|
