Toute question des nouveaux arrivants sur MQL4 et MQL5, aide et discussion sur les algorithmes et les codes. - page 745
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
Est-il possible de masquer toutes les bandes de niveau d'inversion dans l'indicateur, non testées et les autres, et de ne laisser que celles testées, c'est-à-dire masquer extern bool zone_show_weak = true ; et ci-dessous dans le code si (zone_strength[i] == ZONE_WEAK && zone_show_weak == false) et les autres ne peuvent pas être masqués. Peut-être que quelqu'un comprend et corrige le code ou supprime les niveaux que j'ai décrits ci-dessus. Code indicateur :
#propriété copyright "Copyright © 2017 Andrew Sumner"
#lien de propriété ""
#propriété indicator_chart_window
#propriété indicator_buffers 4
#propriété indicator_color1 Rouge
#propriété indicator_color2 Rouge
#propriété indicator_color3 DodgerBlue
#propriété indicator_color4 DodgerBlue
extern int BackLimit = 300 ; //Retour retour
extern entier TimeFrame = 0 ;
extern string TimeString = "0=Actuel, 60=H1, 240=H4, 1440=Jour, 10080=Semaine, 43200=Mois" ;
couleur externe color_support_weak = MediumAquamarine ; //support - support pour DarkSlateGray faible
couleur externe color_support_untested = SeaGreen ; // décoché
couleur externe color_support_verified = Vert ;
couleur externe color_support_proven = LimeGreen ;
couleur externe color_support_turncoat = Olive Drab ;
couleur externe color_resist_weak = Sienne ;
couleur externe color_resist_untested = Orchidée ;
couleur externe color_resist_verified = Crimson ;
couleur externe color_resist_proven = Rouge ;
couleur externe color_resist_turncoat = DarkOrange;
extern bool zone_show_weak = true ;
extern double zone_fuzzfactor = 0.2;
extern bool zone_solid = faux ; // vrai si faux, il n'y aura pas de zones pleine bande, mais encadrées par un rectangle de largeur largeur
extern int zone_linewidth = 2 ;
extern int zone_style = 0 ;
extern bool zone_show_info = true ;
extern int zone_label_shift = 22 ; // décalage horizontal des étiquettes, mais seulement après suppression de l'indicateur
extern bool zone_show_alerts = false ;
extern bool zone_alert_popups = true ;
extern bool zone_alert_sounds = true ;
bool externe send_email = false ;
extern int zone_alert_waitseconds = 300 ;
externe bool zone_merge = true ;
externe bool zone_extend = true ;
extern bool fractals_show = faux ;
extern double fractal_fast_factor = 3.0 ;
extern double fractal_slow_factor = 6.0 ;
extern bool SetGlobals = true ;
double FastDnPts[], FastUpPts[] ;
double SlowDnPts[], SlowUpPts[] ;
double zone_hi[1000], zone_lo[1000] ;
int zone_start[1000], zone_hits[1000], zone_type[1000], zone_strength[1000], zone_count = 0 ;
boolzone_tour[1000] ;
#define ZONE_SUPPORT 1
#define ZONE_RESIST 2
#define ZONE_WEAK 0
#define ZONE_TURNCOAT 1
#define ZONE_UNTESTED 2
#define ZONE_VERIFIED 3
#define ZONE_PROVEN 4
#define UP_POINT 1
#define DN_POINT -1
int time_offset = 0 ;
int init()
{
IndicateurBuffers(4);
SetIndexBuffer(0, SlowDnPts);
SetIndexBuffer(1, SlowUpPts);
SetIndexBuffer(2, FastDnPts);
SetIndexBuffer(3, FastUpPts);
si (fractals_show == vrai)
{
SetIndexStyle(0, DRAW_ARROW, 0, 3);
SetIndexStyle(1, DRAW_ARROW, 0, 3);
SetIndexStyle(2, DRAW_ARROW, 0, 1);
SetIndexStyle(3, DRAW_ARROW, 0, 1);
SetIndexArrow(0, 218);
SetIndexArrow(1, 217);
SetIndexArrow(2, 218);
SetIndexArrow(3, 217);
}
autre
{
SetIndexStyle(0, DRAW_NONE);
SetIndexStyle(1, DRAW_NONE);
SetIndexStyle(2, DRAW_NONE);
SetIndexStyle(3, DRAW_NONE);
}
si (TimeFrame != 1 && TimeFrame != 5 && TimeFrame != 15 &&
TimeFrame != 60 && TimeFrame != 240 && TimeFrame != 1440 &&
TimeFrame != 10080 && TimeFrame != 43200)
délai = 0 ;
if(TimeFrame < Période())
délai = period();
retour(0);
}
int deinit()
{
SupprimeZones();
DeleteGlobalVars();
retour(0);
}
int start()
{
si (NouvelleBarre() == vrai)
{
int old_zone_count = zone_count ;
Fractales rapides();
SlowFractales();
SupprimeZones();
FindZones();
DrawZones();
si (zone_count < old_zone_count)
DeleteOldGlobalVars(old_zone_count);
}
si (zone_show_info == vrai)
{
pour (int i=0 ; i<zone_count ; i++)
{
chaîne lbl;
si (zone_strength[i] == ZONE_PROVEN)
lbl="" ; // Éprouvé
sinon si (zone_strength[i] == ZONE_VERIFIED)
lbl="" ; // Vérifié
sinon si (zone_strength[i] == ZONE_UNTESTED)
lbl="" ; // PAS tester
sinon si (zone_strength[i] == ZONE_TURNCOAT)
lbl="" ; // Inversion
autre
lbl="" ; // Faible
si (zone_type[i] == ZONE_SUPPORT)
lbl = lbl + "sous" ; //Soutien
autre
lbl = lbl + "sop" ; //Résistance
si (zone_hits[i] > 0 && zone_strength[i] > ZONE_UNTESTED)
{
si (zone_hits[i] == 1)
lbl = lbl + ",T=" + zone_hits[i] ; // Nombre de tests
autre
lbl = lbl + ",T=" + zone_hits[i] ; // Nombre de tests
}
int ajuster_hpos ;
int wbpc = WindowBarsPerChart();
entier k ;
k = Période() * 60 + (20 + StringLen(lbl));
si (wbpc < 80)
adjust_hpos = Temps[0] + k * 4 ;
sinon si (wbpc < 125)
adjust_hpos = Temps[0] + k * 8 ;
sinon si (wbpc < 250)
adjust_hpos = Temps[0] + k * 15 ;
sinon si (wbpc < 480)
adjust_hpos = Temps[0] + k * 29 ;
sinon si (wbpc < 950)
adjust_hpos = Temps[0] + k * 58 ;
autre
adjust_hpos = Temps[0] + k * 115 ;
int shift = k * zone_label_shift ;
double vpos = zone_hi[i] - (zone_hi[i] - zone_lo[i]) / 2 ;
// Texte des descriptions de niveau
chaîne s = "SSSR#"+i+"LBL" ;
ObjetCrée(s, OBJ_TEXT, 0, 0, 0);
ObjectSet(s, OBJPROP_TIME1, adjust_hpos + shift);
ObjectSet(s, OBJPROP_PRICE1, vpos);
ObjectSetText(s, StringRightPad(lbl, 36, " "), 11, "Courier New",clrWhite); //Le noir
}
}
CheckAlerts();
retour(0);
}
annuler CheckAlerts()
{
statique int lastertert = 0 ;
si (zone_show_alerts == faux)
retourner;
si (Heure[0] - lastalert > zone_alert_waitseconds)
si (CheckEntryAlerts() == vrai)
lastalert = Heure[0] ;
}
bool CheckEntryAlerts()
{
// vérifie les enregistrements
pour (int i=0 ; i<zone_count ; i++)
{
si (Fermer[0] >= zone_lo[i] && Fermer[0] < zone_hi[i])
{
si (zone_show_alerts == vrai)
{
si (zone_alert_popups == vrai)
{
si (zone_type[i] == ZONE_SUPPORT)
Alert(Symbol() + TimeFrameToString(TimeFrame) + " : Zone de support entrée" ); // Zone d'assistance introduite
autre
Alert(Symbol() + TimeFrameToString(TimeFrame) + " : Zone de résistance entrée" ); // Zone de résistance introduite
}
si (zone_alert_sounds == vrai)
PlaySound("alert.wav");
}
si (send_email == vrai)
{
string dir = "" ;
string msg = StringConcatenate(Symbol(), "-", TimeFrameToString(TimeFrame), " at ", TimeToStr(Time[0], TIME_DATE|TIME_SECONDS),
" ", rép, "Zone entrée");
si (zone_type[i] == ZONE_SUPPORT)
{
dir = "Assistance" ;
SendMail("Alerte SS_SupRes_v04c", msg);
}
autre
{
dir="résistance" ;
SendMail("Alerte SS_SupRes_v04c", msg);
}
}
retour(vrai);
}
}
retour(faux);
}
annuler DeleteGlobalVars()
{
si(SetGlobals==false)
retourner;
GlobalVariableDel("SSSR_Count_"+Symbol()+TimeFrame);
GlobalVariableDel("SSSR_Updated_"+Symbol()+TimeFrame);
int old_count = zone_count ;
zone_count = 0 ;
DeleteOldGlobalVars(old_count);
}
void DeleteOldGlobalVars(int old_count)
{
si(SetGlobals==false)
retourner;
for (int i=zone_count ; i<old_count ; i++)
{
GlobalVariableDel("SSSR_HI_"+Symbol()+TimeFrame+i);
GlobalVariableDel("SSSR_LO_"+Symbol()+TimeFrame+i);
GlobalVariableDel("SSSR_HITS_"+Symbol()+TimeFrame+i);
GlobalVariableDel("SSSR_STRENGTH_"+Symbol()+TimeFrame+i);
GlobalVariableDel("SSSR_AGE_"+Symbol()+TimeFrame+i);
}
}
annuler FindZones()
{
int i, j, shift, bustcount=0, testcount = 0;
double hival, loval ;
bool tourné = faux, hasturned = faux ;
double temp_hi[1000], temp_lo[1000] ;
int temp_start[1000], temp_hits[1000], temp_strength[1000], temp_count = 0 ;
booléen temp_turn[1000], temp_merge[1000] ;
int merge1[1000], merge2[1000], merge_count = 0 ;
// boucle à travers les zones de la plus ancienne à la plus petite (ignorez les 5 dernières barres),
// trouver ceux qui ont survécu jusqu'à présent...
for (shift=MathMin(iBars(NULL, TimeFrame)-1, BackLimit); shift>5; shift--)
{
double atr = iATR(NULL, TimeFrame, 7, shift);
double fu = atr/2 * zone_fuzzfactor ;
booléen est faible ;
bool touchOk = faux ;
bool isBust = false ;
double fermeture = iClose(NULL, TimeFrame, shift);
double high = iHigh(NULL, TimeFrame, shift);
double bas = iBas(NULL, TimeFrame, shift);
double hi_i ;
double lo_i ;
si (FastUpPts[shift] > 0.001)
{
// zigzag point haut
estFaible = vrai ;
si (SlowUpPts[shift] > 0.001)
estFaible = faux ;
hival=élevé ;
si (zone_extend == vrai)
hival += fu ;
loval = MathMax(MathMin(close, high-fu), high-fu*2);
tourner=faux ;
est devenu=faux ;
isbust=false ;
nombre de bus = 0 ;
nombre de tests = 0 ;
pour (i=shift-1 ; i>=0 ; i--)
{
hi_i = iHigh(NULL, TimeFrame, je);
lo_i = iBas(NULL, TimeFrame, je);
if ((turned == false && FastUpPts[i] >= loval && FastUpPts[i] <= hival) ||
(devenu == vrai && FastDnPts[i] <= hival && FastDnPts[i] >= loval))
{
// Touche potentielle, assurez-vous simplement que cela fait plus de 10 bougies depuis la dernière
toucherOk = vrai ;
pour (j=i+1; j<i+11; j++)
{
if ((turned == false && FastUpPts[j] >= loval && FastUpPts[j] <= hival) ||
(devenu == vrai && FastDnPts[j] <= hival && FastDnPts[j] >= loval))
{
touchOk = faux ;
Pause;
}
}
si (touchOk == vrai)
{
// nous avons une touche. S'il a été bloqué une fois, supprimez le décompte
// puisque nous savons que ce niveau est toujours valide et vient de changer de côté
nombre de bus = 0 ;
testcount++ ;
}
}
if ((turned == false && hi_i > hival) ||
(devenu == vrai && lo_i < loval))
{
// ce niveau a été cassé au moins une fois
bustcount++ ;
si (bustcount > 1 || isWeak == true)
{
// deux ou plus
isBust = vrai;
Pause;
}
si (devenu == vrai)
tourner=faux ;
sinon si (devenu == faux)
tourner=vrai ;
est devenu = vrai ;
// oublie les hits précédents
nombre de tests = 0 ;
}
}
if(isBust==false)
{
// le niveau est toujours valide, ajouter à notre liste
temp_hi[temp_count] = hival ;
temp_lo[temp_count] = loval ;
temp_turn[temp_count] = a tourné ;
temp_hits[temp_count] = testcount ;
temp_start[temp_count] = décalage ;
temp_merge[temp_count] = faux ;
si (nombre de tests > 3)
temp_force[temp_count] = ZONE_PROVEN ;
sinon si (testcount > 0)
temp_strength[temp_count] = ZONE_VERIFIED ;
sinon si (est devenu == vrai)
temp_strength[temp_count] = ZONE_TURNCOAT ;
sinon si (estfaible == faux)
temp_strength[temp_count] = ZONE_UNTESTED ;
autre
temp_force[temp_count] = ZONE_WEAK ;
temp_count++ ;
}
}
sinon si (FastDnPts[shift] > 0.001)
{
// point de zigzag bas
estFaible = vrai ;
si (SlowDnPts[shift] > 0.001)
estFaible = faux ;
loval = faible ;
si (zone_extend == vrai)
loval = fu;
hival = MathMin(MathMax(fermé, bas+fu), bas+fu*2);
tourner=faux ;
est devenu=faux ;
nombre de bus = 0 ;
nombre de tests = 0 ;
isbust=false ;
pour (i=shift-1 ; i>=0 ; i--)
{
hi_i = iHigh(NULL, TimeFrame, je);
lo_i = iBas(NULL, TimeFrame, je);
if ((turned == true && FastUpPts[i] >= lovale && FastUpPts[i] <= hival) ||
(devenu == faux && FastDnPts[i] <= hival && FastDnPts[i] >= loval))
{
// Touche potentielle, assurez-vous simplement que cela fait plus de 10 bougies depuis la dernière
toucherOk = vrai ;
pour (j=i+1; j<i+11; j++)
{
if ((turned == true && FastUpPts[j] >= lovale && FastUpPts[j] <= hival) ||
(devenu == faux && FastDnPts[j] <= hival && FastDnPts[j] >= loval))
{
touchOk = faux ;
Pause;
}
}
si (touchOk == vrai)
{
// nous avons une touche. S'il a été bloqué une fois, supprimez le décompte
// puisque nous savons que ce niveau est toujours valide et vient de changer de camp
nombre de bus = 0 ;
testcount++ ;
}
}
if ((turned == true && hi_i > hival) ||
(devenu == faux && lo_i < loval))
{
// ce niveau a été cassé au moins une fois
bustcount++ ;
si (bustcount > 1 || isWeak == true)
{
// deux ou plus
isBust = vrai;
Pause;
}
si (devenu == vrai)
tourner=faux ;
sinon si (devenu == faux)
tourner=vrai ;
est devenu = vrai ;
// oublie les hits précédents
nombre de tests = 0 ;
}
}
if(isBust==false)
{
// le niveau est toujours valide, ajouter à notre liste
temp_hi[temp_count] = hival ;
temp_lo[temp_count] = loval ;
temp_turn[temp_count] = a tourné ;
temp_hits[temp_count] = testcount ;
temp_start[temp_count] = décalage ;
temp_merge[temp_count] = faux ;
si (nombre de tests > 3)
temp_force[temp_count] = ZONE_PROVEN ;
sinon si (testcount > 0)
temp_strength[temp_count] = ZONE_VERIFIED ;
sinon si (est devenu == vrai)
temp_strength[temp_count] = ZONE_TURNCOAT ;
sinon si (estfaible == faux)
temp_strength[temp_count] = ZONE_UNTESTED ;
autre
temp_force[temp_count] = ZONE_WEAK ;
temp_count++ ;
}
}
}
// recherche les zones qui se chevauchent...
si (zone_merge == vrai)
{
merge_count = 1 ;
int itérations = 0 ;
tandis que (merge_count > 0 && itérations < 3)
{
merge_count = 0 ;
itérations++ ;
pour (i = 0; i < temp_count; i++)
temp_merge[i] = faux ;
pour (i = 0; je < temp_count-1; i++)
{
si (temp_hits[i] == -1 || temp_merge[j] == vrai)
Continuez;
pour (j = i+1 ; j < temp_count ; j++)
{
si (temp_hits[j] == -1 || temp_merge[j] == vrai)
Continuez;
si ((temp_hi[i] >= temp_lo[j] && temp_hi[i] <= temp_hi[j]) ||
(temp_lo[i] <= temp_hi[j] && temp_lo[i] >= temp_lo[j]) ||
(temp_hi[j] >= temp_lo[i] && temp_hi[j] <= temp_hi[i]) ||
(temp_lo[j] <= temp_hi[i] && temp_lo[j] >= temp_lo[i]))
{
fusionner1[merge_count] = je ;
fusionner2[merge_count] = j ;
temp_merge[i] = vrai ;
temp_merge[j] = vrai ;
merge_count++ ;
}
}
}
// ... et les combiner ...
pour (i=0 ; i<merge_count ; i++)
{
int cible = merge1[i] ;
int source = merge2[i] ;
temp_hi[cible] = MathMax(temp_hi[cible], temp_hi[source]);
temp_lo[cible] = MathMin(temp_lo[cible], temp_lo[source]);
temp_hits[cible] += temp_hits[source] ;
temp_start[cible] = MathMax(temp_start[cible], temp_start[source]);
force_temp[cible] = MathMax(force_temp[cible], force_temp[source]);
si (temp_hits[cible] > 3)
temp_strength[cible] = ZONE_PROVEN ;
si (temp_hits[cible] == 0 && temp_turn[cible] == faux)
{
temp_hits[cible] = 1 ;
si (temp_strength[cible] < ZONE_VERIFIED)
temp_strength[cible] = ZONE_VERIFIED ;
}
si (temp_turn[cible] == faux || temp_turn[source] == faux)
temp_turn[cible] = faux ;
si (temp_turn[cible] == true)
temp_hits[cible] = 0 ;
temp_hits[source] = -1 ;
}
}
}
// copie le reste de la liste dans nos zones officielles
zone_count = 0 ;
pour (i=0 ; i<temp_count ; i++)
{
si (temp_hits[i] >= 0 && zone_count < 1000)
{
zone_hi[zone_count] = temp_hi[i] ;
zone_lo[zone_count] = temp_lo[i] ;
zone_hits[zone_count] = temp_hits[i] ;
zone_turn[zone_count] = temp_turn[i] ;
zone_start[zone_count] = temp_start[i] ;
zone_force[zone_count] = temp_force[i] ;
si (zone_hi[zone_count] < Fermer[4])
zone_type[zone_count] = ZONE_SUPPORT ;
sinon si (zone_lo[zone_count] > Fermer[4])
zone_type[zone_count] = ZONE_RESIST ;
autre
{
pour (j=5; j<1000; j++)
{
si (iClose(NULL, TimeFrame, j) < zone_lo[zone_count])
{
zone_type[zone_count] = ZONE_RESIST ;
Pause;
}
sinon si (iClose(NULL, TimeFrame, j) > zone_hi[zone_count])
{
zone_type[zone_count] = ZONE_SUPPORT ;
Pause;
}
}
si (j == 1000)
zone_type[zone_count] = ZONE_SUPPORT ;
}
zone_count++ ;
}
}
}
annuler DrawZones()
{
si(SetGlobals==true)
{
GlobalVariableSet("SSSR_Count_"+Symbol()+TimeFrame, zone_count);
GlobalVariableSet("SSSR_Updated_"+Symbol()+TimeFrame, TimeCurrent());
}
pour (int i=0 ; i<zone_count ; i++)
{
si (zone_force[i] == ZONE_WEAK && zone_show_weak == faux)
Continuez;
chaîne s = "SSSR#"+i+" Force=" ;
si (zone_strength[i] == ZONE_PROVEN)
s = s + "Proven, Test Count=" + zone_hits[i] ;
sinon si (zone_strength[i] == ZONE_VERIFIED)
s = s + "Vérifié, Nombre de tests=" + zone_hits[i] ;
sinon si (zone_strength[i] == ZONE_UNTESTED)
s = s + "Non testé" ;
sinon si (zone_strength[i] == ZONE_TURNCOAT)
s = s + "Turncoat" ;
autre
s = s + "faible" ;
ObjetCrée(s, OBJ_RECTANGLE , 0, 0, 0, 0, 0);
ObjectSet(s, OBJPROP_TIME1, iTime(NULL, TimeFrame, zone_start[i]));
ObjectSet(s, OBJPROP_TIME2, TimeCurrent());
ObjectSet(s, OBJPROP_PRICE1, zone_hi[i]);
ObjectSet(s, OBJPROP_PRICE2, zone_lo[i]);
ObjectSet(s, OBJPROP_BACK, zone_solid);
ObjectSet(s, OBJPROP_WIDTH, zone_linewidth);
ObjectSet(s, OBJPROP_STYLE, zone_style);
si (zone_type[i] == ZONE_SUPPORT)
{
// zone d'assistance
si (zone_strength[i] == ZONE_TURNCOAT)
ObjectSet(s, OBJPROP_COLOR, color_support_turncoat);
sinon si (zone_strength[i] == ZONE_PROVEN)
ObjectSet(s, OBJPROP_COLOR, color_support_proven);
sinon si (zone_strength[i] == ZONE_VERIFIED)
ObjectSet(s, OBJPROP_COLOR, color_support_verified);
sinon si (zone_strength[i] == ZONE_UNTESTED)
ObjectSet(s, OBJPROP_COLOR, color_support_untested);
autre
ObjectSet(s, OBJPROP_COLOR, color_support_weak);
}
autre
{
// zone de résistance
si (zone_strength[i] == ZONE_TURNCOAT)
ObjectSet(s, OBJPROP_COLOR, color_resist_turncoat);
sinon si (zone_strength[i] == ZONE_PROVEN)
ObjectSet(s, OBJPROP_COLOR, color_resist_proven);
sinon si (zone_strength[i] == ZONE_VERIFIED)
ObjectSet(s, OBJPROP_COLOR, color_resist_verified);
sinon si (zone_strength[i] == ZONE_UNTESTED)
ObjectSet(s, OBJPROP_COLOR, color_resist_untested);
autre
ObjectSet(s, OBJPROP_COLOR, color_resist_weak);
}
si(SetGlobals==true)
{
GlobalVariableSet("SSSR_HI_"+Symbol()+TimeFrame+i, zone_hi[i]);
GlobalVariableSet("SSSR_LO_"+Symbol()+TimeFrame+i, zone_lo[i]);
GlobalVariableSet("SSSR_HITS_"+Symbol()+TimeFrame+i, zone_hits[i]);
GlobalVariableSet("SSSR_STRENGTH_"+Symbol()+TimeFrame+i, zone_strength[i]);
GlobalVariableSet("SSSR_AGE_"+Symbol()+TimeFrame+i, zone_start[i]);
}
}
}
bool Fractal(int M, int P, int shift)
{
si (TimeFrame > P)
P = délai ;
P = P / TimeFrame*2 + MathCeil(P / TimeFrame / 2);
si(décalage<p)
retour(faux);
if (shift > iBars(Symbol(), TimeFrame)-P)
retour(faux);
pour (int i=1; i<=P; i++)
{
si (M == UP_POINT)
{
si (iHigh(NULL, TimeFrame, shift+i) > iHigh(NULL, TimeFrame, shift))
retour(faux);
si (iHigh(NULL, TimeFrame, shift-i) >= iHigh(NULL, TimeFrame, shift))
retour(faux);
}
si (M == DN_POINT)
{
si (iLow(NULL, TimeFrame, shift+i) < iLow(NULL, TimeFrame, shift))
retour(faux);
si (iLow(NULL, TimeFrame, shift-i) <= iLow(NULL, TimeFrame, shift))
retour(faux);
}
}
retour(vrai);
}
annuler FastFractals()
{
décalage int ;
int limit = MathMin(Bars-1, BackLimit);
int P = TimeFrame * fractal_fast_factor ;
FastUpPts[0] = 0,0 ; FastUpPts[1] = 0,0 ;
FastDnPts[0] = 0,0 ; FastDnPts[1] = 0,0 ;
pour (shift=limit; shift>1; shift--)
{
si (Fractale(UP_POINT, P, shift) == vrai)
FastUpPts[shift] = iHigh(NULL, TimeFrame, shift);
autre
FastUpPts[décalage] = 0,0 ;
si (Fractale(DN_POINT, P, décalage) == vrai)
FastDnPts[shift] = iLow(NULL, TimeFrame, shift);
autre
FastDnPts[décalage] = 0,0 ;
}
}
annuler SlowFractals()
{
décalage int ;
int limit = MathMin(iBars(Symbol(), TimeFrame) - 1, BackLimit);
int P = TimeFrame * fractal_slow_factor ;
SlowUpPts[0] = 0.0 ; SlowUpPts[1] = 0,0 ;
SlowDnPts[0] = 0,0 ; SlowDnPts[1] = 0,0 ;
pour (shift=limit; shift>1; shift--)
{
si (Fractale(UP_POINT, P, shift) == vrai)
SlowUpPts[shift] = iHigh(NULL, TimeFrame, shift);
autre
SlowUpPts[décalage] = 0,0 ;
si (Fractale(DN_POINT, P, décalage) == vrai)
SlowDnPts[shift] = iLow(NULL, TimeFrame, shift);
autre
SlowDnPts[décalage] = 0,0 ;
}
}
bool NouvelleBar()
{
datetime statique LastTime = 0 ;
si (iTime(NULL, TimeFrame, 0) != LastTime)
{
LastTime = iTime(NULL, TimeFrame, 0)+time_offset ;
retour(vrai);
}
autre
retour (faux);
}
annuler DeleteZones()
{
intlen = 5 ;
int je ;
tandis que (i < ObjectsTotal())
{
string objName = ObjectName(i);
if (StringSubstr(objName, 0, len) != "SSSR#")
{
je++ ;
Continuez;
}
ObjectDelete(objName);
}
}
chaîne TimeFrameToString(int tf) // code de TRO
{
chaîne tfs ;
interrupteur (tf)
{
cas PERIOD_M1 :
tfs="M1" ;
Pause;
cas PERIOD_M5 :
tfs="M5" ;
Pause;
cas PERIOD_M15 :
tfs="M15" ;
Pause;
cas PERIOD_M30 :
tfs="M30" ;
Pause;
cas PERIOD_H1 :
tfs="H1" ;
Pause;
cas PERIOD_H4 :
tfs="H4" ;
Pause;
cas PERIOD_D1 :
tfs="D1" ;
Pause;
cas PERIOD_W1 :
tfs="W1" ;
Pause;
cas PERIOD_MN1 :
tfs="MN" ;
}
retour(tfs);
}
chaîne ChaîneRépéter(chaîne chaîne, int n = 1)
{
chaîne outstr = "" ;
for(int i = 0; i < n; i++) outstr = outstr + str;
retour(outstr);
}
chaîne StringRightPad(chaîne str, int n=1, chaîne str2=" ")
{
return(str + StringRepeat(str2,n-StringLen(str)));
Passage à MT5. Aidez-moi avec un mot. Comment dans MT5 c'est écrit en code, qu'est-ce qui ne va pas ?
QUESTION : Pourquoi toutes sortes d'ordures tombent dans le tampon ?
J'en suis au stade du constructeur de Lego, c'est-à-dire que je copie le module et comprends les particularités de MT% par expérience. Documentation du cours.
Passage à MT5. Aidez-moi avec un mot. Comment dans MT5 c'est écrit en code, qu'est-ce qui ne va pas ?
QUESTION : Pourquoi toutes sortes de déchets tombent dans le tampon ?
dans mt5 la série temporelle va dans l'autre sens
si vous en avez besoin de la même manière que dans mt4, c'estArraySetAsSeries
Passage à MT5. Aidez-moi avec un mot. Comment dans MT5 c'est écrit en code, qu'est-ce qui ne va pas ?
QUESTION : Pourquoi toutes sortes d'ordures tombent dans le tampon ?
J'en suis au stade du constructeur de Lego, c'est-à-dire que je copie le module et comprends les particularités de MT% par expérience. Documentation du cours.
Merci pour la réponse.
Vérifié dans MT5... Quel gâchis... Les points sont éparpillés sur le graphique d'une manière étrange, quelque part au fond de l'histoire... Je ne comprends pas ce que et pourquoi MT5 n'aime pas ? Le problème est simple ! !!
PRENEZ-LE DANS MT4
.
ET AUSSI DANS MT5. Bien sûr, dans un tampon. Mais le problème est que l'indicateur attrape des points, mais pas ceux-là et pas là...(((
S'il vous plaît, dites-moi encore. Ce que j'ai fait de mal dans le code MT5 ????
J'ai quelque chose dans MT5. Mais les tampons... un mystère
Merci pour la réponse.
Vérifié dans MT5... Quel gâchis... Les points sont éparpillés sur le graphique d'une manière étrange, quelque part au fond de l'histoire... Je ne comprends pas ce que et pourquoi MT5 n'aime pas ? Le problème est simple ! !!
PRENEZ-LE DANS MT4
.
ET AINSI DANS MT5 . Bien sûr, dans un tampon. Mais le problème est que l'indicateur attrape des points, mais pas ceux-là et pas là...(((
S'il vous plaît, dites-moi encore. Ce que j'ai fait de mal dans le code MT5 ????
J'ai quelque chose dans MT5. Mais les tampons... un mystère
Il n'y a pas de mystère. La numérotation est différente de celle de mql4 et les tampons des indicateurs ne sont pas mis à zéro automatiquement. Pour éliminer les "déchets", le programmeur doit veiller à la propreté des index s'ils ne doivent pas contenir de valeurs.
Pas de mystère. La numérotation est différente de celle de mql4 et les tampons des indicateurs ne sont pas mis à zéro automatiquement. Pour éliminer les "déchets", le programmeur doit veiller à la pureté des index s'ils ne doivent pas contenir de valeurs.
La question est de savoir POURQUOI les marques (points) sont placées n'importe où ? J'ai défini dans le code l'algorithme ! !!!. La condition MA dans le corps de la bougie. Cela ne suffit-il pas ?
La question est de savoir POURQUOI les marques (points) sont placées n'importe où ? J'ai défini dans le code l'algorithme ! !!!. La condition MA dans le corps de la bougie. Cela ne suffit-il pas ?
Regarde ici.
Passage à MT5. Aidez-moi avec un mot.
Artem a donné le code complet au lieu du mot aide. Chacun a sa propre approche de la question. J'essaie de ne pas donner de code tout fait, mais il m'arrive encore d'échouer.
Merci pour la réponse.
Vérifié dans MT5... C'est un peu le bazar...Mais les graphiques de comparaison sont des périodes complètement différentes. Comment peut-on juger si les points sont bons ou mauvais ???
D'où un mot d'aide.
Forum sur le trading, les systèmes de trading automatisés et les tests de stratégie
Toutes les questions des débutants de MQL4, l'aide et la discussion sur les algorithmes et les codes
Alexey Viktorov, 2019.01.21 11:04
Pas de mystère. La numérotation est différente de celle de mql4 et les tampons indicateurs ne sont pas mis à zéro automatiquement. Pour éliminer les "déchets", le programmeur lui-même devrait veiller à la propreté des index s'ils ne sont pas censés contenir des valeurs.
Voici un aperçu.
Artyom a donné le code complet au lieu d'aider avec le mot. Chacun a une approche différente de la question. J'essaie de ne pas donner de code prêt à l'emploi, mais il arrive quand même qu'il échoue.
Mais les graphiques de comparaison sont des périodes complètement différentes. Comment peut-on juger si les points sont bons ou mauvais ?
D'où un mot d'aide.
Hallelujah !!!!! Changé open[i] et close[i] en iOpen(NULL,PERIOD_H1,i)
Hallelujah !!!!! Changé open[i] et close[i] en iOpen(NULL,PERIOD_H1,i)
Quelle est la différence ? Si l'indicateur est sur H1, c'est uniquement au niveau de la vitesse d'accès - vous avez une vitesse plus lente. Dans mon exemple, vous n'avez pas dû voir que vous deviez définir les tableaux open et close pour l'indexation en série. J'ai souligné ce que vous n'aviez pas. Vous avez une boucle du début à la fin - de la limite à 0, et vous n'avez pas indexé les tableaux - elle a donc été dessinée à l'envers et à l'endroit.