public void CalculateWithNoBarsShouldReturn1()
{
series = new MockTimeSeries(100, 95, 100, 80, 85, 70);
AbstractAnalysisCriterion averageProfit = new AverageProfitCriterion();
Assert.AreEqual(1M, averageProfit.Calculate(series, new BaseTradingRecord()));
}
public void getValue()
{
List <IBar> bars = new List <IBar>();
bars.Add(new MockBar(1355.69M, 2739.55M));
bars.Add(new MockBar(1325.51M, 3119.46M));
bars.Add(new MockBar(1335.02M, 3466.88M));
bars.Add(new MockBar(1313.72M, 2577.12M));
bars.Add(new MockBar(1319.99M, 2480.45M));
bars.Add(new MockBar(1331.85M, 2329.79M));
bars.Add(new MockBar(1329.04M, 2793.07M));
bars.Add(new MockBar(1362.16M, 3378.78M));
bars.Add(new MockBar(1365.51M, 2417.59M));
bars.Add(new MockBar(1374.02M, 1442.81M));
ITimeSeries series = new MockTimeSeries(bars);
PVIIndicator pvi = new PVIIndicator(series);
Assert.AreEqual(pvi.GetValue(0), 1000);
Assert.AreEqual(pvi.GetValue(1), 977.7382734991037774122402614M);
Assert.AreEqual(pvi.GetValue(2), 984.7531515316923485457589862M);
Assert.AreEqual(pvi.GetValue(3), 984.7531515316923485457589862M);
Assert.AreEqual(pvi.GetValue(4), 984.7531515316923485457589862M);
Assert.AreEqual(pvi.GetValue(5), 984.7531515316923485457589862M);
Assert.AreEqual(pvi.GetValue(6), 982.6754728473029236860423644M);
Assert.AreEqual(pvi.GetValue(7), 1007.1639846006757889365101630M);
Assert.AreEqual(pvi.GetValue(8), 1007.1639846006757889365101630M);
Assert.AreEqual(pvi.GetValue(9), 1007.1639846006757889365101630M);
}
public void getValue()
{
List<IBar> bars = new List<IBar>();
bars.Add(new MockBar(12.915, 13.600, 12.890, 13.550, 264266));
bars.Add(new MockBar(13.550, 13.770, 13.310, 13.505, 305427));
bars.Add(new MockBar(13.510, 13.590, 13.425, 13.490, 104077));
bars.Add(new MockBar(13.515, 13.545, 13.400, 13.480, 136135));
bars.Add(new MockBar(13.490, 13.495, 13.310, 13.345, 92090));
bars.Add(new MockBar(13.350, 13.490, 13.325, 13.420, 80948));
bars.Add(new MockBar(13.415, 13.460, 13.290, 13.300, 82983));
bars.Add(new MockBar(13.320, 13.320, 13.090, 13.130, 126918));
bars.Add(new MockBar(13.145, 13.225, 13.090, 13.150, 68560));
bars.Add(new MockBar(13.150, 13.250, 13.110, 13.245, 41178));
bars.Add(new MockBar(13.245, 13.250, 13.120, 13.210, 63606));
bars.Add(new MockBar(13.210, 13.275, 13.185, 13.275, 34402));
TimeSeries series = new MockTimeSeries(bars);
ChaikinOscillatorIndicator co = new ChaikinOscillatorIndicator(series);
Assert.AreEqual(co.getValue(0), 0.0);
Assert.AreEqual(co.getValue(1), 0.0);
Assert.AreEqual(co.getValue(2), -165349.14743589723);
Assert.AreEqual(co.getValue(3), -337362.31490384537);
Assert.AreEqual(co.getValue(4), -662329.9816620838);
Assert.AreEqual(co.getValue(5), -836710.5421757463);
Assert.AreEqual(co.getValue(6), -1847749.1562169262);
Assert.AreEqual(co.getValue(7), -2710068.6997245993);
Assert.AreEqual(co.getValue(8), -3069157.9046621257);
Assert.AreEqual(co.getValue(9), -2795286.881074371);
Assert.AreEqual(co.getValue(9), -2795286.881074371);
Assert.AreEqual(co.getValue(9), -2795286.881074371);
}
public void wmaUsingTimeFrame9UsingClosePrice()
{
// Example from http://traders.com/Documentation/FEEDbk_docs/2010/12/TradingIndexesWithHullMA.xls
ITimeSeries data = new MockTimeSeries(
84.53M, 87.39M, 84.55M,
82.83M, 82.58M, 83.74M,
83.33M, 84.57M, 86.98M,
87.10M, 83.11M, 83.60M,
83.66M, 82.76M, 79.22M,
79.03M, 78.18M, 77.42M,
74.65M, 77.48M, 76.87M
);
WMAIndicator wma = new WMAIndicator(new ClosePriceIndicator(data), 9);
Assert.AreEqual(84.49577777777777777777777778M, wma.GetValue(8));
Assert.AreEqual(85.01577777777777777777777778M, wma.GetValue(9));
Assert.AreEqual(84.68066666666666666666666667M, wma.GetValue(10));
Assert.AreEqual(84.53866666666666666666666667M, wma.GetValue(11));
Assert.AreEqual(84.42977777777777777777777778M, wma.GetValue(12));
Assert.AreEqual(84.12244444444444444444444444M, wma.GetValue(13));
Assert.AreEqual(83.10311111111111111111111111M, wma.GetValue(14));
Assert.AreEqual(82.14622222222222222222222222M, wma.GetValue(15));
Assert.AreEqual(81.11488888888888888888888889M, wma.GetValue(16));
Assert.AreEqual(80.07355555555555555555555556M, wma.GetValue(17));
Assert.AreEqual(78.690666666666666666666666667M, wma.GetValue(18));
Assert.AreEqual(78.150444444444444444444444444M, wma.GetValue(19));
Assert.AreEqual(77.613333333333333333333333333M, wma.GetValue(20));
}
public void coppockCurveWithRoc14Roc11Wma10()
{
// Example from http://stockcharts.com/school/doku.php?id=chart_school:technical_indicators:coppock_curve
ITimeSeries data = new MockTimeSeries(
872.81M, 919.14M, 919.32M, 987.48M, 1020.62M,
1057.08M, 1036.19M, 1095.63M, 1115.1M, 1073.87M,
1104.49M, 1169.43M, 1186.69M, 1089.41M, 1030.71M,
1101.6M, 1049.33M, 1141.2M, 1183.26M, 1180.55M,
1257.64M, 1286.12M, 1327.22M, 1325.83M, 1363.61M,
1345.2M, 1320.64M, 1292.28M, 1218.89M, 1131.42M,
1253.3M, 1246.96M, 1257.6M, 1312.41M, 1365.68M,
1408.47M, 1397.91M, 1310.33M, 1362.16M, 1379.32M
);
CoppockCurveIndicator cc = new CoppockCurveIndicator(new ClosePriceIndicator(data), 14, 11, 10);
Assert.AreEqual(cc.GetValue(31), 23.892855086922197744287818351M);
Assert.AreEqual(cc.GetValue(32), 19.318661466425348019588229135M);
Assert.AreEqual(cc.GetValue(33), 16.350542803958196462308468202M);
Assert.AreEqual(cc.GetValue(34), 14.119931234084269587181699349M);
Assert.AreEqual(cc.GetValue(35), 12.782034421286169059841703773M);
Assert.AreEqual(cc.GetValue(36), 11.39242630956381711118490345M);
Assert.AreEqual(cc.GetValue(37), 8.366161426264314349758720221M);
Assert.AreEqual(cc.GetValue(38), 7.4532394830272277872914349091M);
Assert.AreEqual(cc.GetValue(39), 8.790068424954794622463894475M);
}
public void CashFlowSize()
{
ITimeSeries sampleTimeSeries = new MockTimeSeries(1, 2, 3, 4, 5);
CashFlow cashFlow = new CashFlow(sampleTimeSeries, new BaseTradingRecord());
Assert.AreEqual(5, cashFlow.GetSize());
}
public void CalculateWithNullSeriesSizeShouldReturn0()
{
MockTimeSeries series = new MockTimeSeries(new decimal[0]);
MaximumDrawdownCriterion mdd = new MaximumDrawdownCriterion();
Assert.AreEqual(0M, mdd.Calculate(series, new BaseTradingRecord()));
}
public void CalculateWithNoTrades()
{
MockTimeSeries series = new MockTimeSeries(1, 2, 3, 6, 5, 20, 3);
MaximumDrawdownCriterion mdd = new MaximumDrawdownCriterion();
Assert.AreEqual(0M, mdd.Calculate(series, new BaseTradingRecord()));
}
public void getValue()
{
List <IBar> bars = new List <IBar>();
bars.Add(new MockBar(1355.69M, 2739.55M));
bars.Add(new MockBar(1325.51M, 3119.46M));
bars.Add(new MockBar(1335.02M, 3466.88M));
bars.Add(new MockBar(1313.72M, 2577.12M));
bars.Add(new MockBar(1319.99M, 2480.45M));
bars.Add(new MockBar(1331.85M, 2329.79M));
bars.Add(new MockBar(1329.04M, 2793.07M));
bars.Add(new MockBar(1362.16M, 3378.78M));
bars.Add(new MockBar(1365.51M, 2417.59M));
bars.Add(new MockBar(1374.02M, 1442.81M));
ITimeSeries series = new MockTimeSeries(bars);
NVIIndicator nvi = new NVIIndicator(series);
Assert.AreEqual(nvi.GetValue(0), 1000);
Assert.AreEqual(nvi.GetValue(1), 1000);
Assert.AreEqual(nvi.GetValue(2), 1000);
Assert.AreEqual(nvi.GetValue(3), 984.0451828437027160641788138M);
Assert.AreEqual(nvi.GetValue(4), 988.7417416967536066875402616M);
Assert.AreEqual(nvi.GetValue(5), 997.6255037377717187757486779M);
Assert.AreEqual(nvi.GetValue(6), 997.6255037377717187757486779M);
Assert.AreEqual(nvi.GetValue(7), 997.6255037377717187757486779M);
Assert.AreEqual(nvi.GetValue(8), 1000.0789933700627383754276863M);
Assert.AreEqual(nvi.GetValue(9), 1006.3115894210467911495376449M);
}
public void bestShouldBeAlwaysOperateOnProfit()
{
MockTimeSeries series = new MockTimeSeries(6.0M, 9.0M, 6.0M, 6.0M);
TimeSeriesManager manager = new TimeSeriesManager(series);
IStrategy bestStrategy = new TotalProfitCriterion().ChooseBest(manager, strategies);
Assert.AreEqual(alwaysStrategy, bestStrategy);
}
public void CalculateWithNoTrades()
{
MockTimeSeries series = new MockTimeSeries(100, 105, 110, 100, 95, 105);
AbstractAnalysisCriterion numberOfBars = new NumberOfBarsCriterion();
Assert.AreEqual(0, (int)numberOfBars.Calculate(series, new BaseTradingRecord()));
}
public void CalculateWithOneTrade()
{
MockTimeSeries series = new MockTimeSeries(100, 105);
Trade trade = new Trade(Order.buyAt(0, series), Order.sellAt(1, series));
AbstractAnalysisCriterion buyAndHold = new BuyAndHoldCriterion();
Assert.AreEqual(105M / 100, buyAndHold.Calculate(series, trade));
}
public void bestShouldBeBuyAndHoldOnLoss()
{
MockTimeSeries series = new MockTimeSeries(6.0M, 3.0M, 6.0M, 6.0M);
TimeSeriesManager manager = new TimeSeriesManager(series);
IStrategy bestStrategy = new TotalProfitCriterion().ChooseBest(manager, strategies);
Assert.AreEqual(buyAndHoldStrategy, bestStrategy);
}
public void CalculateWithNoTradesShouldReturn1()
{
MockTimeSeries series = new MockTimeSeries(100, 95, 100, 80, 85, 70);
AbstractAnalysisCriterion profit = new TotalProfitCriterion();
Assert.AreEqual(1M, profit.Calculate(series, new BaseTradingRecord()));
}
public void CalculateWithOneTrade()
{
series = new MockTimeSeries(100, 105);
Trade trade = new Trade(Order.buyAt(0, series), Order.sellAt(1, series));
AbstractAnalysisCriterion average = new AverageProfitCriterion();
Assert.AreEqual(1.0246950765959598383221038678M, average.Calculate(series, trade));
}
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 CalculateWithOneTrade()
{
MockTimeSeries series = new MockTimeSeries(100, 95, 100, 80, 85, 70);
Trade t = new Trade(Order.buyAt(2, series), Order.sellAt(5, series));
AbstractAnalysisCriterion numberOfBars = new NumberOfBarsCriterion();
Assert.AreEqual(4, numberOfBars.Calculate(series, t));
}
public void CalculateWithNoTrades()
{
MockTimeSeries series = new MockTimeSeries(100, 95, 100, 80, 85, 70);
AbstractAnalysisCriterion buyAndHold = new BuyAndHoldCriterion();
Assert.AreEqual(0.7M, buyAndHold.Calculate(series, new BaseTradingRecord()));
}
public void setUp()
{
ITimeSeries data = new MockTimeSeries(1, 2, 3, 4, 3, 4, 5, 4, 3, 3, 4, 3, 2);
timeFrame = 3;
closePrice = new ClosePriceIndicator(data);
sma = new SMAIndicator(closePrice, timeFrame);
}
public void CalculateWithNoTrades()
{
MockTimeSeries series = new MockTimeSeries(100, 105, 110, 100, 95, 105);
AbstractAnalysisCriterion buyAndHold = new NumberOfTradesCriterion();
Assert.AreEqual(0M, buyAndHold.Calculate(series, new BaseTradingRecord()));
}
public void CalculateWithOnlyOneTrade()
{
MockTimeSeries series = new MockTimeSeries(100, 95, 100, 80, 85, 70);
Trade trade = new Trade(Order.buyAt(0, series), Order.sellAt(1, series));
AbstractAnalysisCriterion buyAndHold = new VersusBuyAndHoldCriterion(new TotalProfitCriterion());
Assert.AreEqual(1.3571428571428571428571428571M, buyAndHold.Calculate(series, trade)); // (100M / 70) / (100M / 95)
}
public void runOnWholeSeries()
{
ITimeSeries series = new MockTimeSeries(20, 40, 60, 10, 30, 50, 0, 20, 40);
manager.SetTimeSeries(series);
var allTrades = manager.Run(strategy).Trades;
Assert.AreEqual(2, allTrades.Count());
}
public void WithOneTrade()
{
MockTimeSeries series = new MockTimeSeries(100, 95, 95, 100, 90, 95, 80, 120);
Trade trade = new Trade(Order.buyAt(0, series), Order.sellAt(1, series));
RewardRiskRatioCriterion ratioCriterion = new RewardRiskRatioCriterion();
Assert.AreEqual((95M / 100) / ((1M - 0.95M)), ratioCriterion.Calculate(series, trade));
}
public void cashFlowValueWithNoTrades()
{
ITimeSeries sampleTimeSeries = new MockTimeSeries(3, 2, 5, 4, 7, 6, 7, 8, 5, 6);
CashFlow cashFlow = new CashFlow(sampleTimeSeries, new BaseTradingRecord());
Assert.AreEqual(cashFlow.GetValue(4), 1);
Assert.AreEqual(cashFlow.GetValue(7), 1);
Assert.AreEqual(cashFlow.GetValue(9), 1);
}
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 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 setUp()
{
ITimeSeries data = new MockTimeSeries(
0.73M, 0.72M, 0.86M, 0.72M, 0.62M,
0.76M, 0.84M, 0.69M, 0.65M, 0.71M,
0.53M, 0.73M, 0.77M, 0.67M, 0.68M
);
closePrice = new ClosePriceIndicator(data);
}
public void setUp()
{
List <IBar> bars = new List <IBar>();
foreach (decimal price in typicalPrices)
{
bars.Add(new MockBar(price, price, price, price));
}
series = new MockTimeSeries(bars);
}
public void CalculateWithOpenedTradeShouldReturn1()
{
MockTimeSeries series = new MockTimeSeries(100, 95, 100, 80, 85, 70);
AbstractAnalysisCriterion profit = new TotalProfitCriterion();
Trade trade = new Trade();
Assert.AreEqual(1M, profit.Calculate(series, trade));
trade.Operate(0);
Assert.AreEqual(1M, profit.Calculate(series, trade));
}
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);
}