/// <summary>
/// Evaluates the two indicators as passed
/// </summary>
/// <param name="indicatorLibraryAdapter">The indicatorLibraryAdapter to use for the indicator evaluation.</param>
/// <returns>A boolean value of the evaluation.</returns>
public override bool Eval(IndicatorLibraryAdapter indicatorLibraryAdapter)
{
double? indicator1 = indicatorLibraryAdapter.GetIndicator(this.IndicatorName1);
double? indicator2 = indicatorLibraryAdapter.GetIndicator(this.IndicatorName2);
double? previousIndicator1 = indicatorLibraryAdapter.GetPreviousIndicator(this.IndicatorName1);
double? previousIndicator2 = indicatorLibraryAdapter.GetPreviousIndicator(this.IndicatorName2);
if (indicator1 == null || indicator2 == null)
{
return false;
}
switch (this.CompareType)
{
case IndicatorCompareType.GT:
return indicator1 > indicator2;
case IndicatorCompareType.LT:
return indicator1 < indicator2;
case IndicatorCompareType.UP_XOVER:
return previousIndicator1 < previousIndicator2 && indicator1 > indicator2;
case IndicatorCompareType.DOWN_XUNDER:
return previousIndicator1 > previousIndicator2 && indicator1 < indicator2;
default:
throw new Exception("Compare Type not defined");
}
}
/// <summary>
/// Initializes a new instance of the BacktestFitness class.
/// </summary>
/// <param name="indicatorLibraryAdapter">The indicator library adapter to run the backtest with.</param>
public BacktestFitness(IndicatorLibraryAdapter indicatorLibraryAdapter)
{
this.indicatorLibraryAdapter = indicatorLibraryAdapter;
/// *********************************************
/// GDBCup - Code goes here
/// *********************************************
}
public MachineLearnerTradeRule(IndicatorLibraryAdapter indicatorLibraryAdapter)
{
this.indicatorsTypes = Enum.GetValues(typeof(IndicatorCompareType)).Cast<IndicatorCompareType>().ToList();
this.randomGenerator = new RandomSingleton();
this.Headers = indicatorLibraryAdapter.IndicatorLocations.Keys.Select(k => k.ToString()).ToArray();
this.FixedValues = TechnicalIndicatorClass.GetIndicatorsDefaultCrossOvers(this.Headers);
this.Groups = TechnicalIndicatorClass.GetGroupsOfIndicators(this.Headers);
}
public GeneticAlgorithmModel(IndicatorLibraryAdapter indicatorLibraryAdapter)
{
this.rand = new Random();
this.PopulationSize = 10;
this.MinSize = 5;
this.MaxSize = 5;
this.MutationRate = 0.01;
this.GenerationSize = 10;
this.NumberOfIteration = 1;
this.IndicatorLibraryAdapter = indicatorLibraryAdapter;
this.Seed = false;
this.SeededChromosomes = new List<TradeChromosome>();
this.joinTypes = Enum.GetValues(typeof(RuleJoinType)).Cast<RuleJoinType>().ToList();
this.stockPoints = this.IndicatorLibraryAdapter.StockPoints;
this.stockDaySplit = this.IndicatorLibraryAdapter.EndOfDayIndex;
SetData();
}
public EvalulateTrade(IndicatorLibraryAdapter indicatorLibraryAdapter)
{
this.LogTables = null;
this.Winners = 0;
this.Losers = 0;
this.StopOuts = 0;
this.IndicatorLibraryAdapter = indicatorLibraryAdapter;
this.Data = new Dictionary<string, double[]>();
//this.StockPoints = Enumerable.Range(0, indicatorLibraryAdapter.DataCount)
// .Select(e => new StockPoint(
// GetDateTimeValue((int)indicatorLibraryAdapter.Data["Date"][e].Value,
// (int)indicatorLibraryAdapter.Data["Time"][e].Value),
// indicatorLibraryAdapter.Data["Open"][e].Value,
// indicatorLibraryAdapter.Data["High"][e].Value,
// indicatorLibraryAdapter.Data["Low"][e].Value,
// indicatorLibraryAdapter.Data["Close"][e].Value,
// (long)indicatorLibraryAdapter.Data["Volume"][e].Value)
// ).ToArray();
this.StockPoints = indicatorLibraryAdapter.StockPoints;
}
/// <summary>
/// Returns TradeType triggered at the current row
/// </summary>
/// <returns>int 0 : no triggered, 1 - long triggered , 2 - short triggered, 3- both triggered</returns>
private int GetTradeCondition(IndicatorLibraryAdapter indicatorLibraryAdapter)
{
TradeCondition buyTradeCondition = this.tradeSystem.BuyCondition;
TradeCondition sellTradeCondition = this.tradeSystem.SellCondition;
bool bLongTriggered = false;
bool bShortTriggered = false;
int iTrigger = 0;
//check for buy condition update tradeTypes
if (buyTradeCondition != null)
{
if (EvalBuySellSignal(indicatorLibraryAdapter, buyTradeCondition.TradeRules, buyTradeCondition.RuleJoinTypes))
{
bLongTriggered = true;
}
}
// check for sell condition update tradeTypes
if (sellTradeCondition != null)
{
if (EvalBuySellSignal(indicatorLibraryAdapter, sellTradeCondition.TradeRules, sellTradeCondition.RuleJoinTypes))
{
bShortTriggered = true;
}
}
if (bLongTriggered && bShortTriggered)
{
iTrigger = 3;
}
else if (!bLongTriggered && bShortTriggered)
{
iTrigger = 2;
}
else if (bLongTriggered && !bShortTriggered)
{
iTrigger = 1;
}
return iTrigger;
}
/// <summary>
/// Evaluates the join conditions and returns the signal as boolean
/// </summary>
/// <param name="tradeRules">List of traderules</param>
/// <param name="joinTypes">list of join types</param>
/// <returns>boolean signal</returns>
private bool EvalBuySellSignal(IndicatorLibraryAdapter indicatorLibraryAdapter, List<TradeRule> tradeRules, List<RuleJoinType> joinTypes)
{
List<bool> andResults = new List<bool>();
List<int> andList = null;
List<bool> orList = new List<bool>();
for (int idx = 0; idx < joinTypes.Count; idx++)
{
if (joinTypes[idx] == RuleJoinType.and)
{
if (andList == null)
{
andList = new List<int>();
}
andList.Add(idx);
}
else
{
if (andList != null && andList.Any())
{
bool tr1 = tradeRules[andList[0]].Eval(indicatorLibraryAdapter);
bool tr2;
for (int id = 1; id < andList.Count; id++)
{
tr2 = tradeRules[andList[id]].Eval(indicatorLibraryAdapter);
tr1 = tr1 && tr2;
}
andResults.Add(tr1);
}
if (idx == 0 || joinTypes[idx - 1] == RuleJoinType.or)
{
orList.Add(tradeRules[idx].Eval(indicatorLibraryAdapter));
}
andList = null;
}
}
List<bool> andOrResultList = andResults.Concat(orList).ToList();
bool result = false;
for (int idx = 0; idx < andOrResultList.Count; idx++)
{
if (idx == 0)
{
result = andOrResultList[idx];
}
else
{
result = result || andOrResultList[idx];
}
}
return result;
/*
int i = 0;
RuleJoinType rj = joinTypes[i];
TradeRule tr = tradeRules[i];
bool bSignal = tr.Eval(indicatorLibraryAdapter);
while (rj != RuleJoinType.none)
{
tr = tradeRules[i];
bSignal = rj == RuleJoinType.or ? bSignal || tr.Eval(indicatorLibraryAdapter)
: bSignal && tr.Eval(indicatorLibraryAdapter);
rj = joinTypes[i];
++i;
}
return bSignal;
*/
}
private TradeType? CheckShortCondition(IndicatorLibraryAdapter indicatorLibraryAdapter)
{
TradeCondition sellTradeCondition = this.tradeSystem.SellCondition;
TradeType? triggerValue = null;
//check for buy condition update tradeTypes
if (sellTradeCondition != null)
{
if (EvalBuySellSignal(indicatorLibraryAdapter, sellTradeCondition.TradeRules, sellTradeCondition.RuleJoinTypes))
{
triggerValue = TradeType.shortTrade;
}
}
return triggerValue;
}
private TradeType? CheckLongCondition(IndicatorLibraryAdapter indicatorLibraryAdapter)
{
TradeCondition buyTradeCondition = this.tradeSystem.BuyCondition;
TradeType? triggerValue = null;
//check for buy condition update tradeTypes
if (buyTradeCondition != null)
{
if (EvalBuySellSignal(indicatorLibraryAdapter, buyTradeCondition.TradeRules, buyTradeCondition.RuleJoinTypes))
{
triggerValue = TradeType.longTrade;
}
}
return triggerValue;
}
/// <summary>
/// Runs the backtest for one row. Must manually MoveNext on the indicator library if using this method.
/// </summary>
/// <param name="indicatorLibraryAdapter">The indicator Library Adapter to use for the backtest row.</param>
public void RunBacktestRow(IndicatorLibraryAdapter indicatorLibraryAdapter)
{
/// *********************************************
/// GDBCup - Code is needed here
/// *********************************************
}
/// <summary>
/// Closes any open trades if there are some.
/// </summary>
/// <param name="indicatorLibraryAdapter">The indicatorLibraryAdapter to get the final stock point from.</param>
public void CloseOpenTrades(IndicatorLibraryAdapter indicatorLibraryAdapter)
{
/// *********************************************
/// GDBCup - Code is needed here
/// *********************************************
}
public IndicatorLibraryAdapter Clone(IndicatorLibraryAdapter indicatorLibraryAdapter)
{
using (var ms = new MemoryStream())
{
var formatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
formatter.Serialize(ms, indicatorLibraryAdapter);
ms.Position = 0;
return (IndicatorLibraryAdapter)formatter.Deserialize(ms);
}
}
/// <summary>
/// Evaluates the trade rule for the current indicatorLibraryAdapter line.
/// </summary>
/// <param name="indicatorLibraryAdapter">The data source to evaluate.</param>
/// <returns>A boolean value for the conditionon this line.</returns>
public bool Eval(IndicatorLibraryAdapter indicatorLibraryAdapter)
{
if (this.TradeRules.Count == 0)
{
throw new TradeRuleException("Trade rules not defined.");
}
bool evalValue = true;
/// *********************************************
/// GDBCup - Need to code this
/// *********************************************
return evalValue;
}
/// <summary> /// Evaluates the two indicators as passed /// </summary> /// <param name="indicatorLibraryAdapter">The indicatorLibraryAdapter to use for the indicator evaluation.</param> /// <returns>A boolean value of the evaluation.</returns> public abstract bool Eval(IndicatorLibraryAdapter indicatorLibraryAdapter);
