Prevedere il futuro con le trasformate di Fourier - pagina 5

Nuovo commento
 

Ecco le frequenze che si sono distinte nell'intervallo di poco più di una settimana (indicate in giorni)

4.58.

2.58.

1,63 (il più forte, mostrato nel grafico al centro)

1.04

0.52.

0.26.


Qualche suggerimento su cosa causa il periodo di 1,63 giorni (terza armonica della settimana)?

 

Ecco la prima previsione


C'è ancora molto lavoro da fare

ANG3110, quali sono le tue previsioni per domani?

 
m_keeper:

Ecco la prima previsione


C'è ancora molto lavoro da fare

ANG3110, quali sono le tue previsioni per domani?

In realtà non ho fatto una previsione specifica. Posso solo darvi un disegno a occhio.

E cosa vedi nel grafico, descrivilo in modo più dettagliato.


 
Forse qualcuno ha una trasformazione di Fourier non veloce in mq4? È possibile anche un'implementazione C o Pascal.
 
vaa20003:
Forse qualcuno ha una trasformazione di Fourier non veloce in mq4? È possibile anche l'implementazione in C o Pascal.

Nella seconda pagina vedi

 
m_keeper:
vaa20003:
Forse qualcuno ha una trasformazione di Fourier non veloce in mq4? È possibile anche un'implementazione C o Pascal.

Vedi pagina due.

Grazie, mi mancava...

 

Ecco cosa abbiamo finora

Cerchiamo le principali frequenze di mercato, determiniamo la loro ampiezza e fase, definiamo trnd, e aggiungiamo e normalizziamo il tutto.

Non mi piace il modo in cui vengono cercati i massimi locali sul periodogramma, la ricerca è basata sulla distribuzione armonica

e non c'è nessun segno, naturalmente è possibile isolarli giocando con i parametri, ma è ancora instabile, e spesso molto microlocale

dei massimi.

Il secondo inconveniente è che tutto viene visualizzato in una finestra, è necessario distribuire tutto questo piacere su diversi grafici nella finestra principale,

e 2-3 finestre aggiuntive.


Chi sa come fare in modo che tutti i calcoli siano eseguiti in un posto e tutti gli altri - indicatori, esperti - abbiano accesso ai risultati?

La selezione delle frequenze appropriate delle fluttuazioni di mercato deve ancora essere fatta manualmente. Sarebbe molto comodo selezionare i massimi con un mouse o una linea come ANG3110


ANG3110, come hai implementato il lavoro con la linea? Attraverso gli script?



Un paio di parole su cosa fare con quello che ho postato ora.

Lenght=560;//impostare la dimensione della finestra in barre
Period_count=2;//Quanti periodi considereremo, di conseguenza, la lunghezza dovrebbe essere period_count volte superiore a quella che si vede sul mercato
Garmonic=9;// Questo parametro e il prossimo sono determinati dal metodo di adattamento terribilmente complicato (lo scriverò in dettaglio)
GarmonicControl=1.7;

iMAperiodo=4;//se l'adattamento non ha aiutato, prova a smussare un po' il grafico

Futur=100;//per quante barre fare la previsione
InPast=200;// operazione sulle barre passate, per la stima della previsione, basata su dati già esistenti

In realtà cosa vedi sull'indicatore (la previsione per oggi tra l'altro)

Tutti i grafici dovrebbero trovarsi in un intervallo da 0 a Lenght (ben +/- 5%)

Se la gamma è diversa è solo un problema tecnico. Premi Refresh e funzionerà bene (non capisco cosa c'è di sbagliato qui)

Grafico rosa sottile - serie temporale preparata, dovrebbe essere simile al corso.

Arancione spesso - periodogramma, il valore del periodo è uguale al valore corrispondente della linea blu

la posizione e la quantità di barre rosse che alimentano la linea blu sono determinate da Garmonic e GarmonicControl

Le barre verdi che puntellano il periodogramma - i periodi rilevati dipendono fortemente dalle linee rosse. Dopo aver discernuto i periodi più significativi, si dovrebbe iniziare a regolare il Garmonic* fino ad ottenere il risultato

La sottile curva verde è il fasogramma, sembra che se la frequenza è stabile allora il fasogramma è liscio, ma se fluttua allora la fluttuazione di quella frequenza è stata recentemente disturbata e non ci si può fidare. (0 corrisponde a -pi/2; Lunghezza --- 3*pi/2)


E in realtà la cosa più importante è la spessa linea rosa - è una previsione. La previsione non deve coincidere con il grafico iniziale in termini di elevazione e ripetere il precedente. La cosa più importante da vedere sono i punti pivot e la loro possibile intensità (il tempo pivot previsto sarà sicuramente diverso)


 
m_keeper:

La selezione delle frequenze di fluttuazione del mercato appropriate deve essere fatta manualmente dopo tutto. Sarebbe molto comodo selezionare i massimi con un mouse, o con una linea, come ha ANG3110


ANG3110, come hai implementato il lavoro con la linea? Attraverso gli script?

Per il tuo caso, penso che la più adatta sia la seguente opzione:

Fate uno script per controllare l'indicatore:


//==============================================================
#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");
}
//**************************************************************

Lo inserite dopo int start() nell'indicatore:

   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);
   }


Prima metti l'indicatore sul grafico, poi butti fuori lo script e usi il canale LR per spostare il grafico.

Spero che tu possa farlo da solo o che io possa darti un suggerimento.

 

Grazie, le linee sono sistemate.


Posso fare un'altra domanda?

Ora ho informazioni in 3 grafici, uno nella finestra principale e due nella mia finestra.

I parametri sono impostati solo in uno di essi e memorizzati in variabili globali

Le variabili sono memorizzate in variabili globali con le chiavi "PF_"+Symbol()+"_"+DoubleToStr(Period(),0)+"_key".

Memorizzo anche le informazioni sui massimi in variabili globali

Il problema è che devo eseguire i calcoli tre volte per ogni grafico.

All'inizio ho provato iCustom, ma secondo me non prende

i dati dei grafici aggiunti in precedenza, ma li calcola di nuovo, almeno init

e vede che è già iniziato (da variabili globali)

e non fa calcoli, e iCustom restituisce un Empty.

C'è un modo per rendere gli array globali?

Mi sembra che se si stipano migliaia di valori in GlobalVariable, il lavoro sarà molto più lento.

sarà molto più lento a lavorare, perché la ricerca sulla stringa sta andando

 
m_keeper:

C'è un modo per rendere gli array globali?

Non sono sicuro di cosa hai bisogno, ma quando hai bisogno di salvare molti dati e poi leggerli di nuovo, è più facile usare la scrittura su un file intermedio, per esempio:

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

FileWriteArray(handle,arr,0,Narr);

E poi rileggere da un altro programma:

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

FileReadArray(handle,arr,0,Narr);

Si prega di fare riferimento all'aiuto di MT4 per maggiori dettagli.

123456789101112...55
Nuovo commento