Discussion :

[membreComplexe12]

Salut tous,

j'ai un ami qui m'a donné un bout de code pour effectuer une certaine opération sur les données "d'une famille". Je dois réutiliser ce code pour qu'il fonctionne pour "i" familles (et qu'il soit adapté à notre nouvelle implementation).

1°) Mon probleme:
A priori c'est facile mais quand je me mets dans le cas "i=1" (cas le plus simple) je me rends compte que mes resutats sont faux: je ne retrouve pas ses resultats donc mon implementation est différente de la sienne (donc pour les cas où "i" est différent de 1 alors c'est faux aussi).

2°) Ma question:
pourriez vous regardez les codes si dessous et me dire si vous voyer une différence entre les 2 car moi je n'en voit pas...

petite precision:
=> le but de ce bout de code et de reclasser des données et en insérant des données au milieu de celles existantes
=> on va réarranger deux vecteurs "R" et "Nb" (qui ont la même taille)
=> dans mon code ce sont des vecteurs à deux dimensions, pour chaque famille "i" on a un vecteur "R" et un "Nb"

Son code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
void maClasse::maMethode(double Nb_D)
{
        int n=1;
        if(taille()>2)
        {
                miseAjour();
		//--------------------------------------------------------------------------------
		//recherche du min et max et chargement de F
		//--------------------------------------------------------------------------------
                double minR=1e30;
                double maxR=1e-30;
                for(int L=0;L<taille();L++)
                {
                    if(R[L]<minR)
		    {
	                 minR=R[L];
		    }
                    if(R[L]>maxR)
		    {
			maxR=R[L];
		    }
                }
		double AncienF=F;
		//--------------------------------------------------------------------------------
		//modification du classement
		//--------------------------------------------------------------------------------
                do
                {
                        double NouveauRNmoins1, NouveauNbNmoins1, NouveauRN;
                        double NouveauNbN, NouveauRNplus1, NouveauNbNplus1;
 
                        if(fabs(R[n-1]-R[n])>2.0*(maxR-minR)/Nb_D)
                        {
 
                        n++;
                        }
                        n++;
                }while(n<taille()-2);
		//--------------------------------------------------------------------------------
		//mise à jour
		//--------------------------------------------------------------------------------
                miseAjour();
                double NouvelleF=F();
		//--------------------------------------------------------------------------------
		//dernier calcul
		//--------------------------------------------------------------------------------
                for(int z=0;z<taille();z++)
                        Nb[z]=Nb[z]*AncienF/NouvelleF;
                miseAjour();
        }
}

Mon code (je fais la même chose mais pour chaque famille "i":

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
void maClasse::maMethode(double Nb_D,Class2 &monObjet)
{
   monObjet.miseAjour();
   //-------------------------------------------------------------------------------
   //initialisation specifique à mon code
   //-------------------------------------------------------------------------------
    vector <double> minR;
    vector <double> maxR;
    minR.clear();
    maxR.clear();
    vector <double> ancienF;
    vector <double> nouveauF;
    ancienF.clear();
    nouveauF.clear();
    //--------------------------------------------------------------------------------
    //recherche du min et max (et chargement de F)
    //--------------------------------------------------------------------------------
    //on charge nos vecteur à deux dimensions
    Nb.clear();
    R.clear();
    Nb=monObjet.getNb();
    R=monObjet.getR();
    //la recherche du min et max peut commencer
    for (int i=0;i<monObjet.get_nombreFamilles();i++)
    {
        //---------------------------------------
        int L=0;
        minR.push_back(1.0e30);
        maxR.push_back(1.0e-30);
        ancienF.push_back(monObjet.get_F(i));
        //----------------------------------------
        while (L<monObjet.get_taille(i))
        {
            if (R[i][L]>maxR[i])
            {
                maxR[i]=R[i][L];
            }
            if (R[i][L]<minR[i])
            {
                minR[i]=R[i][L];
            }
            L=L+1;
        }
    }
    //--------------------------------------------------------------------------------
    //modification du classement
    //--------------------------------------------------------------------------------
    for (int i=0;i<monObjet.get_nombreFamilles();i++)
    {
        int n=1;
        if (monObjet.get_taille(i)>2)
        {
            while(n<monObjet.get_taille(i)-2)
            {
 
                double NouveauRNmoins1=0.0,NouveauNbNmoins1=0.0,NouveauRN=0.0;
                double NouveauNbN=0.0,NouveauRNplus1=0.0,NouveauNbNplus1=0.0;
                double maxR=maxR[i], minR=minR[i];
 
                if(fabs(R[i][n-1]-R[i][n])>(2.0*maxR-2.0*minR)/Nb_D)
                {
 
                    n=n+1;
                }
                n=n+1;
            }
            //--------------------------------------------------------------------------------
	    //mise à jour
	    //--------------------------------------------------------------------------------
            monObjet.miseAjour();
			monObjet.keep(Nb,R);
 
            nouveauF.push_back(i);
            nouveauF[i]=monObjet.get_F(i);
            //--------------------------------------------------------------------------------
	    //dernier calcul
	    //--------------------------------------------------------------------------------
            for (int z=0;z<monObjet.get_taille(i);z++)
            {
                Nb[i][z]=Nb[i][z]*(ancienF[i]/nouveauF[i]);
            }
            monObjet.keep(Nb,R);
            monObjet.miseAjour();
        }
    }
	}

[oxyde356]

J'ai bien rigolé en lisant ton topic tellement que le sujet et le code sont incompréhensibles
J'imagine qu'une """famille""" (je sais pas combien de guillemets il faut que je mette) est une structure définit dans une convention ratifiée par les signataires de la charte des nations unies un truc du genre

Reprends de zéro

[membreComplexe12]

je vais tous reprendre, merci quand meme

A+