public override bool IsSatisfied(int index, TradingRecord tradingRecord)
{
var satisfied = _cross.GetValue(index);
TraceIsSatisfied(index, satisfied);
return(satisfied);
}
public override bool IsSatisfied(int index, TradingRecord tradingRecord)
{
var satisfied = _ref.GetValue(index).IsLessThanOrEqual(_upper.GetValue(index)) && _ref.GetValue(index).IsGreaterThanOrEqual(_lower.GetValue(index));
TraceIsSatisfied(index, satisfied);
return(satisfied);
}
public override double Calculate(TimeSeries series, TradingRecord tradingRecord)
{
var cashFlow = new CashFlow(series, tradingRecord);
var maximumDrawdown = CalculateMaximumDrawdown(series, cashFlow);
return(maximumDrawdown.ToDouble());
}
public override double Calculate(TimeSeries series, TradingRecord tradingRecord)
{
var totalCosts = 0d;
var tradedAmount = _initialAmount;
foreach (var trade in tradingRecord.Trades)
{
var tradeCost = GetTradeCost(series, trade, tradedAmount);
totalCosts += tradeCost;
// To calculate the new traded amount:
// - Remove the cost of the first order
// - Multiply by the profit ratio
tradedAmount = (tradedAmount - tradeCost) * _profit.Calculate(series, trade);
}
// Special case: if the current trade is open
var currentTrade = tradingRecord.CurrentTrade;
if (currentTrade.Opened)
{
totalCosts += GetOrderCost(currentTrade.Entry, tradedAmount);
}
return(totalCosts);
}
public override bool IsSatisfied(int index, TradingRecord tradingRecord)
{
var satisfied = false;
// No trading history or no trade opened, no gain
if (tradingRecord != null)
{
var currentTrade = tradingRecord.CurrentTrade;
if (currentTrade.Opened)
{
var entryPrice = currentTrade.Entry.Price;
var currentPrice = _closePrice.GetValue(index);
var threshold = entryPrice.MultipliedBy(_gainRatioThreshold);
if (currentTrade.Entry.IsBuy)
{
satisfied = currentPrice.IsGreaterThanOrEqual(threshold);
}
else
{
satisfied = currentPrice.IsLessThanOrEqual(threshold);
}
}
}
TraceIsSatisfied(index, satisfied);
return(satisfied);
}
public override bool IsSatisfied(int index, TradingRecord tradingRecord)
{
var satisfied = _indexes.Any(t => t == index);
TraceIsSatisfied(index, satisfied);
return(satisfied);
}
public override bool IsSatisfied(int index, TradingRecord tradingRecord)
{
var satisfied = _first.GetValue(index).IsLessThan(_second.GetValue(index));
TraceIsSatisfied(index, satisfied);
return(satisfied);
}
public static void Main(string[] args)
{
// Splitting the series into slices
TimeSeries series = CsvTradesLoader.loadBitstampSeries();
IList <TimeSeries> subseries = series.split(Period.hours(6), Period.weeks(1));
// Building the map of strategies
IDictionary <Strategy, string> strategies = buildStrategiesMap(series);
// The analysis criterion
AnalysisCriterion profitCriterion = new TotalProfitCriterion();
foreach (TimeSeries slice in subseries)
{
// For each sub-series...
Console.WriteLine("Sub-series: " + slice.SeriesPeriodDescription);
foreach (KeyValuePair <Strategy, string> entry in strategies.SetOfKeyValuePairs())
{
Strategy strategy = entry.Key;
string name = entry.Value;
// For each strategy...
TradingRecord tradingRecord = slice.run(strategy);
double profit = profitCriterion.calculate(slice, tradingRecord);
Console.WriteLine("\tProfit for " + name + ": " + profit);
}
Strategy bestStrategy = profitCriterion.chooseBest(slice, new List <Strategy>(strategies.Keys));
Console.WriteLine("\t\t--> Best strategy: " + strategies[bestStrategy] + "\n");
}
}
public void Operate()
{
var record = new TradingRecord();
record.Operate(1);
Assert.IsTrue(record.CurrentTrade.Opened);
Assert.AreEqual(0, record.TradeCount);
Assert.IsNull(record.LastTrade);
Assert.AreEqual(Order.BuyAt(1), record.LastOrder);
Assert.AreEqual(Order.BuyAt(1), record.GetLastOrder(OrderType.Buy));
Assert.IsNull(record.GetLastOrder(OrderType.Sell));
Assert.AreEqual(Order.BuyAt(1), record.LastEntry);
Assert.IsNull(record.LastExit);
record.Operate(3);
Assert.IsTrue(record.CurrentTrade.New);
Assert.AreEqual(1, record.TradeCount);
Assert.AreEqual(new Trade(Order.BuyAt(1), Order.SellAt(3)), record.LastTrade);
Assert.AreEqual(Order.SellAt(3), record.LastOrder);
Assert.AreEqual(Order.BuyAt(1), record.GetLastOrder(OrderType.Buy));
Assert.AreEqual(Order.SellAt(3), record.GetLastOrder(OrderType.Sell));
Assert.AreEqual(Order.BuyAt(1), record.LastEntry);
Assert.AreEqual(Order.SellAt(3), record.LastExit);
record.Operate(5);
Assert.IsTrue(record.CurrentTrade.Opened);
Assert.AreEqual(1, record.TradeCount);
Assert.AreEqual(new Trade(Order.BuyAt(1), Order.SellAt(3)), record.LastTrade);
Assert.AreEqual(Order.BuyAt(5), record.LastOrder);
Assert.AreEqual(Order.BuyAt(5), record.GetLastOrder(OrderType.Buy));
Assert.AreEqual(Order.SellAt(3), record.GetLastOrder(OrderType.Sell));
Assert.AreEqual(Order.BuyAt(5), record.LastEntry);
Assert.AreEqual(Order.SellAt(3), record.LastExit);
}
public override double Calculate(TimeSeries series, TradingRecord tradingRecord)
{
var numberOfProfitable = 0;
foreach (var trade in tradingRecord.Trades)
{
var entryIndex = trade.Entry.Index;
var exitIndex = trade.Exit.Index;
Decimal result;
if (trade.Entry.IsBuy)
{
// buy-then-sell trade
result = series.GetTick(exitIndex).ClosePrice.DividedBy(series.GetTick(entryIndex).ClosePrice);
}
else
{
// sell-then-buy trade
result = series.GetTick(entryIndex).ClosePrice.DividedBy(series.GetTick(exitIndex).ClosePrice);
}
if (result.IsGreaterThan(Decimal.One))
{
numberOfProfitable++;
}
}
return(((double)numberOfProfitable) / tradingRecord.TradeCount);
}
public override bool IsSatisfied(int index, TradingRecord tradingRecord)
{
var satisfied = !_rule.IsSatisfied(index, tradingRecord);
TraceIsSatisfied(index, satisfied);
return(satisfied);
}
public void RewardRiskRatioCriterionOnlyWithGain()
{
var series = GenerateTimeSeries.From(1, 2, 3, 6, 8, 20, 3);
var tradingRecord = new TradingRecord(Order.BuyAt(0), Order.SellAt(1), Order.BuyAt(2), Order.SellAt(5));
Assert.IsTrue(double.IsInfinity(_rrc.Calculate(series, tradingRecord)));
}
public void WithSimpleTrades()
{
var series = GenerateTimeSeries.From(1, 10, 5, 6, 1);
var mdd = new MaximumDrawdownCriterion();
var tradingRecord = new TradingRecord(Order.BuyAt(0), Order.SellAt(1), Order.BuyAt(1), Order.SellAt(2), Order.BuyAt(2), Order.SellAt(3), Order.BuyAt(3), Order.SellAt(4));
Assert.AreEqual(.9d, mdd.Calculate(series, tradingRecord), TaTestsUtils.TaOffset);
}
public void WithTradesThatSellBeforeBuying()
{
var series = GenerateTimeSeries.From(2, 1, 3, 5, 6, 3, 20);
var mdd = new MaximumDrawdownCriterion();
var tradingRecord = new TradingRecord(Order.BuyAt(0), Order.SellAt(1), Order.BuyAt(3), Order.SellAt(4), Order.SellAt(5), Order.BuyAt(6));
Assert.AreEqual(.91, mdd.Calculate(series, tradingRecord), TaTestsUtils.TaOffset);
}
public void CalculateOnlyWithGainTrades()
{
var _series = GenerateTimeSeries.From(100d, 105d, 110d, 100d, 95d, 105d);
var tradingRecord = new TradingRecord(Order.BuyAt(0), Order.SellAt(2), Order.BuyAt(3), Order.SellAt(5));
IAnalysisCriterion averageProfit = new AverageProfitCriterion();
Assert.AreEqual(1.0243, TaTestsUtils.TaOffset, averageProfit.Calculate(_series, tradingRecord));
}
public void CalculateWithOnlyGains()
{
var series = GenerateTimeSeries.From(1, 2, 3, 6, 8, 20, 3);
var mdd = new MaximumDrawdownCriterion();
var tradingRecord = new TradingRecord(Order.BuyAt(0), Order.SellAt(1), Order.BuyAt(2), Order.SellAt(5));
Assert.AreEqual(0d, mdd.Calculate(series, tradingRecord), TaTestsUtils.TaOffset);
}
public void CalculateOnlyWithLossTrades()
{
var _series = GenerateTimeSeries.From(100, 95, 100, 80, 85, 70);
var tradingRecord = new TradingRecord(Order.BuyAt(0), Order.SellAt(1), Order.BuyAt(2), Order.SellAt(5));
IAnalysisCriterion averageProfit = new AverageProfitCriterion();
Assert.AreEqual(Math.Pow(95d / 100 * 70d / 100, 1d / 6), averageProfit.Calculate(_series, tradingRecord), TaTestsUtils.TaOffset);
}
public override double Calculate(TimeSeries series, TradingRecord tradingRecord)
{
if (series.End == -1)
{
return(1);
}
return(series.GetTick(series.End).ClosePrice.DividedBy(series.GetTick(series.Begin).ClosePrice).ToDouble());
}
public static void AddTradingRecord(TradingRecord tradingRecord)//ex DataException
{
using (StockMonitorEntities _dbContext = new StockMonitorEntities())
{
_dbContext.TradingRecords.Add(tradingRecord);
_dbContext.SaveChanges();//ex DataException
}
}
public void CalculateWithASimpleTrade()
{
var _series = GenerateTimeSeries.From(100d, 105d, 110d, 100d, 95d, 105d);
var tradingRecord = new TradingRecord(Order.BuyAt(0), Order.SellAt(2));
IAnalysisCriterion averageProfit = new AverageProfitCriterion();
Assert.AreEqual(Math.Pow(110d / 100, 1d / 3), averageProfit.Calculate(_series, tradingRecord), TaTestsUtils.TaOffset);
}
public void CalculateShouldWork()
{
var series = GenerateTimeSeries.From(1, 2, 3, 6, 5, 20, 3);
var mdd = new MaximumDrawdownCriterion();
var tradingRecord = new TradingRecord(Order.BuyAt(0), Order.SellAt(1), Order.BuyAt(3), Order.SellAt(4), Order.BuyAt(5), Order.SellAt(6));
Assert.AreEqual(.875d, mdd.Calculate(series, tradingRecord), TaTestsUtils.TaOffset);
}
/// <summary>
/// Calculates the cash flow for a trading record. </summary>
/// <param name="tradingRecord"> the trading record </param>
private void Calculate(TradingRecord tradingRecord)
{
foreach (var trade in tradingRecord.Trades)
{
// For each trade...
Calculate(trade);
}
}
public void CalculateWithAverageProfit()
{
var series = GenerateTimeSeries.From(100, 95, 100, 80, 85, 130);
var tradingRecord = new TradingRecord(Order.BuyAt(0), Order.SellAt(1), Order.BuyAt(2), Order.SellAt(5));
IAnalysisCriterion buyAndHold = new VersusBuyAndHoldCriterion(new AverageProfitCriterion());
Assert.AreEqual(Math.Pow(95d / 100 * 130d / 100, 1d / 6) / Math.Pow(130d / 100, 1d / 6), buyAndHold.Calculate(series, tradingRecord), TaTestsUtils.TaOffset);
}
public void CalculateOnlyWithLossTrades()
{
var series = GenerateTimeSeries.From(100, 95, 100, 80, 85, 70);
var tradingRecord = new TradingRecord(Order.BuyAt(0), Order.SellAt(1), Order.BuyAt(2), Order.SellAt(5));
IAnalysisCriterion buyAndHold = new BuyAndHoldCriterion();
Assert.AreEqual(0.7, buyAndHold.Calculate(series, tradingRecord), TaTestsUtils.TaOffset);
}
public void CalculateWithNumberOfTicks()
{
var series = GenerateTimeSeries.From(100, 95, 100, 80, 85, 130);
var tradingRecord = new TradingRecord(Order.BuyAt(0), Order.SellAt(1), Order.BuyAt(2), Order.SellAt(5));
IAnalysisCriterion buyAndHold = new VersusBuyAndHoldCriterion(new NumberOfTicksCriterion());
Assert.AreEqual(6d / 6d, buyAndHold.Calculate(series, tradingRecord), TaTestsUtils.TaOffset);
}
public void CalculateOnlyWithGainTrades()
{
var series = GenerateTimeSeries.From(100, 105, 110, 100, 95, 105);
var tradingRecord = new TradingRecord(Order.BuyAt(0), Order.SellAt(2), Order.BuyAt(3), Order.SellAt(5));
IAnalysisCriterion profit = new TotalProfitCriterion();
Assert.AreEqual(1.10 * 1.05, profit.Calculate(series, tradingRecord), TaTestsUtils.TaOffset);
}
public void CalculateProfitWithTradesThatStartSelling()
{
var series = GenerateTimeSeries.From(100, 95, 100, 80, 85, 70);
var tradingRecord = new TradingRecord(Order.SellAt(0), Order.BuyAt(1), Order.SellAt(2), Order.BuyAt(5));
IAnalysisCriterion profit = new TotalProfitCriterion();
Assert.AreEqual((1 / 0.95) * (1 / 0.7), profit.Calculate(series, tradingRecord), TaTestsUtils.TaOffset);
}
public void WithConstrainedTimeSeries()
{
var sampleSeries = GenerateTimeSeries.From(new double[] { 1, 1, 1, 1, 1, 10, 5, 6, 1, 1, 1 });
var subSeries = sampleSeries.Subseries(4, 8);
var mdd = new MaximumDrawdownCriterion();
var tradingRecord = new TradingRecord(Order.BuyAt(4), Order.SellAt(5), Order.BuyAt(5), Order.SellAt(6), Order.BuyAt(6), Order.SellAt(7), Order.BuyAt(7), Order.SellAt(8));
Assert.AreEqual(.9d, mdd.Calculate(subSeries, tradingRecord), TaTestsUtils.TaOffset);
}
public void CalculateWithTwoTrades()
{
var series = GenerateTimeSeries.From(100, 105, 110, 100, 95, 105);
var tradingRecord = new TradingRecord(Order.BuyAt(0), Order.SellAt(2), Order.BuyAt(3), Order.SellAt(5));
IAnalysisCriterion numberOfTicks = new NumberOfTicksCriterion();
Assert.AreEqual(6, numberOfTicks.Calculate(series, tradingRecord), TaTestsUtils.TaOffset);
}
public void ReallyLongCashFlow()
{
const int size = 1000000;
TimeSeries sampleTimeSeries = GenerateTimeSeries.From(Enumerable.Repeat((Tick)GenerateTick.From(10), size).ToList());
var tradingRecord = new TradingRecord(Order.BuyAt(0), Order.SellAt(size - 1));
var cashFlow = new CashFlow(sampleTimeSeries, tradingRecord);
TaTestsUtils.AssertDecimalEquals(cashFlow.GetValue(size - 1), 1);
}
