synT

ÿþ//+------------------------------------------------------------------+

//|                                                         synT.mq5 |

//|                            Copyright 2019, maxim.bagno@gmail.com |

//|                                             https://www.mql5.com |

//+------------------------------------------------------------------+

#property copyright "Copyright 2019, maxim.bagno@gmail.com"

#property link      "https://www.mql5.com"

#property version   "1.00"

#property indicator_chart_window

#property description "synT"

#property indicator_buffers 5   

#property indicator_plots   1

//--- plot synt EURUSD

#property indicator_label1  "Open;High;Low;Close"

#property indicator_type1   DRAW_COLOR_CANDLES

#property indicator_color1  clrGreen,clrRed,clrGray

#property indicator_style1  STYLE_SOLID

#property indicator_width1  1

//--- input parameters

input double   synRatio=1.059;

input string   synNameIndexA="EUR";

input double   synRatioIndexA=34.38805726;

input string   synBasketIndexA="EURUSD;EURGBP;EURJPY;EURCHF;EURSEK";

input string   synPartIndexA="31.55;30.56;18.91;11.13;7.85";

input string   synNameIndexB="USD";

input double   synRatioIndexB=50.14348112;

input string   synBasketIndexB="EURUSD;USDJPY;GBPUSD;USDCAD;USDSEK;USDCHF";

input string   synPartIndexB="57.6;13.6;11.9;9.1;4.2;3.6";

//--- input parameters

input bool InpReverse=false;   // Reverse

//--- indicator buffers

double         BufferA_O[];

double         BufferA_H[];

double         BufferA_L[];

double         BufferA_C[];

double         BufferB_O[];

double         BufferB_H[];

double         BufferB_L[];

double         BufferB_C[];

double         BufferSYNT_O[];

double         BufferSYNT_H[];

double         BufferSYNT_L[];

double         BufferSYNT_C[];

double         BufferColors[];

//--- global variables

int hindeXA,hindeXB;

//+------------------------------------------------------------------+

//| Custom indicator initialization function                         |

//+------------------------------------------------------------------+

int OnInit()

  {

//--- indicator buffers mapping

   SetIndexBuffer(0,BufferSYNT_O,INDICATOR_DATA);

   SetIndexBuffer(1,BufferSYNT_H,INDICATOR_DATA);

   SetIndexBuffer(2,BufferSYNT_L,INDICATOR_DATA);

   SetIndexBuffer(3,BufferSYNT_C,INDICATOR_DATA);

   SetIndexBuffer(4,BufferColors,INDICATOR_COLOR_INDEX);

   SetIndexBuffer(5,BufferA_O,INDICATOR_CALCULATIONS);

   SetIndexBuffer(6,BufferA_H,INDICATOR_CALCULATIONS);

   SetIndexBuffer(7,BufferA_L,INDICATOR_CALCULATIONS);

   SetIndexBuffer(8,BufferA_C,INDICATOR_CALCULATIONS);

   SetIndexBuffer(9,BufferB_O,INDICATOR_CALCULATIONS);

   SetIndexBuffer(10,BufferB_H,INDICATOR_CALCULATIONS);

   SetIndexBuffer(11,BufferB_L,INDICATOR_CALCULATIONS);

   SetIndexBuffer(12,BufferB_C,INDICATOR_CALCULATIONS);     

   MqlParam params[];

   ArrayResize(params,5);

//--- set ma_period 

   params[0].type         = TYPE_STRING;

   params[0].string_value = "indeX";

   params[1].type         = TYPE_STRING;

   params[1].string_value = synNameIndexA;

   params[2].type         = TYPE_DOUBLE;

   params[2].double_value = synRatioIndexA;

   params[3].type         = TYPE_STRING;

   params[3].string_value = synBasketIndexA;

   params[4].type         = TYPE_STRING;

   params[4].string_value = synPartIndexA;

   ResetLastError();

   hindeXA=IndicatorCreate(NULL,0,IND_CUSTOM,5,params);



//--- 5A;8 =5 C40;>AL A>740BL EM=4; 

   if(hindeXA==INVALID_HANDLE)

     {

      //--- A>>1I8< > =5C40G5 8 2K2545< =><5@ >H81:8 

      PrintFormat("5 C40;>AL A>740BL 8=48:0B>@ indeX %s, :>4 >H81:8 %d",synNameIndexA,GetLastError());

      //--- @01>B0 8=48:0B>@0 7025@H05BAO 4>A@>G=> 

      return(INIT_FAILED);

     }

     

   params[0].type         = TYPE_STRING;

   params[0].string_value = "indeX";

   params[1].type         = TYPE_STRING;

   params[1].string_value = synNameIndexB;

   params[2].type         = TYPE_DOUBLE;

   params[2].double_value = synRatioIndexB;

   params[3].type         = TYPE_STRING;

   params[3].string_value = synBasketIndexB;

   params[4].type         = TYPE_STRING;

   params[4].string_value = synPartIndexB;

   ResetLastError();

   hindeXB=IndicatorCreate(NULL,0,IND_CUSTOM,5,params);



//--- 5A;8 =5 C40;>AL A>740BL EM=4; 

   if(hindeXB==INVALID_HANDLE)

     {

      //--- A>>1I8< > =5C40G5 8 2K2545< =><5@ >H81:8 

      PrintFormat("5 C40;>AL A>740BL 8=48:0B>@ indeX %s, :>4 >H81:8 %d",synNameIndexB,GetLastError());

      //--- @01>B0 8=48:0B>@0 7025@H05BAO 4>A@>G=> 

      return(INIT_FAILED);

     }

//--- indicator buffers mapping

//--- setting indicator parameters

   IndicatorSetString(INDICATOR_SHORTNAME,"synT "+synNameIndexA+synNameIndexB);

   IndicatorSetInteger(INDICATOR_DIGITS,Digits());

//--- setting buffer arrays as timeseries

   ArraySetAsSeries(BufferSYNT_O,true);

   ArraySetAsSeries(BufferSYNT_H,true);

   ArraySetAsSeries(BufferSYNT_L,true);

   ArraySetAsSeries(BufferSYNT_C,true);

   ArraySetAsSeries(BufferColors,true);

   ArraySetAsSeries(BufferA_O,true);

   ArraySetAsSeries(BufferA_H,true);

   ArraySetAsSeries(BufferA_L,true);

   ArraySetAsSeries(BufferA_C,true);

   ArraySetAsSeries(BufferB_O,true);

   ArraySetAsSeries(BufferB_H,true);

   ArraySetAsSeries(BufferB_L,true);

   ArraySetAsSeries(BufferB_C,true);      

//---

   return(INIT_SUCCEEDED);

  }

//+------------------------------------------------------------------+

//| 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[])

  {

//--- @>25@:0 =0 <8=8<0;L=>5 :>;85AB2> 10@>2 4;O @0AGQB0

   if(rates_total<4) return 0;

//--- #AB0=>2:0 <0AA82>2 1CD5@>2 :0: B09<A5@89

   ArraySetAsSeries(time,true);

//--- @>25@:0 8 @0AGQB :>;8G5AB20 ?@>AG8BK205<KE 10@>2

   int limit=rates_total-prev_calculated;

   if(limit>1)

     {

      limit=rates_total-1;

      ArrayInitialize(BufferSYNT_O,EMPTY_VALUE);

      ArrayInitialize(BufferSYNT_H,EMPTY_VALUE);

      ArrayInitialize(BufferSYNT_L,EMPTY_VALUE);

      ArrayInitialize(BufferSYNT_C,EMPTY_VALUE);

      ArrayInitialize(BufferA_O,0);

      ArrayInitialize(BufferA_H,0);

      ArrayInitialize(BufferA_L,0);

      ArrayInitialize(BufferA_C,0);

      ArrayInitialize(BufferB_O,0);

      ArrayInitialize(BufferB_H,0);

      ArrayInitialize(BufferB_L,0);

      ArrayInitialize(BufferB_C,0);        

     }



//--- >43>B>2:0 40==KE

   int min_bars=rates_total;

   

   int bars=BarsCalculated(hindeXA);

   if(bars<min_bars) min_bars=bars;

   int copied=0,count=(limit==0 ? 1 : bars);

   copied=CopyBuffer(hindeXA,0,0,count,BufferA_O);

   if(copied<=0) return 0;

   copied=CopyBuffer(hindeXA,1,0,count,BufferA_H);

   if(copied<=0) return 0;

   copied=CopyBuffer(hindeXA,2,0,count,BufferA_L);

   if(copied<=0) return 0;

   copied=CopyBuffer(hindeXA,3,0,count,BufferA_C);

   if(copied<=0) return 0;



   bars=BarsCalculated(hindeXB);

   if(bars<min_bars) min_bars=bars;

   copied=0; count=(limit==0 ? 1 : bars);

   copied=CopyBuffer(hindeXB,0,0,count,BufferB_O);

   if(copied<=0) return 0;

   copied=CopyBuffer(hindeXB,1,0,count,BufferB_H);

   if(copied<=0) return 0;

   copied=CopyBuffer(hindeXB,2,0,count,BufferB_L);

   if(copied<=0) return 0;

   copied=CopyBuffer(hindeXB,3,0,count,BufferB_C);

   if(copied<=0) return 0;   



   int limit1=(limit>1 ? min_bars-1 : 0);

//---  0AGQB 8=48:0B>@0

   for(int i=limit1; i>=0 && !IsStopped(); i--)

     {

      double xO=synRatio;

      double xH=synRatio;

      double xL=synRatio;

      double xC=synRatio;

      

      xO*=BufferA_O[i]/BufferB_O[i];  

      xH*=BufferA_H[i]/BufferB_H[i];

      xL*=BufferA_L[i]/BufferB_L[i];

      xC*=BufferA_C[i]/BufferB_C[i];

        

      BufferSYNT_O[i]=(InpReverse ? 1/xO : xO);

      BufferSYNT_H[i]=(InpReverse ? 1/xH : xH);

      BufferSYNT_L[i]=(InpReverse ? 1/xL : xL);

      BufferSYNT_C[i]=(InpReverse ? 1/xC : xC);

      //---

      BufferColors[i]=(BufferSYNT_O[i]<BufferSYNT_C[i]? 0 : BufferSYNT_O[i]>BufferSYNT_C[i]? 1 : 2);

     }



//--- return value of prev_calculated for next call

   return(rates_total);

  }

//+------------------------------------------------------------------+ 

//| Indicator deinitialization function                              | 

//+------------------------------------------------------------------+ 

void OnDeinit(const int reason) 

  { 

//--- ?>G8AB8< 3@0D8: ?@8 C40;5=88 8=48:0B>@0 

   Comment(""); 

   IndicatorRelease(hindeXA);

   IndicatorRelease(hindeXB);

  }

//+------------------------------------------------------------------+