Help with Logic | Page 2 | Forex Factory

Options

Go to
Permalinks
Print Thread

Similar Threads

Help with logic for only hitting one order per bar 6 replies

EA Math Logic-Help 10 replies

Need help w/ programming logic 19 replies

Help with coding Logic 0 replies

help me confirm this logic! 5 replies

Help with Logic

  • #21
  • Jul 28, 2010 7:30pm Jul 28, 2010 7:30pm
Quote
If it doesn't enter a trade, but hits the stop, then it will keep putting in a default entry for the ordersend and emptying it out over and over right?

Just to clarify, you are concerned that you have one routine that tells you that you need an order and then when it gets to the order routine, another routine say no? Is that correct?

I knew you had a knack for this......in a way you are correct and I like the way you think. You've probably I am bit of a speed freak.....I like code that executes super quick. Fortunately calculations use so few resources that there will be virtually no impact on speed. Output tends to be a big resource hog but your CPU can do millions of calculations a second, so unless you are wasting it by doing unnessesary calculations I have no qualms about doing as much maths as is needed.

If you wanted to be ultra efficient, you could place the minimum distance check in the Check_For_Trade function, subject to each of the 2 if statements.
  • #22
  • Jul 28, 2010 7:36pm Jul 28, 2010 7:36pm
Quoting kennyhubbard
Just to clarify, you are concerned that you have one routine that tells you that you need an order and then when it gets to the order routine, another routine say no? Is that correct?

I knew you had a knack for this......in a way you are correct and I like the way you think. You've probably I am bit of a speed freak.....I like code that executes super quick. Fortunately calculations use so few resources that there will be virtually no impact on speed. Output tends to be a big resource hog but your CPU can do millions of calculations a second,...
I see! Makes sense... I used to design software 10+ years ago for web based applications and I know that would have freaked me out as the applications then were quite thick and the computers much slower!

If it wasn't compiled, ultra-efficient and QA'd, it didn't get passed.

I will give that a stab. I am moving half-way across country this week, so if I am incommunicado, that is just because I am internetless!
We are our own best indicator.
  • #23
  • Aug 10, 2010 11:02am Aug 10, 2010 11:02am
Kenny,

I am in hopes you can continue to help me. I am no further ahead and just got my stuff set back up (from my move) so I can focus on getting this EA "done".

When I do the check for minimum distance it is deleting my orders and not behaving like a good boy. I am trying to figure out what is going on, but any pointers would be appreciated. You may have covered this already, but I am confused..

Here are the errors I am getting:
2010.08.10 11:05:022010.07.12 13:34 LBM v4 AUDNZD,M5: ArrayInitialize function internal error
2010.08.10 11:05:022010.07.12 13:34 LBM v4 AUDNZD,M5: incorrect start position 0 for ArraySort function



Here is my code below. If I take out the function check, it works fine...

Inserted Code
//+------------------------------------------------------------------+
//|                                                      REAV_EA.mq4 |
//|                                  Copyright © 2010, Kenny Hubbard |
//|                                       http://www.compu-forex.com |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2010, Kenny Hubbard"
#property link      "http://www.compu-forex.com"
#define        NO_RESULT            -10

extern int     MagicNumber       = 100;
extern double  Eq_StopLoss       = 10000;
extern double  Risk              = 1;        //1 = .01, 2 = .02, 10 = .1
extern double  Trail_From        = 8;
extern double  Trail_Max         = 50.0;
extern double  Trail_Percent     = 20;
extern double  Grid_Size         = 13;
extern double  MinimumReEntry    = 200;
extern double  Multiplier        = 1.5;
extern double  MinimumProfit     = 1;
extern double  RetraceDistance   = 2.0;      //Distance from opening retracement trade
extern int     StopLoss          = 0;        //Stop loss on entries if greater than 0

int   
   D_Factor    = 1,
   LotDigits   = 1,
   Slippage    = 3,
   Retries     = 10;
double   
   Anchor,
   Pip,
   Grid_Min = 0,
   Grid_Max = 0,
   Grid_Ord_OpenPrice[2],      //Creating 2 dimensional array, 0,0 & 0,1 positions to hold the pending short and pending long
   Auto_Grid,
   NewMultiplierTakeProfit = 0,
   NewLotSize = 0;
string
   Order_Cmt = "LBM_V1";
//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+
int init()
{
   Pip = Point;
//----
   if (Digits == 3|| Digits == 5){D_Factor = 10; Pip *= 10;}
   Grid_Size      *= Pip;
   if (MarketInfo(Symbol(),MODE_LOTSTEP) == 0.01)LotDigits = 2;
   Auto_Grid = Grid_Size;
   if(MinimumProfit == 0){MinimumProfit = 1;}
   MinimumReEntry *= Pip; 
   MinimumProfit *= Pip;
//----
   return(0);
}
//+------------------------------------------------------------------+
//| expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit()
{
//----
   
//----
   return(0);
}
//+------------------------------------------------------------------+
//| expert start function                                            |
//+------------------------------------------------------------------+
int start()
{
int
   result = NO_RESULT;

//----
   if (!OrdersTotal()){
      Print("Making an initial trade");
      OrderSend(Symbol(), 4, Get_Lots(Risk), NormalizeDouble(Ask+Auto_Grid,Digits), Slippage, 0 ,0 ,Order_Cmt, MagicNumber, 0, Blue);
      OrderSend(Symbol(), 5, Get_Lots(Risk), NormalizeDouble(Bid-Auto_Grid,Digits), Slippage, 0 ,0 ,Order_Cmt, MagicNumber, 0, Blue);
   }
   Update_Grid(Grid_Min, Grid_Max);                   //Updating Grid
   result = Check_For_Trade(Grid_Min, Grid_Max);      //Checking for existing trade
   if(result!=NO_RESULT) {Do_Trade(result);}          //
   Trail_Stop();
   Martingale();
   double BuyLevel = (Bid - (MinimumReEntry * Pip));
   double SellLevel = (Ask + (MinimumReEntry * Pip));
   Comment("Buy Level: ", (BuyLevel), "n", 
         "Sell Level: ", (SellLevel), "n", 
         "Bid :", Bid, "n",
         "Ask :", Ask, "n",
         "Minium Reentry: ", MinimumReEntry, "n");
   
 //----
   return(0);
  }
//+------------------------------------------------------------------+
void Martingale() //Function to remove existing straggler orders
{
   double CurrentLotSize;
   for(int xo = OrdersTotal()-1; xo >=0; xo--)
   {
      if(OrderSelect(xo,SELECT_BY_POS))
      {
         RefreshRates();
         CurrentLotSize = OrderLots();
         
         if(OrderType() == 0)
         {
            if(OrderOpenPrice() >= (Bid + (MinimumReEntry)))
            {
               NewLotSize = Multiplier * CurrentLotSize;
               NewMultiplierTakeProfit = Ask + CalculatePreviousLosses(CurrentLotSize,NewLotSize)+MinimumProfit;//Calculate new take profit
               
               if(OrderClose(OrderTicket(),OrderLots(),Ask,99,Red))
               {
                  OrderSend(Symbol(), 0, NormalizeDouble(NewLotSize,LotDigits), Ask, Slippage, 0 , NormalizeDouble(NewMultiplierTakeProfit,Digits) , "Multiplied Order", MagicNumber + 1, 0, Blue);
               }
            }
         }
         if(OrderType() == 1)
         {
            if(OrderOpenPrice() <= (Ask - (MinimumReEntry)))
            {
               NewLotSize = Multiplier * CurrentLotSize;
               NewMultiplierTakeProfit = Bid - CalculatePreviousLosses(CurrentLotSize,NewLotSize)-MinimumProfit;//Calculate new take profit
               
               if(OrderClose(OrderTicket(),OrderLots(),Ask,99,Red))
               {
                  OrderSend(Symbol(), 1, NormalizeDouble(NewLotSize,LotDigits), Bid, Slippage, 0 , NormalizeDouble(NewMultiplierTakeProfit,Digits), "Multiplied Order", MagicNumber + 1, 0, Blue);
               }
            }
         }
      }
   }  
}  
//+------------------------------------------------------------------+
double CalculatePreviousLosses(double CurrentLotSize, double FutureLotSize)
{
   double TotalNumberOfPipsLost;
   double StartingLotSize = Get_Lots(Risk);
   
   while(CurrentLotSize >= StartingLotSize)
   {
      TotalNumberOfPipsLost = TotalNumberOfPipsLost + ((CurrentLotSize * MinimumReEntry));
      CurrentLotSize /= Multiplier;  //Counting down
   }
   TotalNumberOfPipsLost = TotalNumberOfPipsLost / FutureLotSize;
   
   return(TotalNumberOfPipsLost);
}
//+------------------------------------------------------------------+
void Update_Grid(double& Min, double& Max)
{
int
   Order_Cnt=0,
   Grid_Num = 0;
   for(int i=0;i<OrdersTotal();i++)       //Looping through all orders
   {      
      if(OrderSelect(i,SELECT_BY_POS))
      {
         if(OrderType()>3)Order_Cnt++;    //Counting all Orders that are not currently opened
      }
      else Print("Error Selecting Order = " + GetLastError());
   }
   
   ArrayResize(Grid_Ord_OpenPrice,Order_Cnt);   //Set the number of rows in the array (Grid_Ord_OpenPrice 2nd dimension) equal to the current # of pending orders (should be 2)
   ArrayInitialize(Grid_Ord_OpenPrice,0.0);     //Zero'ing out Array to 0.0, if previous orders were added
   
   for(i=0;i<OrdersTotal();i++)
   {
      if(OrderSelect(i,SELECT_BY_POS))
      {
         if(OrderType()>3)
         {
            Grid_Ord_OpenPrice[Grid_Num] = OrderOpenPrice();
            Grid_Num++;
         }
      }
      else Print("Error Selecting Order = " + GetLastError());
   }
   ArraySort(Grid_Ord_OpenPrice);
   Min = Grid_Ord_OpenPrice[0];
   Max = Grid_Ord_OpenPrice[Order_Cnt-1];
}
//+------------------------------------------------------------------+
int Check_For_Trade(double Min, double Max)
{
   if(Ask >= Max + Auto_Grid)
   {   
      return(OP_BUYSTOP);
   }
   if(Bid <= Min - Auto_Grid) 
   {   
      return(OP_SELLSTOP);
   }
   return(NO_RESULT);
}
//+------------------------------------------------------------------+
void Check_Min_Distance(int Buy_or_Sell)
{
   for(int ex = 0; ex < OrdersTotal(); ex++)
   {
      if(OrderSelect(ex,SELECT_BY_POS))
      {
         RefreshRates();
         if(Buy_or_Sell == 4)
         {
            if((Ask + Auto_Grid) >= OrderOpenPrice())
            {
               Auto_Grid = (OrderOpenPrice() - Ask) + Auto_Grid;
            }
         }
         else if(Buy_or_Sell == 5)
         {
            if((Bid - Auto_Grid) <= OrderOpenPrice())
            {
               Auto_Grid = (Bid - OrderOpenPrice()) + Auto_Grid;
            }
         }  
      }
   }
}
//+------------------------------------------------------------------+
void Do_Trade(int Buy_or_Sell)
{
   Check_Min_Distance(Buy_or_Sell);
   
   switch(Buy_or_Sell)
   {
      case OP_BUYSTOP:  int ticket = OrderSend(Symbol(),OP_BUYSTOP,NormalizeDouble(Get_Lots(Risk),LotDigits),NormalizeDouble(Ask + Auto_Grid,Digits), Slippage,0,0,Order_Cmt,MagicNumber,0,Green);
                        Delete_Opposite_Trade(5);
                        ticket = OrderSend(Symbol(),OP_SELLSTOP,NormalizeDouble(Get_Lots(Risk),LotDigits),NormalizeDouble(Bid - (RetraceDistance * Auto_Grid),Digits), Slippage,0,0,Order_Cmt,MagicNumber,0,Red);
                        break;
      case OP_SELLSTOP: ticket = OrderSend(Symbol(),OP_SELLSTOP,NormalizeDouble(Get_Lots(Risk),LotDigits),NormalizeDouble(Bid - Auto_Grid,Digits), Slippage,0,0,Order_Cmt,MagicNumber,0,Red);
                        Delete_Opposite_Trade(4);
                        ticket = OrderSend(Symbol(),OP_BUYSTOP,NormalizeDouble(Get_Lots(Risk),LotDigits),NormalizeDouble(Ask + (RetraceDistance * Auto_Grid),Digits), Slippage,0,0,Order_Cmt,MagicNumber,0,Green);
                        break;
      default        :  Alert("Unknown ordertype returned");
                        break;
   }
   return;
}
//+------------------------------------------------------------------+
void Delete_Opposite_Trade(int Del_B_S)
{
   for(int i=0;i<OrdersTotal();i++){
      OrderSelect(i,SELECT_BY_POS);
      if(OrderMagicNumber() == MagicNumber){
         if(OrderType() == Del_B_S)OrderDelete(OrderTicket());
      }
   }
}
//+------------------------------------------------------------------+
double Get_Lots(double lRisk)
{
double
   Lots = AccountEquity() * lRisk/10000/100;
   if (MarketInfo(Symbol(),MODE_MINLOT) > Lots)Lots = MarketInfo(Symbol(),MODE_MINLOT);
   if (MarketInfo(Symbol(),MODE_MAXLOT) < Lots)Lots = MarketInfo(Symbol(),MODE_MAXLOT);
   return(Lots);
}
//+------------------------------------------------------------------+
bool Trail_Stop()
{
bool
   mod,
   lresult = false;
double
   My_Profit,
   My_Trail,
   My_SL,
   lTrail_Max,
   lTrail_From,
   Stop_Level;
//----
   for (int i = 0; i < OrdersTotal(); i++){
      if (OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
      {
         if(OrderMagicNumber() == MagicNumber)
         {
            RefreshRates();
         //******************************++++++++++++++++++++++++++++HARDCODED FOR NOW UNTIL BETTER SOLUTION, TO .01 LOTS, FOR UNDER 10K ACCOUNT IT WORKS!*************************
            
            if(OrderComment() == "LBM_V1")
            {            
               lTrail_Max = Trail_Max * Pip;
               lTrail_From = Trail_From * Pip;
               Stop_Level = MarketInfo(OrderSymbol(),MODE_STOPLEVEL)*Pip;
               switch(OrderType()){
                  case OP_BUY :  My_Profit = Bid - OrderOpenPrice();
                                 My_Trail = MathMin(My_Profit * Trail_Percent/100,lTrail_Max);
                                 My_SL = NormalizeDouble(OrderClosePrice()-My_Trail,Digits);
                                 lresult = true;
                                 if(My_Profit > lTrail_From){
                                    if(OrderClosePrice() - My_SL > Stop_Level){
                                       if(OrderStopLoss() < My_SL||OrderStopLoss() == 0)mod = OrderModify(OrderTicket(),OrderOpenPrice(),My_SL,OrderTakeProfit(),0, CLR_NONE);
                                    }
                                 }
                                 break;
                        
                  case OP_SELL : My_Profit = OrderOpenPrice() - Ask;
                                 My_Trail = MathMin(My_Profit * Trail_Percent/100,lTrail_Max);
                                 My_SL = NormalizeDouble(Ask+My_Trail,Digits);
                                 lresult = true;
                                 if(My_Profit > lTrail_From){
                                    if(My_SL - OrderClosePrice() > Stop_Level){
                                       if(My_SL < OrderStopLoss()||OrderStopLoss() == 0)mod = OrderModify(OrderTicket(),OrderOpenPrice(),My_SL,OrderTakeProfit(),0,CLR_NONE);
                                    }
                                 }
                                 break;
                  }
                  if(!mod && GetLastError() > 1)Print("Error entering Trailing Stop - Error " + GetLastError());
               }
            }
      }
      else Print("Error selecting order");
   } 
//----
   return(lresult);
}
We are our own best indicator.
  • #24
  • Aug 10, 2010 11:11am Aug 10, 2010 11:11am
Kenny,

I forgot about your boolean post above. I will play around with that and see if I can get it working!

Thanks.

Gil
We are our own best indicator.
  • #25
  • Aug 10, 2010 1:36pm Aug 10, 2010 1:36pm
Ok, I gave it another shot... Here is my boolean logic code that I am attempting to get working:

Inserted Code
int Check_For_Trade(double Min, double Max)
{
   int Buy_or_Sell;
   if(Ask >= Max + Auto_Grid)
   {   
      Buy_or_Sell = 4;
      if(Min_Distance(Buy_or_Sell) == false)
      {
         return;
      }
      return(OP_BUYSTOP);
   }
   if(Bid <= Min - Auto_Grid) 
   {   
      Buy_or_Sell = 5;
      if(Min_Distance(Buy_or_Sell) == false)
      {
         return;
      }
      return(OP_SELLSTOP);
   }
   return(NO_RESULT);
}
//+------------------------------------------------------------------+
bool Min_Distance(int Buy_or_Sell)
{
   for(int ex = 0; ex < OrdersTotal(); ex++)
   {
      if(OrderSelect(ex,SELECT_BY_POS))
      {
         RefreshRates();
         if(OrderType() == 4)
         {
            if(OrderOpenPrice() - Ask <= Auto_Grid)
            {
               return(false);
            }
         }
         if(OrderType() == 5)
         {
            if(Bid - OrderOpenPrice() <= Auto_Grid)
            {
               return(false);
            }
         
         }
      }
   } 
   return(true);  
}

Unfortunately, it is not doing what is intended and continues to open multiple orders within the 15 pips or whatever. Please help...

Entire code:

Inserted Code
//+------------------------------------------------------------------+
//|                                                      REAV_EA.mq4 |
//|                                  Copyright © 2010, Kenny Hubbard |
//|                                       http://www.compu-forex.com |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2010, Kenny Hubbard"
#property link      "http://www.compu-forex.com"
#define        NO_RESULT            -10

extern int     MagicNumber       = 100;
extern double  Eq_StopLoss       = 10000;
extern double  Risk              = 1;        //1 = .01, 2 = .02, 10 = .1
extern double  Trail_From        = 8;
extern double  Trail_Max         = 50.0;
extern double  Trail_Percent     = 20;
extern double  Grid_Size         = 13;
extern double  MinimumReEntry    = 200;
extern double  Multiplier        = 1.5;
extern double  MinimumProfit     = 1;
extern double  RetraceDistance   = 2.0;      //Distance from opening retracement trade
extern int     StopLoss          = 0;        //Stop loss on entries if greater than 0

int   
   D_Factor    = 1,
   LotDigits   = 1,
   Slippage    = 3,
   Retries     = 10;
double   
   Anchor,
   Pip,
   Grid_Min = 0,
   Grid_Max = 0,
   Grid_Ord_OpenPrice[2],      //Creating 2 dimensional array, 0,0 & 0,1 positions to hold the pending short and pending long
   Auto_Grid,
   NewMultiplierTakeProfit = 0,
   NewLotSize = 0;
string
   Order_Cmt = "LBM_V1";
//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+
int init()
{
   Pip = Point;
//----
   if (Digits == 3|| Digits == 5){D_Factor = 10; Pip *= 10;}
   Grid_Size      *= Pip;
   if (MarketInfo(Symbol(),MODE_LOTSTEP) == 0.01)LotDigits = 2;
   Auto_Grid = Grid_Size;
   if(MinimumProfit == 0){MinimumProfit = 1;}
   MinimumReEntry *= Pip; 
   MinimumProfit *= Pip;
//----
   return(0);
}
//+------------------------------------------------------------------+
//| expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit()
{
//----
   
//----
   return(0);
}
//+------------------------------------------------------------------+
//| expert start function                                            |
//+------------------------------------------------------------------+
int start()
{
int
   result = NO_RESULT;

//----
   if (!OrdersTotal()){
      Print("Making an initial trade");
      OrderSend(Symbol(), 4, Get_Lots(Risk), NormalizeDouble(Ask+Auto_Grid,Digits), Slippage, 0 ,0 ,Order_Cmt, MagicNumber, 0, Blue);
      OrderSend(Symbol(), 5, Get_Lots(Risk), NormalizeDouble(Bid-Auto_Grid,Digits), Slippage, 0 ,0 ,Order_Cmt, MagicNumber, 0, Blue);
   }
   Update_Grid(Grid_Min, Grid_Max);                   //Updating Grid
   result = Check_For_Trade(Grid_Min, Grid_Max);      //Checking for existing trade
   if(result!=NO_RESULT) {Do_Trade(result);}          //
   Trail_Stop();
   Martingale();
   double BuyLevel = (Bid - (MinimumReEntry * Pip));
   double SellLevel = (Ask + (MinimumReEntry * Pip));
   Comment(//"Buy Level: ", (BuyLevel), "n", 
         //"Sell Level: ", (SellLevel), "n", 
         //"Bid :", Bid, "n",
         //"Ask :", Ask, "n",
         "Grid Size: ",Auto_Grid, "n", 
         "Minium Reentry: ", MinimumReEntry, "n");
   
 //----
   return(0);
  }
//+------------------------------------------------------------------+
void Martingale() //Function to remove existing straggler orders
{
   double CurrentLotSize;
   for(int xo = OrdersTotal()-1; xo >=0; xo--)
   {
      if(OrderSelect(xo,SELECT_BY_POS))
      {
         RefreshRates();
         CurrentLotSize = OrderLots();
         
         if(OrderType() == 0)
         {
            if(OrderOpenPrice() >= (Bid + (MinimumReEntry)))
            {
               NewLotSize = Multiplier * CurrentLotSize;
               NewMultiplierTakeProfit = Ask + CalculatePreviousLosses(CurrentLotSize,NewLotSize)+MinimumProfit;//Calculate new take profit
               
               if(OrderClose(OrderTicket(),OrderLots(),Ask,99,Red))
               {
                  OrderSend(Symbol(), 0, NormalizeDouble(NewLotSize,LotDigits), Ask, Slippage, 0 , NormalizeDouble(NewMultiplierTakeProfit,Digits) , "Multiplied Order", MagicNumber + 1, 0, Blue);
               }
            }
         }
         if(OrderType() == 1)
         {
            if(OrderOpenPrice() <= (Ask - (MinimumReEntry)))
            {
               NewLotSize = Multiplier * CurrentLotSize;
               NewMultiplierTakeProfit = Bid - CalculatePreviousLosses(CurrentLotSize,NewLotSize)-MinimumProfit;//Calculate new take profit
               
               if(OrderClose(OrderTicket(),OrderLots(),Ask,99,Red))
               {
                  OrderSend(Symbol(), 1, NormalizeDouble(NewLotSize,LotDigits), Bid, Slippage, 0 , NormalizeDouble(NewMultiplierTakeProfit,Digits), "Multiplied Order", MagicNumber + 1, 0, Blue);
               }
            }
         }
      }
   }  
}  
//+------------------------------------------------------------------+
double CalculatePreviousLosses(double CurrentLotSize, double FutureLotSize)
{
   double TotalNumberOfPipsLost;
   double StartingLotSize = Get_Lots(Risk);
   
   while(CurrentLotSize >= StartingLotSize)
   {
      TotalNumberOfPipsLost = TotalNumberOfPipsLost + ((CurrentLotSize * MinimumReEntry));
      CurrentLotSize /= Multiplier;  //Counting down
   }
   TotalNumberOfPipsLost = TotalNumberOfPipsLost / FutureLotSize;
   
   return(TotalNumberOfPipsLost);
}
//+------------------------------------------------------------------+
void Update_Grid(double& Min, double& Max)
{
int
   Order_Cnt=0,
   Grid_Num = 0;
   for(int i=0;i<OrdersTotal();i++)       //Looping through all orders
   {      
      if(OrderSelect(i,SELECT_BY_POS))
      {
         if(OrderType()>3)Order_Cnt++;    //Counting all Orders that are not currently opened
      }
      else Print("Error Selecting Order = " + GetLastError());
   }
   
   ArrayResize(Grid_Ord_OpenPrice,Order_Cnt);   //Set the number of rows in the array (Grid_Ord_OpenPrice 2nd dimension) equal to the current # of pending orders (should be 2)
   ArrayInitialize(Grid_Ord_OpenPrice,0.0);     //Zero'ing out Array to 0.0, if previous orders were added
   
   for(i=0;i<OrdersTotal();i++)
   {
      if(OrderSelect(i,SELECT_BY_POS))
      {
         if(OrderType()>3)
         {
            Grid_Ord_OpenPrice[Grid_Num] = OrderOpenPrice();
            Grid_Num++;
         }
      }
      else Print("Error Selecting Order = " + GetLastError());
   }
   ArraySort(Grid_Ord_OpenPrice);
   Min = Grid_Ord_OpenPrice[0];
   Max = Grid_Ord_OpenPrice[Order_Cnt-1];
}
//+------------------------------------------------------------------+
int Check_For_Trade(double Min, double Max)
{
   int Buy_or_Sell;
   if(Ask >= Max + Auto_Grid)
   {   
      Buy_or_Sell = 4;
      if(Min_Distance(Buy_or_Sell) == false)
      {
         return;
      }
      return(OP_BUYSTOP);
   }
   if(Bid <= Min - Auto_Grid) 
   {   
      Buy_or_Sell = 5;
      if(Min_Distance(Buy_or_Sell) == false)
      {
         return;
      }
      return(OP_SELLSTOP);
   }
   return(NO_RESULT);
}
//+------------------------------------------------------------------+
bool Min_Distance(int Buy_or_Sell)
{
   for(int ex = 0; ex < OrdersTotal(); ex++)
   {
      if(OrderSelect(ex,SELECT_BY_POS))
      {
         RefreshRates();
         if(OrderType() == 4)
         {
            if(OrderOpenPrice() - Ask <= Auto_Grid)
            {
               return(false);
            }
         }
         if(OrderType() == 5)
         {
            if(Bid - OrderOpenPrice() <= Auto_Grid)
            {
               return(false);
            }
         
         }
      }
   } 
   return(true);  
}
//+------------------------------------------------------------------+
void Do_Trade(int Buy_or_Sell)
{
   switch(Buy_or_Sell)
   {
      case OP_BUYSTOP:  int ticket = OrderSend(Symbol(),OP_BUYSTOP,NormalizeDouble(Get_Lots(Risk),LotDigits),NormalizeDouble(Ask + Auto_Grid,Digits), Slippage,0,0,Order_Cmt,MagicNumber,0,Green);
                        Delete_Opposite_Trade(5);
                        ticket = OrderSend(Symbol(),OP_SELLSTOP,NormalizeDouble(Get_Lots(Risk),LotDigits),NormalizeDouble(Bid - (RetraceDistance * Auto_Grid),Digits), Slippage,0,0,Order_Cmt,MagicNumber,0,Red);
                        break;
      case OP_SELLSTOP: ticket = OrderSend(Symbol(),OP_SELLSTOP,NormalizeDouble(Get_Lots(Risk),LotDigits),NormalizeDouble(Bid - Auto_Grid,Digits), Slippage,0,0,Order_Cmt,MagicNumber,0,Red);
                        Delete_Opposite_Trade(4);
                        ticket = OrderSend(Symbol(),OP_BUYSTOP,NormalizeDouble(Get_Lots(Risk),LotDigits),NormalizeDouble(Ask + (RetraceDistance * Auto_Grid),Digits), Slippage,0,0,Order_Cmt,MagicNumber,0,Green);
                        break;
      default        :  Alert("Unknown ordertype returned");
                        break;
   }
   return;
}
//+------------------------------------------------------------------+
void Delete_Opposite_Trade(int Del_B_S)
{
   for(int i=0;i<OrdersTotal();i++){
      OrderSelect(i,SELECT_BY_POS);
      if(OrderMagicNumber() == MagicNumber){
         if(OrderType() == Del_B_S)OrderDelete(OrderTicket());
      }
   }
}
//+------------------------------------------------------------------+
double Get_Lots(double lRisk)
{
double
   Lots = AccountEquity() * lRisk/10000/100;
   if (MarketInfo(Symbol(),MODE_MINLOT) > Lots)Lots = MarketInfo(Symbol(),MODE_MINLOT);
   if (MarketInfo(Symbol(),MODE_MAXLOT) < Lots)Lots = MarketInfo(Symbol(),MODE_MAXLOT);
   return(Lots);
}
//+------------------------------------------------------------------+
bool Trail_Stop()
{
bool
   mod,
   lresult = false;
double
   My_Profit,
   My_Trail,
   My_SL,
   lTrail_Max,
   lTrail_From,
   Stop_Level;
//----
   for (int i = 0; i < OrdersTotal(); i++){
      if (OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
      {
         if(OrderMagicNumber() == MagicNumber)
         {
            RefreshRates();
         //******************************++++++++++++++++++++++++++++HARDCODED FOR NOW UNTIL BETTER SOLUTION, TO .01 LOTS, FOR UNDER 10K ACCOUNT IT WORKS!*************************
            
            if(OrderComment() == "LBM_V1")
            {            
               lTrail_Max = Trail_Max * Pip;
               lTrail_From = Trail_From * Pip;
               Stop_Level = MarketInfo(OrderSymbol(),MODE_STOPLEVEL)*Pip;
               switch(OrderType()){
                  case OP_BUY :  My_Profit = Bid - OrderOpenPrice();
                                 My_Trail = MathMin(My_Profit * Trail_Percent/100,lTrail_Max);
                                 My_SL = NormalizeDouble(OrderClosePrice()-My_Trail,Digits);
                                 lresult = true;
                                 if(My_Profit > lTrail_From){
                                    if(OrderClosePrice() - My_SL > Stop_Level){
                                       if(OrderStopLoss() < My_SL||OrderStopLoss() == 0)mod = OrderModify(OrderTicket(),OrderOpenPrice(),My_SL,OrderTakeProfit(),0, CLR_NONE);
                                    }
                                 }
                                 break;
                        
                  case OP_SELL : My_Profit = OrderOpenPrice() - Ask;
                                 My_Trail = MathMin(My_Profit * Trail_Percent/100,lTrail_Max);
                                 My_SL = NormalizeDouble(Ask+My_Trail,Digits);
                                 lresult = true;
                                 if(My_Profit > lTrail_From){
                                    if(My_SL - OrderClosePrice() > Stop_Level){
                                       if(My_SL < OrderStopLoss()||OrderStopLoss() == 0)mod = OrderModify(OrderTicket(),OrderOpenPrice(),My_SL,OrderTakeProfit(),0,CLR_NONE);
                                    }
                                 }
                                 break;
                  }
                  if(!mod && GetLastError() > 1)Print("Error entering Trailing Stop - Error " + GetLastError());
               }
            }
      }
      else Print("Error selecting order");
   } 
//----
   return(lresult);
}
We are our own best indicator.
  • #26
  • Aug 10, 2010 2:52pm Aug 10, 2010 2:52pm
Hi Gil,

I haven't really had a chance to dig into this as I am a bit snowed under at the moment but I can point you to some of the more obvious errors.

refer to my post#16 second para to find out about the array errors.

In your third last post, your code contains this line :-

Quote
Check_Min_Distance(Buy_or_Sell);

in the Do_Trade function......the line as you have it does nothing, you need to use something like :-

Quote
if(Check_Min_Distance(Buy_or_Sell)==true)return;

This way, if the result of Check_Min_Distance is true ie there is a trade within 15 pips, the return will cause the program execution to leave the trade function immediately and not do the trade.

In your Check_For_Trade function, you have this code :-

Quote
if(Min_Distance(Buy_or_Sell) == false)
{
return;
}
return(OP_BUYSTOP);

This function must return an integer.....I am not sure what simply saying return; will send back to the expression calling the function. It would be better to say return(NO_RESULT)
  • #27
  • Aug 10, 2010 6:06pm Aug 10, 2010 6:06pm
Quoting kennyhubbard
Hi Gil,

I haven't really had a chance to dig into this as I am a bit snowed under at the moment but I can point you to some of the more obvious errors.

refer to my post#16 second para to find out about the array errors.

In your third last post, your code contains this line :-



in the Do_Trade function......the line as you have it does nothing, you need to use something like :-



This way, if the result of Check_Min_Distance is true ie there is a trade within 15 pips, the return will cause the program execution to leave...
Hey Kenny!

No worries, any help is appreciated!

I feel I am close!~


I did try the boolean w/ "NO_RESULT" being passed, however that didn't work either. I will focus on that.

I understand what is happening and I believe it is just a small logic 'mis-understanding'.



Will update you on my progress!

Aloha!
We are our own best indicator.
  • #28
  • Aug 12, 2010 5:43pm Aug 12, 2010 5:43pm
Kenny et al,

I think I figured out what the problem is. We check for if the order is within 15 pips on the direction of the move, but we are not checking on the trailing entry @ 30 pips or 2X distance.

So, if it goes up and it does the test, then it says, nope, can't go in yet as there is an order already within 15 pips. Then, it finally makes it to 15 pips outside of last order, so it enters and enters a sell stop 30 pips from that price. Well, we already had a sell order there about 3 pips away from that.

Any idea's on how to fix this?

I am thinking that we can:

1. Change it from a boolean to an actual number like I was doing before and check both current direction and opposite direction at the same time and fix the order_grid size appropriately. I don't think this would work, because you are using a static number for both?

2. Change the array to have both buy/sell OR both and do the above?

3. Do another function check of the 2X OrderDistance and verify nothing is in it's way.

Writing this out helps me think some. I am thinking the best way would be to have to check both on the Do_Trade function/method/routine before it enters its trades and to update the orderprice appropriately?

Thanks in advance for any wisdom shared!

---So far the EA looks decent, but the multiple entries all at the same price are hurting it I believe. it needs tweaking..


Inserted Code
//+------------------------------------------------------------------+
//|                                                      REAV_EA.mq4 |
//|                                  Copyright © 2010, Kenny Hubbard |
//|                                       http://www.compu-forex.com |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2010, Kenny Hubbard"
#property link      "http://www.compu-forex.com"
#define        NO_RESULT            -10

extern int     MagicNumber       = 100;
extern double  Eq_StopLoss       = 10000;
extern double  Risk              = 1;        //% of account to risk per 10K account size
extern double  Trail_From        = 8;
extern double  Trail_Max         = 50.0;
extern double  Trail_Percent     = 20;
extern double  Grid_Size         = 13;
extern double  MinimumReEntry    = 200;
extern double  Multiplier        = 1.5;         //Martingale multiplier
extern double  MinimumProfit     = 1;           //Minimum profit from martingale recovery
extern int     StopLoss          = 0;           //Stop loss on entries if greater than 0 and if you want to use jumping stop placement of new entries

int   
   D_Factor    = 1,
   LotDigits   = 1,
   Slippage    = 3,
   Retries     = 10;
double   
   Anchor,
   Pip,
   Grid_Min = 0,
   Grid_Max = 0,
   Grid_Ord_OpenPrice[][2],      //Creating 2 dimensional array, 0,1 & 0,2 positions to hold the pending short and pending long
   Auto_Grid,
   NewMultiplierTakeProfit = 0,
   NewLotSize = 0;
string
   Order_Cmt = "LBM_V1";
//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+
int init()
{
   Pip = Point;
//----
   if (Digits == 3|| Digits == 5){D_Factor = 10; Pip *= 10;}
   Grid_Size      *= Pip;
   if (MarketInfo(Symbol(),MODE_LOTSTEP) == 0.01)LotDigits = 2;
   Auto_Grid = Grid_Size;
   if(MinimumProfit == 0){MinimumProfit = 1;}
   MinimumReEntry *= Pip; 
   MinimumProfit *= Pip;
//----
   return(0);
}
//+------------------------------------------------------------------+
//| expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit()
{
//----
   
//----
   return(0);
}
//+------------------------------------------------------------------+
//| expert start function                                            |
//+------------------------------------------------------------------+
int start()
{
int
   result = NO_RESULT;

//----
   if (!OrdersTotal()){
      Print("Making an initial trade");
      OrderSend(Symbol(), 4, Get_Lots(Risk), NormalizeDouble(Ask+Auto_Grid,Digits), Slippage, 0 ,0 ,Order_Cmt, MagicNumber, 0, Blue);
      OrderSend(Symbol(), 5, Get_Lots(Risk), NormalizeDouble(Bid-Auto_Grid,Digits), Slippage, 0 ,0 ,Order_Cmt, MagicNumber, 0, Blue);
   }
   Update_Grid(Grid_Min, Grid_Max);                   //Updating Grid
   result = Check_For_Trade(Grid_Min, Grid_Max);      //Checking for existing trade
   if(result!=NO_RESULT) {Do_Trade(result);}          //
   Trail_Stop();
   Martingale();
   double BuyLevel = (Bid - (MinimumReEntry * Pip));
   double SellLevel = (Ask + (MinimumReEntry * Pip));
   Comment("Buy Level: ", (BuyLevel), "n", 
         "Sell Level: ", (SellLevel), "n", 
         "Bid :", Bid, "n",
         "Ask :", Ask, "n",
         "Minium Reentry: ", MinimumReEntry, "n");
   
 //----
   return(0);
  }
//+------------------------------------------------------------------+
void Martingale() //Function to remove existing straggler orders
{
   double CurrentLotSize;
   for(int xo = OrdersTotal()-1; xo >=0; xo--)
   {
      if(OrderSelect(xo,SELECT_BY_POS))
      {
         RefreshRates();
         CurrentLotSize = OrderLots();
         
         if(OrderType() == 0)
         {
            if(OrderOpenPrice() >= (Bid + (MinimumReEntry)))
            {
               NewLotSize = Multiplier * CurrentLotSize;
               NewMultiplierTakeProfit = Ask + CalculatePreviousLosses(CurrentLotSize,NewLotSize)+MinimumProfit;//Calculate new take profit
               
               if(OrderClose(OrderTicket(),OrderLots(),Ask,99,Red))
               {
                  OrderSend(Symbol(), 0, NormalizeDouble(NewLotSize,LotDigits), Ask, Slippage, 0 , NormalizeDouble(NewMultiplierTakeProfit,Digits) , "Multiplied Order", MagicNumber + 1, 0, Blue);
               }
            }
         }
         if(OrderType() == 1)
         {
            if(OrderOpenPrice() <= (Ask - (MinimumReEntry)))
            {
               NewLotSize = Multiplier * CurrentLotSize;
               NewMultiplierTakeProfit = Bid - CalculatePreviousLosses(CurrentLotSize,NewLotSize)-MinimumProfit;//Calculate new take profit
               
               if(OrderClose(OrderTicket(),OrderLots(),Ask,99,Red))
               {
                  OrderSend(Symbol(), 1, NormalizeDouble(NewLotSize,LotDigits), Bid, Slippage, 0 , NormalizeDouble(NewMultiplierTakeProfit,Digits), "Multiplied Order", MagicNumber + 1, 0, Blue);
               }
            }
         }
      }
   }  
}  
//+------------------------------------------------------------------+
double CalculatePreviousLosses(double CurrentLotSize, double FutureLotSize)
{
   double TotalNumberOfPipsLost;
   double StartingLotSize = Get_Lots(Risk);
   
   while(CurrentLotSize >= StartingLotSize)
   {
      TotalNumberOfPipsLost = TotalNumberOfPipsLost + ((CurrentLotSize * MinimumReEntry));
      CurrentLotSize /= Multiplier;  //Counting down
   }
   TotalNumberOfPipsLost = TotalNumberOfPipsLost / FutureLotSize;
   
   return(TotalNumberOfPipsLost);
}
//+------------------------------------------------------------------+
void Update_Grid(double& Min, double& Max)
{
int
   Order_Cnt=0,
   Grid_Num = 0;
   for(int i=0;i<OrdersTotal();i++){      //Looping through all orders
      if(OrderSelect(i,SELECT_BY_POS)){
         if(OrderType()>3)Order_Cnt++;    //Counting all Orders that are not currently opened
      }
      else Print("Error Selecting Order = " + GetLastError());
   }
   
   ArrayResize(Grid_Ord_OpenPrice,Order_Cnt);   //Set the number of rows in the array (Grid_Ord_OpenPrice 2nd dimension) equal to the current # of pending orders (should be 2)
   ArrayInitialize(Grid_Ord_OpenPrice,0.0);     //Zero'ing out Array to 0.0, if previous orders were added
   
   for(i=0;i<OrdersTotal();i++)
   {
      if(OrderSelect(i,SELECT_BY_POS))
      {
         if(OrderType()>3)
         {
            Grid_Ord_OpenPrice[Grid_Num][0] = OrderOpenPrice();
            Grid_Num++;
         }
      }
      else Print("Error Selecting Order = " + GetLastError());
   }
   ArraySort(Grid_Ord_OpenPrice);
   Min = Grid_Ord_OpenPrice[0][0];
   Max = Grid_Ord_OpenPrice[Order_Cnt-1][0];
}
//+------------------------------------------------------------------+
int Check_For_Trade(double Min, double Max)
{
   int Buy_or_Sell;
   if(Ask >= Max + Auto_Grid)
   {   
      Buy_or_Sell = 4;
      if(Min_Distance(Buy_or_Sell) == false)
      {
         return(NO_RESULT);
      }
      return(OP_BUYSTOP);
   }
   if(Bid <= Min - Auto_Grid) 
   {   
      Buy_or_Sell = 5;
      if(Min_Distance(Buy_or_Sell) == false)
      {
         return(NO_RESULT);
      }
      return(OP_SELLSTOP);
   }
   return(NO_RESULT);
}
//+------------------------------------------------------------------+
bool Min_Distance(int Buy_or_Sell)
{
   for(int ex = 0; ex < OrdersTotal(); ex++)
   {
      if(OrderSelect(ex,SELECT_BY_POS))
      {
         RefreshRates();
         if(OrderType() == 4)
         {
            if(OrderOpenPrice() - Ask <= Auto_Grid)
            {
               return(false);
            }
         }
         if(OrderType() == 5)
         {
            if(Bid - OrderOpenPrice() <= Auto_Grid)
            {
               return(false);
            }
         
         }
      }
   } 
   return(true);  
}
//+------------------------------------------------------------------+
void Do_Trade(int Buy_or_Sell)
{
   switch(Buy_or_Sell){
      case OP_BUYSTOP:  int ticket = OrderSend(Symbol(),OP_BUYSTOP,NormalizeDouble(Get_Lots(Risk),LotDigits),NormalizeDouble(Ask + Auto_Grid,Digits), Slippage,0,0,Order_Cmt,MagicNumber,0,Green);
                        Delete_Opposite_Trade(5);
                        ticket = OrderSend(Symbol(),OP_SELLSTOP,NormalizeDouble(Get_Lots(Risk),LotDigits),NormalizeDouble(Bid - 2 * Auto_Grid,Digits), Slippage,0,0,Order_Cmt,MagicNumber,0,Red);
                        break;
      case OP_SELLSTOP: ticket = OrderSend(Symbol(),OP_SELLSTOP,NormalizeDouble(Get_Lots(Risk),LotDigits),NormalizeDouble(Bid - Auto_Grid,Digits), Slippage,0,0,Order_Cmt,MagicNumber,0,Red);
                        Delete_Opposite_Trade(4);
                        ticket = OrderSend(Symbol(),OP_BUYSTOP,NormalizeDouble(Get_Lots(Risk),LotDigits),NormalizeDouble(Ask + 2 * Auto_Grid,Digits), Slippage,0,0,Order_Cmt,MagicNumber,0,Green);
                        break;
      default        :  Alert("Unknown ordertype returned");
                        break;
   }
   return;
}
//+------------------------------------------------------------------+
void Delete_Opposite_Trade(int Del_B_S)
{
   for(int i=0;i<OrdersTotal();i++){
      OrderSelect(i,SELECT_BY_POS);
      if(OrderMagicNumber() == MagicNumber){
         if(OrderType() == Del_B_S)OrderDelete(OrderTicket());
      }
   }
}
//+------------------------------------------------------------------+
double Get_Lots(double lRisk)
{
double
   Lots = AccountEquity() * lRisk/10000/100;
   if (MarketInfo(Symbol(),MODE_MINLOT) > Lots)Lots = MarketInfo(Symbol(),MODE_MINLOT);
   if (MarketInfo(Symbol(),MODE_MAXLOT) < Lots)Lots = MarketInfo(Symbol(),MODE_MAXLOT);
   return(Lots);
}
//+------------------------------------------------------------------+
bool Trail_Stop()
{
bool
   mod,
   lresult = false;
double
   My_Profit,
   My_Trail,
   My_SL,
   lTrail_Max,
   lTrail_From,
   Stop_Level;
//----
   for (int i = 0; i < OrdersTotal(); i++){
      if (OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
      {
         if(OrderMagicNumber() == MagicNumber)
         {
            RefreshRates();
         //******************************++++++++++++++++++++++++++++HARDCODED FOR NOW UNTIL BETTER SOLUTION, TO .01 LOTS, FOR UNDER 10K ACCOUNT IT WORKS!*************************
            
            if(OrderComment() == "LBM_V1")
            {            
               lTrail_Max = Trail_Max * Pip;
               lTrail_From = Trail_From * Pip;
               Stop_Level = MarketInfo(OrderSymbol(),MODE_STOPLEVEL)*Pip;
               switch(OrderType()){
                  case OP_BUY :  My_Profit = Bid - OrderOpenPrice();
                                 My_Trail = MathMin(My_Profit * Trail_Percent/100,lTrail_Max);
                                 My_SL = NormalizeDouble(OrderClosePrice()-My_Trail,Digits);
                                 lresult = true;
                                 if(My_Profit > lTrail_From){
                                    if(OrderClosePrice() - My_SL > Stop_Level){
                                       if(OrderStopLoss() < My_SL||OrderStopLoss() == 0)mod = OrderModify(OrderTicket(),OrderOpenPrice(),My_SL,OrderTakeProfit(),0, CLR_NONE);
                                    }
                                 }
                                 break;
                        
                  case OP_SELL : My_Profit = OrderOpenPrice() - Ask;
                                 My_Trail = MathMin(My_Profit * Trail_Percent/100,lTrail_Max);
                                 My_SL = NormalizeDouble(Ask+My_Trail,Digits);
                                 lresult = true;
                                 if(My_Profit > lTrail_From){
                                    if(My_SL - OrderClosePrice() > Stop_Level){
                                       if(My_SL < OrderStopLoss()||OrderStopLoss() == 0)mod = OrderModify(OrderTicket(),OrderOpenPrice(),My_SL,OrderTakeProfit(),0,CLR_NONE);
                                    }
                                 }
                                 break;
                  }
                  if(!mod && GetLastError() > 1)Print("Error entering Trailing Stop - Error " + GetLastError());
               }
            }
      }
      else Print("Error selecting order");
   } 
//----
   return(lresult);
}
We are our own best indicator.
  • #29
  • Last Post: Aug 12, 2010 6:02pm Aug 12, 2010 6:02pm
I just realized, doing it this way also blows up the martingale effect.

hmmmmm.....
We are our own best indicator.
0 traders viewing now