Vous êtes sur la page 1sur 76

Universit Djillali Liabs Sidi Bel Abbs

Facult des Sciences de lIngnieur


Dpartement Informatique

Support de cours
Langages de programmation :
TURBO PASCAL & MATLAB
- 2 Anne LMD
Domaine : Sciences et Techniques
Mention : Sciences de lingnieur

Ralis par : Dr. ADJOUDJ Rda


Sidi Bel-Abbs Mars 2010

Avant Propos

Ce support de cours est intitul Langages de programmation:


TURBO PASCAL & MATLAB, il commence par la
description du Turbo Pascal, les diffrents aspects de la
programmation permettent de faire peu prs tout ce que
lon peut tre amen faire avec un langage de
programmation, dans toutes les circonstances que peut
rencontrer les futurs tudiants licencis de notre universit.
Ce support contient aussi les notions de base de
Matlab, de lutilisation des fonctions mathmatiques et des
techniques de manipulation des matrices.
Nous esprons que ce support sera un complment
indispensable pour la matrise non seulement de lutilisation
de programmation informatique, mais aussi des autres units
denseignement scientifiques &techniques du cursus pdagogique
assur au sein de notre Universit.

Sommaire
Chapitre I. Le langage PASCAL

01.

02.

03.

04.

05.

06.

07.

08.

09.
10.

Prface
Introduction
Le compilateur Borland Pascal 7.0
1.1. Architecture standard dun listing en Pascal
1.2. Grammaire du Pascal
1.3. Mots rservs du Pascal
Les entres / sorties
2.1. Les commandes write, writeln, read et radln
2.2. Affichage lcran
Les oprateurs
3.1. Oprateurs mathmatiques
3.2. Oprateurs relationnels
3.3. Oprateurs logiques
3.4. Priorit des oprateurs
Les variables
4.1. Dclaration
4.2. Prise de valeurs
4.3. Fonctions mathmatiques de base en Pascal
4.4. Oprations sur les variables
Les types de variables
5.1. Type simple
5.2. Type structur (enregistrement)
5.3. Type intervalle
5.4. Type numr
5.5. Type enregistrement conditionnel
Les structures alternatives
6.1. If .. Then.. Else
6.2. Case .. Of
Les structures rptitives
7.1. For .. to .. do
7.2. For .. downto .. do
7.3. Repeat .. until
7.4. While .. do
7.5. Arrts de boucle
Les procdures
8.1. Procdures simples
8.2. Variables locales et sous-procdures
8.3. Procdures paramtre
8.4. Syntaxe var (procdure et fonction)
Les fonctions
Les fichiers
10.1. Dclaration
10.2. Lecture, Ecriture

03
03
04
04
04
05
06
06
07
09
09
09
09
09
10
10
10
11
11
12
13
13
15
16
18
20
20
21
22
22
22
23
24
24
26
26
27
27
29
31
33
33
33

11.

12.
13.

37
37
38
40
44
44
45
45
46

Caractres et chanes de caractres


11.1. Chanes de caractres
11.2. Caractres seuls
Les tableaux
Les algorithmes de tri
13.1. Tri bulles
13.2. Tri par slection
13.3. Tri par insertion
13.4. Tri rapide

Chapitre II. MATLAB


01.

02

03

04.

Introduction
Gnralits et prise en main
1.1. Dmarrage, quitter
1.2. Aide, documentation en ligne
1.3. Calculs lmentaires
1.4 Historique des commandes
variables et fonctions prdfinies
2.1.Variables
2.2. Effacement et liste des variables
2.3. Variables prdfinies
2.4. Fonctions prdfinies
Matrices et tableaux
3.1. Dfinition dun tableau
3.2. Accs un lment dun tableau
3.3. Extraction de sous-tableaux
3.4. Construction de tableaux par blocs
3.5. Oprations sur les tableaux
3.5.1. Addition et soustraction
3.5.2. Multiplication, division et puissance terme `a terme
3.5.3. Multiplication, division et puissance au sens matriciel
3.5.4. Transposition
3.5.5. Synthse
3.6. Longueurs de tableau
3.7. Generation rapide de tableaux
3.7.1. Matrices classiques
3.7.2. Listes de valeurs
Graphique 2D
4.1 .Linstruction plot
4.1.1. Tracer une courbe simple
4.1.2 .Superposer plusieurs courbes
4.1.3 .Le pige classique
4.1.4. Attributs de courbes
4.2. Echelles logarithmiques
4.3. Dcoration des graphiques
4.3.1. Titre
4.3.2 .Labels

48
49
49
49
49
50
51
51
52
52
52
53
53
54
54
55
56
56
56
56
57
57
57
58
58
58
60
60
60
61
61
62
62
63
63
63

05.

06.

64
65
65
65
70
70
73

4.3.3. Lgendes
Graphique 3D et assimiles
5.1.Courbes en 3D
5.2.Surfaces
5.3. Divers
5.4. Exemple
Conclusion

Chapitre I. Le langage PASCAL


Prface
Le langage Pascal offre une trs bonne approche de la programmation. Trs utilis
dans le milieu scolaire, il permet d'acqurir des notions solides que l'on retrouve dans tous les
autres langages.
Les lments de base de la programmation tels que : types, tableaux, procdures, fonctions,...
et bien d'autres vous sont expliqus avec le maximum de pertinence, de simplicit et
d'efficacit.
De plus vous disposez galement de plusieurs tests d'valuation qui vous permettent d'valuer
vos connaissances en Pascal.

Introduction
Le 1ier chapitre de ce support de cours sur la programmation en Turbo Pascal 7.0 est
destin en premier lieu ceux qui dbutent dans la programmation. Que ce soit dans le cadre
de l'enseignement luniversit ou pour votre propre intrt personnel, vous avez dcid
d'apprendre ce langage fort archaque mais qui a nanmoins le mrite de former la logique
informatique. Le langage Pascal est trs structur et constitue en lui-mme une trs bonne
approche de la programmation.
Vous dcouvrirez dans les pages qui vont suivre, les bases de la programmation en gnral :
les structures de boucle et de contrle, l'utilisation de la logique boolenne, la chronologie
d'excution du code... Ces notions de base vous servirons si vous dcidez de changer de
langage de programmation, car les principes de base (et mme les instructions de base) sont
les mmes.

1. Le compilateur Borland Pascal 7.0


Pour ouvrir un fichier, aller dans le menu File/Open... ou taper la touche fonction
F3. Pour excuter un programme, aller dans le menu Run/Run ou taper la combinaison de
touches Ctrl+F9.
Pour compiler "correctement" un excutable, aller dans le menu Compile/Make (ou
/Compile) ou taper F9 on obtient ainsi des excutables de meilleurs qualit qui pourront tre
utiliss sur d'autres ordinateurs.
Si vous avez omis de mettre une pause la fin d'un programme, ou si vous dsirez tout
simplement avoir sous les yeux, la dernire page d'cran, il vous suffit d'allez dans le menu :
Debug/User Screen ou tapez ALT+F5.
Pour une aide, aller dans le menu Help/Index ou taper Shift+F1. Pour obtenir de l'aide sur
une instruction qui apparat dans un script, placez le curseur de la souris dessus et allez dans
le menu Help/Topic Search, une fentre apparatra alors.
Si un problme a lieu lors de l'excution d'un programme, utilisez le dbugger :
Debug/Watch. Une fentre apparat en bas de page. Cliquez sur Add et tapez le nom de la
variable dont vous dsirez connatre la dernire valeur.

1.1. Architecture standard d'un listing en pascal


{ les instructions facultatives pour compilation doivent tres entre accolades }
Program nom de programme ;
Uses units utilises ;
Const dclaration de constantes ;
Type dclaration de types ;
Function dclaration de fonction ;
Procedure dclaration de procdure paramtre ;
Var dclaration de variables ;
Procedure dclaration de procdure simple ;
BEGIN{ programme principal }
...
Commandes
...
END.

1.2. Grammaire du Pascal


Un nom de programme respecte les rgles lies aux identificateurs (cf plus bas) et ne
peut pas contenir le caractre point "."
Un programme principal dbute toujours par BEGIN et se termine par END. (avec
un point). Alors qu'un sous-programme (ou fonction, procdure, bloc conditionnel...)
commence lui aussi par Begin mais se termine par End ; (sans point mais avec un pointvirgule).

Chaque commande doit se terminer avec un point-virgule. Il n'y a pas d'exception la


rgle hormis Begin et l'instruction prcdent End ou Else.
Il est tolr de mettre plusieurs instructions les unes la suite des autres sur une mme
ligne du fichier mais il est recommand de n'en crire qu'une par ligne : c'est plus clair et en
cas de bogue, on s'y retrouve plus aisment. De plus, s'il vous arrive d'crire une ligne trop
longue, le compilateur vous le signifiera en l'erreur Error 11: Line too long. Il vous
faudra alors effectuer des retours la ligne comme le montre l'exemple suivant :
WriteLn('Fichier: ', file, ' Date de cration:', datecrea, '
Utilisateur courant:', nom, ' Numro de code:',
Round(ArcTan(x_enter)*y_old):0:10) ;
Les noms de constantes, variables, procdures, fonctions, tableaux, etc. (appels
identificateurs) doivent tres des noms simples, par exemple, n'appelez pas une variable
comme a : x4v_t3la78yugh456b2dfgt mais plutt comme cela : discriminant (pour un
nd
programme sur les quations du 2 degr) ou i (pour une variable de boucle).
Les identificateurs doivent imprativement tre diffrents de ceux d'unit utilises, de
mots rservs du langage Pascal et ne doivent pas excder 127 signes (1 lettre au minimum).
Ils ne doivent tre composs que de lettres, de chiffres et du caractre de soulignement
(Shift+8).
Les identificateurs ne doivent pas contenir de caractres accentus, ni d'espace, ni de
point et ni les caractres suivants : @, $, &, #, +, -, *, /. Mais le caractre de soulignement
est autoris. De plus, Turbo Pascal ne diffrencie aucunement les majuscules des
minuscules. Les chiffres sont accepts hormis en premire place.
N'hsitez pas insrer des commentaires dans votre code, cela vous permettra de
comprendre vos programmes un an aprs les avoir crit, et ainsi d'autres personnes
n'auront aucun mal rutiliser vos procdures, fonctions... Procdez ainsi :
{ ici votre commentaire entre accolades } (* ici vos commentaires entre
parenthses et toiles *)
Vos commentaires peuvent tenir sur une seule ligne comme sur plusieurs. Vous
pouvez aussi mettre en commentaire une partie de votre programme.
Un identificateur ne peut tre gale un mot rserv du langage pascal !

1.3. Les mots rservs du langage Pascal


AND,
ARRAY,
ASM,
BEGIN,
CASE,
CONST,
CONSTRUCTOR,
DESTRUCTOR, DIV, DO, DOWNTO, ELSE, END, EXPORTS, FILE, FOR,
FUNCTION,GOTO, IF, IMPLEMENTATION, IN, INHERITED, INLINE,
INTERFACE, LABEL, LIBRARY, MOD, NIL, NOT, OBJECT, OF, OR,
PACKED, PROCEDURE, PROGRAM, RECORD, REPEAT, SET, SHL, SHR,
STRING, THEN, TO, TYPE, UNIT, UNTIL, USES, VAR, WHILE, WITH,
XOR.

2. Les Entres / Sorties


2.1. Les commandes write,writeln, read et readln
La commande write permet d'afficher du texte et de laisser le curseur la fin du
texte affich. Cette commande permet d'afficher des chanes de caractres d'excdant pas 255
signes ainsi que des valeurs de variables, de constantes, de types... Le texte doit tre entre
apostrophe. Si le texte afficher contient une apostrophe, il faut alors la doubler. Les
diffrents noms de variables doivent tres spars par des virgules.
Note : toute commande doit tre suivie d'un point virgule.
Syntaxe :
Write ('Texte afficher', variable1, variable2, 'texte2') ;
Write ('L''apostrophe se double.') ; La commande WriteLn est semblable la
prcdente la diffrence prs que le curseur est maintenant renvoy la ligne suivante.
WriteLn ('Texte avec renvoi la ligne') ; La commande read permet
l'utilisateur de rentrer une valeur qui sera utilise par le programme. Cette commande ne
provoque pas de retour Chariot, c'est--dire que le curseur ne passe pas la ligne.
Read (variable) ; La commande ReadLn permet l'utilisateur de rentrer une valeur
qui sera utilise par le programme. Cette commande provoque le retour Chariot, c'est--dire
que le curseur passe la ligne suivante. Lorsqu'aucune variable n'est affecte la commande,
il suffit de presser sur <ENTREE>.
ReadLn (variable1, variable2) ;
Program exemple2.1a;
Var nom : String ;
BEGIN
Write('Entrez votre nom : ') ;
ReadLn(nom) ;
WriteLn('Votre nom est ', nom) ;
ReadLn ;
END.
Ce programme exemple2.1a dclare tout d'abord la variable nomme nom comme tant une
chane de caractre (String). Ensuite, dans le bloc programme principal, il est demand
l'utilisateur d'affecter une valeur la variable nom qui est initialise automatiquement (valeur
nulle) chaque dmarrage du programme. Ensuite, il y a affichage de la valeur de la variable
et attente que la touche entre soit valide (ReadLn).
L'quivalent de la commande ReadLn est ReadKey qui donne une valeur une variable
de type Char(caractre ASCII).
Syntaxe :
x := ReadKey ; Il existe une quivalence cette commande trs utile pour sortir
d'une boucle : KeyPressed.
6

Syntaxe :
Repeat
...
commandes
...
Until KeyPressed ;
Program exemple2.1b ;
Uses crt ;
Var i : integer ;
Const bornesup=10000 ;
BEGIN
Repeat
WriteLn(sqrt(i)) ;
Inc(i) ;
Until (i=bornesup) or KeyPressed ;
END.
Ce programme exemple2.1b rpte une boucle jusqu' qu'une valeur soit atteinte (bornesup)
mais s'arrte si on appuie sur une touche. L'instruction Inc(a,n); incrmente la valeur n
la variable a (par dfault n vaut 1), cette dernire tant de type integer.

2.2. Affichage l'cran


En rgle gnrale, les programmes dialoguent avec l'utilisateur : entres et sorties de
donnes respectivement avec les commandes read et write. La ncessit pratique ou la
volont de prsenter une interface plus conviviale imposent l'utilisation d'instructions
spcifiques : effacer une ligne seulement d'cran, changer la couleur des lettres Cette
section numre la quasi-totalit des instructions en Pascal vous permettant de faire des
oprations graphiques l'cran tout en restant en mode texte sous MS-DOS.

ClrScr ; Pour effacer tout l'cran et placer le curseur en haut gauche de l'cran,
trs utilis au dmarrage de chaque programme.

DelLine ;Efface la ligne courante c'est--dire celle qui contient le curseur.


InsLine ;Insre une ligne vide la position courante du curseur.

ClrEol ; Pour effacer une ligne l'cran partir de la position courante du


curseur.

TextBackground ( x ) ; Choix d'une couleur de fond pour le texte qui sera tap par la
suite. x est le numro (entre 0 et 15) de la couleur, il est tout fait possible d'y mettre
une variable de type integer a la place de x.

TextColor ( x ) ; Choix d'une couleur pour le texte qui sera affich par la
suite.

TextColor ( x + blink ) Choix d'une couleur pour le texte qui sera affich
en mode clignotant.

Windows (x1, y1, x2, y2 ) ; Pour crer une fentre l'cran. x1, y1 sont
les coordonnes du caractre en haut gauche et x2, y2 sont les positions du caractre
7

en bas droite. La rsolution de l'cran en mode texte est de 80 colonnes par 25


lignes.

GotoXY ( x, y ) ;Pour positionner le curseur la position voulue dans l'cran


ou dans une fentre Window. x et y sont respectivement le numro de colonne et le
numro de ligne (axes des abscisses et des ordonnes).

WhereX,WhereY ;Pour connatre la position courante du curseur. Ce sont des


fonctions et donc renvoient de manire intrinsque la valeur. C'est--dire que WhereX
prend la valeur du numro de colonne.

HightVideo ; Pour slectionner le mode haute densit des caractres. C'est--dire


que la couleur slectionne pour l'affichage du texte est modifie en son homologue
plus vive dans la liste des couleurs (liste de 15 couleurs).

LowVideo ; Au contraire, pour slectionner le mode faible densit de la couleur


des caractres. C'est- dire que la couleur slectionne pour l'affichage du texte est
modifie en son homologue moins vive dans la liste des couleurs.

NormVideo ; Pour revenir au mode normal de couleur de texte, c'est--dire pour


pouvoir utiliser indiffremment les couleurs vives et ternes.

TextMode ( x ) ; Pour slectionner un mode spcifique d'affichage du texte. x


est la valeur-code du mode dsir.

3. Les oprateurs
3.1. Oprateurs mathmatiques
Addition (et union) +
Soustraction (et complment) Division /
Multiplication (et intersection) *
Egalit =
MOD: renvoie le reste de la division x MOD y
DIV: renvoie le quotient de la division x DIV y
Oprateurs prioritaires : *, /, DIV et MOD.
Oprateurs secondaires : + et -. Vous pouvez utiliser des parenthses.

3.2. Oprateurs relationnels


Infrieur strict <
Infrieur ou gale (et inclu) <=
Suprieur strict >
Suprieur ou gale (et contenant) >=
Diffrent <>
Oprateur ultra-prioritaire : NOT.
Oprateur semi-prioritaire : AND.
Oprateur non prioritaires : OR et XOR.

3.3. Oprateurs logiques :


AND: le "et" logique des maths
OR: le "ou"
XOR: le "ou" exclusif
NOT: le "non"

3.4. Priorit des oprateurs


Niveau 1 : NOT.
Niveau 2 : *, /, MOD, DIV, AND.
Niveau 3 : +, -, OR, XOR.
Niveau 4 : =, <, >, <=, >=, <>.

4. Les variables
4.1. Dclaration
Toutes les variables doivent tres pralablement dclares avant d'tre utilises dans
le programme, c'est--dire qu'on leur affecte un type (voir types de variables). On peut les
dclarer de diverses manires :
Au tout dbut du programme avec la syntaxe VAR nom de la variable : type ; elles
seront alors valables pour le programme dans son intgralit (sous-programmes,
fonctions, procdures...).

Au dbut d'une procdure avec la syntaxe prcdente. Elles ne seront valables que
dans la procdure.

Aprs la dclaration des procdures, toujours avec la mme syntaxe, elles ne pourront
alors pas tres utilise par les procdures qui devront donc tre paramtres (voir
procdures paramtres).

4.2. Prise de valeurs


Les variables sont faites pour varier, il faut donc pouvoir leur donner diffrentes
valeurs au moyen du commutateur suivant := (deux points et signe gale) ou de certaines
fonction. Il faut bien sr que la valeur donne soit compatible avec le type utilis. Ainsi, on ne
peut donner la valeur 'bonjour' un nombre entier (integer).
Syntaxes :
Y := 1998 ;
On donne ainsi la valeur 1998 la variable Y (dclare pralablement en INTEGER).
LETTRE := 'a' ;
On affecte la valeur a la variable LETTRE (dclare pralablement en CHAR).
TEST := true ;
On donne la valeur true (vrai) la variable TEST (dclare pralablement en BOOLEAN).
NOMBRE := Y + 103 ;
Il est ainsi possible d'utiliser les valeurs d'autres variables, du moment qu'elles sont de mme
type, sinon, il faut faire des conversions au pralable.
DELTA := sqr(b) - 4*(a*c) ;
On peut donc galement utiliser une expression littrale mathmatique dans l'affectation de
variables. Mais attention la priorit des oprateurs (voir oprateurs).
PHRASE := 'Bonjour' + chr(32) + NOM ;On peut aussi ajouter des variables
String pour les chanes de caractres).

10

4.3. Fonctions mathmatiques de base en Pascal


Syntaxe
Sin(a)
Cos(a)
ArcTan(a)
Abs(a)
Sqr(a)
Sqrt(a)
Exp(a)
Ln(a)

Fonction
sinus
cosinus
arctangeante
valeur absolue
carr
racine carr
exponentielle
logarithme nprien

L'argument des fonctions trigonomtriques doit tre exprim en radian (Real), vous donc
de faire une conversion si ncessaire. De plus, on peut voir que les fonctions tangente,
factorielle n'existent pas, il faudra donc crer de toute pice les fonctions dsires (voir
fonctions).

4.4. Oprations sur les variables


Syntaxe
Inc(a);
Inc(a,n);
Dec(a);
Dec(a,n);

Utilisation
Procdure
Procdure
Procdure
Procdure

Type des variables


intervalle ou numr
intervalle ou numr
intervalle ou numr
intervalle ou numr

Trunc(a)

Fonction

tout scalaire

Int(a)

Fonction

Frac(a)

Fonction

Real

Round(a)

Fonction

a:Real
Round(a):Longin t

Pred(x)

Fonction

intervalle ou numr

Succ(x)

Fonction

intervalle ou numr

Hight(x)

Fonction

tous

Low(x)

Fonction

tous

Odd(a)

Fonction

a:Longint
Odd(a):Boolean

Renvoit le prdcesseur de la variable


x dans un ensembre ordonne
Renvoit le successeur de la variable x
dans un ensembre ordonne
Renvoit la plus grande valeur possible
que peut prendre de la variable x
Renvoit la plus petite valeur possible
que peut prendre de la variable x
Renvoit truesi le nombre a est impair
et falsesi a est pair

SizeOf(x)

Fonction

x:tous SizeOf(x):Integ
er

Renvoit renvoit le nombre d'octets


occups par la variable x

a:Real Int(a):Longint

11

Description
Le nombre a est incrment de 1
Le nombre a est incrment de n
Le nombre a est dcrment de 1
Le nombre a est dcrment de n
Prise de la partie entire du nombre a
sans arrondis
Prise de la partie entire du nombre a
sans arrondis
Prise de la partie fractionnaire du
nombre a
Prise de la partie entire du nombre a
avec arrondi l'unit la plus proche

5. Les types de variables


On peut donner n'importe quel nom aux variables condition qu'il ne fasse pas plus de
127 caractres et qu'il ne soit pas utilis par une fonction, procdure, unit ou commande dj
existante. Les identificateurs ne doivent pas contenir des caractres accentus, ni d'espace. Ils
doivent exclusivement tre composs des 26 lettres de l'alphabet, des 10 chiffres et du
caractre de soulignement. De plus, Turbo Pascal ne diffrencie aucunement les majuscules
des minuscules et un chiffre ne peut pas tre plac en dbut de nom de variable.
liste-exemple trs loin d'tre exhaustive :
Dsignation

Description

Bornes

Place en
mmoire

REAL
SINGLE(*)
DOUBLE(*)
EXTENDED(*)
COMP(*)
INTEGER
LONGINT
SHORTINT
WORD
BYTE
LONG
BOOLEAN

nombres rels
rel
rel
rel
rel
nombres entier (sans virgule)
entier
entier
entier
entier
entier
variable boolenne
tableau de 10 colones fait d'lments
de l'ensemble dfini xxx (CHAR,
INTEGER...)

2.9E-039 et 1.7E+038
1.5E-045 et 3.4E+038
5.0E-324 et 1.7E+308
1.9E-4951 et 1.1E+4932
-2E+063 +1 et 2E+063 +1
-32768 et 32767
-2147483648 et 2147483647
-128 et 127
0 et 65535
0 et 255
(-2)^31 et (2^31)-1
TRUE ou FALSE

6 octets
4 octets
8 octets
10 octets
8 octets
2 octets
4 octets
1 octet
2 octets
1 octet
4 octets
1 octet

ARRAY [1..10] OF
xxx
ARRAY [1..10,
1..50, 1..13] OF xxx

tableau en 3 dimensions fait d'lments


de l'ensemble dfini xxx (CHAR,
INTEGER...)

STRING

chane de caractres
chane de caractre ne devant pas
excder y caractres
fichier texte
fichier
fichier contenant des donnes de type
xxx (REAL, BYTE...)
nombre correspondant un caractre
ASCII cod
adresse mmoire
format de date
chane de caractre (nom complet de
fichier)
chane de caractre (chemin de fichier)

STRING [y]
TEXT
FILE
FILE OF xxx
CHAR
POINTEUR
DATETIME
PATHSTR
DIRSTR
NAMESTR
EXTSTR

256 octets
y+1
octets

0 et 255

chane de caractre (nom de fichier)


chane de caractre (extension de
fichier)

(*) : ncessitent un co-processeur mathmatique.


12

1 octet
4 octet

Il est possible de crer de nouveaux types de variables sur Turbo Pascal 7.0. Il y a encore
quelques dcennies, un "bon" programmeur tait celui qui savait optimiser la place en
mmoire que prenaient son programme, et donc la "lourdeur" des types de variables qu'il
utilisait. Par consquent, il cherchait toujours n'utiliser que les types les moins gourmands
en mmoire. Par exemple, au lieu d'utiliser un integer pour un champs de base de donne
destin l'ge, il utilisait un byte (1 octet contre 2).. Il est donc intressant de pouvoir
manipuler, par exemple, des chanes de caractres de seulement 20 signes : string[20]
(au lieu de 255 pour string, a tient moins de place).

5.1. Type simple


On dclare les nouveaux types simples de variable dans la partie dclarative du programme et
avant la dclaration des variables utilisant ce nouveau type.
Syntaxe :
Type nom_du_type = nouveau_type ;
Exemples :
Type nom = string[20] ;
Type entier = integer ;
Type tableau = array [1..100] of byte ;
Program exemple5.1 ;
Type chaine = string[20] ;
Var nom : chaine ;
age : byte ;
BEGIN
Write('Entrez votre nom : ') ;
ReadLn(nom) ;
Write('Entrez votre ge : ') ;
ReadLn(age) ;
WriteLn('Votre nom est : ',nom,'et votre ge : ',age) ;
END.
Ce programme utilise un nouveau type appel chane qui sert dclarer la variable nom.

5.2. Type structur (encore appel enregistrement)


On peut tre amen utiliser des types structurs car dans une seule variable on peut russir
caser des sous-variables nommes champs.
Syntaxe :
Type nom_du_type = Record sous_type1 : nouveau_type1 ;sous_type2 :
nouveau_type2 ;sous_type3 : nouveau_type3 ;End ;
Note : les champs sont placs dans un bloc Record ... End ;et un sous-type peut luimme tre de type Record.

13

Syntaxe :
Type nom_du_type = Record
sous_type1 : nouveau_type1 ;sous_type2 = Record ;
sous_type2_1 : nouveau_type2 ;sous_type2_2 : nouveau_type3 ;
sous_type2_3 : nouveau_type4 ;End ;
Note :
- une constante ne peut pas tre de type complexe (Array, Record...) mais seulement de
type simple.
- on ne peut pas afficher le contenu d'une variable structure sans passer par une syntaxe
spcifiant le champ dont on veut connatre la valeur.
- les champs d'une variable de type structur peuvent tre de tout type (mme tableau) sauf
de type fichier (Text, File, File OF x).
Program exemple5.2a;
Type formulaire = Record
nom : string[20] ;age : byte ;sexe : char ;
nb_enfants : 0..15 ;End ;
Var personne : formulaire ;
BEGIN
With personne Do
Begin
nom := 'Etivant' ;age := 18 ;
sexe := 'M' ;nb_enfants := 3 ;
End ;
END.
Program exemple5.2b;
Type formulaire = Record
nom : string[20] ; age :byte ; sexe : char; nb_enfants : 0..15 ; End ;
Var personne : formulaire ;
BEGIN
personne.nom := 'Etivant' ;personne.age := 18 ;
personne.sexe := 'M' ;personne.nb_enfants := 3 ;
END.
Ces programmes exemple5.2 (a et b) sont absolument identiques. Ils utilisent tout deux
une variable personne de type formulaire qui comprend trois champs : nom, age et sexe.
L'utilisation de ces champs se fait ainsi : variable[point]champ (exemple5.2b). Lorsqu'on
les utilise la chane (exemple5.2a), on peut faire appel With.
Program exemple5.2c;
Type date = Record
jour : 1..31 ;mois : 1..12 ;an : 1900..2000 ;End ;
Type formulaire = Record
nom : string[20] ;date_naissance : date ;End ;
Var personne : formulaire ;
BEGIN With personne Do

14

Begin
nom := 'Etivant' ;
With date_naissance Do
Begin
jour := 21 ;mois := 10 ;an := 1980 ;
End ;
End ;
END.
Program exemple5.2d;
Type formulaire = Record
nom : string[20] ;
date_naissance : Record
jour : 1..31 ;mois : 1..12 ;an : 1900..2000 ;End ;
End ;
Var personne : formulaire ;
BEGIN
With personne Do
Begin
nom := 'Etivant' ;With date_naissance Do
Begin
jour := 21 ;mois := 10 ;an := 1980 ;
End ;
End ;
END.
La aussi, les programmes exemple5.2 (c et d) sont identiques. Ils utilisent tout deux une
variable personne de type formulaire qui comprend deux champs : nom, et date_naissance
qui elle-mme est de type structur et comprenant les variables jour, mois et an.

5.3. Type intervalle


Les types intervalles trs utiliss ici ont rigoureusement les mmes proprits que ceux dont
ils sont tirs. Ils peuvent tre de type nombre entier (Byte, Integer, ShortInt,
LongInt, Long, Word) ou caractres (Char). Un type intervalle est forcment de type
entier ou est compatible avec un type entier. Certaines fonctions sont rserves aux types
intervalle, comme par exemple renvoyer le successeur dans l'intervalle considr. Sachant
qu'un intervalle est forcment ordonn et continu.
Syntaxe :
Type mon_type = borneinf..bornesup ;
On doit obligatoirement avoir :
borneinf et bornesup de type entier ou caractre
borneinf <= bornesup
Exemples :
Type bit = 0..1 ;
Type alpha = 'A'..'Z' ;
Type cent = 1..100 ;

15

Toutes ces instructions : Inc() (incrmentation de la variable passe en paramtre), Dec()


(dcrmentation de la variable passe en paramtre), Succ() (renvoie le successeur de la
variable passe en paramtre), Pred() (renvoie le prdcesseur de la variable passe en
paramtre), Ord() (renvoie l'index de la variable dans l'intervalle auquel elle appartient)
s'appliquent aux seuls types intervalles qu'ils soient de type nombre entier ou caractre et
numrs. Par exemple, la boucle Foret la condition Case Ofn'acceptent que des variables
de type intervalles (dont ont peut tir un successeur pour l'itration...).
Program exemple3.1a ;
Const Max=100 ;Type intervalle=1..Max ;Var x : intervalle ;
BEGIN
x:=1 ;
{...}If Not(Succ(x)=Max) Then
Inc(x) ;{...}
END.
Cet utilise quelques fonctions spcifiques aux types intervalles. L'exemple suivant montre
qu'on aurait pu se passer de dclarer un nouveau type en le spcifiant directement dans la
syntaxe Var.
Program exemple3.1b ;
Const Max=100 ;Var x : 1..Max ;
BEGIN
x:=1 ;
{...}If Not(Succ(x)=Max) Then
Inc(x) ;{...}
END.

5.4. Type numr


Un type numr est un type dont les variables associes n'auront qu'un nombre trs limit de
valeur (au maximum 256 diffrentes possibles). Un type numr sert de dfinition un
ensemble mathmatique par l'intermdiaire de la syntaxe Set Of dont ce n'est pas le sujet ici,
voir chapitre Ensemble. La dfinition d'un type numr consiste dclarer une liste de
valeurs possibles (256 au maximum) associes un type, c'est--dire qu'une variable de type
numr aura l'une et une seule de ces valeurs et pas une autre.
Program exemple5.4a ;
Type jours=(dim, lun, mar, mer, jeu, ven, sam) ;
Var today : jours ;
BEGIN
today := mar ;
today:=Succ(today) ;
Inc(today,2) ;
Case today Of dim : WriteLn('Dimanche') ;lun : WriteLn('Lundi')
;mar : WriteLn('Mardi') ;mer : WriteLn('Mercredi') ;jeu :
WriteLn('Jeudi') ;ven : WriteLn('Vendredi') ;sam :
WriteLn('Samedi') ;Else WriteLn('autre, ',Ord(today)) ;
End;
END.
16

Les instructions propres au type intervalle sont valables galement pour le type numr.
Dans cet exemple, il est dclar un type jours de type numr compos de 7 lments
reprsentant les jours de la semaine. Remarquez que les lments sont uniquement des
identifiants qui n'on aucune valeur intrinsque, on peut tout juste les reprer par leur
index(l'ordre dans lequel ils apparaissent dans la dclaration, o le premier lment le
numro 0 et le dernier : n-1). Tout d'abord une affectation l'aide de loprateur habituel
:= vers la variable today. Puis on lui affecte sont successeur dans la dclaration.
Ensuite, on l'incrmente de 2 c'est--dire qu'on le remplace par son sur-suivant. Et selon,
sa valeur, on affiche l'cran le jour de la semaine correspondant si cela est possible.
Remarque : La fonction Chr() rciproque de Ord() dans le cas de la table ASCII ne
s'applique pas aux types intervalles et numrs.
La partie dclarative de cet exemple : Type jours=(dim, lun, mar, mer, jeu, ven,
sam) ;Var today : jours ; aurait trs bien pu tre racourcie en :
Var today : (dim, lun, mar, mer, jeu, ven, sam) ;
Note : Il est impossible d'utiliser les procdures Write(Ln) et Read(Ln) avec les variables
de type numr.
Program exemple5.4b ;
Var color:(red, yellow, green, black, blue) ;
BEGIN
For color:=red To blue Do
WriteLn('*') ;
END.
Cet exemple montre que l'instruction de boucle For marche aussi bien pour les types
intervalles qu'numrs.
Program exemple5.4c;
Var color:(red, yellow, green, black, blue) ;
BEGIN
color:=green ;Case color Of
red : WriteLn('Rouge') ;yellow : WriteLn('Jaune') ;green :
WriteLn('Vert') ;black : WriteLn('Noir') ;blue :
WriteLn('Bleu') ;
End ;
END.
Cet exemple montre que l'instruction de contrle conditionnel Case Of fonctionne
aussi avec le type numr, conformment ce qui a t dit dans le chapitre sur les types
intervalles.
Program exemple5.4d;
Var color:(red, yellow, green, black, blue) ;
BEGIN
color:=red ;
Repeat Inc(color) ;
Until color>green ;
If color=black Then WriteLn('Noir') ;
END.
17

Cet exemple5.4d montre que comme toute variable, color -qui est de type numr -peut tre
sujette des tests boolens. Ici, sa valeur est incrmente dans une boucle Repeat qui ne
s'arrte que lorsque color atteint une valeur qui dans le type numr est suprieure la valeur
green. Ensuite un test If vient confirmer que la dernire valeur prise par color ( laquelle on
s'attendait au vu de la dfinition du type numr appliqu color) est black.

5.5. Enregistrement conditionnel


Lors de la cration d'un enregistrement (type structur), il est quelquefois ncessaire de
pouvoir en fonction d'un champ, dcider de la cration d'autres champs de tel ou tel type. Une
telle programmation s'effectue grce la syntaxe Case Of que l'on connaissait dj pour
tester des variables de type intervalle. Cette fois-ci on va tester des champs dont les valeurs
doivent tre de type numr !
Syntaxe :
Type type_enumere=(lment1, lment2, ... lmentN) ;
mon_type=Record
champ1:type1;
Case champ2:type_enumere Of
lment1:(champ3:type3);
lment2:(champ4:type4; champ5:type5;... champM:typeM);
...
lmentN:( );
End;
Le principe c'est de crer un type numr dont les valeurs seront les valeurs-test de
l'instruction Case Of. Ensuite, on crer le type enregistrement et on commence crer les
champs fixes, en ne mettant la structure conditionnelle qu'en dernier car son End; est
confondu avec celui du Record. On crit Case + un autre champ fixe dont la valeur
conditionne la suite + : (deux points) + le type de ce champ qui est le type numr cr plus
haut + Of. Ensuite partir de la ligne suivante on procde comme pour un Case Of normal
: on crit les diffrentes valeurs possibles c'est--dire les lments (par forcment tous...) du
type numr + : (deux points) + entre parenthses () on met les champs que l'on veut
suivant la valeur de l'lment sans oublier de spcifier leur type. Donc suivant la valeur d'un
champs fixe (de type numr), on va procder la cration d'un champ, de plusieurs champs
ou mme d'aucun champ (pour cette dernire option, il suffit de ne rien mettre entre les
parenthses).
Program exemple5.5a ;
Const Nmax=1 ;
Type materiaux=(metal, beton, verre) ;
produit=Record
nom : String[20] ;
Case matiere : materiaux Of
metal : (conductivite : Real) ;
beton : (rugosite : Byte) ;
verre : (opacite : Byte;
incassable : Boolean) ;
End ;
18

tab=Array[1..Nmax] Of produit ;
Procedure affichage(prod : produit) ;
Begin With prod Do
Begin WriteLn('Produit ', nom) ;
Case matiere Of
metal : WriteLn('Conductivit : ', conductivite) ;
beton : WriteLn('Rugosit : ', rugosite) ;
verre : Begin
WriteLn('Opacit : ', opacite) ;
If incassable Then WriteLn('Incassable') ;
End ;
End ;
End ;
End ;
Var x : tab ; i : Integer ;
BEGIN
With x[1] Do
Begin
nom:='Lampouille' ;
matiere:=verre ;opacite:=98 ;incassable:=true ;
End ;
For i:=1 To Nmax Do affichage(x[i]) ;
END.
Note : Il est absolument ncessaire de remplir les champs qui conditionnent le choix des
autres champs avant de remplir les champs qui sont soumis condition. Sinon, il est renvoy
des rsultats absurdes.
Program exemple5.5b ;
Type toto=Record
Case i:Integer Of1:( ) ;2:(a:Real) ;3:(x, y:String) ;
End ;
Var x:toto ;BEGIN x.i:=2 ;x.a:=2.23 ;
WriteLn(x.a) ;x.i:=3 ;x.x:='Castor' ;WriteLn(x.x) ;
END.
Cet exemple montre que l'on peut utiliser des variables d'autres types que celui numr pour
crer des enregistrements conditionnels. Ici c'est un Integer qui est utilis et dont la valeur
dans le programme conditionne l'existence d'autres champs.

19

6. Les structures alternatives


6.1. If ... Then ... Else
Cette commande est similaire au basic, elle se traduit par : SI ALORS SINON
Program exemple6.1a ;
Var chiffre:integer ;
BEGIN
Write('Entrez un entier pas trop grand : ') ;
Readln(chiffre) ;
If chiffre < 100 then
writeln(chiffre, 'est infrieur cent.')
else writeln(chiffre, 'est suprieur ou gale cent.')
;
END.
Ce programme exemple6.1a compare un chiffre entr par l'utilisateur au scalaire 100. Si le
chiffre est infrieur 100, alors il affiche cette information l'cran, sinon il affiche que
le chiffre entr est suprieur ou gale 100.
Program exemple6.1b ;
Var chiffre:integer ;
BEGIN
Write('Entrez un entier pas trop grand : ') ;
Readln(chiffre) ;
If chiffre < 100 then
Begin
writeln(chiffre, 'est infrieur cent.');
end
else
begin
writeln(chiffre,'est suprieur ou gale cent.');
end ;
END.
Ce programme exemple6.1b fait strictement la mme chose que le prcdent mais sa
structure permet d'insrer plusieurs autres commandes dans les sous-blocs THEN et
ELSE. Notez que le END terminant le THEN ne possde pas de point virgule car s'il en
possdait un, alors le ELSE n'aurait rien faire ici et le bloc condition se stopperait avant
le ELSE. Il est galement possible d'insrer dautres blocs IF dans un ELSE, comme
l'illustre l'exemple 6.1c qui suit :

20

Program exemple6.1c ;
Var i : integer ;
BEGIN
Randomize ;i := random(100) ;
if i < 50 then writeln ( i, ' est infrieur 50.')
else
if i < 73 then writeln ( i, ' est infrieur 73.')
else writeln ( i, ' est suprieur ou gale 73.')
END.

6.2. Case ... Of ... End


Cette instruction compare la valeur d'une variable de type entier ou caractre (et de manire
gnrale de type intervalle) tout un tas d'autres valeurs constantes.
Note : attention car Case..Of ne permet de comparer une variable qu'avec des constantes.
Program exemple6.2 ;
Var age:integer ;
BEGIN
Write('Entrez votre ge : ') ;
Readln(age) ;
Case age of 18 :
writeln('La majorit, pile-poil !') ;0..17 :
writeln('Venez moi, les petits enfants') ;60..99 :
writeln('Les infirmires vous laisse jouer sur l''ordinateur votre ge ?!!!')
Else writeln('Vous tes d''un autre ge...') ;
End ;
END.
Ce programme exemple6.2 vrifie certaines conditions quant la valeur de la variable age
dont l'a affect l'utilisateur. Et l, attention : le point-virgule avant le Else est facultatif.
Mais pour plus scurit afin de ne pas faire d'erreur avec le bloc If, choisissez
systmatiquement d'omettre le point-virgule avant un Else.
Note : On peut effectuer un test de plusieurs valeurs en une seule ligne par sparation avec
une virgule si on souhaite un mme traitement pour plusieurs valeurs diffrentes.
Ainsi la ligne : 0..17 : writeln('Venez moi, les petits enfants') ;
peut devenir : 0..10, 11..17 : writeln('Venez moi, les petits enfants') ;
ou encore : 0..9, 10, 11..17 : writeln('Venez moi, les petits enfants') ;
ou mme : 0..17, 5..10 : writeln('Venez moi, les petits enfants') ;
{cette dernire ligne est stupide mais correcte ! }

21

7. Les structures rptitives


7.1. For ... : = ... To ... Do ...
Cette instruction permet d'incrmenter une variable partir d'une valeur infrieur jusqu' une
valeur suprieur et d'excuter une ou des instructions entre chaque incrmentation. Les
valeurs extremum doivent tre des entiers (integer) ou des caractres de la table ASCII
(char). De manire plus gnrale, les bornes doivent tre de type intervalle (voir section
Type de variables) c'est--dire qu'ils doivent tres de type entier ou compatibles avec un type
entier. La boucle n'excute les instructions de son bloc interne que si la valeur infrieure est
effectivement infrieure ou gale celle de la borne suprieure. Le pas de variation est l'unit
et ne peut pas tre chang.
Syntaxe :
For variable := borne infrieur To borne suprieur Do instruction ;
Autre Syntaxe :
For variable := borne infrieur To borne suprieur Do
Begin
...
commandes ...
End ;
Program exemple7.1;
Var i : integer ;
BEGIN
For i := 10 To 53 Do
writeln ('Valeur de i : ', i ) ;
END.

7.2. For ... : = ... DownTo ... Do ...


Cette instruction permet de dcrmenter une variable partir d'une valeur suprieur jusqu'
une valeur infrieur et d'excuter une ou des instructions entre chaque dcrmentation.
S'appliquent ici les mmes remarques que prcdemment.
Syntaxe :
For variable := borne suprieur DownTo borne infrieur Do instruction;
Autre Syntaxe :
For variable := borne suprieur DownTo borne infrieur Do
Begin
commandes
...
End ;

22

Program exemple7.2;
Var i : integer ;
BEGIN
For i := 100 DownTo 0 Do
Begin
WriteLn ('Valeur de i : ', i ) ;
End ;
END.

7.3. Repeat ... Until ...


Cette boucle effectue les instructions places entre deux bornes (repeat et until) et
value chaque rptition une condition de type boolen avant de continuer la boucle pour
dcider l'arrt ou la continuit de la rptition. Il y a donc au moins une fois excution des
instructions. Il est ncessaire qu'au moins une variable intervenant lors de l'valuation de fin
de boucle soit sujette modification l'intrieur de la structure excutive interne la boucle.
Syntaxe :
Repeat
...commandes...
Until variable condition valeur ;
Program exemple7.3 ;
Uses crt ;
Var i : integer ;
BEGIN
Repeat
Inc ( i , 1 ) ;
Writeln ('Boucle itre ', i, 'fois.') ;
Until i > 20 ;
END.
Ce programme permet de rpter l'incrmentation de la variable i jusqu' que i soit suprieure
20.
Note : la commande Inc permet d'incrmenter une variable d'une certaine valeur. La
commande Dec permet au contraire de dcrmenter une variable d'une certaine valeur.
Ces commandes permettent d'viter la syntaxe :
variable := variable +1 et variable := variable - 1.
Syntaxe :
Inc ( variable , nombre ) ;
Dec ( variable , nombre ) ;

23

7.4. While ... Do ...


Ce type de boucle, contrairement la prcdente, value une condition avant d'excuter des
instructions (et nom pas l'inverse), c'est--dire qu'on peut ne pas entrer dans la structure de
rptition si les conditions ne sont pas favorables. De plus, au moins une variable de
l'expression d'valuation doit tre sujette modification au sein de la structure de rptition
pour qu'on puisse en sortir.
Syntaxe :
While variable condition valeur Do instruction ;
Autre Syntaxe :
While variable condition valeur Do
Begin
...
Commandes
...
End ;
Program exemple7.4;
Var code : boolean ; essai : string ;Const levraicode = 'password' ;
BEGIN
code:=false ; { facultatif, la valeur false est donne par dfaut }
While code = false Do
Begin
Write ('Entrez le code secret : ') ;
Readln (essai) ;
If essai = levraicode then code:=true ;
End ;
END.

7.5. Arrts de boucle.


Il est possible de terminer une boucle For, While ou Repeat en cours grce la
commande Break lorsque celle-ci est place au sein de la boucle en question. Pour
reprendre une boucle stoppe par Break, il faut utiliser la commande Continue.
Program exemple7.5a;
Var i, x : Integer ;
BEGIN
x := 0 ;
Repeat
Inc(i) ;
Break ;
x := 50 ;
Continue ;
Until i>10 ;
WriteLn(x) ;
END.

24

Ce programme exemple7.5a stoppe systmatiquement une boucle Repeat avant que la


variable x puisse tre incrment de 50 et la reprend aprs la ligne d'incrmentation. Ce
qui a pour rsultats que la variable x soit nulle la fin du programme.
Program exemple7.5b;
Var i, x : Integer ;
BEGIN
x := 0 ;
For i := 1 to 10 Do
Begin
Break ;
x := 50 ;
Continue ;
End ;
WriteLn(x) ;
END.
Ce programme exemple7.5b fait la mme chose que le programme prcdent mais dans une
boucle For.
Program exemple7.5c ;
Var i, x : Integer ;
BEGIN
x := 0 ;
While i<10 Do
Begin
Break ;
x := 50 ;
Continue ;
End ;
WriteLn(x) ;
END.
Ce programme exemple7.5c fait la mme chose que les programmes prcdents mais dans une
boucle While. Et pour quitter un bloc sous-programme (structure Begin ... End ;) ou
mme le programme principal (structure Begin ... End.), utilisez la commande Exit.
Program exemple7.5d ;
Var i : Integer ;
BEGIN
While i <> 13 Do
Begin
Write ('Entrez un nombre : ') ;
Readln (i) ;
Writeln (i) ;
If i = 0 Then Exit ;
End ;
Writeln ('Boucle termine.') ;
END.

25

8. Les procdures
Les procdures et fonctions sont des sortes de sous-programmes crits avant le programme
principal mais appels depuis ce programme principal, d'une autre procdure ou mme d'une
autre fonction. Le nom d'une procdure ou d'une fonction (ou comme celui d'un tableau, d'une
variable ou d'une constante) de doit pas excder 127 caractres et ne pas contenir d'accent. Ce
nom doit, en outre, tre diffrent de celui d'une instruction en Pascal. L'appel d'une procdure
peut dpendre d'une structure de boucle, de condition, etc.

8.1. Procdure simple


Une procdure peut voir ses variables dfinies par le programme principal, c'est--dire que
ces variables sont valables pour tout le programme et accessible partout dans le programme
principal mais aussi dans les procdures et fonctions qui auront t dclares aprs. La
dclaration des variables se fait alors avant la dclaration de la procdure pour qu'elle puisse
les utiliser. Car une procdure dclare avant les variables ne peut pas connatre leur existence
et ne peut donc pas les utiliser.
Syntaxe :
Program nom de programme ;
Var variable : type ;
Procedure nom de procdure ;
Begin
commandes
...
End ;
BEGIN
nom de procdure ;
End.
Program exemple8.1a ;
Uses crt ;
Var a, b, c : real ;
Procedure maths ;
Begin
a := a + 10 ;
b := sqrt(a) ;
c := sin(b) ;
End ;
BEGIN
clrscr ;
Write('Entrez un nombre :') ;
Readln(a) ;
Repeat maths ;
Writeln (c) ;
Until keypressed ;
END.

26

Ce programme exemple8.1a appelle une procdure appele maths qui effectue des calculs
successifs. Cette procdure est appele depuis une boucle qui ne se stoppe que lorsqu'une
touche du clavier est presse (instruction keypressed). Durant cette procdure, on
additionne 10 la valeur de a entre par l'utilisateur, puis on effectue le carr (sqrt) du
nombre ainsi obtenu, et enfin, on cherche le sinus () de ce dernier nombre.

8.2. Variables locales et sous-procdures


Une procdure peut avoir ses propres variables locales qui seront rinitialises chaque appel.
Ces variables n'existent alors que dans la procdure. Ainsi, une procdure peut utiliser les
variables globales du programme (dclares en tout dbut) mais aussi ses propres variables
locales qui lui sont rserves. Une procdure ne peut pas appeler une variable locale
appartenant une autre procdure. Les variables locales doivent porter des noms diffrents de
celles globales si ces dernires ont t dclare avant la procdure. Enfin, on peut utiliser dans
une procdure, un nom pour une variable locale dj utilis pour une autre variable locale
dans une autre procdure.
Une procdure, tant un sous-programme complet, peut contenir ses propres procdures et
fonctions qui n'existent alors que lorsque la procdure principale est en cours. Une sousprocdure ne peut appeler d'autres procdures ou fonctions que si ces dernires font parti du
programme principal ou de la procdure qui contient la sous-procdure.
Syntaxe :
Procedure nom de procdure ;
Var variable : type ;
Procedure nom de sous-procdure ;
Var variable : type ;
Begin
...
End;
Begin
...
commandes
...
End;

8.3. Procdure paramtre


On peut aussi crer des procdures paramtres (dont les variables n'existent que dans la
procdure). Ces procdures l ont l'intrt de pouvoir, contrairement aux procdures simples,
tre dclare avant les variables globales du programme principal ; elles n'utiliseront que les
variables passes en paramtres ! Le programme principal (ou une autre procdure qui aurait
t dclare aprs) affecte alors des valeurs de variables la procdure en passant des
variables en paramtres. Et ces valeurs s'incorporent dans les variables propres la procdure
(dont les identificateurs peuvent ou non tres identiques, a n'a aucune espce d'importance).
La dclaration des variables se fait alors en mme temps que la dclaration de la procdure,
ces variables sont des paramtres formels car existant uniquement dans la procdure. Lorsque
que le programme appelle la procdure et lui envoie des valeurs de type simple (car celles de
type complexe ne sont pas acceptes, voir chapitre 20 sur les types), celles-ci sont appeles

27

paramtres rels car les variables sont dfinies dans le programme principal et ne sont pas
valables dans la procdure.
A noter qu'on peut passer en paramtre directement des valeurs (nombre, chanes de
caractres...) aussi bien que des variables.
Syntaxe :
Program nom de programme ;
Procedure nom de procdure( noms de variables : types ) ;
Begin
...
commandes
...
End ;
BEGIN
nom de procdure ( noms d'autres variables ou leurs valeurs ) ;
END.
Note : on peut passer en paramtre une procdure des types simples et structurs. Attention
nanmoins dclarer des types spcifiques de tableau l'aide de la syntaxe Type (voir
Chapitre 20 sur les "Types simples et structurs") car le passage d'un tableau en tant que type
Array une procdure est impossible.
Program exemple8.3a ;
Uses Crt ;
Procedure maths ( param : Real ) ;
Begin
WriteLn('Procdure de calcul. Veuillez patienter.') ;
param := Sin(Sqrt(param+10)) ;
WriteLn(param) ;
End ;
Var nombre : Real ;
BEGIN
ClrScr ;
Write('Entrez un nombre :') ;
ReadLn(nombre) ;maths (nombre) ;
ReadLn ;
END.
Ce programme exemple8.3a appelle une procdure paramtre appele maths qui effectue les
mmes calculs que le programme exemple8.1a. Mais ici, la variable est dclare aprs la
procdure paramtre. Donc, la procdure ne connat pas l'existence de la variable nombre,
ainsi, pour qu'elle puisse l'utiliser, il faut le lui passer en paramtre !

28

8.4. Syntaxe var (procdures et fonctions)


Il est quelquefois ncessaire d'appeler une procdure paramtre sans pour autant avoir
de valeur lui affecter mais on souhaiterait que ce soit elle qui nous renvoie des valeurs
(exemple typique d'une procdure de saisie de valeurs par l'utilisateur) ou alors on dsire que
la procdure puisse modifier la valeur de la variable passe en paramtre. Les syntaxes
prcdentes ne conviennent pas ce cas spcial. Lors de la dclaration de variable au sein de
la procdure paramtre, la syntaxe Var(place devant l'identificateur de la variable ) permet
de dclarer des paramtres formels dont la valeur l'intrieur de la procdure ira remplacer la
valeur, dans le programme principal, de la variable passe en paramtre. Et lorsque Var n'est
pas l, les paramtres formels doivent imprativement avoir une valeur lors de l'appel de la
procdure.
Pour expliquer autrement, si Var n'est pas l, la variable qu'on envoie en paramtre
la procdure doit absolument dj avoir une valeur (valeur nulle accepte). De plus, sans Var,
la variable ( l'intrieur de la procdure) qui contient la valeur de la variable passe en
paramtre, mme si elle change de valeur n'aura aucun effet sur la valeur de la variable (du
programme principal) passe en paramtre. C'est dire que la variable de la procdure
n'existe qu' l'intrieur de cette dernire et ne peut absolument pas affecter en quoi que ce soit
la valeur initiale qui fut envoye la procdure : cette valeur initiale reste la mme avant et
aprs l'appel de la procdure. Car en effet, la variable de la procdure est dynamique : elle est
cre lorsque la procdure est appele et elle est dtruite lorsque la procdure est finie, et ce,
sans retour d'information vers le programme principal. La procdure paramtre sans Var
volue sans aucune interaction avec le programme principal (mme si elle est capable
d'appeler elle-mme d'autres procdures et fonctions).
Par contre, si Var est l, la valeur de la variable globale passe en paramtre la
procdure va pouvoir changer (elle pourra donc ne rien contenir l'origine). Si au cours de la
procdure la valeur est change (lors d'un calcul, d'une saisie de l'utilisateur...), alors la
nouvelle valeur de la variable dans la procdure, une fois la procdure termine, ira se placer
dans la variable globale (du programme principal) qui avait t passe en paramtre la
procdure. Donc, si on veut passer une variable en paramtre dont la valeur dans le
programme principal ne doit pas tre modifie (mme si elle change dans la procdure), on
n'utilise pas le Var. Et dans le cas contraire, si on veut de la valeur de la variable globale
place en paramtre change grce la procdure (saisie, calcul...), on colle un Var.
Program Exemple8.4a ;
Uses Crt ;
Procedure Saisie ( var nom : String ) ;
Begin
Write('Entrez votre nom : ') ;
ReadLn(nom) ;
End ;
Procedure Affichage ( info : String ) ;
Begin
WriteLn('Voici votre nom : ', info) ;
End ;

29

Var chaine : String ;


BEGIN
ClrScr ;
Saisie(chaine) ;
Affichage(chaine) ;
END.
Ce programme exemple8.4a illustre l'utilisation de la syntaxe Var. En effet, le programme
principal appelle pour commencer une procdure paramtre Saisie et lui affecte la valeur de
la variable chaine (c'est--dire rien du tout puisque qu'avant on n'a rien mis dedans, mme pas
une chane vide). Au sein de la procdure paramtre, cette variable porte un autre nom : nom,
et comme au dbut du programme cette variable n'a aucune valeur, on offre la procdure la
possibilit de modifier le contenu de la variable qu'on lui envoie, c'est--dire ici d'y mettre le
nom de l'utilisateur. Pour cela, on utilise la syntaxe Var. Lorsque cette procdure Saisie est
termine, la variable chaine du programme principal prend la valeur de la variable nom de la
procdure. Ensuite, on envoie la procdure Affichage la valeur de la variable chaine (c'est-dire ce que contenait la variable nom, variable qui fut dtruite lorsque la procdure Saisie se
termina). Comme cette dernire procdure n'a pas pour objet de modifier la valeur de cette
variable, on n'utilise pas le mot cl Var, ainsi, la valeur de la variable chaine ne pourra pas
tre modifie par la procdure. Par contre, mme sans Var, la valeur de la variable info
pourrait varier au sein de la procdure si on le voulait mais cela n'aurait aucune influence sur
la variable globale chaine. Comme cette variable info n'est dfinie que dans la procdure, elle
n'existera plus quand la procdure sera termine.
Il faut savoir qu'une procdure paramtre peut accepter, si on le dsire, plusieurs variables
d'un mme type et aussi plusieurs variables de types diffrents. Ainsi, certaines pourront tres
associes au Var, et d'autres pas. Si l'on dclare, dans une procdure paramtre, plusieurs
variables de mme type dont les valeurs de certaines devront remplacer celles initiales, mais
d'autres non ; il faudra dclarer sparment (sparation par une virgule ;) les variables
dclare avec Var et les autres sans Var. Si on dclare plusieurs variables de types
diffrents et qu'on veut que leurs changements de valeur affecte les variables globales, alors
on devra placer devant chaque dclaration de types diffrents un Var.
Syntaxes :
Procedure identifiant(Var var1, var2 : type1 ; var3 : type1) ;
Begin
...
End
Procedure identifiant(Var var1 : type1 ; Var var2 : type2) ;
Begin
...
End ;

30

9. Les fonctions
Quant aux fonctions, elles sont appeles partir du programme principal, d'une
procdure ou d'une autre fonction. Le programme affecte des valeurs leurs variables
(comme pour les procdures paramtres, il faudra faire attention l'ordre d'affectation des
variables). Ces fonctions, aprs lancement, sont affectes elles-mmes d'une valeur
intrinsque issue de leur fonctionnement interne. Il faut dclarer une fonction en lui donnant
tout d'abord un identifiant (c'est--dire un nom d'appel), en dclarant les variables locales dont
elle aura besoin et enfin, il faudra prciser le type correspondant la valeur que prendra en
elle-mme la fonction (string, real, etc.). Attention, on ne peut pas affecter un type complexe
(array, record) une fonction : seuls les types simples sont accepts (voir chapitre 20 sur les
types simples et complexes). De plus, comme le montre les syntaxes suivantes, on peut
fabriquer une fonction sans paramtre (ex: random). Il ne faut surtout pas oublier, en fin (ou
cours) de fonction, de donner une valeur la fonction c'est--dire d'affecter le contenu d'une
variable ou le rsultat d'une opration (ou autre...) l'identifiant de la fonction (son nom)
comme le montrent les syntaxes suivantes.
Syntaxes :
Function nom de fonction (variable : type ) : type ;
Var dclaration de variables locales ;
Begin
...
Commandes
...
nom de fonction := une valeur ;
End ;
Function nom de fonction : type ;
Var dclaration de variables locales ;
Begin
...
Commandes
...
nom de fonction := une valeur ;
End ;
Program exemple9 ;
Uses crt ;
Function exposant ( i , j : integer ) : integer ;
Var i2 , a : integer ;
Begin
i2 := 1 ;
For a := 1 To j Do
i2 := i2 * i ;
exposant := i2 ;
End ;
Var resultat, x, n : integer ;

31

BEGIN
Write ('Entrez un nombre : ') ;
Readln (x) ;
Write('Entrez un exposant : ') ;
Readln (n) ;
resultat := exposant ( x , n ) ;
Writeln ( resultat ) ;
Readln ;

END.

32

10. Les fichiers


10.1. Dclaration
Pour utiliser un ou des fichiers tout au long d'un programme, il faudra l'identifier par une
variable dont le type est fonction de l'utilisation que l'on veut faire du fichier. Il existe trois
types de fichiers :
Les fichiers textes (Text), qui sont crits au format texte (chanes de caractres, nombres)
dans lesquels ont peut crire et lire ligne par ligne ou la file avec les procdures Write(Ln)
et Read(Ln). Chaque fin de ligne du fichier se termine par les caractres 10 et 13 de la table
ASCII qui signifient respectivement retour chariot et passage la ligne. Ces deux derniers
caractres sont transparents au programmeur. On pourra donc y crire ou y lire
indiffremment des chanes ou des nombres, cela dpend du type que l'on affecte la variable
passe en paramtre aux procdures d'entre/sorties (voir plus bas).
Note : S'il y a lieu de faire une conversion nombre/chane, le compilateur le fait tout seul, par
contre si le type de la variable ne correspond pas avec la donne lue dans le fichier et
qu'aucune conversion n'est possible (exemple : WriteLn(f, x:Real); alors que le
fichier ne contient que des lettres), alors cela produit une erreur.
Syntaxe :
Var f : Text ;

Les fichiers typs (File Of), qui sont des fichiers crits sur disque telles que les
donnes se prsentent en mmoire. C'est--dire que la taille du fichier rsultera
directement et exactement de la taille en mmoire qu'occupe telle ou telle variable.
Cela accrue la vitesse d'accs aux donnes du fichier. Mais le plus grand avantage c'est
que l'on obtient ainsi des fichiers parfaitement formats, c'est--dire qu'on peut y lire
et crire directement des variables de type structur qui contiennent plusieurs champs
de donnes ( voir chap Type) sans avoir se soucier des divers champs qu'elles
contiennent. Il va sans dire que ce type de fichier est prfrable tous les
Les fichiers tout courts (File), qui sont des fichiers dont on ne connat pas le
contenu. N'ayant aucune information sur la structure des donnes, n'ayant aucune
conversion faire, la lecture et son criture en sont plus rapides. Mais sont utilit est
bien maigre : part faire une simple copie d'un fichier dans un autre...

Syntaxe :
Var f : File Of type ;
Exemple :
Var f : File Of Integer
Syntaxe :
Var f : File ;

33

10.2. Lecture, criture


Avant de travailler sur un fichier, il faut le dclarer en lui affectant une variable qui servira
dsigner le fichier tout au long du programme. Assign s'applique tous les types de
fichiers (Text, File Of et File).
Syntaxe :
Assign ( variable d'appel , nom du fichier ) ;
Ensuite, il faut renvoyer le pointeur au dbut du fichier pour pouvoir lire (Text, File Ofet
File) ou crire (File Of et File) partir du dbut du fichier. Attention, on ne peut pas
crire sur un Text avec Reset!
Syntaxe :
Reset (variable d'appel) ;
Il est possible pour le type File uniquement, de spcifier la taille de chaque bloc de donne
lu ou crit sur le fichier, en rajoutant en argument Reset une variable (ou un nombre
directement) de type Word (entier) spcifiant cette taille en octet. Cela ncessite de connatre
la taille mmoire de chaque type de variables (voir section "Les types de variables"). Par
exemple cette taille vaudra 6 si on veut lire des nombres rels (Real) ou bien 256 pour des
chanes de caractres (String). Le fait que la variable taille soit de type Word implique
que sa valeur doit tre comprise entre 0 et 65535. Par dfaut, taille=128 octets.
Syntaxe :
Reset ( variable d'appel, taille ) ;
Pour crer un fichier qui n'existe pas ou bien pour en effacer sont contenu, on emploi
ReWrite qui permet d'effectuer des lectures (File Of et File) et critures (Text,
File Ofet File). Attention, on ne peut pas lire sur un Text avec ReWrite!
Syntaxe :
Rewrite ( variable d'appel ) ;
Tout comme Reset, ReWrite permet de spcifier une taille aux changes de donnes sur
un File seulement (aussi bien en criture qu'en lecture). Avec ReWrite c'est le cas ou le
fichier n'existe pas encore alors qu'avec Reset c'est le cas ou il existe dj.
Syntaxe :
Rewrite ( variable d'appel, taille) ;
Tableau des correspondances entre procdures et types de fichiers :
Syntaxe

Types de fichiers associs


Lecture
Ecriture

Reset(f)

-Text -File Of -File

-File Of -File

ReWrite(f)

-File Of -File

-Text -File Of -File

Reset(f, taille)
ReWrite(f, taille)

File
File

File
File

34

Pour lire le contenu d'une ligne d'un fichier Text ouvert, on utilise la mme instruction qui
permet de lire la valeur d'une variable au clavier savoir ReadLn. Sera alors lue, la ou les
variable(s) correspondants au contenu de la ligne courante (celle pointe par le pointeur). Si la
ou les variable(s) n'tai(en)t pas de taille suffisamment grande pour contenir toutes les
donnes de la ligne, alors l'excdent serait perdu.
Syntaxes :
ReadLn ( variable d'appel, variable ) ;
ReadLn ( variable d'appel, var1, var2, ... varN) ;
Pour crire sur un fichier Text, il suffit d'employer la commande WriteLn.
Syntaxes :
WriteLn ( variable d'appel, variable ) ;
WriteLn ( variable d'appel, var1, var2, ... varN) ;
Les procdures Read et Write s'utilisent respectivement de la mme manire que
ReadLn et WriteLn mais s'appliquent aux File Of aussi bien qu'aux Text. Pour lire
et crire sur un File, il faut utiliser les procdures BlockRead et BlockWrite.
Syntaxes:
BlockRead ( f, variable, nbr ) ;
BlockRead ( f, variable, nbr, result ) ;
BlockWrite ( f, variable, nbr ) ;
BlockWrite ( f, variable, nbr, result ) ;
BlockRead lit sur le fichier f de type File une variable qui contiendra un nombre de
bloc mmoire (dont la taille est dfinie par Reset ou ReWrite) gale nbr. La variable
facultative result prend pour valeur le nombre de bloc effectivement lu (car il peut y en avoir
moins que prvu initialement). BlockWrite crit sur le fichier f de type File une
variable sur un nombre de bloc mmoire gale nbr. La variable facultative result prend pour
valeur le nombre de bloc effectivement crit (car il peut y en avoir plus crire que ne le
permet l'initialisation par Reset ou ReWrite). Dans le cas ou cette variable result est
ommise et qu'il est impossible d'crire autant de blocs que voulu, il est gnr une erreur !
Note : Les variables nbr et result doivent tre de type Word.
Tableau des correspondances entre procdures et types de fichiers :
Syntaxe
WriteLn
ReadLn
Write

Types de fichiers associs


Text
Text
-Text -File Of

Read

-Text -File Of

BlockWrite File
BlockRead
File

35

Il est impratif de fermer les fichiers ouverts pendant un programme Turbo Pascal avant de
terminer le programme sous peine de voir les donnes inscrites perdues.
Syntaxe :
Close ( variable d'appel ) ;
Il est possible de rappeler un fichier Text en cours de programme mme s'il a dj t
referm grce sa variable d'appel. Et alors la position courante du curseur sera la fin du
fichier. Ne fonctionne qu'en criture et qu'avec un Text.
Syntaxe :
Append ( variable d'appel ) ;
La syntaxe Append est quivalente au bloc suivant :
Begin
Reset(variable d'appel) ;
Seek(variable d'appel, FileSize(variable d'appel)) ;
End ;
Program exemple10.2;
Uses crt, dos ;
Var f : text ;nom : string ;choix : char ;
Procedure lecture ;
Begin
Append (f) ;
Reset (f) ;
Readln (f, nom) ;
Writeln (nom) ;
End ;
BEGIN
Clrscr ;
Assign (f, 'init.txt') ;
Rewrite (f) ;
Write ('Entrez un nom d''utilisateur : ') ;
Readln (nom) ;
nom := 'Dernier utilisateur : ' + nom ;
Writeln (f, nom) ;
Close (f) ;
Write ('Voulez-vous lire le fichier init.txt ? [O/N] ') ;
Readln (choix) ;
If (choix='O') or (choix='o') then lecture ;
END.
Ce programme exemple10.2 illustre les principales commandes qui permettent de travailler
sur des fichiers de type texte. Ici, le programme rinitialise chaque lancement le fichier
init.txt et y inscrit une valeur entre par l'utilisateur (son nom, en l'occurrence). Il permet
galement l'utilisateur de lire le contenu du fichier (qui ne contient qu'une seule ligne de
texte).
36

11. Caractres et chanes de caractres


11.1. Chanes de caractres
Le type String dfini des variables "chanes de caractres" ayant au maximum 255 signes,
ces derniers appartenant la table ASCII. Une chane peut en contenir moins si cela est
spcifi lors de la dclaration o le nombre de signes (compris entre 1 et 255) sera mis en
crochet la suite du type String. Le premier caractre de la chane a pour indice 1, le
dernier a pour indice 255 (ou moins si spcifi lors de la dclaration).
Syntaxe :
Var chaine : String ; telephone : String[10] ;
Lorsqu'une valeur est affecte une variable chane de caractres, on procde comme
pour un nombre mais cette valeur doit tre entre quottes. Si cette valeur contient une
apostrophe, celle-ci doit tre double dans votre code.
Syntaxe :
variable := valeur ; animal := 'l''abeille' ;
Note importante : le type String est en fait un tableau de caractres une dimension
dont l'lment d'indice zro contient une variable de type Char et dont le rang dans la
table ASCII correspond la longueur de la chane. Il est donc possible, une chane de
caractre tant un tableau de modifier un seul caractre de la chane grce la syntaxe
suivante :
chaine[index]:=lettre;
Program Chaine;
Var nom:String;
BEGIN
nom:='Etivant'; nom[2]:='Z'; nom[0]:=Chr(4);
WriteLn(nom); nom[0]:=Chr(28);
Write(nom,'-tagada');
END.
L'exemple Chaine remplace la deuxime lettre de la variable nom en un "Z" majuscule,
puis spcifie que la variable ne contient plus que 4 caractres. Ainsi la valeur de la
variable nom est devenue : EZi. Mais aprs, on dit que la variable nom a une longueur de
28 caractres et on s'apperoit l'cran que les caractres de rang suprieur 4 ont t
conservs et des espaces ont t insrs pour aller jusqu' 28 ! Ce qui veut dire que la
chane affiche n'est pas toujours la valeur totale de la chane relle en mmoire. Attention
cependant aux chanes dclares de longueur spcifie (voir Chapitre 20 sur Types simples
et structurs exemple: Type nom:String[20];) dont la longueur ne doit pas
dpasser celle dclare en dbut de programme.
Concat ( s1, s2, s3, ..., sn) ;
Cette fonction concatne les chanes de caractres spcifis s1, s2, etc. en une seule et mme
chane. On peut se passer de cette fonction grce l'oprateur + : s1 + s2 + s3 +
... + sn. Rappelons que les chanes de caractres sont gnralement dfinies en string.
37

Syntaxes :
s := Concat ( s1, s2 ) ;
s := s1 + s2 ;
Copy ( s, i, j ) ; Fonction qui retourne de la chane de caractre s, un nombre
j de caractres partir de la position i(dans le sens de la lecture). Rappelons que i et j
sont des entiers (integer).
Delete ( s, i, j ) ; Procdure qui supprime dans la chane nomme s, un
nombre j de caractres partir de la position i.
Insert ( s1, s2, i ) ; Procdure qui insert la chane s1 dans la chane s2
la position i.
Pos ( s1, s2 ) ; Fonction qui renvoie sous forme de variable byte la position
de la chane s1 dans la chane-mre s2. Si la chane s1 en est absente, alors cette
fonction renvoie 0 comme valeur.
Str ( x, s ) ; Procdure qui convertit le nombre (Integer ou Real) x en
chane de caractre de nom s.
Val ( x, s, error ) ; Procdure qui convertit la chane de caractre de nom s
en un nombre (Integer ou Real) x et renvoie un code erreur error (de type
integer) qui est gale 0 si la conversion est possible.
FillChar ( s, n, i ) ; Procdure qui introduit n fois dans la chane s la valeur i (de type
Byte ou Char).

11.2. Caractres seuls


Un caractre est une variable de type Char qui prend 1 octet ( 8 bits) en mmoire. La table
ASCII est un tableau de 256 caractres numrots de 0 255 o les 23 premiers sont associs
des fonction de base de MS-DOS (Suppr, End, Inser, Enter, Esc, Tab, Shift...) et tous les
autres sont directement affichables (lettres, ponctuations, symboles, caractres graphiques).
Dans un programme en Pascal, on peut travailler sur un caractre partir de son numro dans
la table ASCII (avec la fonction Chr(n) ou #n) ou directement avec sa valeur affichage
entre quotte ''.
Exemples :
espace :=' ';
lettre :=#80;
carac :=Chr(102);
Le type Char dfini des variables "caractre seul" ou "lettre" ayant 1 seul signe, ce dernier
appartenant la table ASCII.
Syntaxe :
Var lettre : Char ;
Lorsqu'on donne une valeur une variable Char, celle-ci doit tre entre quottes. On peut
aussi utiliser les fonctions Chr et Ord ou mme une variable String dont on prend
un caractre une position dtermine.
Syntaxe :
lettre := chaine[position] ; StrUpper ( s ) ;
38

Convertit une chane de caractres minuscules en MAJUSCULES. S'applique aux


tableaux de caractres.
Syntaxe de dclaration :
Var s : Array[1..x] of Char avec x la longueur maximale de la chane.
StrLower (s) ; Convertit une chane de caractres MAJUSCULES en minuscules.
S'applique aux tableaux de caractres.
Syntaxe de dclaration :
Var s : Array[1..x] of Char avec x la longueur maximale de la chane.
UpCase ( k ) ; Cette fonction ne s'applique qu'aux caractres seuls (de type Char)
pris dans une chane s. Convertit un caractre minuscule en MAJUSCULE.
Syntaxe :
For i := 1 To Lenght(s) Do s[i] := UpCase(s[i]) ;
Chr ( x ) ; Cette fonction renvoie un caractre Char correspondant au caractre
d'indice x dans la table ASCII.
Exemple :
k := Chr(64) ;
Ord ( y ) ; Cette fonction renvoie l'indice (en byte) correspondant au caractre y
dans la table ASCII. C'est la fonction rciproque de Chr.
Exemple :
i := Ord('M') ;

13. Les tableaux


39

Il est courant d'utiliser des tableaux afin d'y stocker temporairement des donnes. Ainsi, une
donne peut tre en relation avec 1, 2 ou 3 (ou plus) entres. L'intrt du tableau est de
pouvoir stocker en mmoire des donnes que l'on pourra retrouver grce d'autres valeurs
l'aide de boucles, de formules, d'algorithmes. On peut utiliser un tableau afin de reprsenter
l'tat d'un chiquier, le rsultat d'une fonction mathmatique... Il est possible d'introduire des
variables de presque tous les types au sein d'un tableau : Char, Integer, Real,
String, Byte, Record, etc.
Un tableau, tout comme une variable quelconque doit tre dclar dans la partie dclarative
du programme. On doit toujours spcifier le type des variables qui seront introduites dans le
tableau.
Syntaxe :
Var nom_du_tableau : Array[MinDim..MaxDim] Of type ;
Note : les valeurs MinDim et MaxDim doivent tre des Integer ou des Char (c'est--dire
de type numr). Avec MinDim infrieur MaxDim. L'un ou les deux peuvent tres ngatifs.
Le type des variables qui seront mises dans le tableau devra tre celui l : type.
Remarque : il ne peut y avoir qu'un seul type de variable au sein d'un tableau.
Exemples :
Var tab1 : Array[0..10] Of Byte ;
Var tab2 : Array[1..100] Of Integer ;
Var tab3 : Array[-10..10] Of Real ;
Var tab4 : Array[50..60] Of String ;
Var tab5 : Array['A'..'S'] Of Char ;
Var tab6 : Array['a'..'z'] Of Extended ;
Remarque : que les bornes d'un tableau soient dclares par des valeurs de type caractre
(Char) n'interdit pas pour autant de remplir le tableau de nombres virgules (voir le tab6 cidessus). Car en effet, le type des bornes d'un tableau n'influe aucunement sur le type des
variables contenues dans le tableau. Et rciproquement, le type des variables d'un tableau de
renseigne en rien sur le type des bornes ayant servi sa dclaration.
Un tableau peut avoir plusieurs dimensions. Si toutefois, vous imposez trop de dimensions ou
des index trop importants, une erreur lors de la compilation vous dira : Error 22:
Structure too large.
Syntaxes :
Var nom_du_tableau : Array[MinDim1..MaxDim1, MinDim2..MaxDim2] Of
type ; Var nom_du_tableau : Array[MinDim1..MaxDim1,
MinDim2..MaxDim2, MinDim3..MaxDim3] Of type ;
Exemples :
Var tab1 : Array[0..10, 0..10] Of Byte ;
40

Var tab2 : Array[0..10, 0..100] Of Integer ;


Var tab3 : Array[-10..10, -10..10] Of Real ;
Var tab4 : Array[5..7, 20..22] Of String ;
Var tab5 : Array[1..10, 1..10, 1..10, 0..2] Of Char ;
La technique pour introduire des valeurs dans un tableau est relativement simple. Il suffit de
procder comme pour une variable normale, sauf qu'il ne faut pas oublier de spcifier la
position indexqui indique la place de la valeur dans la dimension du tableau.
Syntaxes :
nom_du_tableau[index] := valeur;nom_du_tableau[index1, index2] := valeur ;
Note : la variable index doit ncessairement tre du mme type numr que celui utilis pour
la dclaration du tableau.
On peut introduire dans un tableau les valeurs d'un autre tableau. Mais pour cela, il faut que
les deux tableaux en question soient du mme type (ou de types compatibles), qu'ils aient le
mme nombre de dimension(s) et le mme nombre d'lments.
Syntaxe :
nom_du_premier_tableau:= nom_du_deuxime_tableau ;
Program exemple12a ;
Var tab : Array[1..10] Of Integer ;
i :Integer;
BEGIN
For i:=1 To
10 Do
Begin
tab[i]:=i ;WriteLn(sqrt(tab[i])*5+3) ;
End;
END.
Ce programme utilise un tableau une seule dimension dont les valeurs seront des variables
de type integer. Les "cases" du tableau vont de 1 10. Ici, le programme donne chaque
case la valeur de l'index l'aide d'une boucle. Et ensuite, il affiche les valeurs contenues dans
le tableau.
Il existe une autre manire de dclarer un tableau de dimensions multiples en crant un
tableau de tableau. Mais cette technique n'est pas la plus jolie, pas la pratique, pas la plus
apprcie aux examens... Donc ne pas utiliser !
Syntaxe :
Var nom_du_tableau : Array[MinDim1..MaxDim1] Of
Array[MinDim2..MaxDim2] Of type ; { syntaxe dsute }
Mais une autre manire d'introduire des valeurs accompagne ce type de dclaration.
Syntaxe :
nom_du_tableau[index1][index2] := valeur ;

41

Le passage d'un tableau (type complexe) en paramtre une procdure pose problme si on
ne prend pas des prcautions. C'est--dire qu'il faut dclarer un type prcis de tableau (qui
sera un type simple).
Syntaxe :
Type nom_du_nouveau_type_tableau = Array[DimMin..DimMax] Of Type;
Var nom_du_tableau : nom_du_nouveau_type_tableau ;
Procedure nom_de_la_procedure(Var nom_du_tableau :
nom_du_nouveau_type_tableau) ;
Program exemple12b ;
Uses crt ;
Type tableau = Array[1..10] Of Integer ;
Procedure saisie(Var tab:Tableau) ;
Var i:Integer ;Begin
For i:=1 to 10 Do
Begin Write('Entrez la valeur de la case n',i,'/10 : ') ;
ReadLn(tab[i]) ;
End ;
End ;
Procedure tri(Var tab:Tableau) ;Var i,j,x:Integer ;
Begin
For i:=1 To 10 Do
Begin
For j:=i To 10 Do
Begin if tab[i]>tab[j] Then
Begin x:=tab[i] ;tab[i]:=tab[j] ;tab[j]:=x ;
End;
End ;
End ;
End ;
Procedure affiche(tab:Tableau) ;
Var i:Integer ;
Begin
For i:=1 To 10 Do Write(tab[i],' ') ;
WriteLn ;
End ;
Var tab1,tab2:Tableau ;
i:Integer ;
BEGIN ClrScr ;saisie(tab1) ;tab2:=tab1 ;tri(tab2) ;WriteLn('Srie saisie
:') ;affiche(tab1) ;WriteLn('Srie trie :') ;affiche(tab2) ;
END.
Ce programme a pour but de trier les lments d'un tableau d'entiers dans l'ordre croissant.
Pour cela, il dclare un nouveau type de tableau grce la syntaxe Type. Ce nouveau type est
un tableau une dimension, de 10 lments de type integer. Une premire procdure
42

saisie charge l'utilisateur d'initialiser le tableau tab1. Le programme principal copie le contenu
de ce tableau vers un autre appel tab2. Une procdure tri range les lments de tab2dans
l'ordre. Et une procdure affiche affiche l'cran le tableau tab1 qui contient les lments
dans introduits par l'utilisateur et le tableau tab2 qui contient les mmes lments mais rangs
dans l'ordre croissant.
Il est galement possible d'introduire dans un tableau des donnes complexes, c'est--dire de
dclarer un tableau en type complexe (Record).
Syntaxe :
Var tab : Array[1..10] Of Record
nom : String[20] ;age : Byte ; End ;
Introduire des valeurs dans un tel tableau ncessite d'utiliser en mme temps la syntaxe des
tableaux et des types complexes.
Syntaxe :
tab[5].nom := 'CyberZode' ;
La dclaration de tableau en tant que constante ncessite de forcer le type (le type tableau bien
sr) la dclaration.
Syntaxe :
Const a : Array[0..3] Of Byte = (103, 8, 20, 14) ;
b :
c :
5),
d :

Array[-3..3] Of Char = ('e', '5', '&', 'Z', 'z', ' ', #80) ;
Array[1..3, 1..3] Of Integer = ((200, 23, 107), (1234, 0,
(1, 2, 3)) ;
Array[1..26] Of Char = 'abcdefghijklmnopqrstuvwxyz';

Attention : cette forme parenthse est rserve aux constantes car elle ne permet pas de
passer un tableau en paramtre une procdure ou d'initialiser un tableau.

43

13. Les algorithmes de tri


Un algorithme de tri est, en informatique ou en mathmatiques, un algorithme qui
permet d'organiser une collection d'objets selon un ordre dtermin. Les objets trier font
donc partie d'un ensemble muni d'une relation d'ordre (de manire gnrale un ordre total).
Les ordres les plus utiliss sont lordre numrique et l'ordre lexicographique (dictionnaire).
Suivant la relation d'ordre considre, une mme collection dobjet peut donner lieu divers
arrangements, pourtant il est possible de dfinir un algorithme de tri indpendamment de la
fonction dordre utilise. Celui-ci ne fera qu'utiliser une certaine fonction dordre
correspondant une relation dordre qui doit permettre de comparer tout couple d'lments de
la collection.

13.1. Tri bulles


Le tri bulles ou tri par propagation est un algorithme de tri qui consiste faire
remonter progressivement les plus petits lments d'une liste, comme les bulles d'air
remontent la surface d'un liquide. L'algorithme parcourt la liste, et compare les couples
d'lments successifs. Lorsque deux lments successifs ne sont pas dans l'ordre croissant, ils
sont changs. Aprs chaque parcours complet de la liste, l'algorithme recommence
l'opration. Lorsqu'aucun change n'a lieu pendant un parcours, cela signifie que la liste est
trie : l'algorithme peut s'arrter.
Cet algorithme est souvent enseign en tant qu'exemple algorithmique. Cependant, il prsente
une complexit en (n) dans le pire des cas (o n est la longueur de la liste), ce qui le classe
parmi les mauvais algorithmes de tri. Il n'est donc quasiment pas utilis en pratique.
Syntaxe :
Const MAX = 100; (* MAX = 100 est donn en exemple seulement *)
Type tab = array [1..MAX] of integer;
Procedure TriBulle(n: integer ; var t: tab);
Var i, j, tmp: integer;
begin
(* On va trier les n-1 premiers lments du tableau *)
for i := 1 to n - 1 do
begin
for j := 1 to n - i do (* on fait n-i-1 comparaisons en avanant dans le tableau *)
begin
if(t[j + 1] < t[j]) then
begin
tmp := t[j];
t[j] := t[j + 1];
t[j+1] := tmp;
end;
end;
end;
end;

44

13.2. Tri par slection


Le tri par slection (ou tri par extraction) est un des algorithmes de tri les plus triviaux.
Il consiste en la recherche soit du plus grand lment (ou le plus petit) que l'on va replacer
sa position finale c'est--dire en dernire position (ou en premire), puis on recherche le
second plus grand lment (ou le second plus petit) que l'on va replacer galement sa
position finale c'est--dire en avant-dernire position (ou en seconde), etc., jusqu' ce que le
tableau soit entirement tri.
Le tri par slection est intressant lorsque les lments sont aisment comparables
mais coteux dplacer dans la structure. Ainsi, le nombre de comparaisons sera toujours
suprieur ou gal ce qui est ncessaire pour effectuer un tri par insertion ou un tri bulles.
Par contre, s'il n'est pas possible de faire des insertions dans la structure en temps constant
(O(1)), le nombre d'changes sera en moyenne trs infrieur.
Syntaxe :
procedure TriSelection(n : integer ; var t : tab);
var i, j, min, tmp : integer;
begin
for i := 1 to n - 1 do begin
min := i;
for j := i + 1 to n do
if (t[j] < t[min]) then min:=j;
if (i <> min) then begin
tmp := t[i];
t[i] := t[min];
t[min] := tmp;
end;
end;
end;

13.3. Tri par insertion


Le tri par insertion est le tri le plus efficace sur des listes de petite taille. C'est
pourquoi il est utilis par d'autres mthodes comme le tri rapide (ou quicksort). Il est d'autant
plus rapide que les donnes sont dj tries en partie dans le bon ordre.
Le principe de ce tri est trs simple: c'est le tri que toute personne utilise naturellement quand
elle a des dossiers (ou n'importe quoi d'autre) classer. On prend un dossier et on le met sa
place parmi les dossiers dj tris. Puis on recommence avec le dossier suivant.
Pour procder un tri par insertion, il suffit de parcourir une liste : on prend les lments dans
l'ordre. Ensuite, on les compare avec les lments prcdents jusqu' trouver la place de
l'lment qu'on considre. Il ne reste plus qu' dcaler les lments du tableau pour insrer
l'lment considr sa place dans la partie dj trie. On peut aussi faire une recherche par
dichotomie sur les tableaux.

45

Syntaxe :
const MAX = 100;
type tab = array [1..MAX] of real;
Procedure TriInsertion(n : integer ; var t : tab);
var i, j : integer;
var z : real;
begin
for i:=2 to n do begin
z := t[i]; (* z est la valeur insrer *)
(* dans l'endroit appropri du tableau *)
(* On dcale toutes les valeurs du tableau < z *)
(* droite pour vider une place pour z

*)

j := i - 1;
while (j >= 1) and (t[j] > z) do begin
t[j + 1] := t[j];
j := j - 1;
end;
(* finalement la valeur z est insre son emplacement adquat *)
t[j + 1] := z;
end;
end;

13.4. Tri rapide


Le tri rapide (en anglais quicksort) est une mthode de tri invente par C.A.R. Hoare
en 1961 et fonde sur la mthode de conception diviser pour rgner. Il peut tre implment
sur un tableau (tri sur place) ou sur des listes ; son utilisation la plus rpandue concerne tout
de mme les tableaux.
Le Quicksort est un tri dont la complexit moyenne est en , mais dont la complexit dans le
pire des cas est O(n2). Malgr ce dsavantage thorique, c'est en pratique un des tris sur place
le plus rapide pour des donnes rparties alatoirement. Les entres donnant lieu au
comportement quadratique dpendent de l'implmentation de l'algorithme, mais sont souvent
(si l'implmentation est maladroite) les entres dj presque tries. Il sera plus avantageux
alors d'utiliser le tri par insertion.

46

Syntaxe :
const MAX_VAL = 200;
type tab_entier = array [1..MAX_VAL] of integer;
procedure tri_rapide(deb, fin : integer ; var t : tab_entier);
var i, p : integer; mid, aux : integer;
begin
(* si fin > deb alors le tableau ncessite d'tre tri*)
if (fin > deb) then begin
(* choisir le milieu du tableau comme pivot *)
mid := (deb + fin) div 2;
(* mettre l'lment pivot au dbut afin de pouvoir parcourir le tableau en continu. *)
aux := t[mid];
t[mid] := t[deb];
t[deb] := aux;
(* parcourir le tableau tout en amenant les lments infrieurs
l'lment pivot au dbut de la plage *)
p := deb;
for i:=deb+1 to fin do begin
if (t[i] < t[deb]) then begin
p := p + 1;
aux := t[i];
t[i] := t[p];
t[p] := aux;
end;
end;
(* mettre le pivot la position adquate cd
la suite des lments qui lui sont infrieurs *)
aux := t[p];
t[p] := t[deb];
t[deb] := aux;
tri_rapide(deb, p - 1, t); (* trie le sous tableau gauche *)
tri_rapide(p + 1, fin, t); (* trie le sous tableau droite *)
end;
end;
47

Chapitre II. MATLAB


Introduction
MATLAB (MATrix LABoratory) comprend de nombreuses fonctions graphiques, un systme
puissant doperateurs sappliquant des matrices, des algorithmes numriques (EDOs, zros
dune fonction, intgration, interpolation), ainsi quun langage de programmation
extrmement simple utiliser.
Il fut conu initialement (au milieu des annes 1980) pour manipuler aisment des matrices
laide de fonctions prprogrammes (addition, multiplication, inversion, dcompositions,
dterminants . . .), en saffranchissant des contraintes des langages de programmation
classique :
Plus de dclarations de variables.
Plus de phase ddition-compilation-excution.
Cette orientation calcul matriciel a depuis volue vers un outil pouvant tre vu comme une
super-calculatrice graphique et regroupant dans la version de base la quasi-majorit des
problmes numriques (hormis les EDP qui sont aussi diversifies que dlicates rsoudre).
Plusieurs extensions plus pointues ont t conues sous la forme de TOOLBOX, qui
sont des paquets (payants parfois !) de fonctions supplmentaires ddies un domaine
particulier :
CONTROL pour lautomatique.
SIGNAL pour le traitement du signal.
OPTIMIZATION pour loptimisation.
Cet aspect modulaire est lun des plus grands atouts de MATLAB : lutilisateur peut luimme dfinir ses propres fonctions, en regroupant des instructions MATLAB dans un fichier
portant le suffixe .m. La syntaxe est bien plus abordable que dans les langages classiques et
devrait liminer les rticences habituelles des programmeurs dbutants pour crire des
fonctions.
En termes de vitesse dexcution, les performances sont infrieures celles obtenues avec un
langage de programmation classique. Lemploi de MATLAB devrait donc tre restreinte des
problmes peu gourmands en temps calcul, mais dans la plupart des cas, il prsente une
solution lgante et rapide mettre en uvre.
Notons enfin que MATLAB est disponible sur tous types de plates-formes (toutes les stations
sous UNIX y compris LINUX, Windows 9x et Macintosh).

48

1. Gnralits et prise en main


1.1

Dmarrage, quitter

Pour lancer le programme, tapez matlab dans une fentre de commandes. Une fentre logo
fait une brve apparition, puis dans la fentre de commande, le symbole apparat :
Cest linvite de MATLAB qui attend vos commandes.
>>_
Vous pourrez quitter la session avec la commande quit.
>> quit

1.2. Aide, documentation en ligne


Laide en ligne peut tre obtenue directement dans la session en tapant help nom de
commande :
>> help
La commande help toute seule vous indiquera les diffrents thmes abords dans la
documentation.

1.3 .Calculs lmentaires


Commenons par les oprateurs les plus courants : +, -, *, /, ^. Le dernier signifie
puissance, et on retiendra quil est diffrent de celui du FORTRAN. Les parenthses
sutilisent de manire classique.
Nous avons tout pour effectuer un premier calcul : tapez une expression mathmatique
quelconque et appuyez sur Entre. Par exemple :
>> (3*2)/(5+3)
ans =
0.7500
Le rsultat est mis automatiquement dans une variable appele ans (answer). Celle-ci peut
tre utilise pour le calcul suivant, par exemple :
>> ans*2
ans =
1.5000
Ensuite, vous remarquerez que le rsultat est affich avec 5 chiffres significatifs, ce qui ne
signifie pas que les calculs sont faits avec aussi peu de prcision. La prcision utilise par
MATLAB pour stocker les rels est celle du double prcision FORTRAN. Si vous voulez
afficher les nombres avec plus de prcision, tapez la commande format long. Pour revenir au
format initial : format short.

49

1.4. Historique des commandes


Cest une fonctionnalit trs utile, inspire des shells UNIX modernes : toutes les commandes
que vous aurez tap sous MATLAB peuvent tre retrouves et dites grce aux touches de
direction. Appuyez sur * pour remonter dans les commandes prcdentes, + pour redescendre
et utilisez, et la touche Backspace pour diter une commande.
Pour relancer une commande, inutile de remettre le curseur la fin, vous appuyez directement
sur la touche Entre.
Encore plus fort : vous pouvez retrouver toutes les commandes commenant par un groupe de
lettres. Par exemple pour retrouver toutes les commandes commenant par plot, tapez plot,
puis appuyez plusieurs fois sur *.

50

2. variables et fonctions prdfinies


2.1. Variables
Le calcul effectu plus haut na gure dintrt en soi. Il est bien sr possible de conserver un
rsultat de calcul et de le stocker dans des variables. Gros avantage sur les langages classiques
: on ne dclare pas les variables. Leur type (entier, rel, complexe) saffectera
automatiquement en fonction du calcul effectu.
Pour affecter une variable, on dit simplement quoi elle est gale. Exemple :
>> a=1.2
a=
1.2000
On peut maintenant inclure cette variable dans de nouvelles expressions mathmatiques, pour
en dfinir une nouvelle :
>> b = 5*a2+a
b=
8.4000
et ensuite utiliser ces deux variables :
>> c = a2 + b3/2
c=
297.7920
Jai maintenant trois variables a, b et c. Comme indiqu dans le prambule ces variables ne
sont pas affiches en permanence lcran. Mais pour voir le contenu dune variable, rien de
plus simple, on tape son nom :
>> b
b=
8.4000
On peut aussi faire des calculs en complexe. 1 scrit indiffremment i ou j, donc pour
dfinir un complexe :
>> a+ b*i
ans =
1.2000 + 8.4000i
Le symbole * peut tre omis si la partie imaginaire est une constante numrique. Tous les
oprateurs prcdents fonctionnent en complexe. Par exemple :
>> (a+b*i)2
ans =
-69.1200 +20.1600i

51

Important : Un dernier point sur les variables :


MATLAB fait la diffrence entre les minuscules et les majuscules.
Les noms de variables peuvent avoir une longueur quelconque.
Les noms de variables doivent commencer par une lettre.

2.2. Effacement et liste des variables


La commande clear permet deffacer une partie ou toutes les variables dfinies jusqu
prsent. Il est conseill de placer cette commande au dbut de vos fichiers de commandes, en
particulier lorsque vous manipulez des tableaux. Syntaxe :
clear var1 var2 var3 . . .
Si aucune variable nest spcifie, toutes les variables seront effaces. La commande who
affiche les noms de toutes les variables en cours.

2.3. Variables prdfinies


Il existe un certain nombre de variables prexistantes. Nous avons dj vu ans qui contient le
dernier rsultat de calcul, ainsi que i et j qui reprsentent 1.
Il existe aussi pi, qui reprsente , et quelques autres. Retenez que eps, nom que lon a
souvent tendance utiliser est une variable prdfinie.
ATTENTION : ces variables ne sont pas protges, donc si vous les affectez, elles ne gardent
pas leur valeur. Cest souvent le problme pour i et j que lon utilise souvent spontanment
comme indices de boucles, de telle sorte quon ne peut plus ensuite dfinir de complexe ! !

2.4 .Fonctions prdfinies


Toutes les fonctions courantes et moins courantes existent. La plupart dentre elles
fonctionnent en complexe. On retiendra que pour appliquer une fonction `a une valeur, il faut
mettre cette dernire entre parenthses. Exemple :
>> sin(pi/12)
ans =
0.16589613269342
Voici une liste non exhaustive :
fonctions trigonomtriques et inverses : sin, cos, tan, asin, acos, atan
fonctions hyperboliques (on rajoute h) : sinh, cosh, tanh, asinh, acosh, atanh
racine, logarithmes et exponentielles : sqrt, log, log10, exp
fonctions erreur : erf, erfc

52

3. Matrices et tableaux
En dpit du titre de cette section, MATLAB ne fait pas de diffrence entre les deux. Le
concept de tableau est important car il est la base du graphique : typiquement pour une
courbe de n points, on dfinira un tableau de n abscisses et un tableau de n ordonnes.
Mais on peut aussi dfinir des tableaux rectangulaires deux indices pour dfinir des matrices
au sens mathmatique du terme, puis effectuer des oprations sur ces matrices.

3.1. Dfinition dun tableau


On utilise les crochets [ et ] pour dfinir le dbut et la fin de la matrice. Ainsi pour dfinir une
variable M contenant, on crira :
>> M = [1 2 3
11 12 13
21 22 23]
M=
1 2 3
11 12 13
21 22 23
Le passage dune ligne de commande la suivante seffectuant par la frappe de la touche
Entre. On peut galement utiliser le symbole, qui sert de sparateur de colonne et ; de
sparateur de ligne. Ainsi pour dfinir la matrice prcdente on aurait pu taper :
>> M = [1,2,3;11,12,13;21,22,23]
ou bien, en remplaant la virgule par des blancs :
>> M = [1 2 3;11 12 13;21 22 23]
On peut aussi dfinir des vecteurs, ligne ou colonne, partir de cette syntaxe. Par exemple :
>> U = [1 2 3]
U=
123
Ou un vecteur ligne :
>> V = [11
12
13]
V=
11
12
13

53

dfinit un vecteur colonne. On aurait pu aussi dfinir ce dernier par :


>> V=[11;12;13]

3.2. Accs un lment dun tableau


Il suffit dentre le nom du tableau suivi entre parenthses du ou des indices dont on veut lire
ou crire la valeur. Exemple si je veux la valeur de 32:
>> M(3,2)
ans =
22
Pour modifier seulement un lment dun tableau, on utilise le mme principe. Par exemple :
je veux que M32 soit gal 32 au lieu de 22 :
>> M(3,2)=32
M=
123
11 12 13
21 32 23
Vous remarquerez que MATLAB raffiche du coup toute la matrice, en prenant en compte la
modification. On peut de demander se qui se passe si on affecte la composante dune matrice
qui nexiste pas encore. Exemple :
>> P(2,3) = 3
P=
000
003
Voil la rponse : MATLAB construit automatiquement un tableau suffisamment grand pour
arriver jusquaux indices spcifis, et met des zros partout sauf au terme considr.
Vous remarquerez que contrairement aux langages classiques, inutile de dimensionner les
tableaux lavance : ils se construisent au fur et mesure !

3.3. Extraction de sous-tableaux


Il est souvent utile dextraire des blocs dun tableau existant. Pour cela on utilise le caractre :
Il faut spcifier pour chaque indice la valeur de dbut et la valeur de fin. La syntaxe gnrale
est donc la suivante (pour un tableau deux indices) :
tableau (dbut :fin, dbut :fin)

54

Exemple :
>> M(1:2,2:3)
ans =
23
12 13
Si on utilise le caractre : seul, a veut dire prendre tous les indices possibles. Exemple :
>> M(1:2,:)
ans =
1 2 3
11 12 13

Cest bien pratique pour extraire des lignes ou des colonnes dune matrice. Par exemple :
Pour obtenir la deuxime ligne de:
>> M(2,:)
ans =
11 12 13

3.4. Construction de tableaux par blocs


Vous connaissez ce principe en mathmatiques. Par exemple, partir des matrices et vecteurs
prcdemment dfinis, on peut dfinir la matrice :

Qui est une matrice 4x4. Pour faire a sous MATLAB, on fait comme si les blocs taient des
scalaires, et on crit tout simplement :
>> N=[M V
U 0]
N=
1 2 3 11
11 12 13 12
21 32 23 13
1 2 3 0
Ou bien en utilisant le caractre ;
>> N=[M V; U 0]
Cette syntaxe est trs utilise pour allonger des vecteurs ou des matrices, par exemple si je
veux ajouter une colonne M, constitue par V :

55

>> M=[M V]
M=
1 2 3 11
11 12 13 12
21 32 23 13
Si je veux lui ajouter une ligne, constitue par U :
>> M = [M;U]
M=
1 2 3
11 12 13
21 32 23
1 2 3

3.5. Oprations sur les tableaux


3.5.1. Addition et soustraction
Les deux oprateurs sont les mmes que pour les scalaires. A partir du moment o les deux
tableaux concerns ont la mme taille, Le tableau rsultant est obtenu en ajoutant ou
soustrayant les termes de chaque tableau.

3.5.2. Multiplication, division et puissance terme `a terme


Ces oprateurs sont nots .*, ./ et .^ (attention ne pas oublier le point).
Ils sont prvus pour effectuer des oprations termes terme sur deux tableau de mme taille.
Ces symboles sont fondamentaux lorsque lon veut tracer des courbes.

3.5.3. Multiplication, division et puissance au sens matriciel


Puisque lon peut manipuler des matrices, il parat intressant de disposer dune
multiplication matricielle. Celle-ci se note simplement * et ne doit pas tre confondu avec la
multiplication terme terme. Il va de soi que si lon crit A*B le nombre de colonnes de A
doit tre gal au nombre de lignes de B pour que la multiplication fonctionne.
La division a un sens vis--vis des inverses de matrices. Ainsi A/B reprsente A multipli (au
sens des matrices) la matrice inverse de B. ATTENTION : mme si la matrice B est
rgulire, elle peut tre mal conditionne, et la mthode numrique utilise pour calculer son
inverse peut renvoyer des rsultats faux (cf. cours systmes linaires).
Voici la multiplication au sens des matrices :
>> [1 0; 0 1] * [1 2; 3 4]
ans =
12
34

56

et maintenant la multiplication terme terme :


>> [1 0; 0 1] .* [1 2; 3 4]
ans =
10
04

3.5.4. Transposition
Loprateur transposition est le caractre et est souvent utilis pour transformer des vecteurs
lignes en vecteurs colonnes et inversement.

3.5.5. Synthse
Le tableau suivant rsume les diffrents oprateurs applicables aux matrices.

3.6. Longueurs de tableau


La fonction size applique une matrice renvoie un tableau de deux entiers : le premier est le
nombre de lignes, le second le nombre de colonnes. La commande fonctionne aussi sur les
vecteurs et renvoie 1 pour le nombre de lignes (resp. colonnes) dun vecteur ligne (resp.
colonne).
Pour les vecteurs, la commande length est plus pratique et renvoie le nombre de composantes
du vecteur, quil soit ligne ou colonne.

57

3.7. Gnration rapide de tableaux


3.7.1. Matrices classiques
On peut dfinir des matrices de taille donne ne contenant que des 0 avec la fonction zeros,
ou ne contenant que des 1 avec la fonction ones. Il faut spcifier le nombre de lignes et le
nombre de colonnes.
ATTENTION, pour engendrer des vecteurs lignes (resp. colonnes), il faut spcifier
explicitement 1 pour le nombre de lignes (resp. colonnes). Voici deux exemples :
>> ones(2,3)
ans =
111
111
>> zeros(1,3)
ans =
000
La matrice identit est obtenue avec eye. On spcifie seulement la dimension de la matrice
(qui est carre. . .)
>> eye(3)
ans =
100
010
001
Il existe galement une fonction diag permettant de crer des matrices diagonale par
diagonale.

3.7.2. Listes de valeurs


Cette notion est capitale pour la construction de courbes. Il sagit de gnrer dans un vecteur
une liste de valeurs quidistantes entre deux valeurs extrmes. La syntaxe gnrale est :
variable = valeur dbut: pas: valeur fin
Cette syntaxe cre toujours un vecteur ligne. Par exemple pour crer un vecteur x de valeurs
quidistantes de 0.1 entre 0 et 1 :
>> x = 0:0.1:1
x=
Columns 1 through 7
0 0.1000 0.2000 0.3000 0.4000 0.5000 0.6000
Columns 8 through 11
0.7000 0.8000 0.9000 1.0000

58

Il est conseill de mettre un point-virgule ; la fin de ce type dinstruction pour viter


laffichage fastidieux du rsultat.
Autre exemple pour crer 101 valeurs qui-rparties sur lintervalle [0, 2] :
>> x = 0: 2*pi/100 : 2*pi;
On peut aussi crer des valeurs rparties de manire logarithmique avec la fonction logspace.

59

4. Graphique 2D
Une courbe 2D est pour tout logiciel de trac de courbes reprsent par une srie dabscisses
et une srie dordonnes. Ensuite, le logiciel trace gnralement des droites entre ces points.
MATLAB nchappe pas la rgle. La fonction sappelle plot.

4.1 .Linstruction plot


4.1.1. Tracer une courbe simple
Lutilisation la plus simple de linstruction plot est la suivante.
plot ( vecteur dabscisses, vecteur dordonnes )
[ x1 x2 . . . xn ] [ y1 y2 . . . yn ]
Les vecteurs peuvent tre indiffremment ligne ou colonne, pourvu quils soient tous deux de
mme type. En gnral ils sont lignes car la gnration de listes de valeurs vue la fin du
chapitre prcdent fournit par dfaut des vecteurs lignes.
Par exemple, si on veut tracer sin(x) sur lintervalle [0 2], on commence par dfinir une
srie (raisonnable, disons 100) de valeurs quidistantes sur cet intervalle :
>> x = 0: 2*pi/100 : 2*pi;
Puis, comme la fonction sin peut sappliquer terme terme un tableau :
>> plot(x, sin(x))
Qui fournit le graphe suivant dans la fentre graphique :

On voit que les axes sadaptent automatiquement aux valeurs extrmales des abscisses et
ordonnes. On remarquera que tout ce que demande plot, cest un vecteur dabscisses et un
vecteur dordonnes. Les abscisses peuvent donc tre une fonction de x plutt que x luimme. En dautres termes, il est donc possible de tracer des courbes paramtres :
>> plot(cos(x), sin(x))

60

4.1.2. Superposer plusieurs courbes


Il suffit de spcifier autant de couples (abscisses, ordonnes) quil y a de courbes tracer.
Par exemple pour superposer sin et cos :
>> plot(x,cos(x),x,sin(x))

4.1.3. Le pige classique


Vous tomberez rapidement dessus, et rassurez-vous, vous ne serez pas le premier. Essayez par
exemple de tracer le graphe de la fonction x sin (x) sur [0 2]. Selon la section prcdente:
>> x = 0:0.1:1;
>> plot(x, x*sin(x))
??? Error using ==> *
Inner matrix dimensions must agree.
Et voil : pour MATLAB vous manipulez des tableaux : x en est un, et sin(x) en est un
deuxime de mme taille, et tous deux sont des vecteurs lignes.
Est-ce que a a un sens de multiplier deux vecteurs lignes au sens des matrices ? Non, nestce-pas ? Cest pourtant ce que vous avez fait, puisque vous avez utilis le symbole * .
Vous avez compris : il fallait utiliser la multiplication terme terme .* soit :

61

>> plot(x, x.*sin(x))


et a marche ! On peut donc noncer la rgle suivante :
Rgle : Lorsque lon crit une expression arithmtique dans les arguments de plot, il faut
utiliser systmatiquement les oprateurs terme terme .* ./ et .^ au lieu de * / et ^

4.1.4. Attributs de courbes


Vous aurez remarqu que MATLAB attribue des couleurs par dfaut aux courbes. Il est
possible de modifier la couleur, le style du trait et celui des points, en spcifiant aprs chaque
couple (abscisse, ordonne) une chaine de caractres (entre quottes) pouvant contenir les
codes suivants (obtenus en tapant help plot ):

Lorsque lon utilise seulement un style de points, MATLAB ne trace plus de droites entre les
points successifs, mais seulement les points eux-mmes. Ceci peut tre pratique par exemple
pour prsenter des rsultats exprimentaux.
Les codes peuvent tre combins entre eux. Par exemple :
>> plot(x,sin(x),:,x,cos(x),r-.)

4.2. Echelles logarithmiques


On peut tracer des chelles log en abscisse, en ordonne ou bien les deux. Les fonctions
correspondantes sappellent respectivement semilogx, semilogy et loglog. Elles sutilisent
exactement de la mme manire que plot.
Par exemple :
>> x=1:100;
>> semilogx(x,log(x))
Cette fonction donne la courbe suivante :

62

4.3. Dcoration des graphiques


4.3.1. Titre
Cest linstruction title laquelle il faut fournir une chaine de caractres. Le titre apparat en
haut de la fentre graphique :
>> plot(x,cos(x),x,sin(x))
>> title(Fonctions sin et cos)

4.3.2. Labels
Il sagit dafficher quelque chose sous les abscisses et cot de laxe des ordonnes :
>> plot(x,cos(x))
>> xlabel(Abscisse)
>> ylabel(Ordonnee)

63

4.3.3. Lgendes
Cest linstruction legend. Il faut lui communiquer autant de chaines de caractres que de
courbes traces lcran. Un cadre est alors trac au milieu du graphique, qui affiche en face
du style de chaque courbe, le texte correspondant. Par exemple :

>> plot(x,cos(x),:,x,sin(x),-.,x,sqrt(x),--)
>> legend(cosinus,sinus,racine)

64

5.Graphique 3D et assimiles
5.1. Courbes en 3D
Une courbe en 2D est dfinie par une liste de doublets (x,y) et une courbe en 3D par une liste de
triplets (x,y,z). Puisque linstruction plot attendait deux arguments, un pour les x, un pour les y,
linstruction plot3 en attend trois : les x, les y et les z.

Voici un exemple de courbe paramtre :


>> plot3(exp(-t/10).*sin(t), exp(-t/10).*cos(t), exp(-t))
>> grid

5.2. Surfaces
5.2.1. Gnration des points (meshgrid)
Pour dfinir une surface, il faut un ensemble de triplets (x,y,z) En gnral les points (x,y) tracent dans
le plan un maillage rgulier mais ce nest pas une obligation. La seule contrainte est que le nombre de
points soit le produit de deux entiers mn (on comprendra pourquoi trs bientt).
Si on a en tout m n points, cela signifie que lon a mn valeurs de x, mn valeurs de y et mn
valeurs de z. Il apparat donc que abscisses, ordonnes et cotes des points de la surface peuvent tre
stocks dans des tableaux de taille mn.

Toutes les instructions de trace du surface, par exemple surf auront donc la syntaxe suivante :

65

Il reste maintenant construire ces tableaux. Prenons tout dabord le cas de la surface dfinie
par :

dont on veut tracer la surface reprsentative sur [1, 1] [2, 2]. Pour dfinir un quadrillage de ce rectangle, il
faut dfinir une suite de valeurs x1. . .xm pour x et une suite de valeurs y1. . . yn pour y, par exemple :

>> x = -1:0.2:1
x=
Columns 1 through 7
-1.0000 -0.8000 -0.6000 -0.4000 -0.2000 0 0.2000
Columns 8 through 11
0.4000 0.6000 0.8000 1.0000

>> y = -2:0.2:2
y=
Columns 1 through 7
-2.0000 -1.8000 -1.6000 -1.4000 -1.2000 -1.0000 -0.8000
Columns 8 through 14
-0.6000 -0.4000 -0.2000 0 0.2000 0.4000 0.6000
Columns 15 through 21
0.8000 1.0000 1.2000 1.4000 1.6000 1.8000 2.0000
En combinant toutes ces valeurs de x et y, on obtient m n points dans le plan (x, y). Il faut
maintenant construire deux tableaux, lun contenant les mn abscisses de ces points lautre
les m n ordonnes, soit :

Rassurez-vous pas besoin de boucle, la fonction meshgrid sen charge :


>> [X,Y] = meshgrid(x,y);

66

Il reste maintenant calculer les


correspondants. Cest l que les calculs terme
terme sur les matrices montrent leur efficacit : on applique directement la formule aux
tableaux X et Y, sans oublier de mettre un point devant les oprateurs *, / et ^
>> Z = Y .2 - X.2;
5.2.2 Trace de la surface
Ensuite on peut utiliser toutes les fonctions de trac de surface, par exemple mesh
>> mesh(X,Y,Z)

Les instructions les plus courantes sont :


mesh qui trace une srie de lignes entre les points de la surface en mode lignes caches
meshc qui fonctionne comme mesh mais ajoute les courbes de niveau dans le plan (x,y)
surf qui peint la surface avec une couleur fonction de la cote.
surfl qui peint la surface comme si elle tait claire.
surfc qui fonctionne comme mesh mais ajoute les courbes de niveau dans le plan (x,y)
Le rsultat pour les 4 premires instructions est visible sur la figure suivante :

67

Notons enfin quil existe des fonctions de conversion entre les coordonnes cartsiennes,
cylindriques et sphriques, permettant de tracer facilement des courbes dfinies dans lun de
ces systmes de coordonnes. On regardera par exemple la documentation de cart2pol.

5.2.3. Courbes de contour


Pour tracer les courbes z= C dune surface z= f(x,y), on peut utiliser la fonction contour. Elle
sutilise comme les instructions prcdentes, mais fournit un graphe 2D dans le plan (x,y).
Plusieurs paramtres optionnels peuvent tre spcifis, notamment le nombre de courbes de
contours afficher. Avec les matrices X,Y,Z construites prcdemment, on Pourra par
exemple essayer, pour tracer 10 lignes de niveau :

>> contour(X,Y,Z, 10)

68

Dans ce cas, il est galement intressant dajouter les valeurs de z le long des diffrentes
lignes de contour. Pour cela il faut affecter une variable avec la sortie de la commande
contour et utiliser la fonction clabel :
>> ch = contour(X,Y,Z, [-0.5 0 0.5 1 2 3 ]);
>> clabel (ch)
Le rsultat est visible sur la figure :

69

5.3. Divers
5.3.1. Contrle de langle de vue
Il existe la commande view, mais le plus simple est dutiliser le bouton
dans la barre
doutils de la fentre graphique. Cliquez ensuite avec le bouton gauche de la souris pour faire
tourner la figure. ATTENTION : tout clic de la souris provoque un raffichage, et si votre
surface contient beaucoup de points, elle met beaucoup de temps se rafficher.

5.3.2. Colormaps
Linstruction colormap dfinit la suite des couleurs, ou palette, pour peindre les surfaces.
On peut donner directement des tableaux de couleurs ou bien utiliser des palettes prdfinies
(par exemple bone, winter, hot . . .). Reportez-vous la documentation pour en savoir
plus.

5.3.3. Interpolation
Vous aurez remarqu que MATLAB trace les surfaces avec des facettes. Il est possible de
lisser ces surfaces avec linstruction shading. On pourra tester par exemple, la suite dune
instruction surfl (cest le plus spectaculaire) :
>> shading interp

5.3.4. Autres
Il existe de nombreuses autres fonctions pour jouer sur la camra, tracer des donnes en
volumes, des champs de vecteurs, des donnes sur une surface etc. Leur prsentation sortirait
du cadre de cette introduction, et vous pourrez trouver plus dinfos dans la rubrique
Graphique 3D de laide Help.

5.4. Exemple:
Cet exemple utilise loutil traitement dimage de MATLAB et voici les diffrentes tapes de
ralisation de cet exemple :
tape 1: Lecture dun fichier image (Read Images)
tape 2: Le choix des points de contrle (Choose Control Points)
tape 3: appliquer une transformation gomtrique sur limage initiale (Infer Geometric
Transformation)
tape 4: Transformer limage rsultante de ltape 3( Transform Unregistered Image )
tape 5: afficher limage transforme (View Registered Image)
tape 1:
Notre image initiale ( transformer) est appele westconcordorthophoto.png de type .png
Cette image est prise par une vue arienne.
Voici le code de la 1ire tape :

70

unregistered = imread('westconcordaerial.png');
figure, imshow(unregistered)
figure, imshow('westconcordorthophoto.png')

westconcordorthophoto.png

unregistered

Etape 2: Le choix des points de contrle


On va choisir des points pour appliquer une rotation sur notre image arienne, pour cela
MATLAB nous offre une fonction cpselect, mais cette fonction est applicable que sur des
images RGB(couleur) seulement, donc on a besoin de transformer dabord l image en niveau
de gris.
Voici le code MATLAB correspondent:
load westconcordpoints % load some points that were already picked
cpselect(unregistered(:,:,1),'westconcordorthophoto.png',input_points,base_points)
tape 3: appliquer une transformation gomtrique sur limage initiale.
On peut modifier, si on a besoin, les points caractristiques de notre fonction transfert, pour
cela on modifie les valeurs des deux variables suivantes: input_points et base_points .
Remarque : cette tape est optionnelle.
La fonction cp2tform: appliqu une transformation ou une distorsion selon les coordonnes
des points motionnes dans les deux varibles input_points et base_points.
Voici le code MATLAB:
t_concord = cp2tform(input_points,base_points,'projective');
tape 4: Transformer limage rsultante de ltape 3
Puisque on a seulement utilis limage en niveau de gris, il nous manque de la rendre en RGB
pour le rsultat finale.
Voici le code MATLAB :
71

info = imfinfo('westconcordorthophoto.png');
registered = imtransform(unregistered,t_concord,...
'XData',[1 info.Width], 'YData',[1 info.Height]);
Etape 5 : afficher limage transforme,
Le rsultat finale est obtebnu en RGB(couleur)
Code Matlab :
imshow(registered)

Conclusion : on peut remarquer, quon a utilis MATAB (les fonctionnalits MATLAB),


pour appliquer une distorsion de limage arienne sans quon touche sa qualit.

72

Conclusion
Les concepts exposs ici sont plus que suffisants pour rsoudre la majorit des problmes.
Evidemment il faut ensuite apprendre aller chercher dans la documentation la fonction dont
on a besoin, et pratiquer rgulirement.
Le but de ce 2ime chapitre du support de cours tait de convaincre ltudiant en sciences &
techniques que MATLAB pouvait remplacer avantageusement les tableurs pour traiter des
problmes scientifiques. La syntaxe MATLAB est bien plus simple, pourvu que lon se donne
la peine dessayer.
Pour le lecteur souhaitant aller plus loin, on notera que MATLAB peut sinterfacer avec des
routines FORTRAN ou C externes, ou bien tre appel depuis un programme crit dans lun
de ces langages.
Par ailleurs, tout le graphique MATLAB est construit sous forme de structures de donnes,
assez faciles utiliser. Il est ainsi ais de construire ses propres menus, masques de saisie,
boutons et autres pour dvelopper des outils trs conviviaux.

73