public void UpdateTrailings()
{
lock (this) {
for (int i = 0; i < Trailings.Count; i++)
{
TradingSettings tr = Trailings[i];
tr.Update();
}
}
RaiseChanged();
}
protected TrailingSettinsForm CreateSettingsForm(TradingSettings settings)
{
TrailingSettinsForm form = new TrailingSettinsForm();
form.Ticker = Ticker;
form.Settings = settings;
form.Owner = FindForm();
form.CollectionControl = this;
form.Mode = EditingMode.Edit;
return(form);
}
public static void Delete(int identifier)
{
using (TradeProAssistantContext context = new TradeProAssistantContext())
{
try
{
TradingSettings tradingsettings = context.TradingSettings.Find(identifier);
context.Entry(tradingsettings).State = EntityState.Deleted;
context.SaveChanges();
}
catch { }
}
}
public static int Save(TradingSettings tradingsettings)
{
using (TradeProAssistantContext context = new TradeProAssistantContext())
{
context.Entry(tradingsettings).State = tradingsettings.IsNew ?
EntityState.Added :
EntityState.Modified;
context.SaveChanges();
return(tradingsettings.Identifier);
}
}
static void GenerateExampleFiles(Options options)
{
string prefix = "gen.";
var tradingSettings = TradingSettings.GenerateExampleSettings();
tradingSettings.SaveToFile(AddPrefixToFileName(options.TradingSettingsFile, prefix));
var combinedStrategySettings = CombinedStrategySettings.GenerateExampleSettings();
combinedStrategySettings.SaveToFile(AddPrefixToFileName(options.CombinedStrategySettingsFile, prefix));
var stockDataSettings = ChinaStockDataSettings.GenerateExampleSettings();
stockDataSettings.SaveToFile(AddPrefixToFileName(options.StockDataSettingsFile, prefix));
}
public void UpdateTradingSettings(TradingSettings newSettings)
{
if (_tradingSettings == null)
{
_tradingSettings = newSettings;
return;
}
_tradingSettings.QuoteCurrencies = newSettings.QuoteCurrencies;
_tradingSettings.Period = newSettings.Period;
_tradingSettings.BaseOrderSide = newSettings.BaseOrderSide;
_tradingSettings.Moment = newSettings.Moment;
_tradingSettings.MinCurrencyPairTradingVolumeInBTC = newSettings.MinCurrencyPairTradingVolumeInBTC;
_tradingSettings.MaxOrderUsingBalancePart = newSettings.MaxOrderUsingBalancePart;
}
void OnTickerChanged()
{
if (Ticker != null)
{
Ticker.Changed += OnTickerUpdated;
}
this.gcTrailings.DataSource = Ticker == null ? null : Ticker.Trailings;
if (ChartControl != null && Ticker != null)
{
for (int i = 0; i < Ticker.Trailings.Count; i++)
{
TradingSettings settings = Ticker.Trailings[i];
if (settings.ShowOnChart)
{
ChartControl.AddIndicator(settings);
}
}
}
}
private void btRemove_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
{
if (XtraMessageBox.Show("Are you shure to remove selected trailing?", "Remove Trailings", MessageBoxButtons.YesNoCancel) != DialogResult.Yes)
{
return;
}
TradingSettings settings = (TradingSettings)this.gvTrailings.GetFocusedRow();
if (settings == null)
{
return;
}
Ticker.Trailings.Remove(settings);
if (ChartControl != null)
{
ChartControl.RemoveIndicator(settings);
}
this.gcTrailings.RefreshDataSource();
}
public static TradingPosition CreatePosition(NewOrderPositionInfo positionInfo, CurrencyPair currencyPair, TradingSettings tradingSettings)
{
var now = DateTime.UtcNow;
var parentClientId = Guid.NewGuid();
var position = new TradingPosition
{
OpenPositionOrder = new Order
{
ClientId = parentClientId,
CurrencyPair = currencyPair,
Role = OrderRoleType.OpenPosition,
OrderSide = tradingSettings.BaseOrderSide,
OrderType = OrderType.StopLimit,
OrderStateType = OrderStateType.Suspended,
TimeInForce = OrderTimeInForceType.GoodTillCancelled,
Price = positionInfo.OpenPrice,
StopPrice = positionInfo.OpenStopPrice,
Created = now,
Updated = now
},
ClosePositionOrder = new Order
{
ClientId = Guid.NewGuid(),
ParentClientId = parentClientId,
CurrencyPair = currencyPair,
Role = OrderRoleType.ClosePosition,
OrderSide = tradingSettings.OppositeOrderSide,
OrderType = OrderType.StopLimit,
OrderStateType = OrderStateType.Pending,
TimeInForce = OrderTimeInForceType.GoodTillCancelled,
Price = positionInfo.ClosePrice,
StopPrice = positionInfo.CloseStopPrice,
Created = now,
Updated = now
},
StopLossOrder = new Order
{
ClientId = Guid.NewGuid(),
ParentClientId = parentClientId,
CurrencyPair = currencyPair,
Role = OrderRoleType.StopLoss,
OrderSide = tradingSettings.OppositeOrderSide,
OrderType = OrderType.StopMarket,
OrderStateType = OrderStateType.Pending,
TimeInForce = OrderTimeInForceType.GoodTillCancelled,
Price = 0,
StopPrice = positionInfo.StopLossPrice,
Created = now,
Updated = now
}
};
return(position);
}
public static void CalculateBuyOrderQuantity(this Order order, TradingBallance tradingBalance, TradingSettings settings)
{
order.Quantity = Math.Floor((tradingBalance.Available * (1 - order.CurrencyPair.TakeLiquidityRate) * settings.MaxOrderUsingBalancePart / order.Price) / order.CurrencyPair.QuantityIncrement) * order.CurrencyPair.QuantityIncrement;
}
private static void EvaluateStrategy(
int numberOfAccounts,
int accountId,
EvaluationResultContextManager contextManager,
ITradingStrategy strategy,
IDictionary <ParameterAttribute, object> parameterValues,
DateTime startDate,
DateTime endDate,
ICapitalManager capitalManager,
ITradingDataProvider dataProvider,
StockBlockRelationshipManager relationshipManager,
bool shouldDumpData,
TradingSettings tradingSettings)
//StockNameTable stockNameTable)
{
// OutputParameterValues(parameterValues);
EvaluationResultContext context;
lock (contextManager)
{
context = contextManager.CreateNewContext();
}
using (context)
{
StreamWriter dumpDataWriter = shouldDumpData ? context.DumpDataWriter : null;
var evaluator
= new TradingStrategyEvaluator(
numberOfAccounts,
accountId,
capitalManager,
strategy,
parameterValues,
dataProvider,
relationshipManager,
tradingSettings,
context.Logger,
dumpDataWriter);
//EventHandler<EvaluationProgressEventArgs> evaluationProgressHandler =
// (object obj, EvaluationProgressEventArgs e) =>
// {
// Console.Write("\r{0:yyyy-MM-dd} {1}%", e.EvaluationPeriod, (int)(e.EvaluationPercentage * 100.0));
// };
//evaluator.OnEvaluationProgress += evaluationProgressHandler;
try
{
evaluator.Evaluate();
}
catch (Exception ex)
{
Console.WriteLine();
Console.WriteLine("{0}", ex);
return;
}
if (!evaluator.Tracker.TransactionHistory.Any())
{
// no transaction
return;
}
var calculator
= new TradeMetricsCalculator(
//stockNameTable,
evaluator.Tracker,
dataProvider,
tradingSettings);
var metrics = calculator.Calculate();
// get the overall metric
var tradeMetrics = metrics as TradeMetric[] ?? metrics.ToArray();
var overallMetric = tradeMetrics.First(m => m.Code == TradeMetric.CodeForAll);
// summarize block related data
BlockTradingDetailSummarizer summarizer = new BlockTradingDetailSummarizer(evaluator.Tracker, dataProvider);
var details = summarizer.Summarize();
// save results
context.SaveResults(parameterValues, tradeMetrics, evaluator.ClosedPositions, details);
// create result summary;
var resultSummary = new ResultSummary();
resultSummary.Initialize(
context,
parameterValues,
startDate,
endDate,
overallMetric);
lock (contextManager)
{
contextManager.AddResultSummary(resultSummary);
}
}
}
static void Run(Options options)
{
// check the validation of options
CheckOptions(options);
// generate example files if necessary
if (options.ShouldGenerateExampleFiles)
{
GenerateExampleFiles(options);
return;
}
// register handler for Ctrl+C/Ctrl+Break
Console.CancelKeyPress += ConsoleCancelKeyPress;
// load settings from files
var tradingSettings = TradingSettings.LoadFromFile(options.TradingSettingsFile);
var combinedStrategySettings = CombinedStrategySettings.LoadFromFile(options.CombinedStrategySettingsFile);
var stockDataSettings = ChinaStockDataSettings.LoadFromFile(options.StockDataSettingsFile);
// load codes and stock name table
var stockNameTable = new StockNameTable(stockDataSettings.StockNameTableFile);
var codes = LoadCodeOfStocks(options.CodeFile);
// load stock block relationship if necessary, and filter codes
StockBlockRelationshipManager stockBlockRelationshipManager = null;
if (!string.IsNullOrWhiteSpace(options.StockBlockRelationshipFile))
{
stockBlockRelationshipManager = LoadStockBlockRelationship(options.StockBlockRelationshipFile);
// filter stock block relationship for loaded codes only
stockBlockRelationshipManager = stockBlockRelationshipManager.CreateSubsetForStocks(codes);
// codes will be updated according to stock-block relationships
codes = stockBlockRelationshipManager.Stocks;
}
var allDataFiles = codes
.Select(stockDataSettings.BuildActualDataFilePathAndName)
.ToArray();
// dump data for temporary usage, will be commented out in real code
// create data provider
//var dumpDataProvider
// = new ChinaStockDataProvider(
// stockNameTable,
// allDataFiles,
// options.StartDate,
// options.EndDate,
// 0);
//DumpData(dumpDataProvider);
// generate evaluation time intervals
var intervals =
GenerateIntervals(
options.StartDate,
options.EndDate,
options.YearInterval)
.ToArray();
using (_contextManager = new EvaluationResultContextManager(options.EvaluationName))
{
// save evluation summary
var evaluationSummary = new EvaluationSummary
{
StrategySettings = combinedStrategySettings.GetActiveSettings(),
TradingSettings = tradingSettings,
DataSettings = stockDataSettings,
StartTime = options.StartDate,
EndTime = options.EndDate,
YearInterval = options.YearInterval,
ObjectNames = codes
.Select(c => stockNameTable.ContainsStock(c)
? c + '|' + stockNameTable[c].Names[0]
: c)
.ToArray()
};
_contextManager.SaveEvaluationSummary(evaluationSummary);
Action <Tuple <DateTime, DateTime> > evaluatingAction =
(Tuple <DateTime, DateTime> interval) =>
{
if (_toBeStopped)
{
return;
}
// initialize data provider
var dataProvider
= new ChinaStockDataProvider(
stockNameTable,
allDataFiles,
interval.Item1, // interval start date
interval.Item2, // interval end date
options.WarmupPeriods);
var finalCodes = dataProvider.GetAllTradingObjects().Select(to => to.Code);
var filteredStockBlockRelationshipManager = stockBlockRelationshipManager == null
? null
: stockBlockRelationshipManager.CreateSubsetForStocks(finalCodes);
// initialize combined strategy assembler
var combinedStrategyAssembler = new CombinedStrategyAssembler(combinedStrategySettings, true);
var strategyInstances
= new List <Tuple <CombinedStrategy, IDictionary <ParameterAttribute, object> > >();
IDictionary <ParameterAttribute, object> values;
while ((values = combinedStrategyAssembler.GetNextSetOfParameterValues()) != null)
{
var strategy = combinedStrategyAssembler.NewStrategy();
strategyInstances.Add(Tuple.Create(strategy, values));
}
if (strategyInstances.Any())
{
// initialize ResultSummary
ResultSummary.Initialize(strategyInstances.First().Item2, options.EnableERatioOutput);
}
SetTotalStrategyNumber(intervals.Count() * strategyInstances.Count());
try
{
Parallel.For(
0,
strategyInstances.Count,
// below line is for performance profiling only.
new ParallelOptions()
{
MaxDegreeOfParallelism = Environment.ProcessorCount * 2
},
t =>
{
for (int i = 0; i < options.AccountNumber; ++i)
{
if (_toBeStopped)
{
return;
}
ICapitalManager capitalManager = options.ProportionOfCapitalForIncrementalPosition > 0.0
? (ICapitalManager) new AdvancedCapitalManager(options.InitialCapital, options.ProportionOfCapitalForIncrementalPosition)
: (ICapitalManager) new SimpleCapitalManager(options.InitialCapital)
;
EvaluateStrategy(
options.AccountNumber,
i,
_contextManager,
strategyInstances[t].Item1,
strategyInstances[t].Item2,
interval.Item1,
interval.Item2,
capitalManager,
dataProvider,
filteredStockBlockRelationshipManager,
options.ShouldDumpData,
tradingSettings);
}
IncreaseProgress();
// reset the strategy object to ensure the referred IEvaluationContext object being
// released, otherwise it will never be released until all strategies are evaluated.
// This is a bug hid for long time.
strategyInstances[t] = null;
});
}
catch
{
_toBeStopped = true;
}
finally
{
lock (_contextManager)
{
// save result summary
_contextManager.SaveResultSummaries();
}
}
};
if (options.ParallelExecution)
{
Parallel.ForEach(intervals, evaluatingAction);
}
else
{
foreach (var interval in intervals)
{
evaluatingAction(interval);
}
}
}
_contextManager = null;
Console.WriteLine();
Console.WriteLine("Done.");
}
public static void Delete(TradingSettings tradingsettings)
{
Delete(tradingsettings.Identifier);
}
