calcul de khi et enregistrements des fichier txt

Version imprimable

1 pièce(s) jointe(s)

Bonjour tout le monde :)
j'ai un programme qui lit 25 fichier txt independants et calcul "khi" pour chaque fichiers, le but c'est d'enregistrer les resultats dans un seul fichier txt a la fin , il est ci dessous, ce que je cherche c'est si j'ai 200 fichier txt, il sera long, est ce que il ya une methode pour le reduire? merci d'avance

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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
 
{
 
 double khi1[10];
 double khi2[10]; 
 double khi3[10],khi4[10],khi5[10],khi6[10],khi7[10],khi8[10],khi9[10],khi10[10],khi11[10];
 double khi24[10],khi12[10],khi13[10],khi14[10],khi15[10],khi16[10],khi17[10],khi18[10],khi19[10],khi20[10],khi21[10],khi22[10],khi23[10],khi25[10];
 double khi11p;
 double  khi21p, khi31,khi41,khi51,khi61,khi71,khi81,khi91,khi101,khi111,khi121;
 double khi131,khi141,khi151,khi161,khi171,khi181,khi191,khi201,khi211,khi221,khi231,khi241,khi251;
 double segexp[10]; 
 double esegmaexp[10];
 ofstream fcoef("../3-root/val.txt");
 ifstream f1(Form("../1-code-dr/fort.0303"));
 ifstream f2(Form("../1-code-dr/fort.0307"));
 ifstream f3(Form("../1-code-dr/fort.0311"));
 ifstream f4(Form("../1-code-dr/fort.0315"));
 ifstream f5(Form("../1-code-dr/fort.0319"));
 ifstream f6(Form("../1-code-dr/fort.0703"));
 ifstream f7(Form("../1-code-dr/fort.0707"));
 ifstream f8(Form("../1-code-dr/fort.0711"));
 ifstream f9(Form("../1-code-dr/fort.0715"));
 ifstream f10(Form("../1-code-dr/fort.0719"));
 ifstream f11(Form("../1-code-dr/fort.1103"));
 ifstream f12(Form("../1-code-dr/fort.1107"));
 ifstream f13(Form("../1-code-dr/fort.1111"));
 ifstream f14(Form("../1-code-dr/fort.1115"));
 ifstream f15(Form("../1-code-dr/fort.1119"));
 ifstream f16(Form("../1-code-dr/fort.1503"));
 ifstream f17(Form("../1-code-dr/fort.1507"));
 ifstream f18(Form("../1-code-dr/fort.1511"));
 ifstream f19(Form("../1-code-dr/fort.1515"));
 ifstream f20(Form("../1-code-dr/fort.1519"));
 ifstream f21(Form("../1-code-dr/fort.1903"));
 ifstream f22(Form("../1-code-dr/fort.1907"));
 ifstream f23(Form("../1-code-dr/fort.1911"));
 ifstream f24(Form("../1-code-dr/fort.1915"));
 ifstream f25(Form("../1-code-dr/fort.1919"));
 ifstream fexp(Form("../../cross-section-q2-05-oct2013/Results/section1.txt"));
 
 double qcm1[10], epsilon1[10], qprimcm1[10], thetacm1[10], phideg1[10], segmaDR1[10],costheta1[10];
 double qcm2[10], epsilon2[10], qprimcm2[10], thetacm2[10], phideg2[10], segmaDR2[10],costheta2[10];
 double qcm3[10], epsilon3[10], qprimcm3[10], thetacm3[10], phideg3[10], segmaDR3[10],costheta3[10];
 double qcm4[10], epsilon4[10], qprimcm4[10], thetacm4[10], phideg4[10], segmaDR4[10],costheta4[10];
 double qcm5[10], epsilon5[10], qprimcm5[10], thetacm5[10], phideg5[10], segmaDR5[10],costheta5[10];
 double qcm6[10], epsilon6[10], qprimcm6[10], thetacm6[10], phideg6[10], segmaDR6[10],costheta6[10];
 double qcm7[10], epsilon7[10], qprimcm7[10], thetacm7[10], phideg7[10], segmaDR7[10],costheta7[10];
 double qcm8[10], epsilon8[10], qprimcm8[10], thetacm8[10], phideg8[10], segmaDR8[10],costheta8[10];
 double qcm9[10], epsilon9[10], qprimcm9[10], thetacm9[10], phideg9[10], segmaDR9[10],costheta9[10];
 double qcm10[10], epsilon10[10], qprimcm10[10], thetacm10[10], phideg10[10], segmaDR10[10],costheta10[10];
 double qcm11[10], epsilon11[10], qprimcm11[10], thetacm11[10], phideg11[10], segmaDR11[10],costheta11[10];
 double qcm12[10], epsilon12[10], qprimcm12[10], thetacm12[10], phideg12[10], segmaDR12[10],costheta12[10];
 double qcm13[10], epsilon13[10], qprimcm13[10], thetacm13[10], phideg13[10], segmaDR13[10],costheta13[10];
 double qcm14[10], epsilon14[10], qprimcm14[10], thetacm14[10], phideg14[10], segmaDR14[10],costheta14[10];
 double qcm15[10], epsilon15[10], qprimcm15[10], thetacm15[10], phideg15[10], segmaDR15[10],costheta15[10];
 double qcm16[10], epsilon16[10], qprimcm16[10], thetacm16[10], phideg16[10], segmaDR16[10],costheta16[10];
 double qcm17[10], epsilon17[10], qprimcm17[10], thetacm17[10], phideg17[10], segmaDR17[10],costheta17[10];
 double qcm18[10], epsilon18[10], qprimcm18[10], thetacm18[10], phideg18[10], segmaDR18[10],costheta18[10];
 double qcm19[10], epsilon19[10], qprimcm19[10], thetacm19[10], phideg19[10], segmaDR19[10],costheta19[10];
 double qcm20[10], epsilon20[10], qprimcm20[10], thetacm20[10], phideg20[10], segmaDR20[10],costheta20[10];
 double qcm21[10], epsilon21[10], qprimcm21[10], thetacm21[10], phideg21[10], segmaDR21[10],costheta21[10];
 double qcm22[10], epsilon22[10], qprimcm22[10], thetacm22[10], phideg22[10], segmaDR22[10],costheta22[10];
 double qcm23[10], epsilon23[10], qprimcm23[10], thetacm23[10], phideg23[10], segmaDR23[10],costheta23[10];
 double qcm24[10], epsilon24[10], qprimcm24[10], thetacm24[10], phideg24[10], segmaDR24[10],costheta24[10];
 double qcm25[10], epsilon25[10], qprimcm25[10], thetacm25[10], phideg25[10], segmaDR25[10],costheta25[10];
 
   for(int i=0; i<10; i++){
     //lecture des fichiers txt
   f1>>qcm1[i]>>epsilon1[i]>>qprimcm1[i]>>thetacm1[i]>>phideg1[i]>>segmaDR1[i];
   f2>>qcm2[i]>>epsilon2[i]>>qprimcm2[i]>>thetacm2[i]>>phideg2[i]>>segmaDR2[i];
   f3>>qcm3[i]>>epsilon3[i]>>qprimcm3[i]>>thetacm3[i]>>phideg3[i]>>segmaDR3[i];
   f4>>qcm4[i]>>epsilon4[i]>>qprimcm4[i]>>thetacm4[i]>>phideg4[i]>>segmaDR4[i];
   f5>>qcm5[i]>>epsilon5[i]>>qprimcm5[i]>>thetacm5[i]>>phideg5[i]>>segmaDR5[i];
   f6>>qcm6[i]>>epsilon6[i]>>qprimcm6[i]>>thetacm6[i]>>phideg6[i]>>segmaDR6[i];
   f7>>qcm7[i]>>epsilon7[i]>>qprimcm7[i]>>thetacm7[i]>>phideg7[i]>>segmaDR7[i];
   f8>>qcm8[i]>>epsilon8[i]>>qprimcm8[i]>>thetacm8[i]>>phideg8[i]>>segmaDR8[i];
   f9>>qcm9[i]>>epsilon9[i]>>qprimcm9[i]>>thetacm9[i]>>phideg9[i]>>segmaDR9[i];
   f10>>qcm10[i]>>epsilon10[i]>>qprimcm10[i]>>thetacm10[i]>>phideg10[i]>>segmaDR10[i];
   f11>>qcm11[i]>>epsilon11[i]>>qprimcm11[i]>>thetacm11[i]>>phideg11[i]>>segmaDR11[i];
   f12>>qcm12[i]>>epsilon12[i]>>qprimcm12[i]>>thetacm12[i]>>phideg12[i]>>segmaDR12[i];
   f13>>qcm13[i]>>epsilon13[i]>>qprimcm13[i]>>thetacm13[i]>>phideg13[i]>>segmaDR13[i];
   f14>>qcm14[i]>>epsilon14[i]>>qprimcm14[i]>>thetacm14[i]>>phideg14[i]>>segmaDR14[i];
   f15>>qcm15[i]>>epsilon15[i]>>qprimcm15[i]>>thetacm15[i]>>phideg15[i]>>segmaDR15[i];
   f16>>qcm16[i]>>epsilon16[i]>>qprimcm16[i]>>thetacm16[i]>>phideg16[i]>>segmaDR16[i];
   f17>>qcm17[i]>>epsilon17[i]>>qprimcm17[i]>>thetacm17[i]>>phideg17[i]>>segmaDR17[i];
   f18>>qcm18[i]>>epsilon18[i]>>qprimcm18[i]>>thetacm18[i]>>phideg18[i]>>segmaDR18[i];
   f19>>qcm19[i]>>epsilon19[i]>>qprimcm19[i]>>thetacm19[i]>>phideg19[i]>>segmaDR19[i];
   f20>>qcm20[i]>>epsilon20[i]>>qprimcm20[i]>>thetacm20[i]>>phideg20[i]>>segmaDR20[i];
   f21>>qcm21[i]>>epsilon21[i]>>qprimcm21[i]>>thetacm21[i]>>phideg21[i]>>segmaDR21[i];
   f22>>qcm22[i]>>epsilon22[i]>>qprimcm22[i]>>thetacm22[i]>>phideg22[i]>>segmaDR22[i];
   f23>>qcm23[i]>>epsilon23[i]>>qprimcm23[i]>>thetacm23[i]>>phideg23[i]>>segmaDR23[i];
   f24>>qcm24[i]>>epsilon24[i]>>qprimcm24[i]>>thetacm24[i]>>phideg24[i]>>segmaDR24[i];
   f25>>qcm25[i]>>epsilon25[i]>>qprimcm25[i]>>thetacm25[i]>>phideg25[i]>>segmaDR25[i];
 
   //cout<<qcm1[i]<<epsilon1[i]<<qprimcm1[i]<<thetacm1[i]<<phideg1[i]<<segmaDR1[i]<<endl;
   fexp>>segexp[i]>>esegmaexp[i];
 
   //calcul de Khi2 pour chaque points de sigma
  khi1[i]=((segexp[i]-segmaDR1[i])*(segexp[i]-segmaDR1[i]))/(esegmaexp[i]*esegmaexp[i]);
  khi2[i]=((segexp[i]-segmaDR2[i])*(segexp[i]-segmaDR2[i]))/(esegmaexp[i]*esegmaexp[i]);
  khi3[i]=((segexp[i]-segmaDR3[i])*(segexp[i]-segmaDR3[i]))/(esegmaexp[i]*esegmaexp[i]);
  khi4[i]=((segexp[i]-segmaDR4[i])*(segexp[i]-segmaDR4[i]))/(esegmaexp[i]*esegmaexp[i]);
  khi5[i]=((segexp[i]-segmaDR5[i])*(segexp[i]-segmaDR5[i]))/(esegmaexp[i]*esegmaexp[i]);
  khi6[i]=((segexp[i]-segmaDR6[i])*(segexp[i]-segmaDR6[i]))/(esegmaexp[i]*esegmaexp[i]);
  khi7[i]=((segexp[i]-segmaDR7[i])*(segexp[i]-segmaDR7[i]))/(esegmaexp[i]*esegmaexp[i]);
  khi8[i]=((segexp[i]-segmaDR8[i])*(segexp[i]-segmaDR8[i]))/(esegmaexp[i]*esegmaexp[i]);
  khi9[i]=((segexp[i]-segmaDR9[i])*(segexp[i]-segmaDR9[i]))/(esegmaexp[i]*esegmaexp[i]);
  khi10[i]=((segexp[i]-segmaDR10[i])*(segexp[i]-segmaDR10[i]))/(esegmaexp[i]*esegmaexp[i]);
  khi11[i]=((segexp[i]-segmaDR11[i])*(segexp[i]-segmaDR11[i]))/(esegmaexp[i]*esegmaexp[i]);
  khi12[i]=((segexp[i]-segmaDR12[i])*(segexp[i]-segmaDR12[i]))/(esegmaexp[i]*esegmaexp[i]);
  khi13[i]=((segexp[i]-segmaDR13[i])*(segexp[i]-segmaDR13[i]))/(esegmaexp[i]*esegmaexp[i]);
  khi14[i]=((segexp[i]-segmaDR14[i])*(segexp[i]-segmaDR14[i]))/(esegmaexp[i]*esegmaexp[i]);
  khi15[i]=((segexp[i]-segmaDR15[i])*(segexp[i]-segmaDR15[i]))/(esegmaexp[i]*esegmaexp[i]);
  khi16[i]=((segexp[i]-segmaDR16[i])*(segexp[i]-segmaDR16[i]))/(esegmaexp[i]*esegmaexp[i]);
  khi17[i]=((segexp[i]-segmaDR17[i])*(segexp[i]-segmaDR17[i]))/(esegmaexp[i]*esegmaexp[i]);
  khi18[i]=((segexp[i]-segmaDR18[i])*(segexp[i]-segmaDR18[i]))/(esegmaexp[i]*esegmaexp[i]);
  khi19[i]=((segexp[i]-segmaDR19[i])*(segexp[i]-segmaDR19[i]))/(esegmaexp[i]*esegmaexp[i]);
  khi20[i]=((segexp[i]-segmaDR20[i])*(segexp[i]-segmaDR20[i]))/(esegmaexp[i]*esegmaexp[i]);
  khi21[i]=((segexp[i]-segmaDR21[i])*(segexp[i]-segmaDR21[i]))/(esegmaexp[i]*esegmaexp[i]);
  khi22[i]=((segexp[i]-segmaDR22[i])*(segexp[i]-segmaDR22[i]))/(esegmaexp[i]*esegmaexp[i]);
  khi23[i]=((segexp[i]-segmaDR23[i])*(segexp[i]-segmaDR23[i]))/(esegmaexp[i]*esegmaexp[i]);
  khi24[i]=((segexp[i]-segmaDR24[i])*(segexp[i]-segmaDR24[i]))/(esegmaexp[i]*esegmaexp[i]);
  khi25[i]=((segexp[i]-segmaDR25[i])*(segexp[i]-segmaDR25[i]))/(esegmaexp[i]*esegmaexp[i]);
 
 }
 
// calcul de Khi2 somme
    for(int i=0; i<10; i++){
    khi11p +=khi1[i];
    khi21p +=khi2[i];
    khi31 +=khi3[i];
    khi41 +=khi4[i];
    khi51 +=khi5[i];
    khi61 +=khi6[i];
    khi71 +=khi7[i];
    khi81 +=khi8[i];
    khi91 +=khi9[i];
    khi101 +=khi10[i];
    khi111 +=khi11[i];
    khi121 +=khi12[i];
    khi131 +=khi13[i];
    khi141 +=khi14[i];
    khi151 +=khi15[i];
    khi161 +=khi16[i];
    khi171 +=khi17[i];
    khi181 +=khi18[i];
    khi191 +=khi19[i];
    khi201 +=khi20[i];
    khi211 +=khi21[i];
    khi221 +=khi22[i];
    khi231 +=khi23[i];
    khi241 +=khi24[i];
    khi251 +=khi25[i];
    //cout<<khi1[i]<<endl; 
 
 }
//remplissage de fechier txt "out"
  cout<<khi11p<<endl;// j'ajoute p ici si car j'ai un tableau a le mem nom que khi11
  fcoef<<khi11p<<endl;
  fcoef<<khi21p<<endl;
  fcoef<<khi31<<endl;
  fcoef<<khi41<<endl;
  fcoef<<khi51<<endl;
  fcoef<<khi61<<endl;
  fcoef<<khi71<<endl;
  fcoef<<khi81<<endl;
  fcoef<<khi91<<endl;
  fcoef<<khi101<<endl;
  fcoef<<khi111<<endl;
  fcoef<<khi121<<endl;
  fcoef<<khi131<<endl;
  fcoef<<khi141<<endl;
  fcoef<<khi151<<endl;
  fcoef<<khi161<<endl;
  fcoef<<khi171<<endl;
  fcoef<<khi181<<endl;
  fcoef<<khi191<<endl;
  fcoef<<khi201<<endl;
  fcoef<<khi211<<endl;
  fcoef<<khi221<<endl;
  fcoef<<khi231<<endl;
  fcoef<<khi241<<endl;
  fcoef<<khi251<<endl;
 
 
}

Salut,

Tu sais que tu peux utiliser des tableaux à deux dimensions ? Et faire des doubles boucles ?

Par exemple :
Tu peux déclarer tes doubles khixx comme ceci :

Code:

double khi[25][10];

25 : nombre de khi
10 : nombre d'élément dans chaque khi

Et tu peux faire tes calculs dans des doubles boucles comme ceci :
Code:

1 2 3 4 5 6 7 8 9 int i =0; int y=0; for(i=0;i <25; i++) { for(y=0;y < 10; y++) { khi[i][y]=((segexp[i][y]-segmaDR1[i][y])*(segexp[i][y]-segmaDR1[i][y]))/(esegmaexp[i][y]*esegmaexp[i][y]); } }
Même chose, tu peux ici remplacer :
Code:

1 2 3 double khi11p; double khi21p, khi31,khi41,khi51,khi61,khi71,khi81,khi91,khi101,khi111,khi121; double khi131,khi141,khi151,khi161,khi171,khi181,khi191,khi201,khi211,khi221,khi231,khi241,khi251;
Par

Code:

double khi11p[25];

Et à chaque fois, manipuler dans des boucles et faire tes traitements réguliers. Pense bien que dès que tu vois un code pâté comme ça et répété, il y a toujours moyen de l'optimiser et d'écrire le moins de code possible.

Fais des fonctions pour séparer si tu sais comment faire, ça aide aussi à ta compréhension et à l'organisation.

Déjà ça fera du vide. J’espère avoir bien compris ta question :)

1 pièce(s) jointe(s)

Oui merci et vous avez bien compris ma question, j'ai déjà commencé à l'appliquer, mais le problème est que j'ai 25 fichiers .txt. Je veux les lire avec une boucle j'essaye comme suit mais ça marche pas, je crois qu'il me faut un tableau à trois dimensions, mais je n'arrive pas à trouver le chemin.
Encore merci pour votre réponse

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
{
 
    double khi[25][10];
    double f[25];
    double khi11p[25];
    double segexp[10]; 
    double esegmaexp[10];
    ofstream fcoef("../3-root/val.txt");
    ifstream f1(Form("../1-code-dr/fort.0303"));
    ifstream f2(Form("../1-code-dr/fort.0307"));
    ifstream f3(Form("../1-code-dr/fort.0311"));
    ifstream f4(Form("../1-code-dr/fort.0315"));
    ifstream f5(Form("../1-code-dr/fort.0319"));
    ifstream f6(Form("../1-code-dr/fort.0703"));
    ifstream f7(Form("../1-code-dr/fort.0707"));
    ifstream f8(Form("../1-code-dr/fort.0711"));
    ifstream f9(Form("../1-code-dr/fort.0715"));
    ifstream f10(Form("../1-code-dr/fort.0719"));
    ifstream f11(Form("../1-code-dr/fort.1103"));
    ifstream f12(Form("../1-code-dr/fort.1107"));
    ifstream f13(Form("../1-code-dr/fort.1111"));
    ifstream f14(Form("../1-code-dr/fort.1115"));
    ifstream f15(Form("../1-code-dr/fort.1119"));
    ifstream f16(Form("../1-code-dr/fort.1503"));
    ifstream f17(Form("../1-code-dr/fort.1507"));
    ifstream f18(Form("../1-code-dr/fort.1511"));
    ifstream f19(Form("../1-code-dr/fort.1515"));
    ifstream f20(Form("../1-code-dr/fort.1519"));
    ifstream f21(Form("../1-code-dr/fort.1903"));
    ifstream f22(Form("../1-code-dr/fort.1907"));
    ifstream f23(Form("../1-code-dr/fort.1911"));
    ifstream f24(Form("../1-code-dr/fort.1915"));
    ifstream f25(Form("../1-code-dr/fort.1919"));
    ifstream fexp(Form("../../cross-section-q2-05-oct2013/Results/section1.txt"));
 
    double qcm1[10][25], epsilon1[10][25], qprimcm1[10][25], thetacm1[10][25], phideg1[10][25], segmaDR1[10][25],costheta1[10][25];
 
 
    for(int j=0; j<25; j++){
        f1>>f[0];
        f1>>f[1];
        f1>>f[2];
        f1>>f[3];
        f1>>f[4];
        f1>>f[5];
        f1>>f[6];
        f1>>f[7];
        f1>>f[8];
        f1>>f[9];
        f1>>f[10];
        f1>>f[11];
        f1>>f[12];
        f1>>f[13];
        f1>>f[14];
        f1>>f[15];
        f1>>f[16];
        f1>>f[17];
        f1>>f[18];
        f1>>f[19];
        f1>>f[20];
        f1>>f[21];
        f1>>f[22];
        f1>>f[23];
        f1>>f[24];
 
    }
 
    for(j=0; j<25; j++){
        for(int i=0; i<10; i++){
 
            //lecture des fichiers txt
            f[j]>>qcm1[i][j]>>epsilon1[i][j]>>qprimcm1[i][j]>>thetacm1[i][j]>>phideg1[i][j]>>segmaDR1[i][j];
            fexp>>segexp[i]>>esegmaexp[i];
 
            //calcul de Khi2 pour chaque points de sigma
            khi[i][j]=((segexp[i][j]-segmaDR1[i][j])*(segexp[i][j]-segmaDR1[i][j]))/(esegmaexp[i][j]*esegmaexp[i][j]);
 
    }}
 
 
 
 // calcul de Khi2 somme
    for(int j=0; j<10; j++){
        for(int i=0; i<25; i++){
            khi11p[i] +=khi[i][j];
    }}
 
//remplissage de fechier txt "out"
 
    for(int i=0; i<25; i++){ fcoef<<khi11p[i]<<endl;}
 
}

17/10/2013, 17h43
white_tentacle
Tu ne pourras pas avoir 25 flux de fichiers différents (dans 25 variables différentes) et itérer dessus dans une boucle.

Pour itérer, il te faut… un tableau de tes 25 flux. Mais c’est plutôt une mauvaise idée si le traitement est séquentiel.

Une meilleure idée est de faire quelque chose comme :
Code:

1 2 3 4 5 char[25][40] input_files = { "../1-code-dr/fort.0303", "../1-code-dr/fort.0307", … };
Cela te déclare un tableau de 25 éléments contenant les chemins de tes fichiers d’entrée. Là, tu vas pouvoir appeler, pour chacun, une fonction dont le rôle est de calculer le khi de ce fichier.
17/10/2013, 21h43
therwald

c++ <-> std::vector<std::string>?
18/10/2013, 08h50
white_tentacle

Citation:

Envoyé par therwald

c++ <-> std::vector<std::string>?

Si on dispose d’un compilateur c++11, oui :ccool:

Sinon, on ne peut pas utiliser la déclaration sous forme de { "fichier1", "fichier2", … } ce qui du coup rend l’écriture plus lourde qu’avec un tableau de char*.
18/10/2013, 10h06
therwald

Ceci dit, là je vois un programme où la liste des fichiers est codée en dur, or mimo1213 parlait dans son premier post d'arriver à 200 fichiers, j'en déduit que la liste n'est pas fixe?
Il faut peut-être chercher par là pour déterminer par le calcul la liste des noms de fichiers, puis faire une boucle dessus. Du coup, on n'a plus besoin d'initialisation statique. Par ailleurs, ça évite d'ouvrir simultanément tous les fichiers alors qu'on y accède l'un après l'autre. Ouvrir tous les fichiers en même temps peut poser un problème si le nombre augmente...

@mimo1213: tu prends tous les fichiers fort.xxx d'un dossier?
18/10/2013, 10h23
white_tentacle

Citation:

Envoyé par therwald

Ceci dit, là je vois un programme où la liste des fichiers est codée en dur, or mimo1213 parlait dans son premier post d'arriver à 200 fichiers, j'en déduit que la liste n'est pas fixe?
Il faut peut-être chercher par là pour déterminer par le calcul la liste des noms de fichiers, puis faire une boucle dessus. Du coup, on n'a plus besoin d'initialisation statique. Par ailleurs, ça évite d'ouvrir simultanément tous les fichiers alors qu'on y accède l'un après l'autre. Ouvrir tous les fichiers en même temps peut poser un problème si le nombre augmente...

Je suis bien d’accord, mais chaque chose en son temps :).

D’abord, réarchitecturer le traitement pour que le calcul de khi se fasse sur un fichier individuel, pris en argument d’une fonction, et renvoie le résultat.

Ensuite, faire en sorte que l’appel à ce traitement soit fait dans une boucle itérant sur la liste des fichiers, et pas par n appels successifs.

Et enfin, effectivement, récupérer la liste des fichiers dynamiquement mais pas en dur dans le code.

Chacune de ces étapes est indispensable pour arriver à un bon code, mais il est tout aussi indispensable de les faire dans l’ordre, vouloir brûler les étapes ne fera que rajouter de la complexité et de la confusion.

Donc tant que la première étape (faire une fonction qui calcule le khi pour un fichier) n’est pas effectuée, la liste des fichiers en dur dans le code est loin d’être la priorité.
18/10/2013, 10h33
therwald

Citation:

Envoyé par white_tentacle

Chacune de ces étapes est indispensable pour arriver à un bon code, mais il est tout aussi indispensable de les faire dans l’ordre, vouloir brûler les étapes ne fera que rajouter de la complexité et de la confusion.

Donc tant que la première étape (faire une fonction qui calcule le khi pour un fichier) n’est pas effectuée, la liste des fichiers en dur dans le code est loin d’être la priorité.

C'est pas faux! (mais non, y'a pas de mot que je comprends pas ;) )
18/10/2013, 13h15
mimo1213

1 pièce(s) jointe(s)

Citation:

Envoyé par therwald

C'est pas faux! (mais non, y'a pas de mot que je comprends pas ;) )

je voulais tout d'abord vous remercier tous, j'arrive enfin a exucuter mon programme, il est ci joint, je lis mes fichiers et fais mes calcul et a la fin faire sortir mon fichier txt