Instruction RPG full free · IBM i (AS/400) · Données et calculs

SORTA

Trier un tableau

Trie les éléments d'un tableau en mémoire, dans l'ordre croissant ou décroissant déclaré avec le tableau, ou sur une tranche de ses éléments.

Syntaxe

SORTA tableau;
SORTA %SUBARR(tableau : début : nombre);
dcl-s tableau type dim(n) [ASCEND | DESCEND];

tableau: Le tableau à trier, déclaré avec DIM. L'ordre est celui de son mot-clé ASCEND (par défaut) ou DESCEND.
%SUBARR: Ne trie que nombre éléments à partir de début. Les autres ne bougent pas.
Effet: Réordonne les éléments du tableau. Ne positionne ni %FOUND ni indicateur. Le tri est en mémoire, il ne touche à aucun fichier.

À quoi ça sert

Un tableau chargé depuis un fichier ou construit par calcul arrive dans le désordre. SORTA le met en ordre en une ligne : villes en ordre alphabétique pour un menu, montants du plus gros au plus petit pour un classement.

Le sens du tri n'est pas dans l'instruction mais dans la déclaration du tableau : descend sur soldes donne un classement du plus grand au plus petit. Pour trier seulement ce qui est rempli d'un tableau partiellement utilisé, %SUBARR est le bon outil.

Exemple 1 : Alphabétique et décroissant

**free
// SORTA : trier un tableau, croissant puis decroissant.
ctl-opt dftactgrp(*no) actgrp(*new);

dcl-s villes char(12) dim(5);
dcl-s soldes packed(9:2) dim(5) descend;

villes(1) = 'Montpellier';
villes(2) = 'Lyon';
villes(3) = 'Brest';
villes(4) = 'Nantes';
villes(5) = 'Albi';
soldes(1) = 1250.50;
soldes(2) = 0;
soldes(3) = -320;
soldes(4) = 98000;
soldes(5) = 45.10;

sorta villes;
snd-msg 'Villes : ' + %trim(villes(1)) + ', ' + %trim(villes(2)) + ', ' + %trim(villes(3))
        + ', ' + %trim(villes(4)) + ', ' + %trim(villes(5));
sorta soldes;
snd-msg 'Soldes : ' + %char(soldes(1)) + ' / ' + %char(soldes(2)) + ' / ' + %char(soldes(3))
        + ' / ' + %char(soldes(4)) + ' / ' + %char(soldes(5));

*inlr = *on;

Résultat réel, compilé et exécuté sur IBM i 7.5 :

Villes : Albi, Brest, Lyon, Montpellier, Nantes
Soldes : 98000.00 / 1250.50 / 45.10 / .00 / -320.00

Les villes sont triées de Albi à Nantes. Le tableau des soldes est déclaré descend : le plus grand vient en premier, et la valeur négative en dernier.

Exemple 2 : Vides, casse et tranche

**free
// SORTA : les elements vides sont tries comme les autres, et la casse compte.
ctl-opt dftactgrp(*no) actgrp(*new);

dcl-s noms char(10) dim(6);
dcl-s i    int(10);

noms(1) = 'Petit';
noms(2) = 'Dupont';
noms(3) = 'leroy';
noms(4) = 'Martin';

sorta noms;
for i = 1 to %elem(noms);
  snd-msg 'Rang ' + %char(i) + ' : [' + noms(i) + ']';
endfor;

// Trier seulement la partie remplie
noms(1) = 'Petit';
noms(2) = 'Dupont';
noms(3) = 'Leroy';
noms(4) = 'Martin';
noms(5) = *blanks;
noms(6) = *blanks;
sorta %subarr(noms : 1 : 4);
for i = 1 to %elem(noms);
  snd-msg 'Rang ' + %char(i) + ' : [' + noms(i) + ']';
endfor;

*inlr = *on;

Résultat réel, compilé et exécuté sur IBM i 7.5 :

Rang 1 : [          ]
Rang 2 : [          ]
Rang 3 : [leroy     ]
Rang 4 : [Dupont    ]
Rang 5 : [Martin    ]
Rang 6 : [Petit     ]
Rang 1 : [Dupont    ]
Rang 2 : [Leroy     ]
Rang 3 : [Martin    ]
Rang 4 : [Petit     ]
Rang 5 : [          ]
Rang 6 : [          ]

Le tableau a six éléments, dont deux vides. Après SORTA noms, les deux vides arrivent en tête, puis leroy (écrit en minuscules), et seulement ensuite Dupont, Martin et Petit.

Avec SORTA %SUBARR(noms : 1 : 4), seuls les quatre premiers sont triés et les blancs restent à la fin.

Le piège

Un tableau à moitié plein se trie avec ses vides. Les éléments vides sont des blancs (ou des zéros) comme les autres : en tri croissant, ils passent devant, et vos données commencent au rang 3 au lieu de 1. Triez la partie utile avec %SUBARR, ou déclarez le tableau descend en le sachant.

L'ordre est celui de l'EBCDIC, pas celui du dictionnaire : une minuscule se trie avant toute majuscule. Dans le deuxième exemple, leroy arrive avant Dupont. Mettez la casse en cohérence avant de trier.