kirillovyv/LibreOCL
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
LibreOCL/Lesson01/Part02/Prog01_02B/Prog01_02B.mq5
super.admin 10c769ed25 convert
2025-05-30 15:03:43 +02:00

713 lines
No EOL
63 KiB
MQL5
Raw Permalink Blame History

//============================================================================================= MQL5 ===
// LibreFEI v1.006 (MQL5)
// Главный модуль обработки событий
// Librecoin(c)2014-2017
//============================================================================================= MQL5 ===
// REVIEWS
//------------------------------------------------------------------------------------------------------
// Fourier Extrapolator Adaptive - экстраполятор фурье творческая переработка.
//============================================================================================= MQL5 ===
// IDEAS
//------------------------------------------------------------------------------------------------------
// 12.12.2017 Идея: расчетную часть выполнить с использованием OpenCL
//============================================================================================= MQL5 ===
// PROPERTY
//------------------------------------------------------------------------------------------------------
#property strict
#define ver "1.006"
#property copyright "Librecoin(c)2014-2017, gpwr(c)2008-2010"
#property link "https://www.mql5.com/ru/users/kirillovyv"
#property description "**************************************************"
#property description " Indicator LibreFEI v"+ver+" Lite (MQL5)"
#property description " Extrapolator by trigonometric (multitone) model"
#property description " From Russia with Love! :-)"
#property description " https://www.mql5.com/ru/users/kirillovyv"
#property description " Based from: gpwr(c)2008-2010, neoclassic(c)2009"
#property description "**************************************************"
#property version ver
const string vers = "LibreFEI v"+ver; //Version
//----- indicator property
#property indicator_chart_window
#property indicator_buffers 4
#property indicator_plots 2
#resource "Kernels/Prog01_02B.cl" as string CL_Source//Код кернел-программ можно подключать как ресурс
//
//============================================================================================= MQL5 ===
// INTERFACE
//------------------------------------------------------------------------------------------------------
input int Npast = 650; //Past bars, to which trigonometric series is fitted
input int Nfut = 20; //Predicted future bars
input int Nharm = 9; //Min Narmonics in model
input double FreqTOL = 0.0000001; //Tolerance of frequency calculations
input int StartBar = 15; //С какого бара начинаем
input int MSTimerSet = 500; //Установка таймера xxx миллисекунд
input int nTickDelay = 5; //Интервал пропуска тиков для тестирования
input ulong IterLimit = 60; //Iteration limit для Freq
input bool CommentOn = false; //Вывод комментариев на экран
input bool PrintOn = false; //Печать комментариев в журнал
input bool OCLSelector = true; //Использовать OpenCL
//============================================================================================= MQL5 === OCLSelector
// Global variable definition
//------------------------------------------------------------------------------------------------------
bool TimeInterrupt;
int nTickSumm;
//----- indicator buffers
double pv[]; //0 Отображаемый буфер истории PAST
double fv[]; //1 Отображаемый буфер прогноза FUTURE
double pc[]; //2 Расчетный буфер истории PAST
double fc[]; //3 Расчетный буфер прогноза FUTURE
//----- Буфер расчетного параметра
double xc[]; //Буфер расчетного параметра (Close())
//----- Включатель отладочной печати
bool PrintDebugSelector=true;
//----- Хендлы для объектов OpenCL
int h_CL_Context=INVALID_HANDLE; //Хендл контекста
int h_CL_Program=INVALID_HANDLE; //Хендл программы
int h_CL_Kernel=INVALID_HANDLE; //Хендл кернела
int h_CL_Buffers[]; //Хендлы буферов
//
//============================================================================================= MQL5 ===
// OnInit() - Custom indicator initialization function
//------------------------------------------------------------------------------------------------------
int OnInit()
{
//----- initialize global variables
TimeInterrupt=true;
nTickSumm=0;
//----- indicator parametrs
IndicatorSetInteger(INDICATOR_DIGITS,_Digits);
IndicatorSetString(INDICATOR_SHORTNAME,"LibreFEI");
//----- indicator buffers mapping
//Прошлое - буфер отображения PAST
ArraySetAsSeries(pv,true);
ArrayInitialize(pv,EMPTY_VALUE);
SetIndexBuffer(0,pv,INDICATOR_DATA);
PlotIndexSetString(0,PLOT_LABEL,"Past");
PlotIndexSetInteger(0,PLOT_DRAW_TYPE,DRAW_LINE);
PlotIndexSetInteger(0,PLOT_LINE_STYLE,STYLE_SOLID);
PlotIndexSetInteger(0,PLOT_LINE_WIDTH,2);
PlotIndexSetInteger(0,PLOT_LINE_COLOR,clrBlue);
//Будущее - буфер отображения FUTURE
ArraySetAsSeries(fv,true);
ArrayInitialize(fv,EMPTY_VALUE);
SetIndexBuffer(1,fv,INDICATOR_DATA);
PlotIndexSetString(1,PLOT_LABEL,"Future");
PlotIndexSetInteger(1,PLOT_DRAW_TYPE,DRAW_LINE);
PlotIndexSetInteger(1,PLOT_LINE_STYLE,STYLE_SOLID);
PlotIndexSetInteger(1,PLOT_LINE_WIDTH,2);
PlotIndexSetInteger(1,PLOT_LINE_COLOR,clrRed);
PlotIndexSetInteger(1,PLOT_SHIFT,Nfut); //future data vector i=0..Nfut; Nfut corresponds to bar=StartBar
//Прошлое - буфер расчета PAST - разобраться с AsSeries(), сделать false
ArraySetAsSeries(pc,false);
ArrayInitialize(pc,EMPTY_VALUE);
SetIndexBuffer(2,pc,INDICATOR_CALCULATIONS);
//Будущее - буфер расчета FUTURE
ArraySetAsSeries(fc,true);//false
ArrayInitialize(fc,EMPTY_VALUE);
SetIndexBuffer(3,fc,INDICATOR_CALCULATIONS);
//Буфер расчетного параметра
ArraySetAsSeries(xc,false);//Всегда!
ArrayResize(xc,Npast+1);
//----- Настройки таймера и глобальных счетчиков
{if(!MQLInfoInteger(MQL_TESTER))//Не тестирование
{
int err=-1;
int count=50;
{while((err!=0)&&(count>0))
{
ResetLastError();
EventSetMillisecondTimer(MSTimerSet); //Установка таймера XXX миллисекунд
err=GetLastError();
{if(err!=0)
{
Sleep(50);
}}//if(err!=0)
count--;
}}//while((err!=0)&&(count>0))
}}//if(!MQLInfoInteger(MQL_TESTER))
//----- Подготовительные операции OpenCL
{if(OCLSelector)
{
//----- Включатель отладочной печати
PrintDebugSelector=true;
//----- Хендлы для объектов OpenCL
h_CL_Context=INVALID_HANDLE; //Хендл контекста
h_CL_Program=INVALID_HANDLE; //Хендл программы
h_CL_Kernel=INVALID_HANDLE; //Хендл кернела
//----- Определение числа буферов под переменные
ArrayResize(h_CL_Buffers,5);//x,ipc,im,ic,is
ArrayFill(h_CL_Buffers,0,ArraySize(h_CL_Buffers),INVALID_HANDLE);
//----- Создание контекста (среды) для программы OpenCL (выбор девайса)
ResetLastError();
{if((h_CL_Context=CLContextCreate(CL_USE_ANY))==INVALID_HANDLE) //CL_USE_ANY - использовать любое доступное устройство с поддержкой OpenCL
{
Print("OpenCL not found, error:",GetLastError());
ShutDown(h_CL_Context,h_CL_Program,h_CL_Kernel,h_CL_Buffers);
return(INIT_FAILED);
}else{
Print("OpenCL found, Хендл на контекст OpenCL:",h_CL_Context," Error:",GetLastError());
}}//if((h_CL_Context=CLContextCreate(CL_USE_ANY))==INVALID_HANDLE)
//----- Создание в контексте программы на основе кода в строке CL_Source
string BuildLog=""; //Лог компиляции
ResetLastError();
{if((h_CL_Program=CLProgramCreate(h_CL_Context,CL_Source,BuildLog))==INVALID_HANDLE)//В третьем параметре - лог компиляции
{
Print("OpenCL program create failed, error:",GetLastError()," BuildLog=",BuildLog);
ShutDown(h_CL_Context,h_CL_Program,h_CL_Kernel,h_CL_Buffers,BuildLog,PrintDebugSelector);
return(INIT_FAILED);
}else{
Print("OpenCL program create, Хендл программы OpenCL:",h_CL_Program," Error:",GetLastError());
}}//if((h_CL_Program=CLProgramCreate(h_CL_Context,CL_Source,BuildLog))==INVALID_HANDLE)
//----- Создание кернела для расчета значений функции от двух переменных
string CL_Kernel_Name="TrigFit_OCL"; //Задание имени кернела - задать вручную
ResetLastError();
{if((h_CL_Kernel=CLKernelCreate(h_CL_Program,CL_Kernel_Name))==INVALID_HANDLE) //Имя функции должно соответствовать имени в программной строке CL_Source
{
Print("OpenCL kernel create failed, error:",GetLastError());
ShutDown(h_CL_Context,h_CL_Program,h_CL_Kernel,h_CL_Buffers);
return(INIT_FAILED);
}else{
Print("OpenCL kernel create, Хендл кернела OpenCL:",h_CL_Kernel," Error:",GetLastError());
}}//if((h_CL_Kernel=CLKernelCreate(h_CL_Program,"Exch"))==INVALID_HANDLE)
//----- Создание буферов
//----- Создание буфера[0] OpenCL для значений x[]
ResetLastError();
{if((h_CL_Buffers[0]=CLBufferCreate(h_CL_Context,Npast*sizeof(double),CL_MEM_READ_WRITE))==INVALID_HANDLE)//__global double *x,
{
Print("OpenCL buffer create failed, error:",GetLastError());
ShutDown(h_CL_Context,h_CL_Program,h_CL_Kernel,h_CL_Buffers);
return(INIT_FAILED);
}else{
Print("OpenCL buffer create, Хендл буфера OpenCL:",h_CL_Buffers[0]," Error:",GetLastError());
}}//if((h_CL_Buffer=CLBufferCreate(h_CL_Context,ArraySize(x)*sizeof(double),CL_MEM_READ_WRITE))==INVALID_HANDLE)
//----- Создание буфера[1] OpenCL для значений ipc[] - переделать, только при изменении размерности массива
ResetLastError();
{if((h_CL_Buffers[1]=CLBufferCreate(h_CL_Context,Npast*sizeof(double),CL_MEM_READ_WRITE))==INVALID_HANDLE)//__global double *ipc,
{
Print("OpenCL buffer create failed, error:",GetLastError());
ShutDown(h_CL_Context,h_CL_Program,h_CL_Kernel,h_CL_Buffers);
return(INIT_FAILED);
}else{
Print("OpenCL buffer create, Хендл буфера OpenCL:",h_CL_Buffers[1]," Error:",GetLastError());
}}//if((h_CL_Buffer=CLBufferCreate(h_CL_Context,ArraySize(x)*sizeof(double),CL_MEM_READ_WRITE))==INVALID_HANDLE)
//----- Создание буфера[2] OpenCL для значений im[]
ResetLastError();
{if((h_CL_Buffers[2]=CLBufferCreate(h_CL_Context,sizeof(double),CL_MEM_READ_WRITE))==INVALID_HANDLE)//__global double *m,
{
Print("OpenCL buffer create failed, error:",GetLastError());
ShutDown(h_CL_Context,h_CL_Program,h_CL_Kernel,h_CL_Buffers);
return(INIT_FAILED);
}else{
Print("OpenCL buffer create, Хендл буфера OpenCL:",h_CL_Buffers[2]," Error:",GetLastError());
}}//if((h_CL_Buffer=CLBufferCreate(h_CL_Context,ArraySize(x)*sizeof(double),CL_MEM_READ_WRITE))==INVALID_HANDLE)
//----- Создание буфера[3] OpenCL для значений ic[]
ResetLastError();
{if((h_CL_Buffers[3]=CLBufferCreate(h_CL_Context,sizeof(double),CL_MEM_READ_WRITE))==INVALID_HANDLE)//__global double *c,
{
Print("OpenCL buffer create failed, error:",GetLastError());
ShutDown(h_CL_Context,h_CL_Program,h_CL_Kernel,h_CL_Buffers);
return(INIT_FAILED);
}else{
Print("OpenCL buffer create, Хендл буфера OpenCL:",h_CL_Buffers[3]," Error:",GetLastError());
}}//if((h_CL_Buffer=CLBufferCreate(h_CL_Context,ArraySize(x)*sizeof(double),CL_MEM_READ_WRITE))==INVALID_HANDLE)
//----- Создание буфера[4] OpenCL для значений is[]
ResetLastError();
{if((h_CL_Buffers[4]=CLBufferCreate(h_CL_Context,sizeof(double),CL_MEM_READ_WRITE))==INVALID_HANDLE)//__global double *s,
{
Print("OpenCL buffer create failed, error:",GetLastError());
ShutDown(h_CL_Context,h_CL_Program,h_CL_Kernel,h_CL_Buffers);
return(INIT_FAILED);
}else{
Print("OpenCL buffer create, Хендл буфера OpenCL:",h_CL_Buffers[4]," Error:",GetLastError());
}}//if((h_CL_Buffer=CLBufferCreate(h_CL_Context,ArraySize(x)*sizeof(double),CL_MEM_READ_WRITE))==INVALID_HANDLE)
}else{
}}//if(OCLSelector)
//----- Выход тут
return(INIT_SUCCEEDED);
}//OnInit()
//
//============================================================================================= MQL5 ===
// OnDeinit() - Custom indicator iteration function |
//------------------------------------------------------------------------------------------------------
void OnDeinit(const int reason){
Comment("");
return;
}//OnDeinit()
//
//============================================================================================= MQL5 ===
// OnTimer()
//------------------------------------------------------------------------------------------------------
void OnTimer(){
TimeInterrupt=true;
nTickSumm=0;
}//OnTimer()
//
//============================================================================================= MQL5 ===
// OnCalculate() - Custom indicator iteration function
//------------------------------------------------------------------------------------------------------
int OnCalculate(const int rates_total,
const int prev_calculated,
const datetime& time[],
const double& open[],
const double& high[],
const double& low[],
const double& close[],
const long& tick_volume[],
const long& volume[],
const int& spread[])
{
//----- Check for insufficient data
{if(rates_total<Npast+StartBar+1)
{
{if(PrintOn)
{
Print("Error: not enough bars in history!"
+" Total="+IntegerToString(rates_total)
+" needed="+IntegerToString(Npast+StartBar+1));
}}//if(PrintOn)
return(0);
}}//if(rates_total<Npast)
//----- Проверка необходимости пересчета по тикам
{if(MQLInfoInteger(MQL_TESTER))
{
nTickSumm++;
{if(MathMod(nTickSumm,nTickDelay)<1.0)
{
nTickSumm=0;
TimeInterrupt=true;
}}//if(MathMod(nTickSumm,7)<1.0)
}}//if(MQLInfoInteger(MQL_TESTER))
//----- Проверка необходимости пересчета по таймеру
{if(rates_total<=prev_calculated)//размер входных таймсерий меньше или равен, чем ранее обработано (обычно размер входных на предшествующем тике)
{//Изменений нет - проверяем таймер
{if(!TimeInterrupt)//если нет прерывания от msec таймера
{
return(rates_total); //Сваливаем, ибо нет изменений и прерывания таймера
}else{//есть прерывание таймера - сбрасываем и выполняем расчет
TimeInterrupt=false;
}}//if(!TimeInterrupt)
}}//if(rates_total<=prev_calculated)
//----- Определение серийности массивов данных
ArraySetAsSeries(open,true);
ArraySetAsSeries(close,true);
ArraySetAsSeries(high,true);
ArraySetAsSeries(low,true);
ArraySetAsSeries(spread,true);
//----- Заполнение исходного массива для расчета прогноза
{for(int i=0;i<Npast;i++)
{
xc[i]=close[i];
}}//for(int i=0;i<Npast;i++)
//----- Расчет индикаторных буферов
Calc_Fourier(xc,pc,fc,Npast,Nharm);
//----- Расчет и вывод индикаторных буферов и справочной информации
{if(CommentOn)
{
Comment( "LibreFEI"+" "+
string(TimeCurrent())+" "+
"ST="+IntegerToString(StartBar)+" "+
"NF="+IntegerToString(Nfut)+" "+
"NP="+IntegerToString(Npast)+" "+
"NH="+IntegerToString(Nharm)+" "
);
}}//if(CommentOn)
{if(PrintOn)
{
Print( string(TimeCurrent())+" "+
"NP="+IntegerToString(Npast)+" "+
"NH="+IntegerToString(Nharm)+" "
);
}}//if(PrintOn)
//----- Гасим индикацию
PlotIndexSetInteger(0,PLOT_DRAW_TYPE,DRAW_NONE); //pv Past View
PlotIndexSetInteger(1,PLOT_DRAW_TYPE,DRAW_NONE); //fv Future View
PlotIndexSetInteger(2,PLOT_DRAW_TYPE,DRAW_NONE); //pc Past Calculate
PlotIndexSetInteger(3,PLOT_DRAW_TYPE,DRAW_NONE); //fc Future Calculate
ArrayInitialize(pv,EMPTY_VALUE);
ArrayInitialize(fv,EMPTY_VALUE);
//----- Перекладка массивов для отображения
//ArrayCopy(pv,pc,0,0,Npast+StartBar+1); - Если один массив AsSeries, а второй нет, то разворачивает
{for(int i=0;i<=Npast+StartBar;i++)
{
pv[i]=pc[i];
}}//for(int i=0;i<=Npast+StartBar;i++)
{for(int i=0;i<=Nfut;i++)
{
fv[Nfut-i]=fc[i];
}}//for(int i=0;i<=Nfut;i++)
//----- Включаем индикацию
PlotIndexSetInteger(0,PLOT_DRAW_TYPE,DRAW_LINE); //pv
PlotIndexSetInteger(1,PLOT_DRAW_TYPE,DRAW_LINE); //fv
PlotIndexSetInteger(2,PLOT_DRAW_TYPE,DRAW_LINE); //pc
PlotIndexSetInteger(3,PLOT_DRAW_TYPE,DRAW_LINE); //fs
ChartRedraw(ChartID());
//-----
return(rates_total);
}//OnCalculate()
//
//============================================================================================= MQL5 ===
// Calc_Fourier() - Calc_Fourier
//------------------------------------------------------------------------------------------------------
void Calc_Fourier(double &x[],double &p[],double &f[],int iNpast,int iNharm){
//-----
//----- initialize indicator buffers to EMPTY_VALUE
ArrayInitialize(p,EMPTY_VALUE);
ArrayInitialize(f,EMPTY_VALUE);
//----- Find average of past values
double av=0.0;
//Заполнение исходного массива для расчета и накопление суммы для вычисления среднего
{for(int i=0;i<iNpast;i++)
{
av=av+x[i];
}}//for(int i=0;i<Npast;i++)
//Расчет среднего
av=av/iNpast;
//----- initialize model outputs
{for(int i=0;i<iNpast;i++)
{
p[i]=av; //Прошлое заполняем средним значением от [0] на максимальную глубину
}}//for(int i=0;i<iNpast;i++)
{for(int i=0;i<=Nfut;i++)
{
f[i]=av; //Будущее заполняем средним значением от [0] на глубину Nfut
}}//for(int i=0;i<iNpast;i++)
//----- fit trigonometric model and calculate predictions
double w,m,c,s;
{for(int harm=1;harm<=iNharm;harm++)//Nharmm - раз прогоняемся в цикле
{
Freq(x,p,iNpast,w,m,c,s);
double mcc=0.0;
double ss=0.0;
{for(int i=0;i<iNpast;i++)
{
mcc=m+c*MathCos(w*i);
ss=s*MathSin(w*i);
p[i]+=mcc+ss;
{if(i<=Nfut)
{
f[i]+=mcc-ss;
}}//if(i<=Nfut)
}}//for(int i=0;i<iNpast;i++)
}}//for(int harm=1;harm<=Nharmm;harm++)
return;
}//Calc_Fourier()
//
//============================================================================================= MQL5 ===
// Freq() - Quinn and Fernandes algorithm for finding frequency
//------------------------------------------------------------------------------------------------------
void Freq(double& x[],double& ipc[],int n,double& w,double& m,double& c,double& s)
{
double z[];
ArrayResize(z,n);
double alpha=0.0;
double beta=2.0;
z[0]=x[0]-ipc[0];
ulong IterCount=0;
{while((MathAbs(alpha-beta)>FreqTOL)&&(IterCount<IterLimit))
{
alpha=beta;
z[1]=x[1]-ipc[1]+alpha*z[0];
double num=z[0]*z[1];
double den=z[0]*z[0];
{for(int i=2;i<n;i++)
{
z[i]=x[i]-ipc[i]+alpha*z[i-1]-z[i-2];
num+=z[i-1]*(z[i]+z[i-2]);
den+=z[i-1]*z[i-1];
}}//for(int i=2;i<n;i++)
beta=num/den;
IterCount++;
}}//while(MathAbs(alpha-beta)>FreqTOL)
w=MathArccos(beta/2.0);
////----- Сравнение расчетов
//double m1,c1,s1;
//m1=m;c1=c;s1=s;
//TrigFitOCL(x,ipc,n,w,m,c,s);
//Print("1. m=",DoubleToString(m,8)," c=",DoubleToString(c,8)," s=",DoubleToString(s,8));
//m=m1;c=c1;s=s1;
//TrigFit(x,ipc,n,w,m,c,s);
//Print("2. m=",DoubleToString(m,8)," c=",DoubleToString(c,8)," s=",DoubleToString(s,8));
{if(OCLSelector)
{
TrigFitOCL(x,ipc,n,w,m,c,s);
}else{
TrigFit(x,ipc,n,w,m,c,s);
}}//if(OCLSelector)
}//Freq()
//
//============================================================================================= MQL5 ===
// TrigFitOCL() - Least-squares fitting of trigonometric series
//------------------------------------------------------------------------------------------------------
void TrigFitOCL(double& x[],double& ipc[],int n,double w,double& m,double& c,double& s)
{
//----- Транзитные переменные
double im[1];//2 для m
double ic[1];//3 для c
double is[1];//4 для s
im[0]=m;
ic[0]=c;
is[0]=s;
//----- Устанавливаем в качестве 0-го параметра функции OpenCL (кернела) буфер по хендлу h_CL_Buffers[0]
ResetLastError();
{if(!CLSetKernelArgMem(h_CL_Kernel,0,h_CL_Buffers[0]))
{
Print("OpenCL set buffer failed, error:",GetLastError());
ShutDown(h_CL_Context,h_CL_Program,h_CL_Kernel,h_CL_Buffers);
return;
}else{
//Print("OpenCL set buffer, Error:",GetLastError());
}}//if(CLSetKernelArgMem(h_CL_Kernel,0,h_CL_Buffer))
//----- Устанавливаем в качестве 1-го параметра функции OpenCL (кернела) буфер по хендлу h_CL_Buffers[1]
ResetLastError();
{if(!CLSetKernelArgMem(h_CL_Kernel,1,h_CL_Buffers[1]))
{
Print("OpenCL set buffer failed, error:",GetLastError());
ShutDown(h_CL_Context,h_CL_Program,h_CL_Kernel,h_CL_Buffers);
return;
}else{
//Print("OpenCL set buffer, Error:",GetLastError());
}}//if(CLSetKernelArgMem(h_CL_Kernel,0,h_CL_Buffer_ipc))
//----- Устанавливаем в качестве 2-го параметра функции OpenCL (кернела) значение переменной n
ResetLastError();
{if(!CLSetKernelArg(h_CL_Kernel,2,n))
{
Print("OpenCL set buffer failed, error:",GetLastError());
ShutDown(h_CL_Context,h_CL_Program,h_CL_Kernel,h_CL_Buffers);
return;
}else{
//Print("OpenCL set buffer, Error:",GetLastError());
}}//if(CLSetKernelArgMem(h_CL_Kernel,0,h_CL_Buffer_ipc))
//----- Устанавливаем в качестве 3-го параметра функции OpenCL (кернела) значение переменной w
ResetLastError();
{if(!CLSetKernelArg(h_CL_Kernel,3,w))
{
Print("OpenCL set buffer failed, error:",GetLastError());
ShutDown(h_CL_Context,h_CL_Program,h_CL_Kernel,h_CL_Buffers);
return;
}else{
//Print("OpenCL set buffer, Error:",GetLastError());
}}//if(CLSetKernelArgMem(h_CL_Kernel,0,h_CL_Buffer_ipc))
//----- Устанавливаем в качестве 4-го параметра функции OpenCL (кернела) буфер по хендлу h_CL_Buffers[2]
ResetLastError();
{if(!CLSetKernelArgMem(h_CL_Kernel,4,h_CL_Buffers[2]))
{
Print("OpenCL set buffer failed, error:",GetLastError());
ShutDown(h_CL_Context,h_CL_Program,h_CL_Kernel,h_CL_Buffers);
return;
}else{
//Print("OpenCL set buffer, Error:",GetLastError());
}}//if(CLSetKernelArgMem(h_CL_Kernel,0,h_CL_Buffer_ipc))
//----- Устанавливаем в качестве 5-го параметра функции OpenCL (кернела) буфер по хендлу h_CL_Buffers[3]
ResetLastError();
{if(!CLSetKernelArgMem(h_CL_Kernel,5,h_CL_Buffers[3]))
{
Print("OpenCL set buffer failed, error:",GetLastError());
ShutDown(h_CL_Context,h_CL_Program,h_CL_Kernel,h_CL_Buffers);
return;
}else{
//Print("OpenCL set buffer, Error:",GetLastError());
}}//if(CLSetKernelArgMem(h_CL_Kernel,0,h_CL_Buffer_ipc))
//----- Устанавливаем в качестве 6-го параметра функции OpenCL (кернела) буфер по хендлу h_CL_Buffers[4]
ResetLastError();
{if(!CLSetKernelArgMem(h_CL_Kernel,6,h_CL_Buffers[4]))
{
Print("OpenCL set buffer failed, error:",GetLastError());
ShutDown(h_CL_Context,h_CL_Program,h_CL_Kernel,h_CL_Buffers);
return;
}else{
//Print("OpenCL set buffer, Error:",GetLastError());
}}//if(!CLSetKernelArgMem(h_CL_Kernel,6,h_CL_Buffers[4]))
//----- Записываем исходные значения x[] в буфер по хендлу h_CL_Buffers[0]
ResetLastError();
uint nElementsWrite=CLBufferWrite(h_CL_Buffers[0],x,0,0,n);
{if(nElementsWrite<(uint)n)
{
Print("OpenCL buffer x write failed, nElementsWrite=",nElementsWrite," error:",GetLastError());
ShutDown(h_CL_Context,h_CL_Program,h_CL_Kernel,h_CL_Buffers);
return;
}else{
//Print("OpenCL buffer write, nElementsWrite=",nElementsWrite," error:",GetLastError());
}}//if(nElementsWrite<=0)
//----- Записываем исходные значения ipc[] в буфер по хендлу h_CL_Buffers[1]
ResetLastError();
nElementsWrite=CLBufferWrite(h_CL_Buffers[1],ipc,0,0,n);
{if(nElementsWrite<(uint)n)
{
Print("OpenCL buffer ipc write failed, nElementsWrite=",nElementsWrite," error:",GetLastError());
ShutDown(h_CL_Context,h_CL_Program,h_CL_Kernel,h_CL_Buffers);
return;
}else{
//Print("OpenCL buffer write, nElementsWrite=",nElementsWrite," error:",GetLastError());
}}//if(nElementsWrite<=0)
//----- Записываем исходное значение m в буфер по хендлу h_CL_Buffers[2]
ResetLastError();
nElementsWrite=CLBufferWrite(h_CL_Buffers[2],im,0,0,1);
{if(nElementsWrite<1)
{
Print("OpenCL buffer write failed, nElementsWrite=",nElementsWrite," error:",GetLastError());
ShutDown(h_CL_Context,h_CL_Program,h_CL_Kernel,h_CL_Buffers);
return;
}else{
//Print("OpenCL buffer write, nElementsWrite=",nElementsWrite," error:",GetLastError());
}}//if(nElementsWrite<=0)
//----- Записываем исходное значение c в буфер по хендлу h_CL_Buffers[3]
ResetLastError();
nElementsWrite=CLBufferWrite(h_CL_Buffers[3],ic,0,0,1);
{if(nElementsWrite<1)
{
Print("OpenCL buffer write failed, nElementsWrite=",nElementsWrite," error:",GetLastError());
ShutDown(h_CL_Context,h_CL_Program,h_CL_Kernel,h_CL_Buffers);
return;
}else{
//Print("OpenCL buffer write, nElementsWrite=",nElementsWrite," error:",GetLastError());
}}//if(nElementsWrite<=0)
//----- Записываем исходное значение s в буфер по хендлу h_CL_Buffers[4]
ResetLastError();
nElementsWrite=CLBufferWrite(h_CL_Buffers[4],is,0,0,1);
{if(nElementsWrite<1)
{
Print("OpenCL buffer write failed, nElementsWrite=",nElementsWrite," error:",GetLastError());
ShutDown(h_CL_Context,h_CL_Program,h_CL_Kernel,h_CL_Buffers);
return;
}else{
//Print("OpenCL buffer write, nElementsWrite=",nElementsWrite," error:",GetLastError());
}}//if(nElementsWrite<=0)
//----- Запускаем выполнение кернела
ResetLastError();
{if(!CLExecute(h_CL_Kernel))
{
Print("OpenCL execute failed, error:",GetLastError());
ShutDown(h_CL_Context,h_CL_Program,h_CL_Kernel,h_CL_Buffers);
return;
}else{
//Print("OpenCL execute, error:",GetLastError());
}}//if(!CLExecute(h_CL_Kernel))
//----- Считываем полученные значения в массивы
//Print("Из буфера прочитано ",CLBufferRead(h_CL_Buffers[0],x,0,0,5)," элементов");
CLBufferRead(h_CL_Buffers[0],x,0,0,n);
//Print("Из буфера прочитано ",CLBufferRead(h_CL_Buffers[1],ipc,0,0,3)," элементов");
CLBufferRead(h_CL_Buffers[1],ipc,0,0,n);
//Print("Из буфера прочитано ",CLBufferRead(h_CL_Buffers[2],im,0,0,1)," элементов");
CLBufferRead(h_CL_Buffers[2],im,0,0,1);
m=im[0];
//Print("Из буфера прочитано ",CLBufferRead(h_CL_Buffers[3],ic,0,0,1)," элементов");
CLBufferRead(h_CL_Buffers[3],ic,0,0,1);
c=ic[0];
//Print("Из буфера прочитано ",CLBufferRead(h_CL_Buffers[4],is,0,0,1)," элементов");
CLBufferRead(h_CL_Buffers[4],is,0,0,1);
s=is[0];
return;
}//TrigFitOCL()
//
//============================================================================================= MQL5 ===
// TrigFit() - Least-squares fitting of trigonometric series
//------------------------------------------------------------------------------------------------------
void TrigFit(
double &x[],
double &ipc[],
int n,
double w,
double &m,
double &c,
double &s
)
{
//c=ipc[0];
double Sc =0.0;
double Ss =0.0;
double Scc=0.0;
double Sss=0.0;
double Scs=0.0;
double Sx =0.0;
double Sxc=0.0;
double Sxs=0.0;
{for(int i=0;i<n;i++)
{
double cos_w_i=cos(w*i);
double sin_w_i=sin(w*i);
double dx=x[i]-ipc[i];
Sc +=cos_w_i;
Ss +=sin_w_i;
Scc+=cos_w_i*cos_w_i;
Sss+=sin_w_i*sin_w_i;
Scs+=cos_w_i*sin_w_i;
Sx +=dx;
Sxc+=dx*cos_w_i;
Sxs+=dx*sin_w_i;
}}//for(int i=0;i<n;i++)
Sc /=n;
Ss /=n;
Scc/=n;
Sss/=n;
Scs/=n;
Sx /=n;
Sxc/=n;
Sxs/=n;
{if(w==0.0)
{
m=Sx;
c=0.0;
s=0.0;
}else{
// calculating a, b, and m
double den=pow(Scs-Sc*Ss,2)-(Scc-Sc*Sc)*(Sss-Ss*Ss);
c=((Sxs-Sx*Ss)*(Scs-Sc*Ss)-(Sxc-Sx*Sc)*(Sss-Ss*Ss))/den;
s=((Sxc-Sx*Sc)*(Scs-Sc*Ss)-(Sxs-Sx*Ss)*(Scc-Sc*Sc))/den;
m=Sx-c*Sc-s*Ss;
}}//if(w==0.0)
return;
}//TrigFit()
//
//============================================================================================= MQL5 ===
// ShutDown() function
//------------------------------------------------------------------------------------------------------
void ShutDown(
int &i_CL_Context,
int &i_CL_Program,
int &i_CL_Kernel,
int &i_CL_Buffers[],
const string i_BuildLog = "",
const bool i_PrintDebugSelector = false
)
{
//----- Build Log Print
{if((i_PrintDebugSelector)&&(i_BuildLog!=""))
{
string LogLines[];
StringSplit(i_BuildLog,'\n',LogLines);
int LogLinesCount=ArraySize(LogLines);
{for(int i=0; i<LogLinesCount; i++)
{
Print(LogLines[i]);
}}//for(int i=0; i<LogLinesCount; i++)
}}//if((i_PrintDebugSelector)&&(i_BuildLog!=""))
//----- Remove buffer
{for(int i=0;i<=ArraySize(i_CL_Buffers)-1;i++)
{
{if(i_CL_Buffers[i]!=INVALID_HANDLE)
{
CLBufferFree(i_CL_Buffers[i]);
i_CL_Buffers[i]=INVALID_HANDLE;
}}//if(i_CL_Buffers[i]=INVALID_HANDLE)
}}//for(i=0;i<=ArraySize(i_CL_Buffers);i++)
//----- Remove kernel
{if(i_CL_Kernel!=INVALID_HANDLE)
{
CLKernelFree(i_CL_Kernel);
i_CL_Kernel=INVALID_HANDLE;
}}//if(i_CL_Kernel!=INVALID_HANDLE)
//----- Remove program
{if(i_CL_Program!=INVALID_HANDLE)
{
CLProgramFree(i_CL_Program);
i_CL_Program=INVALID_HANDLE;
}}//if(m_program!=INVALID_HANDLE)
//----- Remove context
{if(i_CL_Context!=INVALID_HANDLE)
{
CLContextFree(i_CL_Context);
i_CL_Context=INVALID_HANDLE;
}}//if(m_context!=INVALID_HANDLE)
}//ShutDown()
//
Reference in a new issue View git blame Copy permalink