Programmation Delphi : Algorithmes obligatoires

Programmation Delphi : Algorithmes obligatoires
Ire B, 2014–15
Version 4.2 du 21 juillet 2014
Table des matières
1 Mathématiques élémentaires
1.1 Fonction « puissance à exposant naturel » . . . .
1.1.1 Version itérative . . . . . . . . . . . . . .
1.1.2 Version récursive . . . . . . . . . . . . . .
1.2 Fonction « puissance rapide à exposant naturel »
1.3 Fonction « factorielle » . . . . . . . . . . . . . . .
1.3.1 Version itérative . . . . . . . . . . . . . .
1.3.2 Version récursive . . . . . . . . . . . . . .
1.4 Fonction « pgcd » . . . . . . . . . . . . . . . . . .
1.4.1 Algorithme d’Euclide par soustraction . .
1.4.2 Algorithme d’Euclide par division . . . .
1.5 Nombre premier ? . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
2
2
2
2
2
3
3
3
3
3
4
4
2 Fréquence, minimum et maximum
2.1 Fréquence d’un élément dans une liste . . . . . . . . . . . . . . . . . . . . . . . .
2.2 Minimum d’une liste d’entiers non vide . . . . . . . . . . . . . . . . . . . . . . . .
2.3 Maximum d’une liste d’entiers non vide . . . . . . . . . . . . . . . . . . . . . . .
5
5
5
5
3 Algorithmes de tri
3.1 Tri par sélection . . . . . . . . . . . .
3.1.1 Version itérative . . . . . . . .
3.1.2 Version récursive . . . . . . . .
3.2 Tri par insertion . . . . . . . . . . . .
3.2.1 Version itérative . . . . . . . .
3.2.2 Version récursive . . . . . . . .
3.3 Tri rapide (Quicksort) . . . . . . . . .
3.3.1 Version récursive . . . . . . . .
3.3.2 Fonction auxiliaire « division »
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
6
6
6
6
7
7
7
8
8
9
4 Algorithme de recherche
4.1 Recherche séquentielle .
4.2 Recherche dichotomique
4.2.1 Version itérative
4.2.2 Version récursive
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
10
10
11
11
11
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
5 Graphiques
12
5.1 Affichage de fonctions simples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
5.2 Affichage de polynômes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
5.3 [Affichage d’une aire et calcul d’une intégrale numérique] . . . . . . . . . . . . . . 14
Algorithmes Delphi
1
Version 4.2 du 21 juillet 2014
Mathématiques élémentaires
1.1
1.1.1
Fonction « puissance à exposant naturel »
Version itérative
La fonction suivante calcule be pour un exposant e naturel. Le cas particulier b = e = 0 n’est
pas traité correctement.
1
2
3
4
5
6
7
8
9
function puissance ( base : extended ; expo : integer ) : extended ;
var i : integer ;
p : extended ;
begin
p :=1;
for i:=1 to expo do
p:=p∗ base ;
puissance :=p
end ;
1.1.2
Version récursive
La fonction suivante calcule be pour un exposant e naturel. Le cas particulier b = e = 0 n’est
pas traité correctement.
1
2
3
4
5
6
7
function puissance ( base : extended ; expo : integer ) : extended ;
begin
i f expo=0 then
puissance :=1
else
puissance := base ∗ puissance ( base , expo −1)
end ;
1.2
1
2
3
4
5
6
7
8
9
Fonction « puissance rapide à exposant naturel »
function puissRapid ( base : extended ; expo : integer ) : extended ;
begin
i f expo=0 then
puissRapid :=1
e l s e i f expo mod 2 = 0 then
puissRapid := puissRapid ( base ∗ base , expo div 2 )
else
puissRapid := base ∗ puissRapid ( base , expo −1)
end ;
2
Algorithmes Delphi
1.3
Version 4.2 du 21 juillet 2014
Fonction « factorielle »
Les fonctions suivantes calculent n! pour n naturel.
1.3.1
1
2
3
4
5
6
7
8
9
function factorielle ( n : integer ) : integer ;
var i : integer ;
fact : integer ;
begin
fact : = 1 ;
for i:=2 to n do
fact := fact ∗i ;
factorielle := fact
end ;
1.3.2
1
2
3
4
5
6
7
Version itérative
Version récursive
function factorielle ( n : integer ) : integer ;
begin
i f n<2 then
factorielle :=1
else
factorielle :=n∗ factorielle ( n −1)
end ;
1.4
Fonction « pgcd »
Les fonctions suivantes déterminent le pgcd de deux nombres naturels non nuls.
1.4.1
Algorithme d’Euclide par soustraction
C’est sous cette forme, transcrite en langage de programmation moderne, qu’Euclide a présenté
l’algorithme dans le livre 7 des Éléments (vers 300 av. J.-C.).
1
2
3
4
5
6
7
8
9
function euclideDiff ( a , b : integer ) : integer ;
begin
while a<>b do
i f a>b then
a:=a−b
else
b:=b−a ;
euclideDiff :=a
end ;
3
Algorithmes Delphi
1.4.2
1
2
3
4
5
6
7
8
9
10
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Algorithme d’Euclide par division
function euclideDivi ( a , b : integer ) : integer ;
var c : integer ;
begin
while b>0 do begin
c:=a mod b ;
a:=b ;
b:=c
end ;
euclideDivi :=a
end ;
1.5
1
Version 4.2 du 21 juillet 2014
Nombre premier ?
function primTest ( n : integer ) : boolean ;
var i , lim : integer ;
prim : boolean ;
begin
i f n<2 then
prim := false
e l s e i f n=2 then
prim := true
e l s e i f n mod 2 = 0 then
prim := false
e l s e begin
i :=3;
prim := true ;
lim := round ( s q r t ( n ) ) ;
while ( i<=lim ) and prim do
i f n mod i = 0 then prim := false
e l s e i:=i+2
end ;
primTest := prim
end ;
4
Algorithmes Delphi
2
2.1
1
2
3
4
5
6
7
8
9
1
3
4
5
6
7
8
9
1
3
4
5
6
7
8
9
Fréquence d’un élément dans une liste
Minimum d’une liste d’entiers non vide
function minimum ( liste : TListBox ) : integer ;
var i , mini : integer ;
begin
mini := S t r T o I n t ( liste . Items [ 0 ] ) ;
for i:=1 to liste . Items . Count −1 do
i f S t r T o I n t ( liste . Items [ i ]) < mini then
mini := S t r T o I n t ( liste . Items [ i ] ) ;
minimum := mini
end ;
2.3
2
Fréquence, minimum et maximum
function frequence ( liste : TListBox ; cle : string ) : integer ;
var i , freq : integer ;
begin
freq : = 0 ;
for i:=0 to liste . Items . Count −1 do
i f liste . Items [ i]= cle then
freq := freq +1;
frequence := freq
end ;
2.2
2
Version 4.2 du 21 juillet 2014
Maximum d’une liste d’entiers non vide
function maximum ( liste : TListBox ) : integer ;
var i , maxi : integer ;
begin
maxi := S t r T o I n t ( liste . Items [ 0 ] ) ;
for i:=1 to liste . Items . Count −1 do
i f S t r T o I n t ( liste . Items [ i ]) > maxi then
maxi := S t r T o I n t ( liste . Items [ i ] ) ;
maximum := maxi
end ;
5
Algorithmes Delphi
3
Version 4.2 du 21 juillet 2014
Algorithmes de tri
Les algorithmes de cette section réalisent un tri lexicographique. La procédure echange réalise
l’échange de deux éléments d’une liste.
1
2
3
4
5
6
7
procedure echange ( var liste : TListBox ; i , j : integer ) ;
var aux : string ;
begin
aux := liste . Items [ i ] ;
liste . Items [ i ] : = liste . Items [ j ] ;
liste . Items [ j ] : = aux
end ;
3.1
3.1.1
1
2
3
4
5
6
7
8
9
10
11
Tri par sélection
Version itérative
procedure triSelectionI ( var liste : TListBox ) ;
var i , j , min : integer ;
begin
for i:=0 to liste . Items . Count −2 do begin
min :=i ;
for j:=i+1 to liste . Items . Count −1 do
i f liste . Items [ j]<liste . Items [ min ] then
min :=j ;
echange ( liste , i , min )
end
end ;
L’algorithme devient légèrement plus rapide lorsqu’on effectue l’échange uniquement pour des
indices différents. Pour cela, on remplace la ligne 9 par
if i<>min then echange(liste,i,min)
3.1.2
1
2
3
4
5
6
7
8
9
10
11
Version récursive
procedure triSelectionR ( var liste : TListBox ; debut : integer ) ;
var j , min : integer ;
begin
min := debut ;
for j:= debut+1 to liste . Items . Count −1 do
i f liste . Items [ j]<liste . Items [ min ] then
min :=j ;
echange ( liste , debut , min ) ;
i f debut<liste . Items . Count −2 then
triSelectionR ( liste , debut+1)
end ;
Appel de la procédure : triSelectionR(liste, 0);
6
Algorithmes Delphi
3.2
3.2.1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Tri par insertion
Version itérative
procedure triInsertionI ( var liste : TListBox ) ;
var i , j : integer ;
candidat : string ;
termine : boolean ;
begin
for i:=1 to liste . Items . Count −1 do begin
candidat := liste . Items [ i ] ;
j:=i ;
termine := false ;
while ( not termine ) and ( j>0) do
i f liste . Items [ j − 1] > candidat then begin
liste . Items [ j ] : = liste . Items [ j − 1];
j:=j−1
end
e l s e termine := true ;
i f j<i then
liste . Items [ j ] : = candidat
end
end ;
3.2.2
1
Version 4.2 du 21 juillet 2014
Version récursive
procedure triInsertionR ( var liste : TListBox ; fin : integer ) ;
var j : integer ;
candidat : string ;
termine : boolean ;
begin
i f fin>0 then begin
triInsertionR ( liste , fin − 1);
candidat := liste . Items [ fin ] ;
j:= fin ;
termine := false ;
while ( not termine ) and ( j>0) do
i f liste . Items [ j − 1] > candidat then begin
liste . Items [ j ] : = liste . Items [ j − 1];
j:=j−1
end
e l s e termine := true ;
i f j<fin then
liste . Items [ j ] : = candidat
end
end ;
Appel de la procédure : triInsertionR(liste, liste.Items.Count−1);
7
Algorithmes Delphi
Version 4.2 du 21 juillet 2014
Dans l’algorithme précédent, l’appel récursif a lieu au début (ligne 7) du bloc d’instructions,
avant les manipulations de la liste. Cela diffère de l’algorithme 3.1.2, où l’appel récursif a lieu
à la fin du bloc d’instructions. On peut évidemment aussi implémenter le tri par insertion avec
un appel récursif à la fin du bloc, comme l’illustre le code alternatif suivant :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
procedure triInsertionR ( var liste : TListBox ; indiceCandidat : integer ) ;
var j : integer ;
candidat : string ;
termine : boolean ;
begin
i f indiceCandidat<liste . Items . Count then begin
candidat := liste . Items [ indiceCandidat ] ;
j:= indiceCandidat ;
termine := false ;
while ( not termine ) and ( j>0) do
i f liste . Items [ j − 1] > candidat then begin
liste . Items [ j ] : = liste . Items [ j − 1];
j:=j−1
end
e l s e termine := true ;
i f j<indiceCandidat then
liste . Items [ j ] : = candidat ;
triInsertionR ( liste , indiceCandidat +1)
end
end ;
Appel de la procédure : triInsertionR(liste, 1);
Comme la première tentative d’insertion consiste à insérer éventuellement le deuxième élément
de la liste devant le premier, l’algorithme reçoit comme deuxième argument la valeur 1, c’està-dire l’indice du deuxième élément. (Grâce au test j > 0 de la ligne 10, l’algorithme
fonctionnerait même si l’on passe comme deuxième argument la valeur 0, mais il effectuerait
alors quelques instructions superflues.)
3.3
3.3.1
1
2
3
4
5
6
7
8
9
Tri rapide (Quicksort)
Version récursive
procedure triRapide ( var liste : TListBox ; g , d : integer ) ;
var i : integer ;
begin
i f g<d then begin
i:= division ( liste , g , d ) ;
triRapide ( liste , g , i − 1);
triRapide ( liste , i+1,d )
end
end ;
Appel de la procédure, pour trier toute la liste : triRapide(liste, 0, liste.Items.Count−1);
8
Algorithmes Delphi
3.3.2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Version 4.2 du 21 juillet 2014
Fonction auxiliaire « division »
function division ( var liste : TListBox ; g , d : integer ) : integer ;
var i , j : integer ;
pivot : string ;
begin
pivot := liste . Items [ d ] ;
j:=d − 1;
i:=g ;
while i<=j do
i f liste . Items [ i]<pivot then
i:=i+1
e l s e i f liste . Items [ j]>pivot then
j:=j−1
e l s e begin
echange ( liste , i , j ) ;
i:=i+1;
j:=j−1
end ;
echange ( liste , i , d ) ;
division :=i
end ;
La durée d’exécution du corps de la boucle while n’est pas optimale : lorsque l’indice j doit
être diminué successivement plusieurs fois (ligne 12), le test à la ligne 9 est évalué chaque fois
avant qu’on ne passe au test significatif de la ligne 11, alors que l’indice i n’a pas changé.
Nous proposons au lecteur intéressé une version alternative de la fonction « division » :
? On choisit d’abord l’élément du milieu de la liste comme pivot qu’on place à la position g .
Cette première étape est facultative, mais elle permet quelquefois d’obtenir un pivot plus
équilibré, surtout lorsque la liste à trier est déjà presque triée, ou triée dans l’ordre inverse.
? Ensuite on examine tous les éléments de la liste depuis g + 1 jusqu’à d en veillant à ce
que les valeurs strictement inférieures au pivot soient toujours placées avant les valeurs
supérieures ou égales au pivot. L’indice j indique constamment la position de la dernière
valeur strictement inférieure au pivot dans la partie déjà traitée de la liste (ou j = g
lorsqu’une telle valeur n’a pas encore été trouvée).
? Après la boucle, il suffit d’échanger le pivot avec l’élément à la position j pour placer le
pivot au bon endroit.
9
Algorithmes Delphi
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Version 4.2 du 21 juillet 2014
function division ( var liste : TListBox ; g , d : integer ) : integer ;
var i , j : integer ;
pivot : string ;
begin
echange ( liste , g , ( g+d ) div 2 ) ;
pivot := liste . Items [ g ] ;
j:=g ;
for i:=g+1 to d do
i f liste . Items [ i]<pivot then begin
j:=j+1;
i f j<>i then echange ( liste , j , i )
end ;
i f g<>j then echange ( liste , g , j ) ;
division :=j
end ;
Pour les listes à taille faible (d − g < 20), le tri par insertion devient généralement plus rapide
que le tri rapide.
4
Algorithme de recherche
Par convention, les algorithmes de recherche suivants renvoient tous l’indice −1, lorsque la clé
cherchée n’a pas été trouvée.
4.1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Recherche séquentielle
function rechercheSeq ( liste : TListBox ; cle : string ) : integer ;
var i : integer ;
trouve : boolean ;
begin
i :=0;
trouve := false ;
while ( not trouve ) and ( i<liste . Items . Count ) do
i f liste . Items [ i]= cle then
trouve := true
else
i:=i+1;
i f trouve then
rechercheSeq :=i
else
rechercheSeq:=−1
end ;
10
Algorithmes Delphi
4.2
4.2.1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
1
3
4
5
6
7
8
9
10
11
12
13
14
15
Recherche dichotomique
Version itérative
function rechDichoI ( liste : TListBox ; cle : string ) : integer ;
var milieu , g , d : integer ;
begin
g :=0;
d:= liste . Items . Count − 1;
milieu :=( g+d ) div 2 ;
while ( cle<>liste . Items [ milieu ] ) and ( g<=d ) do begin
i f cle<liste . Items [ milieu ] then
d:= milieu −1
else
g:= milieu +1;
milieu :=( g+d ) div 2
end ;
i f cle=liste . Items [ milieu ] then
rechDichoI := milieu
else
rechDichoI:=−1
end ;
4.2.2
2
Version 4.2 du 21 juillet 2014
Version récursive
function rechDichoR ( liste : TListBox ; cle : string ; g , d : integer ) : integer ;
var milieu : integer ;
begin
i f g>d then
rechDichoR:=−1
e l s e begin
milieu :=( g+d ) div 2 ;
i f liste . Items [ milieu ]= cle then
rechDichoR := milieu
e l s e i f cle<liste . Items [ milieu ] then
rechDichoR := rechDichoR ( liste , cle , g , milieu −1)
else
rechDichoR := rechDichoR ( liste , cle , milieu +1,d )
end
end ;
Appel de la fonction, pour rechercher dans toute la liste :
. . . rechDichoR(liste, cle, 0, liste.Items.Count−1) . . .
11
Algorithmes Delphi
5
5.1
Version 4.2 du 21 juillet 2014
Graphiques
Affichage de fonctions simples
La procédure dessFonction réalise la représentation graphique Cf de la fonction f , supposée
définie, continue et non constante sur l’intervalle d’affichage [x1 , x2 ], avec x1 < x2 . L’échelle de
l’axe vertical (axe des ordonnées) est ajustée par la procédure en fonction des valeurs maximale
et minimale prises par la fonction sur l’intervalle considéré.
Exemple de fonction f :
1
2
3
4
function f ( x : extended ) : extended ;
begin
f:= s i n ( x)+ c o s ( 2 ∗ x )
end ;
Procédure de dessin, qui accepte comme arguments la surface de dessin (Image) et les nombres
x1 et x2 . Le graphique de la fonction est dessiné en couleur rouge sur le canevas (dont le contenu
antérieur n’est pas effacé).
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
procedure dessFonction ( var im : TImage ; x1 , x2 : extended ) ;
var fx , dx , dy , ymin , ymax : extended ;
i : integer ;
begin
dx :=( x2−x1 ) / ( im . Width − 1);
ymin :=f ( x1 ) ;
ymax := ymin ;
for i:=1 to im . Width −1 do begin
fx:=f ( x1+i∗ dx ) ;
i f fx<ymin then ymin :=fx
e l s e i f fx>ymax then ymax :=fx
end ;
dy :=( ymax−ymin ) / ( im . Height − 1);
im . Canvas . Pen . Color := clRed ;
im . Canvas . MoveTo ( 0 , round ( ( ymax−f ( x1 ) ) / dy ) ) ;
for i:=1 to im . Width −1 do
im . Canvas . LineTo ( i , round ( ( ymax−f ( x1+i∗ dx ) ) / dy ) )
end ;
L’algorithme précédent convertit des ordonnées réelles en indices de pixel (lignes 15 et 17). Plus
généralement, on pourra utiliser la fonction suivante pour convertir des coordonnées réelles
x, y en indices de pixel. On suppose que les intervalles d’affichage horizontal et vertical sont
[xmin, xmax] et [ymin, ymax]. Pour ne pas devoir passer ces quatre valeurs comme arguments à
la fonction, on a recours à des variables globales.
12
Algorithmes Delphi
1
2
3
Version 4.2 du 21 juillet 2014
type pixel = record
x , y : integer
end ;
4
5
6
7
8
9
function pointToPixel ( x , y : extended ; im : TImage ) : pixel ;
begin
result . x:= round ( ( x−xmin ) / ( xmax−xmin ) ∗ ( im . Width − 1));
result . y:= round ( ( ymax−y ) / ( ymax−ymin ) ∗ ( im . Height − 1))
end ;
5.2
Affichage de polynômes
Un polynôme à coefficients réels et de degré inférieur ou égal à 20 peut être représenté à l’aide
du type
1
2
3
4
type poly = record
c : array [ 0 . . 2 0 ] of extended ;
d : integer
end ;
La méthode de Horner permet d’évaluer efficacement un polynôme p donné en un nombre
réel x.
Dans l’algorithme proposé, le polynôme est passé par variable pour des raisons d’efficacité : on
évite ainsi de copier tout le contenu du polynôme dans la pile, mais on se limite à transmettre
un pointeur vers l’endroit où le polynôme original est stocké. En passant le polynôme par valeur,
on ne modifierait pas les effets produits par la fonction, mais la quantité de mémoire occupée
lors de l’appel serait plus élevée.
1
2
3
4
5
6
7
8
9
function horner ( var p : poly ; x : extended ) : extended ;
var i : integer ;
px : extended ;
begin
px:=p . c [ p . d ] ;
for i:=p . d−1 downto 0 do
px:=px ∗x+p . c [ i ] ;
horner :=px
end ;
Pour réaliser la représentation graphique d’un polynôme p donné, il suffit de remplacer dans
l’algorithme 5.1 les appels du genre f(x) par des appels horner(p,x).
13
Algorithmes Delphi
5.3
Version 4.2 du 21 juillet 2014
[Affichage d’une aire et calcul d’une intégrale numérique]
En modifiant légèrement l’algorithme 5.1, on peut afficher l’aire comprise entre Cf et l’axe des
abscisses et approcher en même temps cette aire algébrique par la méthode des rectangles :
Z x2
f (x) dx ≈ δx ·
x1
n−1
X
f (x1 + iδx ) ,
i=0
où n est le nombre de rectangles, à largeur constante, construits entre Cf et l’axe des abscisses,
1
est la largeur commune des rectangles. À nouveau, la fonction f est supposée
et δx = x2 −x
n
définie, continue et non constante sur l’intervalle d’affichage [x1 , x2 ], avec x1 < x2 .
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
function dessIntegrale ( im : TImage ; x1 , x2 : extended ) : extended ;
var fx , dx , dy , ymin , ymax , intNum : extended ;
i , y0 : integer ;
begin
dx :=( x2−x1 ) / ( im . Width − 1);
ymin :=f ( x1 ) ;
ymax := ymin ;
for i:=1 to im . Width −2 do begin
fx:=f ( x1+i∗dx ) ;
i f fx<ymin then ymin :=fx
e l s e i f fx>ymax then ymax :=fx
end ;
i f ymin>0 then ymin :=0
e l s e i f ymax<0 then ymax : = 0 ;
dy :=( ymax−ymin ) / ( im . Height − 1);
y0:= round ( ymax /dy ) ;
im . Canvas . Pen . Color := clRed ;
intNum : = 0 ;
for i:=0 to im . Width −2 do begin
im . Canvas . MoveTo ( i , y0 ) ;
im . Canvas . LineTo ( i , round ( ( ymax−f ( x1+i∗ dx ) ) / dy ) ) ;
intNum := intNum+f ( x1+i∗ dx )
end ;
dessIntegrale :=dx ∗ intNum
end ;
Par les lignes 13 et 14, on veille à visualiser correctement le bord horizontal de l’aire près de
l’axe des abscisses, qui se situera aux pixels d’ordonnée y0 (ligne 16).
Aux lignes 8 et 19, on choisit im.Width−2 comme valeur d’indice supérieure, pour que le nombre
de rectangles considérés lors de l’approximation de l’intégrale corresponde à la largeur commune
des rectangles, calculée à la ligne 5.
14