Cualquier pregunta de los recién llegados sobre MQL4 y MQL5, ayuda y discusión sobre algoritmos y códigos

Konstantin Lebedev 2019.01.20 10:26 #7441

¿Es posible ocultar todas las bandas de nivel de reversión en el indicador, no probadas y el resto, y dejar solo las probadas, es decir, ocultar extern bool zone_show_weak = true; y debajo en el código si (zone_strength[i] == ZONE_WEAK && zone_show_weak == false) y otros no se pueden ocultar. Tal vez alguien entienda y corrija el código o elimine los niveles que describí anteriormente. Código indicador:

#enlace de propiedad ""

#propiedad indicador_gráfico_ventana

#indicador de propiedades_amortiguadores 4

#indicador de propiedad_color1 Rojo

#indicador de propiedad_color2 Rojo

#indicador de propiedad_color3 DodgerBlue

#indicador de propiedad_color4 DodgerBlue

externo interno BackLimit = 300; //Atras, atras

marco de tiempo externo interno = 0;

cadena externa TimeString = "0=Actual, 60=H1, 240=H4, 1440=Día, 10080=Semana, 43200=Mes";

color externo color_support_weak = MediumAquamarine; // soporte - soporte para DarkSlateGray débil

color externo color_support_untested = SeaGreen; // desmarcado

color externo color_support_verified = Verde;

color externo color_support_proven = LimeGreen;

color externo color_support_turncoat = verde oliva;

color externo color_resist_weak = Siena;

color externo color_resist_untested = Orquídea;

color externo color_resist_verified = Carmesí;

color externo color_resist_proven = Rojo;

color externo color_resist_turncoat = naranja oscuro;

bool externo zone_show_weak = verdadero;

externo doble zone_fuzzfactor = 0.2;

booleano externo zone_solid = falso; // verdadero si es falso, no habrá zonas de banda completa, sino enmarcadas por un rectángulo con ancho ancho

externo int zone_linewidth = 2;

externo int zone_style = 0;

externo bool zone_show_info = verdadero;

externo int zone_label_shift = 22; // desplazamiento horizontal de las etiquetas, pero solo después de eliminar el indicador

booleano externo zone_show_alerts = falso;

booleano externo zone_alert_popups = verdadero;

externo bool zone_alert_sounds = verdadero;

externo bool enviar_email = falso;

externo int zone_alert_waitseconds = 300;

bool externo zone_merge = verdadero;

bool externo zone_extend = verdadero;

extern bool fractals_show = false;

externo doble fractal_fast_factor = 3.0;

externo doble fractal_slow_factor = 6.0;

bool externo SetGlobals = verdadero;

doble FastDnPts[], FastUpPts[];

double SlowDnPts[], SlowUpPts[];

doble zone_hi[1000], zone_lo[1000];

int zone_start[1000], zone_hits[1000], zone_type[1000], zone_strength[1000], zone_count = 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_VERIFICADO 3

#define ZONE_PROVEN 4

#define UP_POINT 1

#define DN_POINT -1

int time_offset = 0;

int inicial()

{

Indicadores de búfer (4);

SetIndexBuffer(0, SlowDnPts);

SetIndexBuffer(1, SlowUpPts);

SetIndexBuffer(2, FastDnPts);

SetIndexBuffer(3, FastUpPts);

si (fractals_show == verdadero)

{

SetIndexStyle(0, DIBUJAR_FLECHA, 0, 3);

SetIndexStyle(1, DIBUJAR_FLECHA, 0, 3);

SetIndexStyle(2, DIBUJAR_FLECHA, 0, 1);

SetIndexStyle(3, DIBUJAR_FLECHA, 0, 1);

EstablecerFlechaÍndice(0, 218);

EstablecerFlechaÍndice(1, 217);

EstablecerFlechaÍndice(2, 218);

EstablecerFlechaÍndice(3, 217);

}

demás

{

SetIndexStyle(0, DRAW_NONE);

SetIndexStyle(1, DRAW_NONE);

SetIndexStyle(2, DRAW_NONE);

SetIndexStyle(3, DRAW_NONE);

}

if (Marco de tiempo != 1 && Marco de tiempo != 5 && Marco de tiempo != 15 &&

Marco de tiempo != 60 && Marco de tiempo != 240 && Marco de tiempo != 1440 &&

Marco de tiempo != 10080 && Marco de tiempo != 43200)

marco de tiempo = 0;

si (marco de tiempo <período ())

marco de tiempo = período ();

retorno(0);

}

definición int()

{

EliminarZonas();

DeleteGlobalVars();

retorno(0);

}

inicio int()

{

if (NuevaBarra() == verdadero)

{

int old_zone_count = zone_count;

Fractales Rápidos();

Fractaleslentos();

EliminarZonas();

BuscarZonas();

DibujarZonas();

if (zone_count < old_zone_count)

DeleteOldGlobalVars(old_zone_count);

}

si (zone_show_info == verdadero)

{

para (int i=0; i<zone_count; i++)

{

cadena lbl;

if (zone_strength[i] == ZONE_PROVEN)

lbl=""; // Probado

si no (zone_strength[i] == ZONE_VERIFIED)

lbl=""; // Comprobado

si no (zone_strength[i] == ZONE_UNTESTED)

lbl=""; // NO prueba

si no (zone_strength[i] == ZONE_TURNCOAT)

lbl=""; // Inversión

demás

lbl=""; // Débil

if (zone_type[i] == ZONE_SUPPORT)

lbl = lbl + "debajo"; //Apoyo

demás

lbl = lbl + "sop"; //Resistencia

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

{

si (zona_hits[i] == 1)

lbl = lbl + ",T=" + zone_hits[i]; //Recuento de prueba

demás

lbl = lbl + ",T=" + zone_hits[i]; //Recuento de prueba

}

int ajustar_hpos;

int wbpc = WindowBarsPerChart();

intk;

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

si (wbpc < 80)

ajustar_hpos = Tiempo[0] + k * 4;

si no (wbpc < 125)

ajustar_hpos = Tiempo[0] + k * 8;

si no (wbpc < 250)

ajustar_hpos = Tiempo[0] + k * 15;

si no (wbpc < 480)

ajustar_hpos = Tiempo[0] + k * 29;

si no (wbpc < 950)

ajustar_hpos = Tiempo[0] + k * 58;

demás

ajustar_hpos = Tiempo[0] + k * 115;

cambio int = k * zone_label_shift;

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

// Texto de las descripciones de los niveles

cadena 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); //Negro

}

Comprobar Alertas();

retorno(0);

}

anular CheckAlerts()

{

static int lastalert = 0;

si (zone_show_alerts == falso)

devolver;

if (Tiempo[0] - últimaalert > zone_alert_waitseconds)

si (CheckEntryAlerts() == verdadero)

última alerta = Hora[0];

}

bool Comprobar alertas de entrada ()

{

// comprobar las entradas

para (int i=0; i<zone_count; i++)

{

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

{

si (zone_show_alerts == verdadero)

{

si (zone_alert_popups == verdadero)

{

if (zone_type[i] == ZONE_SUPPORT)

Alert(Symbol() + TimeFrameToString(TimeFrame) + ": Zona de soporte ingresada"); //Zona de apoyo introducida

demás

Alert(Symbol() + TimeFrameToString(TimeFrame) + ": Zona de resistencia ingresada"); //Zona de resistencia introducida

}

si (zone_alert_sounds == verdadero)

ReproducirSonido("alerta.wav");

}

si (enviar_email == verdadero)

{

cadena dir = "";

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

" ", dir, "Zona ingresada");

if (zone_type[i] == ZONE_SUPPORT)

{

dir = "Soporte";

SendMail("Alerta SS_SupRes_v04c", mensaje);

}

demás

{

dir="resistencia";

SendMail("Alerta SS_SupRes_v04c", mensaje);

}

retorno (verdadero);

}

falso retorno);

}

void DeleteGlobalVars()

{

if(SetGlobals==falso)

devolver;

GlobalVariableDel("SSSR_Count_"+Símbolo()+Marco de tiempo);

GlobalVariableDel("SSSR_Updated_"+Símbolo()+Marco de tiempo);

int old_count = zone_count;

recuento_zona = 0;

DeleteOldGlobalVars(old_count);

}

void DeleteOldGlobalVars(int old_count)

{

if(SetGlobals==falso)

devolver;

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

{

GlobalVariableDel("SSSR_HI_"+Símbolo()+Marco de tiempo+i);

GlobalVariableDel("SSSR_LO_"+Símbolo()+Marco de tiempo+i);

GlobalVariableDel("SSSR_HITS_"+Símbolo()+Marco de tiempo+i);

GlobalVariableDel("SSSR_STRENGTH_"+Símbolo()+Marco de tiempo+i);

GlobalVariableDel("SSSR_AGE_"+Símbolo()+Marco de tiempo+i);

}

void BuscarZonas()

{

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

hival doble, loval;

bool convertido = falso, ha convertido = falso;

doble temp_alta[1000], temp_baja[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;

// recorrer las zonas de la más antigua a la más pequeña (ignorar los últimos 5 compases),

// encontrar a los que sobrevivieron hasta el presente...

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

{

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

doble fu = atr/2 * zone_fuzzfactor;

bool es Débil;

bool toqueOk = falso;

bool esBusto = falso;

cierre doble = iClose(NULL, TimeFrame, shift);

doble alto = iHigh(NULL, TimeFrame, shift);

doble bajo = iLow(NULL, TimeFrame, shift);

doble hola_i;

doble lo_i;

si (FastUpPts[shift] > 0.001)

{

// punto alto en zigzag

esDébil = verdadero;

si (SlowUpPts[shift] > 0.001)

esDébil = falso;

hival=alto;

si (zone_extend == verdadero)

hival += fu;

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

giro=falso;

se ha vuelto=falso;

esbusto=falso;

contador de bus = 0;

recuento de pruebas = 0;

para (i=desplazamiento-1; i>=0; i--)

{

hi_i = iHigh(NULL, TimeFrame, i);

lo_i = iLow(NULL, TimeFrame, i);

if ((convertido == falso && FastUpPts[i] >= loval && FastUpPts[i] <= hival) ||

(convertido == verdadero && FastDnPts[i] <= hival && FastDnPts[i] >= loval))

{

// Toque potencial, solo asegúrate de que hayan pasado más de 10 velas desde la última vez

tocarOk = verdadero;

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

{

if ((convertido == falso && FastUpPts[j] >= loval && FastUpPts[j] <= hival) ||

(convertido == verdadero && FastDnPts[j] <= hival && FastDnPts[j] >= loval))

{

tocarOk = falso;

romper;

}

si (tocarOk == verdadero)

{

// tenemos un toque. Si fue arrestado una vez, elimine el bustcount

// ya que sabemos que este nivel sigue siendo válido y acaba de cambiar de lado

contador de bus = 0;

recuento de pruebas++;

}

if ((convertido == falso && hi_i > hival) ||

(convertido == verdadero && lo_i <loval))

{

// este nivel ha sido violado al menos una vez

recuento de busto ++;

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

{

// dos o más

esBusto = verdadero;

romper;

}

si (convertido == verdadero)

giro=falso;

más si (convertido == falso)

giro=verdadero;

se ha vuelto = verdadero;

// olvidar golpes anteriores

recuento de pruebas = 0;

}

si(esBusto==falso)

{

// el nivel sigue siendo válido, agregue a nuestra lista

temp_hi[temp_count] = hival;

temp_lo[temp_count] = loval;

temp_turn[temp_count] = ha girado;

temp_hits[temp_count] = testcount;

temp_start[temp_count] = turno;

temp_merge[temp_count] = falso;

si (recuento de pruebas > 3)

temp_strength[temp_count] = ZONE_PROVEN;

si no (recuento de pruebas > 0)

temp_strength[temp_count] = ZONA_VERIFICADA;

otra cosa si (se ha vuelto == verdadero)

temp_strength[temp_count] = ZONE_TURNCOAT;

más si (es débil == falso)

temp_strength[temp_count] = ZONE_UNTESTED;

demás

temp_strength[temp_count] = ZONA_DÉBIL;

cuenta_temp++;

}

si no (FastDnPts[shift] > 0.001)

{

// punto de zigzag bajo

esDébil = verdadero;

si (SlowDnPts[shift] > 0.001)

esDébil = falso;

loval = bajo;

si (zone_extend == verdadero)

loval = fu;

hival = MathMin(MathMax(cerrar, bajo+fu), bajo+fu*2);

giro=falso;

se ha vuelto=falso;

contador de bus = 0;

recuento de pruebas = 0;

esbusto=falso;

para (i=desplazamiento-1; i>=0; i--)

{

hi_i = iHigh(NULL, TimeFrame, i);

lo_i = iLow(NULL, TimeFrame, i);

if ((convertido == verdadero && FastUpPts[i] >= loval && FastUpPts[i] <= hival) ||

(convertido == falso && FastDnPts[i] <= hival && FastDnPts[i] >= loval))

{

// Toque potencial, solo asegúrate de que hayan pasado más de 10 velas desde la última vez

tocarOk = verdadero;

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

{

if ((convertido == verdadero && FastUpPts[j] >= loval && FastUpPts[j] <= hival) ||

(convertido == falso && FastDnPts[j] <= hival && FastDnPts[j] >= loval))

{

tocarOk = falso;

romper;

}

si (tocarOk == verdadero)

{

// tenemos un toque. Si fue arrestado una vez, elimine el bustcount

// ya que sabemos que este nivel sigue siendo válido y acaba de cambiar de lado

contador de bus = 0;

recuento de pruebas++;

}

if ((convertido == verdadero && hi_i > hival) ||

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

{

// este nivel ha sido violado al menos una vez

recuento de busto ++;

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

{

// dos o más

esBusto = verdadero;

romper;

}

si (convertido == verdadero)

giro=falso;

más si (convertido == falso)

giro=verdadero;

se ha vuelto = verdadero;

// olvidar golpes anteriores

recuento de pruebas = 0;

}

si(esBusto==falso)

{

// el nivel sigue siendo válido, agregue a nuestra lista

temp_hi[temp_count] = hival;

temp_lo[temp_count] = loval;

temp_turn[temp_count] = ha girado;

temp_hits[temp_count] = testcount;

temp_start[temp_count] = turno;

temp_merge[temp_count] = falso;

si (recuento de pruebas > 3)

temp_strength[temp_count] = ZONE_PROVEN;

si no (recuento de pruebas > 0)

temp_strength[temp_count] = ZONA_VERIFICADA;

otra cosa si (se ha vuelto == verdadero)

temp_strength[temp_count] = ZONE_TURNCOAT;

más si (es débil == falso)

temp_strength[temp_count] = ZONE_UNTESTED;

demás

temp_strength[temp_count] = ZONA_DÉBIL;

cuenta_temp++;

}

// buscar zonas superpuestas...

si (zone_merge == verdadero)

{

combinar_cuenta = 1;

iteraciones internas = 0;

while (merge_count > 0 && iteraciones < 3)

{

combinar_cuenta = 0;

iteraciones++;

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

temp_merge[i] = falso;

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

{

si (temp_hits[i] == -1 || temp_merge[j] == verdadero)

Seguir;

para (j = i+1; j < cuenta_temp; j++)

{

si (temp_hits[j] == -1 || temp_merge[j] == verdadero)

Seguir;

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_baja[j] <= temp_alta[i] && temp_baja[j] >= temp_baja[i]))

{

fusionar1[merge_count] = i;

fusionar2[merge_count] = j;

temp_merge[i] = verdadero;

temp_merge[j] = verdadero;

unir_cuenta++;

}

// ... y combinarlos ...

para (i=0; i<merge_count; i++)

{

int objetivo = fusionar1[i];

fuente int = fusionar2[i];

temp_hi[objetivo] = MathMax(temp_hi[objetivo], temp_hi[fuente]);

temp_lo[objetivo] = MathMin(temp_lo[objetivo], temp_lo[origen]);

temp_hits[objetivo] += temp_hits[origen];

temp_start[objetivo] = MathMax(temp_start[objetivo], temp_start[origen]);

temp_strength[objetivo] = MathMax(temp_strength[objetivo], temp_strength[fuente]);

si (temp_hits[objetivo] > 3)

temp_strength[objetivo] = ZONE_PROVEN;

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

{

temp_hits[objetivo] = 1;

if (temp_strength[target] <ZONE_VERIFIED)

fuerza_temp[objetivo] = ZONA_VERIFICADA;

}

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

temp_turn[objetivo] = falso;

if (temp_turn[objetivo] == verdadero)

temp_hits[objetivo] = 0;

temp_hits[fuente] = -1;

}

// copia el resto de la lista a nuestras zonas oficiales

recuento_zona = 0;

para (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_strength[zone_count] = temp_strength[i];

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

zone_type[zone_count] = ZONE_SUPPORT;

else if (zone_lo[zone_count] > Cerrar[4])

zone_type[zone_count] = ZONE_RESIST;

demás

{

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

{

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

{

zone_type[zone_count] = ZONE_RESIST;

romper;

}

más si (iClose(NULL, TimeFrame, j) > zone_hi[zone_count])

{

zone_type[zone_count] = ZONE_SUPPORT;

romper;

}

si (j == 1000)

zone_type[zone_count] = ZONE_SUPPORT;

}

zone_count++;

}

void DrawZones()

{

if(SetGlobals==verdadero)

{

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

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

}

para (int i=0; i<zone_count; i++)

{

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

Seguir;

cadena s = "SSSR#"+i+" Fuerza=";

if (zone_strength[i] == ZONE_PROVEN)

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

si no (zone_strength[i] == ZONE_VERIFIED)

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

si no (zone_strength[i] == ZONE_UNTESTED)

s = s + "No probado";

si no (zone_strength[i] == ZONE_TURNCOAT)

s = s + "Chaquetón";

demás

s = s + "débil";

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 (zone_type[i] == ZONE_SUPPORT)

{

// zona de apoyo

if (zone_strength[i] == ZONE_TURNCOAT)

ObjectSet(s, OBJPROP_COLOR, color_support_turncoat);

si no (zone_strength[i] == ZONE_PROVEN)

ObjectSet(s, OBJPROP_COLOR, color_support_proven);

si no (zone_strength[i] == ZONE_VERIFIED)

ObjectSet(s, OBJPROP_COLOR, color_support_verified);

si no (zone_strength[i] == ZONE_UNTESTED)

ObjectSet(s, OBJPROP_COLOR, color_support_untested);

demás

ObjectSet(s, OBJPROP_COLOR, color_support_weak);

}

demás

{

// zona de resistencia

if (zone_strength[i] == ZONE_TURNCOAT)

ObjectSet(s, OBJPROP_COLOR, color_resist_turncoat);

si no (zone_strength[i] == ZONE_PROVEN)

ObjectSet(s, OBJPROP_COLOR, color_resist_proven);

si no (zone_strength[i] == ZONE_VERIFIED)

ObjectSet(s, OBJPROP_COLOR, color_resist_verified);

si no (zone_strength[i] == ZONE_UNTESTED)

ObjectSet(s, OBJPROP_COLOR, color_resist_untested);

demás

ObjectSet(s, OBJPROP_COLOR, color_resist_weak);

}

if(SetGlobals==verdadero)

{

GlobalVariableSet("SSSR_HI_"+Símbolo()+Marco de tiempo+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 (Marco de tiempo > P)

P = marco de tiempo;

P = P / Marco de tiempo * 2 + MathCeil (P / Marco de tiempo / 2);

si (cambio <p)

falso retorno);

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

falso retorno);

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

{

si (M == PUNTO_ARRIBA)

{

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

falso retorno);

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

falso retorno);

}

si (M == DN_PUNTO)

{

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

falso retorno);

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

falso retorno);

}

retorno (verdadero);

}

anular FastFractals()

{

int-desplazamiento;

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

int P = Marco de tiempo * fractal_fast_factor;

FastUpPts[0] = 0.0; FastUpPts[1] = 0.0;

FastDnPts[0] = 0.0; FastDnPts[1] = 0.0;

for (shift=límite; shift>1; shift--)

{

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

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

demás

FastUpPts[cambio] = 0.0;

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

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

demás

FastDnPts[desplazamiento] = 0,0;

}

void Fractales Lentos()

{

int-desplazamiento;

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

int P = Marco de tiempo * fractal_slow_factor;

SlowUpPts[0] = 0.0; SlowUpPts[1] = 0.0;

SlowDnPts[0] = 0.0; SlowDnPts[1] = 0.0;

for (shift=límite; shift>1; shift--)

{

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

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

demás

SlowUpPts[cambio] = 0.0;

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

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

demás

SlowDnPts[desplazamiento] = 0,0;

}

bool NuevaBarra()

{

fecha y hora estática LastTime = 0;

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

{

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

retorno (verdadero);

}

demás

falso retorno);

}

anular EliminarZonas()

{

intlen = 5;

ent yo;

while (i <TotalObjetos())

{

cadena objName = ObjectName(i);

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

{

yo++;

Seguir;

}

EliminarObjeto(objNombre);

}

cadena TimeFrameToString(int tf) // código de TRO

{

cadena tfs;

cambiar (tf)

{

caso PERIODO_M1:

tfs="M1" ;

romper;

caso PERIODO_M5:

tfs="M5" ;

romper;

caso PERIODO_M15:

tfs="M15" ;

romper;

caso PERIODO_M30:

tfs="M30" ;

romper;

caso PERIODO_H1:

tfs="H1" ;

romper;

caso PERIODO_H4:

tfs="H4" ;

romper;

caso PERIODO_D1:

tfs="D1" ;

romper;

caso PERIODO_W1:

tfs="W1" ;

romper;

caso PERIODO_MN1:

tfs="MN";

}

retorno(tfs);

}

cadena StringRepeat(cadena str, int n = 1)

{

cadena salida = "";

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

return(outstr);

}

cadena StringRightPad(cadena str, int n=1, string str2=" ")

{

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

Any questions from newcomers Experts: AG Ayuda a la codificación

kopeyka2 2019.01.20 18:50 #7442

Cambiando a MT5. Ayúdame con una palabra. ¿Cómo escribe MT5 en código, qué es lo que falla?

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

PREGUNTA: ¿Por qué cae todo tipo de basura en el tampón?

Estoy en la etapa de constructor de Lego, es decir, copio el módulo y trato de entender las peculiaridades de MT5 por la experiencia. Documentación, por supuesto.

Errores, fallos, preguntas Preguntas de los principiantes Negociación en línea sobre

Taras Slobodyanik 2019.01.20 18:54 #7443

kopeyka2:

Cambiando a MT5. Ayúdame con una palabra. ¿Cómo escribe MT5 en el código, lo que está mal?

PREGUNTA: ¿Por qué cae todo tipo de basura en el tampón?

en mt5 las series de tiempo van al revés
si lo necesitas igual que en mt4, es decirArraySetAsSeries

Artyom Trishkin 2019.01.20 21:25 #7444

kopeyka2:

Cambiando a MT5. Ayúdame con una palabra. ¿Cómo en MT5 se escribe en código, lo que está mal?

PREGUNTA: ¿Por qué cae todo tipo de basura en el tampón?

Estoy en la fase de constructor de Lego, es decir, copio el módulo y entiendo las peculiaridades del MT% por experiencia. Documentación, por supuesto.

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

Gracias por la respuesta.

Comprobado en MT5... Qué lío... Los puntos están dispersos por todo el gráfico de forma extraña, en algún lugar de la historia... No entiendo qué y por qué no le gusta a MT5? ¡¡¡El problema es simple!!!

TÓMALO EN MT4

.

Y ASÍ EN MT5. Por supuesto en un buffer. Pero el problema es que el indicador está cogiendo puntos, pero no esos y no ahí...(((

Por favor, dígame otra vez. Lo que hice mal en el código MT5????

Tengo algo en MT5. Pero los topes... un misterio

[ARCHIVO]Cualquier pregunta de novato, Sobre la desigual probabilidad Ayuda a la codificación

Alexey Viktorov 2019.01.21 10:04 #7446

kopeyka2:

Gracias por la respuesta.

Comprobado en MT5... Qué lío... Los puntos están dispersos por todo el gráfico de forma extraña, en algún lugar de la historia... No entiendo qué y por qué no le gusta a MT5? ¡¡¡El problema es simple!!!

TÓMALO EN MT4

.

Y ASÍ EN MT5 . Por supuesto, en un buffer. Pero el problema es que el indicador está cogiendo puntos, pero no esos y no ahí...(((

Por favor, ayúdenme de nuevo. Lo que hice mal en el código MT5????

Tengo algo en MT5. Pero los topes... un misterio

No hay ningún misterio. La numeración es diferente a la de mql4 y los buffers de los indicadores no se ponen a cero automáticamente. Para limpiar la "basura", el programador debe cuidar la limpieza de los índices si no van a contener valores.

Para quienes se han Errores, fallos, preguntas ¡¡¡Vamos SetLastError!!!

kopeyka2 2019.01.21 15:49 #7447

Alexey Viktorov:

No es un misterio. La numeración es diferente a la de mql4 y los buffers de los indicadores no se ponen a cero automáticamente. Para despejar la "basura", el programador debe cuidar la pureza de los índices para que no contengan valores.

La pregunta es, ¿POR QUÉ se ponen las marcas (puntos) en cualquier lugar? ¡¡¡¡He definido en el código el algoritmom!!!! La condición de MA en el cuerpo de la vela. ¿No es suficiente?

Alexey Viktorov 2019.01.21 16:25 #7448

kopeyka2:

La pregunta es, ¿POR QUÉ se ponen las marcas (puntos) en cualquier lugar? ¡¡¡¡He definido en el código el algoritmom!!!! La condición de MA en el cuerpo de la vela. ¿No es suficiente?

Mira aquí.

kopeyka2:
Cambiando a MT5. Ayúdame con una palabra.

Artem ha dado el código completo en lugar de la palabra ayuda. Cada uno tiene su propio enfoque al respecto. Intento no dar código ya hecho, pero aún así a veces fallo.

kopeyka2:

Gracias por la respuesta.

Comprobado en MT5... Es un poco desordenado...

Pero los gráficos de comparación son tiempos completamente diferentes. ¿Cómo se puede juzgar si los puntos están bien o mal?

Por lo tanto, una palabra de ayuda.

Foro sobre comercio, sistemas de comercio automatizados y pruebas de estrategias

Cualquier pregunta para principiantes de MQL4, ayuda y discusión sobre algoritmos y códigos

Alexey Viktorov, 2019.01.21 11:04

No es un misterio. La numeración es diferente a la de mql4 y los búferes de los indicadores no se ponen a cero automáticamente. Para limpiar la "basura", el propio programador debe ocuparse de la limpieza de los índices si no deben contener valores.

Ayuda: En MT5 hicieron una secuencia inadecuada de ejecuciones OnInit y OnDeinit, por lo que también puede haber problemas. Pero es en algunos casos especiales, y el recálculo del indicador debe ser SIEMPRE consecutivo. Siempre que prev_calculated == 0, el recálculo debe realizarse para todas las barras y en cada iteración del bucle, si no debe haber ningún valor en el buffer, entonces rellena este índice del array con el valor EMPTY_VALUE o 0 dependiendo de la configuración de PLOT_EMPTY_VALUE

Preguntas de los principiantes Errores, fallos, preguntas ¿Se puede resolver en

kopeyka2 2019.01.21 17:59 #7449

Alexey Viktorov:

Aquí tienes un vistazo.

Artiom dio el código completo en lugar de ayudar con la palabra. Cada uno tiene un enfoque diferente de esto. Intento no dar un código ya hecho, pero aún así a veces falla.

Pero los gráficos de comparación son tiempos completamente diferentes. ¿Cómo se puede juzgar si los puntos son correctos o incorrectos?

Por lo tanto, una palabra de ayuda.

Más ayuda en palabras: En MT5 hicieron una secuencia inadecuada de ejecuciones OnInit y OnDeinit, de ahí que también pueda haber problemas. Pero sí lo es en algunos casos especiales, y el recálculo de indicadores debería ser SIEMPRE consecutivo. Siempre que prev_calculated == 0, recalcula en todas las barras y en cada iteración del bucle, si no hay ningún valor en el buffer, rellena este índice de la matriz con el valor EMPTY_VALUE o 0 dependiendo de la configuración de PLOT_EMPTY_VALUE

Hallelujah!!!!! Cambiado open[i] y close[i] a iOpen(NULL,PERIOD_H1,i)

Artyom Trishkin 2019.01.21 18:16 #7450

kopeyka2:

Hallelujah!!!!! Cambiado open[i] y close[i] a iOpen(NULL,PERIOD_H1,i)

¿Cuál es la diferencia? Si el indicador está en H1, es sólo en la velocidad de acceso - usted tiene uno más lento. En mi ejemplo, probablemente se te haya pasado por alto que tienes que configurar los arrays open y close para la indexación en serie. Subrayé lo que no tenías. Tienes un bucle desde el principio hasta el final - desde el límite hasta el 0, y no has indexado arrays - por lo que se ha dibujado hacia atrás y hacia delante.

Preguntas de los principiantes Simple y rentable [ARCHIVO] Cualquier pregunta de

Cualquier pregunta de los recién llegados sobre MQL4 y MQL5, ayuda y discusión sobre algoritmos y códigos - página 745