je vois pas la différence entre ces 2 codes
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:
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:
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();
}
}
} |
