Toute question des nouveaux arrivants sur MQL4 et MQL5, aide et discussion sur les algorithmes et les codes. - page 106
Vous manquez des opportunités de trading :
- Applications de trading gratuites
- Plus de 8 000 signaux à copier
- Actualités économiques pour explorer les marchés financiers
Inscription
Se connecter
Vous acceptez la politique du site Web et les conditions d'utilisation
Si vous n'avez pas de compte, veuillez vous inscrire
Veuillez me conseiller sur une solution au problème d'arrondi !
J'ai besoin de me débarrasser du point décimal sans reste - l'arrondi et l'exponentiation ne résolvent pas tout le problème - que dois-je faire ?
Par exemple, il était de 1.44430 et j'ai besoin de 144430.
Une partie du code - tel quel
NormalizeDouble(Low[1],Digits)*MathPow(10,(Digits+1)*1-1)
Il suffit de diviser par _Point.
Le résultat imprimé est incorrect, l'original est 161188 (1.61188) Votre méthode 161187 print donne 1.6119 (pourquoi l'arrondi est fait quand print Low[1] si cinq décimales ?), ma version est 161188.
Mais si on complique le problème.
long Calc=
NormalizeDouble(Close[1],Digits)*MathPow(10,(Digits+1)*3-1)+
NormalizeDouble(High[1],Digits)*MathPow(10,(Digits+1)*2-1)+
NormalizeDouble(Low[1],Digits)*MathPow(10,(Digits+1)*1-1);
C'est-à-dire la dernière partie du nombre 161184 - soit une divergence de 4 unités.
Votre Variante de cette expression produit la même valeur
NormalizeDouble(Close[1],Digits)*MathPow(10,(Digits+1)*3-1)+
NormalizeDouble(High[1],Digits)*MathPow(10,(Digits+1)*2-1)+
Low[1]/Point;
Une idée de ce qu'est l'erreur et comment la réparer ?
Le résultat imprimé est erroné, l'original est 161188 (1.61188) votre méthode 161187 print donne 1.6119 (pourquoi arrondir vers le haut quand print Low[1] si cinq décimales ?), ma version est 161188.
Mais si on complique le problème.
long Calc=
NormalizeDouble(Close[1],Digits)*MathPow(10,(Digits+1)*3-1)+
NormalizeDouble(High[1],Digits)*MathPow(10,(Digits+1)*2-1)+
NormalizeDouble(Low[1],Digits)*MathPow(10,(Digits+1)*1-1);
C'est-à-dire la dernière partie du nombre 161184 - soit une divergence de 4 unités.
Votre variante dans cette expression donne la même valeur
NormalizeDouble(Close[1],Digits)*MathPow(10,(Digits+1)*3-1)+
NormalizeDouble(High[1],Digits)*MathPow(10,(Digits+1)*2-1)+
Low[1]/Point;
Une idée de ce qu'est l'erreur et comment la réparer ?
void OnStart()
{
string i = DoubleToString(SymbolInfoDouble(_Symbol, SYMBOL_BID)/_Point, 0);
Print(i);
Print(SymbolInfoDouble(_Symbol, SYMBOL_BID)/_Point);
}/*******************************************************************/
Exécutez-le comme ceci.
void OnStart()
{
string i = DoubleToString(SymbolInfoDouble(_Symbol, SYMBOL_BID)/_Point, 0);
Print(i);
Print(SymbolInfoDouble(_Symbol, SYMBOL_BID)/_Point);
}/*******************************************************************/
Oui, la variable chaîne obtient le bon numéro (de façon préliminaire), mais les zéros 161188.00000000 sont ajoutés, comment puis-je m'en débarrasser ?
Oui, la variable chaîne obtient le bon numéro (de façon préliminaire), mais les zéros 161188.00000000 sont ajoutés, comment puis-je m'en débarrasser ?
Il n'y a pas de zéros dans mon code. Regardez comment c'est écrit.
Merci - j'ai oublié un zéro.
C'est la construction.
DoubleToString(Close[1]/_Point,0)+
DoubleToString(High[1]/_Point,0)+
DoubleToString(Low[1]/_Point,0);
Print("CalcX=",CalcX);
Maintenant, je dois décomposer ces chiffres en leurs composants.
Lorsque j'essaie de convertir la chaîne en un nombre, j'obtiens à nouveau le mauvais nombre 161184 au lieu de 161188.
Print("testX=",testX);
Je devrais probablement couper la ficelle, mais comment le faire de manière optimale ?
Oui, la variable chaîne obtient le bon numéro (de manière préliminaire), mais les zéros 161188.00000000 sont ajoutés, comment puis-je m'en débarrasser?
Alors... Montre-moi le modèle. Comment savez-vous ce qu'il y a là-dedans ?
//| Custom indicator initialization function |
//+------------------------------------------------------------------+
int OnInit()
{
//--- indicator buffers mapping
//---
return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Custom indicator iteration function |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
const int prev_calculated,
const datetime &time[],
const double &open[],
const double &high[],
const double &low[],
const double &close[],
const long &tick_volume[],
const long &volume[],
const int &spread[])
{
//---
//--- return value of prev_calculated for next call
return(rates_total);
}
//+------------------------------------------------------------------+
Merci - le zéro m'a échappé.
Il en est ressorti cette construction
DoubleToString(Close[1]/_Point,0)+
DoubleToString(High[1]/_Point,0)+
DoubleToString(Low[1]/_Point,0);
Print("CalcX=",CalcX);
Maintenant, je dois décomposer ces chiffres en leurs composants.
Lorsque j'essaie de convertir la chaîne de caractères en un nombre, j'obtiens à nouveau le mauvais nombre 161184 au lieu de 161188.
Print("testX=",testX);
Je devrais probablement couper la ficelle, mais comment le faire de manière optimale ?
Eh bien, si vous avez une envie irrésistible de faire du désordre, reconvertissez la chaîne en un nombre StringToDouble() et multipliez par _Point avec normalisation au nombre de chiffres souhaité, probablement _Digits