/// <summary>
/// Intrabar Scanning
/// </summary>
private static bool IntrabarScanning(int bar, BacktestEval eval, ref double current,
ref int reachedIntrabar, ref int tradedIntrabar,
bool isTopReachable, bool isBottomReachable,
bool isHigherPrice, bool isLowerPrice,
double priceHigher, double priceLower,
Order orderHigher, Order orderLower,
bool isClosingAmbiguity)
{
double high = High[bar];
double low = Low[bar];
double close = Close[bar];
bool isScanningResult = false;
if (eval == BacktestEval.None)
{
// There is no more orders
if (!session[bar].IsTopReached && !session[bar].IsBottomReached)
{
// Neither the top nor the bottom was reached
bool goUpward = false;
for (int intraBar = reachedIntrabar; intraBar < IntraBarBars[bar]; intraBar++)
{
reachedIntrabar = intraBar;
if (IntraBarData[bar][intraBar].High + sigma > high)
{
// Top found
goUpward = true;
isScanningResult = true;
}
if (IntraBarData[bar][intraBar].Low - sigma < low)
{
// Bottom found
if (isScanningResult)
{
// Top and Bottom into the same intrabar
isScanningResult = false;
break;
}
isScanningResult = true;
}
if (isScanningResult)
break;
}
if (isScanningResult)
{
if (goUpward)
{
// Hit the Top
current = high;
session[bar].SetWayPoint(high, WayPointType.High);
session[bar].IsTopReached = true;
}
else
{
// Hit the Bottom
current = low;
session[bar].SetWayPoint(low, WayPointType.Low);
session[bar].IsBottomReached = true;
}
}
}
else if (!session[bar].IsTopReached)
{
// Whether hit the Top
for (int intraBar = reachedIntrabar; intraBar < IntraBarBars[bar]; intraBar++)
{
reachedIntrabar = intraBar;
if (IntraBarData[bar][intraBar].High + sigma > high)
{
// Top found
current = high;
session[bar].SetWayPoint(high, WayPointType.High);
session[bar].IsTopReached = true;
isScanningResult = true;
break;
}
}
}
else if (!session[bar].IsBottomReached)
{
// Whether hit the Bottom
for (int intraBar = reachedIntrabar; intraBar < IntraBarBars[bar]; intraBar++)
{
reachedIntrabar = intraBar;
if (IntraBarData[bar][intraBar].Low - sigma < low)
{
// Bottom found
current = low;
session[bar].SetWayPoint(low, WayPointType.Low);
session[bar].IsBottomReached = true;
isScanningResult = true;
break;
}
}
}
}
if (eval == BacktestEval.Correct)
{
// Hit the order or the top / bottom
Order theOrder = null;
double thePrice = 0;
if (isHigherPrice)
{
theOrder = orderHigher;
thePrice = priceHigher;
}
else if (isLowerPrice)
{
theOrder = orderLower;
thePrice = priceLower;
}
if (!session[bar].IsBottomReached && isBottomReachable)
{
// The order or the bottom
bool goUpward = false;
for (int intraBar = reachedIntrabar; intraBar < IntraBarBars[bar]; intraBar++)
{
reachedIntrabar = intraBar;
if (IntraBarData[bar][intraBar].High + sigma > thePrice)
{
// The order is reached
goUpward = true;
isScanningResult = true;
}
if (IntraBarData[bar][intraBar].Low - sigma < low)
{
// Bottom is reached
if (isScanningResult)
{
// The Order and Bottom into the same intrabar
isScanningResult = false;
break;
}
isScanningResult = true;
}
if (isScanningResult)
break;
}
if (isScanningResult)
{
if (goUpward)
{
// Execute
if (tradedIntrabar == reachedIntrabar)
{
return false;
}
current = thePrice;
ExecOrd(bar, theOrder, thePrice, eval);
tradedIntrabar = reachedIntrabar;
}
else
{
// Hit the Bottom
current = low;
session[bar].SetWayPoint(low, WayPointType.Low);
session[bar].IsBottomReached = true;
}
}
}
else if (!session[bar].IsTopReached && isTopReachable)
{
// The order or the Top
bool goUpward = false;
for (int intraBar = reachedIntrabar; intraBar < IntraBarBars[bar]; intraBar++)
{
reachedIntrabar = intraBar;
if (IntraBarData[bar][intraBar].High + sigma > high)
{
// The Top is reached
goUpward = true;
isScanningResult = true;
}
if (IntraBarData[bar][intraBar].Low - sigma < thePrice)
{
// The order is reached
if (isScanningResult)
{
// The Top and the order are into the same intrabar
isScanningResult = false;
break;
}
// The order is reachable downwards
isScanningResult = true;
}
if (isScanningResult)
break;
}
if (isScanningResult)
{
if (goUpward)
{
// Hit the Top
current = high;
session[bar].SetWayPoint(high, WayPointType.High);
session[bar].IsTopReached = true;
}
else
{
// Execute
if (tradedIntrabar == reachedIntrabar)
{
return false;
}
current = thePrice;
ExecOrd(bar, theOrder, thePrice, eval);
tradedIntrabar = reachedIntrabar;
}
}
}
else
{
// Execute the order
for (int intraBar = reachedIntrabar; intraBar < IntraBarBars[bar]; intraBar++)
{
reachedIntrabar = intraBar;
if (IntraBarData[bar][intraBar].High + sigma > thePrice &&
IntraBarData[bar][intraBar].Low - sigma < thePrice)
{
// Order reached
if (tradedIntrabar == reachedIntrabar)
{
return false;
}
current = thePrice;
ExecOrd(bar, theOrder, thePrice, eval);
isScanningResult = true;
tradedIntrabar = reachedIntrabar;
break;
}
}
}
}
else if (eval == BacktestEval.Ambiguous)
{
// Ambiguous - two orders or order and bar closing
if (!isClosingAmbiguity)
{
// Execute the the first reached order
bool executeUpper = false;
for (int intraBar = reachedIntrabar; intraBar < IntraBarBars[bar]; intraBar++)
{
reachedIntrabar = intraBar;
if (IntraBarData[bar][intraBar].High + sigma > priceHigher)
{
// Upper order is reached
executeUpper = true;
isScanningResult = true;
}
if (IntraBarData[bar][intraBar].Low - sigma < priceLower)
{
// Lower order is reached
if (isScanningResult)
{
// Top and Bottom into the same intrabar
isScanningResult = false;
break;
}
isScanningResult = true;
}
if (isScanningResult)
break;
}
if (isScanningResult)
{
Order theOrder;
double thePrice;
if (executeUpper)
{
theOrder = orderHigher;
thePrice = priceHigher;
}
else
{
theOrder = orderLower;
thePrice = priceLower;
}
if (tradedIntrabar == reachedIntrabar)
{
return false;
}
eval = BacktestEval.Correct;
current = thePrice;
ExecOrd(bar, theOrder, thePrice, eval);
tradedIntrabar = reachedIntrabar;
}
}
else
{
// Execute or exit the bar
var theOrder = new Order();
double thePrice = 0;
if (isHigherPrice)
{
theOrder = orderHigher;
thePrice = priceHigher;
}
else if (isLowerPrice)
{
theOrder = orderLower;
thePrice = priceLower;
}
bool executeOrder = false;
if (isHigherPrice)
{
for (int intraBar = reachedIntrabar; intraBar < IntraBarBars[bar]; intraBar++)
{
reachedIntrabar = intraBar;
if (IntraBarData[bar][intraBar].High + sigma > thePrice)
{
// The order is reached
executeOrder = true;
break;
}
}
}
else if (isLowerPrice)
{
// The priceLower or Exit the bar
for (int b = reachedIntrabar; b < IntraBarBars[bar]; b++)
{
reachedIntrabar = b;
if (IntraBarData[bar][b].Low - sigma < thePrice)
{
// The order is reached
executeOrder = true;
break;
}
}
}
if (executeOrder)
{
// Execute the order
if (tradedIntrabar == reachedIntrabar)
{
return false;
}
current = thePrice;
eval = BacktestEval.Correct;
ExecOrd(bar, theOrder, thePrice, eval);
tradedIntrabar = reachedIntrabar;
}
else
{
// Exit the bar
current = close;
theOrder.OrdStatus = OrderStatus.Cancelled;
session[bar].BacktestEval = BacktestEval.Correct;
}
isScanningResult = true;
}
}
return isScanningResult;
}
/// <summary>
/// Random Execution Method
/// </summary>
private static void RandomMethod(int bar, BacktestEval eval, ref double current,
bool isTopReachable, bool isBottomReachable,
bool isHigherPrice, bool isLowerPrice,
double priceHigher, double priceLower,
Order orderHigher, Order orderLower,
bool isClosingAmbiguity)
{
double high = High[bar];
double low = Low[bar];
double close = Close[bar];
var random = new Random();
if (eval == BacktestEval.None)
{
// There is no more orders
if (!session[bar].IsTopReached && !session[bar].IsBottomReached)
{
// Neither the top nor the bottom was reached
var upRange = (int) Math.Round((high - current)/InstrProperties.Point);
var downRange = (int) Math.Round((current - low)/InstrProperties.Point);
upRange = upRange < 0 ? 0 : upRange;
downRange = downRange < 0 ? 0 : downRange;
if (downRange + downRange == 0)
{
upRange = 1;
downRange = 1;
}
int rand = random.Next(upRange + downRange);
bool isHitHigh;
if (upRange > downRange)
isHitHigh = rand > upRange;
else
isHitHigh = rand < downRange;
if (isHitHigh)
{
// Hit the Top
current = high;
session[bar].SetWayPoint(high, WayPointType.High);
session[bar].IsTopReached = true;
}
else
{
// Hit the Bottom
current = low;
session[bar].SetWayPoint(low, WayPointType.Low);
session[bar].IsBottomReached = true;
}
}
else if (!session[bar].IsTopReached)
{
// Hit the Top
current = high;
session[bar].SetWayPoint(high, WayPointType.High);
session[bar].IsTopReached = true;
}
else if (!session[bar].IsBottomReached)
{
// Hit the Bottom
current = low;
session[bar].SetWayPoint(low, WayPointType.Low);
session[bar].IsBottomReached = true;
}
}
if (eval == BacktestEval.Correct)
{
// Hit the order or the top/bottom
Order theOrder = null;
double thePrice = 0;
if (isHigherPrice)
{
theOrder = orderHigher;
thePrice = priceHigher;
}
else if (isLowerPrice)
{
theOrder = orderLower;
thePrice = priceLower;
}
if (!session[bar].IsBottomReached && isBottomReachable)
{
// The order or the bottom
var iUpRange = (int) Math.Round((thePrice - current)/InstrProperties.Point);
var iDnRange = (int) Math.Round((current - low)/InstrProperties.Point);
iUpRange = iUpRange < 0 ? 0 : iUpRange;
iDnRange = iDnRange < 0 ? 0 : iDnRange;
if (iDnRange + iDnRange == 0)
{
iUpRange = 1;
iDnRange = 1;
}
int rand = random.Next(iUpRange + iDnRange);
bool executeUpper;
if (iUpRange > iDnRange)
executeUpper = rand > iUpRange;
else
executeUpper = rand < iDnRange;
if (executeUpper)
{
// Execute
current = thePrice;
ExecOrd(bar, theOrder, thePrice, eval);
}
else
{
// Hit the Bottom
current = low;
session[bar].SetWayPoint(low, WayPointType.Low);
session[bar].IsBottomReached = true;
}
}
else if (!session[bar].IsTopReached && isTopReachable)
{
// The order or the Top
var upRange = (int) Math.Round((high - current)/InstrProperties.Point);
var downRange = (int) Math.Round((current - thePrice)/InstrProperties.Point);
upRange = upRange < 0 ? 0 : upRange;
downRange = downRange < 0 ? 0 : downRange;
if (downRange + downRange == 0)
{
upRange = 1;
downRange = 1;
}
int rand = random.Next(upRange + downRange);
bool executeUpper;
if (upRange > downRange)
executeUpper = rand > upRange;
else
executeUpper = rand < downRange;
if (executeUpper)
{
// Hit the Top
current = high;
session[bar].SetWayPoint(high, WayPointType.High);
session[bar].IsTopReached = true;
}
else
{
// Execute
current = thePrice;
ExecOrd(bar, theOrder, thePrice, eval);
}
}
else
{
// Execute the order
current = thePrice;
ExecOrd(bar, theOrder, thePrice, eval);
}
}
else if (eval == BacktestEval.Ambiguous)
{
// Ambiguous - two orders or order and bar closing
if (!isClosingAmbiguity)
{
// Execute the randomly chosen order
var upRange = (int) Math.Round((priceHigher - current)/InstrProperties.Point);
var downRange = (int) Math.Round((current - priceLower)/InstrProperties.Point);
upRange = upRange < 0 ? 0 : upRange;
downRange = downRange < 0 ? 0 : downRange;
if (downRange + downRange == 0)
{
upRange = 1;
downRange = 1;
}
int rand = random.Next(upRange + downRange);
bool executeUpper;
if (upRange > downRange)
executeUpper = rand > upRange;
else
executeUpper = rand < downRange;
Order theOrder;
double thePrice;
if (executeUpper)
{
theOrder = orderHigher;
thePrice = priceHigher;
}
else
{
theOrder = orderLower;
thePrice = priceLower;
}
current = thePrice;
ExecOrd(bar, theOrder, thePrice, eval);
}
else
{
// Execute or exit the bar
if (isHigherPrice)
{
var upRange = (int) Math.Round((priceHigher - current)/InstrProperties.Point);
var downRange = (int) Math.Round((close - current)/InstrProperties.Point);
upRange = upRange < 0 ? 0 : upRange;
downRange = downRange < 0 ? 0 : downRange;
if (downRange + downRange == 0)
{
upRange = 1;
downRange = 0;
}
int rand = random.Next(upRange + downRange);
if (rand > upRange)
{
// Execute the order
current = priceHigher;
ExecOrd(bar, orderHigher, priceHigher, eval);
}
else
{
// Exit the bar
current = close;
orderHigher.OrdStatus = OrderStatus.Cancelled;
session[bar].BacktestEval = BacktestEval.Ambiguous;
}
}
else if (isLowerPrice)
{
// The priceLower or Exit the bar
var upRange = (int) Math.Round((current - close)/InstrProperties.Point);
var downRange = (int) Math.Round((current - priceLower)/InstrProperties.Point);
upRange = upRange < 0 ? 0 : upRange;
downRange = downRange < 0 ? 0 : downRange;
if (downRange + downRange == 0)
{
upRange = 0;
downRange = 1;
}
int rand = random.Next(upRange + downRange);
if (rand > downRange)
{
// Execute the order
current = priceLower;
ExecOrd(bar, orderLower, priceLower, eval);
}
else
{
// Exit the bar
current = close;
orderLower.OrdStatus = OrderStatus.Cancelled;
session[bar].BacktestEval = BacktestEval.Ambiguous;
}
}
}
}
}
/// <summary>
/// Optimistic / Pessimistic Method
/// </summary>
private static void OptimisticPessimisticMethod(int bar, BacktestEval eval, ref double current,
bool isTopReachable, bool isBottomReachable,
bool isHigherPrice, bool isLowerPrice,
double priceHigher, double priceLower,
Order orderHigher, Order orderLower,
bool isClosingAmbiguity)
{
double open = Open[bar];
double high = High[bar];
double low = Low[bar];
double close = Close[bar];
bool isOptimistic = InterpolationMethod == InterpolationMethod.Optimistic;
if (eval == BacktestEval.None)
{
// There is no more orders
if (!session[bar].IsTopReached && !session[bar].IsBottomReached)
{
// Neither the top nor the bottom was reached
if (close < open)
{
// Hit the Top
current = high;
session[bar].SetWayPoint(high, WayPointType.High);
session[bar].IsTopReached = true;
}
else
{
// Hit the Bottom
current = low;
session[bar].SetWayPoint(low, WayPointType.Low);
session[bar].IsBottomReached = true;
}
}
else if (!session[bar].IsTopReached)
{
// Hit the Top
current = high;
session[bar].SetWayPoint(high, WayPointType.High);
session[bar].IsTopReached = true;
}
else if (!session[bar].IsBottomReached)
{
// Hit the Bottom
current = low;
session[bar].SetWayPoint(low, WayPointType.Low);
session[bar].IsBottomReached = true;
}
}
if (eval == BacktestEval.Correct)
{
// Hit the order or the top/bottom
var theOrder = new Order();
double thePrice = 0;
if (isHigherPrice)
{
theOrder = orderHigher;
thePrice = priceHigher;
}
else if (isLowerPrice)
{
theOrder = orderLower;
thePrice = priceLower;
}
if (!session[bar].IsBottomReached && isBottomReachable)
{
// The order or the bottom
bool goUpward;
if (current < low + sigma)
goUpward = false;
else if (thePrice - current < sigma)
goUpward = true;
else if (theOrder.OrdDir == OrderDirection.Buy)
goUpward = !isOptimistic;
else if (theOrder.OrdDir == OrderDirection.Sell)
goUpward = isOptimistic;
else
goUpward = thePrice - current < current - low;
if (goUpward)
{
// Execute order
current = thePrice;
ExecOrd(bar, theOrder, thePrice, eval);
}
else
{
// Hit the Bottom
current = low;
session[bar].SetWayPoint(low, WayPointType.Low);
session[bar].IsBottomReached = true;
}
}
else if (!session[bar].IsTopReached && isTopReachable)
{
// The order or the top
bool goUpward;
if (current > high - sigma)
goUpward = true;
else if (current - thePrice < sigma)
goUpward = false;
else if (theOrder.OrdDir == OrderDirection.Buy)
goUpward = !isOptimistic;
else if (theOrder.OrdDir == OrderDirection.Sell)
goUpward = isOptimistic;
else
goUpward = high - current < current - thePrice;
if (goUpward)
{
// Hit the Top
current = high;
session[bar].SetWayPoint(high, WayPointType.High);
session[bar].IsTopReached = true;
}
else
{
// Execute order
current = thePrice;
ExecOrd(bar, theOrder, thePrice, eval);
}
}
else
{
// Execute the order
current = thePrice;
ExecOrd(bar, theOrder, thePrice, eval);
}
}
else if (eval == BacktestEval.Ambiguous)
{
// Ambiguous - two orders or order and bar closing
if (!isClosingAmbiguity)
{
// Execute one of both orders
bool executeUpper;
if (priceHigher - current < sigma)
executeUpper = true;
else if (current - priceLower < sigma)
executeUpper = false;
else if (session[bar].Summary.PosDir == PosDirection.Long)
executeUpper = isOptimistic;
else if (session[bar].Summary.PosDir == PosDirection.Short)
executeUpper = !isOptimistic;
else
{
if (orderHigher.OrdDir == OrderDirection.Buy && orderLower.OrdDir == OrderDirection.Buy)
executeUpper = !isOptimistic;
else if (orderHigher.OrdDir == OrderDirection.Sell && orderLower.OrdDir == OrderDirection.Sell)
executeUpper = isOptimistic;
else if (orderHigher.OrdDir == OrderDirection.Buy && orderLower.OrdDir == OrderDirection.Sell)
{
if (current < close)
executeUpper = isOptimistic;
else
executeUpper = !isOptimistic;
if (Strategy.OppSignalAction == OppositeDirSignalAction.Reverse)
executeUpper = !executeUpper;
}
else
{
if (current < close)
executeUpper = !isOptimistic;
else
executeUpper = isOptimistic;
if (Strategy.OppSignalAction == OppositeDirSignalAction.Reverse)
executeUpper = !executeUpper;
}
}
Order theOrder;
double thePrice;
if (executeUpper)
{
theOrder = orderHigher;
thePrice = priceHigher;
}
else
{
theOrder = orderLower;
thePrice = priceLower;
}
current = thePrice;
ExecOrd(bar, theOrder, thePrice, eval);
}
else
{
// Execute or exit the bar
if (isHigherPrice)
{
bool toExecute = false;
if (session[bar].Summary.PosDir == PosDirection.Long)
toExecute = isOptimistic;
else if (session[bar].Summary.PosDir == PosDirection.Short)
toExecute = !isOptimistic;
else if (orderHigher.OrdDir == OrderDirection.Buy)
toExecute = !isOptimistic;
else if (orderHigher.OrdDir == OrderDirection.Sell)
toExecute = isOptimistic;
if (toExecute)
{
// Execute
current = priceHigher;
ExecOrd(bar, orderHigher, priceHigher, eval);
}
else
{
// Exit the bar
current = close;
orderHigher.OrdStatus = OrderStatus.Cancelled;
session[bar].BacktestEval = BacktestEval.Ambiguous;
}
}
else if (isLowerPrice)
{
// The priceLower or Exit the bar
bool toExecute = false;
if (session[bar].Summary.PosDir == PosDirection.Long)
toExecute = !isOptimistic;
else if (session[bar].Summary.PosDir == PosDirection.Short)
toExecute = isOptimistic;
else if (orderLower.OrdDir == OrderDirection.Buy)
toExecute = isOptimistic;
else if (orderLower.OrdDir == OrderDirection.Sell)
toExecute = !isOptimistic;
if (toExecute)
{
// Execute
current = priceLower;
ExecOrd(bar, orderLower, priceLower, eval);
}
else
{
// Exit the bar
current = close;
orderLower.OrdStatus = OrderStatus.Cancelled;
session[bar].BacktestEval = BacktestEval.Ambiguous;
}
}
}
}
}
/// <summary>
/// Tick Scanning
/// </summary>
private static bool TickScanning(int bar, BacktestEval eval,
ref double current, ref int reachedTick,
bool isTopReachable, bool isBottomReachable,
bool isHigherPrice, bool isLowerPrice,
double priceHigher, double priceLower,
Order orderHigher, Order orderLower,
bool isClosingAmbiguity)
{
double high = High[bar];
double low = Low[bar];
double close = Close[bar];
bool isScanningResult = false;
if (eval == BacktestEval.None)
{
// There isn't any orders
if (!session[bar].IsTopReached && !session[bar].IsBottomReached)
{
// Neither the top nor the bottom was reached
int tickCount = TickData[bar].Length;
for (int tick = reachedTick; tick < tickCount; tick++)
{
reachedTick = tick;
if (TickData[bar][tick] + sigma > high)
{
// Top found
current = high;
session[bar].SetWayPoint(high, WayPointType.High);
session[bar].IsTopReached = true;
isScanningResult = true;
break;
}
if (TickData[bar][tick] - sigma < low)
{
// Bottom found
current = low;
session[bar].SetWayPoint(low, WayPointType.Low);
session[bar].IsBottomReached = true;
isScanningResult = true;
break;
}
}
}
else if (!session[bar].IsTopReached)
{
// Whether hit the Top
int tickCount = TickData[bar].Length;
for (int tick = reachedTick; tick < tickCount; tick++)
{
reachedTick = tick;
if (TickData[bar][tick] + sigma > high)
{
// Top found
current = high;
session[bar].SetWayPoint(high, WayPointType.High);
session[bar].IsTopReached = true;
isScanningResult = true;
break;
}
}
}
else if (!session[bar].IsBottomReached)
{
// Whether hit the Bottom
int tickCount = TickData[bar].Length;
for (int tick = reachedTick; tick < tickCount; tick++)
{
reachedTick = tick;
if (TickData[bar][tick] - sigma < low)
{
// Bottom found
current = low;
session[bar].SetWayPoint(low, WayPointType.Low);
session[bar].IsBottomReached = true;
isScanningResult = true;
break;
}
}
}
}
if (eval == BacktestEval.Correct)
{
// Hit the order or the top / bottom
Order theOrder = null;
double thePrice = 0;
if (isHigherPrice)
{
theOrder = orderHigher;
thePrice = priceHigher;
}
else if (isLowerPrice)
{
theOrder = orderLower;
thePrice = priceLower;
}
if (!session[bar].IsBottomReached && isBottomReachable)
{
// The order or the Bottom
int tickCount = TickData[bar].Length;
for (int tick = reachedTick; tick < tickCount; tick++)
{
reachedTick = tick;
if (TickData[bar][tick] + sigma > thePrice)
{
// The order is reached
current = thePrice;
ExecOrd(bar, theOrder, thePrice, BacktestEval.Correct);
isScanningResult = true;
break;
}
if (TickData[bar][tick] - sigma < low)
{
// Bottom is reached
current = low;
session[bar].SetWayPoint(low, WayPointType.Low);
session[bar].IsBottomReached = true;
isScanningResult = true;
break;
}
}
}
else if (!session[bar].IsTopReached && isTopReachable)
{
// The order or the Top
int tickCount = TickData[bar].Length;
for (int tick = reachedTick; tick < tickCount; tick++)
{
reachedTick = tick;
if (TickData[bar][tick] + sigma > high)
{
// The Top is reached
current = high;
session[bar].SetWayPoint(high, WayPointType.High);
session[bar].IsTopReached = true;
isScanningResult = true;
break;
}
if (TickData[bar][tick] - sigma < thePrice)
{
// The order is reached
current = thePrice;
ExecOrd(bar, theOrder, thePrice, BacktestEval.Correct);
isScanningResult = true;
break;
}
}
}
else
{
// Execute the order
double priceOld = TickData[bar][reachedTick];
int tickCount = TickData[bar].Length;
for (int tick = reachedTick; tick < tickCount; tick++)
{
reachedTick = tick;
if (priceOld - sigma < thePrice && TickData[bar][tick] + sigma > thePrice ||
priceOld + sigma > thePrice && TickData[bar][tick] - sigma < thePrice)
{
// Order reached
current = thePrice;
ExecOrd(bar, theOrder, thePrice, BacktestEval.Correct);
isScanningResult = true;
break;
}
}
}
}
else if (eval == BacktestEval.Ambiguous)
{
// Ambiguous - two orders or order and bar closing
if (!isClosingAmbiguity)
{
// Execute the the first reached order
int tickCount = TickData[bar].Length;
for (int tick = reachedTick; tick < tickCount; tick++)
{
reachedTick = tick;
if (TickData[bar][tick] + sigma > priceHigher)
{
// Upper order is reached
current = priceHigher;
ExecOrd(bar, orderHigher, priceHigher, BacktestEval.Correct);
isScanningResult = true;
break;
}
if (TickData[bar][tick] - sigma < priceLower)
{
// Lower order is reached
current = priceLower;
ExecOrd(bar, orderLower, priceLower, BacktestEval.Correct);
isScanningResult = true;
break;
}
}
}
else
{
// Execute or exit the bar
var theOrder = new Order();
double thePrice = 0.0;
if (isHigherPrice)
{
theOrder = orderHigher;
thePrice = priceHigher;
}
else if (isLowerPrice)
{
theOrder = orderLower;
thePrice = priceLower;
}
bool executeOrder = false;
if (isHigherPrice)
{
int tickCount = TickData[bar].Length;
for (int tick = reachedTick; tick < tickCount; tick++)
{
reachedTick = tick;
if (TickData[bar][tick] + sigma > thePrice)
{
// The order is reached
executeOrder = true;
break;
}
}
}
else if (isLowerPrice)
{
// The priceLower or Exit the bar
int tickCount = TickData[bar].Length;
for (int tick = reachedTick; tick < tickCount; tick++)
{
reachedTick = tick;
if (TickData[bar][tick] - sigma < thePrice)
{
// The order is reached
executeOrder = true;
break;
}
}
}
if (executeOrder)
{
// Execute the order
current = thePrice;
ExecOrd(bar, theOrder, thePrice, BacktestEval.Correct);
}
else
{
// Exit the bar
current = close;
theOrder.OrdStatus = OrderStatus.Cancelled;
session[bar].BacktestEval = BacktestEval.Correct;
}
isScanningResult = true;
}
}
return isScanningResult;
}
/// <summary>
/// Shortest route inside the bar Method
/// </summary>
private static void ShortestMethod(int bar, BacktestEval eval, ref double current,
bool isTopReachable, bool isBottomReachable,
bool isHigherPrice, bool isLowerPrice,
double priceHigher, double priceLower,
Order orderHigher, Order orderLower,
bool isClosingAmbiguity)
{
double open = Open[bar];
double high = High[bar];
double low = Low[bar];
double close = Close[bar];
bool isGoUpward;
if (!session[bar].IsTopReached && !session[bar].IsBottomReached)
isGoUpward = open > close;
else if (session[bar].IsTopReached && !session[bar].IsBottomReached)
isGoUpward = false;
else if (!session[bar].IsTopReached && session[bar].IsBottomReached)
isGoUpward = true;
else
isGoUpward = open > close;
if (isLowerPrice && current - priceLower < sigma)
isGoUpward = false;
if (isHigherPrice && priceHigher - current < sigma)
isGoUpward = true;
if (eval == BacktestEval.None)
{
// There is no more orders
if (!session[bar].IsTopReached && !session[bar].IsBottomReached)
{
// Neither the top nor the bottom was reached
if (isGoUpward)
{
// Hit the Top
current = high;
session[bar].SetWayPoint(high, WayPointType.High);
session[bar].IsTopReached = true;
}
else
{
// Hit the Bottom
current = low;
session[bar].SetWayPoint(low, WayPointType.Low);
session[bar].IsBottomReached = true;
}
}
else if (!session[bar].IsTopReached)
{
// Hit the Top
current = high;
session[bar].SetWayPoint(high, WayPointType.High);
session[bar].IsTopReached = true;
}
else if (!session[bar].IsBottomReached)
{
// Hit the Bottom
current = low;
session[bar].SetWayPoint(low, WayPointType.Low);
session[bar].IsBottomReached = true;
}
}
if (eval == BacktestEval.Correct)
{
// Hit the top/bottom or execute
Order theOrder = null;
double thePrice = 0;
if (isHigherPrice)
{
theOrder = orderHigher;
thePrice = priceHigher;
}
else if (isLowerPrice)
{
theOrder = orderLower;
thePrice = priceLower;
}
if (!session[bar].IsBottomReached && isBottomReachable && !isGoUpward)
{
// Hit the Bottom
current = low;
session[bar].SetWayPoint(low, WayPointType.Low);
session[bar].IsBottomReached = true;
}
else if (!session[bar].IsTopReached && isTopReachable && isGoUpward)
{
// Hit the Top
current = high;
session[bar].SetWayPoint(high, WayPointType.High);
session[bar].IsTopReached = true;
}
else
{
// Execute the order
current = thePrice;
ExecOrd(bar, theOrder, thePrice, eval);
}
}
else if (eval == BacktestEval.Ambiguous)
{
// Ambiguous - two orders or order and bar closing
if (!isClosingAmbiguity)
{
// Execute the nearest order
Order theOrder;
double thePrice;
if (isGoUpward)
{
theOrder = orderHigher;
thePrice = priceHigher;
}
else
{
theOrder = orderLower;
thePrice = priceLower;
}
current = thePrice;
ExecOrd(bar, theOrder, thePrice, eval);
}
else
{
// Exit the bar
current = close;
session[bar].BacktestEval = BacktestEval.Ambiguous;
if (isHigherPrice)
orderHigher.OrdStatus = OrderStatus.Cancelled;
else if (isLowerPrice)
orderLower.OrdStatus = OrderStatus.Cancelled;
}
}
}
/// <summary>
/// Nearest order first Method
/// </summary>
private static void NearestMethod(int bar, BacktestEval eval, ref double current,
bool isTopReachable, bool isBottomReachable,
bool isHigherPrice, bool isLowerPrice,
double priceHigher, double priceLower,
Order orderHigher, Order orderLower,
bool isClosingAmbiguity)
{
double open = Open[bar];
double high = High[bar];
double low = Low[bar];
double close = Close[bar];
if (eval == BacktestEval.None)
{
// There is no more orders
if (!session[bar].IsTopReached && !session[bar].IsBottomReached)
{
// Neither the top nor the bottom was reached
if (close < open)
{
// Hit the Top
current = high;
session[bar].SetWayPoint(high, WayPointType.High);
session[bar].IsTopReached = true;
}
else
{
// Hit the Bottom
current = low;
session[bar].SetWayPoint(low, WayPointType.Low);
session[bar].IsBottomReached = true;
}
}
else if (!session[bar].IsTopReached)
{
// Hit the Top
current = high;
session[bar].SetWayPoint(high, WayPointType.High);
session[bar].IsTopReached = true;
}
else if (!session[bar].IsBottomReached)
{
// Hit the Bottom
current = low;
session[bar].SetWayPoint(low, WayPointType.Low);
session[bar].IsBottomReached = true;
}
}
if (eval == BacktestEval.Correct)
{
// Hit the order or the top/bottom
Order theOrder = null;
double thePrice = 0;
if (isHigherPrice)
{
theOrder = orderHigher;
thePrice = priceHigher;
}
else if (isLowerPrice)
{
theOrder = orderLower;
thePrice = priceLower;
}
if (!session[bar].IsBottomReached && isBottomReachable)
{
// The order or the bottom
double upRange = thePrice - current;
double downRange = current - low;
if (upRange < downRange)
{
// Execute
current = thePrice;
ExecOrd(bar, theOrder, thePrice, eval);
}
else
{
// Hit the Bottom
current = low;
session[bar].SetWayPoint(low, WayPointType.Low);
session[bar].IsBottomReached = true;
}
}
else if (!session[bar].IsTopReached && isTopReachable)
{
// The order or the bottom
double upRange = high - current;
double downRange = current - thePrice;
if (upRange < downRange)
{
// Hit the Top
current = high;
session[bar].SetWayPoint(high, WayPointType.High);
session[bar].IsTopReached = true;
}
else
{
// Execute
current = thePrice;
ExecOrd(bar, theOrder, thePrice, eval);
}
}
else
{
// Execute the order
current = thePrice;
ExecOrd(bar, theOrder, thePrice, eval);
}
}
else if (eval == BacktestEval.Ambiguous)
{
// Ambiguous - two orders or order and bar closing
if (!isClosingAmbiguity)
{
// Execute the nearest order
double upRange = priceHigher - current;
double downRange = current - priceLower;
Order theOrder;
double thePrice;
if (upRange < downRange)
{
theOrder = orderHigher;
thePrice = priceHigher;
}
else
{
theOrder = orderLower;
thePrice = priceLower;
}
current = thePrice;
ExecOrd(bar, theOrder, thePrice, eval);
}
else
{
// Exit the bar
double orderRange = isHigherPrice ? priceHigher - current : current - priceLower;
double closeRange = Math.Abs(current - close);
if (orderRange < closeRange)
{
// Execute the order
Order theOrder;
double thePrice;
if (isHigherPrice)
{
theOrder = orderHigher;
thePrice = priceHigher;
}
else
{
theOrder = orderLower;
thePrice = priceLower;
}
current = thePrice;
ExecOrd(bar, theOrder, thePrice, eval);
}
else
{
// Cancel the order, go to Close
current = close;
session[bar].BacktestEval = BacktestEval.Ambiguous;
if (isHigherPrice)
orderHigher.OrdStatus = OrderStatus.Cancelled;
else if (isLowerPrice)
orderLower.OrdStatus = OrderStatus.Cancelled;
}
}
}
}
/// <summary>
/// Makes a deep copy.
/// </summary>
public Order Copy()
{
var order = new Order
{
OrdDir = OrdDir,
OrdType = OrdType,
OrdCond = OrdCond,
OrdStatus = OrdStatus,
OrdSender = OrdSender,
OrdOrigin = OrdOrigin,
OrdNumb = OrdNumb,
OrdIf = OrdIf,
OrdPos = OrdPos,
OrdLots = OrdLots,
OrdPrice = OrdPrice,
OrdPrice2 = OrdPrice2,
OrdNote = OrdNote
};
return order;
}
/// <summary>
/// Finds and cancels the exit order of an entry order
/// </summary>
private static void FindCancelExitOrder(int bar, Order order)
{
for (int ord = 0; ord < session[bar].Orders; ord++)
if (session[bar].Order[ord].OrdIf == order.OrdNumb)
{
session[bar].Order[ord].OrdStatus = OrderStatus.Cancelled;
break;
}
}
/// <summary>
/// Tunes and Executes an order
/// </summary>
private static void ExecOrd(int bar, Order order, double price, BacktestEval testEval)
{
Position position = session[bar].Summary;
PosDirection posDir = position.PosDir;
OrderDirection ordDir = order.OrdDir;
var wayPointType = WayPointType.None;
// Orders modification on a fly
// Checks whether we are on the market
if (posDir == PosDirection.Long || posDir == PosDirection.Short)
{
// We are on the market
if (order.OrdSender == OrderSender.Open)
{
// Entry orders
if (ordDir == OrderDirection.Buy && posDir == PosDirection.Long ||
ordDir == OrderDirection.Sell && posDir == PosDirection.Short)
{
// In case of a Same Dir Signal
switch (Strategy.SameSignalAction)
{
case SameDirSignalAction.Add:
order.OrdLots = TradingSize(Strategy.AddingLots, bar);
if (position.PosLots + TradingSize(Strategy.AddingLots, bar) <= maximumLots)
{
// Adding
wayPointType = WayPointType.Add;
}
else
{
// Cancel the Adding
order.OrdStatus = OrderStatus.Cancelled;
wayPointType = WayPointType.Cancel;
FindCancelExitOrder(bar, order); // Canceling of its exit order
}
break;
case SameDirSignalAction.Winner:
order.OrdLots = TradingSize(Strategy.AddingLots, bar);
if (position.PosLots + TradingSize(Strategy.AddingLots, bar) <= maximumLots &&
(position.PosDir == PosDirection.Long && position.PosPrice < order.OrdPrice ||
position.PosDir == PosDirection.Short && position.PosPrice > order.OrdPrice))
{
// Adding
wayPointType = WayPointType.Add;
}
else
{
// Cancel the Adding
order.OrdStatus = OrderStatus.Cancelled;
wayPointType = WayPointType.Cancel;
FindCancelExitOrder(bar, order); // Canceling of its exit order
}
break;
case SameDirSignalAction.Nothing:
order.OrdLots = TradingSize(Strategy.AddingLots, bar);
order.OrdStatus = OrderStatus.Cancelled;
wayPointType = WayPointType.Cancel;
FindCancelExitOrder(bar, order); // Canceling of its exit order
break;
}
}
else if (ordDir == OrderDirection.Buy && posDir == PosDirection.Short ||
ordDir == OrderDirection.Sell && posDir == PosDirection.Long)
{
// In case of an Opposite Dir Signal
switch (Strategy.OppSignalAction)
{
case OppositeDirSignalAction.Reduce:
if (position.PosLots > TradingSize(Strategy.ReducingLots, bar))
{
// Reducing
order.OrdLots = TradingSize(Strategy.ReducingLots, bar);
wayPointType = WayPointType.Reduce;
}
else
{
// Closing
order.OrdLots = position.PosLots;
wayPointType = WayPointType.Exit;
}
break;
case OppositeDirSignalAction.Close:
order.OrdLots = position.PosLots;
wayPointType = WayPointType.Exit;
break;
case OppositeDirSignalAction.Reverse:
order.OrdLots = position.PosLots + TradingSize(Strategy.EntryLots, bar);
wayPointType = WayPointType.Reverse;
break;
case OppositeDirSignalAction.Nothing:
order.OrdStatus = OrderStatus.Cancelled;
wayPointType = WayPointType.Cancel;
FindCancelExitOrder(bar, order); // Canceling of its exit order
break;
}
}
}
else
{
// Exit orders
if (ordDir == OrderDirection.Buy && posDir == PosDirection.Short ||
ordDir == OrderDirection.Sell && posDir == PosDirection.Long)
{
// Check for Break Even Activation
if (order.OrdOrigin == OrderOrigin.BreakEvenActivation)
{
// This is a fictive order
order.OrdStatus = OrderStatus.Cancelled;
wayPointType = WayPointType.Cancel;
}
else
{
// The Close orders can only close the position
order.OrdLots = position.PosLots;
wayPointType = WayPointType.Exit;
}
}
else
{
// If the direction of the exit order is same as the position's direction
// the order have to be cancelled
order.OrdStatus = OrderStatus.Cancelled;
wayPointType = WayPointType.Cancel;
}
}
}
else
{
// We are out of the market
if (order.OrdSender == OrderSender.Open)
{
// Open a new position
double entryAmount = TradingSize(Strategy.EntryLots, bar);
if (Strategy.UseMartingale && consecutiveLosses > 0)
{
entryAmount = entryAmount*Math.Pow(Strategy.MartingaleMultiplier, consecutiveLosses);
entryAmount = NormalizeEntryLots(entryAmount);
}
order.OrdLots = Math.Min(entryAmount, maximumLots);
wayPointType = WayPointType.Entry;
}
else // if (order.OrdSender == OrderSender.Close)
{
// The Close strategy cannot do anything
order.OrdStatus = OrderStatus.Cancelled;
wayPointType = WayPointType.Cancel;
}
}
// Enter Once can cancel an entry order
if (hasEnterOnce && order.OrdSender == OrderSender.Open && order.OrdStatus == OrderStatus.Confirmed)
{
bool toCancel = false;
switch (Strategy.Slot[slotEnterOnce].IndParam.ListParam[0].Text)
{
case "Enter no more than once a bar":
toCancel = Time[bar] == lastEntryTime;
break;
case "Enter no more than once a day":
toCancel = Time[bar].DayOfYear == lastEntryTime.DayOfYear;
break;
case "Enter no more than once a week":
int lastEntryWeek = CultureInfo.CurrentCulture.Calendar.GetWeekOfYear(
lastEntryTime, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
int currentWeek = CultureInfo.CurrentCulture.Calendar.GetWeekOfYear(
Time[bar], CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
toCancel = lastEntryWeek == currentWeek;
break;
case "Enter no more than once a month":
toCancel = Time[bar].Month == lastEntryTime.Month;
break;
}
if (toCancel)
{
// Cancel the entry order
order.OrdStatus = OrderStatus.Cancelled;
wayPointType = WayPointType.Cancel;
FindCancelExitOrder(bar, order); // Canceling of its exit order
}
else
lastEntryTime = Time[bar];
}
// Do not trade after Margin Call or after -1000000 Loss
if (order.OrdSender == OrderSender.Open && order.OrdStatus == OrderStatus.Confirmed)
{
if (position.FreeMargin < -1000000 ||
Configs.TradeUntilMarginCall && RequiredMargin(order.OrdLots, bar) > position.FreeMargin)
{
// Cancel the entry order
order.OrdStatus = OrderStatus.Cancelled;
wayPointType = WayPointType.Cancel;
FindCancelExitOrder(bar, order); // Canceling of its exit order
}
}
// Executing the order
if (order.OrdStatus == OrderStatus.Confirmed)
{
// Executes the order
SetPosition(bar, ordDir, order.OrdLots, price, order.OrdNumb);
order.OrdStatus = OrderStatus.Executed;
// Set the evaluation
switch (testEval)
{
case BacktestEval.Error:
session[bar].BacktestEval = BacktestEval.Error;
break;
case BacktestEval.None:
break;
case BacktestEval.Ambiguous:
session[bar].BacktestEval = BacktestEval.Ambiguous;
break;
case BacktestEval.Unknown:
if (session[bar].BacktestEval != BacktestEval.Ambiguous)
session[bar].BacktestEval = BacktestEval.Unknown;
break;
case BacktestEval.Correct:
if (session[bar].BacktestEval == BacktestEval.None)
session[bar].BacktestEval = BacktestEval.Correct;
break;
}
// If entry order closes or reverses the position the exit orders of the
// initial position have to be cancelled
if (order.OrdSender == OrderSender.Open &&
(session[bar].Summary.Transaction == Transaction.Close ||
session[bar].Summary.Transaction == Transaction.Reverse))
{
int initialNumber = session[bar].Position[session[bar].Positions - 2].FormOrdNumb;
// If the position was opened during the current bar, we can find its exit order
bool isFound = false;
for (int ord = 0; ord < session[bar].Orders; ord++)
{
if (session[bar].Order[ord].OrdIf == initialNumber &&
session[bar].Order[ord].OrdSender == OrderSender.Close)
{
session[bar].Order[ord].OrdStatus = OrderStatus.Cancelled;
isFound = true;
break;
}
}
// In case when the order is not found, this means that the position is transferred
// so its exit order is not conditional
if (!isFound)
{
for (int ord = 0; ord < session[bar].Orders; ord++)
{
if (session[bar].Order[ord].OrdSender == OrderSender.Close &&
session[bar].Order[ord].OrdIf == 0)
{
session[bar].Order[ord].OrdStatus = OrderStatus.Cancelled;
break;
}
}
}
// Setting the exit order of the current position
switch (session[bar].Summary.Transaction)
{
case Transaction.Close:
{
// In case of closing we have to cancel the exit order
int number = session[bar].Summary.FormOrdNumb;
for (int ord = 0; ord < session[bar].Orders; ord++)
{
if (session[bar].Order[ord].OrdIf != number) continue;
session[bar].Order[ord].OrdStatus = OrderStatus.Cancelled;
break;
}
}
break;
case Transaction.Reduce:
{
// In case of reducing we have to change the direction of the exit order
int number = session[bar].Summary.FormOrdNumb;
for (int ord = 0; ord < session[bar].Orders; ord++)
{
if (session[bar].Order[ord].OrdIf != number) continue;
session[bar].Order[ord].OrdDir = session[bar].Summary.PosDir == PosDirection.Long
? OrderDirection.Sell
: OrderDirection.Buy;
break;
}
}
break;
}
}
}
session[bar].SetWayPoint(price, wayPointType);
if (order.OrdStatus == OrderStatus.Cancelled)
{
session[bar].WayPoint[session[bar].WayPoints - 1].OrdNumb = order.OrdNumb;
}
}