pnn2-system-1

//+------------------------------------------------------------------+
//| Example system using trained probabilistic neural network (PNN)  |
//|                                                                  |
//|                                                PNN2 System 1.mq4 |
//|                                             Paco Hernández Gómez |
//|                                    http://www.hernandezgomez.com |
//+------------------------------------------------------------------+
#property copyright "Paco Hernández Gómez"
#property link      "http://www.hernandezgomez.com"

// Import PNN library
#import "PNN2.ex4"
   void PNNInit();
   void PNNLoad();
   void PNNSave();
   void PNNAddVector(int class, double vector[]);
   int PNNClassifyVector(double vector[]);
#import

/**
 * In this system there is always an open position, either buy or sell.
 */
 
/**
 * Take profits at 18 pips.
 */
extern int LIMIT = 360;// 18;

extern double NORMALIZER = 30000000;

/**
 * Take loses at 54 pips.
 */
extern int STOP_LOSS = 240; //54;


static datetime dtsv;

////////////////////////////////////////////

/**
 * Load the trained PNN
 */
int init() {
   PNNLoad();
   return(0);
   
   //STOP_LOSS *= ( 0.0001 / Point );
   //LIMIT *= ( 0.0001 / Point );
      
   dtsv = Time[2];   
}

///////////////////////////////////////////

/**
 * Operate the system using the PNN
 */
int start() {
      
   if ( dtsv >= Time[0] ) return;
   dtsv = Time[0] ;
      
   int total;
   total = OrdersTotal();

   // If there is not an opened position
   /*if (total == 0)*/ {

      double data[60];

      // Calculate the vector to classify using the trading system criteria

    
   double month_low  = iLow(Symbol(), PERIOD_MN1, 1) ;
   double month_high = iHigh(Symbol(), PERIOD_MN1, 1) ;
   double month_close= iClose(Symbol(), PERIOD_MN1, 1) ;

   double month_pv = ( month_low + month_high + month_close ) / 3 ;

   double week_low  = iLow (Symbol(), PERIOD_W1, 1) ;
   double week_high = iHigh(Symbol(), PERIOD_W1, 1) ;
   double week_close= iClose(Symbol(), PERIOD_W1, 1) ;

   double week_pv = ( week_low + week_high + week_close ) / 3 ;
   
   double day_low  = iLow(Symbol(), PERIOD_D1, 1) ;
   double day_high = iHigh(Symbol(), PERIOD_D1, 1) ;
   double day_close= iClose(Symbol(), PERIOD_D1, 1) ;

   double day_pv = ( day_low + day_high + day_close ) / 3 ;
   double day_r1 = 2 * day_pv - day_low ;
   double day_r2 = day_pv + ( day_high - day_low ) ;
   double day_r3 = 2 * day_pv + ( day_high - 2 * day_low ) ;
   
   double day_s1 = 2 * day_pv - day_high ;
   double day_s2 = day_pv - ( day_high - day_low ) ;
   double day_s3 = 2 * day_pv - ( 2 * day_high - day_low ) ;
   
   double day_mr1 = ( day_pv + day_r1 ) / 2 ;
   double day_mr2 = ( day_r2 + day_r1 ) / 2 ;
   double day_mr3 = day_mr2 + ( day_mr2 - day_r1 ) / 2 ;
   
   double day_ms1 = ( day_pv + day_s1 ) / 2 ;
   double day_ms2 = ( day_s2 + day_s1 ) / 2 ;
   double day_ms3 = day_ms2 - ( day_ms1 - day_s2 ) / 2 ;
   
   double hl = day_high + day_low ;
   double fib_r1 = day_pv + hl * 0.382 ;
   double fib_r2 = day_pv + hl * 0.618 ;
   double fib_r3 = day_pv + hl * 1.000 ;
   
   double fib_s1 = day_pv - hl * 0.382 ;
   double fib_s2 = day_pv - hl * 0.618 ;
   double fib_s3 = day_pv - hl * 1.000 ;

   double hi = iHigh(Symbol(), PERIOD_M15, 0);
   double lo = iLow(Symbol(), PERIOD_M15, 0);
   double cl = iClose(Symbol(), PERIOD_M15, 0);
   double price ;

   price = cl;
   if ( month_low > hi ) price = hi;
   else if ( month_low < lo ) price = lo;
   data[0] = ( month_low - price ) / ( Point * NORMALIZER );

   price = cl;
   if ( month_high > hi ) price = hi;
   else if ( month_high < lo ) price = lo;
   data[1] = ( month_high - price ) / ( Point * NORMALIZER );

   price = cl;
   if ( month_close > hi ) price = hi;
   else if ( month_close < lo ) price = lo;
   data[2] = ( month_close - price ) / ( Point * NORMALIZER );
   
   price = cl;
   if ( month_pv > hi ) price = hi;
   else if ( month_pv < lo ) price = lo;
   data[3] = ( month_pv - price ) / ( Point * NORMALIZER );


   price = cl;
   if ( week_low > hi ) price = hi;
   else if ( week_low < lo ) price = lo;
   data[4] = ( week_low - price ) / ( Point * NORMALIZER );

   price = cl;
   if ( week_high > hi ) price = hi;
   else if ( week_high < lo ) price = lo;
   data[5] = ( week_high - price ) / ( Point * NORMALIZER );

   price = cl;
   if ( week_close > hi ) price = hi;
   else if ( week_close < lo ) price = lo;
   data[6] = ( week_close - price ) / ( Point * NORMALIZER );
   
   price = cl;
   if ( week_pv > hi ) price = hi;
   else if ( week_pv < lo ) price = lo;
   data[7] = ( week_pv - price ) / ( Point * NORMALIZER );

   
   price = cl;
   if ( day_low > hi ) price = hi;
   else if ( day_low < lo ) price = lo;
   data[8] = ( day_low - price ) / ( Point * NORMALIZER );
   
   price = cl;
   if ( day_high > hi ) price = hi;
   else if ( day_high < lo ) price = lo;
   data[9] = ( day_high - price ) / ( Point * NORMALIZER );
   
   price = cl;
   if ( day_close > hi ) price = hi;
   else if ( day_close < lo ) price = lo;
   data[10] = ( day_close - price ) / ( Point * NORMALIZER );
   
   price = cl; if ( day_pv > hi ) price = hi;  else if ( day_pv < lo ) price = lo;
   data[11] = ( day_pv - price ) / ( Point * NORMALIZER );
   
   price = cl; if ( day_r1 > hi ) price = hi;  else if ( day_r1 < lo ) price = lo;
   data[12] = ( day_r1 - price ) / ( Point * NORMALIZER );
   
   price = cl; if ( day_r2 > hi ) price = hi;  else if ( day_r2 < lo ) price = lo;
   data[13] = ( day_r2 - price ) / ( Point * NORMALIZER );
   
   price = cl; if ( day_r3 > hi ) price = hi;  else if ( day_r3 < lo ) price = lo;
   data[14] = ( day_r3 - price ) / ( Point * NORMALIZER );
   
   price = cl; if ( day_s1 > hi ) price = hi;  else if ( day_s1 < lo ) price = lo;
   data[15] = ( day_s1 - price ) / ( Point * NORMALIZER );
   
   price = cl; if ( day_s2 > hi ) price = hi;  else if ( day_s2 < lo ) price = lo;
   data[16] = ( day_s2 - price ) / ( Point * NORMALIZER );
   
   price = cl; if ( day_s3 > hi ) price = hi;  else if ( day_s3 < lo ) price = lo;
   data[17] = ( day_s3 - price ) / ( Point * NORMALIZER );
   
   
   price = cl; if ( fib_r1 > hi ) price = hi;  else if ( fib_r1 < lo ) price = lo;
   data[18] = ( fib_r1 - price ) / ( Point * NORMALIZER );
   
   price = cl; if ( fib_r2 > hi ) price = hi;  else if ( fib_r2 < lo ) price = lo;
   data[19] = ( fib_r2 - price ) / ( Point * NORMALIZER );
   
   price = cl; if ( fib_r3 > hi ) price = hi;  else if ( fib_r3 < lo ) price = lo;
   data[20] = ( fib_r3 - price ) / ( Point * NORMALIZER );
   
   price = cl; if ( fib_s1 > hi ) price = hi;  else if ( fib_s1 < lo ) price = lo;
   data[21] = ( fib_s1 - price ) / ( Point * NORMALIZER );
   
   price = cl; if ( fib_s2 > hi ) price = hi;  else if ( fib_s2 < lo ) price = lo;
   data[22] = ( fib_s2 - price ) / ( Point * NORMALIZER );
   
   price = cl; if ( fib_s3 > hi ) price = hi;  else if ( fib_s3 < lo ) price = lo;
   data[23] = ( fib_s3 - price ) / ( Point * NORMALIZER );


   price = cl; if ( day_mr1 > hi ) price = hi;  else if ( day_mr1 < lo ) price = lo;
   data[24] = ( day_mr1 - price ) / ( Point * NORMALIZER );
   
   price = cl; if ( day_mr2 > hi ) price = hi;  else if ( day_mr2 < lo ) price = lo;
   data[25] = ( day_mr2 - price ) / ( Point * NORMALIZER );
   
   price = cl; if ( day_mr3 > hi ) price = hi;  else if ( day_mr3 < lo ) price = lo;
   data[26] = ( day_mr3 - price ) / ( Point * NORMALIZER );
   
   price = cl; if ( day_ms1 > hi ) price = hi;  else if ( day_ms1 < lo ) price = lo;
   data[27] = ( day_ms1 - price ) / ( Point * NORMALIZER );
   
   price = cl; if ( day_ms2 > hi ) price = hi;  else if ( day_ms2 < lo ) price = lo;
   data[28] = ( day_ms2 - price ) / ( Point * NORMALIZER );
   
   price = cl; if ( day_ms3 > hi ) price = hi;  else if ( day_ms3 < lo ) price = lo;
   data[29] = ( day_ms3 - price ) / ( Point * NORMALIZER );
   for (int i = 0 ; i < 10 ; i++) {
      data[i+30] = iCCI(NULL,PERIOD_M15,14,PRICE_CLOSE,i) / 100 ;
   }

   for ( i = 0; i < 20; i++) {
      data[i+40] = (iClose(Symbol(), PERIOD_M15, i) - iClose(Symbol(), PERIOD_M15, i + 1)) / ( Point * NORMALIZER );
   }


/*
      for (int i = 0; i < 60; i++) {
         data[i] = (iClose(Symbol(), PERIOD_M15, i) - iClose(Symbol(), PERIOD_M15, i + 1)) / ( Point * NORMALIZER );
      }
*/

      // Use the PNN to classify the vector
      int class = PNNClassifyVector(data);
      
      //Comment("\n class = " , class ) ;
      
      // If PNN classifies the vector as a buying position
      if (class == 0) {

         // Open a new buying position
         OrderSend(Symbol(), OP_BUY, 0.1, Ask, 3, Ask - STOP_LOSS * Point, Ask + LIMIT * Point, NULL, 16384, 0, Green);
      }

      // If PNN classifies the vector as a selling position
      else if (class == 1) {

         // Open a new selling position
         OrderSend(Symbol(), OP_SELL, 0.1, Bid, 3, Bid + STOP_LOSS * Point, Bid - LIMIT * Point, NULL, 16384, 0, Red);
      }
   }

   return(0);
}