419 lines
15 KiB
MQL5
419 lines
15 KiB
MQL5
//+------------------------------------------------------------------+
|
|
//| Wavelet.mq5 |
|
|
//| Copyright 2000-2025, MetaQuotes Ltd. |
|
|
//| https://www.mql5.com |
|
|
//+------------------------------------------------------------------+
|
|
#property copyright "Copyright 2000-2025, MetaQuotes Ltd."
|
|
#property link "https://www.mql5.com"
|
|
#property version "1.00"
|
|
|
|
#include <Math/Stat/Math.mqh>
|
|
#include <Graphics/Graphic.mqh>
|
|
#include <OpenCL/OpenCL.mqh>
|
|
|
|
#define CPU_DATA 1
|
|
#define GPU_DATA 2
|
|
|
|
#define SIZE_X 600
|
|
#define SIZE_Y 200
|
|
|
|
#resource "Kernels/wavelet.cl" as string cl_program
|
|
//+------------------------------------------------------------------+
|
|
//| CWavelet |
|
|
//+------------------------------------------------------------------+
|
|
class CWavelet
|
|
{
|
|
protected:
|
|
int m_xsize;
|
|
int m_ysize;
|
|
int m_maxcolor;
|
|
string m_res_name;
|
|
string m_label_name;
|
|
uchar m_palette[3*256];
|
|
//---
|
|
double m_data[];
|
|
double m_wavelet_data_CPU[];
|
|
double m_wavelet_data_GPU[];
|
|
uint m_bmp_buffer[];
|
|
|
|
COpenCL m_OpenCL;
|
|
|
|
double Morlet(const double t);
|
|
void ShowWaveletData(const double &m_wavelet_data[]);
|
|
int GetPalColor(const int index);
|
|
void Blend(const uint c1,const uint c2,const uint r1,const uint g1,const uint b1,const uint r2,const uint g2,const uint b2);
|
|
bool WaveletCPU(const double &data[],const int datacount,const int x_size,const int y_size,const int i,const int j,const bool norm,double &result[]);
|
|
public:
|
|
//---
|
|
void Create(const string name,const int x0,const int y0,const int x_size,const int y_size);
|
|
bool CalculateWavelet_CPU(const double &data[],uint &time);
|
|
bool CalculateWavelet_GPU(double &data[],uint &time);
|
|
void ShowWavelet(const int mode);
|
|
};
|
|
//+------------------------------------------------------------------+
|
|
//| Morlet wavelet function |
|
|
//+------------------------------------------------------------------+
|
|
double CWavelet::Morlet(const double t)
|
|
{
|
|
double v=t;
|
|
double res=MathExp(-v*v*0.5)*MathCos(M_2_PI*v);
|
|
return ((double)res);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| GetPalColor |
|
|
//+------------------------------------------------------------------+
|
|
int CWavelet::GetPalColor(const int index)
|
|
{
|
|
int ind=index;
|
|
if(ind<=0)
|
|
ind=0;
|
|
if(ind>255)
|
|
ind=255;
|
|
int idx=3*(ind);
|
|
uchar r=m_palette[idx];
|
|
uchar g=m_palette[idx+1];
|
|
uchar b=m_palette[idx+2];
|
|
//---
|
|
return(b+256*g+65536*r);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Gradient palette |
|
|
//+------------------------------------------------------------------+
|
|
void CWavelet::Blend(const uint c1,const uint c2,const uint r1,const uint g1,const uint b1,const uint r2,const uint g2,const uint b2)
|
|
{
|
|
int n=int(c2-c1);
|
|
for(int i=0; i<=n; i++)
|
|
{
|
|
if((c1+i+2)<m_palette.Size())
|
|
{
|
|
m_palette[3*(c1+i)]=uchar(MathRound(1*(r1*(n-i)+r2*i)*1.0/n));
|
|
m_palette[3*(c1+i)+1]=uchar(MathRound(1*(g1*(n-i)+g2*i)*1.0/n));
|
|
m_palette[3*(c1+i)+2]=uchar(MathRound(1*(b1*(n-i)+b2*i)*1.0/n));
|
|
}
|
|
}
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Create |
|
|
//+------------------------------------------------------------------+
|
|
void CWavelet::Create(const string name,const int x0,const int y0,const int x_size,const int y_size)
|
|
{
|
|
//---
|
|
m_xsize=x_size;
|
|
m_ysize=y_size;
|
|
int size=m_xsize*m_ysize;
|
|
ArrayResize(m_bmp_buffer,size);
|
|
ArrayFill(m_bmp_buffer,0,size,0);
|
|
ArrayResize(m_wavelet_data_CPU,size);
|
|
ArrayResize(m_wavelet_data_GPU,size);
|
|
ArrayFill(m_wavelet_data_CPU,0,size,0);
|
|
ArrayFill(m_wavelet_data_GPU,0,size,0);
|
|
m_res_name=name;
|
|
m_label_name=m_res_name;
|
|
StringToUpper(m_label_name);
|
|
ResourceCreate(m_res_name,m_bmp_buffer,m_xsize,m_ysize,0,0,0,COLOR_FORMAT_XRGB_NOALPHA);
|
|
ObjectCreate(0,m_label_name,OBJ_BITMAP_LABEL,0,0,0);
|
|
ObjectSetInteger(0,m_label_name,OBJPROP_XDISTANCE,x0);
|
|
ObjectSetInteger(0,m_label_name,OBJPROP_YDISTANCE,y0);
|
|
ObjectSetString(0,m_label_name,OBJPROP_BMPFILE,NULL);
|
|
ObjectSetString(0,m_label_name,OBJPROP_BMPFILE,"::"+m_label_name);
|
|
//---
|
|
m_maxcolor=100;
|
|
Blend(0,20,0,0,95,0,0,246);
|
|
Blend(21,40,0,0,246,0,236,226);
|
|
Blend(41,60,0,236,226,226,246,0);
|
|
Blend(61,80,226,246,0,226,0,0);
|
|
Blend(81,100,226,0,0,123,0,0);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| WaveletCPU |
|
|
//+------------------------------------------------------------------+
|
|
bool CWavelet::WaveletCPU(const double &data[],const int datacount,const int x_size,const int y_size,const int i,const int j,const bool norm,double &result[])
|
|
{
|
|
double a1=(double)10e-10;
|
|
double a2=(double)15.0;
|
|
double da=(double)(a2-a1)/y_size;
|
|
double db=(double)(datacount-0)/x_size;
|
|
int pos=j*x_size+i;
|
|
//---
|
|
double a=a1+j*da;
|
|
double b=i*db;
|
|
double B=(double)1.0; //Morlet
|
|
double B_inv=(double)1.0/B;
|
|
double a_inv=(double)1/a;
|
|
double dt=(double)1.0;
|
|
double coef=(double)0.0;
|
|
if(!norm)
|
|
coef=(double)MathSqrt(a_inv);
|
|
else
|
|
{
|
|
for(int k=0; k<datacount; k++)
|
|
{
|
|
double arg=(dt*k-b)*a_inv;
|
|
arg=-B_inv*arg*arg;
|
|
coef+=(double)MathExp(arg);
|
|
}
|
|
}
|
|
double sum=0.0;
|
|
for(int k=0; k<datacount; k++)
|
|
{
|
|
double arg=(dt*k-b)*a_inv;
|
|
sum+=data[k]*Morlet(arg);
|
|
}
|
|
sum/=coef;
|
|
result[pos]=sum;
|
|
//---
|
|
return(true);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| CalculateWavelet_CPU |
|
|
//+------------------------------------------------------------------+
|
|
bool CWavelet::CalculateWavelet_CPU(const double &data[],uint &time)
|
|
{
|
|
time=GetTickCount();
|
|
int datacount=ArraySize(data);
|
|
ArrayCopy(m_data,data,0,0,WHOLE_ARRAY);
|
|
for(int i=0; i<m_xsize; i++)
|
|
{
|
|
for(int j=0; j<m_ysize; j++)
|
|
{
|
|
WaveletCPU(m_data,datacount,m_xsize,m_ysize,i,j,true,m_wavelet_data_CPU);
|
|
}
|
|
}
|
|
time=GetTickCount()-time;
|
|
//---
|
|
return(true);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| CalculateWavelet_GPU |
|
|
//+------------------------------------------------------------------+
|
|
bool CWavelet::CalculateWavelet_GPU(double &data[],uint &time)
|
|
{
|
|
int datacount=ArraySize(data);
|
|
if(!m_OpenCL.Initialize(cl_program,true))
|
|
{
|
|
PrintFormat("Error in OpenCL initialization. Error code=%d",GetLastError());
|
|
return(false);
|
|
}
|
|
//--- check support working with double
|
|
if(!m_OpenCL.SupportDouble())
|
|
{
|
|
PrintFormat("Working with double (cl_khr_fp64) is not supported on the device.");
|
|
return(false);
|
|
}
|
|
//---
|
|
m_OpenCL.SetKernelsCount(1);
|
|
m_OpenCL.KernelCreate(0,"Wavelet_GPU");
|
|
//---
|
|
m_OpenCL.SetBuffersCount(2);
|
|
if(!m_OpenCL.BufferFromArray(0,data,0,datacount,CL_MEM_READ_ONLY))
|
|
{
|
|
PrintFormat("Error in BufferFromArray for data array. Error code=%d",GetLastError());
|
|
return(false);
|
|
}
|
|
if(!m_OpenCL.BufferCreate(1,m_xsize*m_ysize*sizeof(double),CL_MEM_READ_WRITE))
|
|
{
|
|
PrintFormat("Error in BufferCreate for data array. Error code=%d",GetLastError());
|
|
return(false);
|
|
}
|
|
m_OpenCL.SetArgumentBuffer(0,0,0);
|
|
m_OpenCL.SetArgumentBuffer(0,4,1);
|
|
//---
|
|
ArrayResize(m_wavelet_data_GPU,m_xsize*m_ysize);
|
|
uint work[2];
|
|
uint offset[2]={0,0};
|
|
//--- set dimensions
|
|
work[0]=m_xsize;
|
|
work[1]=m_ysize;
|
|
//--- set parameters and write data to buffer
|
|
m_OpenCL.SetArgument(0,1,datacount);
|
|
m_OpenCL.SetArgument(0,2,m_xsize);
|
|
m_OpenCL.SetArgument(0,3,m_ysize);
|
|
time=GetTickCount();
|
|
//--- GPU calculation start
|
|
if(!m_OpenCL.Execute(0,2,offset,work))
|
|
{
|
|
PrintFormat("Error in Execute. Error code=%d",GetLastError());
|
|
return(false);
|
|
}
|
|
if(!m_OpenCL.BufferRead(1,m_wavelet_data_GPU,0,0,m_xsize*m_ysize))
|
|
{
|
|
PrintFormat("Error in BufferRead for m_wavelet_data_GPU array. Error code=%d",GetLastError());
|
|
return(false);
|
|
}
|
|
//--- GPU calculation finish
|
|
time=GetTickCount()-time;
|
|
//---
|
|
m_OpenCL.Shutdown();
|
|
return(true);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| ShowWavelet |
|
|
//+------------------------------------------------------------------+
|
|
void CWavelet::ShowWavelet(const int mode)
|
|
{
|
|
if(mode==CPU_DATA)
|
|
ShowWaveletData(m_wavelet_data_CPU);
|
|
else
|
|
if(mode==GPU_DATA)
|
|
ShowWaveletData(m_wavelet_data_GPU);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| ShowWaveletData |
|
|
//+------------------------------------------------------------------+
|
|
void CWavelet::ShowWaveletData(const double &m_wavelet_data[])
|
|
{
|
|
//--- calculate min/max and range
|
|
int count=ArraySize(m_wavelet_data);
|
|
double min_value=m_wavelet_data[0];
|
|
double max_value=m_wavelet_data[0];
|
|
for(int i=1; i<count; i++)
|
|
{
|
|
min_value=MathMin(min_value,m_wavelet_data[i]);
|
|
max_value=MathMax(max_value,m_wavelet_data[i]);
|
|
}
|
|
double range=max_value-min_value;
|
|
if(range>0)
|
|
{
|
|
for(int j=0; j<m_ysize; j++)
|
|
{
|
|
for(int i=0; i<m_xsize; i++)
|
|
{
|
|
int pos=j*m_xsize+i;
|
|
int colindex=int(m_maxcolor*(m_wavelet_data[pos]-min_value)/range);
|
|
m_bmp_buffer[pos]=GetPalColor(colindex);
|
|
}
|
|
}
|
|
//--- show image
|
|
ResourceCreate(m_res_name,m_bmp_buffer,m_xsize,m_ysize,0,0,0,COLOR_FORMAT_XRGB_NOALPHA);
|
|
ChartRedraw();
|
|
}
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Weirstrass function |
|
|
//+------------------------------------------------------------------+
|
|
double Weirstrass(double x,double a,double b)
|
|
{
|
|
double sum=0.0;
|
|
double b0=b;
|
|
double a0=a;
|
|
for(int n=0; n<35; n++)
|
|
{
|
|
double v=b0*(double)MathCos(a0*M_PI*x);
|
|
sum=sum+v;
|
|
a0=a0*a;
|
|
b0=b0*b;
|
|
}
|
|
return(sum);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| PrepareModelData |
|
|
//+------------------------------------------------------------------+
|
|
void PrepareModelData(double &price_data[],const int datacount)
|
|
{
|
|
ArrayResize(price_data,datacount);
|
|
//--- Weirstrass function
|
|
double x1=0;
|
|
double x2=2;
|
|
double dx=(x2-x1)/datacount;
|
|
for(int i=0; i<datacount; i++)
|
|
{
|
|
price_data[i]=Weirstrass(x1+dx*i,(double)3,(double)0.62);
|
|
}
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| PreparePriceData |
|
|
//+------------------------------------------------------------------+
|
|
void PreparePriceData(const string symbol,ENUM_TIMEFRAMES timeframe,double &price_data[],const int datacount)
|
|
{
|
|
ArrayResize(price_data,datacount);
|
|
CopyClose(symbol,timeframe,0,datacount,price_data);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| PrepareMomentumData |
|
|
//+------------------------------------------------------------------+
|
|
void PrepareMomentumData(double &price_data[],double &momentum_data[],const int momentum_period)
|
|
{
|
|
int size=ArraySize(price_data);
|
|
int datacount=size-momentum_period;
|
|
//---
|
|
ArrayResize(momentum_data,datacount);
|
|
for(int i=0; i<datacount; i+=1)
|
|
{
|
|
momentum_data[i]=price_data[i+momentum_period]-price_data[i];
|
|
}
|
|
ArrayCopy(price_data,price_data,momentum_period,0,datacount);
|
|
ArrayResize(price_data,datacount);
|
|
//--- rescale momentum data
|
|
double min_value=momentum_data[0];
|
|
double max_value=momentum_data[0];
|
|
for(int i=1; i<datacount; i++)
|
|
{
|
|
double value=momentum_data[i];
|
|
if(momentum_data[i]>max_value)
|
|
max_value=value;
|
|
|
|
if(momentum_data[i]<min_value)
|
|
min_value=value;
|
|
}
|
|
double range=max_value-min_value;
|
|
for(int i=0; i<datacount; i+=1)
|
|
momentum_data[i]=-1+2*(momentum_data[i]-min_value)/range;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Script program start function |
|
|
//+------------------------------------------------------------------+
|
|
void OnStart()
|
|
{
|
|
//---
|
|
int momentum_period=8;
|
|
double price_data[];
|
|
double momentum_data[];
|
|
PrepareModelData(price_data,SIZE_X+momentum_period);
|
|
//PreparePriceData("EURUSD",PERIOD_M1,price_data,SIZE_X+momentum_period);
|
|
PrepareMomentumData(price_data,momentum_data,momentum_period);
|
|
//---
|
|
CGraphic graph_price;
|
|
CGraphic graph_momentum;
|
|
graph_price.Create(0,"price",0,0,0,SIZE_X+130+6,SIZE_Y);
|
|
graph_price.XAxis().MaxGrace(0);
|
|
graph_price.HistorySymbolSize(10);
|
|
graph_price.CurveAdd(price_data,ColorToARGB(clrRed,255),CURVE_LINES,"Price");
|
|
graph_price.CurvePlotAll();
|
|
graph_price.Redraw(true);
|
|
graph_price.Update();
|
|
//---
|
|
graph_momentum.Create(0,"momentum",0,0,SIZE_Y,SIZE_X+130+6,SIZE_Y+SIZE_Y);
|
|
graph_momentum.XAxis().MaxGrace(0);
|
|
graph_momentum.HistorySymbolSize(10);
|
|
graph_momentum.CurveAdd(momentum_data,ColorToARGB(clrBlue,255),CURVE_LINES,"Momentum");
|
|
graph_momentum.CurvePlotAll();
|
|
graph_momentum.Redraw(true);
|
|
graph_momentum.Update();
|
|
//---
|
|
CWavelet wavelet;
|
|
//---
|
|
uint time_cpu=0;
|
|
wavelet.Create("Wavelet",50,2*SIZE_Y,SIZE_X,SIZE_Y);
|
|
if(!wavelet.CalculateWavelet_CPU(momentum_data,time_cpu))
|
|
{
|
|
PrintFormat("Error in calculation on CPU. Error code=%d",GetLastError());
|
|
return;
|
|
}
|
|
//wavelet.ShowWavelet(CPU_DATA);
|
|
uint time_gpu=0;
|
|
if(!wavelet.CalculateWavelet_GPU(momentum_data,time_gpu))
|
|
{
|
|
PrintFormat("Error in calculation on GPU. Error code=%d",GetLastError());
|
|
return;
|
|
}
|
|
wavelet.ShowWavelet(GPU_DATA);
|
|
//---
|
|
double CPU_GPU_ratio=0;
|
|
if(time_gpu!=0)
|
|
CPU_GPU_ratio=1.0*time_cpu/time_gpu;
|
|
//---
|
|
PrintFormat("time CPU=%d ms, time GPU=%d ms, CPU/GPU ratio: %f",time_cpu,time_gpu,CPU_GPU_ratio);
|
|
//--- Sleep 10 seconds
|
|
Sleep(10000);
|
|
}
|
|
//+------------------------------------------------------------------+
|