une stratégie commerciale basée sur la théorie des vagues d'Elliott - page 22

 
D'après la description sur ce site http://impb.psn.ru/~sychyov/html/soft.shtml
J'ai téléchargé un programme qui calcule l'indice de Hurst. J'ai créé un fichier avec les prix d'ouverture des barres dans le script.
J'ai ouvert le fichier et le programme a calculé l'indice de Hurst. Mais quel que soit l'échantillon que je sélectionne, le programme affiche toujours des valeurs d'indicateur proches de 1. Mais ça ne correspond pas à la théorie, n'est-ce pas ? C'est-à-dire que la lecture doit varier de 0 à 1 pour différents échantillons ? Mais dans ce programme, ce paramètre est collé à 1 :o(. En général, je suis content que les fonctions de calcul rapide soient disponibles sur le site. Et maintenant, j'ai peur de les utiliser pour calculer quelque chose.

Jusqu'à présent, j'ai obtenu ce coefficient dans la fourchette 0,21-0,39. Je ne sais pas pourquoi :o(.
Voici mon code du script, que j'ai basé sur votre code :
//+------------------------------------------------------------------+
//|                                                        Herst.mq4 |
//|                      Copyright © 2006, MetaQuotes Software Corp. |
//|                                        https://www.metaquotes.net |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2006, MetaQuotes Software Corp."
#property link      "https://www.metaquotes.net"
#property show_inputs

extern int start_bar=500;
extern int end_bar=0;

//+------------------------------------------------------------------+
//| script program start function                                    |
//+------------------------------------------------------------------+
int start()
{
double viborka[10];
int size_of_array,i;

size_of_array=start_bar-end_bar+1;
ArrayResize(viborka, size_of_array);
for(i=size_of_array-1;i>=0;i--) viborka[i]=Open[i+end_bar];

double S_A=srednee_arifmeticheskoe(viborka);
Print("Среднее арифметическое выборки = ",DoubleToStr(S_A,8));

double disp=dispercia(viborka,S_A);
Print("Дисперсия выборки = ",DoubleToStr(disp,8));

double S=CKO(disp);
Print("СКО выборки (размах) = ",DoubleToStr(S,8));

double pMin=Low[Lowest(NULL,0,MODE_LOW,size_of_array,end_bar)];
double pMax=High[Highest(NULL,0,MODE_HIGH,size_of_array,end_bar)];
double R=pMax-pMin;
Print("pMin = ",pMin," pMax = ",pMax, " R = ",R);

double Hrst;
if( (R>0)&&(S>0)) Hrst = MathLog(R/S)/MathLog(size_of_array*0.5);
Print("Хёрст = ",DoubleToStr(Hrst ,8));
  
  return(0);
}
//+------------------------------------------------------------------+
//функция для расчёта СКО
double CKO(double disper)
{
   double sko=MathPow(disper,0.5);
   return(sko);
}


//функция для расчёта дисперсии
double dispercia(double data[], double centr)
{
   int k,size;
   double disper=0;
   size=ArraySize(data);
   
   for(k=size-1;k>=0;k--) disper=disper+MathPow((data[k]-centr),2);
   if(size>1) disper=disper/(size-1);
   return(disper);
}

//функция для подсчёта среднего арифметического значения по массиву
double srednee_arifmeticheskoe(double data[])
{
   int k,size;
   double sr_arifm=0;
   
   size=ArraySize(data);
   
   for(k=size-1;k>=0;k--) sr_arifm=sr_arifm+data[k];
   sr_arifm=sr_arifm/size;
   return(sr_arifm);
}


Vladislav, tu peux peut-être jeter un coup d'œil et me dire où modifier les choses pour calculer le coefficient correctement ? Après tout, selon la théorie, tous les calculs sont élémentaires et je ne sais même pas où se trouve mon erreur :o(

 
Que choisissez-vous comme variable centrale lorsque vous appelez la fonction de calcul de la variance ? Il devrait au moins y avoir un tableau de valeurs prédites - vous faites une prédiction pour chaque barre, ou vous l'avez fait, un parcours inverse et regardez la précision de la prédiction - toujours satisfaisante ou non.
Et puis un tel nombre d'appels de fonctions sur un algorithme qui n'est déjà pas très allégé par les calculs...... À mon avis, elle va ralentir considérablement. (L'appel de fonction est la procédure la plus longue, puis vient l'opération de division en virgule flottante).
Quel est le problème avec l'algorithme standard de calcul de l'écart-type? Elle est disponible, mais la prévision prend la valeur d'un mutisme sur la barre correspondante - prenez ce dont vous avez besoin, c'est tout et pas d'appels de fonction. Il suffit d'exécuter une boucle dans un tableau et d'élever au carré les différences entre le prix prévu sur une barre donnée et le prix réel, puis de faire la racine carrée une fois - c'est tout.

Bonne chance et bonne chance avec les tendances.
 
<br / translate="no">http://forex.ua/forum/viewtopic.php?t=1574
http://forex.ua/forum/viewtopic.php?t=1634&postdays=0&postorder=asc&start=50
Il y avait une comparaison à court terme des prévisions de la FA et de la TA ici (après quelques flammes dans le fil de discussion, j'en ai eu assez).
http://forex.ua/forum/viewtopic.php?t=1780

Merci pour les liens ! A lire. Très instructif ! Cela m'a confirmé une fois de plus que je comprends bien l'essence de votre stratégie. J'ai déjà commencé à programmer moi-même quelque chose dans ce sens. J'ai déjà écrit plus haut sur les problèmes actuels de l'agenda. Mais même les résultats des premiers calculs sont très impressionnants ! En effet, tant que vous n'avez pas essayé vous-même, vous ne pouvez pas comprendre pourquoi les choses se passent vraiment comme vous le dites ! C'est ce qui rend votre stratégie si impopulaire auprès de la majorité des traders. Il est beaucoup plus attrayant de regarder de beaux graphiques multicolores de différents oscillateurs ;o) et de lire différents analystes rémunérés, que de fonder sa stratégie de trading Forex sur des connaissances accumulées par des personnes depuis longtemps. Bien qu'en principe, tant que cet état de fait persiste, il sera possible de gagner beaucoup d'argent sur le Forex !
 
Mais en principe, tant que les choses restent en l'état, il est possible de gagner beaucoup d'argent sur le Forex !


:).

Bonne chance et bonnes tendances.
 
Que choisissez-vous comme variable centrale lorsque vous appelez la fonction de calcul de la variance ? Il devrait au moins y avoir un tableau avec les valeurs prédites - vous faites ou avez fait une prédiction pour chaque barre, vous faites une marche arrière et vous regardez la précision de la prédiction - toujours satisfaisante ou non. <br/ translate="no">Et puis un tel nombre d'appels de fonctions sur un algorithme qui n'est déjà pas beaucoup allégé par les calculs...... À mon avis, elle va ralentir considérablement. (L'appel de fonction est la procédure la plus longue, puis vient l'opération de division en virgule flottante).
Quel est le problème avec l'algorithme standard de calcul de l'écart-type ? Il est disponible, mais la prévision prend la valeur d'un mutisme sur la barre correspondante - prenez ce dont vous avez besoin, c'est tout et pas d'appels de fonction. Il suffit d'exécuter une boucle dans le tableau et de prendre les carrés des différences entre le prix prévu sur la barre donnée et le prix réel, puis de prendre la racine carrée une fois - c'est tout.
Tout à fait d'accord avec vous ! Les décalages à l'avenir seront terribles pour les calculs de masse, bien que sur les petits calculs, ils ne soient pas perceptibles pour le moment. Mais cela est dû au développement de l'algorithme, qui sera ensuite utilisé pour tout calculer. Cette abondance de fonctions primitives est due simplement à la commodité (du moins, c'est ce qui me semble :o)) d'utilisation lors de la recherche d'un algorithme. C'est-à-dire ces fonctions RMS, Dispersion, Moyenne, que j'utilise dans beaucoup d'autres choses. Lorsque tout devient clair - ce qu'il faut compter et comment, ainsi que le volume des calculs, alors bien sûr, tout sera co-optimisé. En attendant, ce que nous avons est ce que nous utilisons - pour ainsi dire, les premières estimations de manivelle ;o).
Dans cet exemple, j'ai utilisé la moyenne arithmétique de l'échantillon comme variable centrale.
Hier, j'ai également essayé de définir une ligne de régression linéaire comme cette variable. On obtient donc que S=SCO des erreurs de régression linéaire. Mais pour une raison quelconque, le résultat ne m'a pas impressionné non plus :o(.
Voici le code du script, dans lequel nous prenons une ligne de régression linéaire comme prévision. De plus, la tendance actuelle de l'EURUSD correspond très bien à cela.
//+------------------------------------------------------------------+
//|                                                        Herst.mq4 |
//|                      Copyright © 2006, MetaQuotes Software Corp. |
//|                                        http://www.metaquotes.net |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2006, MetaQuotes Software Corp."
#property link      "http://www.metaquotes.net"
#property show_inputs

extern int start_bar=500;
extern int end_bar=0;

//+------------------------------------------------------------------+
//| script program start function                                    |
//+------------------------------------------------------------------+
int start()
{
double viborka[10],oshibki_lin_reg[10];
int size_of_array,i;

size_of_array=start_bar-end_bar+1;
ArrayResize(viborka, size_of_array);
ArrayResize(oshibki_lin_reg, size_of_array);

for(i=size_of_array-1;i>=0;i--) viborka[i]=Open[i+end_bar];

double S_A_viborki=srednee_arifmeticheskoe(viborka);
Print("Среднее арифметическое выборки = ",DoubleToStr(S_A_viborki,8));

//-----Расчёт коэффициента a уравнения линейной регрессии
double sred_znach_i=(size_of_array-1)/2.0; //среднее значение по оси индекса
double a_lin_regres=0;//коэффициент a линейной регрессии
double buffer=0;

for(i=size_of_array-1;i>=0;i--)
{
   a_lin_regres=a_lin_regres+(i-sred_znach_i)*(viborka[i]-S_A_viborki);
   buffer=buffer+MathPow((i-sred_znach_i),2);
}
a_lin_regres=a_lin_regres/buffer;
Print("a_lin_regres = ",DoubleToStr(a_lin_regres,8));

//-----Расчёт коэффициента b уравнения линейной регрессии
double b_lin_regres=S_A_viborki-a_lin_regres*sred_znach_i;
Print("b_lin_regres = ",DoubleToStr(b_lin_regres,8));

//-----Расчёт ошибок линейной регрессии
for(i=size_of_array-1;i>=0;i--) oshibki_lin_reg[i]=viborka[i]-(a_lin_regres*i+b_lin_regres);

double S_A_oshibok;//среднее значение ошибок линейной регрессии
S_A_oshibok=srednee_arifmeticheskoe(oshibki_lin_reg);
Print("Среднее значение ошибок = ",DoubleToStr(S_A_oshibok,8));

double disp_oshibok=dispercia_oshibok(oshibki_lin_reg,S_A_oshibok);
Print("Дисперсия ошибок= ",DoubleToStr(disp_oshibok,8));

double S=CKO(disp_oshibok);
Print("S= ",DoubleToStr(S,8));

double pMin=0;
double pMax=0;
for(i=size_of_array-1;i>=0;i--)
{  
   if(oshibki_lin_reg[i]<pMin) pMin=oshibki_lin_reg[i];
   if(oshibki_lin_reg[i]>pMax) pMax=oshibki_lin_reg[i];
}

double R=pMax-pMin;
Print("pMin = ",pMin," pMax = ",pMax, " R = ",R);

double Hrst;
Hrst = MathLog(R/S)/MathLog(size_of_array*0.5);
Print("Хёрст = ",DoubleToStr(Hrst ,8));
  
  return(0);
}
//+------------------------------------------------------------------+
//функция для расчёта дисперсии ошибок
double dispercia_oshibok(double data[], double centr)
{
   int k,size;
   double disper=0;
   size=ArraySize(data);
   
   for(k=size-1;k>=0;k--) disper=disper+MathPow((data[k]-centr),2);
   if(size>1) disper=disper/(size-2);
   return(disper);
}

//функция для расчёта СКО
double CKO(double disper)
{
   double sko=MathPow(disper,0.5);
   return(sko);
}

//функция для подсчёта среднего арифметического значения по массиву
double srednee_arifmeticheskoe(double data[])
{
   int k,size;
   double sr_arifm=0;
   
   size=ArraySize(data);
   
   for(k=size-1;k>=0;k--) sr_arifm=sr_arifm+data[k];
   sr_arifm=sr_arifm/size;
   return(sr_arifm);
}


Prenons la période H1 sur EURUSD. Nous prenons un échantillon de 500 barres Le coefficient de Hearst = 0,26
300 barres - 0,31, 100 barres - 0,39, 30 barres - 0,51. Je ne comprends pas pourquoi :o(.

Nous allons essayer le mouving recommandé par vous. Bien que je ne sache pas encore pourquoi les résultats seront fondamentalement différents de ce que j'ai.

 
HOORAY ! On dirait que j'ai trouvé comment calculer le Hurst. Voici le texte du script, où l'indice est calculé par rapport au canal de régression linéaire.
//+------------------------------------------------------------------+
//|                                                Herst_lin_reg.mq4 |
//|                      Copyright © 2006, MetaQuotes Software Corp. |
//|                                        http://www.metaquotes.net |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2006, MetaQuotes Software Corp."
#property link      "http://www.metaquotes.net"
#property show_inputs

extern int start_bar=800;
extern int end_bar=570;

//+------------------------------------------------------------------+
//| script program start function                                    |
//+------------------------------------------------------------------+
int start()
{
double viborka[10],oshibki_lin_reg[10],data_for_drawing[10];
int size_of_array,i;

size_of_array=start_bar-end_bar+1;
ArrayResize(viborka, size_of_array);
ArrayResize(oshibki_lin_reg, size_of_array);
ArrayResize(data_for_drawing, size_of_array);

for(i=size_of_array-1;i>=0;i--) viborka[i]=Open[i+end_bar];

double S_A_viborki=srednee_arifmeticheskoe(viborka);
Print("Среднее арифметическое выборки = ",DoubleToStr(S_A_viborki,8));

//-----Расчёт коэффициента a уравнения линейной регрессии
double sred_znach_i=(size_of_array-1)/2.0; //среднее значение по оси индекса
double a_lin_regres=0;//коэффициент a линейной регрессии
double buffer=0;

for(i=size_of_array-1;i>=0;i--)
{
   a_lin_regres=a_lin_regres+(i-sred_znach_i)*(viborka[i]-S_A_viborki);
   buffer=buffer+MathPow((i-sred_znach_i),2);
}
a_lin_regres=a_lin_regres/buffer;
Print("a_lin_regres = ",DoubleToStr(a_lin_regres,8));

//-----Расчёт коэффициента b уравнения линейной регрессии
double b_lin_regres=S_A_viborki-a_lin_regres*sred_znach_i;
Print("b_lin_regres = ",DoubleToStr(b_lin_regres,8));

for(i=size_of_array-1;i>=0;i--) data_for_drawing[i]=a_lin_regres*i+b_lin_regres; 

linregres_grafic_c(0,data_for_drawing,end_bar);

//-----Расчёт ошибок линейной регрессии
for(i=size_of_array-1;i>=0;i--) oshibki_lin_reg[i]=viborka[i]-(a_lin_regres*i+b_lin_regres);

double S_A_oshibok;//среднее значение ошибок линейной регрессии
S_A_oshibok=srednee_arifmeticheskoe(oshibki_lin_reg);
Print("Среднее значение ошибок = ",DoubleToStr(S_A_oshibok,8));

double disp_oshibok=dispercia_oshibok(oshibki_lin_reg,S_A_oshibok);
Print("Дисперсия ошибок= ",DoubleToStr(disp_oshibok,8));

double S=CKO(disp_oshibok);
Print("S= ",DoubleToStr(S,8));

double pMin=Low[Lowest(NULL,0,MODE_LOW,size_of_array,end_bar)];
double pMax=High[Highest(NULL,0,MODE_HIGH,size_of_array,end_bar)];
double R=pMax-pMin;
Print("pMin = ",pMin," pMax = ",pMax, " R = ",R);

double Hrst;
Hrst = MathLog(R/S)/MathLog(size_of_array*0.5);
Print("Хёрст = ",DoubleToStr(Hrst ,8));
Comment("Хёрст = ",DoubleToStr(Hrst ,8));
  
  return(0);
}
//+------------------------------------------------------------------+
//функция для расчёта дисперсии ошибок
double dispercia_oshibok(double data[], double centr)
{
   int k,size;
   double disper=0;
   size=ArraySize(data);
   
   for(k=size-1;k>=0;k--) disper=disper+MathPow((data[k]-centr),2);
   if(size>1) disper=disper/(size-2);
   return(disper);
}

//функция для расчёта СКО
double CKO(double disper)
{
   double sko=MathPow(disper,0.5);
   return(sko);
}

//функция для подсчёта среднего арифметического значения по массиву
double srednee_arifmeticheskoe(double data[])
{
   int k,size;
   double sr_arifm=0;
   
   size=ArraySize(data);
   
   for(k=size-1;k>=0;k--) sr_arifm=sr_arifm+data[k];
   sr_arifm=sr_arifm/size;
   return(sr_arifm);
}

//функция рисования канала линейной регрессии 
int linregres_grafic_c(int window_number, double data[], int ended_bar)
{
   int deletedArrows,k,size;
   string line_name;
   //очистка предыдущего рисунка
   deletedArrows=ObjectsDeleteAll(window_number,OBJ_TREND);
   
   //находим размер массива
   size=ArraySize(data);
   
   //рисуем центральную линию линейной регрессии
   for(k=size-1;k>=1;k--)
   {
      line_name="line_lin_reg"+k;
      ObjectCreate(line_name,OBJ_TREND,window_number,Time[k+ended_bar],data[k],Time[k+ended_bar-1],data[k-1]);
      ObjectSet(line_name,OBJPROP_COLOR,Yellow);
      ObjectSet(line_name,OBJPROP_STYLE,DRAW_LINE);
      ObjectSet(line_name,OBJPROP_WIDTH,2);
      ObjectSet(line_name,OBJPROP_BACK,true);
      ObjectSet(line_name,OBJPROP_RAY,false);
   }
   
   //рисуем проекцию центральной линии линейной регрессии
   line_name="line_lin_reg_proec";
   ObjectCreate(line_name,OBJ_TREND,window_number,Time[size-1+ended_bar],data[size-1],Time[ended_bar],data[0]);
   ObjectSet(line_name,OBJPROP_COLOR,Red);
   ObjectSet(line_name,OBJPROP_STYLE,DRAW_LINE);
   ObjectSet(line_name,OBJPROP_WIDTH,1);
   ObjectSet(line_name,OBJPROP_BACK,false);
   ObjectSet(line_name,OBJPROP_RAY,true);
   
      
   
   return(0);

}


Voici le lien où se trouvent les captures d'écran https://c.mql5.com/mql4/forum/2006/05/Herst.zip
J'ai d'abord essayé de télécharger ces fichiers image sur le site, afin de pouvoir les afficher dans le thème lui-même, mais pour une raison quelconque, ces fichiers gif sur le site www.mql4.com après le changement de moteur ne veulent toujours pas être insérés :o(. Peu importe la bonne chose qu'au moins le zip a téléchargé.

Une brève explication du script. Le script trace une ligne jaune épaisse du canal de régression linéaire dans le graphique et en même temps il trace la projection du canal dans le futur avec une ligne rouge fine.
À en juger par les captures d'écran, je dois avoir raison dans mes calculs :o). Bien que je doive vérifier à nouveau à l'avenir.

PS : Vladislav, je pense que le calcul de l'indice de Hurst par muving est un peu douteux, car on ne sait pas quelle valeur de la période de calcul de la moyenne doit être prise. Je suppose que cette valeur pour chaque calcul particulier devrait en quelque sorte changer en fonction du nombre de tochets. C'est pourquoi j'ai opté pour un canal de régression linéaire pour le moment.

 
Je vais participer à la conversation, si les autres n'y voient pas d'inconvénient. Je n'ai pas beaucoup approfondi la méthodologie de Vladislav, même si j'en ai une vague idée. J'ai décidé de m'exprimer à cause des photos. Eh bien, ils n'ont pas de grain sous cette forme, il me semble que les calculs doivent être rampants (c'est probablement ce que propose Vladislav). Supposons que nous calculions la ligne jaune pour 20 (30-40 barres et ainsi de suite, selon notre goût) barres et que nous calculions ensuite Hearst (RMS, etc.), puis sur une nouvelle barre nous laissons tomber la barre la plus ancienne de l'échantillon (sur laquelle la ligne jaune a été obtenue) et ajoutons une nouvelle barre (nouvellement formée) et utilisons cet échantillon pour calculer Hearst (RMS, etc.) jusqu'à ce que ces barres apparaissent.Tant que ces calculs s'inscrivent dans l'intervalle de confiance (la probabilité est maintenant exigée), nous ne faisons rien et tout se développe dans les limites acceptables, dès que l'intervalle est violé, le canal et les autres facteurs sont recalculés. C'est-à-dire qu'il existe un tel canal rampant qui suit le chemin établi jusqu'à ce que le marché lui demande de tout recalculer.

C'est ce que j'ai compris (probablement de manière incorrecte).
 
En fait, c'est un peu plus profond que ça ! Mes images du script de Hearst ne sont qu'un ajout à l'essence de l'idée de déterminer les canaux actuellement significatifs de la régression linéaire et les canaux optimaux en termes de formes quadratiques. Autrement dit, dans cette stratégie, Hearst n'est qu'une caractéristique de confirmation, mais pas la principale ! La principale - il s'agit de chaînes réelles avec des intervalles de confiance calculés de 90%, 95% et 99% par exemple. Et le point de la stratégie - est de les déterminer correctement, c'est-à-dire de prendre exactement le nombre de barres, qui est optimal pour construire un canal d'action et de l'approcher avec la fonction de cet ordre, qui est le plus acceptable. Bien sûr, personne ne va supprimer les anciennes barres de la sélection parce qu'une nouvelle barre est apparue ! Il s'agit là d'une absurdité sur laquelle reposent TOUS les indicateurs conventionnels. Et il existe un grand nombre d'indicateurs basés sur les canaux d'exploration. A titre d'exemple, je vais en citer un ci-dessous. Le délire de son travail peut être estimé après l'avoir observé pendant un certain temps. Vous verrez les moments où la pente de l'indicateur peut passer de 45 à -45 degrés dès qu'une nouvelle barre apparaît (et que la dernière disparaît en conséquence) ! Et ensuite, quand vous en voyez un autre, vous pouvez revenir à 45 degrés !:o)))) Il est vrai que cet indicateur ne fonctionne pas exactement comme je l'ai écrit. Il faut une période limitée par le nombre de barres pour trouver des points de référence - les fractales. Bien entendu, nous ne tenons pas compte de ce que sont réellement ces points de référence - parce que nous n'estimons pas à quel intervalle de confiance ils appartiennent - d'où toutes les erreurs de traçage des lignes de l'indicateur.
//+------------------------------------------------------------------+
//|                                                  SHI_Channel.mq4 |
//|                                 Copyright © 2004, Shurka & Kevin |
//|                                                                  |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2004, Shurka & Kevin"
#property link      ""

#property indicator_chart_window
#property indicator_buffers 1
#property indicator_color1 Red
double ExtMapBuffer1[];
//---- input parameters
extern int       AllBars=240;
extern int       BarsForFract=0;
int CurrentBar=0;
double Step=0;
int B1=-1,B2=-1;
int UpDown=0;
double P1=0,P2=0,PP=0;
int i=0,AB=300,BFF=0;
int ishift=0;
double iprice=0;
datetime T1,T2;

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---- indicators
   SetIndexStyle(0,DRAW_ARROW);
   SetIndexArrow(0,164);
   SetIndexBuffer(0,ExtMapBuffer1);
   SetIndexEmptyValue(0,0.0);
//----
	
	
   return(0);
  }
//+------------------------------------------------------------------+
//| Custor indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//---- 
   
//----
   return(0);
  }

void DelObj()
{
	ObjectDelete("TL1");
	ObjectDelete("TL2");
	ObjectDelete("MIDL");
}

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   int    counted_bars=IndicatorCounted();
//---- 
	if ((AllBars==0) || (Bars<AllBars)) AB=Bars; else AB=AllBars; //AB-количество обсчитываемых баров
	if (BarsForFract>0) 
		BFF=BarsForFract; 
	else
	{
		switch (Period())
		{
			case 1: BFF=12; break;
			case 5: BFF=48; break;
			case 15: BFF=24; break;
			case 30: BFF=24; break;
			case 60: BFF=12; break;
			case 240: BFF=15; break;
			case 1440: BFF=10; break;
			case 10080: BFF=6; break;
			default: DelObj(); return(-1); break;
		}
	}
	CurrentBar=2; //считаем с третьего бара, чтобы фрактал "закрепился
	B1=-1; B2=-1; UpDown=0;
	while(((B1==-1) || (B2==-1)) && (CurrentBar<AB))
	{
		//UpDown=1 значит первый фрактал найден сверху, UpDown=-1 значит первый фрактал
		//найден снизу, UpDown=0 значит фрактал ещё не найден.
		//В1 и В2 - номера баров с фракталами, через них строим опорную линию.
		//Р1 и Р2 - соответственно цены через которые будем линию проводить

		if((UpDown<1) && (CurrentBar==Lowest(Symbol(),Period(),MODE_LOW,BFF*2+1,CurrentBar-BFF))) 
		{
			if(UpDown==0) { UpDown=-1; B1=CurrentBar; P1=Low[B1]; }
			else { B2=CurrentBar; P2=Low[B2];}
		}
		if((UpDown>-1) && (CurrentBar==Highest(Symbol(),Period(),MODE_HIGH,BFF*2+1,CurrentBar-BFF))) 
		{
			if(UpDown==0) { UpDown=1; B1=CurrentBar; P1=High[B1]; }
			else { B2=CurrentBar; P2=High[B2]; }
		}
		CurrentBar++;
	}
	if((B1==-1) || (B2==-1)) {DelObj(); return(-1);} // Значит не нашли фракталов среди 300 баров 8-)
	Step=(P2-P1)/(B2-B1);//Вычислили шаг, если он положительный, то канал нисходящий
	P1=P1-B1*Step; B1=0;//переставляем цену и первый бар к нулю
	//А теперь опорную точку противоположной линии канала.
	ishift=0; iprice=0;
	if(UpDown==1)
	{ 
		PP=Low[2]-2*Step;
		for(i=3;i<=B2;i++) 
		{
			if(Low[i]<PP+Step*i) { PP=Low[i]-i*Step; }
		}
		if(Low[0]<PP) {ishift=0; iprice=PP;}
		if(Low[1]<PP+Step) {ishift=1; iprice=PP+Step;}
		if(High[0]>P1) {ishift=0; iprice=P1;}
		if(High[1]>P1+Step) {ishift=1; iprice=P1+Step;}
	} 
	else
	{ 
		PP=High[2]-2*Step;
		for(i=3;i<=B2;i++) 
		{
			if(High[i]>PP+Step*i) { PP=High[i]-i*Step;}
		}
		if(Low[0]<P1) {ishift=0; iprice=P1;}
		if(Low[1]<P1+Step) {ishift=1; iprice=P1+Step;}
		if(High[0]>PP) {ishift=0; iprice=PP;}
		if(High[1]>PP+Step) {ishift=1; iprice=PP+Step;}
	}
	//Теперь переставим конечную цену и бар на АВ, чтобы линии канала рисовались подлиннее
	P2=P1+AB*Step;
	T1=Time[B1]; T2=Time[AB];

	//Если не было пересечения канала, то 0, иначе ставим псису.
	if(iprice!=0) ExtMapBuffer1[ishift]=iprice;
	DelObj();
	ObjectCreate("TL1",OBJ_TREND,0,T2,PP+Step*AB,T1,PP); 
		ObjectSet("TL1",OBJPROP_COLOR,Lime); 
		ObjectSet("TL1",OBJPROP_WIDTH,2); 
		ObjectSet("TL1",OBJPROP_STYLE,STYLE_SOLID); 
	ObjectCreate("TL2",OBJ_TREND,0,T2,P2,T1,P1); 
		ObjectSet("TL2",OBJPROP_COLOR,Lime); 
		ObjectSet("TL2",OBJPROP_WIDTH,2); 
		ObjectSet("TL2",OBJPROP_STYLE,STYLE_SOLID); 
	ObjectCreate("MIDL",OBJ_TREND,0,T2,(P2+PP+Step*AB)/2,T1,(P1+PP)/2);
		ObjectSet("MIDL",OBJPROP_COLOR,Lime); 
		ObjectSet("MIDL",OBJPROP_WIDTH,1); 
		ObjectSet("MIDL",OBJPROP_STYLE,STYLE_DOT);
	//	Comment(" Channel size = ", DoubleToStr(MathAbs(PP - P1)/Point,0), " Slope = ", DoubleToStr(-Step/Point, 2));
//----

//----
   return(0);
  }
//+------------------------------------------------------------------+
 
Néanmoins, cet indicateur (Shi Channel) est très intéressant - l'idée de jouer avec la tendance et à partir des frontières du canal dans le plat est sensible en soi.
 
Néanmoins, cet indicateur (Shi Channel) est très intéressant - l'idée de jouer avec la tendance et à partir des frontières du canal dans le plat est sensible en soi.

Cet indicateur est tiré de cette stratégie
http://fxovereasy.50webs.com/Example1.html
Vous pouvez télécharger les indicateurs nécessaires à cette stratégie pour MT4 depuis le site web.
http://fxovereasy.50webs.com/Indicators.html
Tout semble avoir un sens à première vue. Il n'y a pas d'autre description de stratégie ;o).