AttribInd_2e

//+------------------------------------------------------------------+
//|                                                 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=1;
   double g=0;  						    
   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 flag=0;//0-no file ,1-file ma,2-file ma diff   


   int normalize=1;//1-normalize 0-
   
//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.std";
//---- 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 
   );

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