Tutte le domande dei nuovi arrivati su MQL4 e MQL5, aiuto e discussione su algoritmi e codici

Konstantin Lebedev 2019.01.20 10:26 #7441

È possibile nascondere tutte le bande di livello di inversione nell'indicatore, non testate e il resto, e lasciare solo quelle testate, ovvero nascondere extern bool zone_show_weak = true; e sotto nel codice if (zone_strength[i] == ZONE_WEAK && zone_show_weak == false) e altri non possono essere nascosti. Forse qualcuno capisce e corregge il codice o rimuove i livelli che ho descritto sopra. Codice indicatore:

#link proprietà ""

#finestra_grafico_indicatore_proprietà

#indicatore di proprietà_buffer 4

#property indicator_color1 Rosso

#property indicator_color2 Rosso

#property indicator_color3 DodgerBlue

#property indicator_color4 DodgerBlue

extern int BackLimit = 300; //Indietro indietro

extern int TimeFrame = 0;

stringa esterna TimeString = "0=Corrente, 60=H1, 240=H4, 1440=Giorno, 10080=Settimana, 43200=Mese";

colore esterno color_support_weak = MediumAquamarine; //support - supporto per DarkSlateGray debole

colore esterno color_support_untested = SeaGreen; // deselezionato

colore esterno color_support_verified = Verde;

colore esterno color_support_proven = LimeGreen;

colore esterno color_support_turncoat = Olive Drab;

colore esterno color_resist_weak = Siena;

colore esterno color_resist_untested = Orchidea;

colore esterno color_resist_verified = cremisi;

colore esterno color_resist_proven = Rosso;

colore esterno color_resist_turncoat = DarkOrange;

bool esterno zone_show_weak = true;

doppia zona esterna_fattore fuzz = 0,2;

bool esterno zone_solid = false; // true se false, non ci saranno zone a banda intera, ma incorniciate da un rettangolo con larghezza e larghezza

extern int larghezza_zona_linea = 2;

extern int zona_style = 0;

bool esterno zone_show_info = true;

extern int zone_label_shift = 22; // offset orizzontale delle etichette, ma solo dopo aver rimosso l'indicatore

bool esterno zone_show_alerts = false;

bool esterno zone_alert_popups = true;

bool esterno zone_alert_sounds = true;

extern bool send_email = false;

extern int zone_alert_waitseconds = 300;

bool esterno zone_merge = vero;

extern bool zone_extend = true;

extern bool fractals_show = false;

esterno doppio fractal_fast_factor = 3.0;

esterno doppio fractal_slow_factor = 6,0;

bool esterno SetGlobals = true;

doppio FastDnPts[], FastUpPts[];

double SlowDnPts[], SlowUpPts[];

doppia zona_hi[1000], zona_lo[1000];

int inizio_zona[1000], colpi_zona[1000], tipo_zona[1000], forza_zona[1000], conteggio_zona = 0;

boolzone_turn[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

#definisci PUNTO_DN -1

int time_offset = 0;

int init()

{

IndicatorBuffers(4);

SetIndexBuffer(0, SlowDnPts);

SetIndexBuffer(1, SlowUpPts);

SetIndexBuffer(2, FastDnPts);

SetIndexBuffer(3, FastUpPts);

if (fractals_show == vero)

{

SetIndexStyle(0, DRAW_ARROW, 0, 3);

SetIndexStyle(1, DRAW_ARROW, 0, 3);

SetIndexStyle(2, DRAW_ARROW, 0, 1);

SetIndexStyle(3, DRAW_ARROW, 0, 1);

ImpostaFrecciaIndice(0, 218);

ImpostaFrecciaIndice(1, 217);

ImpostaFrecciaIndice(2, 218);

ImpostaFrecciaIndice(3, 217);

}

altro

{

SetIndexStyle(0, DRAW_NONE);

SetIndexStyle(1, DRAW_NONE);

SetIndexStyle(2, DRAW_NONE);

SetIndexStyle(3, DRAW_NONE);

}

if (TimeFrame != 1 && TimeFrame != 5 && TimeFrame != 15 &&

TimeFrame != 60 && TimeFrame != 240 && TimeFrame != 1440 &&

TimeFrame != 10080 && TimeFrame != 43200)

intervallo di tempo = 0;

if(TimeFrame < Periodo())

lasso di tempo = periodo();

ritorno(0);

}

int deinit()

{

EliminaZone();

DeleteGlobalVars();

ritorno(0);

}

inizio int()

{

se (NuovaBarra() == vero)

{

int old_zone_count = zone_count;

Frattali veloci();

Frattali lenti();

EliminaZone();

TrovaZone();

DrawZone();

se (conta_zona < conta_zona_vecchia)

DeleteOldGlobalVars(old_zone_count);

}

se (zone_show_info == vero)

{

for (int i=0; i<conteggio_zona; i++)

{

libbra di stringa;

se (forza_zona[i] == ZONA_PROVATA)

lbl=""; // Provato

altrimenti se (forza_zona[i] == ZONA_VERIFICATA)

lbl=""; // Controllato

altrimenti se (forza_zona[i] == ZONE_UNTESTED)

lbl=""; // NON testare

altrimenti se (forza_zona[i] == ZONE_TURNCOAT)

lbl=""; // Inversione

altro

lbl=""; // Debole

if (tipo_zona[i] == SUPPORTO_ZONA)

lbl = lbl + "sotto"; //Supporto

altro

lbl = lbl + "sop"; //Resistenza

if (zone_hits[i] > 0 && zone_strength[i] > ZONE_UNTESTED)

{

if (zone_hits[i] == 1)

lbl = lbl + ",T=" + zone_hits[i]; //Conteggio test

altro

lbl = lbl + ",T=" + zone_hits[i]; //Conteggio test

}

int aggiusta_hpos;

int wbpc = WindowBarsPerChart();

int k;

k = Periodo() * 60 + (20 + StringLen(lbl));

se (wbpc < 80)

adjust_hpos = Tempo[0] + k * 4;

altrimenti se (wbpc < 125)

adjust_hpos = Tempo[0] + k * 8;

altrimenti se (wbpc < 250)

adjust_hpos = Tempo[0] + k * 15;

altrimenti se (wbpc < 480)

adjust_hpos = Tempo[0] + k * 29;

altrimenti se (wbpc < 950)

adjust_hpos = Tempo[0] + k * 58;

altro

adjust_hpos = Tempo[0] + k * 115;

int shift = k * zona_label_shift;

doppio vpos = zone_hi[i] - (zone_hi[i] - zone_lo[i]) / 2;

// Testo delle descrizioni dei livelli

stringa s = "SSSR#"+i+"LBL";

ObjectCreate(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); //Nero

}

CheckAlerts();

ritorno(0);

}

void CheckAlerts()

{

statico int lastalert = 0;

se (zone_show_alerts == false)

Restituzione;

if (Time[0] - lastalert > zone_alert_waitseconds)

se (CheckEntryAlerts() == vero)

lastalert = Tempo[0];

}

bool CheckEntryAlerts()

{

// controlla i record

for (int i=0; i<conteggio_zona; i++)

{

if (Chiudi[0] >= zone_lo[i] && Chiudi[0] < zone_hi[i])

{

se (zone_show_alerts == vero)

{

se (zone_alert_popups == vero)

{

if (tipo_zona[i] == SUPPORTO_ZONA)

Avviso(Simbolo() + TimeFrameToString(TimeFrame) + ": Zona di supporto inserita"); //Introdotta la zona di supporto

altro

Avviso(Simbolo() + TimeFrameToString(TimeFrame) + ": Zona di resistenza inserita"); //Introdotta la zona di resistenza

}

se (zone_alert_sounds == vero)

PlaySound("alert.wav");

}

se (send_email == vero)

{

stringa dir = "";

stringa msg = StringConcatenate(Simbolo(), "-", TimeFrameToString(TimeFrame), " at ", TimeToStr(Time[0], TIME_DATE|TIME_SECONDS),

" ", dir, "Zona inserita");

if (tipo_zona[i] == SUPPORTO_ZONA)

{

dir = "Supporto";

SendMail("Avviso SS_SupRes_v04c", msg);

}

altro

{

dir="resistenza";

SendMail("Avviso SS_SupRes_v04c", msg);

}

ritorno(vero);

}

ritorno (falso);

}

void DeleteGlobalVars()

{

if(SetGlobals==false)

Restituzione;

GlobalVariableDel("SSSR_Count_"+Simbolo()+TimeFrame);

GlobalVariableDel("SSSR_Aggiornato_"+Simbolo()+TimeFrame);

int conteggio_vecchio = conteggio_zona;

conteggio_zone = 0;

DeleteOldGlobalVars(old_count);

}

void DeleteOldGlobalVars(int old_count)

{

if(SetGlobals==false)

Restituzione;

for (int i=zone_count; i<old_count; i++)

{

GlobalVariableDel("SSSR_HI_"+Simbolo()+TimeFrame+i);

GlobalVariableDel("SSSR_LO_"+Simbolo()+TimeFrame+i);

GlobalVariableDel("SSSR_HITS_"+Simbolo()+TimeFrame+i);

GlobalVariableDel("SSSR_STRENGTH_"+Simbolo()+TimeFrame+i);

GlobalVariableDel("SSSR_AGE_"+Simbolo()+TimeFrame+i);

}

void FindZones()

{

int i, j, shift, bustcount=0, testcount = 0;

doppio hival, loval;

bool girato = falso, hasturned = falso;

doppia temp_hi[1000], temp_lo[1000];

int temp_start[1000], temp_hits[1000], temp_strength[1000], temp_count = 0;

bool temp_turn[1000], temp_merge[1000];

int merge1[1000], merge2[1000], merge_count = 0;

// scorre le zone dalla più vecchia alla più piccola (ignora le ultime 5 barre),

// trovare coloro che sono sopravvissuti fino ad oggi...

for (shift=MathMin(iBars(NULL, TimeFrame)-1, BackLimit); shift>5; shift--)

{

double atr = iATR(NULL, TimeFrame, 7, shift);

doppio fu = atr/2 * zone_fuzzfactor;

bool è debole;

bool touchOk = falso;

bool isBust = falso;

doppia chiusura = iClose(NULL, TimeFrame, shift);

double high = iHigh(NULL, TimeFrame, shift);

double low = iLow(NULL, TimeFrame, shift);

doppio hi_i;

doppio lo_i;

se (FastUpPts[shift] > 0,001)

{

// zigzag del punto più alto

è debole = vero;

se (SlowUpPts[shift] > 0,001)

isWeak = falso;

hival=alto;

if (zone_extend == vero)

hival += fu;

loval = MathMax(MathMin(close, high-fu), high-fu*2);

girare=falso;

è tornato = falso;

isbust=falso;

conta bus = 0;

conteggio test = 0;

for (i=shift-1; i>=0; i--)

{

hi_i = iHigh(NULL, TimeFrame, i);

lo_i = iLow(NULL, TimeFrame, i);

if ((diventato == false && FastUpPts[i] >= loval && FastUpPts[i] <= hival) ||

(diventato == true && FastDnPts[i] <= hival && FastDnPts[i] >= loval))

{

// Potenziale tocco, assicurati che siano trascorse più di 10 candele dall'ultima volta

touchOk = vero;

per (j=i+1; j<i+11; j++)

{

if ((diventato == false && FastUpPts[j] >= loval && FastUpPts[j] <= hival) ||

(diventato == true && FastDnPts[j] <= hival && FastDnPts[j] >= loval))

{

touchOk = falso;

rompere;

}

se (touchOk == vero)

{

// abbiamo un tocco. Se è stato eliminato una volta, rimuovi il conteggio

// poiché sappiamo che questo livello è ancora valido e abbiamo appena cambiato lato

conta bus = 0;

conteggio delle prove++;

}

if ((diventato == false && hi_i > hival) ||

(trasformato == vero && lo_i < loval))

{

// questo livello è stato superato almeno una volta

busto++;

if (bustcount > 1 || isWeak == true)

{

// due o più

isBust = vero;

rompere;

}

se (trasformato == vero)

girare=falso;

altrimenti se (trasformato == falso)

girare=vero;

hasturned = vero;

// dimentica i colpi precedenti

conteggio test = 0;

}

se(èBusto==falso)

{

// il livello è ancora valido, aggiungilo alla nostra lista

temp_hi[temp_count] = hival;

temp_lo[temp_count] = amore;

temp_turn[temp_count] = è tornato;

temp_hits[temp_count] = conteggio test;

temp_start[temp_count] = turno;

temp_merge[temp_count] = falso;

se (conteggio test > 3)

temp_strength[temp_count] = ZONA_PROVATA;

altrimenti se (conteggio test > 0)

temp_strength[temp_count] = ZONA_VERIFICATA;

altrimenti se (trasformato == vero)

temp_strength[temp_count] = ZONE_TURNCOAT;

altrimenti se (è debole == falso)

temp_strength[temp_count] = ZONA_NON TESTED;

altro

temp_strength[temp_count] = ZONA_DEBOLE;

conteggio_temp++;

}

altrimenti se (FastDnPts[shift] > 0,001)

{

// punto a zigzag basso

è debole = vero;

se (SlowDnPts[shift] > 0,001)

isWeak = falso;

lovale = basso;

if (zone_extend == vero)

lovale = fu;

hival = MathMin(MathMax(chiudi, basso+fu), basso+fu*2);

girare=falso;

è tornato = falso;

conta bus = 0;

conteggio test = 0;

isbust=falso;

for (i=shift-1; i>=0; i--)

{

hi_i = iHigh(NULL, TimeFrame, i);

lo_i = iLow(NULL, TimeFrame, i);

if ((diventato == true && FastUpPts[i] >= loval && FastUpPts[i] <= hival) ||

(diventato == false && FastDnPts[i] <= hival && FastDnPts[i] >= loval))

{

// Potenziale tocco, assicurati che siano trascorse più di 10 candele dall'ultima volta

touchOk = vero;

per (j=i+1; j<i+11; j++)

{

if ((diventato == true && FastUpPts[j] >= loval && FastUpPts[j] <= hival) ||

(diventato == false && FastDnPts[j] <= hival && FastDnPts[j] >= loval))

{

touchOk = falso;

rompere;

}

se (touchOk == vero)

{

// abbiamo un tocco. Se è stato eliminato una volta, rimuovi il conteggio

// poiché sappiamo che questo livello è ancora valido e abbiamo appena cambiato lato

conta bus = 0;

conteggio delle prove++;

}

if ((diventato == true && hi_i > hival) ||

(diventato == falso && lo_i < loval))

{

// questo livello è stato superato almeno una volta

busto++;

if (bustcount > 1 || isWeak == true)

{

// due o più

isBust = vero;

rompere;

}

se (trasformato == vero)

girare=falso;

altrimenti se (trasformato == falso)

girare=vero;

hasturned = vero;

// dimentica i colpi precedenti

conteggio test = 0;

}

se(èBusto==falso)

{

// il livello è ancora valido, aggiungilo alla nostra lista

temp_hi[temp_count] = hival;

temp_lo[temp_count] = amore;

temp_turn[temp_count] = è tornato;

temp_hits[temp_count] = conteggio test;

temp_start[temp_count] = turno;

temp_merge[temp_count] = falso;

se (conteggio test > 3)

temp_strength[temp_count] = ZONA_PROVATA;

altrimenti se (conteggio test > 0)

temp_strength[temp_count] = ZONA_VERIFICATA;

altrimenti se (trasformato == vero)

temp_strength[temp_count] = ZONE_TURNCOAT;

altrimenti se (è debole == falso)

temp_strength[temp_count] = ZONA_NON TESTED;

altro

temp_strength[temp_count] = ZONA_DEBOLE;

conteggio_temp++;

}

// cerca zone sovrapposte...

se (unione_zona == vero)

{

conteggio_unione = 1;

iterazioni int = 0;

while (merge_count > 0 && iterazioni < 3)

{

conteggio_unione = 0;

iterazioni++;

for (i = 0; i < temp_count; i++)

temp_merge[i] = falso;

for (i = 0; i < temp_count-1; i++)

{

if (temp_hits[i] == -1 || temp_merge[j] == true)

Continua;

for (j = i+1; j < conteggio_temp; j++)

{

if (temp_hits[j] == -1 || temp_merge[j] == true)

Continua;

if ((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]))

{

merge1[conteggio_unione] = i;

merge2[conteggio_unione] = j;

temp_merge[i] = vero;

temp_merge[j] = vero;

merge_count++;

}

// ... e combinali ...

for (i=0; i<conteggio_unione; i++)

{

int destinazione = merge1[i];

int sorgente = merge2[i];

temp_hi[target] = MathMax(temp_hi[target], temp_hi[source]);

temp_lo[target] = MathMin(temp_lo[target], temp_lo[source]);

temp_hits[target] += temp_hits[sorgente];

temp_start[target] = MathMax(temp_start[target], temp_start[sorgente]);

temp_strength[target] = MathMax(temp_strength[target], temp_strength[sorgente]);

if (temp_hits[target] > 3)

temp_strength[bersaglio] = ZONA_PROVATA;

if (temp_hits[target] == 0 && temp_turn[target] == false)

{

temp_hits[obiettivo] = 1;

if (temp_strength[target] < ZONE_VERIFIED)

temp_strength[obiettivo] = ZONA_VERIFICATA;

}

if (temp_turn[target] == false || temp_turn[source] == false)

temp_turn[obiettivo] = falso;

if (temp_turn[target] == vero)

temp_hits[obiettivo] = 0;

temp_hits[sorgente] = -1;

}

// copia il resto dell'elenco nelle nostre zone ufficiali

conteggio_zone = 0;

for (i=0; i<temp_count; i++)

{

if (temp_hits[i] >= 0 && zone_count < 1000)

{

zona_hi[zone_count] = temp_hi[i];

zona_lo[zone_count] = temp_lo[i];

zone_hits[zone_count] = temp_hits[i];

zona_turno[conta_zone] = temp_turno[i];

inizio_zona[conta_zona] = inizio_temp[i];

forza_zona[conta_zona] = forza_temp[i];

if (zone_hi[zone_count] < Chiudi[4])

tipo_zona[conta_zona] = SUPPORTO_ZONA;

altrimenti se (zone_lo[zone_count] > Chiudi[4])

tipo_zona[conta_zona] = RESISTENZA_ZONA;

altro

{

per (j=5; j<1000; j++)

{

if (iClose(NULL, TimeFrame, j) < zone_lo[zone_count])

{

tipo_zona[conta_zona] = RESISTENZA_ZONA;

rompere;

}

altrimenti se (iClose(NULL, TimeFrame, j) > zone_hi[zone_count])

{

tipo_zona[conta_zona] = SUPPORTO_ZONA;

rompere;

}

se (j == 1000)

tipo_zona[conta_zona] = SUPPORTO_ZONA;

}

conteggio_zone++;

}

void DrawZones()

{

if(SetGlobals==true)

{

GlobalVariableSet("SSSR_Count_"+Simbolo()+TimeFrame, zone_count);

GlobalVariableSet("SSSR_Updated_"+Simbolo()+TimeFrame, TimeCurrent());

}

for (int i=0; i<conteggio_zona; i++)

{

if (zone_strength[i] == ZONE_WEAK && zone_show_weak == false)

Continua;

stringa s = "SSSR#"+i+" Strength=";

se (forza_zona[i] == ZONA_PROVATA)

s = s + "Comprovato, Test Count=" + zone_hits[i];

altrimenti se (forza_zona[i] == ZONA_VERIFICATA)

s = s + "Verificato, Test Count=" + zone_hits[i];

altrimenti se (forza_zona[i] == ZONE_UNTESTED)

s = s + "Non testato";

altrimenti se (forza_zona[i] == ZONE_TURNCOAT)

s = s + "voltagabbana";

altro

s = s + "debole";

ObjectCreate(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);

if (tipo_zona[i] == SUPPORTO_ZONA)

{

// zona di supporto

if (forza_zona[i] == ZONE_TURNCOAT)

ObjectSet(s, OBJPROP_COLOR, color_support_turncoat);

altrimenti se (forza_zona[i] == ZONE_PROVEN)

ObjectSet(s, OBJPROP_COLOR, color_support_proven);

altrimenti se (forza_zona[i] == ZONA_VERIFICATA)

ObjectSet(s, OBJPROP_COLOR, color_support_verified);

altrimenti se (forza_zona[i] == ZONE_UNTESTED)

ObjectSet(s, OBJPROP_COLOR, color_support_untested);

altro

ObjectSet(s, OBJPROP_COLOR, color_support_weak);

}

altro

{

// zona di resistenza

if (forza_zona[i] == ZONE_TURNCOAT)

ObjectSet(s, OBJPROP_COLOR, color_resist_turncoat);

altrimenti se (forza_zona[i] == ZONE_PROVEN)

ObjectSet(s, OBJPROP_COLOR, color_resist_proven);

altrimenti se (forza_zona[i] == ZONA_VERIFICATA)

ObjectSet(s, OBJPROP_COLOR, color_resist_verified);

altrimenti se (forza_zona[i] == ZONE_UNTESTED)

ObjectSet(s, OBJPROP_COLOR, color_resist_untested);

altro

ObjectSet(s, OBJPROP_COLOR, color_resist_weak);

}

if(SetGlobals==true)

{

GlobalVariableSet("SSSR_HI_"+Symbol()+TimeFrame+i, zone_hi[i]);

GlobalVariableSet("SSSR_LO_"+Simbolo()+TimeFrame+i, zone_lo[i]);

GlobalVariableSet("SSSR_HITS_"+Simbolo()+TimeFrame+i, zone_hits[i]);

GlobalVariableSet("SSSR_STRENGTH_"+Symbol()+TimeFrame+i, zone_strength[i]);

GlobalVariableSet("SSSR_AGE_"+Simbolo()+TimeFrame+i, inizio_zona[i]);

}

bool Fractal(int M, int P, int shift)

{

se (TimeFrame > P)

P = lasso di tempo;

P = P / TimeFrame*2 + MathCeil(P / TimeFrame / 2);

se(shift<p)

ritorno (falso);

if (shift > iBars(Simbolo(), TimeFrame)-P)

ritorno (falso);

for (int i=1; i<=P; i++)

{

se (M == PUNTO_UP)

{

if (iHigh(NULL, TimeFrame, shift+i) > iHigh(NULL, TimeFrame, shift))

ritorno (falso);

if (iHigh(NULL, TimeFrame, shift-i) >= iHigh(NULL, TimeFrame, shift))

ritorno (falso);

}

se (M == DN_POINT)

{

if (iLow(NULL, TimeFrame, shift+i) < iLow(NULL, TimeFrame, shift))

ritorno (falso);

if (iLow(NULL, TimeFrame, shift-i) <= iLow(NULL, TimeFrame, shift))

ritorno (falso);

}

ritorno(vero);

}

void FastFractals()

{

turno interno;

limite int = MathMin(Bars-1, BackLimit);

int P = TimeFrame * fattore_frattale_veloce;

FastUpPts[0] = 0,0; FastUpPts[1] = 0,0;

FastDnPts[0] = 0,0; FastDnPts[1] = 0,0;

for (shift=limite; shift>1; shift--)

{

if (Fractal(UP_POINT, P, shift) == vero)

FastUpPts[shift] = iHigh(NULL, TimeFrame, shift);

altro

FastUpPts[shift] = 0,0;

if (Fractal(DN_POINT, P, shift) == vero)

FastDnPts[shift] = iLow(NULL, TimeFrame, shift);

altro

FastDnPts[shift] = 0,0;

}

void SlowFractals()

{

turno interno;

int limit = MathMin(iBars(Symbol(), TimeFrame) - 1, BackLimit);

int P = TimeFrame * fattore_frattale_lento;

SlowUpPts[0] = 0,0; SlowUpPts[1] = 0,0;

SlowDnPts[0] = 0,0; SlowDnPts[1] = 0,0;

for (shift=limite; shift>1; shift--)

{

if (Fractal(UP_POINT, P, shift) == vero)

SlowUpPts[shift] = iHigh(NULL, TimeFrame, shift);

altro

SlowUpPts[shift] = 0,0;

if (Fractal(DN_POINT, P, shift) == vero)

SlowDnPts[shift] = iLow(NULL, TimeFrame, shift);

altro

SlowDnPts[shift] = 0,0;

}

bool NewBar()

{

data e ora statica LastTime = 0;

if (iTime(NULL, TimeFrame, 0) != LastTime)

{

LastTime = iTime(NULL, TimeFrame, 0)+time_offset;

ritorno(vero);

}

altro

ritorno (falso);

}

void DeleteZones()

{

interno = 5;

int io;

while (i <TotaleOggetti())

{

stringa NomeOggetto = NomeOggetto(i);

if (StringSubstr(objName, 0, len) != "SSSR#")

{

i++;

Continua;

}

Elimina oggetto(nomeoggetto);

}

string TimeFrameToString(int tf) // codice da TRO

{

stringa tfs;

interruttore (tf)

{

caso PERIOD_M1:

tfs="M1" ;

rompere;

caso PERIOD_M5:

tfs="M5" ;

rompere;

caso PERIOD_M15:

tfs="M15" ;

rompere;

caso PERIOD_M30:

tfs="M30" ;

rompere;

caso PERIOD_H1:

tfs="H1" ;

rompere;

caso PERIOD_H4:

tfs="H4" ;

rompere;

caso PERIOD_D1:

tfs="D1" ;

rompere;

caso PERIOD_W1:

tfs="W1" ;

rompere;

caso PERIOD_MN1:

tfs="MN";

}

ritorno(tfs);

}

stringa StringRepeat(stringa str, int n = 1)

{

stringa outstr = "";

for(int i = 0; i < n; i++) outstr = outstr + str;

ritorno(outstr);

}

stringa StringRightPad(stringa str, int n=1, stringa str2=" ")

{

return(str + StringRepeat(str2,n-StringLen(str)));

Any questions from newcomers Experts: AG Indicatori multi timeframe

kopeyka2 2019.01.20 18:50 #7442

Passare alla MT5. Aiutami con una parola. Come in MT5 è scritto in codice, cosa c'è di sbagliato?

//+------------------------------------------------------------------+
//|                                                          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);
  }
//+------------------------------------------------------------------+

DOMANDA: Perché tutti i tipi di spazzatura cadono nel buffer?

Sono allo stadio di costruttore di Lego, cioè copio il modulo e capisco le peculiarità di MT% per esperienza. Documentazione, naturalmente.

Parlare dell'OLP nel salone Autoapprendimento del linguaggio MQL5 L'apprendimento automatico nel trading:

Taras Slobodyanik 2019.01.20 18:54 #7443

kopeyka2:

Passare alla MT5. Aiutami con una parola. Come in MT5 è scritto in codice, cosa c'è di sbagliato?

DOMANDA: Perché tutti i tipi di spazzatura cadono nel buffer?

in mt5 la serie temporale va al contrario
se ne hai bisogno come in mt4, cioèArraySetAsSeries

Artyom Trishkin 2019.01.20 21:25 #7444

kopeyka2:

Passare alla MT5. Aiutami con una parola. Come in MT5 è scritto in codice, cosa c'è di sbagliato?

DOMANDA: Perché tutti i tipi di spazzatura cadono nel buffer?

Sono allo stadio di costruttore di Lego, cioè copio il modulo e capisco le peculiarità di MT% per esperienza. Documentazione, naturalmente.

//+------------------------------------------------------------------+
//|                                                          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:

Grazie per la risposta.

Controllato in MT5... Che pasticcio... I punti sono sparsi su tutto il grafico in modo strano, da qualche parte nel profondo della storia... Non capisco cosa e perché MT5 non piace? Il problema è semplice!!!

PRENDILO IN MT4

.

E COSÌ IN MT5. Naturalmente in un buffer. Ma il problema è che l'indicatore cattura i punti, ma non quelli e non lì...(((

Per favore, ditemelo di nuovo. Cosa ho sbagliato nel codice MT5????

Ho qualcosa in MT5. Ma i buffer ... un mistero

Indicatore Domande varie Aiuto per la codifica Auguri per MT5

Alexey Viktorov 2019.01.21 10:04 #7446

kopeyka2:

Grazie per la risposta.

Controllato in MT5... Che pasticcio... I punti sono sparsi su tutto il grafico in modo strano, da qualche parte nel profondo della storia... Non capisco cosa e perché MT5 non piace? Il problema è semplice!!!

PRENDILO IN MT4

.

E COSÌ IN MT5 . Naturalmente in un buffer. Ma il problema è che l'indicatore cattura i punti, ma non quelli e non lì...(((

Per favore, aiutatemi ancora. Cosa ho sbagliato nel codice MT5????

Ho qualcosa in MT5. Ma i buffer ... un mistero

Non c'è nessun mistero. La numerazione è diversa da quella di mql4 e i buffer degli indicatori non vengono azzerati automaticamente. Per eliminare la "spazzatura" il programmatore deve occuparsi della pulizia degli indici se non devono contenere valori.

OnDeinit negli indicatori Errori, bug, domande Domande dai principianti MQL5

kopeyka2 2019.01.21 15:49 #7447

Alexey Viktorov:

Nessun mistero. La numerazione è diversa da quella di mql4 e i buffer degli indicatori non vengono azzerati automaticamente. Per eliminare la "spazzatura" il programmatore deve occuparsi della purezza degli indici se non devono contenere valori.

La domanda è: PERCHE' i segni (punti) sono messi da qualche parte? Ho definito nel codice l'algoritmo !!!! La condizione MA nel corpo della candela. Non è abbastanza?

Alexey Viktorov 2019.01.21 16:25 #7448

kopeyka2:

La domanda è: PERCHE' i segni (punti) sono messi da qualche parte? Ho definito nel codice l'algoritmo !!!! La condizione MA nel corpo della candela. Non è abbastanza?

Qui guarda.

kopeyka2:
Passare alla MT5. Aiutami con una parola.

Artem ha dato il codice completo invece della parola aiuto. Ognuno ha il suo approccio. Cerco di non dare codice preconfezionato, ma a volte fallisco ancora.

kopeyka2:

Grazie per la risposta.

Controllato in MT5... È un po' un casino...

Ma i grafici di confronto sono tempi completamente diversi. Come si può giudicare se i punti sono giusti o sbagliati?

Da qui una parola di aiuto.

Forum sul trading, sistemi di trading automatico e test di strategia

Qualsiasi domanda, aiuto e discussione su algoritmi e codici per i principianti di MQL4

Alexey Viktorov, 2019.01.21 11:04

Nessun mistero. La numerazione è diversa da quella di mql4 e i buffer degli indicatori non vengono azzerati automaticamente. Per eliminare la "spazzatura" il programmatore stesso dovrebbe occuparsi della pulizia degli indici se non devono contenere valori.

Aiuto: In MT5 hanno fatto una sequenza inadeguata di esecuzioni OnInit e OnDeinit, quindi ci possono essere anche problemi. Ma lo è in alcuni casi speciali, e il ricalcolo dell'indicatore dovrebbe essere SEMPRE consecutivo. A condizione che prev_calculated == 0, il ricalcolo dovrebbe essere eseguito per tutte le barre e ad ogni iterazione del ciclo, se non dovrebbe esserci alcun valore nel buffer, allora riempire questo indice di array con il valore EMPTY_VALUE o 0 a seconda dell'impostazione PLOT_EMPTY_VALUE

Domande dai principianti MQL5 Caratteristiche del linguaggio mql4, Errori, bug, domande

kopeyka2 2019.01.21 17:59 #7449

Alexey Viktorov:

Ecco uno sguardo.

Artyom ha dato il codice completo invece di aiutare con la parola. Ognuno ha un approccio diverso a questo. Cerco di non dare codice preconfezionato, ma ancora a volte fallisce.

Ma i grafici di confronto sono tempi completamente diversi. Come si può giudicare se i punti sono giusti o sbagliati?

Da qui una parola di aiuto.

Più aiuto in parole: in MT5 hanno fatto una sequenza inadeguata di esecuzioni OnInit e OnDeinit, quindi ci possono essere anche problemi. Ma lo è in alcuni casi speciali, e il ricalcolo dell'indicatore dovrebbe essere SEMPRE consecutivo. A condizione che prev_calculated == 0, ricalcolare su tutte le barre e ad ogni iterazione del ciclo, se non ci dovesse essere alcun valore nel buffer, riempire questo indice della matrice con il valore EMPTY_VALUE o 0 a seconda dell'impostazione PLOT_EMPTY_VALUE

Hallelujah!!!!! Ha cambiato open[i] e close[i] in iOpen(NULL,PERIOD_H1,i)

Artyom Trishkin 2019.01.21 18:16 #7450

kopeyka2:

Hallelujah!!!!! Ha cambiato open[i] e close[i] in iOpen(NULL,PERIOD_H1,i)

Qual è la differenza? Se l'indicatore è su H1, è solo nella velocità di accesso - ne hai uno più lento. Nel mio esempio, devi aver dimenticato che devi impostare l'indicizzazione seriale per gli array aperti e chiusi. Ho evidenziato ciò che non avevi. Avete un ciclo dall'inizio alla fine - dal limite allo 0, e non avete indicizzato gli array - quindi è stato disegnato all'indietro e in avanti.

Domande dai principianti MQL5 Errori, bug, domande Aiuto per la codifica

Tutte le domande dei nuovi arrivati su MQL4 e MQL5, aiuto e discussione su algoritmi e codici - pagina 745