Ce que rapportent les fonctions Lowest et Highest - page 2
Vous manquez des opportunités de trading :
- Applications de trading gratuites
- Plus de 8 000 signaux à copier
- Actualités économiques pour explorer les marchés financiers
Inscription
Se connecter
Vous acceptez la politique du site Web et les conditions d'utilisation
Si vous n'avez pas de compte, veuillez vous inscrire
Je n'ai pas pu répondre (j'étais absent). Affichez le code que vous devez analyser pour parler d'une chose.
ZS Dans ce zigzag n'était pas une erreur mais une coquille (par rapport au code dans MT3), je n'ai trouvé que cette coquille et n'ai rien corrigé d'autre.
J'ai maintenant accumulé un grand nombre de ces modifications ou d'autres modifications. Ils fonctionnent très bien. Cependant, le premier rayon - celui qui part de la barre zéro ou de n'importe laquelle des premières barres - échoue avec des erreurs dans les fonctions d'identification des extrema. Et l'indicateur fonctionne de manière instable.
//+------------------------------------------------------------------+
//| Moyenne mobile personnalisée.mq4 |
//| Copyright © 2005, MetaQuotes Software Corp.
//| https://www.metaquotes.net/ |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2005, MetaQuotes Software Corp."
#lien de propriété "https://www.metaquotes.net/
#property indicator_chart_window
#property indicator_buffers 1
#property indicator_color1 Red
//---- paramètres de l'indicateur
extern intDepth=12 ;
extern inttern ExtDeviation=5 ;
externe inttern ExtBackstep=3 ;
//---- tampons indicateurs
double ExtMapBuffer[] ;
double ExtMapBuffer2[] ;
//+------------------------------------------------------------------+
//| Fonction d'initialisation de l'indicateur personnalisé |
//+------------------------------------------------------------------+
int init()
{
IndicatorBuffers(2) ;
//---- paramètres de dessin
SetIndexStyle(0,DRAW_SECTION) ;
//---- mise en correspondance des tampons indicateurs
SetIndexBuffer(0,ExtMapBuffer) ;
SetIndexBuffer(1,ExtMapBuffer2) ;
SetIndexEmptyValue(0,0.0) ;
//---- indicateur nom court
IndicatorShortName("ZigZag("+ExtDepth+", "+ExtDeviation+", "+ExtBackstep+")") ;
//---- initialisation faite
retour(0) ;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int start()
{
int shift,back,lasthighpos,lastlowpos ;
double val,res ;
double curlow, curhigh, lasthigh, lastlow ;
for(shift=Bars-ExtDepth ; shift>=0 ; shift--)
{
val=Low[Lowest(NULL,0,MODE_LOW,ExtDepth,shift)] ;
si(val==lastlow) val=0.0 ;
sinon
{
lastlow=val ;
si((Low[shift]-val)>(ExtDeviation*Point)) val=0.0 ;
sinon
{
for(back=1 ; back<=ExtBackstep ; back++)
{
res=ExtMapBuffer [shift+back] ;
si((res!=0)&&(res>val)) ExtMapBuffer[shift+back]=0.0 ;
}
}
}
ExtMapBuffer[shift]=val ;
//--- haut
val=High[Highest(NULL,0,MODE_HIGH,ExtDepth,shift)] ;
si(val==lasthigh) val=0.0 ;
sinon
{
lasthigh=val ;
si((val-High[shift])>(ExtDeviation*Point)) val=0.0 ;
sinon
{
for(back=1 ; back<=ExtBackstep ; back++)
{
res=ExtMapBuffer2 [shift+back] ;
si((res!=0)&&(res<val)) ExtMapBuffer2[shift+back]=0.0 ;
}
}
}
ExtMapBuffer2[shift]=val ;
}
// coupe finale
lasthigh=-1 ; lasthighpos=-1 ;
lastlow=-1 ; lastlowpos=-1 ;
for(shift=Bars-ExtDepth ; shift>=0 ; shift--)
{
curlow=ExtMapBuffer[shift] ;
curhigh=ExtMapBuffer2[shift] ;
si((curlow==0)&&(curhigh==0)) continuer ;
//---
si(curhigh!=0)
{
if(lasthigh>0)
{
if(lasthigh<curhigh) ExtMapBuffer2[lasthighpos]=0 ;
sinon ExtMapBuffer2[shift]=0 ;
}
//---
si(lasthigh<curhigh || lasthigh<0)
{
lasthigh=curhigh ;
lasthighpos=shift ;
}
dernier bas=-1 ;
}
//----
si(curlow!=0)
{
if(lastlow>0)
{
if(lastlow>curlow) ExtMapBuffer[lastlowpos]=0 ;
sinon ExtMapBuffer[shift]=0 ;
}
//---
if((curlow<lastlow)||(lastlow<0))
{
lastlow=curlow ;
lastlowpos=shift ;
}
lasthigh=-1 ;
}
}
for(shift=Bars-1 ; shift>=0 ; shift--)
{
si(shift>=Bars-ExtDepth) ExtMapBuffer[shift]=0.0 ;
sinon
{
res=ExtMapBuffer2[shift] ;
if(res!=0.0) ExtMapBuffer[shift]=res ;
}
}
}
Il fonctionne sur d'autres horizons temporels mais pas sur d'autres. Cela semble fonctionner pour moi. Oui, et ce n'est pas mon code - à partir de l'offre standard semble être. En tout cas, je l'ai fait dans toutes les versions de MT.
Sur quels horizons temporels il n'est pas affiché. BC - Brezan.
GBP-CHF
Il n'est pas indiqué sur m1 et m15. Il est affiché sur tous les autres.
EUR-USD
Il n'est pas montré - m1, m5
AUD-USD - tous sont montrés.
Je ne sais pas pourquoi il en est ainsi.
Peut-être, vous avez le code que Slava a retravaillé cet été. Mais je n'ai pas aimé son remaniement. Certains problèmes n'y ont pas été résolus.
================
GODZILLA (Nikolay) a fait un bon travail. Mais il n'a résolu que deux problèmes.
1) Recalcul à chaque tick. Il l'a réduit de façon drastique
2) Ajout d'un algorithme de suppression des bosses. Les bosses apparaissent principalement en raison de la présence d'un minimum et d'un maximum sur une même barre. L'algorithme du zigzag ne laisse que des hauts. Cela permet souvent d'atteindre plusieurs sommets d'affilée.
J'ai quelques variantes d'amélioration de l'indicateur corrigées par GODZILL. Les nœuds qui pendaient dans l'air ont été supprimés. Cependant, je suppose que le fonctionnement incorrect des fonctions de recherche d'extremum persiste dans les deux premiers rayons. C'est à cause de ce problème que j'ai abordé ce sujet ici.
Cependant, il se peut que la fonction de recherche fonctionne correctement mais qu'il n'y ait pas de description claire de cette fonction. C'est pourquoi il est utilisé de manière incorrecte.
Je n'arrive pas encore à comprendre. Il me semble que cela devrait être quelque chose comme ...
// val=High[Highest(NULL,0,MODE_HIGH,ExtDepth,shift)] ; highpos=Highest(NULL,0,MODE_HIGH,ExtDepth,shift) ; val=High[highpos] ; if(MathAbs(val-lastlow) < Point) val=0.0 ; // if(val==lasthigh) val=0.0 ; else { lasthigh=val ; if(highpos!=shift) val=0.0 ; // if((val-High[shift])>(ExtDeviation*Point)) val=0.0 ; else { ...Ici, l'ancien code "supplémentaire" est commenté. Même si je ne comprends pas encore tout à fait l'idée du zigzag. Dans tous les cas, ce code ne produit pas d'extrema pendants. Si cette variante de code convient mais qu'elle n'a pas été inventée par moi :), je m'excuse pour le manque de référence.
Très bien. Peu importe le zigzag. La question ne porte pas sur le zigzag. La question est que les fonctions du langage MQ4 doivent fonctionner de manière régulière et prévisible.
Et c'EST LE PROBLÈME PRINCIPAL. Les fonctions de recherche ne sont pas seulement utilisées dans le ZigZag. Mais aussi dans de nombreux autres indicateurs.
Le zigzag est un cas particulier. Mais cela permet de mettre en évidence le problème. De nombreux indicateurs sont basés sur des zigzags. Le zigzag fonctionne de manière instable. Ce n'est un secret pour personne. De nombreuses personnes doivent consacrer leur temps à la programmation de leurs propres zigzags pour leurs propres besoins. Combien de temps est perdu. En vain. En raison d'un manque de compréhension de la racine du problème.
Ce sont des mots en or. Vous n'êtes pas le premier à le dire. Néanmoins, les idées derrière le zigzag et partiellement implémentées dans ce code sont très bonnes. Ces idées doivent être concrétisées.
Lorsque nous déplaçons la fenêtre (shift,shift+ExtDepth) pendant le calcul de l'indicateur, l'apparition d'un nouvel extremum peut être liée à la fois au nouveau prix et au fait que l'ancien extremum a quitté la fenêtre. Ce point doit être traité. À cette fin, mon insertion contient la ligne if(highpos!=shift) val=0.0 ; . Je ne comprends pas comment cela est fait dans le code standard. A en juger par les extrema manquants dans ma version, c'est soit mal fait, soit pas fait du tout.
Et quelle est exactement l'instabilité du zigzag ?