Discussion :

[JM12345]

Bonjour,

J'ai un bug que je n'arrive pas à corriger car ce n'est pas mon code à la base.

Voilà le problème :

J'ai un opérateur Delta qui calcule la différence entre 2 valeurs consécutives d'un paramètre FRAME qui incrémente de 1 à chaque fois.
Le problème est que si je calcule le résultat des 2 paramètres a et b :
A = (+ (DELTA FRAME) (DELTA FRAME)(DELTA FRAME))
B = (DELTA (+ FRAME FRAME FRAME))

Le problème est que lorsque je lance mon programme :

J'obtient :
FRAME=0 ; a=X ; b=X puis
FRAME=1 ; a=X ; b=3 puis
FRAME=2 ; a=X ; b=3 puis
FRAME=3 ; a=3 ; b=3

La question est : Pourquoi l'écriture du paramètre A a besoin de 3 incrémentations du FRAME pour donner un résultat alors que le paramètre B non ?


Voilà le code en question:

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
double Delta::evalue(DecomBoolean temps_reel, unsigned char& erreur)
{
  double valeur;
  double result = 0;
 
  valeur= argument->evalue(temps_reel, erreur);
  /*  on sélectionne les variables concernées */
  if (IsRealTime(temps_reel))
    traitement_d(ancienne_erreur, ancienne_valeur, valeur, result, erreur);
  else
    traitement_d(ancienne_erreurdiff, ancienne_valeurdiff, valeur, result, erreur);
  return result;
}
 
 
void traitement_d(int& une_erreur, double& une_valeur, double& valeur, double& result, unsigned char& erreur)
{
  if (erreur == 0)
    {
      if (une_erreur == 0)
	/*  si il n'y a pas d'erreur cette fois ci et la fois précédente  */
	result = valeur - une_valeur;
      else 
	{
	  /*  si le traitement précédent était invalide  */
	  une_erreur= 0;
	  erreur= 1;
	}
      une_valeur= valeur;
    }
  else 
    une_erreur= 1;
}
 
 
void calcule(unsigned char& erreur, TArbre p, double& resultat, double temp, DecomBoolean temps_reel)
{
  if (erreur == 0)
    {
      temp= p->evalue(temps_reel, erreur);
      if (erreur == WITHOUT_ERROR)
		resultat= resultat + temp;
      else
		resultat= 0;
    }
}
 
const char *Somme::ClassName()
 {return "TSomme";}
 
 
double Somme::evalue(DecomBoolean temps_reel, unsigned char& erreur)
{
  double resultat;
  double temp=0;
  int i;
  double result = 0;
 
  resultat= 0;
 
  for (i= 0;(i <= (arguments->Count - 1));i++)
    calcule(erreur, TArbre(arguments->items(i)), resultat, temp, temps_reel);
  if (erreur == WITHOUT_ERROR)
    result= resultat;
  else
    result= 0;
 
  return result;
}

Merci bien d'avance pour toute l'aide que vous pouvez m'apporter

[AurelienTran]

Bonjour,

J'ai un opérateur Delta qui calcule la différence entre 2 valeurs consécutives d'un paramètre FRAME qui incrémente de 1 à chaque fois.
Le problème est que si je calcule le résultat des 2 paramètres a et b :
A = (+ (DELTA FRAME) (DELTA FRAME)(DELTA FRAME))
B = (DELTA (+ FRAME FRAME FRAME))

Le problème est que lorsque je lance mon programme :

J'obtient :
FRAME=0 ; a=X ; b=X puis
FRAME=1 ; a=X ; b=3 puis
FRAME=2 ; a=X ; b=3 puis
FRAME=3 ; a=3 ; b=3

Les information que tu nous donnes n'est pas franchement compréhensible...

FRAME = incrémente de 1 à chaque fois
Delta = différence entre deux valeur consécutives de FRAME cela signifie-t-il que Delta vaut toujours 1 (étant donnée que FRAME incrémente toujours de 1)?

DELTA FRAME = Delta * Frame ???
A = DELTA FRAME + DELTA FRAME + ...

Ici c'est un forum de C++, donc si ce serait plus compréhensible si tu prenais
les notations du C++ pour écrire tes formules (ou pseudo code)

a=X ; b=X <- la non plus je comprends pas beaucoup

Pour ce qui est du source code... il y a des classe a gogo (Somme, Delta...), pas de header de ces classe (donc pour comprendre les relations entre celle ci ainsi que les différent attribut de la classe).

Si tu reformules plus clairement ton problème en y intégrant les bout de codes qui concerne ton bug (soit le calcul de a et b). ça pourrait nous être utile.

Bye