[COBOL] Tableau Dynamique et Gestion nb inconnu à l'avance d'entrées [Résolu]

[Metalman]

Bonjour,

J'ai cherché quelques trucs sur les tableaux à taille variable, les pointeurs...
Mais sois c'est trop statique, soit je n'ai pas encore vu en détails et n'arriverait pas à implémenter.
Voilà ce que je souhaiterais faire :

J'ai un fichier contenant 3 colonnes :
MONSIEUR X 02500 12012012
MONSIEUR X 01213 13012012
MONSIEUR Y 04042 16012012
MONSIEUR X 03615 17012012
MONSIEUR Z 01337 18012012

Vous l'aurez compris, il s'agit d'une feuille contenant les dépenses de chaque personne, avec la date.
Je souhaiterais faire la moyenne des dépenses, et afficher la moyenne par personne.

J'ai lu quelques livres et tutos pour lire ligne par ligne les entrées.
Je peux donc faire un traitement ligne par ligne.

Pour ne parser qu'une seule fois le fichier...
Suis-je obligé de connaitre le nombre exact de personnes à l'avance ?
Ou est-ce possible de faire un tableau totalement dynamique qui grandit à chaque fois qu'une nouvelle personne est lue ?

Ou suis-je obligé de lire une fois entièrement le fichier, d'appeler une autre procédure qui va allouer un tableau.... avec la taille précédemment obtenue (est-ce possible ?), et faire les moyennes ?


Je suis habitué au C et à quelques langages de scripts...
Je démarre en COBOL (j'ai obtenu un stage dans le mainframe, et je préfère tater de ça avant de démarrer)
Merci de votre aide !

[Hédhili Jaïdane]

Bonjour.

Je pense qu'il est inutile de passer par des tableaux, de toute façon tu dois lire toutes tes données à partir du fichier, du début à la fin. Tu n'as pas à repasser sur ces données puisque tu n'as pas de calcul de pourcentage par exemple.

Si ton fichier n'est pas indexé ou trié sur le champ NOM (ou un identifiant quelconque), il faut le faire pour classer les enregistrements par ordre de cet identifiant sur lequel il suffit tout simplement de cumuler les dépenses et les compter.

Quand il y a un changement d'identifiant, tu calcules ta moyenne et tu l'affiches, tu peux aussi l'écrire dans un fichier en sortie (fichier des moyennes).

A la fin, tu peux calculer ta moyenne générale.

En ce qui concerne les tableaux, on peux travailler avec des tableaux à taille variable sauf que de toute façon il faut prévoir la taille maximale, chose inappropriée dans ce cas. Ce sont les OCCURS DEPENDING ON (ODO). Et je pense que cela n'a rien à voir avec les pointeurs, qui sont par ailleurs très casse-patates en Cobol, mais on peut les utiliser et la moindre erreur nous envoie paître avec les vaches.

[Metalman]

Il faut donc un prétraitement ?
Normalement, ce serait le logiciel générant ces données, ou le SGBD qui renverrait ces données classées ? (okok, le SGBD pourrait fait le calcul :p)

Est-il possible de faire ce tri en COBOL ?

[Hédhili Jaïdane]

Envoyé par Metalman

....

Est-il possible de faire ce tri en COBOL ?

Bien entendu, généralement on l'évite pour des raisons évidentes de performances si les traitements sont récurrents. On essaie autant que faire se peut de prévoir des clés primaires ou secondaires une fois pour toutes.

On peut faire aussi des tris externes, si on a les outils qu'il faut, et soumettre le fichier trié à un programme Cobol.

Le tri interne Cobol peut trier dans un fichier temporaire sans produire un fichier trié à l'extérieur du programme, mais soumettre le fichier temporaire trié au traitement du programme Cobol.

Code :

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
┌─── SORT Statement - Format ────────────────────────────────────────────┐
│                                                                        │
│ >>──SORT──file-name-1────────────────────────────────────────────────> │
│                                                                        │
│    <──────────────────────────────────────────────────┐                │
│                                       <─────────────┐ │                │
│ >────┬────┬──┬─ASCENDING──┬──┬─────┬────data-name-1─┴─┴──────────────> │
│      └─ON─┘  └─DESCENDING─┘  └─KEY─┘                                   │
│                                                                        │
│ >──┬────────────────────────────────────┬────────────────────────────> │
│    └─┬──────┬──DUPLICATES──┬──────────┬─┘                              │
│      └─WITH─┘              └─IN ORDER─┘                                │
│                                                                        │
│ >──┬────────────────────────────────────────────────┬────────────────> │
│    └─┬───────────┬──SEQUENCE──┬────┬──alphabet-name─┘                  │
│      └─COLLATING─┘            └─IS─┘                                   │
│                                                                        │
│             <─────────────┐                                            │
│ >──┬─USING────file-name-2─┴─────┬────────────────────────────────────> │
│    └─┤ input procedure phrase ├─┘                                      │
│                                                                        │
│              <─────────────┐                                           │
│ >──┬─GIVING────file-name-3─┴─────┬──────────────────────────────────>< │
│    └─┤ output procedure phrase ├─┘                                     │
│                                                                        │
│ input procedure phrase:                                                │
│ ├──INPUT PROCEDURE──┬────┬──procedure-name-1─────────────────────────> │
│                     └─IS─┘                                             │
│                                                                        │
│ >──┬───────────────────────────────┬─────────────────────────────────┤ │
│    └─┬─THROUGH─┬──procedure-name-2─┘                                   │
│      └─THRU────┘                                                       │
│                                                                        │
│ output procedure phrase:                                               │
│ ├──OUTPUT PROCEDURE──┬────┬──procedure-name-3────────────────────────> │
│                      └─IS─┘                                            │
│                                                                        │
│ >──┬───────────────────────────────┬─────────────────────────────────┤ │
│    └─┬─THROUGH─┬──procedure-name-4─┘                                   │
│      └─THRU────┘                                                       │
│                                                                        │
└────────────────────────────────────────────────────────────────────────┘

[Metalman]

Super !
Avez-vous de la documentation là dessus ?
Et/Ou les méthodes à appliquer pour coder un tel tri dans un fichier temporaire ?

Merci de votre aide !

[Hédhili Jaïdane]

Puisque tu t'intéresses aux mainframes

- manuels : http://ibmmainframes.com/manuals.php

- et le site z/OS : http://publib.boulder.ibm.com/infoce...1r12/index.jsp

[Hédhili Jaïdane]

A titre d'exemple :

Code :

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
0002   IDENTIFICATION DIVISION.
0003  ******************************************************************
0004  *                                                                *
0005  * CALCUL MOYENNE PAR PERSONNE
0006  *                                                                *
0007  ******************************************************************
0008   PROGRAM-ID. MOYENNE.
0009   AUTHOR. H. JAIDANE.
0010   ENVIRONMENT DIVISION.
0011   CONFIGURATION SECTION.
0012   SOURCE-COMPUTER. IBM-AS400.
0013   OBJECT-COMPUTER. IBM-AS400.
0014   SPECIAL-NAMES. DECIMAL-POINT IS COMMA.
0018   INPUT-OUTPUT SECTION.
0019   FILE-CONTROL.
0020       SELECT FICHIER ASSIGN DISK-FICHIER
                  ORGANIZATION SEQUENTIAL.
0020       SELECT TRI ASSIGN DISK-TRI.
       DATA DIVISION.
0049   FILE SECTION.
0051   FD  FICHIER.
0052   01  FICHIER-RD.
           03 NOM       PIC X(10).
           03 FILLER    PIC X.
           03 DEPENSE   PIC 999V99.
           03 FILLER    PIC X.
           03 DATEX     PIC X(8).
0051   SD  TRI.
0052   01  TRI-RD.
           03 NOM       PIC X(10).
           03 FILLER    PIC X.
           03 DEPENSE   PIC 999V99.
           03 FILLER    PIC X.
           03 DATEX     PIC X(8).
0054  *
0078   WORKING-STORAGE SECTION.
       77  WTOT-P         PIC 9(5)V99 COMP-3.
       77  WTOT-G         PIC 9(5)V99 COMP-3.
       77  WNBR-P         PIC 9(5) COMP-3.
       77  WNBR-G         PIC 9(5) COMP-3.
       77  WNOM           PIC X(10).
       77  WTOT           PIC Z(4)9,99.
       77  WMOY           PIC Z(4)9,99.
       77  WNBR           PIC Z(4)9.
       01  FIN-FICHIER PIC X.
           88 EOF   VALUE 1.
0078   LINKAGE SECTION.
0242   PROCEDURE DIVISION.
0245   TRAITEMENT SECTION.
       TRAIT-TRI.
           SORT TRI ON ASCENDING KEY NOM OF TRI-RD
                INPUT PROCEDURE  ENTREE
                OUTPUT PROCEDURE SORTIE.
           STOP RUN.
       ENTREE SECTION.
       ENTR1.
           OPEN INPUT FICHIER.
           MOVE 0 TO FIN-FICHIER.
           PERFORM LECT-FICHIER UNTIL EOF.
           CLOSE FICHIER.
       ENTREE-DIVERS SECTION.
       LECT-FICHIER.
           READ FICHIER AT END MOVE 1 TO FIN-FICHIER.
           IF NOT EOF PERFORM ECRIT-TRI.
       ECRIT-TRI.
           RELEASE TRI-RD FROM FICHIER-RD.
       SORTIE SECTION.
0248   DEBUT.
           MOVE 0 TO FIN-FICHIER.
           MOVE 0 TO WTOT-G WNBR-G.
           MOVE LOW-VALUE TO WNOM.
           PERFORM TRAIT-FICHIER-TRI UNTIL EOF.
           IF WNOM = LOW-VALUE DISPLAY "FICHIER VIDE"
           ELSE PERFORM FIN-TRAIT.
       SORTIE-DIVERS SECTION.
       TRAIT-FICHIER-TRI.
           RETURN TRI AT END MOVE 1 TO FIN-FICHIER.
           IF NOT EOF
              PERFORM TRAIT-NOM
           ELSE PERFORM FIN-NOM.
       TRAIT-NOM.
           IF NOM OF TRI-RD NOT = WNOM
              IF WNOM NOT = LOW-VALUE
                 PERFORM FIN-NOM
                 PERFORM DEBUT-NOM
              ELSE PERFORM DEBUT-NOM
           ELSE PERFORM CUMUL-NOM.
       CUMUL-NOM.
           ADD 1 TO WNBR-P.
           ADD DEPENSE OF TRI-RD TO WTOT-P.
       DEBUT-NOM.
           MOVE NOM OF TRI-RD TO WNOM.
           MOVE 1 TO WNBR-P.
           MOVE DEPENSE OF TRI-RD TO WTOT-P.
       FIN-NOM.
           ADD WNBR-P TO WNBR-G.
           ADD WTOT-P TO WTOT-G.
           DIVIDE WTOT-P BY WNBR-P GIVING WMOY ROUNDED.
           MOVE WNBR-P TO WNBR.
           MOVE WTOT-P TO WTOT.
           DISPLAY "NOM.... = " WNOM.
           DISPLAY "TOTAL.. = " WTOT.
           DISPLAY "NOMBRE. = " WNBR.
           DISPLAY "MOYENNE = " WMOY.
           DISPLAY "--------------------".
       FIN-TRAIT.
           DIVIDE WTOT-G BY WNBR-G GIVING WMOY ROUNDED.
           MOVE WNBR-G TO WNBR.
           MOVE WTOT-G TO WTOT.
           DISPLAY "********************".
           DISPLAY "GENERAL = ".
           DISPLAY "TOTAL.. = " WTOT.
           DISPLAY "NOMBRE. = " WNBR.
           DISPLAY "MOYENNE = " WMOY.

Fichier :

MONSIEUR X 02500 12012012
MONSIEUR X 01213 13012012
MONSIEUR Y 04042 16012012
MONSIEUR X 03615 17012012
MONSIEUR Z 01337 18012012

Résultats traitement :

NOM.... = MONSIEUR X
TOTAL.. = 73,28
NOMBRE. = 3
MOYENNE = 24,43
--------------------
NOM.... = MONSIEUR Y
TOTAL.. = 40,42
NOMBRE. = 1
MOYENNE = 40,42
--------------------
NOM.... = MONSIEUR Z
TOTAL.. = 13,37
NOMBRE. = 1
MOYENNE = 13,37
--------------------
********************
GENERAL =
TOTAL.. = 127,07
NOMBRE. = 5
MOYENNE = 25,41

[Metalman]

Wow...
Merci !

J'avais un petit début pour l'écriture dans l'écriture de fichier.... je vais essayer de décortiquer et comprendra ça...

Merci beaucoup !

[el_slapper]

+1 avec les autres réponses, mais j'aimerais insister sur 3 points :

1)les pointeurs en cobol, c'est à oublier. Je sais que c'est indispensable en C, mais le COBOL n'est pas fait pour ça.

2)Le tri avant traitement est un système extrêmement efficace et performant - en tous cas sur MVS. La solution avec tri interne au programme marche aussi, mais elle est peu répandue(toujours en MVS, je crois que Hédhili Jaïdane bosse sur AS/400, ou les contraintes sont différentes).

3)Une gestion de mémoire vraiment dynamique n'existe pas. Ca a l'avantage d'interdire les fuites mémoires. Evidemment, c'est moins souple à coder. On gagne en exploitation ce qu'on perd en codage.

[Hédhili Jaïdane]

Envoyé par el_slapper

...
2)Le tri avant traitement est un système extrêmement efficace et performant - en tous cas sur MVS. La solution avec tri interne au programme marche aussi, mais elle est peu répandue(toujours en MVS, je crois que Hédhili Jaïdane bosse sur AS/400, ou les contraintes sont différentes).

Bonjour el_slapper.

En effet je bosse sur AS/400 (et suivants) où le tri externe, avant traitement, existe sue l'AS/400, on l'imagine bien, par l'outil classique de tri de Big Blue (GSORT et compagnie). Mais dans la pratique on l'utilise très peu, comme d'ailleurs le tri interne. On préfère passer par les index secondaires des fichiers BD que l'on peut construire très aisément même à travers un programme CL appelé par un programme Cobol. Imaginez tout simplement qu'on est dans une cuisine d'un 5 étoiles

[BernardBZH]

Bravo à Hédhili Jaïdane pour son exemple de code clair et précis !! Ça mériterait bien de figurer dans la partie "Contribuez" du forum.

Ça fait longtemps que j'avais vu un tri interne en COBOL. C'est vrai que sur z/OS c'est largement abandonné et c'est toujours une source de sueurs froides quand il faut intervenir dans ce genre de code. Là ça va ce n'est pas énorme mais quand le code fait plusieurs centaines de lignes ...

[Metalman]

Cela fait très longtemps que j'ai fini mon code, et qu'il marche...
Ca ne doit pas être aussi beau que ce que Hedhili proposait, mais je vais quand même mettre mon pitit code...
Je l'ai produit avec vos idées et codes, ainsi qu'un livre emprunté à la bibliothèque de mon université pour débuter en COBOL.

C'est issu évidemment d'un "nouveau" en COBOL qui a surtout généré du C pour le moment !
(les critiques sont évidemment bienvenues ! ^^' mais je ne pense pas pouvoir faire comme Hedhili en terme d'optimisation/efficacité par moi-même pour le moment...)

Code :

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
	IDENTIFICATION DIVISION.
	PROGRAM-ID. DEPENSES.


	ENVIRONMENT DIVISION.
	CONFIGURATION SECTION.
	SOURCE-COMPUTER. PC-I686.
	OBJECT-COMPUTER. PC-I686.

	INPUT-OUTPUT SECTION.
	FILE-CONTROL.
		SELECT BUYER-DATA	ASSIGN TO DISK "DEP-JAN.DAT"
		       ORGANIZATION IS LINE SEQUENTIAL.
		SELECT TOTAL-DATA	ASSIGN TO DISK "TOTAL.DAT"
		       ORGANIZATION IS LINE SEQUENTIAL.
		SELECT SORTED-DATA      ASSIGN TO DISK "SRT-TMP.DAT".
      *		SELECT SORTED-DATA     	ASSIGN TO SYSWORK.
      * SYSWORK = zone de travail "interne" a l OS/COBOL
      * Mais n est pas toujours present sur PC


	DATA DIVISION.
	FILE SECTION.
	FD  BUYER-DATA.
	01  PEOPLE-RECORD.
	    05	NAME-IN			PICTURE X(20).
	    05	MONEY-SPENT-IN		PICTURE 9999V99.
	    05				PICTURE X(1).
	    05	DATE-RECORD.
	    	06  DAY-IN		PICTURE 99.
	    	06  MONTH-IN		PICTURE 99.
	    	06  YEAR-IN		PICTURE 9999.
	SD  SORTED-DATA.
	01  SORTED-RECORD.
	    05	NAME-ST			PICTURE X(20).
	    05	MONEY-SPENT-ST		PICTURE 9(4)V99.
	    05				PICTURE X(1).
	    05	DATE-ST.
	    	06  DAY-ST		PICTURE 99.
		06  MONTH-ST		PICTURE 99.
		06  YEAR-ST		PICTURE 9999.
	FD  TOTAL-DATA.
	01  PRINT-REC.
	    05	NAME-OUT		PICTURE X(20).
	    05				PICTURE X(10).
	    05	TOTAL-OUT		PICTURE ZZZZ.99.

	WORKING-STORAGE SECTION.
	01  ARE-THERE-MORE-RECORDS	PICTURE XXX VALUE 'YES'.
	77  CURRENT-NAME		PICTURE X(20).
	77  CURRENT-SUM			PICTURE 9(4)V99.
	77  CURRENT-AVERAGE		PICTURE 9(4)V99.
	77  CURRENT-AV-ENTRIES		PICTURE 999.
	77  CURRENT-ENTRIES		PICTURE 999.
	01  IS-FIRST-ENTRY		PICTURE XXX VALUE 'YES'.
	    88 NOT-FIRST-ENTRY			    VALUE 'NO '.


	PROCEDURE DIVISION.
	100-MAIN-MODULE.
	    SORT SORTED-DATA ON ASCENDING KEY NAME-ST OF SORTED-RECORD
	    	 USING BUYER-DATA
		 OUTPUT PROCEDURE 200-AFTER-SORT
	    STOP RUN.

	200-AFTER-SORT.
	    MOVE 'YES' TO IS-FIRST-ENTRY
	    OPEN OUTPUT TOTAL-DATA
	    PERFORM UNTIL ARE-THERE-MORE-RECORDS = 'NO'
      * Ceci est un commentaire... COL7 a * == commentaire
      *     	READ SORTED-DATA
      * On ne READ pas un SORT
      	      	RETURN SORTED-DATA
		     AT END
			  MOVE 'NO ' TO ARE-THERE-MORE-RECORDS
			  PERFORM 400-WRITE-SUM-TO-FILE
			  PERFORM 500-TOTAL-AVERAGE-TO-FILE
		     NOT AT END
		     	  PERFORM 300-COUNT-ROUTINE
		END-RETURN
	    END-PERFORM
	    CLOSE TOTAL-DATA.

	300-COUNT-ROUTINE.
      *	    DISPLAY "Name temp : " NAME-ST
      *	    DISPLAY "Money : " MONEY-SPENT-ST
	    IF	IS-FIRST-ENTRY = 'YES'
      *         Premiere iteration, on initialize tout
	    	MOVE NAME-ST TO CURRENT-NAME
		MOVE MONEY-SPENT-ST TO CURRENT-SUM
		MOVE 1 TO CURRENT-ENTRIES CURRENT-AV-ENTRIES
		MOVE 0 TO CURRENT-AVERAGE
		MOVE 'NO ' TO IS-FIRST-ENTRY
	    ELSE
		IF  NAME-ST = CURRENT-NAME
      *             2e iteration ou plus dans un meme bloc de nom
      *		    On ajoute la depense associee
		    ADD MONEY-SPENT-ST TO CURRENT-SUM
		    ADD 1 TO CURRENT-ENTRIES
		ELSE
      *             On change de nom, donc on calcule et on ecrit
		    PERFORM 400-WRITE-SUM-TO-FILE
		    ADD CURRENT-SUM TO CURRENT-AVERAGE
		    ADD 1 TO CURRENT-AV-ENTRIES
      *		    On reinitialize avec le nouveau nom
      		    MOVE NAME-ST TO CURRENT-NAME
		    MOVE MONEY-SPENT-ST TO CURRENT-SUM
		    MOVE 1 TO CURRENT-ENTRIES
		END-IF
	    END-IF.

	400-WRITE-SUM-TO-FILE.
      *     move space permet de mettre les espaces ou il faut
	    MOVE SPACES TO PRINT-REC
	    MOVE CURRENT-NAME TO NAME-OUT
	    MOVE CURRENT-SUM TO TOTAL-OUT
	    WRITE PRINT-REC.

	500-TOTAL-AVERAGE-TO-FILE.
	    ADD CURRENT-SUM TO CURRENT-AVERAGE
	    DIVIDE CURRENT-AV-ENTRIES INTO CURRENT-AVERAGE
	    MOVE "-------------------------------------" TO PRINT-REC
	    WRITE PRINT-REC
	    MOVE SPACES TO PRINT-REC
	    MOVE "TOTAL AVERAGE       " TO NAME-OUT
	    MOVE CURRENT-AVERAGE TO TOTAL-OUT
	    WRITE PRINT-REC.

	END PROGRAM DEPENSES.

[el_slapper]

Y'a toujours moyen de faire mieux(y compris pour moi), mais, franchement si tous les codes dont j'ai à assurer la maintenance étaient de ce niveau, je serais vraiment content.

*Des noms de paragraphe clairs.
*Des noms de variables clairs.
*Une indentation de qualité, qui ne varie pas entre les paragraphes.
*Un seul point par paragraphe.
*Une gestion standardisée des majuscules.

C'est quand même très, très bien.

Les numéros de paragraphe, ça n'est pas obligatoire, mais c'est propre, et ça participe généralement à la standardisation des noms de paragraphe, qui facilite la maintenance. J'aime aussi.

Pour pinailler, je dirais qu'idéalement on place le point de fin de paragraphe tout seul(pour éviter les sueurs froides quand on encapsule tout dans un IF/END-IF) et qu'on aligne les ordres, mais c'est vraiment, vraiment pour pinailler. du genre :

Code :

1
2
3
4
5
6
7
8
	400-WRITE-SUM-TO-FILE.
      *     move space permet de mettre les espaces ou il faut
	    MOVE  SPACES       TO PRINT-REC
	    MOVE  CURRENT-NAME TO NAME-OUT
	    MOVE  CURRENT-SUM  TO TOTAL-OUT
	    WRITE PRINT-REC
	    .

Mais il semblerait que le C soit une très bonne école.

[Metalman]

Je note pour les . tous seuls !
Le C, et le fait que mon école nous a imposé une norme très très stricte pour nos projets m'a habitué à tout aligner...
Mais pour connaitre l'indentation exacte, j'ai essayé de respecter au maximum le livre que je lisais...
Il mettait tout en majuscule, et mettait des numéros pour les paragraphes... donc autant faire comme c'était présenté !

C'est ce livre là que j'ai utilisé :
Stern, Stern, Ley: COBOL for the 21st Century, 11th Edition
Il est un peu "long" et lent quand on a déjà fait pas mal d'impératif... mais les exemples sont clairs...
Heureusement votre forum m'a permis de choisir les bons chapitres à lire ! (pour les tris internes par exemple)