Lo que devuelven las funciones Lowest y Highest - página 2

Nuevo comentario
 
nen
No pude responder (estaba fuera). Coloca el código que necesitas parsear para hablar de una cosa.
ZS En ese zigzag no era un error sino una errata (en comparación con el código en MT3), sólo encontré esta errata y no corregí nada más.
 
Vladislav, por alguna razón tu código no funciona en todos los plazos. Funciona en algunos, pero no en otros. Es extraño. Funciona.
 
Rosh, aquí está el código de codebase.mql4.com. Yo tengo el mismo. Si es posible superarlo con todo el mundo, estaré muy agradecido. No seré el único. Gracias de antemano por su ayuda.

Ahora he acumulado un gran número de esas u otras ediciones. Funcionan bastante bien. Sin embargo, el primer rayo -el que parte de la barra cero o de cualquiera de las primeras barras- falla con errores en funciones de identificación de extremos. Y el indicador funciona de forma inestable.

//+------------------------------------------------------------------+
//| Media móvil personalizada.mq4 |
//| Copyright © 2005, MetaQuotes Software Corp.
//| https://www.metaquotes.net/ |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2005, MetaQuotes Software Corp."
#enlace de la propiedad "https://www.metaquotes.net/

#propiedad ventana_del_gráfica_del_indicador
#property indicator_buffers 1
#property indicator_color1 Rojo
//---- parámetros del indicador
extern intDepth=12;
extern inttern ExtDeviation=5;
extern inttern ExtBackstep=3;
//---- búferes indicadores
doble ExtMapBuffer[];
doble ExtMapBuffer2[];

//+------------------------------------------------------------------+
//| Función de inicialización de indicadores personalizada |
//+------------------------------------------------------------------+
int init()
{
IndicatorBuffers(2);
//---- ajustes de dibujo
SetIndexStyle(0,DRAW_SECTION);
//---- asignación de topes indicadores
SetIndexBuffer(0,ExtMapBuffer);
SetIndexBuffer(1,ExtMapBuffer2);
SetIndexEmptyValue(0,0.0);
//---- nombre corto del indicador
IndicatorShortName("ZigZag("+ExtDepth+", "+ExtDeviation+", "+ExtBackstep+")";
//---- inicialización realizada
return(0);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int inicio()
{
int cambio,atrás,última posición alta,última posición baja;
doble val,res;
doble curlow,curhigh,lastthigh,lastlow;

for(shift=Bars-ExtDepth; shift>=0; shift--)
{
val=Low[Lowest(NULL,0,MODE_LOW,ExtDepth,shift)];
if(val==lastlow) val=0,0;
si no
{
lastlow=val;
if((Low[shift]-val)>(ExtDeviation*Point)) val=0.0;
si no
{
for(back=1; back<=ExtBackstep; back++)
{
res=ExtMapBuffer[shift+back];
if((res!=0)&&(res>val)) ExtMapBuffer[shift+back]=0.0;
}
}
}
ExtMapBuffer[shift]=val;
//--- alto
val=Alto[Máximo(NULL,0,MODE_HIGH,ExtDepth,shift)];
if(val==lasthigh) val=0,0;
si no
{
último muslo=val;
if((val-High[shift])>(ExtDeviation*Point)) val=0.0;
si no
{
for(back=1; back<=ExtBackstep; back++)
{
res=BufferExtMap2[shift+back];
if((res!=0)&&(res<val)) ExtMapBuffer2[shift+back]=0.0;
}
}
}
ExtMapBuffer2[shift]=val;
}

// corte final
lasthigh=-1; lasthighpos=-1;
lastlow=-1; lastlowpos=-1;

for(shift=Bars-ExtDepth; shift>=0; shift--)
{
curlow=ExtMapBuffer[shift];
curhigh=ExtMapBuffer2[shift];
if((curlow==0)&&(curhigh==0)) continuar;
//---
if(curhigh!=0)
{
if(lasthigh>0)
{
if(lasthigh<curhigh) ExtMapBuffer2[lasthighpos]=0;
si no ExtMapBuffer2[shift]=0;
}
//---
if(lasthigh<curhigh || lasthigh<0)
{
último tramo = último tramo;
lastthighpos=desplazamiento;
}
lastlow=-1;
}
//----
if(curlow!=0)
{
if(lastlow>0)
{
if(lastlow>curlow) ExtMapBuffer[lastlowpos]=0;
si no ExtMapBuffer[shift]=0;
}
//---
if((curlow<lastlow)||(lastlow<0))
{
lastlow=curlow;
lastlowpos=desplazamiento;
}
último tramo=-1;
}
}

for(shift=Bars-1; shift>=0; shift--)
{
if(shift>=Bars-ExtDepth) ExtMapBuffer[shift]=0.0;
si no
{
res=Buffer2[shift];
if(res!=0.0) ExtMapBuffer[shift]=res;
}
}
}
 
Vladislav, por alguna razón tu código no funciona en todos los plazos. Funciona en algunos plazos, pero no en otros. Es extraño. Funciona. <br / translate="no">


Funciona en otros plazos pero no en otros. Parece que a mí me funciona. Sí, y no es mi código - desde el suministro estándar parece ser. Al menos lo he hecho en todas las versiones de MT.
 
Vladislav, está claro que este no es tu código. Tengo el código que proporcioné en mi entrega.
En qué plazos no se muestra. BC - Brezan.
GBP-CHF
No aparece en m1 y m15. Se muestra en todos los demás.
EUR-USD
No se muestra - m1, m5
AUD-USD - se muestran todos.
No sé por qué lo parece.

Tal vez, usted tiene el código que Slava reelaboró en el verano. Pero no me ha gustado su reelaboración. Algunas cuestiones no se resolvieron allí.
================
GODZILLA (Nikolay) hizo un buen trabajo. Pero sólo tiene dos problemas resueltos.
1) Recálculo en cada tic. Lo redujo drásticamente
2) Añadió el algoritmo de eliminación de joroba. Las jorobas aparecen principalmente debido a la presencia de un mínimo y un máximo en una barra. El algoritmo del zigzag sólo deja los altos. Esto hace que a menudo se produzcan varias subidas seguidas.

Tengo algunas variantes de mejora de los indicadores fijados por GODZILL. Se han eliminado las torceduras que quedaban en el aire. Sin embargo, supongo que el funcionamiento incorrecto de las funciones de búsqueda de extremos aún persiste en los dos primeros rayos. Es debido a este problema que he sacado este tema aquí.

Sin embargo, tal vez la función de búsqueda funciona correctamente pero no hay una descripción clara de esta función. Por eso se utiliza de forma incorrecta.
 
Lo tengo en todos los t\f en los pares especificados. No recuerdo de dónde salió este código - pensé que estaba en la entrega de la compilación 197 - lo tengo en todas las MT por alguna razón :). Lo comprobaré mañana.
 
Me avergüenza decir que nunca me había interesado seriamente por los zigzags :). El código en el post de nen 18.10.06 17:46
Todavía no puedo entenderlo. Me parece que debería ser algo así como . 
.. // val=Alto[Máximo(NULL,0,MODO_ALTO,Profundidad_Externa,desplazamiento)]; highpos=Máximo(NULL,0,MODO_ALTO,Profundidad_Externa,desplazamiento); val=Alto[highpos]; if(MathAbs(val-lastlow) < Punto) val=0.0; // si(val==lasthigh) val=0,0; si no { lasthigh=val; if(highpos!=shift) val=0,0; // si((val-High[shift])>(ExtDeviation*Point)) val=0,0; si no { ...


Aquí se comenta el código antiguo "extra". Aunque puede que aún no entienda del todo la idea del zigzag. En cualquier caso, este código no produce extremos colgantes. Si esta variante de código encaja pero no fue inventada por mí :), me disculpo por la falta de referencia.

 
Cándido, gracias. Veré cómo funciona. Pero la pregunta del título del hilo no desaparece. El simple hecho de zigzaguear ha revelado el problema del trabajo "incomprensible" de las funciones que buscan los extremos. La línea highpos=Highest(NULL,0,MODE_HIGH,ExtDepth,shift); ayuda a encontrar un extremo. Sin embargo, el índice highpos devuelto por la función Highest cuando se ejecuta en el código zigzag suele ser aleatorio. Hay una desviación de la posición real de la barra. En otras palabras, highpos será, por ejemplo, 15. Pero en realidad, la barra tendrá un índice diferente: 13 o 16 o algo más. Así que se entiende la diferencia. Por lo tanto, el zigzag con valores pequeños de los parámetros y en marcos temporales "pequeños" (1 minuto, 5 minutos...) empieza a funcionar de forma inestable.

Muy bien. No importa el zigzag. La pregunta no es sobre el zigzag. La cuestión es que las funciones del lenguaje MQ4 deben funcionar de forma estable y predecible.

Y este ES EL PRINCIPAL PROBLEMA. Las funciones de búsqueda no sólo se utilizan en el ZigZag. Pero también en muchos otros indicadores.

El zigzag es un caso especial. Pero ayuda a resaltar el problema. Muchos indicadores se basan en los zigzags. El zigzag funciona de forma inestable. No es un secreto para nadie. Muchas personas tienen que dedicar su tiempo a programar sus propios zigzags para sus propias necesidades. Cuánto tiempo se pierde. En vano. Por la falta de comprensión de la raíz del problema.
 
Cándido, tus palabras: Avergonzado de decir, ..... El código del post de nen 18.10.06 17:46 aún no se ha entendido.

Esas son palabras de oro. No es usted el primero que lo dice. Sin embargo, las ideas detrás del zigzag y parcialmente implementadas en este código son muy buenas. Estas ideas deben llevarse a cabo.
 
2 nen:
Cuando movemos la ventana (shift,shift+ExtDepth) mientras calculamos el indicador, la aparición de un nuevo extremo puede estar relacionada tanto con el nuevo precio como con el hecho de que el antiguo extremo haya salido de la ventana. Este punto debe ser tratado. Para ello, mi inserción contiene la línea if(highpos!=shift) val=0,0; . No entiendo cómo se hace esto en el código estándar. A juzgar por la falta de extremos colgantes en mi versión, se hace de forma incorrecta o no se hace en absoluto.
¿Y en qué consiste exactamente la inestabilidad del zigzag?
1234567
Nuevo comentario