Sample MQ4 Code

Here is a bit of code that demonstrates what I've been blogging about. It's a simple way to manage pending position requests. The idea is that a signal his been raised but that this code will let you wait for an improvement in the price before actually opening a position.

1. // *******************************************************************
2. // Name: AMS_PEND.MQ4
3. // Date: 01-Mar-2009
4. // Prog: Rookie
5. //
6. // Desc: A pending position queue manager. Pending positions can be
7. // held until a period of time or some favorable conditions.
8. // *******************************************************************
9. #property copyright "Copyright © 2009, Rookie"
10. #property link "http://trying-forex.blogspot.com/"
12. static double pendlask[4096]; // Ask price for a pending long
13. static int pendltime[4096]; // Time used to calculate pending time
14. static int pendlqty = 0; // How many items in pendlask queue
16. static double pendsbid[4096]; // Bid price for a pending short
17. static int pendstime[4096]; // Time used to calculate pending time
18. static int pendsqty = 0; // How many items in pendsbid queue
20. // ****************************************************************************
21. // Add a pending position entry to the long list
22. // ****************************************************************************
23. void addpendl(double ask)
24. {
25. static double last = 0;
27. if ( Time[0] > last )
28. {
29. pendltime[pendlqty] = Time[0];
30. pendlask[pendlqty] = Ask;
31. pendlqty++;
32. }
33. last = Time[0];
34. }
36. // ****************************************************************************
37. // Add a pending position entry to the short list
38. // ****************************************************************************
39. void addpends(double bid)
40. {
41. static double last = 0;
43. if ( Time[0] > last )
44. {
45. pendstime[pendsqty] = Time[0];
46. pendsbid[pendsqty] = Bid;
47. pendsqty++;
48. }
49. last = Time[0];
50. }
52. // ****************************************************************************
53. // A simple way to determining if a pending long position should be
54. // activated.
55. // ****************************************************************************
56. int dopendl_simple()
57. {
58. int i;
59. static int this=0;
61. // Dead simple "drop" style pending manager
62. // ----------------------------------------
63. for (i=0; i"">
64. {
65. if ( pendltime[i]>0 )
66. {
67. if ( pendlask[i] > Ask )
68. Print("Pending L #",i," ask was ",pendlask[i]," at ",pendltime[i]," now ",Ask);
70. // Terminate items that don't fire
71. // -------------------------------
72. if ( Time[0] - pendltime[i] > 3000 )
73. {
74. Print("Pending L #",i," from ",pendltime[i]," cleared due to time ",Time[0]);
75. pendltime[i]=0;
76. continue;
77. }
79. // Fire first pending item more than N points down
80. // -----------------------------------------------
81. if ( pendlask[i] - Ask > 5.0*Point )
82. {
83. if ( Bid <>
84. {
85. Print("Pending L #",i," firing");
86. pendltime[i] = 0;
87. pendlask[i] = 0.0;
88. return(1);
89. }
90. }
91. }
92. }
94. return(0);
95. }
97. // ****************************************************************************
98. // A simple way to determining if a pending short position should be
99. // activated.
100. // ****************************************************************************
101. int dopends_simple()
102. {
103. int i;
104. static int this=0;
106. // Dead simple "drop" style pending manager
107. // ----------------------------------------
108. for (i=0; i"">
109. {
110. if ( pendstime[i]>0 )
111. {
112. if ( pendsbid[i] <>
113. Print("Pending S #",i," bid was ",pendsbid[i]," at ",pendstime[i]," now ",Bid);
115. // Terminate items that don't fire
116. // -------------------------------
117. if ( Time[0] - pendstime[i] > 3000 )
118. {
119. Print("Pending S #",i," from ",pendstime[i]," cleared due to time ",Time[0]);
120. pendstime[i]=0;
121. continue;
122. }
124. // Fire first pending item more than N points up
125. // ---------------------------------------------
126. if ( Bid - pendsbid[i] > 5.0*Point )
127. {
128. if ( Bid > iMA(this,this,5,0,MODE_SMA,PRICE_TYPICAL,0) )
129. {
130. Print("Pending S #",i," firing");
131. pendstime[i] = 0;
132. pendsbid[i] = 0.0;
133. return(1);
134. }
135. }
136. }
137. }
139. return(0);
140. }
142. // ****************************************************************************
143. // Algorithm selection point for long position pend processing
144. // ****************************************************************************
145. int dopendl()
146. {
147. return(dopendl_simple());
148. }
150. // ****************************************************************************
151. // Algorithm selection point for short position pend processing
152. // ****************************************************************************
153. int dopends()
154. {
155. return(dopends_simple());
156. }

// *******************************************************************
// Name: AMS_PEND.MQ4
// Date: 01-Mar-2009
// Prog: Rookie
//
// Desc: A pending position queue manager.  Pending positions can be
//       held until a period of time or some favorable conditions.
// *******************************************************************
#property copyright "Copyright © 2009, Rookie"
#property link      "http://trying-forex.blogspot.com/"

static double pendlask[4096];    // Ask price for a pending long
static int    pendltime[4096];   // Time used to calculate pending time
static int    pendlqty = 0;      // How many items in pendlask queue

static double pendsbid[4096];    // Bid price for a pending short
static int    pendstime[4096];   // Time used to calculate pending time
static int    pendsqty = 0;      // How many items in pendsbid queue

// ****************************************************************************
// Add a pending position entry to the long list
// ****************************************************************************
void addpendl(double ask)
{
static double last = 0;

  if ( Time[0] > last )
  {
     pendltime[pendlqty] = Time[0];
     pendlask[pendlqty] = Ask;
     pendlqty++;
  }
  last = Time[0];
}

// ****************************************************************************
// Add a pending position entry to the short list
// ****************************************************************************
void addpends(double bid)
{
static double last = 0;

  if ( Time[0] > last )
  {
     pendstime[pendsqty] = Time[0];
     pendsbid[pendsqty] = Bid;
     pendsqty++;
  }
  last = Time[0];
}

// ****************************************************************************
// A simple way to determining if a pending long position should be
// activated.
// ****************************************************************************
int dopendl_simple()
{
int i;
static int this=0;

  // Dead simple "drop" style pending manager
  // ----------------------------------------
  for (i=0; i
  {
     if ( pendltime[i]>0 )
     {
        if ( pendlask[i] > Ask )
           Print("Pending L #",i," ask was ",pendlask[i]," at ",pendltime[i]," now ",Ask);

        // Terminate items that don't fire
        // -------------------------------
        if ( Time[0] - pendltime[i] > 3000 )
        {
           Print("Pending L #",i," from ",pendltime[i]," cleared due to time ",Time[0]);
           pendltime[i]=0;
           continue;
        }

        // Fire first pending item more than N points down
        // -----------------------------------------------
        if ( pendlask[i] - Ask > 5.0*Point )
        {
           if ( Bid < iMA(this,this,5,0,MODE_SMA,PRICE_TYPICAL,0) )
           {
              Print("Pending L #",i," firing");
              pendltime[i] = 0;
              pendlask[i] = 0.0;
              return(1);
           }
        }
     }
  }

  return(0);
}

// ****************************************************************************
// A simple way to determining if a pending short position should be
// activated.
// ****************************************************************************
int dopends_simple()
{
int i;
static int this=0;

  // Dead simple "drop" style pending manager
  // ----------------------------------------
  for (i=0; i
  {
     if ( pendstime[i]>0 )
     {
        if ( pendsbid[i] < Bid )
           Print("Pending S #",i," bid was ",pendsbid[i]," at ",pendstime[i]," now ",Bid);

        // Terminate items that don't fire
        // -------------------------------
        if ( Time[0] - pendstime[i] > 3000 )
        {
           Print("Pending S #",i," from ",pendstime[i]," cleared due to time ",Time[0]);
           pendstime[i]=0;
           continue;
        }

        // Fire first pending item more than N points up
        // ---------------------------------------------
        if ( Bid - pendsbid[i] > 5.0*Point )
        {
           if ( Bid > iMA(this,this,5,0,MODE_SMA,PRICE_TYPICAL,0) )
           {
              Print("Pending S #",i," firing");
              pendstime[i] = 0;
              pendsbid[i] = 0.0;
              return(1);
           }
        }
     }
  }

  return(0);
}

// ****************************************************************************
// Algorithm selection point for long position pend processing
// ****************************************************************************
int dopendl()
{
  return(dopendl_simple());
}

// ****************************************************************************
// Algorithm selection point for short position pend processing
// ****************************************************************************
int dopends()
{
  return(dopends_simple());
}

You'd use code like the following in the start function to see whether or not to add a pending position and whether or not to open a position based on a prior pending position.

view plainprint?

1. int openl;
3. // See if you have an "open long" signal. If so, add it to the
4. // queue.
5. // ------------------------------------------------------------
6. openl = ...;
7. if ( openl>0 )
8. {
9. addpendl(Ask);
10. Print("Pending LONG at ask ",Ask);
11. }
13. // Now, see if the queue manager suggests it's time to open a
14. // long position from within the queue.
15. // ----------------------------------------------------------
16. openl = dopendl();
18. // Open a position here if necessary
19. // ---------------------------------
20. if ( openl > 0 )
21. {
22. ...
23. }

int openl;

  // See if you have an "open long" signal.  If so, add it to the
  // queue.
  // ------------------------------------------------------------
  openl = ...;
  if ( openl>0 )
  {
     addpendl(Ask);
     Print("Pending LONG at ask ",Ask);
  }

  // Now, see if the queue manager suggests it's time to open a
  // long position from within the queue.
  // ----------------------------------------------------------
  openl = dopendl();

  // Open a position here if necessary
  // ---------------------------------
  if ( openl > 0 )
  {
     ...
  }

Notice that this design allows you to simply comment out all the pending code and open positions directly from your original signal. This makes it easy to integrate into your own code in case you want to try this in your own testing platform and see how affects your existing EA.