Currency_Strength_v1.0

//+------------------------------------------------------------------+
//|                                       Currency Strength v1.0.mq4 |
//|                                                    Author: Jay_P |
//|                                                      25-Jan-2017 |
//+------------------------------------------------------------------+


//--- input parameters
extern double TradingLots=0.01;
extern int  TakeProfit= 5; // Take Profit (in Pips)
extern bool TradeOnce=true; // Trade Once (per Day)
extern string prefix="";
extern string postfix="";
extern double diff_val=0.5; // Difference Between Two Currencies Percentage
extern int Magic=1; // Magic Number
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int start()
  {

/*
USDCHF, GBPUSD, EURUSD, USDJPY, USDCAD, NZDUSD, AUDUSD, AUDNZD, AUDCAD, AUDCHF, AUDJPY, CHFJPY, EURGBP, EURAUD,

EURCHF, EURJPY, EURNZD, EURCAD, GBPCHF, GBPAUD, GBPCAD, GBPJPY, CADJPY, NZDJPY, GBPNZD, CADCHF
*/

   double USDJPY = perch(prefix+"USDJPY"+postfix);
   double USDCAD = perch(prefix+"USDCAD"+postfix);
   double AUDUSD = perch(prefix+"AUDUSD"+postfix);
   double USDCHF = perch(prefix+"USDCHF"+postfix);
   double GBPUSD = perch(prefix+"GBPUSD"+postfix);
   double EURUSD = perch(prefix+"EURUSD"+postfix);
   double NZDUSD = perch(prefix+"NZDUSD"+postfix);
   double EURJPY = perch(prefix+"EURJPY"+postfix);
   double EURCAD = perch(prefix+"EURCAD"+postfix);
   double EURGBP = perch(prefix+"EURGBP"+postfix);
   double EURCHF = perch(prefix+"EURCHF"+postfix);
   double EURAUD = perch(prefix+"EURAUD"+postfix);
   double EURNZD = perch(prefix+"EURNZD"+postfix);
   double AUDNZD = perch(prefix+"AUDNZD"+postfix);
   double AUDCAD = perch(prefix+"AUDCAD"+postfix);
   double AUDCHF = perch(prefix+"AUDCHF"+postfix);
   double AUDJPY = perch(prefix+"AUDJPY"+postfix);
   double CHFJPY = perch(prefix+"CHFJPY"+postfix);
   double GBPCHF = perch(prefix+"GBPCHF"+postfix);
   double GBPAUD = perch(prefix+"GBPAUD"+postfix);
   double GBPCAD = perch(prefix+"GBPCAD"+postfix);
   double GBPJPY = perch(prefix+"GBPJPY"+postfix);
   double CADJPY = perch(prefix+"CADJPY"+postfix);
   double NZDJPY = perch(prefix+"NZDJPY"+postfix);
   double GBPNZD = perch(prefix+"GBPNZD"+postfix);
   double CADCHF = perch(prefix+"CADCHF"+postfix);


   double eur = (EURJPY+EURCAD+EURGBP+EURCHF+EURAUD+EURUSD+EURNZD)/7;
   double usd = (USDJPY+USDCAD-AUDUSD+USDCHF-GBPUSD-EURUSD-NZDUSD)/7;
   double jpy = (-1*(USDJPY+EURJPY+AUDJPY+CHFJPY+GBPJPY+CADJPY+NZDJPY))/7;
   double cad = (CADCHF+CADJPY-(GBPCAD+AUDCAD+EURCAD+USDCAD))/6;
   double aud = (AUDUSD+AUDNZD+AUDCAD+AUDCHF+AUDJPY-(EURAUD+GBPAUD))/7;
   double nzd = (NZDUSD+NZDJPY-(EURNZD+AUDNZD+GBPNZD))/5;
   double gbp = (GBPUSD-EURGBP+GBPCHF+GBPAUD+GBPCAD+GBPJPY+GBPNZD)/7;
   double chf = (CHFJPY-(USDCHF+EURCHF+AUDCHF+GBPCHF+CADCHF))/6;


   eur = NormalizeDouble(eur,2);
   usd = NormalizeDouble(usd,2);
   jpy = NormalizeDouble(jpy,2);
   cad = NormalizeDouble(cad,2);
   aud = NormalizeDouble(aud,2);
   nzd = NormalizeDouble(nzd,2);
   gbp = NormalizeDouble(gbp,2);
   chf = NormalizeDouble(chf,2);

   Comment("\n\n\n\n\n\n\n\n\n\n\nEUR: "+eur+"\nUSD: "+usd+"\nJPY: "+jpy+"\nCAD: "+cad+"\nAUD: "+aud+"\nNZD: "+nzd+"\nGBP: "+gbp+"\nCHF: "+chf);

   if(MathAbs(usd-jpy)>diff_val)
     {
      if((usd-jpy)>0)
        {
         Trade("Buy",prefix+"USDJPY"+postfix);
        }
      if((usd-jpy)<0)
        {
         Trade("Sell",prefix+"USDJPY"+postfix);
        }
     }

   if(MathAbs(usd-cad)>diff_val)
     {
      if((usd-cad)>0)
        {
         Trade("Buy",prefix+"USDCAD"+postfix);
        }
      if((usd-cad)<0)
        {
         Trade("Sell",prefix+"USDCAD"+postfix);
        }
     }

   if(MathAbs(aud-usd)>diff_val)
     {
      if((aud-usd)>0)
        {
         Trade("Buy",prefix+"AUDUSD"+postfix);
        }
      if((aud-usd)<0)
        {
         Trade("Sell",prefix+"AUDUSD"+postfix);
        }
     }

   if(MathAbs(usd-chf)>diff_val)
     {
      if((usd-chf)>0)
        {
         Trade("Buy",prefix+"USDCHF"+postfix);
        }
      if((usd-chf)<0)
        {
         Trade("Sell",prefix+"USDCHF"+postfix);
        }
     }

   if(MathAbs(gbp-usd)>diff_val)
     {
      if((gbp-usd)>0)
        {
         Trade("Buy",prefix+"GBPUSD"+postfix);
        }
      if((gbp-usd)<0)
        {
         Trade("Sell",prefix+"GBPUSD"+postfix);
        }
     }

   if(MathAbs(eur-usd)>diff_val)
     {
      if((eur-usd)>0)
        {
         Trade("Buy",prefix+"EURUSD"+postfix);
        }
      if((eur-usd)<0)
        {
         Trade("Sell",prefix+"EURUSD"+postfix);
        }
     }

   if(MathAbs(nzd-usd)>diff_val)
     {
      if((nzd-usd)>0)
        {
         Trade("Buy",prefix+"NZDUSD"+postfix);
        }
      if((nzd-usd)<0)
        {
         Trade("Sell",prefix+"NZDUSD"+postfix);
        }
     }

   if(MathAbs(eur-jpy)>diff_val)
     {
      if((eur-jpy)>0)
        {
         Trade("Buy",prefix+"EURJPY"+postfix);
        }
      if((eur-jpy)<0)
        {
         Trade("Sell",prefix+"EURJPY"+postfix);
        }
     }

   if(MathAbs(eur-cad)>diff_val)
     {
      if((eur-cad)>0)
        {
         Trade("Buy",prefix+"EURCAD"+postfix);
        }
      if((eur-cad)<0)
        {
         Trade("Sell",prefix+"EURCAD"+postfix);
        }
     }

   if(MathAbs(eur-gbp)>diff_val)
     {
      if((eur-gbp)>0)
        {
         Trade("Buy",prefix+"EURGBP"+postfix);
        }
      if((eur-gbp)<0)
        {
         Trade("Sell",prefix+"EURGBP"+postfix);
        }
     }

   if(MathAbs(eur-chf)>diff_val)
     {
      if((eur-chf)>0)
        {
         Trade("Buy",prefix+"EURCHF"+postfix);
        }
      if((eur-chf)<0)
        {
         Trade("Sell",prefix+"EURCHF"+postfix);
        }
     }

   if(MathAbs(eur-aud)>diff_val)
     {
      if((eur-aud)>0)
        {
         Trade("Buy",prefix+"EURAUD"+postfix);
        }
      if((eur-aud)<0)
        {
         Trade("Sell",prefix+"EURAUD"+postfix);
        }
     }

   if(MathAbs(eur-nzd)>diff_val)
     {
      if((eur-nzd)>0)
        {
         Trade("Buy",prefix+"EURNZD"+postfix);
        }
      if((eur-nzd)<0)
        {
         Trade("Sell",prefix+"EURNZD"+postfix);
        }
     }

   if(MathAbs(aud-nzd)>diff_val)
     {
      if((aud-nzd)>0)
        {
         Trade("Buy",prefix+"AUDNZD"+postfix);
        }
      if((aud-nzd)<0)
        {
         Trade("Sell",prefix+"AUDNZD"+postfix);
        }
     }

   if(MathAbs(aud-cad)>diff_val)
     {
      if((aud-cad)>0)
        {
         Trade("Buy",prefix+"AUDCAD"+postfix);
        }
      if((aud-cad)<0)
        {
         Trade("Sell",prefix+"AUDCAD"+postfix);
        }
     }

   if(MathAbs(aud-chf)>diff_val)
     {
      if((aud-chf)>0)
        {
         Trade("Buy",prefix+"AUDCHF"+postfix);
        }
      if((aud-chf)<0)
        {
         Trade("Sell",prefix+"AUDCHF"+postfix);
        }
     }

   if(MathAbs(aud-jpy)>diff_val)
     {
      if((aud-jpy)>0)
        {
         Trade("Buy",prefix+"AUDJPY"+postfix);
        }
      if((aud-jpy)<0)
        {
         Trade("Sell",prefix+"AUDJPY"+postfix);
        }
     }

   if(MathAbs(chf-jpy)>diff_val)
     {
      if((chf-jpy)>0)
        {
         Trade("Buy",prefix+"CHFJPY"+postfix);
        }
      if((chf-jpy)<0)
        {
         Trade("Sell",prefix+"CHFJPY"+postfix);
        }
     }

   if(MathAbs(gbp-chf)>diff_val)
     {
      if((gbp-chf)>0)
        {
         Trade("Buy",prefix+"GBPCHF"+postfix);
        }
      if((gbp-chf)<0)
        {
         Trade("Sell",prefix+"GBPCHF"+postfix);
        }
     }

   if(MathAbs(gbp-aud)>diff_val)
     {
      if((gbp-aud)>0)
        {
         Trade("Buy",prefix+"GBPAUD"+postfix);
        }
      if((gbp-aud)<0)
        {
         Trade("Sell",prefix+"GBPAUD"+postfix);
        }
     }

   if(MathAbs(gbp-cad)>diff_val)
     {
      if((gbp-cad)>0)
        {
         Trade("Buy",prefix+"GBPCAD"+postfix);
        }
      if((gbp-cad)<0)
        {
         Trade("Sell",prefix+"GBPCAD"+postfix);
        }
     }

   if(MathAbs(gbp-jpy)>diff_val)
     {
      if((gbp-jpy)>0)
        {
         Trade("Buy",prefix+"GBPJPY"+postfix);
        }
      if((gbp-jpy)<0)
        {
         Trade("Sell",prefix+"GBPJPY"+postfix);
        }
     }

   if(MathAbs(cad-jpy)>diff_val)
     {
      if((cad-jpy)>0)
        {
         Trade("Buy",prefix+"CADJPY"+postfix);
        }
      if((cad-jpy)<0)
        {
         Trade("Sell",prefix+"CADJPY"+postfix);
        }
     }

   if(MathAbs(nzd-jpy)>diff_val)
     {
      if((nzd-jpy)>0)
        {
         Trade("Buy",prefix+"NZDJPY"+postfix);
        }
      if((nzd-jpy)<0)
        {
         Trade("Sell",prefix+"NZDJPY"+postfix);
        }
     }

   if(MathAbs(gbp-nzd)>diff_val)
     {
      if((gbp-nzd)>0)
        {
         Trade("Buy",prefix+"GBPNZD"+postfix);
        }
      if((gbp-nzd)<0)
        {
         Trade("Sell",prefix+"GBPNZD"+postfix);
        }
     }

   if(MathAbs(cad-chf)>diff_val)
     {
      if((cad-chf)>0)
        {
         Trade("Buy",prefix+"CADCHF"+postfix);
        }
      if((cad-chf)<0)
        {
         Trade("Sell",prefix+"CADCHF"+postfix);
        }
     }
   return(0);
  }
//+------------------------------------------------------------------+
//|            CALCULATING PERCENTAGE Of SYMBOLS                                                      |
//+------------------------------------------------------------------+
double perch(string sym)
  {
   double op = iOpen(sym,PERIOD_D1,0);
   double cl = iClose(sym,PERIOD_D1,0);

   double per=(cl-op)/op*100;

   per=NormalizeDouble(per,2);
/* 
   if(op==0)
   {
      Alert(sym);
   }*/
   return(per);
  }
//+------------------------------------------------------------------+
//|               TRADE EXECUTION FUNCTION
//+------------------------------------------------------------------+
int Trade(string signal,string symbol)
  {
   int Magic2=Magic+1;
   int count,count2=0;
   for(int pos=0; pos<=OrdersTotal(); pos++)
     {
      if(OrderSelect(pos,SELECT_BY_POS)
         && OrderMagicNumber()==Magic       //When Magic number is correct      
         && OrderSymbol()==symbol) // Only When Its of Chart Symbol
        {              // and my pair.
         count++; // Count the number of Positions in Order List Of Chart Symbol
        } //if ended

      if(OrderSelect(pos,SELECT_BY_POS)
         && OrderMagicNumber()==Magic2
         && OrderSymbol()==symbol)
        {              // and my pair.
         count2++; // Count the number of Positions in Order List Of Chart Symbol
        } //if ended
     }//for ended

   double bid = MarketInfo(symbol,MODE_BID);
   double ask = MarketInfo(symbol,MODE_ASK);
   double point=MarketInfo(symbol,MODE_POINT);
   double digits=MarketInfo(symbol,MODE_DIGITS);

   double op = iOpen(symbol,PERIOD_D1,0);
   double cl = iClose(symbol,PERIOD_D1,0);

   int    Cur_Hour=Hour();             // Server time in hours
   double Cur_Min =Minute();           // Server time in minutes
   double Cur_time=Cur_Hour+(Cur_Min)/100; // Current time

   bool TradeTime=Cur_time>0.10 && Cur_time<23;

   int TodaySeconds=(Hour()*3600)+(Minute()*60)+Seconds();
   int YesterdayEnd=TimeCurrent()-TodaySeconds;
   int YesterdayStart=YesterdayEnd-86400;

   if(TradeOnce==true)
     {
      for(int h=OrdersHistoryTotal()-1;h>=0;h--) // Trade Once per Pair
        {
         if(OrderSelect(h,SELECT_BY_POS,MODE_HISTORY)==true) // select next
           {
            if(OrderCloseTime()>YesterdayEnd && OrderSymbol()==symbol && OrderMagicNumber()==Magic)
              {
               signal="NoTrade";
              }

            if(OrderCloseTime()>YesterdayEnd && OrderSymbol()==symbol && OrderMagicNumber()==Magic2)
              {
               signal="NoTrade";
              }
           }
        }
     }

   if(!count && TradeTime)
     {

      if(signal=="Buy")
        {
         OrderSend(symbol,OP_BUY,TradingLots,ask,0,0,0,"Buy",Magic,0,Green);
        }
     }

   if(!count2 && TradeTime)
     {
      if(signal=="Sell")
        {
         OrderSend(symbol,OP_SELL,TradingLots,bid,0,0,0,"Sell",Magic2,0,Red);
        }

     }// If Ended

   if(OrdersTotal()>0)
     {
      for(int i=1; i<=OrdersTotal(); i++) // Cycle searching in orders
        {
         if(OrderSelect(i-1,SELECT_BY_POS)==true && OrderSymbol()==symbol)
           {
            double tpb=NormalizeDouble(OrderOpenPrice()+TakeProfit*point*10,digits);
            double tps=NormalizeDouble(OrderOpenPrice()-TakeProfit*point*10,digits);

            if(OrderMagicNumber()==Magic && OrderType()==OP_BUY && OrderTakeProfit()==0 && OrderSymbol()==symbol)
              {
               OrderModify(OrderTicket(),0,0,tpb,0,CLR_NONE);
               Alert(symbol+" TP-Buy: "+tpb);
              }

            if(OrderMagicNumber()==Magic2 && OrderType()==OP_SELL && OrderTakeProfit()==0 && OrderSymbol()==symbol)
              {
               OrderModify(OrderTicket(),0,0,tps,0,CLR_NONE);
               Alert(symbol+" TP-Sell: "+tps);
              }
           }//Nested-if Ended
        }//for loop ended
     }//if Ended

   return(0);

  }
//+------------------------------------------------------------------+