www.pudn.com > RedbinaryoptionsDL.zip > FXForecaster_BO.mq4, change:2010-12-08,size:22348b


//+------------------------------------------------------------------+ 
//|                                          JoeChalhoub_FXForecasterV1.mq4 | 
//|                                                     www.rpchost.com | 
//|                                               webmaster@rpchost.com | 
//+------------------------------------------------------------------+ 
#property copyright "Copyright ゥ 2009, Rpchost.com" 
#property link      "webmaster@rpchost.com" 
//---- 
#property indicator_separate_window 
#property indicator_buffers 15 
#property indicator_color1 Blue 
#property indicator_color2 FireBrick 
#property indicator_color3 Blue 
#property indicator_color4 Violet 
 
//---- input parameters 
extern string    separator1 = "*** OSMA Settings ***"; 
extern int       fastEMA = 12; 
extern int       slowEMA = 26; 
extern int       signal = 9; 
extern string    separator2 = "*** Indicator Settings ***"; 
extern bool      drawDivergenceLines = true; 
extern bool      displayAlert = true; 
 
extern string    Symbol1       = ""; 
extern string    Symbol2       = ""; 
//---- buffers 
double Value=0,Value1=0,Value2=0,Fish=0,Fish1=0,Fish2=0; 
int buy=0,sell=0; 
double buffer1[1000]; 
double buffer2[1000]; 
double buffer3[1000]; 
double MA1buffer[1000]; 
double MA2buffer[1000]; 
//---- 
extern int period=10; 
extern int price=0; // 0 or other = (H+L)/2 
 
extern bool Mode_Fast= False; 
extern bool Signals= False; 
extern int MA1period=9, MA2period=45; 
extern string TypeHelp="SMA- 0, EMA - 1, SMMA - 2, LWMA- 3"; 
extern string TypeHelp2="John Hyden settings TypeMA1=0, TypeMA2=3"; 
extern int TypeMA1=0; 
extern int TypeMA2=3; 
string str1; 
int SELLMA[]; 
int BUYMA[]; 
double upOsMA[]; 
double downOsMA[]; 
double bullishDivergence[]; 
double bearishDivergence[]; 
double bullishDiverg[]; 
double bearishDiverg[]; 
bool isBuy, isSell; 
bool isBuySet, isSellSet; 
double OsMA[]; 
double upMA[]; 
double downMA[]; 
double bullishDivergenceMA[]; 
double bearishDivergenceMA[]; 
double bullishDivergenceMADeviation[1000]; 
double bearishDivergenceMADeviation[1000]; 
 
double LPeak, LTrough; 
double LPeak2, LTrough2; 
 
double MA[]; 
double MA2[1000]; 
double MA1H1_1, MA1H1_2, MA1H1_3; 
double SLShort,SLLong, strTargetLong,strTargetShort,C0,C1,C2; 
string Target,ask,SL,bid , strSell,strBuy; 
string strDirection[]; 
    
static string isBuyExist = "false" ; 
static string isSellExist ="false" ; 
int BarSell = -1; 
int BarBuy = -1; 
string str; 
//---- 
 
static datetime lastAlertTime; 
//+------------------------------------------------------------------+ 
//| Custom indicator initialization function                         | 
//+------------------------------------------------------------------+ 
int init() 
  { 
   
SetIndexStyle(0,DRAW_NONE); 
SetIndexBuffer(0,buffer1); 
SetIndexStyle(1,DRAW_NONE); 
SetIndexBuffer(1,buffer2); 
SetIndexStyle(2,DRAW_NONE); 
SetIndexLabel(2,"line"); 
SetIndexBuffer(2,buffer3); 
SetIndexStyle(3, DRAW_HISTOGRAM, STYLE_SOLID, 2); 
SetIndexLabel(3,"MA1 "+MA1period); 
SetIndexStyle(4, DRAW_HISTOGRAM, STYLE_SOLID, 2); 
SetIndexLabel(4,"MA2 "+MA2period); 
SetIndexBuffer(3,MA1buffer); 
SetIndexBuffer(4,MA2buffer); 
 
   SetIndexStyle(5, DRAW_NONE); 
   SetIndexStyle(6, DRAW_NONE); 
   SetIndexStyle(7, DRAW_NONE); 
   SetIndexStyle(8, DRAW_NONE); 
   SetIndexStyle(9, DRAW_NONE); 
   SetIndexStyle(10, DRAW_NONE); 
   SetIndexBuffer(6, downMA); 
   SetIndexBuffer(7, MA); 
   SetIndexBuffer(8, OsMA); 
   SetIndexBuffer(9, SELLMA); 
   SetIndexBuffer(10, BUYMA); 
   ObjectCreate("Symbol1",OBJ_LABEL,0,0,0,0,0); 
   ObjectCreate("Symbol2",OBJ_LABEL,0,0,0,0,0); 
//---- 
   return(0); 
  } 
//+------------------------------------------------------------------+ 
//| Custom indicator deinitialization function                       | 
//+------------------------------------------------------------------+ 
int deinit() 
  { 
  for(int i = ObjectsTotal() - 1; i >= 0; i--) 
     { 
       string label = ObjectName(i); 
       if(StringSubstr(label, 0, 14) != "DivergenceLine") 
           continue; 
       ObjectDelete(label);    
     } 
     ObjectDelete("Symbol1"); 
      ObjectDelete("Symbol2"); 
   return(0); 
  } 
//+------------------------------------------------------------------+ 
//| Custom indicator iteration function                              | 
//+------------------------------------------------------------------+ 
int start() 
  { 
 
    string Symbol_1 = "  "; 
    string Symbol_2 =  "  "; 
      
     ObjectSetText("Symbol1",Symbol_1,"","Arial Black",Lime); 
     ObjectSet("Symbol1",OBJPROP_XDISTANCE,3);      
     ObjectSet("Symbol1",OBJPROP_YDISTANCE,30); 
     ObjectSet("Symbol1",OBJPROP_COLOR,Red); 
     ObjectSet("Symbol1",OBJPROP_CORNER,"111"); 
      ObjectSetText("Symbol2",Symbol_2,"6","Arial Black",Lime); 
     ObjectSet("Symbol2",OBJPROP_XDISTANCE,3);      
     ObjectSet("Symbol2",OBJPROP_YDISTANCE,50); 
     ObjectSet("Symbol2",OBJPROP_COLOR,Red); 
     ObjectSet("Symbol2",OBJPROP_CORNER,"111"); 
      
   helper(); 
   int countedBars = IndicatorCounted(); 
   if(countedBars < 0) 
       countedBars = 0; 
    
   CalculateIndicator(countedBars); 
    
   return(0); 
  } 
//+------------------------------------------------------------------+ 
//|                                                                  | 
//+------------------------------------------------------------------+ 
void CalculateIndicator(int countedBars) 
  { 
   for(int i = Bars - countedBars; i >= 1; i--) 
     { 
      CalculateMA(i); 
      CatchBullishDivergenceMA(i + 2); 
      CatchBearishDivergenceMA(i + 2); 
      CalculateOsMA(i); 
      CatchBullishDivergence(i + 2); 
      CatchBearishDivergence(i + 2); 
     }      
     for( i = Bars - countedBars; i >= 1; i--) 
     { 
      setSignals(i); 
     } 
  } 
//+------------------------------------------------------------------+ 
//|                                                                  | 
//+------------------------------------------------------------------+ 
 
int helper() 
{ 
int counted_bars=IndicatorCounted(); 
int i; 
int barras; 
double _price; 
double tmp; 
double MinL=0; 
double MaxH=0; 
double Threshold=1.2; 
//---- 
if(counted_bars>0) counted_bars--; 
//barras = Bars;? 
barras=Bars-counted_bars; 
if (Mode_Fast) 
barras=100; 
i=0; 
while(i<barras) 
{ 
MaxH=High[Highest(NULL,0,MODE_HIGH,period,i)]; 
MinL=Low[Lowest(NULL,0,MODE_LOW,period,i)]; 
//---- 
switch(price) 
{ 
case 1: _price=Open[i]; break; 
case 2: _price=Close[i]; break; 
case 3: _price=High[i]; break; 
case 4: _price=Low[i]; break; 
case 5: _price=(High[i]+Low[i]+Close[i])/3; break; 
case 6: _price=(Open[i]+High[i]+Low[i]+Close[i])/4; break; 
case 7: _price=(Open[i]+Close[i])/2; break; 
default: _price=(High[i]+Low[i])/2; break; 
} 
Value=0.33*2*((_price-MinL)/(MaxH-MinL)-0.5) + 0.67*Value1; 
Value=MathMin(MathMax(Value,-0.999),0.999); 
Fish=0.5*MathLog((1+Value)/(1-Value))+0.5*Fish1; 
buffer1[i]= 0; 
buffer2[i]= 0; 
//---- 
if((Fish<0) && (Fish1>0)) 
{ 
if (Signals) 
{ 
ObjectCreate("EXIT: "+DoubleToStr(i,0),OBJ_TEXT,0,Time[i],_price); 
ObjectSetText("EXIT: "+DoubleToStr(i,0),"EXIT AT "+DoubleToStr(_price,4),7,"Arial",White); 
} 
buy=0; 
} 
if ((Fish>0) && (Fish1<0)) 
{ 
if (Signals) 
{ 
ObjectCreate("EXIT: "+DoubleToStr(i,0),OBJ_TEXT,0,Time[i],_price); 
ObjectSetText("EXIT: "+DoubleToStr(i,0),"EXIT AT "+DoubleToStr(_price,4),7,"Arial",White); 
} 
sell=0; 
} 
if (Fish>=0) 
{ 
buffer1[i]=Fish; 
buffer3[i]= Fish; 
} 
else 
{ 
buffer2[i]=Fish; 
buffer3[i]= Fish; 
} 
tmp=i; 
if ((Fish<-Threshold) && 
(Fish>Fish1) && 
(Fish1<=Fish2)) 
{ 
sell=1; 
} 
if ((Fish>Threshold) && 
(Fish<Fish1) && 
(Fish1>=Fish2)) 
{ 
 
buy=1; 
} 
Value1=Value; 
Fish2=Fish1; 
Fish1=Fish; 
i++; 
} 
for(i=0; i<barras; i++) 
MA1buffer[i]=iMAOnArray(buffer3,Bars,MA1period,0,TypeMA1,i); 
for(i=0; i<barras; i++) 
MA2buffer[i]=iMAOnArray(MA1buffer,Bars,MA2period,0,TypeMA2,i); 
//---- 
 
 
return(0); 
} 
 
void CalculateOsMA(int i) 
  { 
   
   OsMA[i] = buffer3[i]; 
 
//---- 
   if(OsMA[i] > 0) 
     { 
       upOsMA[i] = OsMA[i]; 
       downOsMA[i] = 0; 
     } 
   else  
       if(OsMA[i] < 0) 
         { 
           downOsMA[i] = OsMA[i]; 
           upOsMA[i] = 0;    
         } 
       else 
         { 
           upOsMA[i] = 0; 
           downOsMA[i] = 0;    
         }      
  } 
  void CalculateMA(int i) 
  { 
    MA[i] = MA1buffer[i]; 
    MA2[i] = MA2buffer[i]; 
//---- 
   if(MA[i] > 0) 
     { 
       upMA[i] = MA2[i]; 
       downMA[i] = 0; 
     } 
   else  
       if(MA[i] < 0) 
         { 
           downMA[i] =MA2[i]; 
           upMA[i] = 0;   
         } 
       else 
         { 
           downMA[i] = 0; 
           upMA[i] = 0;   
         }          
  } 
//+------------------------------------------------------------------+ 
//|                                                                  | 
//+------------------------------------------------------------------+ 
void CatchBullishDivergence(int shift) 
  { 
   if(IsIndicatorTrough(shift) == false) 
       return; 
   int currentTrough = shift; 
   int lastTrough = GetIndicatorLastPeakMA(shift); 
      bullishDivergence[currentTrough] = OsMA[currentTrough]; 
  } 
//+------------------------------------------------------------------+ 
//|                                                                  | 
//+------------------------------------------------------------------+ 
void CatchBearishDivergence(int shift) 
  { 
   if(IsIndicatorPeak(shift) == false) 
       return; 
   int currentPeak = shift; 
   int lastPeak = GetIndicatorLastTroughMA(shift); 
       bearishDivergence[currentPeak] = OsMA[currentPeak]; 
  } 
//+------------------------------------------------------------------+ 
//|                                                                  | 
//+------------------------------------------------------------------+ 
bool IsIndicatorPeak(int shift) 
  { 
   if(OsMA[shift] > 0 && OsMA[shift] > OsMA[shift+1] && OsMA[shift] > OsMA[shift-1]) 
     { 
       for(int i = shift + 1; i < Bars; i++) 
         { 
           if(OsMA[i] < 0) 
              return(true); 
           if(OsMA[i] > OsMA[shift]) 
              break;             
         } 
     }    
   return(false); 
  } 
//+------------------------------------------------------------------+ 
//|                                                                  | 
//+------------------------------------------------------------------+ 
bool IsIndicatorTrough(int shift) 
  { 
   if(OsMA[shift] < 0 && OsMA[shift] < OsMA[shift+1] && OsMA[shift] < OsMA[shift-1]) 
     { 
       for(int i = shift + 1; i < Bars; i++) 
         { 
           if(OsMA[i] > 0) 
               return(true); 
           if(OsMA[i] < OsMA[shift]) 
               break;             
         } 
     }    
   return(false); 
  } 
//+------------------------------------------------------------------+ 
//|                                                                  | 
//+------------------------------------------------------------------+ 
int GetIndicatorLastPeak(int shift) 
  { 
    for(int i = shift + 2; i < Bars; i++) 
      { 
        if(OsMA[i] >= OsMA[i+1] && OsMA[i] > OsMA[i+1] && 
           OsMA[i] >= OsMA[i-1] && OsMA[i] > OsMA[i-1]) 
            return(i); 
      } 
    return(-1); 
  } 
//+------------------------------------------------------------------+ 
//|                                                                  | 
//+------------------------------------------------------------------+ 
int GetIndicatorLastTrough(int shift) 
  {   
    for(int i = shift + 2; i < Bars; i++) 
      { 
        if(OsMA[i] <= OsMA[i+1] && OsMA[i] < OsMA[i+1] && 
           OsMA[i] <= OsMA[i-1] && OsMA[i] < OsMA[i-1]) 
            return(i); 
      } 
    return(-1); 
  } 
//+------------------------------------------------------------------+ 
//|                                                                  | 
//+------------------------------------------------------------------+ 
void DrawPriceTrendLine(datetime x1, datetime x2, double y1,  
                        double y2, color lineColor, double style) 
  { 
   string label = "DivergenceLine2.1# " + DoubleToStr(x1, 0); 
  //ObjectDelete(label); 
   ObjectCreate(label, OBJ_ARROW, 0, x2, y1, x1, y2, 0, 0); 
   ObjectSet(label,OBJPROP_COLOR,lineColor); 
   ObjectSet(label,OBJPROP_SCALE,500); 
   ObjectSet(label,OBJPROP_RAY, true); 
   ObjectSet(label,OBJPROP_WIDTH,2); 
   if(lineColor == Violet) 
      ObjectSet(label,OBJPROP_ARROWCODE,234); 
   if(lineColor == Blue) 
      ObjectSet(label,OBJPROP_ARROWCODE,233); 
  } 
  
//+------------------------------------------------------------------+ 
//|                                                                  | 
//+------------------------------------------------------------------+ 
void DrawIndicatorTrendLine(datetime x1, datetime x2, double y1,  
                            double y2, color lineColor, double style) 
  { 
   int indicatorWindow = WindowFind("TestSignalsM15_V1_MQL4");/*(" + fastEMA +  
                                    "," + slowEMA + "," + signal + ")"); 
                                    Alert("indicatorWindow = ",indicatorWindow);*/ 
   if(indicatorWindow < 0 ) 
       return; 
   string label = "DivergenceLine2.1$# " + DoubleToStr(x1, 0); 
   
   ObjectDelete(label); 
  } 
//+------------------------------------------------------------------+ 
//Return DrawLine Indicator value 
double GetDrawIndicatorValue(int y1,int y2,double z1, double z2) 
{ 
int zz1,zz2; 
int val =  (y1 - y2) + 1; 
zz2 = MathAbs(z2*10000); 
zz1 = MathAbs(z1*10000); 
int z =  zz1 - zz2 ; 
 
return (MathAbs(z / val)); 
} 
double GetDrawIndicatorValueLine(int shiftDev, int lastMA, int Deviation) 
{ 
double z =  MA[lastMA]* 10000; 
double val =  ( z + (shiftDev * Deviation))/ 10000  ; 
return (val); 
} 
 
void setSignals(int shift) 
{ 
if (shift <= 1000) 
{ 
int lastPeakMA = GetIndicatorLastPeakMA(shift)-1; 
int lastTroughMA = GetIndicatorLastTroughMA(shift)-1; 
int lastPeakMAPOS = GetIndicatorLastPeakMAPOS(shift)-1; 
int lastTroughMAPOS = GetIndicatorLastTroughMAPOS(shift)-1; 
int lastPeakMA2 = GetIndicatorLastPeakMA2(shift)-1; 
int lastTroughMA2 = GetIndicatorLastTroughMA2(shift)-1; 
int lastPeakMA2POS = GetIndicatorLastPeakMA2POS(shift)-1; 
int lastTroughMA2POS = GetIndicatorLastTroughMA2POS(shift)-1; 
} 
} 
 
//MA 
//+------------------------------------------------------------------+ 
//|                                                                  | 
//+------------------------------------------------------------------+ 
void CatchBullishDivergenceMA(int shift) 
  { 
   if(IsIndicatorTroughMA(shift) == false) 
       return; 
   int currentTrough = shift; 
   int lastTrough = GetIndicatorLastTrough(shift); 
      bullishDivergenceMA[currentTrough-1] = MA[currentTrough]; 
            if(lastTrough > currentTrough-1)                              
            {        
               DrawIndicatorTrendLine(Time[lastTrough],Time[currentTrough-1],OsMA[lastTrough], MA[currentTrough-1], Blue, STYLE_SOLID); 
               bullishDivergenceMADeviation[currentTrough-1] = GetDrawIndicatorValue(lastTrough, currentTrough,OsMA[lastTrough],MA[currentTrough-1]); 
             } 
  } 
//+------------------------------------------------------------------+ 
//|                                                                  | 
//+------------------------------------------------------------------+ 
void CatchBearishDivergenceMA(int shift) 
  { 
   if(IsIndicatorPeakMA(shift) == false) 
       return; 
   int currentPeak = shift; 
   int lastPeak = GetIndicatorLastPeak(shift); 
   bearishDivergenceMA[currentPeak-1] = MA[currentPeak]; 
            if(lastPeak > currentPeak-1) 
           { 
           DrawIndicatorTrendLine(Time[lastPeak],Time[currentPeak-1], OsMA[lastPeak],MA[currentPeak-1], Violet, STYLE_SOLID); 
           bearishDivergenceMADeviation[currentPeak-1] = GetDrawIndicatorValue(lastPeak, currentPeak,OsMA[lastPeak],MA[currentPeak-1]);         
           } 
   } 
//+------------------------------------------------------------------+ 
//|                                                                  | 
//+------------------------------------------------------------------+ 
bool IsIndicatorPeakMA(int shift) 
  { 
   if(MA[shift] > 0 && MA[shift] > MA[shift+1] && MA[shift] > MA[shift-1]) 
     { 
       for(int i = shift + 1; i < Bars; i++) 
         { 
           if(MA[i] < 0) 
              return(true); 
           if(MA[i] > MA[shift]) 
              break;             
         } 
     }    
   return(false); 
  } 
   
//+------------------------------------------------------------------+ 
//|                                                                  | 
//+------------------------------------------------------------------+ 
bool IsIndicatorTroughMA(int shift) 
  { 
   if(MA[shift] < 0 && MA[shift] < MA[shift+1] && MA[shift] < MA[shift-1]) 
     { 
       for(int i = shift + 1; i < Bars; i++) 
         { 
           if(MA[i] > 0) 
               return(true); 
           if(MA[i] < MA[shift]) 
               break;             
         } 
     }    
   return(false); 
  } 
   
int GetIndicatorLastMultiplePeakMA(int shift) 
  {  
    int Res = 0; 
      for(int i = shift + 2; MA[i] > 0; i++) 
      { 
        if(MA[i+1] > MA[i]) 
        { 
         if(Res == 0) 
            Res = i+1;   
         if(Res != 0 && MA[i+1] > MA[Res]) 
            Res = i+1; 
        }     
      } 
      return(Res); 
  } 
  int GetIndicatorLastMultTroughMA(int shift) 
  {  
    int Res = 0; 
      for(int i = shift + 2; MA[i] < 0; i++) 
      { 
        if(MA[i+1] < MA[i]) 
        { 
         if(Res == 0) 
            Res = i+1;   
         if(Res != 0 && MA[i+1] < MA[Res]) 
            Res = i+1; 
        }     
      } 
      return(Res); 
  } 
   
  int GetIndicatorLastMultiplePeakMA2(int shift) 
  {  
    int Res = 0; 
      for(int i = shift + 2; MA2[i] > 0; i++) 
      { 
        if(MA2[i+1] > MA2[i]) 
        { 
         if(Res == 0) 
            Res = i+1;   
         if(Res != 0 && MA2[i+1] > MA2[Res]) 
            Res = i+1; 
        }     
      } 
      return(Res); 
  } 
  int GetIndicatorLastMultTroughMA2(int shift) 
  {  
    int Res = 0; 
      for(int i = shift + 2; MA2[i] < 0; i++) 
      { 
        if(MA2[i+1] < MA2[i]) 
        { 
         if(Res == 0) 
            Res = i+1;   
         if(Res != 0 && MA2[i+1] < MA2[Res]) 
            Res = i+1; 
        }     
      } 
      return(Res); 
  } 
 
//+------------------------------------------------------------------+ 
//|                                                                  | 
//+------------------------------------------------------------------+ 
int GetIndicatorLastPeakMA(int shift) 
  { 
    for(int i = shift + 2; i < Bars; i++) 
      { 
        if(MA[i] > MA[i+1] && MA[i] > MA[i+1] && MA[i] > 0 && 
           MA[i] > MA[i-1] && MA[i] > MA[i-1]) 
            return(i); 
      } 
    return(-1); 
  } 
  int GetIndicatorLastPeakMAPOS(int shift) 
  { 
    for(int i = shift + 2; i < Bars; i++) 
      { 
        if(MA[i] > MA[i+1] && MA[i] > MA[i+1] && 
           MA[i] > MA[i-1] && MA[i] > MA[i-1]) 
            return(i); 
      } 
    return(-1); 
  } 
//+------------------------------------------------------------------+ 
//|                                                                  | 
//+------------------------------------------------------------------+ 
int GetIndicatorLastTroughMA(int shift) 
  {   
    for(int i = shift + 2; i < Bars; i++) 
      { 
        if(MA[i] < MA[i+1] && MA[i] < MA[i+1] && MA[i] < 0 && 
           MA[i] < MA[i-1] && MA[i] < MA[i-1]) 
            return(i); 
      } 
    return(-1); 
  } 
  int GetIndicatorLastTroughMAPOS(int shift) 
  {   
    for(int i = shift + 2; i < Bars; i++) 
      { 
        if(MA[i] < MA[i+1] && MA[i] < MA[i+1] && 
           MA[i] < MA[i-1] && MA[i] < MA[i-1]) 
            return(i); 
      } 
    return(-1); 
  } 
   
  //------------------------------------------------------------------- 
  //------------------------------------------------------------------- 
  int GetIndicatorLastPeakMA2(int shift) 
  { 
    for(int i = shift + 2; i < Bars; i++) 
      { 
        if(MA2[i] > MA2[i+1] && MA2[i] > MA2[i+1] && MA2[i] > 0 && 
           MA2[i] > MA2[i-1] && MA2[i] > MA2[i-1]) 
            return(i); 
      } 
    return(-1); 
  } 
  int GetIndicatorLastPeakMA2POS(int shift) 
  { 
    for(int i = shift + 2; i < Bars; i++) 
      { 
        if(MA2[i] > MA2[i+1] && MA2[i] > MA2[i+1] && 
           MA2[i] > MA2[i-1] && MA2[i] > MA2[i-1]) 
            return(i); 
      } 
    return(-1); 
  } 
//+------------------------------------------------------------------+ 
//|                                                                  | 
//+------------------------------------------------------------------+ 
int GetIndicatorLastTroughMA2(int shift) 
  {   
    for(int i = shift + 2; i < Bars; i++) 
      { 
        if(MA2[i] < MA2[i+1] && MA2[i] < MA2[i+1] && MA2[i] < 0 && 
           MA2[i] < MA2[i-1] && MA2[i] < MA2[i-1]) 
            return(i); 
      } 
    return(-1); 
  } 
  int GetIndicatorLastTroughMA2POS(int shift) 
  {   
    for(int i = shift + 2; i < Bars; i++) 
      { 
        if(MA2[i] < MA2[i+1] && MA2[i] < MA2[i+1] && 
           MA2[i] < MA2[i-1] && MA2[i] < MA2[i-1]) 
            return(i); 
      } 
    return(-1); 
  } 
//------------------------------------------------------------------- 
//------------------------------------------------------------------- 
  

2018无需申请注册送58体验金