Библиотека корреляции двух функций c помощью FFT

Новый комментарий
 
Добрый день!
Хочу наладить библиотечку корреляции двух функций с помощью быстрого преобазования Фурье, но что-то запутался....
Посмотрите, пожауйста правильно ли я перевел исходник с С++ на MQL4 ?
первоисточник тут
http://alglib.sources.ru/fft/fastcorellation.php
 
Ну и собственно пример применения этой функции:
Что-то не то показывает.
Где ошибка?
 
А вообще, конечной целью является написание анализатора спектра котировок на заданном интервале.
Что бы на лету просчиывался спектр.
И можно будет, например фильтры цифровые (Fatl-ы, Satl-ы и тд. ..) подстраивать автоматически..., ну еще ряд идей есть.
Если у кого-нибудь есть наработки подскажите, пожалуйста.
 
klot писал (а):
А вообще, конечной целью является написание анализатора спектра котировок на заданном интервале.
Что бы на лету просчиывался спектр.
И можно будет, например фильтры цифровые (Fatl-ы, Satl-ы и тд. ..) подстраивать автоматически..., ну еще ряд идей есть.
Если у кого-нибудь есть наработки подскажите, пожалуйста.

Писал разложение цены в ряд фурье. Ничего хорошего не получилось. Найти бы алгоритм MESA. Может кто знает где он есть?
 
Ну вот и наладил библиотеку быстрого преобразования Фурье.
Файл нужно положить в
c:\Program Files\MetaTrader 4\experts\libraries\ и скомпилировать.
там семь функций:
//+------------------------------------------------------------------+
//| My function                                                      |
//+------------------------------------------------------------------+
//| #import "#_lib_FFT.ex4"                                          |
//| void fastfouriertransform(double& a[], int nn, bool inversefft); |            
//| void realfastfouriertransform(double& a[], int tnn,              |
//|                               bool inversefft);                  |
//| void fastcorellation(double& signal[], int signallen,            |
//|                      double& pattern[],  int patternlen);        |
//| void fastconvolution(double& signal[], int signallen,            |
//|          double& response[], int negativelen, int positivelen);  |
//| void fastsinetransform(double& a[], int tnn, bool inversefst);   | 
//| void fastcosinetransform(double& a[],int tnn, bool inversefct);  |
//| void tworealffts(double a1[], double a2[], double& a[],          | 
//|                  double& b[], int tn);                           |
//| #import                                                          |
//+------------------------------------------------------------------+

Подробное описание каждой функции есть в исходнике #_lib_FFT.mq4
а также на сайте http://alglib.sources.ru/fft/
Файлы:
m_lib_fft_1.mq4  28 kb
 
Integer писал (а):
klot писал (а):
А вообще, конечной целью является написание анализатора спектра котировок на заданном интервале.
Что бы на лету просчиывался спектр.
И можно будет, например фильтры цифровые (Fatl-ы, Satl-ы и тд. ..) подстраивать автоматически..., ну еще ряд идей есть.
Если у кого-нибудь есть наработки подскажите, пожалуйста.

Писал разложение цены в ряд фурье. Ничего хорошего не получилось. Найти бы алгоритм MESA. Может кто знает где он есть?

Да, MESA не помешало бы, но и Фурье тоже не плох!!! если его правильно приготовить :)
У меня все получилось.
 

Здравствуйте, не подскажите, как можно увеличить скорость работы индикатора и убрать перерисовку

//+------------------------------------------------------------------+
//|                                                      FullSSA.mq4 |
//|                                           Copyright © 2007, klot |
//|                                                     klot@mail.ru |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2007, klot"
#property link      "klot@mail.ru"


#import "SSA.ex4" //"FullSSA.dll"
 void fastsingular(double a[],int n,int lag,int s,double& b[]);
#import


#property indicator_separate_window
#property indicator_buffers 1
#property indicator_color1 Yellow
#property indicator_level1 0.0
//----
   extern int Lag=10;
   extern int NumComps=2;
   extern  int PeriodNorm=10;
   extern int N=300;

   double arryTimeSeries[];
//---- buffers
double SSA[];

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---- indicators
   SetIndexStyle(0,DRAW_LINE);
   SetIndexBuffer(0,SSA);
   ArrayResize(arryTimeSeries,N);
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//----
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   int    counted_bars=IndicatorCounted();
//----
   SetIndexDrawBegin(0,Bars-N);
   double dev,ma;
   int i, nmax, nmin;
   //---
   for( i=N-1; i>=0; i--) {
   //-----
      ma=iMA(NULL,0,PeriodNorm,0,MODE_SMA,PRICE_CLOSE,i);
      dev=3*iStdDev(NULL,0,PeriodNorm,0,MODE_SMA,PRICE_CLOSE,i);
      if(dev==0) dev=0.1;
      arryTimeSeries[i]=(Close[i]-ma)/dev;//iDeMarker(NULL,0,PeriodNorm,i);
   }
   fastsingular(arryTimeSeries,N,Lag,NumComps,SSA);
   nmax=ArrayMaximum(SSA,3,1);
   nmin=ArrayMinimum(SSA,3,1);
   if(nmax==2) {
            ObjectCreate("Sell"+Time[0],OBJ_ARROW,0,Time[0],Open[0]);
            ObjectSet("Sell"+Time[0],OBJPROP_ARROWCODE,226);
   }
   if(nmin==2) {
            ObjectCreate("Buy"+Time[0],OBJ_ARROW,0,Time[0],Open[0]);
            ObjectSet("Buy"+Time[0],OBJPROP_ARROWCODE,225);
   }
//----
   return(0);
  }
//+------------------------------------------------------------------+

на сколько я понял, низкая скорость расчёта в вызываемой функции.

void fastsingular( double X[],int n,int l,int s,double &Y[])
{
        if( l>MaxCatLag ) l=MaxCatLag;
   if( s>MaxCompCol ) s=MaxCompCol;
   if( s>l ) s=l;
   if( n>MaxLen ) n=MaxLen;
        double A[200][200]; //Matrix *A = new Matrix(MaxCatLag,MaxCatLag);
        double B[5000][200]; //ArrayResize(B,n); //Matrix *B = new Matrix(n,MaxCatLag);
        double Bn[200][5000]; //Matrix *Bn = new Matrix(MaxCatLag,n);
        
        int kb,lb,m,k,i,j,i1;
        double V[200][5000]; //Matrix *V = new Matrix(MaxCompCol,n);
        double Yn[200][5000]; //Matrix *Yn = new Matrix(MaxCompCol,n);
        double ls[200];
        //---
        double Vtemp[200];
        //---
        j=0;
        k=n-l+1;
        /*Формируем матрицу А в методе который я скачал на сайте создателей эта матрица S*/
        for (i=0;i<=l-1;i++)
        {
                for (j=0;j<=l-1;j++)
                {
                        A[i][j]=0; //A->m[i][j]=0;
                        for (m=0;m<=k-1;m++) // (m=0;m<=k-1;m++)
                        {
                                A[i][j]=A[i][j]+X[i+m]*X[m+j]; //A->m[i][j]=A->m[i][j]+1.0*X[i+m]*X[m+j];
                                B[m][j]=X[m+j]; //B->m[m][j]=X[m+j];
                        }
                }
   }
        /*Находим собственные числа и векторы матрицы А*/
        for (i=0;i<=s-1;i++)
    {
      ls[i]=gaussbisectionl(A,l-i,l);
      svector(A,ls[i],l,Vtemp); //svector(A,ls[i],l,V->m[i]);
      for( j=0;j<=l-1; j++) V[i][j]=Vtemp[j];
    }
   //------
        /*Формируется восстановленная матрица*/
        for (i1=0;i1<=s-1;i1++)
    {
                //------
                for (i=0;i<=k-1;i++)
                {
                        Yn[i1][i]=0; //Yn->m[i1][i]=0;
                        for (j=0;j<=l-1;j++)  Yn[i1][i]=Yn[i1][i]+B[i][j]*V[i1][j];
                                             //Yn->m[i1][i]=Yn->m[i1][i]+1.0*B->m[i][j]*V->m[i1][j];
                }
                //------
                for (i=0;i<=l-1;i++){
                        for (j=0;j<=k-1;j++)    Bn[i][j]=V[i1][i]*Yn[i1][j]; 
                                             //Bn->m[i][j]=1.0*V->m[i1][i]*Yn->m[i1][j];
                }
                //-------
                //Диагональное усреднение (восстановление ряда)
                kb=k;
                lb=l;
                for (i=0;i<=n-1;i++)
                {
                        Yn[i1][i]=0; //Yn->m[i1][i]=0;
                        if (i<lb-1)
                        {
                                for (j=0;j<=i;j++)
                                {
                                        if (l<=k) Yn[i1][i] = Yn[i1][i]+Bn[j][i-j]; //Yn->m[i1][i] = Yn->m[i1][i]+Bn->m[j][i-j];
                                        if (l>k)  Yn[i1][i] = Yn[i1][i]+Bn[i-j][j]; //Yn->m[i1][i] = Yn->m[i1][i]+Bn->m[i-j][j];
                                }
                                Yn[i1][i] = Yn[i1][i]/(1.0*(i+1)); //Yn->m[i1][i]=1.0*Yn->m[i1][i]/(i+1);
                        }
                        if ((lb-1<=i)&&(i<kb-1))
                        {
                                for (j=0;j<=lb-1;j++)
                                {
                                        if (l<=k) Yn[i1][i]=Yn[i1][i]+Bn[j][i-j]; //Yn->m[i1][i]=Yn->m[i1][i]+Bn->m[j][i-j];
                                        if (l>k) Yn[i1][i]=Yn[i1][i]+Bn[i-j][j]; //Yn->m[i1][i]=Yn->m[i1][i]+Bn->m[i-j][j];
                                }
                                Yn[i1][i] = Yn[i1][i]/(1.0*lb); //Yn->m[i1][i] = 1.0*Yn->m[i1][i]/lb;
                        }
                        if (kb-1<=i)
                        {
                                for (j=i-kb+1;j<=n-kb;j++)
                                {
                                        if (l<=k) Yn[i1][i]=Yn[i1][i]+Bn[j][i-j]; //Yn->m[i1][i]=Yn->m[i1][i]+Bn->m[j][i-j];
                                        if (l>k) Yn[i1][i]=Yn[i1][i]+Bn[i-j][j]; //Yn->m[i1][i]=Yn->m[i1][i]+Bn->m[i-j][j];
                                }
                                Yn[i1][i] = Yn[i1][i]/(1.0*(n-i));//(?! что такое N)//Yn->m[i1][i]=1.0*Yn->m[i1][i]/(n-i);
                                //Yn[i1][i]=1.0*Yn[i1][i]/kb;/*(?! что такое N)*/
                        }
                }
    }
        /* Вот здесь если не суммировать, то будут отдельные компоненты разложения
        процесса по собственным функциям */
        for (i=0;i<=n-1;i++)
    {
                Y[i]=0;
                //Y[i]=Yn[3][i];
                for (i1=0;i1<=s-1;i1++)  Y[i]=Y[i]+Yn[i1][i]; //Y[i]=Y[i]+Yn->m[i1][i];
    }
        //delete A;
        //delete B;
        //delete Bn;
        //delete V;
        //delete Yn;
        //delete[] X;
}
//-----------------------------------------------------------------------------+
/*{Х-вектор исходного ряда
n-его длина
l-длина лага
s-число собственных компонент
(там исходный ряд разбивается на компонеты, а потом восстанавливается, тут ты и задаешь сколько компонент тебе надо)
Y - восстановленный ряд (сглаженный гусеницей) там я в конце еще добавил комментарий, где находятся отдельные
компоненты ряда
*/
//---------------------------------------------------------------------------

подскажите хотя бы можно это вообще сделать.

переворотная стратегия от уровней +/-, очень низкая скорость тестирования.

https://www.mql5.com/ru/code/7359

 

Кто знает куда подевался klot ? В одно время он был очень активен и его разработки известны многим. А примерно 3 года назад пропал. Может он изменил ник?

 
gpwr:

Кто знает куда подевался klot ? В одно время он был очень активен и его разработки известны многим. А примерно 3 года назад пропал. Может он изменил ник?

он просто свалил отсюда. ищите на других форумах.
Месяц назад был тут по причине нового бида и не работоспособности его индюков.
 
sergeev:
он просто свалил отсюда. ищите на других форумах.
Месяц назад был тут по причине нового бида и не работоспособности его индюков.

Если не сложно напишите на каких форумах он сейчас активен и под каким ником. Можно в личку если открыто нельзя.
 

мне тоже.

кстати, а какие у него разработки? я читал про его нейросеть построенной на сети Кохонена и оформленной на MQL4...

12
Новый комментарий
Причина обращения: