public void Operate()
{
ITradingRecord record = new BaseTradingRecord();
record.Operate(1);
Assert.IsTrue(record.GetCurrentTrade().IsOpened());
Assert.AreEqual(0, record.GetTradeCount());
Assert.IsNull(record.GetLastTrade());
Assert.AreEqual(Order.buyAt(1, Decimals.NaN, Decimals.NaN), record.GetLastOrder());
Assert.AreEqual(Order.buyAt(1, Decimals.NaN, Decimals.NaN), record.GetLastOrder(OrderType.BUY));
Assert.IsNull(record.GetLastOrder(OrderType.SELL));
Assert.AreEqual(Order.buyAt(1, Decimals.NaN, Decimals.NaN), record.GetLastEntry());
Assert.IsNull(record.GetLastExit());
record.Operate(3);
Assert.IsTrue(record.GetCurrentTrade().IsNew());
Assert.AreEqual(1, record.GetTradeCount());
Assert.AreEqual(new Trade(Order.buyAt(1, Decimals.NaN, Decimals.NaN), Order.sellAt(3, Decimals.NaN, Decimals.NaN)), record.GetLastTrade());
Assert.AreEqual(Order.sellAt(3, Decimals.NaN, Decimals.NaN), record.GetLastOrder());
Assert.AreEqual(Order.buyAt(1, Decimals.NaN, Decimals.NaN), record.GetLastOrder(OrderType.BUY));
Assert.AreEqual(Order.sellAt(3, Decimals.NaN, Decimals.NaN), record.GetLastOrder(OrderType.SELL));
Assert.AreEqual(Order.buyAt(1, Decimals.NaN, Decimals.NaN), record.GetLastEntry());
Assert.AreEqual(Order.sellAt(3, Decimals.NaN, Decimals.NaN), record.GetLastExit());
record.Operate(5);
Assert.IsTrue(record.GetCurrentTrade().IsOpened());
Assert.AreEqual(1, record.GetTradeCount());
Assert.AreEqual(new Trade(Order.buyAt(1, Decimals.NaN, Decimals.NaN), Order.sellAt(3, Decimals.NaN, Decimals.NaN)), record.GetLastTrade());
Assert.AreEqual(Order.buyAt(5, Decimals.NaN, Decimals.NaN), record.GetLastOrder());
Assert.AreEqual(Order.buyAt(5, Decimals.NaN, Decimals.NaN), record.GetLastOrder(OrderType.BUY));
Assert.AreEqual(Order.sellAt(3, Decimals.NaN, Decimals.NaN), record.GetLastOrder(OrderType.SELL));
Assert.AreEqual(Order.buyAt(5, Decimals.NaN, Decimals.NaN), record.GetLastEntry());
Assert.AreEqual(Order.sellAt(3, Decimals.NaN, Decimals.NaN), record.GetLastExit());
}
public void CalculateWithASimpleTrade()
{
series = new MockTimeSeries(100M, 105M, 110M, 100M, 95M, 105M);
ITradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(2, series));
AbstractAnalysisCriterion averageProfit = new AverageProfitCriterion();
Assert.AreEqual(1.0322801154563671592135852251M, averageProfit.Calculate(series, tradingRecord)); // (decimal)Math.Pow(110d / 100, 1d / 3)
}
public void RewardRiskRatioCriterionOnlyWithGain()
{
MockTimeSeries series = new MockTimeSeries(1, 2, 3, 6, 8, 20, 3);
ITradingRecord tradingRecord = new BaseTradingRecord(
Order.buyAt(0, series), Order.sellAt(1, series),
Order.buyAt(2, series), Order.sellAt(5, series));
Assert.AreEqual(Decimals.NaN, rrc.Calculate(series, tradingRecord));
}
public void reallyLongCashFlow()
{
int size = 1000000;
ITimeSeries sampleTimeSeries = new MockTimeSeries(Enumerable.Range(0, size).Select(_ => new MockBar(10)).Cast <IBar>().ToList());
ITradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, sampleTimeSeries), Order.sellAt(size - 1, sampleTimeSeries));
CashFlow cashFlow = new CashFlow(sampleTimeSeries, tradingRecord);
Assert.AreEqual(cashFlow.GetValue(size - 1), 1);
}
public override decimal Calculate(ITimeSeries series, Trade trade)
{
ITradingRecord fakeRecord = new BaseTradingRecord();
fakeRecord.Enter(series.GetBeginIndex());
fakeRecord.Exit(series.GetEndIndex());
return(_criterion.Calculate(series, trade) / _criterion.Calculate(series, fakeRecord));
}
public void cashFlowBuyWithOnlyOneTrade()
{
ITimeSeries sampleTimeSeries = new MockTimeSeries(1, 2);
ITradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, sampleTimeSeries), Order.sellAt(1, sampleTimeSeries));
CashFlow cashFlow = new CashFlow(sampleTimeSeries, tradingRecord);
Assert.AreEqual(cashFlow.GetValue(0), 1);
Assert.AreEqual(cashFlow.GetValue(1), 2);
}
public void CalculateWithOnlyGains()
{
MockTimeSeries series = new MockTimeSeries(1, 2, 3, 6, 8, 20, 3);
MaximumDrawdownCriterion mdd = new MaximumDrawdownCriterion();
ITradingRecord tradingRecord = new BaseTradingRecord(
Order.buyAt(0, series), Order.sellAt(1, series),
Order.buyAt(2, series), Order.sellAt(5, series));
Assert.AreEqual(0M, mdd.Calculate(series, tradingRecord));
}
public void CalculateOnlyWithLossTrades()
{
series = new MockTimeSeries(100, 95, 100, 80, 85, 70);
ITradingRecord tradingRecord = new BaseTradingRecord(
Order.buyAt(0, series), Order.sellAt(1, series),
Order.buyAt(2, series), Order.sellAt(5, series));
AbstractAnalysisCriterion averageProfit = new AverageProfitCriterion();
Assert.AreEqual(0.934265419203025064794086149M, averageProfit.Calculate(series, tradingRecord)); // (decimal)Math.Pow(95d / 100 * 70d / 100, 1d / 6)
}
public void CalculateOnlyWithGainTrades()
{
series = new MockTimeSeries(100M, 105M, 110M, 100M, 95M, 105M);
ITradingRecord tradingRecord = new BaseTradingRecord(
Order.buyAt(0, series), Order.sellAt(2, series),
Order.buyAt(3, series), Order.sellAt(5, series));
AbstractAnalysisCriterion averageProfit = new AverageProfitCriterion();
Assert.AreEqual(1.0243074482606615553441174081M, averageProfit.Calculate(series, tradingRecord));
}
public void CalculateWithNumberOfBars()
{
MockTimeSeries series = new MockTimeSeries(100, 95, 100, 80, 85, 130);
ITradingRecord tradingRecord = new BaseTradingRecord(
Order.buyAt(0, series), Order.sellAt(1, series),
Order.buyAt(2, series), Order.sellAt(5, series));
AbstractAnalysisCriterion buyAndHold = new VersusBuyAndHoldCriterion(new NumberOfBarsCriterion());
Assert.AreEqual(6M / 6M, buyAndHold.Calculate(series, tradingRecord));
}
public void CalculateWithAverageProfit()
{
MockTimeSeries series = new MockTimeSeries(100, 95, 100, 80, 85, 130);
ITradingRecord tradingRecord = new BaseTradingRecord(
Order.buyAt(0, Decimals.NaN, Decimals.NaN), Order.sellAt(1, Decimals.NaN, Decimals.NaN),
Order.buyAt(2, Decimals.NaN, Decimals.NaN), Order.sellAt(5, Decimals.NaN, Decimals.NaN));
AbstractAnalysisCriterion buyAndHold = new VersusBuyAndHoldCriterion(new AverageProfitCriterion());
Assert.AreEqual((95M / 100 * 130M / 100).Pow(1M / 6) / (130M / 100).Pow(1M / 6), buyAndHold.Calculate(series, tradingRecord));
}
public void CalculateOnlyWithGainTrades()
{
MockTimeSeries series = new MockTimeSeries(100, 105, 110, 100, 95, 105);
ITradingRecord tradingRecord = new BaseTradingRecord(
Order.buyAt(0, series), Order.sellAt(2, series),
Order.buyAt(3, series), Order.sellAt(5, series));
AbstractAnalysisCriterion buyAndHold = new VersusBuyAndHoldCriterion(new TotalProfitCriterion());
Assert.AreEqual(1.10M * 1.05M / 1.05M, buyAndHold.Calculate(series, tradingRecord));
}
public void CalculateProfitWithTradesThatStartSelling()
{
MockTimeSeries series = new MockTimeSeries(100, 95, 100, 80, 85, 70);
ITradingRecord tradingRecord = new BaseTradingRecord(
Order.sellAt(0, series), Order.buyAt(1, series),
Order.sellAt(2, series), Order.buyAt(5, series));
AbstractAnalysisCriterion profit = new TotalProfitCriterion();
Assert.AreEqual((1M / 0.95M) * (1M / 0.7M), profit.Calculate(series, tradingRecord));
}
public void WithTradesThatSellBeforeBuying()
{
MockTimeSeries series = new MockTimeSeries(2, 1, 3, 5, 6, 3, 20);
MaximumDrawdownCriterion mdd = new MaximumDrawdownCriterion();
ITradingRecord tradingRecord = new BaseTradingRecord(
Order.buyAt(0, series), Order.sellAt(1, series),
Order.buyAt(3, series), Order.sellAt(4, series),
Order.sellAt(5, series), Order.buyAt(6, series));
Assert.AreEqual(.91M, mdd.Calculate(series, tradingRecord));
}
public void CalculateShouldWork()
{
MockTimeSeries series = new MockTimeSeries(1, 2, 3, 6, 5, 20, 3);
MaximumDrawdownCriterion mdd = new MaximumDrawdownCriterion();
ITradingRecord tradingRecord = new BaseTradingRecord(
Order.buyAt(0, series), Order.sellAt(1, series),
Order.buyAt(3, series), Order.sellAt(4, series),
Order.buyAt(5, series), Order.sellAt(6, series));
Assert.AreEqual(.875M, mdd.Calculate(series, tradingRecord));
}
public void CalculateOnlyWithLossTrades()
{
MockTimeSeries series = new MockTimeSeries(100, 95, 100, 80, 85, 70);
ITradingRecord tradingRecord = new BaseTradingRecord(
Order.buyAt(0, series), Order.sellAt(1, series),
Order.buyAt(2, series), Order.sellAt(5, series));
AbstractAnalysisCriterion buyAndHold = new BuyAndHoldCriterion();
Assert.AreEqual(0.7M, buyAndHold.Calculate(series, tradingRecord));
}
public void CalculateWithTwoTrades()
{
MockTimeSeries series = new MockTimeSeries(100, 105, 110, 100, 95, 105);
ITradingRecord tradingRecord = new BaseTradingRecord(
Order.buyAt(0, series), Order.sellAt(2, series),
Order.buyAt(3, series), Order.sellAt(5, series));
AbstractAnalysisCriterion numberOfBars = new NumberOfBarsCriterion();
Assert.AreEqual(6, numberOfBars.Calculate(series, tradingRecord));
}
public void Calculate()
{
ITimeSeries series = new MockTimeSeries(100M, 95M, 102M, 105M, 97M, 113M);
ITradingRecord tradingRecord = new BaseTradingRecord(
Order.buyAt(0, series), Order.sellAt(1, series),
Order.buyAt(2, series), Order.sellAt(3, series),
Order.buyAt(4, series), Order.sellAt(5, series));
AverageProfitableTradesCriterion average = new AverageProfitableTradesCriterion();
Assert.AreEqual(2M / 3, average.Calculate(series, tradingRecord));
}
public void WithSimpleTrades()
{
MockTimeSeries series = new MockTimeSeries(1, 10, 5, 6, 1);
MaximumDrawdownCriterion mdd = new MaximumDrawdownCriterion();
ITradingRecord tradingRecord = new BaseTradingRecord(
Order.buyAt(0, series), Order.sellAt(1, series),
Order.buyAt(1, series), Order.sellAt(2, series),
Order.buyAt(2, series), Order.sellAt(3, series),
Order.buyAt(3, series), Order.sellAt(4, series));
Assert.AreEqual(.9M, mdd.Calculate(series, tradingRecord));
}
public void cashFlowSell()
{
ITimeSeries sampleTimeSeries = new MockTimeSeries(1, 2, 4, 8, 16, 32);
ITradingRecord tradingRecord = new BaseTradingRecord(Order.sellAt(2, sampleTimeSeries), Order.buyAt(3, sampleTimeSeries));
CashFlow cashFlow = new CashFlow(sampleTimeSeries, tradingRecord);
Assert.AreEqual(cashFlow.GetValue(0), 1);
Assert.AreEqual(cashFlow.GetValue(1), 1);
Assert.AreEqual(cashFlow.GetValue(2), 1);
Assert.AreEqual(cashFlow.GetValue(3), 0.5M);
Assert.AreEqual(cashFlow.GetValue(4), 0.5M);
Assert.AreEqual(cashFlow.GetValue(5), 0.5M);
}
public void SetUp()
{
emptyRecord = new BaseTradingRecord();
openedRecord = new BaseTradingRecord(
Order.buyAt(0, Decimals.NaN, Decimals.NaN),
Order.sellAt(3, Decimals.NaN, Decimals.NaN),
Order.buyAt(7, Decimals.NaN, Decimals.NaN)
);
closedRecord = new BaseTradingRecord(
Order.buyAt(0, Decimals.NaN, Decimals.NaN),
Order.sellAt(3, Decimals.NaN, Decimals.NaN),
Order.buyAt(7, Decimals.NaN, Decimals.NaN),
Order.sellAt(8, Decimals.NaN, Decimals.NaN)
);
}
public void RewardRiskRatioCriterion()
{
MockTimeSeries series = new MockTimeSeries(100, 105, 95, 100, 90, 95, 80, 120);
ITradingRecord tradingRecord = new BaseTradingRecord(
Order.buyAt(0, series), Order.sellAt(1, series),
Order.buyAt(2, series), Order.sellAt(4, series),
Order.buyAt(5, series), Order.sellAt(7, series));
// double totalProfit = (105d / 100) * (90d / 95d) * (120d / 95);
// double peak = (105d / 100) * (100d / 95);
// double low = (105d / 100) * (90d / 95) * (80d / 95);
// totalProfit / ((peak - low) / peak)
Assert.AreEqual(5.1899313501144164759725400496M, rrc.Calculate(series, tradingRecord));
}
public void cashFlowValueWithTwoTradesAndLongTimeWithoutOrders()
{
ITimeSeries sampleTimeSeries = new MockTimeSeries(1, 2, 4, 8, 16, 32);
ITradingRecord tradingRecord = new BaseTradingRecord(
Order.buyAt(1, sampleTimeSeries), Order.sellAt(2, sampleTimeSeries),
Order.buyAt(4, sampleTimeSeries), Order.sellAt(5, sampleTimeSeries));
CashFlow cashFlow = new CashFlow(sampleTimeSeries, tradingRecord);
Assert.AreEqual(cashFlow.GetValue(0), 1);
Assert.AreEqual(cashFlow.GetValue(1), 1);
Assert.AreEqual(cashFlow.GetValue(2), 2);
Assert.AreEqual(cashFlow.GetValue(3), 2);
Assert.AreEqual(cashFlow.GetValue(4), 2);
Assert.AreEqual(cashFlow.GetValue(5), 4);
}
public void cashFlowWithSellAndBuyOrders()
{
ITimeSeries sampleTimeSeries = new MockTimeSeries(2, 1, 3, 5, 6, 3, 20);
ITradingRecord tradingRecord = new BaseTradingRecord(
Order.buyAt(0, sampleTimeSeries), Order.sellAt(1, sampleTimeSeries),
Order.buyAt(3, sampleTimeSeries), Order.sellAt(4, sampleTimeSeries),
Order.sellAt(5, sampleTimeSeries), Order.buyAt(6, sampleTimeSeries));
CashFlow cashFlow = new CashFlow(sampleTimeSeries, tradingRecord);
Assert.AreEqual(cashFlow.GetValue(0), 1);
Assert.AreEqual(cashFlow.GetValue(1), 0.5M);
Assert.AreEqual(cashFlow.GetValue(2), 0.5M);
Assert.AreEqual(cashFlow.GetValue(3), 0.5M);
Assert.AreEqual(cashFlow.GetValue(4), 0.6M);
Assert.AreEqual(cashFlow.GetValue(5), 0.6M);
Assert.AreEqual(cashFlow.GetValue(6), 0.09M);
}
public void cashFlowValue()
{
// First sample series
ITimeSeries sampleTimeSeries = new MockTimeSeries(3, 2, 5, 1000, 5000, 0.0001M, 4M, 7M, 6M, 7, 8, 5, 6);
ITradingRecord tradingRecord = new BaseTradingRecord(
Order.buyAt(0, sampleTimeSeries), Order.sellAt(2, sampleTimeSeries),
Order.buyAt(6, sampleTimeSeries), Order.sellAt(8, sampleTimeSeries),
Order.buyAt(9, sampleTimeSeries), Order.sellAt(11, sampleTimeSeries));
CashFlow cashFlow = new CashFlow(sampleTimeSeries, tradingRecord);
Assert.AreEqual(1, cashFlow.GetValue(0));
Assert.AreEqual(2M / 3, cashFlow.GetValue(1));
Assert.AreEqual(5M / 3, cashFlow.GetValue(2));
Assert.AreEqual(5M / 3, cashFlow.GetValue(3));
Assert.AreEqual(5M / 3, cashFlow.GetValue(4));
Assert.AreEqual(5M / 3, cashFlow.GetValue(5));
Assert.AreEqual(5M / 3, cashFlow.GetValue(6));
Assert.AreEqual(2.9166666666666666666666666667M, cashFlow.GetValue(7)); // 5M / 3M * 7M / 4M
Assert.AreEqual(5M / 3 * 6M / 4, cashFlow.GetValue(8));
Assert.AreEqual(5M / 3 * 6M / 4, cashFlow.GetValue(9));
Assert.AreEqual(2.8571428571428571428571428572M, cashFlow.GetValue(10)); // 5M / 3 * 6M / 4 * 8M / 7
Assert.AreEqual(1.7857142857142857142857142858M, cashFlow.GetValue(11)); // 5M / 3 * 6M / 4 * 5M / 7
Assert.AreEqual(1.7857142857142857142857142858M, cashFlow.GetValue(12)); // 5M / 3 * 6M / 4 * 5M / 7
// Second sample series
sampleTimeSeries = new MockTimeSeries(5, 6, 3, 7, 8, 6, 10, 15, 6);
tradingRecord = new BaseTradingRecord(
Order.buyAt(4, sampleTimeSeries), Order.sellAt(5, sampleTimeSeries),
Order.buyAt(6, sampleTimeSeries), Order.sellAt(8, sampleTimeSeries));
CashFlow flow = new CashFlow(sampleTimeSeries, tradingRecord);
Assert.AreEqual(flow.GetValue(0), 1);
Assert.AreEqual(flow.GetValue(1), 1);
Assert.AreEqual(flow.GetValue(2), 1);
Assert.AreEqual(flow.GetValue(3), 1);
Assert.AreEqual(flow.GetValue(4), 1);
Assert.AreEqual(flow.GetValue(5), 0.75M);
Assert.AreEqual(flow.GetValue(6), 0.75M);
Assert.AreEqual(flow.GetValue(7), 1.125M);
Assert.AreEqual(flow.GetValue(8), 0.45M);
}
