Using Bid in While Loop?

I've been trying to write an EA, and to help get more precise about getting to a peak in the price before placing a sell order (in a strong uptrend), I've been trying to use a while loop - only when I do so, it seems that the tester goes into an infinite loop - it just doesn't perform the script though there are no errors when compiling.

Below is the loop, if anyone can point out why it's not working or give any suggestions to tweak or modify it, I'd appreciate it.

BuyPriceMax = Bid-(TrailingBuy*Point);
while(Bid>=BuyPriceMax) {
if(Bid>BuyPriceMax+(TrailingBuy*Point)) {
BuyPriceMax = Bid-(TrailingBuy*Point);
Sleep(10000); // SLEEP 10 SECONDS
RefreshRates();
}
}

The code follows an if statement to make sure the trend is rising. It should do the following:

1. Set a "trailing price" (BuyPriceMax) that Bid can be compared with
2. While the Bid price is >= BuyPriceMax, keep checking the Bid Price for any increase.
3. If price increased, increase BuyPriceMax to the Bid price minus "TrailingBuy" - a variable I use to allow price to dip slightly as it rises higher without exercising the order (similar to what you might set a trailing stop to)
4. Once price drops below BuyPriceMax, the loop should stop executing and the order will be placed at the Bid price.

If anyone can help me figure out why Bid always seems to be >= BuyPriceMax, I'd appreciate it. It seems that with the refresh command, once Bid drops far enough, it should end the loop so that my order can be placed.

Thanks!

It took a while, but I never like to leave a question unanswered, so I figured it out for you.

Here it is:

Let's say this:
Bid=1.2700
TrailingBuy=30
So, then this--
BuyPriceMax = Bid-(TrailingBuy*Point);
while(Bid>=BuyPriceMax) {
if(Bid>BuyPriceMax+(TrailingBuy*Point)) {
BuyPriceMax = Bid-(TrailingBuy*Point);
Sleep(10000); // SLEEP 10 SECONDS
RefreshRates();
}
}

Becomes this--
BuyPriceMax = 1.2700-(30*Point); // BuyPriceMax becomes 1.2670
while(1.2700>=1.2670) { // This is true so it goes to the if loop
if(1.2700>1.2670+(30*Point)) { // 1.2700 is NOT greater than 1.2700
BuyPriceMax = Bid-(TrailingBuy*Point); // Therefore it skips this line
Sleep(10000); // SLEEP 10 SECONDS // and this line
RefreshRates(); // and this line
} // end of if loop
// here it cycles back through the while loop without refreshing the rates, so your bid is forever 1.2700, making it an infinite loop
}

Wow, that feels good to solve that.

As far as actually changing the code to remedy this, here is what I came up with:


NOTE: You can and may want to put the Sleep line and RefreshRates() before or after the if statement. I'm pretty sure it won't affect anything. At worst the computer will run through the loop one extra time, which will take about 1/1000th of a second.

When price goes up:
BuyPriceMax = 1.2700-(30*Point); // BuyPriceMax becomes 1.2670
while(1.2700>=1.2670) { // This is true
RefreshRates(); // Now say Bid went up to 1.2703
if(1.2703>1.2670+(30*Point)) { // 1.2703 is greater than 1.2700, so it goes to the next line
BuyPriceMax = 1.2703-(30*Point); // New BuyPriceMax is 1.2773
}
Sleep(10000); // SLEEP 10 SECONDS
}

And when price goes down:
BuyPriceMax = 1.2700-(30*Point); // BuyPriceMax becomes 1.2670
while(1.2700>=1.2670) { // This is true
RefreshRates(); // Now say Bid went down to 1.2660
if(1.2660>1.2670+(30*Point)) { // 1.2660 is not greater than 1.2700, so it skips the next line
BuyPriceMax = Bid-(TrailingBuy*Point); // Line skipped
}
Sleep(10000); // SLEEP 10 SECONDS
}
Then it will go back through the while loop...
while (1.2660>=1.2670) { // NOT true, so it will kick out of the loop and execute the order
...
}


Sorry it was such a long post, but I wanted to explain it thoroughly.

andersenws

Where are my manners? I just realized it was your first post, so welcome to the Factory! There are lots of great people here willing to help you out, as well as a wealth of knowledge to learn from.

andersenws

Thanks - that really helps!

Thanks for the welcome. This forum is great.

Well, I thought everything would fly with moving the refresh rate before the if statement, but when I try backtesting, it still seems to freeze as if it's in an infinite loop. If I comment out the while loop, it seems to test the rest of my script fine.

So there is still something with the loop that is giving me problems.

Is there anyway to print out the results of the loop with each iteration so I can see what it's doing? Maybe the refreshrates doesn't actually work when you backtest?

I added the following two lines before the Sleep line to print some values to the log.

testcomments=StringConcatenate("Bid = ", Bid, "; BuyPriceMax = ", BuyPriceMax, "Time = ", TimeToStr(iTime(NULL,0,0)));
Print(testcomments);

Then, when I run the script and check the log, all values, including the time are the same. The time NEVER seems to increment, it just keeps spitting out the same Bid and BuyPriceMax values with the same time value.

This seems to indicate that for some reason, refresh has no effect and time doesn't change when backtesting. But when I run it without the loop, time values do come across for each bar in the results screen - so since there is historical data that comes across when testing without the loop, I'm at a loss as to why that historical data wouldn't work in this loop?

Any further thoughts? Much appreciated :-)

When you are backtesting, maybe try "Every tick method"? Have you done that already? I don't know, this might be a hard one.

andersenws

Hi, just to toss out another idea for you, to code something like that without a loop...

int HighestBarin10 = Highest(Symbol(),0,MODE_HIGH,10,1); //finds the highest bar in the last 10 bars(offset 1 bar)...change it to more bars if you need to

int BuyPriceMax = High[HighestBarin10]; Gives you the price of that High bar

if(Bid < BuyPriceMax-30*point)
{OrderSend(Symbol(),etc,etc,etc) }

Doesn't use a loop, it's fine just running all the time of new ticks. I prefer a setup like that because I would consider a pattern that took more than x amount of bars to develop broken and not worth the trade etc. Just a thought not sure if it suits your EA or not.

I don't know how much you know about the while loops and how much I know in comparison with you, so I might be wrong, but looking at the code you wrote it it looks to me that in the while loop you are assigning the same value to the BuyPriceMax = Bid-(trailingBuy*Point) as it was before the loop.
So the value that causes iteration of the while loop is not incremented but is constantly the same.
Also I know that the while loop will go into the infinite loop if the iteration value is not incremented.
Possible solution? I don't know. Try == instead of =. That would not assign the value to the BuyPriceMax, but make it egual to the Bid-(trailingBuy*Point)

Hope it helps. (Still learning).

Hi lietuve,

My thought was that the bid rate should be updated with each quote posted - therefore, it shouldn't always be the same but would adjust. Refreshrates should pull the latest quote. Therefore, I thought the values would actually adjust up or down as the bid price did, and then if it reached a point where the condition no longer held, it would kick out of the loop and place the order.

Thanks Fishtank for your input. It looks promising for some other signal, but for what I'm trying to do - I don't know if it would work.

I am looking for certain conditions to be met before my EA places a trade. This loop is more of a "fine-tuning" to try to enter at a better point. For example, if I'm trying to enter a Short position when price breaks the top bollinger band, I would like the EA to determine if price is continuing to rise above the band - because often, price might continue up through several bars before starting to fall again - so I don't want to enter the trade until it's closer to it's peak.

This loop was to be used to delay the entry until it is determined price is turning around. So I call this my "trailing buy". I want to allow for the price to keep going up, then when it starts to fall below my adjusted Short price, take the order Short at the market rate.

This means, that all the price comparisons may occur within the same bar or it may spread across several bars. Since it's a delay, I think it needs to be done via a loop, but whether "Bid" works in a loop, I don't really know. So far, it doesn't seem to be getting the latest quote.

Finally I found it on the web; there is a professional explanation how Boolean values are assingned in C. MQL has a lot common with C, C++; And that's what I was trying to explain in my post. Maybe it is not very pertinent to you, you might solve the problem other ways, but it is interesting to know:
Here is the quote from tutorial:
//quote

We've now encountered perhaps the most easy-to-stumble-on ``gotcha!'' in C: the equality-testing operator is ==, not a single =, which is assignment. If you accidentally write
if(a = 0)

(and you probably will at some point; everybody makes this mistake), it will not test whether a is zero, as you probably intended. Instead, it will assign 0 to a, and then perform the ``true'' branch of the if statement if a is nonzero. But a will have just been assigned the value 0, so the ``true'' branch will never be taken! (This could drive you crazy while debugging--you wanted to do something if a was 0, and after the test, a is 0, whether it was supposed to be or not, but the ``true'' branch is nevertheless not taken.)
// End of quote.

Happy programming.

My operator in the while statement was a >= not a =, so it should have worked (I think). I did try splitting it to 2 conditions using just a ">" || a "==", but that didn't work either.

What I ended out doing is eliminating the while loop and replacing it with the following for loop. This made sure the loop is incrementing for a specific period of time and would then stop unless already broken out of due to an interior if statement not being met:


That seems to have solved the problem. It limits the loop so it will end at some point and also allows for a way to check if price is rising before placing BUY (closer to the peak).

Thanks for all the input everyone.