Toute question des nouveaux arrivants sur MQL4 et MQL5, aide et discussion sur les algorithmes et les codes.

Konstantin Lebedev 2019.01.20 10:26 #7441

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 :

#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)));

Any questions from newcomers Experts: AG Aide au codage

kopeyka2 2019.01.20 18:50 #7442

Passage à MT5. Aidez-moi avec un mot. Comment dans MT5 c'est écrit en code, qu'est-ce qui ne va pas ?

//+------------------------------------------------------------------+
//|                                                          123.mq5 |
//|                        Copyright 2019, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2018, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property strict
#property indicator_chart_window
#property indicator_buffers 2
#property indicator_plots   1
//+----------------------------------------------+
//|  Параметры отрисовки индикатора 1            |
//+----------------------------------------------+
#property indicator_type1   DRAW_ARROW
#property indicator_color1  Blue
#property indicator_style1  STYLE_DASHDOTDOT
#property indicator_width1  0
#property indicator_label1  "Label 1"
//----
input int MAPeriod=13;
//---=
int handle_ma;
double ExtLineBuffer[];
double BufferPrice[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
   SetIndexBuffer(0,ExtLineBuffer,INDICATOR_DATA);
   SetIndexBuffer(3,BufferPrice,INDICATOR_CALCULATIONS);
//---- символы для индикатора
   PlotIndexSetInteger(0,PLOT_ARROW,108);
//---- создание метки для отображения в DataWindow
   PlotIndexSetString(0,PLOT_LABEL,"PROBA");
//----
   IndicatorSetInteger(INDICATOR_DIGITS,_Digits);
   IndicatorSetString(INDICATOR_SHORTNAME," 123");
//---- массива будет производиться как в таймсериях
   ArraySetAsSeries(ExtLineBuffer,true);
   ArraySetAsSeries(BufferPrice,true);
//--- create MA's handles
   ResetLastError();
      handle_ma=iMA(NULL,Period(),MAPeriod,0,MODE_SMA,PRICE_CLOSE); 
   if(handle_ma==INVALID_HANDLE)
     {
      Print("The iMA (1) object was not created: Error ",GetLastError());
      return INIT_FAILED;
     }
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 | 
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
 {
 Comment("");
 }
//+------------------------------------------------------------------+
//| 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[])
  {
//---
//--- Проверка количества доступных баров
   if(rates_total<4) return 0;
//--- Проверка и расчёт количества просчитываемых баров
   int limit=rates_total-prev_calculated;
   if(limit>1)
     {
      limit=rates_total-1;
   ArrayInitialize(ExtLineBuffer,EMPTY_VALUE);
   ArrayInitialize(BufferPrice,0);
     }
//--- Подготовка данных
   int count=(limit>1 ? rates_total : 2),copied=0;
   copied=CopyBuffer(handle_ma,0,0,count,BufferPrice);
   if(copied!=count) return 0;
//----   
 for(int i=limit; i>0 && !IsStopped(); i--)
   {
//----------------------------------------- ОСНОВНОЙ МОДУЛЬ КОТОРЫЙ НЕ РАБОТАЕТ ----------------------------
 if(PERIOD_H1==Period())
  {
//--- High signal
 if(BufferPrice[i]>open[i] && BufferPrice[i]<close[i])   
   ExtLineBuffer[i]=high[i];
//--- Low signal
 if(BufferPrice[i]<open[i] && BufferPrice[i]>close[i])
   ExtLineBuffer[i]=low[i];
  } /*
  else
  {
  ExtLineBuffer[i]=0.0;
  ExtLineBuffer[i]=0.0;
  } */
  }    
//--- return value of prev_calculated for next call
   return(rates_total);
  }
//+------------------------------------------------------------------+

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.

Erreurs, bugs, questions Questions des débutants MQL4 Quels instruments négocier chez

Taras Slobodyanik 2019.01.20 18:54 #7443

kopeyka2:

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

Artyom Trishkin 2019.01.20 21:25 #7444

kopeyka2:

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.

//+------------------------------------------------------------------+
//|                                                          123.mq5 |
//|                        Copyright 2019, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2018, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property strict
#property indicator_chart_window
#property indicator_buffers 2
#property indicator_plots   1
//+----------------------------------------------+
//|  Параметры отрисовки индикатора 1            |
//+----------------------------------------------+
#property indicator_type1   DRAW_ARROW
#property indicator_color1  clrBlue
#property indicator_width1  1
#property indicator_label1  "Label 1"
//----
input int MAPeriod=13;
//---=
int handle_ma;
double ExtLineBuffer[];
double BufferPrice[];
//---
int    period;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   period=(MAPeriod<1 ? 1 : MAPeriod);
//---
   SetIndexBuffer(0,ExtLineBuffer,INDICATOR_DATA);
   SetIndexBuffer(1,BufferPrice,INDICATOR_CALCULATIONS);
//---- символы для индикатора
   PlotIndexSetInteger(0,PLOT_ARROW,108);
//---- создание метки для отображения в DataWindow
   PlotIndexSetString(0,PLOT_LABEL,"PROBA");
//----
   IndicatorSetInteger(INDICATOR_DIGITS,_Digits);
   IndicatorSetString(INDICATOR_SHORTNAME," 123");
//---- массива будет производиться как в таймсериях
   ArraySetAsSeries(ExtLineBuffer,true);
   ArraySetAsSeries(BufferPrice,true);
//--- create MA's handles
   ResetLastError();
   handle_ma=iMA(NULL,PERIOD_CURRENT,period,0,MODE_SMA,PRICE_CLOSE);
   if(handle_ma==INVALID_HANDLE)
     {
      Print("The iMA (",(string)period,") object was not created: Error ",GetLastError());
      return INIT_FAILED;
     }
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 | 
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   Comment("");
  }
//+------------------------------------------------------------------+
//| 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[])
  {
//--- 
   ArraySetAsSeries(high,true);
   ArraySetAsSeries(low,true); 
//--- Проверка количества доступных баров
   if(rates_total<4) return 0;
//--- Проверка и расчёт количества просчитываемых баров
   int limit=rates_total-prev_calculated;
   if(limit>1)
     {
      limit=rates_total-1;
      ArrayInitialize(ExtLineBuffer,EMPTY_VALUE);
      ArrayInitialize(BufferPrice,0);
     }
//--- Подготовка данных
   int count=(limit>1 ? rates_total : 2),copied=0;
   copied=CopyBuffer(handle_ma,0,0,count,BufferPrice);
   if(copied!=count) return 0;
//----   
   for(int i=limit; i>=0 && !IsStopped(); i--)
     {
      //----------------------------------------- ОСНОВНОЙ МОДУЛЬ КОТОРЫЙ НЕ РАБОТАЕТ ----------------------------
      if(Period()==PERIOD_H1)
        {
         //--- High signal
         if(BufferPrice[i]>open[i] && BufferPrice[i]<close[i])
            ExtLineBuffer[i]=high[i];
         //--- Low signal
         if(BufferPrice[i]<open[i] && BufferPrice[i]>close[i])
            ExtLineBuffer[i]=low[i];
        }
/*
  else
  {
  ExtLineBuffer[i]=0.0;
  ExtLineBuffer[i]=0.0;
  } */
     }
//--- return value of prev_calculated for next call
   return(rates_total);
  }
//+------------------------------------------------------------------+

kopeyka2 2019.01.21 08:48 #7445

Artyom Trishkin:

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

[ARCHIVE] Toute question de L'apprentissage automatique dans la Inscription au championnat des

Alexey Viktorov 2019.01.21 10:04 #7446

kopeyka2:

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.

OnDeinit dans les indicateurs Erreurs, bugs, questions Pourquoi l'accès à www.mql4.com

kopeyka2 2019.01.21 15:49 #7447

Alexey Viktorov:

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 ?

Questions des débutants MQL5 Toute question de débutant, Est-il possible de tricher

Alexey Viktorov 2019.01.21 16:25 #7448

kopeyka2:

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.

kopeyka2:
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.

kopeyka2:

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.

Aide : Dans MT5 ils ont fait une séquence inadéquate d'exécutions OnInit et OnDeinit, donc il peut y avoir des problèmes aussi. Mais c'est dans certains cas particuliers, et le recalcul de l'indicateur doit TOUJOURS être consécutif. A condition que prev_calculated == 0, le recalcul doit être effectué pour toutes les barres et à chaque itération de la boucle, s'il ne doit pas y avoir de valeur dans le tampon, alors remplissez cet index de tableau avec la valeur EMPTY_VALUE ou 0 selon le paramètre PLOT_EMPTY_VALUE.

[ARCHIVE]Toute question de débutant, Le changement de TF Erreurs, bugs, questions

kopeyka2 2019.01.21 17:59 #7449

Alexey Viktorov:

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.

Plus d'aide en mots : Dans MT5 ils ont fait une séquence inadéquate des exécutions OnInit et OnDeinit, donc il peut y avoir des problèmes aussi. Mais c'est dans certains cas particuliers, et le recalcul de l'indicateur doit TOUJOURS être consécutif. A condition que prev_calculated == 0, recalcule sur toutes les barres et à chaque itération de la boucle, s'il ne doit pas y avoir de valeur dans le buffer, remplit cet index du tableau avec la valeur EMPTY_VALUE ou 0 selon le paramètre PLOT_EMPTY_VALUE

Hallelujah !!!!! Changé open[i] et close[i] en iOpen(NULL,PERIOD_H1,i)

Artyom Trishkin 2019.01.21 18:16 #7450

kopeyka2:

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.

Questions des débutants MQL5 L'EA ne fonctionne pas Erreurs, bugs, questions

Toute question des nouveaux arrivants sur MQL4 et MQL5, aide et discussion sur les algorithmes et les codes. - page 745