problème d'affichage de résultat d'un code

Version imprimable

1 pièce(s) jointe(s)

bonsoir à tous, lorsque je fait l'exécution de mon code , je n'obtient pas le résultat désirée !!!
voici le code et l'affichage obtenu

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
 
for (int j = 1 ; j <= N; j++)
{
              for (int i = 1; i <= M; i++)
          {
 
            float a = coeffapp();
               dist[j]  += pow((X[j] - W[i][j]),2);
                      W1[j]   = W[i][j] + a*(X[j] - W[i][j]);
                       W2[j]   = W[i][j] - a*(X[j] - W[i][j]);
 
                  }
 
                        if(dist[j]<dmin)
                              Eg = Ep[j];
 
                              dmin = dist[j];
 
                        if(Ep[j] == Ef){
                            Wg[j] = W1[j];
 
                            }
                        else{
                              Wg[j] = W2[j];
 
                              }
printf("distance[%d]= %f\n",j, dist[j]);
printf("distance minimale correspondante au neurone gagnant:%f\n",dmin);
 printf("l'étiquette de neuronne gagnant:%f\n",Eg);
printf(" wg[%d]== %f\n",j, Wg[j]);

Pièce jointe 207524

je veux afficher la matrice distance après il y a une comparaison avec une dist min que je l'initialise de le début, mais la résultat affichée ne donne pas la valeur minimale de la distance , de plus je veux afficher les 2 matrices chacune seul car dans l'affichage ne sont pas ordonnés

21/04/2016, 07h12
sben42

Bonjour,

Cette version là du code ne compile pas.. Il manque une accolade fermante, celle du for (int i = 1; i <= M; i++) je pense.

Ensuite, le dmin = dist[j]; n'est pas conditionné, du coup 'dmin' est écrasé par dist[j] à chaque itération de ta première boucle.. Je ne pense pas que se soit ce que tu veux(veuilles?) faire.

Pour le reste j'attends la bonne version du code pour t'aider à déboguer. Et avec un peu plus de code j'y verrai plus clair ;)

Bon courage!

version complète du code :

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
 
#include <stdio.h>
#include<math.h>
#include <time.h>
#include <stdlib.h>
#include<conio.h>
int N=25 ; /*taille de la couche de sortie */
int M =23; /*taille de la couche d'entrée */
float Eg;
float Ef; /*étiquette de réference */
float a;
float dmin =0.1;
float W1 [25] ;
float W2 [25] ;
float Wg [25] ;
float dist [25] ; /*tableau contient les différentes distances*/
float X [23]={0.4,0.3,0.2,0.1,0.6,0.1,0.5,0.8,0.7,0.4,0.9,0.2,0.3,0.6,0.5,0.4,0.6,0.4,0.7,0.9,0.3,0.2,0.5}; ;/*vecteur d'entrée*/
double W[23][25]= {{0.1,0.4,0.2,0.3,0.5,0.1,0.4,0.3,0.6,0.4,0.7,0.4,0.5,0.8,0.7,0.2,0.5,0.1,0.4,0.1,0.9,0.3,0.2,0.5,0.1},{0.4,0.9,0.2,0.3,0.5,0.1,0.4,0.3,0.6,0.4,0.7,0.4,0.5,0.8,0.7,0.7,0.2,0.5,0.1,0.4,0.4,0.1,0.7,0.6,0.3},{0.1,0.4,0.2,0.3,0.5,0.1,0.4,0.3,0.6,0.4,0.1,0.7,0.4,0.5,0.8,0.9,0.7,0.4,0.5,0.8,0.7,0.6,0.2,0.3,0.5},{0.4,0.9,0.2,0.3,0.5,0.3,0.7,0.4,0.5,0.8,0.4,0.5,0.8,0.7,0.6,0.2,0.5,0.1,0.4,0.1,0.6,0.7,0.5,0.3,0.2},{0.4,0.9,0.9,0.1,0.3,0.3,0.7,0.4,0.5,0.8,0.4,0.1,0.3,0.6,0.3,0.7,0.2,0.5,0.1,0.4,0.3,0.6,0.1,0.5,0.2},{0.1,0.4,0.5,0.8,0.7,0.6,0.4,0.2,0.5,0.1,0.1,0.7,0.4,0.5,0.8,0.9,0.7,0.4,0.5,0.8,0.3,0.8,0.4,0.9,0.5},{0.1,0.4,0.2,0.3,0.5,0.3,0.7,0.4,0.5,0.8,0.4,0.5,0.8,0.7,0.6,0.2,0.5,0.1,0.4,0.1,0.5,0.8,0.6,0.1,0.3},{0.4,0.9,0.1,0.4,0.2,0.1,0.4,0.1,0.3,0.6,0.4,0.5,0.8,0.7,0.4,0.7,0.2,0.5,0.1,0.4,0.2,0.7,0.4,0.1,0.3},{0.1,0.4,0.2,0.3,0.5,0.1,0.4,0.1,0.3,0.6,0.4,0.5,0.8,0.7,0.4,0.9,0.7,0.4,0.5,0.8,0.6,0.5,0.3,0.2,0.1},{0.1,0.4,0.4,0.9,0.2,0.5,0.1,0.4,0.1,0.3,0.4,0.1,0.3,0.6,0.3,0.2,0.5,0.1,0.4,0.1,0.9,0.6,0.3,0.5,0.2},{0.4,0.9,0.9,0.2,0.3,0.2,0.5,0.1,0.4,0.1,0.4,0.1,0.3,0.6,0.3,0.7,0.2,0.5,0.1,0.4},{0.4,0.9,0.2,0.3,0.5,0.5,0.1,0.4,0.1,0.3,0.4,0.5,0.8,0.7,0.4,0.9,0.7,0.4,0.5,0.8,0.3,0.5,0.1,0.2,0.7},{0.1,0.4,0.2,0.3,0.5,0.2,0.5,0.1,0.4,0.1,0.7,0.4,0.5,0.8,0.7,0.2,0.5,0.1,0.4,0.1,0.6,0.8,0.4,0.5,0.3},{0.4,0.2,0.3,0.5,0.9,0.6,0.4,0.2,0.5,0.1,0.7,0.4,0.5,0.8,0.7,0.7,0.2,0.5,0.1,0.4},{0.1,0.4,0.3,0.6,0.4,0.7,0.4,0.5,0.8,0.7,0.1,0.7,0.4,0.5,0.8,0.9,0.7,0.4,0.5,0.8,0.5,0.3,0.9,0.6,0.2},{0.1,0.4,0.1,0.3,0.6,0.7,0.4,0.5,0.8,0.7,0.4,0.5,0.8,0.7,0.6,0.2,0.5,0.1,0.4,0.1,0.5,0.2,0.3,0.7,0.1},{0.4,0.9,0.1,0.3,0.6,0.7,0.4,0.5,0.8,0.7,0.4,0.5,0.8,0.7,0.4,0.7,0.2,0.5,0.1,0.4},{0.4,0.9,0.5,0.8,0.7,0.4,0.5,0.8,0.7,0.6,0.4,0.5,0.8,0.7,0.6,0.9,0.7,0.4,0.5,0.8,0.9,0.4,0.8,0.2,0.1},{0.1,0.4,0.9,0.1,0.3,0.7,0.4,0.5,0.8,0.7,0.4,0.5,0.8,0.7,0.4,0.2,0.5,0.1,0.4,0.1,0.4,0.3,0.2,0.6,0.9},{0.4,0.9,0.1,0.3,0.6,0.3,0.7,0.4,0.5,0.8,0.4,0.5,0.8,0.7,0.4,0.7,0.2,0.5,0.1,0.4},{0.1,0.4,0.1,0.3,0.6,0.3,0.7,0.4,0.5,0.8,0.4,0.1,0.3,0.6,0.3,0.9,0.7,0.4,0.5,0.8,0.5,0.6,0.9,0.4,0.1},{0.1,0.4,0.3,0.6,0.4,0.2,0.5,0.1,0.4,0.1,0.7,0.4,0.5,0.8,0.7,0.2,0.5,0.1,0.4,0.1,0.3,0.8,0.2,0.5,0.7},{0.4,0.9,0.2,0.3,0.5,0.6,0.4,0.2,0.5,0.1,0.7,0.4,0.5,0.8,0.7,0.7,0.2,0.5,0.1,0.4,0.1,0.6,0.4,0.8,0.5}}; /*matrice de poids*/
 
int Ep[25]={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}; /*les etiquettes fixées de la couche de sorite*/
float coeffapp(){
            float f ;
             srand(time(NULL)); // initialise le generateur de maniere aleatoire
             f= rand()/(RAND_MAX+1.0);
 
             return f;
 
}
 int main(){
 
 for (int j = 1 ; j <= N; j++)
{
              for (int i = 1; i <= M; i++)
          {
 
            float a = coeffapp();
               dist[j]  += pow((X[j] - W[i][j]),2);
                      W1[j]   = W[i][j] + a*(X[j] - W[i][j]);
                       W2[j]   = W[i][j] - a*(X[j] - W[i][j]);
          }
 
 
                        if(dist[j]<dmin)  {
                              Eg = Ep[j];
                              dmin = dist[j];
                        }
                        if(Ep[j] == Ef) {
                            Wg[j] = W1[j];}
                        else
                              Wg[j] = W2[j];
 
 
 
 
printf("distance[%d]= %f\n",j, dist[j]);
printf("distance minimale correspondante au neurone gagnant:%f\n",dmin);
 printf("l'étiquette de neuronne gagnant:%f\n",Eg);
printf(" wg[%d]== %f\n",j, Wg[j]);
  }
  getch();
    return 0;
}

21/04/2016, 14h29
Médinoc
Ça fait beaucoup de variables globales, dis donc...

Mais ton problème, c'est cette fonction, appelée en boucle près de 600 fois dans l'exécution du programme (moins d'une seconde):
Code:

1 2 3 4 5 6 float coeffapp() { float f ; srand(time(NULL)); // initialise le generateur de maniere aleatoire f= rand()/(RAND_MAX+1.0); return f; }
Que retourne time(NULL), selon toi?
21/04/2016, 16h27
ThourayaNeji

l'appelle de cette fonction permet de donner à chaque fois une valeur comprise entre 0 et 1 et lorsque j'ai testé cette fonction j'ai obtenu le résultat désiré
en fait , je veux que cette valeur diminue au cours de temps , mais pour le moment je trouve cette fonction comme solution :(:(
21/04/2016, 17h11
Médinoc

Okay, indice numéro deux: time(NULL) retourne un nombre entier de secondes écoulées.
21/04/2016, 18h07
ThourayaNeji

je sais pas qu'est ce que tu veux comprendre :( mais a propos de que je comprend cette instruction srand(time(NULL)) permet de donner à chaque fois une nouvelle valeur et lorsque je remplace time(NULL) par exemple par 0 , la valeur reste constante aussi même j'élimine toute l'instruction :(:(
21/04/2016, 18h12
Médinoc

Que se passe-t-il quand une fonction qui retourne un nombre entier de secondes écoulées est appelée six cents fois dans la même seconde?
21/04/2016, 18h17
ThourayaNeji

je sais pas, mais quelle est la relation entre l'exécution de cette fonction et le résultat obtenu !!!!!!!!!!
21/04/2016, 18h20
ThourayaNeji

est ce qu'il y a d'autres solutions permettent de renvoyer une valeur comprise entre 0 et 1 et décroissante au cours tu temps :(

ELLE RETOURNE SIX CENT FOIS LE MÊME RÉSULTAT!!!!!
Résultat, srand() est sans cesse réglé à la même valeur, ce qui fait que le rand() qui suit retourne toujours la même valeur!
As-tu compris le problème, maintenant?

Et au passage, si tu avais pensé à regarder dans la FAQ de dvp pour le langage C, tu y aurais trouvé le problème et sa solution.

En plus, rand() ne correspond même pas à ton besoin: rand() retourne des valeurs aléatoires, et toi tu veux une valeur décroissante.

Et franchement, c'est assez simple:
Code:

1 2 3 4 5 6 7 8 int i; for(i=0 ; i<NOMBRE_ETAPES ; i++) { int valeurQuiDiminue = NOMBRE_ETAPES - i; double valeurQuiDiminueDe1a0 = valeurQuiDiminue * 1.0 / NOMBRE_ETAPES; /*faire ce que tu veux avec valeurQuiDiminueDe1a0*/ }

21/04/2016, 18h37
ThourayaNeji

merci bien :)
21/04/2016, 20h19
Matt_Houston

Citation:

Envoyé par Médinoc

ELLE RETOURNE SIX CENT FOIS LE MÊME RÉSULTAT!!!!!

J'ai ri. :mrgreen:
21/04/2016, 22h15
ThourayaNeji

:lol::lol::lol:

Matt_Houston, je suis débutante en programmation C comparant à vous