public TradingStrategyEvaluator(
int numberOfAccounts,
int accountId,
ICapitalManager capitalManager,
ITradingStrategy strategy,
IDictionary <ParameterAttribute, object> strategyParameters,
ITradingDataProvider provider,
StockBlockRelationshipManager relationshipManager,
TradingSettings settings,
ILogger logger,
StreamWriter dumpDataWriter)
{
if (numberOfAccounts <= 0 || accountId < 0 || accountId >= numberOfAccounts)
{
throw new ArgumentOutOfRangeException();
}
if (strategy == null || provider == null || settings == null)
{
throw new ArgumentNullException();
}
_numberOfAccounts = numberOfAccounts;
_accountId = accountId;
_strategy = strategy;
_strategyParameterValues = strategyParameters;
_provider = provider;
_settings = settings;
_equityManager = new EquityManager(capitalManager, _settings.PositionFrozenDays);
_context = new StandardEvaluationContext(_provider, _equityManager, logger, settings, dumpDataWriter, relationshipManager);
_tradingTracker = new TradingTracker(capitalManager.InitialCapital);
}
public TradingStrategyPredicator(
double initialCapital,
double currentCapital,
ITradingStrategy strategy,
IDictionary <ParameterAttribute, object> strategyParameters,
ITradingDataProvider provider,
StockBlockRelationshipManager relationshipManager,
int positionFrozenDays,
IEnumerable <Position> activePositions,
ILogger logger)
{
if (strategy == null || provider == null)
{
throw new ArgumentNullException();
}
_strategy = strategy;
_strategyParameterValues = strategyParameters;
_provider = provider;
_equityManager = new EquityManager(new SimpleCapitalManager(initialCapital, currentCapital), positionFrozenDays);
_unprocessedActivePositions = activePositions.ToList();
_context = new StandardEvaluationContext(_provider, _equityManager, logger, null, null, relationshipManager);
}
public StandardEvaluationContext(
ITradingDataProvider provider,
EquityManager equityManager,
ILogger logger,
TradingSettings settings = null,
StreamWriter dumpDataWriter = null,
StockBlockRelationshipManager relationshipManager = null)
{
if (equityManager == null || provider == null || logger == null)
{
throw new ArgumentNullException();
}
_provider = provider;
_equityManager = equityManager;
_logger = logger;
_settings = settings;
_relationshipManager = relationshipManager;
var metricManager = new StandardRuntimeMetricManager(_provider.GetAllTradingObjects().Length);
var groupMetricManager = new StandardGroupRuntimeMetricManager(metricManager);
// register the group metric manager as observer of metric manager.
metricManager.RegisterAfterUpdatedMetricsObserver(groupMetricManager);
_metricManager = metricManager;
_groupMetricManager = groupMetricManager;
_boardIndexTradingObjects = new Dictionary <string, ITradingObject>();
var boards = new StockBoard[]
{
StockBoard.GrowingBoard,
StockBoard.MainBoard,
StockBoard.SmallMiddleBoard
};
foreach (var board in boards)
{
string boardIndex = StockName.GetBoardIndex(board);
ITradingObject tradingObject = GetTradingObject(boardIndex);
_boardIndexTradingObjects.Add(boardIndex, tradingObject);
}
_dumper = dumpDataWriter == null ? null : new StreamDataDumper(dumpDataWriter, 8, 3, _settings.DumpMetrics, this, _provider);
}
private TradeMetric GetTradeMetric(string code, string name, double startPrice, double endPrice)
{
var completedTransactions =
code == TradeMetric.CodeForAll
? _completedTransactionHistory
: _completedTransactionHistory.Where(ct => ct.Code == code).ToArray();
if (completedTransactions.Length == 0)
{
return(null);
}
var transactions =
code == TradeMetric.CodeForAll
? _transactionHistory
: _transactionHistory.Where(t => t.Code == code).ToArray();
var requiredInitialCapital = EstimateRequiredInitialCapital(transactions, _initialCapital);
var initialCapital = Math.Max(_initialCapital, requiredInitialCapital);
var manager = new EquityManager(new SimpleCapitalManager(initialCapital), _settings.PositionFrozenDays);
var transactionIndex = 0;
var currentEquity = initialCapital;
var equityPoints = new List <EquityPoint>(_periods.Length);
// Calculate E-Ratio
var eRatios = CalculateERatio(transactions);
foreach (var period in _periods)
{
while (transactionIndex < transactions.Length)
{
var transaction = transactions[transactionIndex];
if (transaction.ExecutionTime <= period)
{
if (transaction.Succeeded)
{
// save transaction selling type
var sellingType = transaction.SellingType;
// always use ByVolume selling type to simulate transactions.
transaction.SellingType = SellingType.ByVolume;
CompletedTransaction completedTransaction;
string error;
if (!manager.ExecuteTransaction(
transaction,
true,
out completedTransaction,
out error,
true))
{
throw new InvalidOperationException("Replay transaction failed: " + error);
}
// recover the transaction selling type
transaction.SellingType = sellingType;
}
++transactionIndex;
}
else
{
break;
}
}
if (manager.PositionCount > 0)
{
// if any transaction is executed, update the total equity.
currentEquity = manager.GetTotalEquity(_dataProvider, period, EquityEvaluationMethod.TotalEquity);
}
equityPoints.Add(
new EquityPoint
{
Capital = manager.CurrentCapital,
Equity = currentEquity,
Time = period
});
}
var metric = new TradeMetric();
metric.Initialize(
code,
name,
_startDate,
_endDate,
startPrice,
endPrice,
equityPoints.OrderBy(t => t.Time).ToArray(),
completedTransactions,
transactions,
eRatios);
return(metric);
}
