//+------------------------------------------------------------------+
//| 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 = " JOE CHALHOUB - http://www.Rpchost.com ";
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);
}
//-------------------------------------------------------------------
//-------------------------------------------------------------------
Sample
Analysis
Market Information Used:
Series array that contains the highest prices of each bar
Series array that contains the lowest prices of each bar
Series array that contains open prices of each bar
Series array that contains close prices for each bar
Series array that contains open time of each bar
Indicator Curves created:
Implements a curve of type DRAW_NONE
Implements a curve of type DRAW_HISTOGRAM
Implements a curve of type DRAW_NONE
Indicators Used:
Moving average indicator
Custom Indicators Used:
Order Management characteristics:
Other Features:
It issuies visual alerts to the screen