0
Views
0
Downloads
0
Favorites
AttribInd_3e_1
//+------------------------------------------------------------------+
//| AttribInd_2d.mq4 |
//| Copyright © 2008, MetaQuotes Software Corp. |
//| http://www.metaquotes.net |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2008, MetaQuotes Software Corp."
#property link "http://www.metaquotes.net"
#property indicator_separate_window
//#property indicator_chart_window
#property indicator_buffers 3
#property indicator_color1 Yellow
#property indicator_color2 Red
#property indicator_color3 LightSeaGreen
#property indicator_level1 0.0
#include <svm288_18_6.mqh>
#define FW_M5 5
#define ROW1_M5 100
#define ROW2_M5 50
int ROW1_M1;
int ROW2_M1;
int FW_M1;
int diff=0;//2 (5min)
string file_name;
double C=50;
double g=1;
int svm_type=NU_SVR ;//C_SVC, NU_SVC, ONE_CLASS, EPSILON_SVR, NU_SVR
int kernel_type=RBF;//LINEAR, POLY, RBF, SIGMOID, PRECOMPUTED
int normalize=3;//1-normalize 0-
int flag=0;//0-no file ,1-file ma,2-file ma diff
//double lines[ROW1_M1];
double lines_attr[][COL];
//double svm_samples_class_dyn_1[ROW1_M1];
double svm_samples_class_dyn_1[][1];
//double svm_samples_attrib_dyn_1[ROW1_M1][COL];
double svm_samples_attrib_dyn_1[][COL];
//double svm_test_attrib_dyn_1[ROW2_M1][COL];
double svm_test_attrib_dyn_1[][COL];
//double ptr_predict_label__1[ROW2_M1]={0,0,0};
double ptr_predict_label__1[][1];
string SymbolName;
int PeriodMinutes1=PERIOD_M1;
int PeriodMinutes5=PERIOD_M5;
int PeriodMinutes60=PERIOD_H1;
int TrainPeriod=PERIOD_M5;
int StopLoss=30; //70
int TakeProfit=30; //70
double x1,x2,x3,x4,x5,x6,x7,x8,x9;
double y1,y2,y3,y4,y5,y6,y7,y8,y9;
double z1,z2,z3,z4,z5,z6,z7,z8,z9;
double at0,at1,at2,at3,at4,at5,at6,at7,at8;
double at9,at10,at11,at12,at13,at14,at15,at16,at17;
double at18,at19,at20,at21,at22,at23,at24,at25,at26;
double Buffer1[];
double Buffer2[];
double Buffer3[];
datetime t1,t2,t3;
int nr_of_sample_lines;
int nr_of_test_lines;
//+------------------------------------------------------------------+
//| Custom indicator initialization function |
//+------------------------------------------------------------------+
int init()
{
SymbolName=Symbol();
file_name="c:/"+SymbolName+"_file_18_6.rng";
//---- indicators
SetIndexStyle(0,DRAW_LINE);
SetIndexBuffer(0,Buffer1);
SetIndexStyle(1,DRAW_HISTOGRAM);
SetIndexBuffer(1,Buffer2);
SetIndexStyle(2,DRAW_LINE);
SetIndexBuffer(2,Buffer3);
t1=iTime(SymbolName,PeriodMinutes5,FW_M5);
FW_M1=iBarShift(SymbolName,PeriodMinutes1,t1,true);
t2=iTime(SymbolName,PeriodMinutes5,ROW2_M5);
ROW2_M1=iBarShift(SymbolName,PeriodMinutes1,t2,true);
t3=iTime(SymbolName,PeriodMinutes5,ROW1_M5);
ROW1_M1=iBarShift(SymbolName,PeriodMinutes1,t3,true);
Print(" ROW2_M5=",ROW2_M5);
Print(" ROW2_M1=",ROW2_M1);
Print("ROW1_M5-FW_M5=",ROW1_M5-FW_M5," ROW1_M5=",ROW1_M5," FW1_M5=",FW_M5);
Print("ROW1_M1-FW_M1=",ROW1_M1-FW_M1," ROW1_M1=",ROW1_M1," FW1_M1=",FW_M1);
/*
|<---------------------------ROW1_M5-------------------------->|
| |
| |<--FW_M5->|
| | |
+-------------------------------------------+-------+----------+
t3 t2 t1 t0
| |
|<-----ROW2_M5---->|
| |
lines_attr ... lines_attr|lines_attr lines_attr
[ROW1_M1-1 [FW_M1]|[FW_M1-1] [0]
*/
nr_of_sample_lines=ROW1_M1-FW_M1-diff;
nr_of_test_lines=ROW2_M1;
ArrayResize(lines_attr,ROW1_M1);
ArrayResize(svm_samples_class_dyn_1,nr_of_sample_lines);
ArrayResize(svm_samples_attrib_dyn_1,nr_of_sample_lines);
ArrayResize(svm_test_attrib_dyn_1,nr_of_test_lines);
ArrayResize(ptr_predict_label__1,nr_of_test_lines);
//----
main();
//----
return(0);
}
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function |
//+------------------------------------------------------------------+
int deinit()
{
//----
//----
return(0);
}
/*
|<---------------------------ROW1_M5-------------------------->|
| |
| |<--FW_M5->|
| | |
+-------------------------------------------+-------+----------+
t3 t2 t1 t0
| |
|<-----ROW2_M5---->|
| |
lines_attr ... lines_attr|lines_attr lines_attr
[ROW1_M1-1 [FW_M1]|[FW_M1-1] [0]
*/
//+------------------------------------------------------------------+
//| Custom indicator iteration function |
//+------------------------------------------------------------------+
int myBars1;
bool isNewBar1(int tf1)
{
//----
bool res=false;
if (myBars1!=iBars(Symbol(),tf1))
{
res=true;
myBars1=iBars(Symbol(),tf1);
}
//----
return(res);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int start()
{
int counted_bars=IndicatorCounted();
//----
int i,j;
if(isNewBar1(PERIOD_M1))
{
main();
}
for(i=FW_M1,j=0;j<nr_of_sample_lines;i++,j++)
{
Buffer2[i]=svm_samples_class_dyn_1[j][0];
}
for( i=0; i < nr_of_test_lines;i++)
{
Buffer1[i]=ptr_predict_label__1[i][0];
}
//----
return(0);
}
//+------------------------------------------------------------------+
double CalcBuySell(string _Sym, int _TPd,int SL,int TP,int _FW_M5,int pos)
{
int i,j;
double c=EMPTY_VALUE;
datetime t1=iTime(_Sym,_TPd,_FW_M5);
int _FW_M1=iBarShift(_Sym,PERIOD_M1,t1,true);
//if(pos<_FW_M1)
// return (c);
//for(i=_FW_M1+pos,j=0;j<_nr_of_sample_lines-pos;i++,j++)
//for(i=pos,j=0;j<_nr_of_sample_lines-pos;i++,j++)
//{
c=0;//EMPTY_VALUE;
double Point1=MarketInfo(_Sym,MODE_POINT);
double sp=MarketInfo(_Sym,MODE_SPREAD)*Point1;
datetime time1=iTime(_Sym,PERIOD_M1,pos);
int ii=iBarShift(_Sym,_TPd,time1,true);
//int ii = pos;//30...504
double entry_buy = iClose(_Sym,_TPd,ii)+sp;//entry_buy=bid0+sp
double entry_sell = iClose(_Sym,_TPd,ii);//entry_sell=bid0
bool longOk=true;
bool shortOk=true;
for (int fw=1; fw<_FW_M5; fw++)
{
double l=iLow(_Sym,_TPd,ii-fw);
double h=iHigh(_Sym,_TPd,ii-fw);
if (l<=entry_buy-SL*Point1) longOk=false;
if (h+sp>=entry_sell+SL*Point1) shortOk=false;
if (longOk && (h>=entry_buy+TP*Point1)) { c=(+1)*fw; break; }
if (shortOk && (l+sp<=entry_sell-TP*Point1)) { c=(-1)*fw; break; }
}
//}
return(c);
}
//////////////////////////////////////
int main()
{
//----
int i,j,k;
for (i=ROW1_M1-1;i>=0;i--)
{
datetime time1=iTime(SymbolName,PeriodMinutes1,i);
int b5=iBarShift(SymbolName,PeriodMinutes5,time1,true);
int b60=iBarShift(SymbolName,PeriodMinutes60,time1,true);
if(b5>=0)
{
x1=iMA(SymbolName,PeriodMinutes5,5,0,MODE_SMA,PRICE_CLOSE,b5);
x2=iMA(SymbolName,PeriodMinutes5,10,0,MODE_SMA,PRICE_CLOSE,b5);
x3=iMA(SymbolName,PeriodMinutes5,15,0,MODE_SMA,PRICE_CLOSE,b5);
at0=x1-x2;
at1=x2-x3;
at2=x1-x3;
y1=iMA(SymbolName,PeriodMinutes5,5,0,MODE_SMA,PRICE_CLOSE,b5+1);
y2=iMA(SymbolName,PeriodMinutes5,10,0,MODE_SMA,PRICE_CLOSE,b5+1);
y3=iMA(SymbolName,PeriodMinutes5,15,0,MODE_SMA,PRICE_CLOSE,b5+1);
at9=y1-y2;
at10=y2-y3;
at11=y1-y3;
z1=iMA(SymbolName,PeriodMinutes5,5,0,MODE_SMA,PRICE_CLOSE,b5+2);
z2=iMA(SymbolName,PeriodMinutes5,10,0,MODE_SMA,PRICE_CLOSE,b5+2);
z3=iMA(SymbolName,PeriodMinutes5,15,0,MODE_SMA,PRICE_CLOSE,b5+2);
at18=z1-z2;
at19=z2-z3;
at20=z1-z3;
}
if(b60>=0)
{
x4=iMA(SymbolName,PeriodMinutes60,5,0,MODE_SMA,PRICE_CLOSE,b60);
x5=iMA(SymbolName,PeriodMinutes60,10,0,MODE_SMA,PRICE_CLOSE,b60);
x6=iMA(SymbolName,PeriodMinutes60,15,0,MODE_SMA,PRICE_CLOSE,b60);
at3=x4-x5;
at4=x5-x6;
at5=x4-x6;
y4=iMA(SymbolName,PeriodMinutes60,5,0,MODE_SMA,PRICE_CLOSE,b60+1);
y5=iMA(SymbolName,PeriodMinutes60,10,0,MODE_SMA,PRICE_CLOSE,b60+1);
y6=iMA(SymbolName,PeriodMinutes60,15,0,MODE_SMA,PRICE_CLOSE,b60+1);
at12=y4-y5;
at13=y5-y6;
at14=y4-y6;
z4=iMA(SymbolName,PeriodMinutes60,5,0,MODE_SMA,PRICE_CLOSE,b60+2);
z5=iMA(SymbolName,PeriodMinutes60,10,0,MODE_SMA,PRICE_CLOSE,b60+2);
z6=iMA(SymbolName,PeriodMinutes60,15,0,MODE_SMA,PRICE_CLOSE,b60+2);
at21=z4-z5;
at22=z5-z6;
at23=z4-z6;
}
//for (j=0;j<COL;j++)
lines_attr[i][0]=at0/Point;
lines_attr[i][1]=at1/Point;
lines_attr[i][2]=at2/Point;
lines_attr[i][3]=at9/Point;
lines_attr[i][4]=at10/Point;
lines_attr[i][5]=at11/Point;
lines_attr[i][6]=at18/Point;
lines_attr[i][7]=at19/Point;
lines_attr[i][8]=at20/Point;
lines_attr[i][9]=at3/Point;
lines_attr[i][10]=at4/Point;
lines_attr[i][11]=at5/Point;
lines_attr[i][12]=at12/Point;
lines_attr[i][13]=at13/Point;
lines_attr[i][14]=at14/Point;
lines_attr[i][15]=at21/Point;
lines_attr[i][16]=at22/Point;
lines_attr[i][17]=at23/Point;
}
for(i=FW_M1,j=0;j<nr_of_sample_lines;i++,j++)
{
svm_samples_class_dyn_1[j][0]=CalcBuySell(SymbolName, TrainPeriod,StopLoss,TakeProfit,FW_M5,i);
for( k = 0; k < COL; k++)
svm_samples_attrib_dyn_1[j][k]=lines_attr[i][k];
}
for( i=0; i < nr_of_test_lines;i++)
{
ptr_predict_label__1[i][0]= 0.0;
for( k = 0; k < COL; k++)
svm_test_attrib_dyn_1[i][k]=lines_attr[i][k];
}
int FutureWindow=FW_M1;
int nr_of_attrib=COL;
int res1=0;
svm_normalize_sample(svm_samples_attrib_dyn_1,normalize);
svm_normalize_sample(svm_samples_class_dyn_1,normalize);
svm_normalize_test(svm_samples_attrib_dyn_1,svm_test_attrib_dyn_1,normalize);
res1= svm_classify(
svm_samples_class_dyn_1,
svm_samples_attrib_dyn_1,
svm_test_attrib_dyn_1,
nr_of_sample_lines, //2200
nr_of_test_lines, //800
nr_of_attrib,
FutureWindow, //200
file_name,
C,
g,
svm_type,//C_SVC,
kernel_type,//RBF,
ptr_predict_label__1,//predict output
flag//0-no file ,1-file ma,2-file ma diff
);
string s1="";
for( i=0; i < nr_of_test_lines;i++)
{
if(ptr_predict_label__1[i][0]!=0)
s1=s1+DoubleToStr(ptr_predict_label__1[i][0],2)+" ";
}
Print(s1);
Print("->",res1);
//----
return(0);
}
/////////////////////////////////////////////////////////////////
#define DBL_MAX 99999999999999999999
//+------------------------------------------------------------------+
//|
//+------------------------------------------------------------------+
double MAX(double x, double y)
{
if(x>y)
return(x);
else
return(y);
}
//+------------------------------------------------------------------+
//|
//+------------------------------------------------------------------+
double MIN(double x, double y)
{
if(x<y)
return(x);
else
return(y);
}
//+------------------------------------------------------------------+
//| Normalize matrix 'fmx' using precomputed 'xmean', 'std'. The
//| normalization is: for each column, subtract 'xmean' and, if the
//| column 'std' is non-zero, divide by 'std'.
//| d=nr_of_attrib
//| nv=nr_of_sample_lines
//| double **x --> double **svm_samples_attrib_scaled_dyn_
//| double *xmean = fmx_mean(x2, nv, d);
//| double *std = fmx_std(x2, nv, d);
//| fmx_prenorm(x, nv, d, xmean, std);
//| X - mean
//| i
//| S = ---------
//| i std
//+------------------------------------------------------------------+
void fmx_prenorm(
double &fmx[][],
double xmean[], // double *xmean = fmx_mean(x2, nv, d);
double std[] // double *std = fmx_std(x2, nv, d);
)
{
int i;
int j;
double f;
int rows = ArrayRange(fmx,0);
int columns = ArrayRange(fmx,1);
for (i = 0; i < columns; i++)
for (j = 0; j < rows; j++)
{
f = fmx[j][i];
if (std[i] != 0)
fmx[j][i] = (f-xmean[i])/std[i];
else
fmx[j][i] = f-xmean[i];
}
}
//+------------------------------------------------------------------+
//| max X + min X
//| i i i i
//| midrange = ----------------
//| 2
//| range = max X - min X
//| i i i i
//|
//| X - midrange
//| i
//| S = -------------
//| i range / 2
//+------------------------------------------------------------------+
void fmx_prenorm_range(
double &fmx[][],
double xrange[],
double xmidrange[]
)
{
int i;
int j;
double f;
int rows = ArrayRange(fmx,0);
int columns = ArrayRange(fmx,1);
for (i = 0; i < columns; i++)
for (j = 0; j < rows; j++)
{
f = fmx[j][i];
if (xrange[i] != 0)
fmx[j][i] = (f-xmidrange[i])/(xrange[i]/2);
else
fmx[j][i] = f-xmidrange[i];
}
}
//+------------------------------------------------------------------+
//|
//+------------------------------------------------------------------+
void fmx_midrange(double &xmidrange[],double fmx[][])
{
int i;
int j;
double smax = -DBL_MAX;
double smin = DBL_MAX;
int rows = ArrayRange(fmx,0);
int columns = ArrayRange(fmx,1);
ArrayResize(xmidrange,columns);
for (i = 0; i < columns; i++)
{
smax = -DBL_MAX;
smin = DBL_MAX;
for (j = 0; j < rows; j++)
{
smax=MAX(fmx[j][i],smax);
smin=MIN(fmx[j][i],smin);
}
xmidrange[i] = (smax+smin)/2;
}
}
//+------------------------------------------------------------------+
//|
//+------------------------------------------------------------------+
void fmx_range(double &xrange[], double fmx[][])
{
int i;
int j;
double smax = -DBL_MAX;
double smin = DBL_MAX;
int rows = ArrayRange(fmx,0);
int columns = ArrayRange(fmx,1);
ArrayResize(xrange,columns);
for (i = 0; i < columns; i++)
{
smax = -DBL_MAX;
smin = DBL_MAX;
for (j = 0; j < rows; j++)
{
smax=MAX(fmx[j][i],smax);
smin=MIN(fmx[j][i],smin);
}
xrange[i] = smax-smin;
}
}
//+------------------------------------------------------------------+
//|
//+------------------------------------------------------------------+
void fmx_max(double &xrange[],double fmx[][])
{
int i;
int j;
double smax = -DBL_MAX;
int rows = ArrayRange(fmx,0);
int columns = ArrayRange(fmx,1);
ArrayResize(xrange,columns);
for (i = 0; i < columns; i++)
{
smax = -DBL_MAX;
for (j = 0; j < rows; j++)
{
smax=MAX(fmx[j][i],smax);
}
xrange[i] = smax;
}
}
//+------------------------------------------------------------------+
//|
//+------------------------------------------------------------------+
void fmx_min(double &xrange[],double fmx[][])
{
int i;
int j;
double smin = DBL_MAX;
int rows = ArrayRange(fmx,0);
int columns = ArrayRange(fmx,1);
ArrayResize(xrange,columns);
for (i = 0; i < columns; i++)
{
smin = DBL_MAX;
for (j = 0; j < rows; j++)
{
smin=MIN(fmx[j][i],smin);
}
xrange[i] = smin;
}
}
//+------------------------------------------------------------------+
//| Return mean values of columns in 'fmx'.
//+------------------------------------------------------------------+
void fmx_mean(double &xmean[], double fmx[][])
{
int i;
int j;
double s;
int rows = ArrayRange(fmx,0);
int columns = ArrayRange(fmx,1);
ArrayResize(xmean,columns);
if (rows > 1)
{
for (i = 0; i < columns; i++)
{
s = 0.0;
for (j = 0; j < rows; j++)
s += fmx[j][i];
xmean[i] = s/rows;
}
}
else
{
for (i = 0; i < columns; i++)
xmean[i] = fmx[0][i];
}
}
//+------------------------------------------------------------------+
//| Set elements of 'vec' to 'value'.
//+------------------------------------------------------------------+
void fvec_set(double &vec[], int len, double value)
{
int i;
ArrayResize(vec,len);
for (i = 0; i < len; i++)
vec[i] = value;
}
//+------------------------------------------------------------------+
//| Return standard deviations of columns in 'fmx'.
//+------------------------------------------------------------------+
void fmx_std(double &std[], double fmx[][])
{
int i;
int j;
double xmean;
double s;
int rows = ArrayRange(fmx,0);
int columns = ArrayRange(fmx,1);
ArrayResize(std,columns);
if (rows > 1)
{
for (i = 0; i < columns; i++)
{
s = 0.0;
for (j = 0; j < rows; j++)
s += fmx[j][i];
xmean = s/rows;
s = 0.0;
for (j = 0; j < rows; j++)
s += (fmx[j][i]-xmean)*(fmx[j][i]-xmean);
std[i] = MathSqrt(s/(rows-1));
}
}
else
fvec_set(std, columns, 0.0);
}
//+------------------------------------------------------------------+
//| 1-normalize TRAIN lines from std and mean calculated from TRAIN lines
//| 1-normalize TEST lines from std and mean calculated from TEST lines
//| ..................................................................
//| 2-normalize TRAIN lines from std and mean calculated from TRAIN lines
//| 2-normalize TEST lines from std and mean calculated from TRAIN lines
//| ..................................................................
//| 3-normalize TRAIN lines from range and midrange calculated from TRAIN lines
//| 3-normalize TEST lines from range and midrange calculated from TEST lines
//| ..................................................................
//| 4-normalize TEST lines from range and midrange calculated from TRAIN lines
//+------------------------------------------------------------------+
void svm_normalize_sample(
double &svm_samples_attrib[][],
int normalize
)
{
double xmean[];
double std[];
double xrange[];
double xmidrange[];
if(normalize==1 || normalize==2)
{ //normalize TRAIN lines from std and mean calculated from TRAIN lines
fmx_mean(xmean,svm_samples_attrib);
fmx_std(std,svm_samples_attrib);
fmx_prenorm(svm_samples_attrib,xmean, std);
}
else if(normalize==3)
{ //normalize TRAIN lines from range and midrange calculated from TRAIN lines
fmx_range(xrange,svm_samples_attrib);
fmx_midrange(xmidrange,svm_samples_attrib);
fmx_prenorm_range(svm_samples_attrib,xrange, xmidrange);
}
}
//+------------------------------------------------------------------+
//| 1-normalize TEST lines from std and mean calculated from TEST lines
//| 2-normalize TEST lines from std and mean calculated from TRAIN lines
//| 3-normalize TEST lines from range and midrange calculated from TEST lines
//| 4-normalize TEST lines from range and midrange calculated from TRAIN lines
//+------------------------------------------------------------------+
void svm_normalize_test(
double svm_samples_attrib[][],
double &svm_test_attrib[][],
int normalize
)
{
if(normalize==1)
{ //normalize TEST lines from std and mean calculated from TEST lines
double xmean2[];
fmx_mean(xmean2,svm_test_attrib);
double std2[];
fmx_std(std2,svm_test_attrib);
fmx_prenorm(svm_test_attrib,xmean2, std2);
}
else if(normalize==2)
{ //normalize TEST lines from std and mean calculated from TRAIN lines
double xmean1[];
fmx_mean(xmean1,svm_samples_attrib);
double std1[];
fmx_std(std1,svm_samples_attrib);
fmx_prenorm(svm_test_attrib, xmean1, std1);
}
else if(normalize==3)
{ //normalize TEST lines from range and midrange calculated from TEST lines
double xrange2[];
fmx_range(xrange2,svm_test_attrib);
double xmidrange2[];
fmx_midrange(xmidrange2,svm_test_attrib);
fmx_prenorm_range(svm_test_attrib, xrange2, xmidrange2);
}
else if(normalize==4)
{ //normalize TEST lines from range and midrange calculated from TRAIN lines
double xrange1[];
fmx_range(xrange1,svm_samples_attrib);
double xmidrange1[];
fmx_midrange(xmidrange1,svm_samples_attrib);
fmx_prenorm_range(svm_test_attrib, xrange1, xmidrange1);
}
}
Comments