PANORAMIC et informatique de gestion (les tableaux)

Le 8 février 2016

Rebonjour à tous les Panoramicien(ne)s

Pour cerner le sujet, je ne 'intéresse qu'à l'informatique de gestion (et un tableur ou un SGDB est très bien pour ça). Ca ne m'empêche pas de vouloir tester d'autres choses.
Ce qui signifie que j'appréhende le monde qui m'entoure, le plus souvent en 2 dimensions (dim tableau r%,c%). Plus de dimensions et je m'y perds.
C'est ce que je pratiquais il y a 35 ans pour trier mes données, les enregistrer sur mon disque dur, les recharger, les manipuler.
Mais, on n'est plus à ce temps là. 
Maintenant, même en BASIC, ce sont des FORM, des File_Load (Fichier), des File_Save (Fichier), des File_Read (ligne d'enregistrement), des File_Write (ligne d'enregistrement) quand ce ne sont pas des Dlist ou des Grid !! Bref des objets.
 
Mon séparateur de champs de tableau, à l'époque, était le CR (carriage return) c'est-à-dire, le séparateur par défaut du DOS. J'enregistrais donc mon fichier tableau par champ et non pas par ligne (donc accès séquentiel et non pas accès direct qui demanderait une préparation de ligne où les champs incomplets seraient complétés par des blancs ou des 0 ou autre chose au choix du programmeur pour que les lignes d'enregistrement aient la même taille).

Aujourd'hui, j'en suis toujours à me demander quand et comment utiliser un tableau, un GRID, un Dlist dans PANORAMiC.
D'autant plus, que je suis aussi "maniaque" du classement (alphanumérique) de mes lignes d'enregistrement (sur un critère ou plus=champ).
Je sais qu'en informatique, il y a plusieurs chemins pour arriver au même résultat MAIS il faut quand même rechercher le moins compliqué.
 
Y a-t-il des exercices, des exemples sur le sujet ?
 
Vivement qu'un (ou des) "senior" écrive "PANORAMIC LANGUAGE for the Dummies" même s'il est déjà bien d'avoir le tutoriel écrit par des bénévoles.

En attendant, ma demande est :

SORT d'un tableau à 2 dimensions ou d'un Objet GRID (moi, je n'appelle pas ça un tri mais un classement)

Un tri, ce sont les adresses d'enveloppes qui sont triées dans des bacs comme Nord OU Pas-de-Calais OU Autres.
Un classement, ce sont les enveloppes du bac de réception Nord que je classe dans l'ordre ASCendant des numéros de code postal. Plus il y a d'enveloppes mélangées au départ, plus le processeur rame (Enfin avec MON programme de classement que j'avais réalisé il y a 35 ans avec le GFA Basic).
Si bien que je coupais le premier classement au bout d'un certain nombre d'enregistrements (ligne de champs) pour créer un nouveau fichier puis les interclasser.
Un interclassement est le classement dans un ordre ASCendant ou DECroissant de plusieurs fichiers déjà classés selon le même ordre et débouchant sur un seul nouveau fichier résultat reprenant toutes les fiches (toutes les enveloppes dans mon exemple).
On peu peaufiner en classant sur plusieurs champs.
Mais bon, avec un seul critère je serais déjà bien content.

Ma proposition est donc :

SORT tableau$(),R1,C1,r2,c2,O,[c3,O,] tableau$+1(nr,nc) tout ou partie des cellules de la table tableau$() (ou tableau%() par exemple, à 2 dimensions), de la cellule R1,C1 (tableau$(R,C)) à la cellule r2,c2, dans l'ordre O (A=ascendant,D=décroissant) vers une table résultante tableau$_1(nombre de lignes,nombre de colonnes).Possibilité d'un deuxième classement [c3,O,] sur un deuxième champ (une colonne) de la table résultante.

Et pourquoi pas un GRID_SORT N,R1,C1,r2,c2,O,[c,O,], N1 (ou mieux un GRID_RANK)
où N est le GRID d'entrée et GRID N1, celui de résultat. Si un grid peut être caché (hide).

Exemple réalisé avec un tableur

Classement par ordre alphabétique des noms du tableau suivant pour janvier 2016 sachant, qu'au départ, je n'ai pas besoin de prendre la première ligne ni la dernière car je sais qu'elles ne sont pas de janvier 2016

(Pensée du jour, il faudra que j'apprenne à réaliser un beau tableau en utilisant l'éditeur du forum)

rang Date Nom Prénom Genre Age No rue rue Code postal Ville Pays adresse mail
1 30/12/15 Xa Xavier M 39 1 aqw Tournai Belgique xa.xavier@
2 02/01/16 Aa Aline F 23 4 zsx Dusseldorf Allemagne aa.aline@
3 03/01/16 Ba Bernard M 15 7 edc Vladivostok Russie bernie_ba@
4 04/01/16 Z Zoe F 45 8 rfv Cologne Allemagne z.z@
5 05/01/16 Ppp Camille I 78 5 tgb Bristol Grande-Bretagne zoe.z@
6 05/01/16 Ca Charles M 36 2 yhn Madrid Espagne charles-ca@
7 05/01/16 W Charles M 56 2 yhn Madrid Espagne charles_w@
8 06/01/16 Be Christian M 56 9 uj Paris France kris.be@
9 07/01/16 Ca Charles M 63 6 iop Amsterdam Pays-Bas charlie.ca@
10 08/01/16 D Nadine F 41 3 yuim Lille France nadia-D@
11 08/02/16 Ouf_Ca_passe Al M 67 59000 Lille France al-ouf_passe@


Résultat sur 1 critère (colonne) en ascendant.

X
Aa Aline F 23 4 zsx Dusseldorf Allemagne
Ba Bernard M 15 7 edc Vladivostok Russie
Be Christian M 56 9 uj Paris France
Ca Charles M 36 2 yhn Madrid Espagne
Ca Charles M 63 6 iop Amsterdam Pays-Bas
D Nadine F 41 3 yuim Lille France
Ppp Camille I 78 5 tgb Bristol Grande-Bretagne
W Charles M 56 2 yhn Madrid Espagne
Z Zoe F 45 8 rfv Cologne Allemagne


Résultat sur un 2ème critère, l'âge, en décroissant

X 2ème
Aa Aline F 23 4 zsx Dusseldorf Allemagne
Ba Bernard M 15 7 edc Vladivostok Russie
Be Christian M 56 9 uj Paris France
Ca Charles M 63 6 iop Amsterdam Pays-Bas
Ca Charles M 36 2 yhn Madrid Espagne
D Nadine F 41 3 yuim Lille France
Ppp Camille I 78 5 tgb Bristol Grande-Bretagne
W Charles M 56 2 yhn Madrid Espagne
Z Zoe F 45 8 rfv Cologne Allemagne


Evidemment, je pourrais utiliser les opérateurs de comparaison comme je le faisais il y a 35 ans, mais, par rapport à l'époque, pour le moment PANORAMIC n'utilise TOUS les opérateurs que pour les nombres et pas pour les strings (ou bien il faut que je crée une routine pour comparer octet par octet de chaque string).

Et une peiite musique pour faire mieux passer ma demande :

https://www.youtube.com/watch?v=jfe8F-ZvplI

Il est vrai que Panoramic est encore un peu "juste" pour traiter correctement les problématiques des applications de gestion. J'en sais quelque chose - j'ai longuement pratiqué (entre autres choses) l'informatique de gestion, et je m'emploie, dans la mesure de mes moyens, de fournir des "extensions" à Panoramic comblant telle ou telle lacune dans ce domaine. Beaucoup de choses sont faites via KGF.dll (même une gestion assez complète Excel/OpenCalc (même code Panoramic vaable pour les deux tableurs), une gestion de fichiers par enregistrements avec des champs à définir par l'utilisateur, une gestion de fichiers ISAM multi-clé et bien d'autres.

Maintenant, pour en venir au problème que tu exposes, je vous 3 solutions, avant de concevoir de nouveaux outils pour Panoramic:

1. utilisation de ce qui existe en Panoramic pur:
Panoramic contient des objets DLIST. Cela semble mystérieux au départ, mais c'est extrêmement puissant. Un objet DLIST est une liste (non visible, gérée uniquement en mémoire), mais qui peut être triée automatiquement. Tu peux donc créer un objet DLIST pour chaque critère de tri que tu veux utiliser, et tu copies dans ces DLIST, pour chaque enregistrement, juste ce qui sert de clé, suivi de 5 ou 10 espaces, puis le numéro de ligne où se trouve l'enregistrement d'origine. Puis, soit tu tries la DLIST par la commande SORT, soit tu as directement créé l'objet DLIST "triable" par la commande SORT_ON. Dans tous les cas, tu peux ensuite lire ta DLIST séquentiellement, et la fin de chaque ligne lue te donne in index dans ton fichier d'origine, selon le tri ascendant. Tu peux aussi lire la DLIST du dernier au premier enregistrement, et tu obtiens en réalité le tri descendant. Simple et efficace, en en plus, le SORT d'une DLIST est très rapide.

2. piloter Excel ou OpenCalc
Tu peux piloter des tables dans Excel et/ou OpenCalc dans lesquelles tu charges tes enregistrements, puis tu les tries dans le tableur. Puis tu relis tes tables, et le tour est joué.

3. utiliser les fichiers ISAM via KGF.dll
Tu peux créer des fichiers ISAM (Indexed Sequential Access Method) multi-clé. Tu définis donc ton enregistrement ISAM, puis tes clés d'accès, et tu charges le fichier. Il te suffit ensuite de lire selon une clé ou l'autre, séquentiellement, et tu as ton résultat trié. Elégant et très souple, car tu peux redéfinir tes clés à volonté et réindexer automatiquement le fichier, créer de nouveaux indexes etc. C'était l'outil de puissance par excellence, à l'époque où je faisais des applications de gestion à titre professionnel.

Techniquement, la solution (1) est la plus simple. Je te conseille de commencer par cela, et tu verras que le résultat est stupéfiant, tant sur le plan fonctionnel que sur le plan des performances. Si tu bloques quelque part, je t'aiderai.

La solution (3) est bien sûr la plus élégante, et c'est celle que je préfère puisque c'est moi qui l'ai réalisée (KGF.dll, c'est moi...). Tu découvrira aussi qu'il y a une base de données relationnelle nommée BDR (réalisée par moi, également) et accessible via KGF.dll. Mais elle est moins intéressante dans ce contexte particulier.

Klaus a écrit:

(KGF.dll, c'est moi...)

KLAUSGUNTHERFILE.DLL

KLAUSGUNTHERFILE.DLL...

pst... le F est l'initiale de mon nom de famille...

Bon, j’ai 2/3 c’est donc plus que la moyenne

Ca fait 3 jours que j'essaie de classer des chiffres dans l'ordre croissant.

Et pourquoi, mon programme appelle la 4ème fiche "8" au lieu de "1" ?

Des questions, toujours des questions Ouf_ca_passe !!

Code:

' =====
' Programme de classement (ascendant) pas de tri
'    par Ouf_ca_passe
' =====
dim a%(10),n%,z%
dim i%        : ' compteur (no fiche appelée)
dim j%        : ' compteur (no fiche inférieure)
dim k%        : ' compteur (reclassement au rang supérieur)
dim m%        : ' nombre de fiches à traiter
label fin
data 10,8,4,1,7,3,8,5,1
m%=4          : ' nombre de datas lus pour essai
print m%
height 0,1500
for i%=1 to m%
 read a%(i%)
 print a%(i%); " - ";
next i%
print
print
' =====
' print "On appelle les fiches une à une en commençant par la deuxième"
' print "Si la fiche appelée est plus grande ou égale à la précédente, elle reste à son rang."
for i%=2 to m%
print "i% = ";i%;" fiche ";a%(i%)
' print "Si la fiche appelée est plus petite que la précédente,"
 if a%(i%-1)>a%(i%)
' print "On continue de la comparer aux fiches précédemment classées en descendant"
' print "jusqu'à ce qu'on arrive à ce qu'elle soit supérieure"
  for j%=i%-1 to 0 step -1
 print a%(j%);" -> ";a%(i%)
 print
  if a%(j%)<a%(i%)
' print "Donc, elle a trouvé sa place (j%+1) mais celle-ci est déjà occupée."
' print "Il faut donc la mettre (i%) en réserve (indice i%+2 par exemple)"
    a%(i%+2)=a%(i%)
' print "et remonter d'1 rang toutes les fiches supérieures et déjà classées."
' print "en commençant par la dernière donc en descendant"
    for k%=i%-1 to j%+1  step -1
    print "k% = ",K%
    a%(k%+1)=a%(k%)
    next k%
' print "Puis,la fiche réservée en i%+2 prend la place de la fiche inférieure + 1"
    a%(j%+1)=a%(i%+2)
  end_if
 print  "a%(J%) ="; a%(j%)
 print "-o-o-o-"
 for n%=1 to i%
  print n%;" = ";a%(n%)
 next n%
  next j%
 end_if
 input z%            : ' ET ON RECOMMENCE JUSQU'A CE QU'IL N'Y AIT PLUS DE FICHES A CLASSER
next i%              : ' S'il y a beaucoup de fiches à classer et que cela prend du temps,
' =====
print "-+-+-+-"
 for i%=1 to m%      : ' on peut créer plusieurs fichiers classés puis les interclasser en
  print a%(i%)      : ' classant la fiche la plus basse, en premier, dans le fichier résultant.
 next i%
fin:
end
' =====

Bonsoir Ouf ca passe !

Je te propose ces quelques lignes ou j'ai repris tes valeurs.
Je te laisse le soin de décortiquer le fonctionnement qui est très simple...

L'idée est d'utilisé  un 'pointeur' dans la liste des nombres afin de permettre leurs classements.

1. On positionne le pointeur sur le premier de la liste nb%(1)
2. On recherche le plus petit nombre a partir du pointeur jusqu'a la fin.
3. Si c'est le cas on échange les valeurs.
On positionne ensuite le pointeur sur le second de la liste nb%(2). Et ainsi de suite...

Code:

DIM nb%(10) , n% , a% , b%

DATA 10,8,4,1,7,3,8,5,1

PRINT "Classement de départ : "
FOR a%=1 TO 9
   READ nb%(a%) : PRINT nb%(a%);" - ";
NEXT a%

PRINT : PRINT : PRINT "Classement croissant : "
FOR a%=1 TO 9
   FOR b%=a% TO 9
       IF nb%(a%)>nb%(b%) THEN n%=nb%(a%) : nb%(a%)=nb%(b%) : nb%(b%)=n%
   NEXT b%
   PRINT nb%(a%);" - ";
NEXT a%

PRINT : PRINT : PRINT "Classement décroissant : "
FOR a%=1 TO 9
   FOR b%=a% TO 9
       IF nb%(a%)<nb%(b%) THEN n%=nb%(a%) : nb%(a%)=nb%(b%) : nb%(b%)=n%
   NEXT b%
   PRINT nb%(a%);" - ";
NEXT a%

Il existe beaucoup d’algorithmes de classements de données.
Voici un exemple de trois algorithmes pour classer un tableau de n entiers.

Code:

rem ============================================================================
rem            Algorithmes de Classements
rem ============================================================================
dim n : n = 50 : ' nombre des éléments à classer
dim x%(n), bidon%(n)
 width 0,1000
font_bold 0
Suite_Aleatoire(n) : Afficher()
Classement_par_encastrement() : Afficher() : Restaurer_la_suite()
Classement_par_substitution() : Afficher() : Restaurer_la_suite()
Classement_par_insertion()    : Afficher() : Restaurer_la_suite()
end
rem ============================================================================
' Fournir une suite aléatoire de n entiers de l'ensemble {0,1,2,...,n-1}
SUB Suite_Aleatoire(n)
    dim_local i
    print "Suite aléatoire de " + str$(n) + " entiers"
    for i = 1 to n : x%(i) = int(rnd(n)) : bidon%(i) = x%(i) : next i
END_SUB
rem ============================================================================
' Pour travaller toujours sur la même suite
SUB Restaurer_la_suite()
    dim_local i
    for i = 1 to n : x%(i) = bidon%(i) : next i
END_SUB
rem ============================================================================
' Afficher la suite
SUB Afficher()
    dim_local i
    for i = 1 to n : print x%(i);" "; : next i : print
'    for i = 1 to n : print x%(i) : next i
    print "===================================================================="
END_SUB
rem ============================================================================

SUB Classement_par_encastrement()
    dim_local i,j,aux%
    print "La même suite classée par encastrement"
    for j = 2 to n
        i = j-1
        aux% = x%(j)
        while i > 0
              if aux% >= x%(i)
                exit_while
              else
                x%(i+1) = x%(i)
                i = i-1
              end_if
        end_while
        x%(i+1) = aux%
    next j
END_SUB
rem ============================================================================
' Cet algorithme s'appelle "Bubble sort"
' C'est l'algorithme de classement le plus simple et le plus mauvais.
SUB Classement_par_substitution()
    dim_local i,j,aux%
    print "La même suite classée par substitution"
    for j = 1 to n-1
        for i = 1 to n-j
            if x%(i) > x%(i+1)
              aux% = x%(i) : x%(i) = x%(i+1) : x%(i+1) = aux%
            end_if
        next i
    next j
END_SUB
rem ============================================================================
SUB Classement_par_insertion()
    dim_local i,j,en_cours%
    print "La même suite classée par insertion"
    for i = 2 to n
        en_cours% = x%(i)
        j = i-1
        ' décalage des éléments du tableau
        while (j > 0) and x%(j) > en_cours%
              x%(j+1) = x%(j)
              j = j -1
        end_while
        ' on insère l'élément à sa place
        x%(j+1) = en_cours%
    next i
END_SUB
rem ============================================================================

@Papydall : Le compte est bon

J'aurai juste modifier la ligne 30 pour une meilleur lisibilité par :

  for i = 1 to n : print x%(i);" "; : next i : print

Mais cela n'est qu'une question de goût...

Bien vu.
J'ai modifié mon code ci-haut.

Pour le moment, je ne veux classer que les 1ers champs d'enregistrement.

Code:

rem =====
rem Algorithme de Classement par Papydall
rem  modifié par Ouf_ca_passe
rem =====
dim a$(20,5)
dim z$
dim i%,j%,n% : n%=9
 width 0,1000 : height 0, 1500
font_bold 0
Data "Zoé","abc","def","ghi",""
Data "Alain","jkl","mno","pqr",""
Data "Bernard","stu","vwxy","",""
Data "Christian","zer","","",""
Data "Bernard","tyu","io)p","",""
Data "William","qsd","fgh","",""
Data "Anatole","jklm","","",""
Data "Brigitte","ù*wx","cfv","",""
Data "Monique","aqw","zsx","",""
For i%=1 to n%
  for j%=1 to 5
    read a$(i%,j%)
  next j%
next i%
Afficher()
Classement_par_substitution()
Afficher()
end
rem =====
SUB Afficher()
For i%=1 to 9
  for j%=1 to 4
    print a$(i%,j%);" ";
  next j%
    print a$(i%,5)
next i%
END_SUB
rem =====

' Cet algorithme s'appelle "Bubble sort"
' C'est l'algorithme de classement le plus simple et le plus mauvais.

' SUB Classement_de nombres_par_substitution()
'  dim_local i,j,aux%
'  print "La même suite classée par substitution"
'  for j = 1 to n-1
'    for i = 1 to n-j
'      if x%(i) > x%(i+1)
'        aux% = x%(i)
'        x%(i) = x%(i+1)
'        x%(i+1) = aux%
'      end_if
'    next i
'  next j
' END_SUB
SUB Classement_par_substitution()
    dim_local aux$
    print "Fiches classées par substitution"
    for i% = 1 to n%-1
        for j% = 1 to n%-i%
        Print a$(j%,1),a$(j%+1,1)
        input z$      : ' Pause pour souffler
            if max(a$(j%,1),a$(j%+1,1))=a$(j%,1)
              aux$= a$(j%,1)
              a$(j%,1) = a$(j%+1,1)
              a$(J%+1,1) = aux$
            end_if
        next j%
    next i%
END_SUB
rem =====

Cordialement

@Jack : Puisqu'on parle de classement, Il avait été question d'une instruction SWAP pour échanger 2 variables dans ce post.
Qu'en est il aujourd'hui ?

@Ouf_ca_passe : Désolé pour le hors sujet.

Bonsoir Ouf_ca_passe !

Est ce que cela réponds à ta demande :

Code:

DIM nb$(9,5) , n$ , a% , b% , c%

Data "Zoé","abc","def","ghi",""
Data "Alain","jkl","mno","pqr",""
Data "Bernard","stu","vwxy","",""
Data "Christian","zer","","",""
Data "Bernard","tyu","io)p","",""
Data "William","qsd","fgh","",""
Data "Anatole","jklm","","",""
Data "Brigitte","ù*wx","cfv","",""
Data "Monique","aqw","zsx","",""

DLIST 1

PRINT "Classement de départ : " : PRINT
FOR a%=1 TO 9
  READ nb$(a%,1) : PRINT nb$(a%,1);" >>> "; : ITEM_ADD 1,nb$(a%,1)
  FOR b%=2 TO 5
      READ nb$(a%,b%) : PRINT nb$(a%,b%);" - ";
  NEXT b%
  PRINT
NEXT a%

SORT 1

PRINT : PRINT : PRINT "Classement croissant : " : PRINT
FOR a%=1 TO 9
  n$=ITEM_READ$(1,a%) : PRINT n$;" >>> ";
  FOR c%=1 TO 9
      IF n$=nb$(c%,1) THEN FOR b%=2 TO 5 : PRINT nb$(c%,b%);" - "; : NEXT b% : nb$(c%,1)="" : EXIT_FOR
  NEXT c%
  PRINT
NEXT a%

@Ouf_ca_passe

Ligne 62

Code:

if max(a$(j%,1),a$(j%+1,1))=a$(j%,1)

Tu ne peux pas faire ça pour la bonne raison que la fonction MAX(X,Y) exige que les deux paramètres soient des valeurs numériques ( entier ou réel) et non du type chaîne de caractères.

Ligne 61

Code:

input z$      : ' Pause pour souffler

Une telle commande est à éviter.
Pourquoi ?
1- Lors du déroulement du programme, rien n’indique qu’il faut appuyer sur <ENTER>
2- Il est plus commode (c’est mon point de vue personnel) de coder

Code:

STOP

Cette commande arrête l’exécution du programme en indiquant le numéro de la ligne de la commande STOP avec possibilité de continuer ou d’arrêter définitivement l’exécution.

EDIT :
Pour SWAP (x,y) cliquez ici

Pour la comparaison des chaînes de caractères, j’ai posté ici une sub qui fait le boulot.

Voici le

Code:

' ******************************************************************************
' Comparaison des chaînes de caractàres
dim s1$,s2$,result
' s1$ = "SALUT" : s2$ = "salut"
' s1$ = "SALUT" : s2$ = "SALUT"
' s1$ = "12345" : s2$ = "2"
 s1$ = "Pomme" : s2$ = " Orange"
 
Str_Compare(s1$,s2$)
select result
   case -1 : message s1$ + " < " + s2$
   case  0 : message s1$ + " = " + s2$
   case  1 : message s1$ + " > " + s2$
end_select
end
' ******************************************************************************
' Comparaison de deux chaînes de caractères
' La comparaison s'effectue sur les codes ASCII des caractères
' Retourne :
' RESULT =  0 si les 2 chaines sont identiques
' RESULT = -1 si la 1ère chaîne est inférieure à la seconde
' RESULT =  1 si la 1ère chaîne est supérieure à la seconde
SUB Str_Compare(a$,b$)
    dim_local l,l1,l2,i
    l1 = len(a$) : l2 = len(b$) : l = min(l1,l2) : result = 0
    for i = 1 to l
        if asc(mid$(a$,i,1)) < asc(mid$(b$,i,1)) then result = -1 : exit_sub
        if asc(mid$(a$,i,1)) > asc(mid$(b$,i,1)) then result =  1 : exit_sub
    next i
   if l1 > l then result = 1 : exit_sub
   if l2 > l then result = -1
END_SUB
' ***********************************************************************

Je viens d'ouvrir mon ordi et je vais regarder vos réponses pour lesquelles je vous remercie grandement.

J'avais oublié STOP dont Papydall m'avait déjà parlé, je me souvenais de PAUSE et WAIT mais c'était pas ça.
Ce que c'est que de vieillir.

Bonne journée ensoleillée aux PANORAMICIEN(NE)S

1) OUI. Vous avez répondu à la question.
2) L'opérateur de comparaison "=" marche pour les strings mais pas "<" et ">" ...???...si bien qu'il faut comparer octet par octet (merci pour la routine de Papydall). Dommage que MAX, MIN, EQUAL ne marchent pas non plus (à défaut de <>=).
3) PANORAMIC n'accepte l'instruction DOWNTO, il faut en passer par STEP -1. C'est pas grave mais c'est comme tout, encore faut-il le savoir.
4) SORT ne marche qu'en ASCending. C'est pas grave non plus.
5) J'ai pas compris EXIT_FOR. Je comprends EXIT_IF quand on veut arrêter à la première condition vraie et qu'on sait qu'il n'y aura pas de doublons dans la suite. Enfin moi, c'est comme ça que je le comprends. Quant à EXIT_FOR ?? Et pourtant, le résultat n'est pas le même avec ou sans (code ci-dessous).
6) Je n'ai pas réussi à classer les autres champs associés quand décroissant (du code Minibug). Je crois que tu procèdes par comparaison à l'aide d'une boucle FOR-NEXT entre l'item classé du SORT et le premier champ de l'enregistrement pour reclasser les autres champs.
7) Définitivement, je préfère un langage interprété comme PANORAMIC à un langage uniquement compilé avec toutes les erreurs les unes à la suite des autres.

Je m'absente aujourd'hui.
A demain les PANORAMICIEN(NE)S

Code:

' -----
' Comparaison de strings par Minibug
'  modifié par Ouf_ca_passe
' -----
DIM nb$(9,5) , n$ , a% , b% , c%

height 0,1500

Data "Zoé","abc","def","ghi",""
Data "Alain","jkl","mno","pqr",""
Data "Bernard","stu","vwxy","",""
Data "Christian","zer","","",""
Data "Bernard","tyu","io)p","",""
Data "William","qsd","fgh","",""
Data "Anatole","jklm","","",""
Data "Brigitte","ù*wx","cfv","",""
Data "Monique","aqw","zsx","",""

DLIST 1

PRINT "Classement de départ : " : PRINT
FOR a%=1 TO 9
  READ nb$(a%,1) : PRINT nb$(a%,1);" >>> "; : ITEM_ADD 1,nb$(a%,1)
  FOR b%=2 TO 5
      READ nb$(a%,b%) : PRINT nb$(a%,b%);" - ";
  NEXT b%
  PRINT
NEXT a%

SORT 1

PRINT : PRINT : PRINT "Classement croissant : " : PRINT
FOR a%=1 TO 9
  n$=ITEM_READ$(1,a%) : PRINT n$;" >>> ";
  FOR c%=1 TO 9
      IF n$=nb$(c%,1)
        FOR b%=2 TO 5
          PRINT nb$(c%,b%);" - ";
        NEXT b%
        nb$(c%,1)=""
        EXIT_FOR
      END_IF
  NEXT c%
  PRINT
NEXT a%

PRINT : PRINT : PRINT "Classement décroissant : " : PRINT
FOR a%=9 TO 1 step -1
  n$=ITEM_READ$(1,a%) : PRINT n$;" >>> ";
  FOR c%=1 TO 9
      print c%
      IF n$=nb$(c%,1)
        FOR b%=2 TO 5
          PRINT nb$(c%,b%);" - ";
        NEXT b%
        nb$(c%,1)=""
        EXIT_FOR
      END_IF
  NEXT c%
  PRINT
NEXT a%

Ouf_ca_passe a écrit:

J'avais oublié STOP dont Papydall m'avait déjà parlé, je me souvenais de PAUSE et WAIT mais c'était pas ça.
Ce que c'est que de vieillir.

Toi et moi, on a le même âge ou presque, non ?
Nous sommes deux jeunes vieux, plus jeunes que vieux.
Bon_ça_passe !

Ouf_ca_passe a écrit:

5) J'ai pas compris EXIT_FOR….

EXIT_FOR  (comme EXIT_WHILE ou EXIT_REPEAT) permet de terminer la boucle FORT/NEXT (respectivement WHILE/END_WHILE et REPEAT/UNTILL) en se branchant à l’instruction qui vient juste après NEXT (respectivement END_WHILE et UNTILL).
C’est donc une manière « élégante » de quitter une boucle sans utilisation de GOTO ni modification du compteur de la boucle FOR/NEXT.
Bien sûr, pour que cette façon de procéder  ait un sens, elle doit être associé à une condition du type IF.

Exemple:

Code:

dim i
font_bold 0
for i = 1 to 10
    print "i = " + str$(i)
    if i = 5 then i = 10 : ' On modifie la valeur du compteur de la boucle pour pouvoir en sortir
next i
print "Sortie de la boucle sans aller jusqu'au bout"
print "i vaut " + str$(i)
print "====================================="
rem ============================================================================
for i = 1 to 10
    print "i = " + str$(i)
    if i = 5 then exit_for : ' On sort de la boucle sans modifier la valeur du compteur
next i
print "Sortie de la boucle sans aller jusqu'au bout"
print "i vaut " + str$(i)

Remarque :
Il n'est pas prudent de modifier la valeur du compteur d'une boucle FOR/NEXT à l'intérieur de la boucle.

@ Papydall

Tu as raison.
Si on s'intéresse à PANORAMIC et FBPano, c'est qu'on est forcément jeune dans sa tête.

@ tou(te)s
Pourquoi ITEM_ADD n° d'objet, élément à inclure. ex = ITEM_ADD 1,nb$(a%,1)
MAIS ITEM_READ$(n° d'objet, élément à inclure). ex = ITEM_READ$(1,nb$(a%,1))
et pas ITEM_READ$ n° d'objet, élément à inclure
sans les parenthèses ??

Bonne journée

Je pense que tu voulais dire/écrire
Item_add et pas Item_read$ mais bon je ne sais pas pour autant...

En fait, je crois que le résultat de la lecture est placé dans la variable système Item_Read$.

Ouf_ca_passe a écrit:

Pourquoi ITEM_ADD n° d'objet, élément à inclure. ex = ITEM_ADD 1,nb$(a%,1)
MAIS ITEM_READ$(n° d'objet, élément à inclure). ex = ITEM_READ$(1,nb$(a%,1))
et pas ITEM_READ$ n° d'objet, élément à inclure
sans les parenthèses ??

C'est très simple :

ITEM_ADD est une commande : c'est quelque chose à effectuer. Dans ce cas, il n'y a pas de parenthèse. Une commande est seule sur une ligne.

ITEM_READ$ est une fonction : c'est une question et il y a un résultat. Comme pour toutes les fonctions, il y a des parenthèses.
ITEM_READ se trouve alors
- derrière un signe = pour affecter le résultat dans une variable,
- ou dans une expression, en tant que résultat d'appel à une fonction.

ITEM_ADD a,b$ : exécute un ordre
c$=ITEM_READ$(a,b) : dans c$, on affecte la ligne b de l'objet a

C'est exactement comme la différence entre :
HEIGHT n,100 : on impose la hauteur de l'objet n à 100 pixels
a=HEIGHT(n) : dans la variable a, on met la hauteur de l'objet n

@Ouf_ca_passe

ITEM_ADD n'a pas de parenthèse car c'est une commande, cad qu'elle ne renvoie pas de résultat. EX.:  ITEM_ADD 1,"c'est la ligne 1"
ITEM_READ$ est une fonction car elle renvoie un résultat dans une variable. Ex.:  ch$ = ITEM_READ$(1,2)
Pourquoi t'embète tu avec le tri sous forme d'une sub? Il y a un objet DLIST qui possède cette option.

EDIT : on s'est croisé Jack

Merci aux PANORAMICIEN(NE)S qui m’ont répondu

Je sais qu’il existe des objets et des DLLs mais je préfère m’attacher à réaliser des programmes « basiques » avec votre aide et les « instructions » que j’utilisais il y a 35 ans.

Pour moi, j’en suis resté à un SPRITE est le nom d’une boisson gazeuse,
une fonction est une expression mathématique du genre y (puis on a changé pour montrer qu’on est intelligent en f(x)) = ax2 + bx + c
une matrice sert à faire des bébés et non pas un tableau de variables à 1 ou plusieurs dimensions.

Comme l’a compris JACK, il me faut beaucoup de temps pour comprendre les choses et que ce soit expliqué simplement.
Ce pourquoi j’aimais bien les ouvrages de vulgarisation de Maître E. AISBERG comme « La radio ? mais c’est très simple ! » Et suivants.

J’attends toujours qu’un SENior ou un collège de SENiors écrive « Le BASIC PANORAMIC ? C’est pas compliqué ! » mais, pour l’instant, l’onglet « Cours » de PANORAMIC le Mag contient peu d’exemples à réaliser pas à pas.
Jean-Claude avait commencé avec sa série d’articles intitulés « Je débute ».

Ouf_ca_passe
Autosurnommé L’IGNOTUS de l’informatique

@ Jack
Pourquoi y veut pas ?

Code:

dim a$(2,2),b$
Dlist 1
a$(1,1)="Benoit"
PRINT a$(1,1)
ITEM_ADD 1,a$(1,1)
B$ = ITEM_READ$(1,a$(1,1))
print b$
end

Cette fois-ci, j'ai quand même utilisé un objet (Dlist) pour me mettre au goût du jour.

@ Papydall
J'ai regardé tes exemples de classement de NOMBRES mais ça ne classe pas les STRINGS.

Toujours le même problème des opérateurs de comparaison de PANORAMIC qui ne comparent que des nombres OU octet par octet.
Le BASIC GFA, comme les autres basics de l'époque d'ailleurs, savait comparer les chaînes de caractères.

Bonne journée ensoleillée aux PANORAMICIEN(NE)S

Bonjour à tous,

@Ouf_ca_passe,
Cette ligne de ton code n'est pas bonne:

Code:

B$ = ITEM_READ$(1,a$(1,1))

Une remarque: évites B$ pour une variable déclarée initialement b$ (en minuscule). Pour Panoramic ce n'est pas un problème, mais je crois que pour le compilateur si un jour tu l'utilises) ça pose problème.

Revenons au sujet:
Tu utilises ITEM_READ$ pour lire dans le DLIST 1, c'est bon, mais le deuxième paramètre doit-être le numéro de ligne (celle que tu veux lire) dans le DLIST.

Voici ton code corrigé:

Code:

dim a$(2,2),b$
Dlist 1
a$(1,1)="Benoit"
PRINT a$(1,1)
ITEM_ADD 1,a$(1,1)
b$ = ITEM_READ$(1,1)
print b$
end

Suite à ta demande, je suis entrain de préparer un article sur les manipulations de fichier avec utilisation d'un DLIST.
J'espère pour la prochaine sortie du mag.

A+