Help with Logic | 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

  • #1
  • First Post: Jul 25, 2010 1:32pm Jul 25, 2010 1:32pm
Hi all,

I am almost through my process of building the "Little Big Man EA", but I am stuck at a point of logic.

I have attached my code below as you can see, and this is all within the Martingale() function.

The whole point of this EA is to take small wins, when the small wins get stuck (stragglers), then I will martingale out of them at 200 (or 'X') pips away from the entry price.

I have my logic setup by default as every 200 pips, the trade will be closed, then a new trade will be opened in its place 1.5 times multiplied.

So, I have calculated a take profit to BE for that lost trade. However:

1) The calculation is not working properly as I am getting only 15.50 back after 20.00 loss on just the first level;

2. I am not able to retrieve if it goes multiple levels. L2 is entered at 200 pips and would be .02 lots, L3 is entered 400 pips and would be .03 lots, L4 is entered at 600 pips and is .05 lots etc.. It doesn't even come close to recovering.

Can someone please help me with how to do this. Thanks.

Here is the short version of what I have thus far:

NewMultiplierTakeProfit = ((OrderOpenPrice() * OrderLots()) + (Ask * NewLotSize)) / ((OrderLots() + NewLotSize));//Calculate new take profit

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              = 0.01;
extern double  Trail_From        = 8;
extern double  Trail_Max         = 50.0;
extern double  Trail_Percent     = 20;
extern double  Grid_Size         = 13;
extern int     MinimumReEntry    = 200;
extern double  Multiplier        = 1.5;
extern int     MinimumProfit     = 1;

int   
   D_Factor    = 1,
   LotDigits   = 1,
   Slippage    = 3,
   Retries     = 10;
double   
   Anchor,
   Pip,
   Grid_Min = 0,
   Grid_Max = 0,
   Grid_Ord_OpenPrice[][2],
   Auto_Grid,
   NewMultiplierTakeProfit = 0,
   NewLotSize = 0;
string
   Order_Cmt = "Little Big Man EA";
//+------------------------------------------------------------------+
//| 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;}
//----
   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);
   result = Check_For_Trade(Grid_Min, Grid_Max);
   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"
         //"Point: ", NormalizeDouble(MinimumReEntry*Point,10),"\n",
         //"Pip: ", NormalizeDouble(MinimumReEntry*Pip,10)
         );
   
 //----
   return(0);
  }
//+------------------------------------------------------------------+
void Martingale() //Function to remove existing straggler orders
{
   for(int xo = 0; xo < OrdersTotal(); xo++)
   {
      if(OrderSelect(xo,SELECT_BY_POS))
      {
         RefreshRates();
         if(OrderType() == 0)
         {
            if(OrderOpenPrice() >= (Bid + (MinimumReEntry * Pip)))
            {
               NewLotSize = Multiplier * OrderLots();
               NewMultiplierTakeProfit = ((OrderOpenPrice() * OrderLots()) + (Ask * NewLotSize)) / ((OrderLots() + NewLotSize));//Calculate new take profit
               
               if(OrderClose(OrderTicket(),OrderLots(),Ask,99,Red))
               {
                  OrderSend(Symbol(), 0, NormalizeDouble(NewLotSize,LotDigits), Ask, Slippage, 0 , NormalizeDouble((NewMultiplierTakeProfit+(MinimumProfit*Pip)),10) , "Multiplied Order", MagicNumber, 0, Blue);
               }
            }
         }
         if(OrderType() == 1)
         {
            if(OrderOpenPrice() <= (Ask - (MinimumReEntry * Pip)))
            {
               NewLotSize = Multiplier * OrderLots();
               NewMultiplierTakeProfit = ((OrderOpenPrice() * OrderLots()) + (Bid * NewLotSize)) / (OrderLots() + NewLotSize);//Calculate new take profit
               
               if(OrderClose(OrderTicket(),OrderLots(),Ask,99,Red))
               {
                  OrderSend(Symbol(), 1, NormalizeDouble(NewLotSize,LotDigits), Bid, Slippage, 0 , NormalizeDouble((NewMultiplierTakeProfit-(MinimumProfit*Pip)),10) , "Multiplied Order", MagicNumber, 0, Blue);
               }
            }
         }
      }
   }  
}

//+------------------------------------------------------------------+
void Update_Grid(double& Min, double& Max)
{
int
   Order_Cnt=0,
   Grid_Num = 0;
   for(int i=0;i<OrdersTotal();i++){
      if(OrderSelect(i,SELECT_BY_POS)){
         if(OrderType()>3)Order_Cnt++;
      }
      else Print("Error Selecting Order = " + GetLastError());
   }
   ArrayResize(Grid_Ord_OpenPrice,Order_Cnt);
   ArrayInitialize(Grid_Ord_OpenPrice,0.0);
   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)
{
   if(Ask >= Max + Auto_Grid)return(OP_BUYSTOP);
   if(Bid <= Min - Auto_Grid) return(OP_SELLSTOP);
   return(NO_RESULT);
}
//+------------------------------------------------------------------+
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/100/1000;
   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(OrderLots() < 0.02)
            {            
               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.
  • #2
  • Jul 25, 2010 8:02pm Jul 25, 2010 8:02pm
Hi Gil,

Not sure if this helps but try it out.

A couple of points that you may be aware of :-

Be careful of using OrdersTotal() directly in a loop that involves changing the number of orders as this will cause chaos in your life at some stage down the road. It makes for a bug that can be very difficlut to find. The reason for this is if you have a loop that counts from 0 to x and you keep changing x, the loop will not exit at the correct point. Its ok to do it if you are just counting orders or something like that, but the moment you have a trade execution in your loop, the OrdersTotal() gets updated within your loop(and not on the next tick as I always thought).

Your orders in this section will not work on an ECN/STP broker due to the requirement to enter a SL or TP separate from the main order. I am not sure which broker you use, if instant execution, it doesn't matter. Note that your code will still test fine in the tester, even if the broker is ECN, as the tester does not differentiate, so don't be misled by this.

I changed your takeprofit formula(to be honest, I didn't understand it:-)) and used this logic....

Number of pips lost(as a +'ve number) = OrderClosePrice() - OrderOpenPrice()
Number of volume weighted pips = Pips lost * OrderLots()
Number of recover pips = Volume weighted pips / lotmultiplier
New profit pips = recoverypips + minimum profit
Convert new profit pips to price....I used Ask + New profit(or Bid - New Profit) for this as that should cover you for the spread.

I generally as a rule, I try and convert all my external pips from 'human pips' to 'computer pips' in the init function in order to prevent repeating
unnecessary calculations, so when you use this routine, I have assumed you will have done this for your MinimumProfit variable. You may as well do this for MinimumReEntry.


PHP Code
void Martingale() //Function to remove existing straggler orders
{
int Total_Orders = OrdersTotal();
   for(int xo = Total_Orders; xo >=0; xo--)
   {
      if(OrderSelect(xo,SELECT_BY_POS))
      {
         RefreshRates();
         if(OrderType() == 0)
         {
            if(OrderOpenPrice() >= (Bid + (MinimumReEntry * Pip)))
            {
               NewLotSize = Multiplier * OrderLots();
               NewMultiplierTakeProfit = Ask + MinimumProfit + ((OrderClosePrice() - OrderOpenPrice()) * OrderLots()/Multiplier);//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 * Pip)))
            {
               NewLotSize = Multiplier * OrderLots();
               NewMultiplierTakeProfit = Bid - MinimumProfit - ((OrderClosePrice() - OrderOpenPrice()) * OrderLots()/Multiplier);//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);
               }
            }
         }
      }
   }  
}
  • #3
  • Jul 25, 2010 10:41pm Jul 25, 2010 10:41pm
Quoting kennyhubbard
Hi Gil,

Not sure if this helps but try it out.

A couple of points that you may be aware of :-

Be careful of using OrdersTotal() directly in a loop that involves changing the number of orders as this will cause chaos in your life at some stage down the road. It makes for a bug that can be very difficlut to find. The reason for this is if you have a loop that counts from...
Kenny,

Thanks so much. Million times over. Yes, I thought my logic was somewhat like yours, but not quite correct. I guess if you just spell it out, then it makes sense, but putting it into code doesn't always seem so easy sometimes.

I understand what you say about total orders etc.. Makes sense. It has been 10 years since I used to program ANYTHING, so the cobwebs are slowly disappearing!

I couldn't do this without you man!

Let me get my head around this and square it away.

Aloha!

P.S. I may have one other question for you if you have the time in how you would go about it? I have come up with a couple of ways, but not sure I am doing it right. How would you set up the grid in basic logic to check for existing orders within 15 pips, then move the grid 15 pips away?

I will put my own code up and see what you think, but the way you did it I have a feeling that I will make more issues then anything, but will give it a go! No harm, no foul!
We are our own best indicator.
  • #4
  • Jul 25, 2010 11:26pm Jul 25, 2010 11:26pm
Kenny,

I put in the init() section the following code:

MinimumReEntry *= Pip;
MinimumProfit *= Pip;

Then remove all references to Pip throughout the function like you mentioned.

But, when I do, it gets super strange in what it is doing entering a lot more often etc.. So I changed it back, can you please tell me what I may be doing wrong?

Also, the following doesn't seem to work either:

NewMultiplierTakeProfit = Ask + MinimumProfit*Pip + ((OrderClosePrice() - OrderOpenPrice()) * OrderLots()/Multiplier);//Calculate new take profit

It actually ends up less than the profit from the multiplied trades I had.

For example on an exit of a .05 after hitting TP is only a profit of 23.00, but the total recovery required would be:

.01 X 200 pips = -20.00
.02 X 200 pips = -40.00
.03 X 200 pips = -60.00 (Total 120.00 + be pips)

So, the # of pips required for .05 would be 240 pips right? This is putting it at a TP of around 46 pips?

Again, your assistance has been awesome and I can't thank you enough.



So there is probably something awry in the code that I did.

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              = 0.01;
extern double  Trail_From        = 8;
extern double  Trail_Max         = 50.0;
extern double  Trail_Percent     = 20;
extern double  Grid_Size         = 13;
extern int     MinimumReEntry    = 200;
extern double  Multiplier        = 1.5;
extern int     MinimumProfit     = 50;

int   
   D_Factor    = 1,
   LotDigits   = 1,
   Slippage    = 3,
   Retries     = 10;
double   
   Anchor,
   Pip,
   Grid_Min = 0,
   Grid_Max = 0,
   Grid_Ord_OpenPrice[][2],
   Auto_Grid,
   NewMultiplierTakeProfit = 0,
   NewLotSize = 0;
string
   Order_Cmt = "Little Big Man EA";
//+------------------------------------------------------------------+
//| 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;}
//----
   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);
   result = Check_For_Trade(Grid_Min, Grid_Max);
   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"
         //"Point: ", NormalizeDouble(MinimumReEntry*Point,10),"n",
         //"Pip: ", NormalizeDouble(MinimumReEntry*Pip,10)
         );
   
 //----
   return(0);
  }
//+------------------------------------------------------------------+
void Martingale() //Function to remove existing straggler orders
{
int Total_Orders = OrdersTotal();
   for(int xo = Total_Orders; xo >=0; xo--)
   {
      if(OrderSelect(xo,SELECT_BY_POS))
      {
         RefreshRates();
         if(OrderType() == 0)
         {
            if(OrderOpenPrice() >= (Bid + (MinimumReEntry * Pip)))
            {
               NewLotSize = Multiplier * OrderLots();
               NewMultiplierTakeProfit = Ask + MinimumProfit*Pip + ((OrderClosePrice() - OrderOpenPrice()) * OrderLots()/Multiplier);//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 * Pip)))
            {
               NewLotSize = Multiplier * OrderLots();
               NewMultiplierTakeProfit = Bid - MinimumProfit*Pip - ((OrderClosePrice() - OrderOpenPrice()) * OrderLots()/Multiplier);//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);
               }
            }
         }
      }
   }  
}  

//+------------------------------------------------------------------+
void Update_Grid(double& Min, double& Max)
{
int
   Order_Cnt=0,
   Grid_Num = 0;
   for(int i=0;i<OrdersTotal();i++){
      if(OrderSelect(i,SELECT_BY_POS)){
         if(OrderType()>3)Order_Cnt++;
      }
      else Print("Error Selecting Order = " + GetLastError());
   }
   ArrayResize(Grid_Ord_OpenPrice,Order_Cnt);
   ArrayInitialize(Grid_Ord_OpenPrice,0.0);
   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)
{
   if(Ask >= Max + Auto_Grid)return(OP_BUYSTOP);
   if(Bid <= Min - Auto_Grid) return(OP_SELLSTOP);
   return(NO_RESULT);
}
//+------------------------------------------------------------------+
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/100/1000;
   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(OrderLots() < 0.02)
            {            
               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.
  • #5
  • Jul 26, 2010 1:38am Jul 26, 2010 1:38am
Quote
P.S. I may have one other question for you if you have the time in how you would go about it? I have come up with a couple of ways, but not sure I am doing it right. How would you set up the grid in basic logic to check for existing orders within 15 pips, then move the grid 15 pips away?

Hi Gil,

I am sure you will discover that there is no right way to do these things....if one of the ways you have come up with works you must run with it. You can always revisit a routine later and you will often find ways to improve but my first rule is always to do what works.

Anyway, I personally would load the OrderOpenPrices into an array and simply inspect each one in turn comparing with the current price. One reason for this approach is because if you check the Update_Grid function, the order are already loaded into the array, so I would simply expand that routine.

I see what you are doing with the TakeProfit now......I was simply looking at the loss from the last trade only. Your method is far more complicated. I can't think of the formula off hand.....I will have to go think about this one. If you want to make it simple, use a variable that adds up the losses from the stragglers and then converts that to number of pips TP based on the current recovery volume. The main problem is knowing what the $$ losses are based on the latest lotsize. You would need to either store the progression, or calculate it. Its easy to see that 15 lots breaks down to 1 + 2 + 4 + 8 but its another thing to calculate it.

Quote
I put in the init() section the following code:

MinimumReEntry *= Pip;
MinimumProfit *= Pip;

You have declared these as integers, so change that to double. May or may not solve the problem, but start with the obvious bugs first.

Quote
I understand what you say about total orders etc.. Makes sense.

At the risk of flogging a dead horse, I just need to point out an error on my part. The way I did it with the orders loop counting down, it is fine to use OrdersTotal() since you are assigning the value at the beginning of the loop and not using it as a condition. If you count up from 0 then you need to assign an intermediate variable to keep the ordercount static. I think this is why they always say that it is good practice to count your order loops down rather than up. With that in mind you could delete the Total_Orders variable as it is wasting time and memory.

Another bug that I have created(not relevant to this discussion).......The Grid_Min and Grid_Max variables should be declared in the Start() function not in the global section.
  • #6
  • Jul 26, 2010 7:46am Jul 26, 2010 7:46am
Quote
I will have to go think about this one. If you want to make it simple, use a variable that adds up the losses from the stragglers and then converts that to number of pips TP based on the current recovery volume. The main problem is knowing what the $$ losses are based on the latest lotsize. You would need to either store the progression, or calculate it. Its easy to see that 15 lots breaks down to 1 + 2 + 4 + 8 but its another thing to calculate it.


Kenny, this is probably over my math head. But, what do you think about something like:

Void CalculatePreviousLosses(NewLotSize)
{
Loop down through NewLotSize/Multiplier until it reaches StartingLotSize(Get_Lots function), counting each time as you loop, you multiply each one by MinimumReEntry to get your total losses into a variable then:
Return(TotalNumberOfPipsLost);
}

I will give that a try, but I am not sure my programming would be right.

Quote
Anyway, I personally would load the OrderOpenPrices into an array and simply inspect each one in turn comparing with the current price. One reason for this approach is because if you check the Update_Grid function, the order are already loaded into the array, so I would simply expand that routine.

Yes, that is how I figured as well. I am not used to working with arrays in this language, so I will have to trial and error some. Should be fun.
We are our own best indicator.
  • #7
  • Edited 8:49am Jul 26, 2010 8:11am | Edited 8:49am
Gil,

Yup, that looks like you are on the right track. You may find it easier to get the formula right in something like MS Excel first. Once you have the correct formula, implementation should be easy enough.

I wouldn't sweat too much about the arrays. The bulk of the stuff is already there.....you just need to figure out how to read the array.

Oh, and one more thing.....the OrdersTotal() loop again......needs to start at OrdersTotal() -1. I just had a dose of stupid last night.

Just shout if you have any questions.
  • #8
  • Jul 26, 2010 4:55pm Jul 26, 2010 4:55pm
Quoting kennyhubbard
Gil,

Yup, that looks like you are on the right track. You may find it easier to get the formula right in something like MS Excel first. Once you have the correct formula, implementation should be easy enough.

I wouldn't sweat too much about the arrays. The bulk of the stuff is already there.....you just need to figure out how to read the array.

Oh, and one more thing.....the OrdersTotal() loop again......needs to start at OrdersTotal() -1. I just had a dose of stupid last night.

Just shout if you have any questions.
Ok, fixed loop, now I seem to have fixed code, however, it is slightly more than BE?

Is this the difference between Point & Pip? For example, it is off after a .12 win by several 10's of dollars... This is very close, but precision would be nice...



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              = 0.01;
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     = 50;

int   
   D_Factor    = 1,
   LotDigits   = 1,
   Slippage    = 3,
   Retries     = 10;
double   
   Anchor,
   Pip,
   Grid_Min = 0,
   Grid_Max = 0,
   Grid_Ord_OpenPrice[][2],
   Auto_Grid,
   NewMultiplierTakeProfit = 0,
   NewLotSize = 0;
string
   Order_Cmt = "Little Big Man EA";
//+------------------------------------------------------------------+
//| 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);
   result = Check_For_Trade(Grid_Min, Grid_Max);
   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 + MinimumProfit + ((OrderClosePrice() - OrderOpenPrice()) * OrderLots()/Multiplier); //OLD
               NewMultiplierTakeProfit = Ask + CalculatePreviousLosses(CurrentLotSize,NewLotSize);//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 - MinimumProfit - ((OrderClosePrice() - OrderOpenPrice()) * OrderLots()/Multiplier); //OLD
               NewMultiplierTakeProfit = Bid - CalculatePreviousLosses(CurrentLotSize,NewLotSize);//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++){
      if(OrderSelect(i,SELECT_BY_POS)){
         if(OrderType()>3)Order_Cnt++;
      }
      else Print("Error Selecting Order = " + GetLastError());
   }
   ArrayResize(Grid_Ord_OpenPrice,Order_Cnt);
   ArrayInitialize(Grid_Ord_OpenPrice,0.0);
   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)
{
   if(Ask >= Max + Auto_Grid)return(OP_BUYSTOP);
   if(Bid <= Min - Auto_Grid) return(OP_SELLSTOP);
   return(NO_RESULT);
}
//+------------------------------------------------------------------+
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/100/1000;
   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(OrderLots() < 0.02)
            {            
               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.
  • #9
  • Jul 26, 2010 7:30pm Jul 26, 2010 7:30pm
Hi Gil,

Looks good. You seem to have a knack for this.

There is probably a small error somewhere.....I would suggest looking at the CalculatePreviousLosses routine and use the Print command to write the variables to the Experts tab for inspection. That way to can step yourself through their values and see what the computer is seeing.

It is also possible that the code is 100% correct and the discrepency comes in with swap and commission, but your discrepency seem a bit big for this.
  • #10
  • Jul 26, 2010 8:05pm Jul 26, 2010 8:05pm
Quoting kennyhubbard
Hi Gil,

Looks good. You seem to have a knack for this.

There is probably a small error somewhere.....I would suggest looking at the CalculatePreviousLosses routine and use the Print command to write the variables to the Experts tab for inspection. That way to can step yourself through their values and see what the computer is seeing.

It is also possible that the code is 100% correct and the discrepency comes in with swap and commission, but your discrepency seem a bit big for this.
"knack"..hmmm... I don't know... but I am spending lots of time.

Thanks.

I will do the print and see, haven't done that either yet. Thanks for guiding me. I think they are accurate on smaller iterations, but when it gets to say Level 4 and above, it starts getting a bit out of proportion, but it could be swap maybe.... I am 'a' close.
We are our own best indicator.
  • #11
  • Jul 26, 2010 8:17pm Jul 26, 2010 8:17pm
Kenny,

If you could be so kind as well to maybe guide me on how to get around the logic on the money management routine with the martingale.

For example, the MM routine has it so it increases with more equity (which is great), however, then it will draw up too much of a position, so I added a 0 to it so it is now .01 = 10,000, which is more inline with what I want.

However, when I set up the trailing stop I hard coded your code to say if less than .02 lots then do trail. However, that doesn't make MM work too well...?

So... My ideas, please point me in the best direction you think.

- Add a comment filter to the orders, then filter TS by that filter. I actually already have this "Multiplied Order" comment in for the martingaled orders, so I could just filter on that, but not sure if it is good coding practice?

- Put in some logic that will be exported with the getLots routine that identifies starting lot size. However, if there are old .02 lots for martingale and equity hits 20K and now the starting lot is .02, there would be some confusion..

- any other ideas....?

Thanks again and I hope I am not taking up too much of your time.
We are our own best indicator.
  • #12
  • Jul 26, 2010 8:49pm Jul 26, 2010 8:49pm
Ok, I seem to have gotten it working w/ a comment, but if you could be kind enough to tell me if this is 'commercial' quality.

Now, I just have to figure out how to read that array using MQL4. I used to be a guru in structures and arrays 10 years ago! Now, it hurts my brain.

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              = 0.01;      //% 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;
extern double  MinimumProfit     = 1;

int   
   D_Factor    = 1,
   LotDigits   = 1,
   Slippage    = 3,
   Retries     = 10;
double   
   Anchor,
   Pip,
   Grid_Min = 0,
   Grid_Max = 0,
   Grid_Ord_OpenPrice[][2],
   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);
   result = Check_For_Trade(Grid_Min, Grid_Max);
   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++){
      if(OrderSelect(i,SELECT_BY_POS)){
         if(OrderType()>3)Order_Cnt++;
      }
      else Print("Error Selecting Order = " + GetLastError());
   }
   ArrayResize(Grid_Ord_OpenPrice,Order_Cnt);
   ArrayInitialize(Grid_Ord_OpenPrice,0.0);
   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)
{
   if(Ask >= Max + Auto_Grid)return(OP_BUYSTOP);
   if(Bid <= Min - Auto_Grid) return(OP_SELLSTOP);
   return(NO_RESULT);
}
//+------------------------------------------------------------------+
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;
   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.
  • #13
  • Jul 26, 2010 11:29pm Jul 26, 2010 11:29pm
Quote
However, if there are old .02 lots for martingale and equity hits 20K and now the starting lot is .02, there would be some confusion..

Being able to foresee problems like this is what I meant by knack. Good spot. I wouldn't sweat it though......there come a time when you have to choose between perfection and practicality. In this case the worst case is a cycle that closes with a small loss rather than a small profit.

The arrays haven't changed in 10 years, so you should be good to go. Just a tip, you would need to add another element for the ticketnumber, since the present system only stores the open price.

There are 2 ways.....either declare a new single dimention array like :-

int Grid_Ord_Ticket[]

or you can expand the existing array(in fact I just realised I didn't need to use a 2 dimenional array in the first place), so you could use the second level of the existing Grid_Ord_OpenPrice[][2]

I am sure from your previous experience you will know that you spend 10% coding and 90% debugging. MQL4 is your worst nightmare in this respect, since there is no debugger to help you. MQL4 will often allow you to do something wrong but will not tell you......a good example was when you declared those doubles as integers. A good runtime environment/debugger would tell you that you are trying to assign a floating point number to an integer variable.....not MQL4, it will simply round the number off and carry on, giving you unpredictable output.

The best tools are the Print command which I use for examining variables and also sometimes just simply as a program marker, so I know a function is getting executed. You could also use Comment() and then run a visual backtest but I think Print is easier. Remember to remove them as Print is the single biggest item affecting execution speed(along with screen output).
  • #14
  • Jul 26, 2010 11:36pm Jul 26, 2010 11:36pm
Quoting kennyhubbard
Being able to foresee problems like this is what I meant by knack. Good spot. I wouldn't sweat it though......there come a time when you have to choose between perfection and practicality. In this case the worst case is a cycle that closes with a small loss rather than a small profit.

The arrays haven't changed in 10 years, so you should be good to go. Just a tip, you would need to add another element for the ticketnumber, since the present system only stores the open price.

There are 2 ways.....either declare a new single dimention array...
As we say in Hawaii (where I used to live), You da kine brah!



Will give it a go!
We are our own best indicator.
  • #15
  • Jul 28, 2010 11:06am Jul 28, 2010 11:06am
Ok, I went through the array, made it a one dimensional array (as a table is not required)

Then, I created a new function that will test each order before it goes to send and seeing if it is within Auto_Grid distance and if so, add that to the OrderOpenPrice().

Please take a look at the code, and specifically Check_Min_Distance() function and tell me what you think? For some reason, I am getting array errors...

I am lost...

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              = 0.01;      //% 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;
extern double  MinimumProfit     = 1;
extern double  RetraceDistance   = 2.0;      //Distance from opening retracement trade

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;
   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.
  • #16
  • Jul 28, 2010 11:56am Jul 28, 2010 11:56am
LOL, Hi Gil,

One can really get tied up in knots with this thing.

The main problem that I can see is that your function Check_Min_Distance() changes the Auto_Grid. This is, in turn, causing trouble when it comes around to do a new round of initial trades. With no trades, the array is confused and that is why you are getting the array errors.

The Auto_Grid was something I was toying with when I wanted to use ATR to optimise a grid size....I just never got around to removing it. I would suggest using the Grid_Size extern as your base grid size and then rework your function, but don't change the Grid_Size variable.

Your function changes the gridsize if there is a pending order within 15 pips of current price. Is that what you intended to do? If that is the case, I would simply delete the pending order and make a new order 15 pips away. If it is a stragler trade that you are worried about within 15 pips, that is a different story. I know you told me, but it has slipped my mind.

I also saw you mentioned that your lotsizing was not working. This is because your lotsizes are being calculated too small(0.01% of equity?) and the lotsize is therefore governed by MODE_MINLOT in the MM calculation. You need to either increase the % or add some more zero's in the MM calculation.
  • #17
  • Jul 28, 2010 12:21pm Jul 28, 2010 12:21pm
Ok, gotcha. I would like to keep the grid the way you have it set up because in the future I do plan on adding an ATR style option for the grid size.

I don't quite understand what you are saying but I will read it a few times, sit on it, read it again and it will finally click.

The concept is that no two orders can be within the grid distance in the same direction. In testing you will get a double top on the 4H which will actually be like 8 orders within 30 pips all being left behind on the tick.

Having multiple orders at the same price is good for profit if it moves your way!

On the MM, that helps! I actually added a 0, and when I do the calculation on the calculator it does end up being .01. I had it working perfect, then changed 'something' and now it doesn't work again! I will continue to look and make sure it isn't what you are saying. Thanks again!
We are our own best indicator.
  • #18
  • Jul 28, 2010 12:37pm Jul 28, 2010 12:37pm
Quoting kennyhubbard

Your function changes the gridsize if there is a pending order within 15 pips of current price. Is that what you intended to do? If that is the case, I would simply delete the pending order and make a new order 15 pips away. If it is a stragler trade that you are worried about within 15 pips, that is a different story. I know you told me, but it has slipped my mind.
Kenny,

To clarify, the whole reason I am checking for minimum distance is to ensure that is there is a straggler that is already 'long', then I don't want to plant another trade closer than 15 pips (or xDistance) as if I have so many multiple orders all within the same area, then if the market reverses, I now have margtingaled numerous trades for very little upside.

I was testing AUDNZD specifically and the reason it blows up occasionally is because at some point it has like 3 orders (on the pip!) and then get martingales out to like 5 levels and kabooooooom!!!



I will play around some more and come back.
We are our own best indicator.
  • #19
  • Jul 28, 2010 1:02pm Jul 28, 2010 1:02pm
Hi Gil,

This formula works nicely for the MM :-

Inserted Code
Lots = AccountEquity() * lRisk/10000/100;

This way 1% risk = 0.01 lots and 5% risk = 0.05 lots.

I understand why you don't want to take more orders when you already have orders at a level. I am trying to define the problem in my mind.

My suggestion would be to use the use the Check_Min_Distance() function as a boolean function which evaluates to true if there is a trade within 15pips. Then you would have a simple statement like this :-

Inserted Code
if(Check_Min_Distance(Buy_or_Sell)==true)return;

This has the effect of exiting the Trade routine immediately and not making a trade.
  • #20
  • Jul 28, 2010 8:56pm Jul 28, 2010 8:56pm
Quoting kennyhubbard
Hi Gil,

This formula works nicely for the MM :-

Inserted Code
Lots = AccountEquity() * lRisk/10000/100;

This way 1% risk = 0.01 lots and 5% risk = 0.05 lots.

I understand why you don't want to take more orders when you already have orders at a level. I am trying to define the problem in my mind.

My suggestion would be to use the use the Check_Min_Distance() function as a boolean function which evaluates to true if there is a trade within 15pips. Then you would have a simple statement like this :-

Inserted Code
if(Check_Min_Distance(Buy_or_Sell)==true)return;
...
Thanks, changing it back works now! I would think what I wrote or changed would work as well, but I don't know why without reviewing it yet.

On using the function for checking the minimum distance, that makes sense, but I am not sure that would work, I have to think about it. 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?

If that is right, wouldn't that be resource intensive?
We are our own best indicator.
0 traders viewing now