Vous êtes sur la page 1sur 18

Algorithme Principes généraux

I. Qu'est-ce qu'un algorithme ?

Programmer, c'est quoi ?

Programmer, c'est définir précisément le problème à résoudre, décrire peu à peu une solution et après seulement l'exprimer dans un langage de programmation.

Notation algorithmique

) respectant

des règles syntaxiques et de présentation qui en facilitent la compréhension. Toutes ces règles définissent

la notation algorithmique.

Les actions ou opérations d'un algorithme sont décrites à l'aide de mots (verbes, locutions,

Complétons la définition d'un algorithme, en précisant que les actions d'un algorithme s'articulent à l'aide de structures de base. Les structures de base d'un algorithme sont :

· la structure séquentielle (ensemble d'opérations à la suite les unes des autres)

· la structure conditionnelle (ensemble d'opérations soumises à une condition)

· la structure répétitive (ensemble d'opérations répétées un nombre fini de fois)

Ces trois structures constituent les briques de base de tout algorithme et permettent de résoudre n'importe quel problème.

Convention syntaxique

Nous définirons les différentes instructions nécessaires. Voici un premier exemple de représentation d'un algorithme.

Exemple

algo somme const pi = 3.1416 var diamètre, circonférence : réels début

|

lire_clavier "Quel est le diamètre du cercle",diamètre

|

circonférence := Diamètre * Pi

|

écrire_écran "La circonférence est : ", circonférence

fin

Les mots-clefs, constitutifs de la syntaxe de l'algorithme et utilisés dans le logiciel Alg’Exec, sont indiqués en bleu gras.

Les lignes de l'algorithme sont indentées (avec une barre | <AltGr + 6>) afin d'en faciliter la lecture.

Liste des exemples d’algorithme.

   

N° des algorithmes

Déclarations

   
 

tableaux : 1 er indice = 0

04_1

 

tableaux : 1 er indice = 1

04_2

 

structure

06

Instructions

   
 

affectation

02, 03, 05

 

à_la_ligne

13_1

 

curseur

01, 04, 05

 

écrire_écran

01, 02, 03, 04, 05, 06

 

écrire_imprimante

16

 

efface_écran

01

 

lire_clavier

01, 03, 04, 05, 06, 07, 08, 09

 

pour…fin_pour

02, 04

 

répéter…jusqu’à

03

 

si…fin_si

03, 05, 06, 09

 

tant…fin_tant_que

05, 06

Fichiers

   
 

Organisation indexée

06_1, 06_3, 06_5,13

 

Organisation relative

06_2, 06_4, 10,14

 

Organisation

12

séquentielle

Fonctions

   
 

alea()

05

 

datesyst()

01

 

entier()

05

 

existe()

06

 

finfichier()

06

 

heuresyst()

02

 

ligne()

05

 

majuscule()

06_5

Procédures

 

09

Fonctions

 

11, 17, 18

programmées

SQL

 

15

II. Langage algorithmique (ALG'EXEC)

Toutes les options sont données à titre purement indicatif. Pour personnaliser les mots-clefs utilisés, il faudra modifier le fichier :

%systemdrive%\Program files\AlgExec\AlgExec.ini

Les mots-clefs (bleu gras) :

ne peuvent être choisis comme identificateurs

peuvent être écrits en minuscule ou majuscule

les caractères accentués ne sont pas pris en compte : début est équivalent à debut.

A) Structure général

algo nom_algo [structure nom_structure [nom_var : {type_standard|nom_structure1}]* fin_structure]* [const [globale[s]] [nom_const = valeur]* ]

[fichier

[var [globale[s]] [nom_var [,nom_var]* : {type_standard|nom_structure]* ]

cf. déclaration des fichiers

]*

début

instruction *

fin

B) Déclarations

a) un identificateur est un mot :

- commençant obligatoirement par une lettre

- ne comportant aucun espace

- composé des caractères suivants : a à z, ç, à, é, è, ê, ë, î, ï, ô, ö, ù, 0 à 9, _

b) nom_const et nom_var sont des identificateurs

c) valeur est une donnée littérale (cf. ci-dessous)

d) nom_structure est un type de donnée :

type

nom_type

caractères

ensemble

exemples

taille en

 

autorisés

de valeurs

de valeurs

octets

 

(fichiers)

booléen

bool

 

{.vrai., .faux.}

.vrai. ou 1

1

booléen

 

.faux. ou 0

chaîne

chaîne

tout caract.

 

"abcd"

60

chaîne(nbr_caract)

 

"67000"

nbr_caract

entier

ent

0

à 9, -, +

[-

-152

6

entier

 

32768 +32767]

+4560 ou

 

4560

réel

réel

0 à 9, -, +,

 

-12.3652

22

 

.

+0.186 ou

 

0.186

décimal

décimal(x,y)

0

à 9, -, +,

idem que le

x+y+2

x

: nbr chiffres

.

type réel, mais

avant .

cadré à droite

y

: nbr chiffres

à l'affichage

après .

 

caractère

car

tout caract.

 

"A"

1

caractère

 

"*"

remarque : utilisez le type décimal pour éviter des problèmes de conversion binaire (essayez la fonction décimale(-150.36) pour vous rendre compte du problème).

Par défaut, les constantes et variables déclarées sont locales. Pour déclarer les constantes ou/et les variables globales il suffit d'écrire par ex. : globales entiers

i,j,k :

e) déclaration de tableaux de variables :

1ère syntaxe nom_var{[t1[,t2[,t3]]] | [interv1[,interv2[,interv3]]] }: nom_type 2ème syntaxe nom_var : tableau[x]{[t1[,t2[,t3]]] | [interv1[,interv2[,interv3]]] } {de | d’} nom_type

t1,t2,t3 : désignent le nombre maximum d'éléments du tableau ; dans ce cas l'indice minimum est toujours égal à 1. interv1, interv2, interv3 désignent l'intervalle de définition de chaque indice ;

interv : vminimum

vmaximum

avec vminimum >= 0 et vmaximum > vminimum

Les valeurs des dimensions peuvent être des littéraux numériques entiers ou des constantes

déclarées précédemment.

f) déclaration de variables structurées :

structure nom_structure nom_var1 : nom_type nom_var2 : nom_type

fin_structure

g) déclaration des fichiers :

organisation séquentielle :

fichier nom_fichier {en | (} organisation séquentielle [fixe] [ ) ] {enregistrement | début_article} nom_enreg déclaration de l'enregistrement {finenregistrement | fin_enregistrement | fin_article} si le mot-clef fixe est omis, l'organisation sera en mode variable : les valeurs de chaque variable seront entre " " et séparées chacune par une virgule.

organisation relative :

fichier nom_fichier {en | (} organisation relative

accès {séquentiel | direct | séquentiel/direct }

{clef | clé} { = | : } nom_clef

[

) ]

{enregistrement | début_article} nom_enreg déclaration de l'enregistrement {finenregistrement | fin_enregistrement | fin_article} nom_clef est déclaré dans la partie VAR et doit être de type numérique (le numéro de l'enregistrement est la partie entière de la valeur de la clef : maximum 2147483647 attention à la place disponible sur le disque !!!) nom_clef doit être déclaré GLOBALE

organisation indexée :

fichier nom_fichier {en | (} organisation indexée accès {séquentiel | direct | séquentiel/direct }

{clef | clé} [{clef | clé}

{

| primaire}

{ = | : } nom_clef1

secondaire

{ = | : } nom_clef2]

[ )

]

{enregistrement | début_article} nom_enreg déclaration de l'enregistrement {finenregistrement | fin_enregistrement | fin_article} nom_clef1 et nom_clef2 sont des données de type chaîne ou des structures de données déclarées dans l'enregistrement du fichier.

organisation binaire :

fichier nom_fichier {en | (} organisation binaire [ ) ] il n'y a pas de déclaration d'enregistrement

remarques préalables :

- expr désigne une variable déclarée, une constante déclarée ou une formule mathématique

- expr_logique désigne une expression logique (résultat de type booléen)

- littéral désigne une chaîne de caractère placée entre " " - une ligne de programme a une longueur maximum de 73 caractères ; lorsqu'une instruction dépasse cette longueur, il faudra appliquer les règles de césure (saut de ligne) indiquées à chaque instruction (aucune indication signifie que l'instruction doit être écrite en 1 ligne). Pour une expression logique ou mathématique, le saut de ligne doit être placé après une '(' ou après un opérateur binaire (pas après + - non).

C) les instructions

Toute instruction doit être suivie d'un espace au minimum ou de la touche <Entrée>

1° entrées/sorties

a) entrée au clavier lire_clavier [littéral,] nom_var

littéral est affiché avant la saisie à la position courante du curseur

b) sortie à l'écran

écrire_écran [{expr | littéral}] [,{expr | littéral}]*

[&]

- afficher seul réalise un saut de ligne

- la césure doit se faire après la virgule

- implicitement, après l'affichage, le curseur se déplacera au début de la ligne suivante; le caractère & annule ce déplacement

- l'affichage des nombres décimaux (point décimal) se fera en concordance avec le panneau de configuration de nombres (International).

c) sortie à l'écran à_la_ligne

- réalise un saut de ligne

d) impression (en différé) : après exécution de l'algo. sélectionner Exécution Imprimer l'état pour

éditer l'état obtenu.

écrire_imprimante [{expr | littéral}] [,{expr | littéral}]*

[&]

- voir les commentaires de l'instruction afficher version 1

- largeur maximum des lignes d'impression :

79

caractères pour une taille en points de 12

120

caractères pour une taille en points de 8 (au-delà la ligne est tronquée à

120 car.) la taille en points étant automatiquement ajustée en fonction de la longueur des

lignes

e) déplacement du curseur à l'écran

curseur {expr | littéral}] ,{expr | littéral}

- la première expression indique le numéro de ligne (1 à 24)

- la deuxième le numéro de colonne (1 à 80) f) effaçage de l'écran efface_écran

2° affectation et calcul

nom_var {:= | <- | flèche d'affectation} {expr | littéral} opérateurs (dans l'ordre de leur priorité) :

 
     

Type

Type

 

Opérateurs

Commentaires

d'opérandes

du résultat

+

et -

unaire

entier, réel, décimal

de l'opérande

non

 

unaire

booléen

booléen

^

exponentielle

entier, réel, décimal

entier, réel, décimal

*

multiplication

entier, réel, décimal

entier, réel, décimal

/

division

entier, réel, décimal

entier, réel, décimal

div

 

division entière

entier, réel, décimal

entier

mod

 

reste d'une division

entier, réel, décimal

entier

+ ou &

 

concaténation

chaîne ou caractère

chaîne

+

et

-

binaire

entier, réel, décimal

entier, réel, décimal

<

<=

>

>=

 

tout type

 

=

<>

et

 

booléen

booléen

ou

   

booléen

booléen

oux

   

booléen

booléen

3° structures conditionnelles

a) alternative simple si expr_logique alors

[sinon]

{finsi |

fsi

|

fin_si}

b) à choix multiples selon expr.

cas

littéral :

cas_sinon :

{finselon | fselon | fin_selon}

ou

suivant expr.

cas

littéral :

cas sinon

:

{finsuivant | fsuivant | fin_suivant}

4° structures répétitives et itératives

a) répétitives

tant_que expr

logique

{fintantque | ftantque | fin_tant_que | ftq}

répéter

{jusqu’à | jqà } expr_logique

b) itératives

itérer

sortir_si expr_logique {finitérer | fitérer | fin_itérer}

pour nom_var op_affect1 {expr | valeur} op_fin {expr | valeur} [PAS op_affect2 {expr | valeur}] {finpour | fpour | fin_pour}

- op_affect1 : {:= | <- | flèche d'affectation | DE | DEPUIS }

- op_fin

- op_affect2 : {pas d'opérateur | := | <- | flèche d'affectation }

- césure après chaque opérateur

- nom_var doit être de type numérique (entier ou réel)

: {A | JUSQU'A | JQA}

5° fichiers

a) ouverture ouvrir nom_fichier {en | (} {lecture | écriture | lecture/écriture | extension} [)] le mode d'ouverture est implicite (lecture/écriture) pour les fichiers en organisation binaire.

b) fermeture fermer nom_fichier1[,nom_fichier2]*

c) lecture organisation séquentielle

organisation indexée ou relative

: lire nom-enreg :

accès direct

: lire nom_enreg avec clef [{:= | flèche d'affectation} nom_clef]

accès séquentiel

: lire nom_enreg suivant

organisation binaire : lire nom_fichier , [nom_var1] , nom_var2

nom_fichier

: nom du fichier binaire déclaré

nom_var1

: position du premier octet de nom_var2 lu dans le fichier

nom_var2

cette position est définie par rapport au début du fichier si la variable nom_var1 est omise : lecture séquentielle : lecture du nombre d'octets égal à la longueur de la variable

entier

: 2 octets

réel

: 4 octets

chaîne

: 60 octets

chaîne(n)

: n octets

décimal(e,d) : e + d + 2 octets (signe et point décimal)

booléen

: 2 octets

d) écriture écrire nom_enreg organisation binaire : écrire nom_fichier , [nom_var1] , nom_var2

e) réécriture (organisation indexée et relative uniquement) réécrire nom_enreg

f) supprimer (organisation indexée et relative uniquement) supprimer nom_enreg

g) positionnement (organisation indexée et relative uniquement)

positionner nom_enreg avec clef

[{ <

| <=

| =

| >= | >

}

nom_clef]

h) positionnement du pointeur de fichier (organisation binaire) positionner nom_fichier , nom_var1

i) les fonctions d'erreur sont les suivantes :

finfichier(nom_fichier)

erreur(nom_fichier)

: retourne la valeur .vrai. en cas de fin de fichier : retourne la valeur .vrai. en cas d'erreur (lecture, écriture,

suppression)

erreur_clef(nom_fichier)

: retourne la valeur .vrai. en cas d'erreur (lecture, écriture,

suppression)

trouvé(nom_enreg)

existe(nom_enreg)

: retourne la valeur .vrai. en cas de lecture directe réussie : retourne la valeur .vrai. en cas de lecture directe réussie

6° Procédure

a) déclaration d'une procédure

version 1 procédure nom_procédure([{donnée|résultat|donnée modifiée}:nom_var[,nom_var]*:nom_type

]*)

version 2 procédure nom_procédure([{e|s|es} nom_var[,nom_var]*:nom_type ;]*)

donnée ou e ou valeur ou par_valeur résultat ou s donnée modifiée ou es ou adresse ou par_adresse

b) appel d'une procédure

: paramètres en entrée : paramètres en sortie : paramètres en entrée/sortie

sans paramètre

: nom_procédure()

avec paramètre(s)

: nom_procédure(param_réel1[,param_réel2]*)

7° Fonction (récursive)

a) déclaration d'une fonction

version 1 fonction nom_procédure([{donnée}:nom_var[,nom_var]*:nom_type ]*) : type_fonction version 2 fonction nom_procédure([{e} nom_var[,nom_var]*:nom_type ;]*) : type_fonction

donnée ou e ou valeur type_fonction

: paramètres en entrée : type de la fonction (entier, réel,

)

b) appel d'une fonction

une fonction est appelée dans toute expression, sauf si elle est récursive (dans ce cas seule

l'instruction d'affectation est autorisée)

c) retour d'appel

version 1 : valeur_retour {:= | <- | flèche d'affectation} expression version 2 : délivre(expression) version 3 : nom_fonction {:= | <- | flèche d'affectation} expression

remarque : dans le cas d'une fonction récursive, expresssion doit être une variable uniquement.

Césure dans la déclaration d'une procédure (ou d'une fonction) :

césure possible après la déclaration de type d' un ou de plusieurs paramètres. exemples :

version 1 : PROCEDURE EXEMPLE (données : a,b : réels résultats : x,y,z : réels) version 2 : PROCEDURE EXEMPLE (e a,b : réels ; s x,y,z : réels)

8° Instructions de service

copie chemin du fichier à copier [fincopie]

a) le chemin du fichier à copier doit être complet (ex. c:\alg'exec\procedu1.alg)

b) la ligne FINCOPIE est facultative

9° SQL Alg’Exec peut accéder :

aux bases de données MS Access ouverture d'une base de données MS Access exec_sql START DATABASE nom_de_la_base fin_exec

le nom de la base peut être :

- soit un littéral de type chaîne

- soit une variable de type chaîne (le nom de la variable hôte sera précédé d'un : ).

aux bases ODBC après avoir créé une source de données ODBC exec_sql START DATABASE ("ODBC;DSN=nom_source;UID=nom_utilisateur;PWD=mot_de_passe") fin_exec ou encore exec_sql START DATABASE (:var_hôte) fin_exec

var_hôte étant de type chaîne et contenant la valeur de la chaîne de connection Odbc.

b)

fermeture de la base de données active exec_sql STOP DATABASE fin_exec

b)

instructions SQL exec_sql instruction SQL fin_exec

Les instructions SQL admises sont les suivantes :

- instructions SANS curseurs

DELETE FROM

WHERE

INSERT INTO

VALUES (valeur1, valeur2,

)

SELECT

FROM

WHERE

GROUP BY

HAVING

ORDER BY

UPDATE

SET

- instructions AVEC curseurs DECLARE nom_curseur CURSOR FOR SELECT OPEN nom_curseur FETCH nom_curseur INTO :var_hôte_1, :var_hôte_2, CLOSE nom_curseur

CONSTANTE.

Les constantes sont déclarées TOUT au début de l'algorithme après le mot_clef CONST.

exemple :

ALGO exemple

CONST

a = 10

b = "ABCDEF"

c = 18.6

Choix multiples : selon

cas

selon expression cas littéral1 :

suite d'actions 1

fin_selon

cas littéral2 :

suite d'actions 2

[ cas sinon suite d'actions 3

fin_selon

]

Selon la valeur de l'expression, la suite d'actions 1 est réalisée si l'expression est égale à littéral1 la suite d'actions 2 est réalisée si l'expression est égale à littéral2 la suite d'actions 3 est réalisée si l'expression est différente de littéral1 ou de littéral2. Après l'exécution des suites d'action, l'algorithme continue après l'instruction fin_selon .

Exemple :

selon code_catégorie cas 1 : taux_réduction := 0.10 cas 2 : taux_réduction := 0.15 cas 3 : taux_réduction := 0.22 fin_selon Déclaration des variables.

Les variables sont déclarées au début de l'algorithme après le mot-clef var. L'identificateur d'une variable est un mot de 20 caractères maximum ; ce mot ne doit pas comporter d'espace et doit commencer par une lettre.

Une variable est d'un type donné ; voici la liste des types :

Types de variables alpha-numériques :

- : valeur de 1 caractère de longueur

car

- : valeur de longueur variable (de 0 à 60 car. maxi.)

chaîne

- : valeur de longueur fixe (n caractères)

chaîne(n)

Types de variables numériques :

- entier : valeur numérique entière comprise entre -32768 et +32767

- réel

: valeur numérique

Type de variables boolénnes :

- booléen :

ou

valeur {.FAUX.|.VRAI.} valeur {0 | 1}

Exemple de déclaration :

algo exemple

var

a,b,c : entiers

d : chaîne(20)

e : réel

f : booléen

Par défaut les variables sont déclarées locales.

Toutefois si vous désirez les déclarer globales, il suffit d'ajouter devant la déclaration de chaque ligne de variables le mot réservé

globale

Exemple :

var

ou globales

nom,prénom : chaîne(20) globales i,j,k : entiers rue : chaîne

nom, prénom et rue sont des variables locales, c'est-à-dire des variables uniquement "visibles" dans la procédure ou fonction dans laquelle elles sont déclarées. i,j,k sont des variables globales, c'est-à-dire des variables "visibles" dans toutes les procédures ou fonctions.

EXPRESSION.

Une expression désigne :

- une variable affectée ou une constante - une combinaison de variables affectées ou de constantes avec des opérateurs

Liste des opérateurs dans l'ordre de leur priorité :

+

-

: unaire

NON

^ **

: exponentielle

*

: multiplication

/

: division

DIV

: division entière

MOD

: reste d'une division entière

+

-

: binaire

&

: opérateur de concaténation de chaînes de caractères

<

<=

=

>

>=

<>

ET

 

OU

FICHIERS. Il existe 4 organisations (séquentielle, relative, indexée et binaire).

Organisation séquentielle fixe :

FICHIER nom_fichier {en|(} organisation séquentielle fixe [)] {ENREGISTREMENT nom_enreg déclaration de l'enregistrement {FINENREGISTREMENT}

Organisation séquentielle variable :

FICHIER nom_fichier {en|(} organisation séquentielle [)] {ENREGISTREMENT nom_enreg déclaration de l'enregistrement {FINENREGISTREMENT} chaque valeur est entre " " et séparée par une virgule

Organisation relative :

FICHIER nom_fichier {en|(} organisation relative accès {séquentiel|direct|séquentiel/direct} {clé|clef} {=|:} nom_clef [)] {ENREGISTREMENT nom_enreg déclaration de l'enregistrement {FINENREGISTREMENT} nom_clef est déclaré dans la partie VAR et doit être de type numérique (maximum 2147483647 : attention à la place disponible sur disque !!!).

FICHIERS (suite)

Organisation indexée :

FICHIER nom_fichier {en|(} organisation indexée accès {séquentiel|direct|séquentiel/direct} {clé|clef} [primaire] {=|:} nom_clef1

[{clé|clef} secondaire {=|:} nom_clef2]* [)] {ENREGISTREMENT nom_enreg déclaration de l'enregistrement {FINENREGISTREMENT}

nom_clef1, nom_clef2,

structures de variables déclarées dans l'enregistrement.

sont des variables de type chaîne ou des

Organisation binaire :

FICHIER nom_fichier {en|(} organisation binaire [)] il n'y a pas de déclaration d'enregistrement;

FONCTIONS PROGRAMMÉES.

a) Déclaration d'une fonction (à la fin de l'algorithme principal) :

fonction nom_fonction ([donnée : nom_var[,nom_var]* : type]*) :

ou fonction nom_fonction ([e nom_var[,nom_var]* : type]*) :

donnée ou e ou par_valeur

type_fonction

: paramètres en entrée

)

: type de la fonction (entier, réel,

b) Appel d'une fonction :

type_fonction

type_fonction

Une fonction est appelée dans les instructions d'affectation, si, tant_que et jusqu'à , sauf si elle est récursive (dans ce cas seule l'instruction d'affectation est autorisée).

c) Retour d'appel :

valret {:=|flèche d'affectation} expression ATTENTION : il faut un ESPACE après valret

ou délivre(expression) remarque : dans le cas d'une fonction récursive, expression doit être une variable uniquement.

ou nom_fonction {:=|flèche d'affectation} expression

INSTRUCTIONS SQL.

Une instruction SQL commence par la ligne : EXEC SQL et se termine par la ligne : FIN SQL

Les bases de données doivent être au format Access version 2.0 au maximum.

Les instructions SQL acceptées sont les suivantes :

START DATABASE <nom base de données> STOP DATABASE

Instructions sans curseur :

SELECT

WHERE

FROM

GROUP BY

HAVING

ORDER BY

DELETE FROM

WHERE

INSERT INTO

VALUES (valeur1, valeur2,

)

UPDATE

SET

Instructions avec curseur :

DECLARE nom_curseur CURSOR FOR SELECT OPEN nom_curseur CLOSE nom_curseur FETCH nom_curseur INTO :variablehôte1,:variablehôte2,

PROCÉDURES.

a) Déclaration d'une procédure (à la fin de l'algorithme principal) :

Version 1 :

procédure nom_proc([{donnée|résultat|donnée modifiée} :

nom_var,[nom_var]* : type]*) Version 2 :

procédure nom_proc([{e|s|es} nom_var,[nom_var]* : type ; ]*) Version 3 :

procédure nom_proc([{par_valeur|par_adresse} nom_var,[nom_var]* : type ; ]*)

donnée ou e ou par_valeur résultat ou s donnée modifiée ou es ou par_adresse

: paramètres en entrée : paramètres en sortie : paramètres en entrée/sortie

b) Appel d'une procédure :

sans paramètres

avec paramètre(s) : nom_procédure(param_réel1[,param_réel2]*)

: nom_procédure()

Exemple :

proc1(a,b,c)

procédure proc1(e x,y : entiers ; es z : réel) var

d

: entier

début

lire_clavier a

fin

z := z * x * y

/ d

Structure d'un algorithme :

les mots obligatoires sont en caractères majuscules les mots entre crochets sont facultatifs ALGO nom_de_l'algo

[STRUCTURE]

déclaration de types de données

[CONST]

déclaration des constantes

[FICHIER]

déclaration des fichiers

[VAR]

déclaration des variables

DEBUT

lignes de l'algorithme principal

FIN

[PROCEDURE]

déclaration des procédures

[FONCTION]

déclaration des fonctions programmées

Les procédures et/ou les fonctions peuvent être également déclarées en début d'algorithme.

Structure alternative.

si expression_logique alors

suite d'actions 1

sinon

suite d'actions 2

fin_si

cette

partie

est

facultative (structure SI

ALORS

FINSI)

Si le résultat de l'expression logique est VRAI, la suite d'actions 1 est réalisée et l'algorithme continue son déroulement aprèes l'instruction FIN_SI.

Si le résultat de l'expression logique est FAUX, la suite d'actions 2 est réalisée.

Exemple :

si code_tva = "A" alors tva := montant_ht * 0.055 sinon tva := montant_ht * 0.206 fin_si

Structure itérative : pour

fin_pour

pour identificateur := valeur_initiale à valeur_finale [pas := valeur]

suite d'actions

fin_pour

Cette structure permet de répéter une suite d'actions un nombre de fois CONNU. L'identificateur est de type numérique (entier ou réel). La valeur initiale et la valeur finale sont des expressions numériques de type entier ou réel. L'incrément (pas) est la valeur d'augmentation (ou de diminution) progressive de l'identificateur. La valeur par défaut est de 1.

La boucle est réalisée jusqu'à ce que la valeur finale soit dépassée.

Exemple :

pour

i := 1 à

12

écrire_écran nom_mois[i]

fin_pour

Structure répétitive : ITER

SORTIRSI

FINITER

Cette structure permet la répétition des lignes comprises entre Iter et Finiter.

La sortie de cette structure est réalisée dans l'instruction SORTIRSI expr_logique lorsque l'expression logique est VRAIE.

Structure répétitive : Répéter

répéter

suite d'actions

jusqu’à

jusqu’à expression_logique

La suite d'actions est réalisée jusqu'à ce que le résultat de l'expression logique soit VRAIE ; lorsque le résultat est VRAI, l'algorithme continue après l'instruction jusqu’à.

Le résultat de l'expression logique VRAI permet donc l'arrêt de la répétition de l'exécution de la suite d'actions.

Dans cette structure, la suite d'actions est réalisée de 1 à n fois

(à ce propos voir la structure répétitive Tant_que

fin_tant_que)

Exemple :

répéter

….

lire_clavier "code catégorie (1, 2 ou 3) ? ",code_catégorie jusqu’à code_catégorie >= 1 et code_catégorie <= 3

Structure répétitive : TANT QUE

tant_que expression_logique

suite d'actions

fin_tant_que

Tant que le résultat de l'expression logique est VRAI, la suite d'actions est réalisée ; lorsque le résultat est FAUX, l'algorithme continue après l'instruction fin_tant_que.

Dans cette structure, la suite d'actions est réalisée de 0 à n fois

(à ce propos voir la structure répétitive Répéter

Jusqu'à)

Exemple :

lire_clavier "Nom du client ou FIN ? ",cli_nom tant_que majuscule(cli_nom) <> "FIN" lire_clavier cli_rue

lire_clavier "Nom du client ou FIN ? ",cli_nom fin_tant_que

TABLEAUX

Un tableau est une structure de donnée linéaire qui permet de stocker des données de même type. Chacune des valeurs est repérée par un indice indiquant la position de la donnée dans le tableau.

Format 1 :

<nom_du_tableau>[indice1,indice2,indice3] : tableau de <type>

Format 2 :

<nom_du_tableau> : tableau[indice1,indice2,indice3] de <type>

On peut définir pour chaque indice, l'indice minimum et l'indice maximum :

<indice_minimum:indice_maximum>

Exemple 1 :

t1[5,6],t2[10]

: tableaux de réels

t[0:20]

: tableau de chaîne(10)

Exemple 2 :

var t[100] : tableau d'entiers début charge_tableau(t) affiche_tableau(t)

fin procédure charge_tableau(t[]:tableau d'entiers) var i : entier début pour i:=1 à 100 t[i] := i * 100 fin_pour

fin procédure affiche_tableau(t[]:tableau d'entiers) var i : entier début pour i := 1 à 100 écrire_écran t[i] fin_pour fin

III. Fonctions standard

Tableau des fonctions

   

Résultat

p1

p2

p3

code

algexec.ini

abs(p1)

valeur absolue de

entier,

entier, réel

   

505

p1

réel

alea()

nombre aléatoire

réel

     

515

compris entre 0 et

1

ansi(p1)

code ansi du premier caractère. de p1

entier

car, chaîne

   

503

arrondi(p1)

partie entière de p1 avec arrondi commercial

entier,

entier, réel

   

520

réel

atn(p1)

arc tangente de p1

entier,

entier, réel

   

516

réel

car(p1)

caractère ayant pour code ansi la valeur de p1

car,

entier

   

509

chaîne

chnombre(p1)

convertit p1 en nombre

entier,réel

chaîne

   

502

colonne()

position courante du curseur (N° de la colonne)

entier

     

523

cos(p1)

cosinus de p1

entier,

entier, réel

   

517

réel

cvchaîne(p1)

convertit p1 en chaîne

chaîne

entier, réel

   

508

datesyst()

date système au format jj/mm/aaaa

chaîne

     

513

décimale(p1)

partie décimale de

réel

réel

   

507

p1

droite(p1,p2)

partie droite de p1 ; p2 = nombre de caractères retournés

chaîne

chaîne

entier

 

511

ent(p1)

partie entière de p1 sans arrondi

entier,

réel

   

506

réel

erreur(p1)

résultat d’une lecture, écriture, … (fichier)

booléen

nom du fichier

   

529

erreur_sql()

résultat d’une

booléen

     

539

instruction SQL

espace(p1)

retourne un nombre d’espaces égal à p1

chaîne

entier

   

533

espacedroite(p1)

supprime les espaces à droite de

chaîne

chaîne

   

537

p1

espacegauche(p1)

supprime les espaces à gauche de p1

chaîne

chaîne

   

538

existe(p1)

résultat d’une

booléen

nom de

   

530

lecture (fichier)

l’enregistrement

exp(p1)

exponentielle de

entier,

entier, réel

   

519

p1

réel

ff(p1)

résultat d’une

booléen

nom du fichier

   

531

lecture (fichier)

gauche(p1,p2)

partie gauche de p1 ;p2 = nombre de caractères retournés

chaîne

chaîne

entier

 

510

heuresyst()

heure système au format hh:mm:ss

chaîne

     

514

hex(p1)

valeur

chaîne

entier

   

521

hexadécimale de

p1

ligne()

position courante du curseur (N° de la ligne)

entier

     

535

long(p1)

longueur de p1

entier

chaîne

   

501

maj(p1)

caractères de p1 en majuscule

chaîne

chaîne

   

527

milieu(p1,p2,p3)

sous-chaîne de p1 de p3 caractères à partir de la position p2 incluse

chaîne

entier

entier

 

512

min(p1)

caractères de p1 en minuscule

chaîne

chaîne

   

528

rac2(p1)

racine carrée de p1

entier,

entier, réel

   

524

réel

rang(p1,p2,p3)

position du 1 er car. de p2 dans p1 ; p3 est la position de départ

entier

chaîne

chaîne

entier

504

répètecar(p1,p2)

chaîne constituée de la répétition de p1 caractères (p2=code ansi du car.)

chaîne

entier

   

534

sin(p1)

sinus de p1

entier,

entier, réel

   

518

réel

suppr(p1,p2,p3)

supprime de p1 une sous-chaîne de longueur p3 à partir de p2 inclus

chaîne

chaîne

entier

entier

532

tab(p1)

déplace le curseur à la colonne p1

 

entier

   

525

tan(p1)

tangente de p1

entier,

entier, réel

   

526

réel

uncar()

lit un caractère au clavier

car,

     

536

chaîne

unetouche()

lit un caractère au clavier

car,

     

522

chaîne