Est-il possible d'obtenir une valeur "exacte" ? - page 2

[Alexandr Bryzgalov]

mais cette valeur

0.099999999

retournera 0,1

)

[Alexandr Bryzgalov]

alors ce qui a été cité plus haut serait plus approprié à la tâche du CT :

void OnStart()
  {
//---
   int DIGITS=2;
   string stroka=DoubleToString(0.099999999,8);
   int P=StringFind(stroka,".");
   Print(stroka);
   stroka=StringSubstr(stroka,0,P+DIGITS+1);
   Print(StringToDouble(stroka));
   Print(NL(DIGITS,0.099999999));
   
  }
//+------------------------------------------------------------------+
double NL (int DIGITS,double value) {
   double step=1/MathPow(10,DIGITS);
   return (MathFloor(value/step)*step);
}

Les retours :

2014.10.04 11:42:31.856 normalize EURUSD,H4: 0.09
2014.10.04 11:42:31.856 normalize EURUSD,H4: 0.1
2014.10.04 11:42:31.856 normalize EURUSD,H4: 0.10000000

[[Supprimé]]

J'ai esquissé une fonction qui fait exactement ce que je veux qu'elle fasse : elle tronque précisément une chaîne de caractères à la précision spécifiée , contrairement à DoubleToStr:

string Normalize (string Normalize_Parse, int Normalize_Number, string Normalize_Separator = ".")
{
   string Normalize_Before,
          Normalize_After;
   
   for (int i = 0; i <= StringLen (Normalize_Parse) - 1; i ++)
   {
      if (StringSubstr (Normalize_Parse, i, StringLen (Normalize_Separator)) == Normalize_Separator)
      {
         for (int ii = i + StringLen (Normalize_Separator); ii < i + StringLen (Normalize_Separator) + Normalize_Number; ii ++)
         {
            Normalize_After += StringSubstr (Normalize_Parse, ii, 1);
         }
         
         break;
      }
      
      Normalize_Before += StringSubstr (Normalize_Parse, i, 1);
   }
   
   return (Normalize_Before + (Normalize_After > 0 ? Normalize_Separator + Normalize_After : ""));
}

Résultat pour "0.09864724" :

Comment (Normalize (0.09864724, 2)); // 0.09

Résultat pour"0,-843158":

Comment (Normalize ("0,-843158", 3, ",-")); // 0,-843

Opérations avec double et similaire :

Comment ((double) Normalize (0.09, 2) * 5); // 0.45

J'ai fait des recherches et une telle fonction existe déjà dans MQL4 (5 ?). S'il n'est pas là, pourquoi ne pas l'avoir ajouté il y a longtemps ? :)

[Alexandr Bryzgalov]

WePlexus:

J'ai esquissé une fonction qui fait exactement ce que je veux qu'elle fasse : elle tronque précisément une chaîne de caractères à la précision spécifiée , contrairement à DoubleToStr:

Résultat pour "0.09864724" :

Résultat pour"0,-843158":

Opérations avec double et similaire :

J'ai fait des recherches et une telle fonction existe déjà dans MQL4 (5 ?). S'il n'est pas là, pourquoi ne pas l'avoir ajouté il y a longtemps ? :)

c'est ce que j'appelle "plus facile" )

[Andrey F. Zelinsky]

WePlexus:

J'ai esquissé une fonction qui fait exactement ce que je veux qu'elle fasse : elle tronque précisément une chaîne de caractères à la précision spécifiée , contrairement à DoubleToStr:

Résultat pour "0.09864724" :

Résultat pour"0,-843158":

Opérations avec double et similaire :

J'ai fait des recherches et une telle fonction existe déjà dans MQL4 (5 ?). S'il n'est pas là, pourquoi ne pas l'avoir ajouté il y a longtemps ? :)

Vous opérez avec des exemples étranges - c'est pourquoi il est impossible de conclure que votre fonction fonctionne correctement.

Prenez cet exemple :

comment laisser =0,019999999999999999999999 -- laisser =0,01

[Alexandr Bryzgalov]

abolk:
Vous opérez avec des exemples hors de propos - vous ne pouvez donc pas conclure que votre fonction fonctionne correctement.

Prenez cet exemple :

comment laisser =0,019999999999999999999999 -- laisser =0,01

a vérifié la dernière fonction, il laisse 0.01.

[Petros Shatakhtsyan]

Je ne comprends toujours pas ce que vous voulez.

Si vous voulez voir 0,098 sur le graphique au lieu de 0,098, alors faites-le !

int a=0.098 * 100 ;

double d=a/100.0 ;

Commentaire(StringFormat("%G", d ) ;

[Andrey F. Zelinsky]

sanyooooook:
a vérifié la dernière fonction, laisse 0.01

Vérifié votre fonction -- laisse 0.02

[[Supprimé]]

abolk:
J'ai vérifié votre fonction... elle laisse 0,02.

En effet, 0,02.

Ma fonction est peut-être plus encombrante, mais elle coupe exactement 0,01.

[[Supprimé]]

sanyooooook:
a vérifié la dernière fonction, laisse 0.01

Comment optimiser votre fonction pour retirer 0,01 de l'exemple de l'abolk?