Prevendo o futuro com as transformações de Fourier - página 5

Novo comentário
 

Aqui estão as freqüências que se destacaram no intervalo de pouco mais de uma semana (mostradas em dias)

4.58.

2.58.

1,63 (o mais forte, mostrado no gráfico do meio)

1.04

0.52.

0.26.


Alguma sugestão sobre o que causa o período de 1,63 dias (terceira harmônica da semana)?

 

Aqui está a primeira previsão


Ainda há muito trabalho a ser feito

ANG3110, qual é a sua previsão para amanhã?

 
m_keeper:

Aqui está a primeira previsão


Ainda há muito trabalho a ser feito

ANG3110, qual é a sua previsão para amanhã?

Na verdade, não fiz uma previsão específica. Posso apenas dar-lhe um desenho a olho nu.

E o que você vê no gráfico, descreva-o com mais detalhes.


 
Talvez alguém tenha uma transformação não rápida de Fourier para mq4? Uma implementação em C ou Pascal também é possível.
 
vaa20003:
Talvez alguém tenha uma transformação não rápida de Fourier para mq4? A implementação C ou Pascal também é possível.

Na segunda página, veja

 
m_keeper:
vaa20003:
Talvez alguém tenha uma transformação não rápida de Fourier para mq4? Uma implementação em C ou Pascal também é possível.

Ver página dois.

Obrigado, falhei...

 

Eis o que temos até agora

Buscamos as principais freqüências de mercado, determinamos sua amplitude e fase, definimos o trnd e adicionamos e normalizamos tudo isso.

Não gosto da forma como os máximos locais são pesquisados no periodograma, a pesquisa é baseada na distribuição harmônica

e não há sinal disso, claro que você pode isolá-los brincando com os parâmetros, mas ainda é instável, e muitas vezes muito microlocal

dos máximos.

O segundo inconveniente é que tudo é exibido em uma janela, é necessário espalhar todo esse prazer por vários gráficos na janela principal,

e 2-3 janelas adicionais.


Quem sabe fazer todos os cálculos em um só lugar e todos os outros - indicadores, especialistas - têm acesso aos resultados?

A seleção das freqüências apropriadas de flutuações de mercado ainda deve ser feita manualmente. Seria muito conveniente selecionar os máximos com um mouse ou uma linha como ANG3110


ANG3110, como você tem implementado o trabalho com a linha? Através de roteiros?



Um par de palavras sobre o que fazer com o que eu tenho postado agora.

Comprimento=560;//ajuste o tamanho da janela em barras
Period_count=2;// Quantos períodos consideraremos, portanto, o comprimento deve ser period_count vezes mais do que o que você vê no mercado
Garmonic=9;// Este parâmetro e o próximo são determinados pelo método de ajuste terrivelmente complicado (vou escrever sobre ele em detalhes)
GarmonicControl=1,7;

iMAperiod=4;// se o ajuste não ajudou, tente suavizar um pouco o gráfico

Futur=100;// para quantas barras para fazer a previsão
InPast=200;// operação em barras passadas, para estimativa de previsão, com base em dados já existentes

Na verdade, o que você vê no indicador (a propósito, a previsão para hoje)

Todos os gráficos devem estar em uma faixa de 0 a Lenght (bem +/- 5%)

Se o intervalo for diferente é apenas uma falha. Pressione Atualizar e funcionará bem (eu não entendo o que está errado aqui)

Gráfico fino cor-de-rosa - série cronológica preparada, deve ser semelhante ao curso.

Laranja espesso - periodograma, o valor do período é igual ao valor correspondente da linha azul

posição e quantidade de barras vermelhas que alimentam a linha azul são determinadas pela Garmonic e GarmonicControl

As barras verdes que sustentam o periodograma - os períodos detectados dependem fortemente das linhas vermelhas. Tendo discernido os períodos mais significativos, você deve começar a ajustar a Garmonic* até obter o resultado

A curva verde fina é o phasograma, parece que se a freqüência é estável então o phasograma é suave, mas se flutua então a oscilação dessa freqüência foi recentemente perturbada e não se pode confiar nela. (0 corresponde a -pi/2 ; Comprimento --- 3*pi/2)


E na verdade, o mais importante é a linha rosa grossa - é uma previsão. A previsão não tem que coincidir com o gráfico inicial por elevação e repetir o anterior. O mais importante é ver os pontos de pivô e sua possível intensidade (o tempo de pivô previsto será certamente diferente)


Arquivos anexados:
fft_and_future_searchlv2.mq4  16 kb
 
m_keeper:

A seleção das freqüências apropriadas de flutuação do mercado tem que ser feita manualmente, afinal de contas. Seria muito conveniente selecionar os máximos com um mouse, ou com uma linha, como o ANG3110 tem


ANG3110, como você tem implementado o trabalho com a linha? Através de roteiros?

Para o seu caso, acho que a opção mais adequada é a seguinte:

Você faz um roteiro para controlar o indicador:


//==============================================================
#import "user32.dll"
int      PostMessageA(int hWnd,int Msg,int wParam,int lParam);
#import
#define WM_COMMAND   0x0111
//==============================================================
int i0,ip,T;
int t0,tp,t0n,tpn;
string Symb;
int Per;
//**************************************************************
int init() 
{ 
   Symb=Symbol();
   Per=Period();
   
   t0=WindowTimeOnDropped();
   T=64; 

   i0=iBarShift(Symbol(),Period(),t0);
   ip=i0+T;
   tp=Time[ip];
   t0n=t0;
   tpn=tp;
   
   ObjectCreate("RCh",4,0,tp,0,t0,0);
   ObjectSet("RCh",OBJPROP_COLOR,DodgerBlue); 
}
//**************************************************************
int start() 
{
   int hwnd=WindowHandle(Symb,Per);        
   if (hwnd!=0) 
   {
      PostMessageA(hwnd,WM_COMMAND,33324,0); 
      GlobalVariableSet("gi0",i0);
      GlobalVariableSet("gip",ip);
   } else return(0);
   //---- 
   while(IsStopped()==false) 
   {
      t0=ObjectGet("RCh",OBJPROP_TIME2); 
      if (t0>Time[0]) t0=Time[0]; 
      tp=ObjectGet("RCh",OBJPROP_TIME1); 
      i0=iBarShift(NULL,Per,t0);
      ip=iBarShift(NULL,Per,tp);
      
      T=ip-i0;
      if (T<2) {T=2; ip=i0+T; tp=Time[ip];}
      
      if (t0n!=t0 || tpn!=tp) 
      {
         GlobalVariableSet("gi0",i0);
         GlobalVariableSet("gip",ip);
         PostMessageA(hwnd,WM_COMMAND,33324,0);
         t0n=t0;
         tpn=tp;
      } 
      
      Sleep(200);
   }
   //=============================================
   return(0);
}
//**************************************************************
void deinit() 
{
   ObjectDelete("RCh"); 
   GlobalVariableDel("gi0");
   GlobalVariableDel("gip");
}
//**************************************************************

Você o insere após int start() no indicador:

   if (GlobalVariableCheck("gi0")) 
   {
      i0=GlobalVariableGet("gi0"); 
      ip=GlobalVariableGet("gip");
      T=ip-i0;
      SetIndexShift(2,T/2);
      SetIndexShift(3,T/2);
   }
   else 
   {
      i0=0; T=T0; SetIndexShift(2,T/2); SetIndexShift(3,T/2);
   }


Primeiro você coloca o indicador no gráfico, depois joga fora o roteiro e usa o canal LR para mover o gráfico.

Espero que você mesmo possa fazer isso, ou posso lhe dar uma dica.

 

Obrigado, as linhas estão resolvidas.


Posso fazer mais uma pergunta?

Agora tenho informações em 3 gráficos, um na janela principal e dois na minha janela.

Os parâmetros são definidos apenas em um deles e armazenados em variáveis globais

As variáveis são armazenadas em variáveis globais com as chaves "PF_"+Symbol()+"_"+DoubleToStr(Period(),0)+"_key".

Eu também armazeno informações sobre os máximos em variáveis globais

O problema é que eu tenho que fazer os cálculos três vezes para cada gráfico.

No início eu tentei o iCustom, mas na minha opinião não é preciso

os dados dos gráficos adicionados anteriormente, mas calcula-os novamente, pelo menos init

e vê que já começou (por variáveis globais)

e não faz cálculos, e o iCustom devolve um Vazio.

Existe alguma maneira de tornar as arrays globais?

Parece-me que se você enfiar milhares de valores na GlobalVariable, será muito mais lento para trabalhar.

será muito mais lento de trabalhar, porque a busca na corda vai

 
m_keeper:

Existe alguma maneira de tornar as arrays globais?

Não tenho certeza do que você precisa, mas quando você precisa salvar muitos dados e depois lê-los novamente, é mais fácil usar a escrita em um arquivo intermediário, por exemplo:

int handle=FileOpen("Test.dat",FILE_BIN|FILE_WRITE);

FileWriteArray(handle,arr,0,Narr);

E depois leia novamente de outro programa:

int handle=FileOpen("Test.dat",FILE_BIN|FILE_READ);

FileReadArray(handle,arr,0,Narr);

Favor consultar a Ajuda MT4 para mais detalhes.

123456789101112...55
Novo comentário