uma estratégia comercial baseada na Teoria da Onda de Elliott - página 22

 
Da descrição neste site http://impb.psn.ru/~sychyov/html/soft.shtml
Eu baixei um programa que calcula o índice Hurst. Eu criei um arquivo com preços de abertura de bar no roteiro.
Eu abri o arquivo e o programa calculou o índice Hurst. Mas qualquer amostra que eu selecione o programa sempre mostra valores indicadores próximos a 1. Mas isso não se encaixa na teoria, não é mesmo? Ou seja, a leitura deve variar de 0 a 1 para diferentes amostras? Mas neste programa, este parâmetro é colado a 1 :o(. Em geral, estou feliz que as funções de cálculo pronto estejam disponíveis no site. E agora tenho medo de usá-los para calcular algo.

Tenho este coeficiente até agora dentro da faixa de 0,21-0,39. Não sei porquê :o(.
Aqui está o meu código do roteiro, que eu baseei no seu código:
//+------------------------------------------------------------------+
//|                                                        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, talvez você possa apenas dar uma olhada e me dizer onde ajustar a fim de calcular o coeficiente corretamente? Afinal, de acordo com a teoria, todos os cálculos são elementares e eu nem sei onde está meu erro :o(

 
O que você seleciona como variável central quando chama a função para calcular o desvio? Deve haver pelo menos um conjunto de valores previstos - você está fazendo uma previsão para cada barra, ou já fez, uma execução inversa e olhar a precisão da previsão - ainda satisfatória ou não.
E então um tal número de funções chama um algoritmo que já não é muito simplificado pelos cálculos..... O IMHO vai desacelerar consideravelmente. (A chamada de função é o procedimento mais longo, depois vem a operação de divisão de ponto flutuante).
O que há de errado com o algoritmo padrão para calcular o desvio padrão? Está disponível, mas a previsão leva o valor de um muving na barra correspondente - leve o que você precisa, é isto e nenhuma função chama. Basta fazer um loop através de um array e ajustar as diferenças entre o preço previsto em uma determinada barra e o preço real, depois ajustar o raiz quadrada uma vez - isso é tudo.

Boa sorte e boa sorte com as tendências.
 
<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
Houve aqui uma comparação a curto prazo das previsões FA e TA (depois que alguma chama no fio acabou de se fartar).
http://forex.ua/forum/viewtopic.php?t=1780

Obrigado pelos links! Faça uma leitura. Muito informativo! Mais uma vez me confirmou que compreendo corretamente a essência de sua estratégia. Eu mesmo já comecei a programar algo nesta direção. Eu já escrevi acima sobre os problemas atuais na agenda. Mas até mesmo os primeiros resultados dos cálculos são muito impressionantes! De fato, até que você mesmo tente, você não consegue entender porque as coisas realmente acontecem da maneira que você diz! Isto é o que torna sua estratégia tão impopular com a maioria dos comerciantes. É muito mais atraente olhar para belos gráficos multicoloridos de diferentes osciladores ;o) e ler diferentes analistas pagos, do que basear sua estratégia de negociação Forex no conhecimento acumulado pelas pessoas por um longo tempo. Embora, em princípio, enquanto este estado de coisas se mantiver, será possível ganhar bom dinheiro no Forex!
 
Em princípio, no entanto, enquanto as coisas permanecerem como estão, é possível fazer bom dinheiro no Forex!


:).

Boa sorte e boas tendências.
 
O que você seleciona como variável central quando chama a função para calcular o desvio? Deve haver pelo menos uma matriz com valores previstos - você faz ou já fez uma previsão para cada barra, marcha ré e olha para a precisão da previsão - ainda satisfatória ou não. <br/ translate="no"> E então tal número de funções chama um algoritmo que já não é muito aliviado pelos cálculos..... O IMHO vai desacelerar consideravelmente. (A chamada de função é o procedimento mais longo, depois vem a operação de divisão de ponto flutuante).
O que há de errado com o algoritmo padrão para calcular o desvio padrão? Está disponível, mas a previsão leva o valor de um muving na barra correspondente - leve o que você precisa, é isto e nenhuma função chama. Basta fazer um loop através da matriz e pegar os quadrados das diferenças entre o preço previsto na barra dada e o real, depois pegar a raiz quadrada uma vez - é isso aí.
Concordo plenamente com você! Os atrasos no futuro serão terríveis para cálculos de massa, embora em cálculos pequenos não seja perceptível no momento. Mas isto é causado pelo desenvolvimento do algoritmo, que será então utilizado para calcular tudo. Tal abundância de funções primitivas é causada simplesmente pela conveniência (pelo menos me parece :o)) de uso quando se procura um algoritmo. São estas funções RMS, Dispersão, Média, eu só uso em muitas outras coisas. Quando tudo ficar claro - o que contar e como, assim como o volume de cálculos, então, é claro, tudo será otimizado em conjunto. Até lá, o que temos é o que usamos - por assim dizer, as primeiras estimativas da manivela ;o).
Neste exemplo, usei a média aritmética de amostra como a variável central.
Também ontem tentei definir uma linha de regressão linear como esta variável. Assim, obtemos aquele S=SCO de erros de regressão linear. Mas por alguma razão o resultado também não me impressionou :o(.
Aqui está o código do roteiro, no qual tomamos uma linha de regressão linear como uma previsão. Além disso, a tendência atual do EURUSD se encaixa muito bem nisso.
//+------------------------------------------------------------------+
//|                                                        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);
}


Vamos pegar o período H1 no EURUSD. Pegamos uma amostra do coeficiente Hearst de 500 barras = 0,26
300 barras - 0,31, 100 barras - 0,39, 30 barras - 0,51. Não entendo porque :o(.

Tentaremos o mouving recomendado por você. Embora eu ainda não saiba por que os resultados serão fundamentalmente diferentes do que eu tenho.

 
HOORAY! Parece que já descobri como calcular o Hurst. Aqui está o texto do roteiro, onde o índice é calculado em relação ao canal de regressão linear.
//+------------------------------------------------------------------+
//|                                                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);

}


Aqui está o link onde as capturas de tela estão localizadas https://c.mql5.com/mql4/forum/2006/05/Herst.zip
No início, tentei carregar estes arquivos de imagens no site, por isso seria conveniente vê-los no próprio tema, mas por alguma razão estes arquivos gif no site www.mql4.com após a mudança persistente do motor não querem ser inseridos :o(. Não importa o bem que pelo menos zipou o upload.

Uma breve explicação do roteiro. O roteiro desenha uma linha amarela grossa do canal de regressão linear no gráfico e ao mesmo tempo traça a projeção do canal no futuro com uma fina linha vermelha.
A julgar pelas capturas de tela, devo estar certo em meus cálculos :o). Embora eu tenha que checar novamente no futuro.

PS: Vladislav, acho que o cálculo do índice Hurst por muving é um pouco duvidoso, pois não se sabe qual o valor do período médio que deve ser tomado. Presumo que este valor para cada cálculo em particular deve mudar de alguma forma, dependendo do número de toques. É por isso que, por enquanto, me instalei em um canal de regressão linear.

 
Eu participarei da conversa, se os outros não se importarem. Eu não me aprofundei muito na metodologia de Vladislav, embora tenha uma vaga idéia. Eu decidi falar por causa das fotos. Bem, não há grão neles nesta forma, parece-me que os cálculos devem ser rastejantes (provavelmente assim Vladislav oferece). Suponha que calculamos a linha amarela para 20 (30-40 e assim por diante, como pode parecer) barras e realizamos cálculos Hearst (RMS, etc.), então em uma nova barra deixamos cair a barra mais antiga da amostra (na qual a linha amarela foi obtida) e adicionamos uma nova barra (recém-formada) e usamos esta amostra para realizar cálculos Hearst (RMS, etc.) até que estas barras apareçam.Enquanto estes cálculos se encaixarem no intervalo de confiança (agora a probabilidade se tornou exigida), não fazemos nada e tudo se desenvolve dentro dos limites aceitáveis, assim que o intervalo é violado, o canal e outros fatores são recalculados. Ou seja, existe um canal tão rastejante que se arrasta pelo caminho estabelecido até que o mercado lhe diga para recalcular tudo de novo.

Isto foi o que entendi (provavelmente incorretamente).
 
Bem, na verdade é um pouco mais profundo que isso! Minhas imagens do roteiro Hearst são apenas uma adição à essência da idéia para determinar os canais atualmente significativos tanto de regressão linear quanto os canais ideais em termos de formas quadráticas. Ou seja, Hearst nesta estratégia é apenas uma característica confirmatória, mas não a principal! O principal - estes são canais reais com intervalos de confiança calculados de 90%, 95% e 99%, por exemplo. E o objetivo da estratégia - é determiná-los corretamente, ou seja, pegar exatamente o número de barras, que é ótimo para construir um canal de atuação e aproximá-lo com a função dessa ordem, que é a mais aceitável. É claro que ninguém vai remover barras antigas da seleção porque uma nova barra apareceu! Tudo isso é um disparate no qual TODOS os indicadores convencionais se baseiam. Enquanto isso, um grande número de indicadores baseados em canais rastejantes já foram inventados. Por exemplo, citarei um deles abaixo. O delírio de seu trabalho pode ser estimado após observá-lo por algum tempo. Você verá os momentos em que a inclinação do indicador pode mudar de 45 para -45 graus assim que uma nova barra aparecer (e a última desaparece de acordo)! E então, quando você vê outro, pode voltar aos 45 graus!:o)))) É verdade que este indicador não funciona exatamente como eu escrevi. Leva um período limitado pelo número de barras e busca de pontos de referência - fractais. É claro que não levamos em consideração quais são realmente esses pontos de referência - porque não estimamos a que intervalo de confiança eles pertencem - daí todos os erros de desenho de linhas do indicador.
//+------------------------------------------------------------------+
//|                                                  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);
  }
//+------------------------------------------------------------------+
 
No entanto, este indicador (Canal Shi) é muito interessante - a idéia de jogar com a tendência e a partir das fronteiras do canal no plano é sensata em si mesma.
 
No entanto, este indicador (Canal Shi) é muito interessante - a idéia de jogar com a tendência e a partir das fronteiras do canal no plano é sensata em si mesma.

Este indicador é extraído desta estratégia
http://fxovereasy.50webs.com/Example1.html
Você pode baixar os indicadores necessários para esta estratégia para MT4 a partir do site.
http://fxovereasy.50webs.com/Indicators.html
Tudo parece fazer sentido à primeira vista. Não há outra descrição da estratégia ;o).
Razão: