public static List <decimal[]> Estimate_Matrix_Profit(AppTypes.TimeRanges timeRange, AppTypes.TimeScale timeScale,
StringCollection stockCodeList, StringCollection strategyList, EstimateOptions option)
{
List <decimal[]> retList = new List <decimal[]>();
for (int rowId = 0; rowId < stockCodeList.Count; rowId++)
{
Data.ClearCache();
AnalysisData analysisData = new AnalysisData(timeRange, timeScale, stockCodeList[rowId], DataAccessMode.Local);
decimal[] rowRetList = new decimal[strategyList.Count];
for (int colId = 0; colId < strategyList.Count; colId++)
{
Data.TradePoints advices = Analysis(analysisData, strategyList[colId]);
if (advices != null)
{
rowRetList[colId] = EstimateTrading_Profit(analysisData, ToTradePointInfo(advices), option);
}
else
{
rowRetList[colId] = 0;
}
}
retList.Add(rowRetList);
}
return(retList);
}
/// <summary>
/// Constructors to create a market indicator's data for specific stock list
/// </summary>
/// <param name="timeRange"></param>
/// <param name="timeScale"></param>
/// <param name="stockCodes"></param>
public MarketData(AppTypes.TimeRanges timeRange, AppTypes.TimeScale timeScale, StringCollection stockCodes)
{
DateTime startDate = DateTime.Today, endDate = DateTime.Today;
AppTypes.GetDate(timeRange, out startDate, out endDate);
this.Init(startDate, endDate, timeScale, stockCodes);
}
public static List <double[]> Estimate_Matrix_LastBizWeight(AppTypes.TimeRanges timeRange, AppTypes.TimeScale timeScale,
StringCollection stockCodeList, StringCollection strategyList)
{
List <double[]> retList = new List <double[]>();
for (int rowId = 0; rowId < stockCodeList.Count; rowId++)
{
Data.ClearCache();
AnalysisData analysisData = new AnalysisData(timeRange, timeScale, stockCodeList[rowId], DataAccessMode.Local);
double[] rowRetList = new double[strategyList.Count];
for (int colId = 0; colId < strategyList.Count; colId++)
{
Data.TradePoints tradePoints = Analysis(analysisData, strategyList[colId]);
if (tradePoints != null && tradePoints.Count > 0)
{
rowRetList[colId] = (tradePoints[tradePoints.Count - 1] as TradePointInfo).BusinessInfo.Weight;
}
else
{
rowRetList[colId] = double.NaN;
}
}
retList.Add(rowRetList);
}
return(retList);
}
private void dataGrid_CellContentDoubleClick(object sender, DataGridViewCellEventArgs e)
{
try
{
common.controls.baseDataGridView resultDataGrid = this.CurrentDataGridView;
if (resultDataGrid == null)
{
return;
}
string stockCode = resultTab.SelectedTab.Name;
if (resultDataGrid.CurrentRow == null)
{
return;
}
AppTypes.TimeRanges timeRange = AppTypes.TimeRangeFromCode(resultDataGrid.Columns[e.ColumnIndex].DataPropertyName);
databases.tmpDS.stockCodeRow stockCodeRow = DataAccess.Libs.myStockCodeTbl.FindBycode(stockCode);
if (stockCodeRow == null)
{
return;
}
string strategyCode = resultDataGrid.CurrentRow.Cells[0].Value.ToString();
DataParams dataParam = new DataParams(timeScaleCb.myValue.Code, timeRange, 0);
ShowTradeTransactions(stockCodeRow, strategyCode, dataParam);
}
catch (Exception er)
{
this.ShowError(er);
}
}
private void dataGrid_CellContentDoubleClick(object sender, DataGridViewCellEventArgs e)
{
try
{
common.controls.baseDataGridView resultDataGrid = this.CurrentDataGridView;
if (resultDataGrid == null)
{
return;
}
string stockCode = resultTab.SelectedTab.Name;
if (resultDataGrid.CurrentRow == null)
{
return;
}
AppTypes.TimeRanges timeRange = AppTypes.TimeRangeFromCode(resultDataGrid.Columns[e.ColumnIndex].DataPropertyName);
data.baseDS.stockCodeRow stockCodeRow = application.dataLibs.FindAndCache(myDataSet.stockCode, stockCode);
if (stockCodeRow == null)
{
return;
}
string strategyCode = resultDataGrid.CurrentRow.Cells[0].Value.ToString();
ShowTradeTransactions(stockCodeRow, strategyCode, timeRange, cbTimeScale.myValue);
}
catch (Exception er)
{
this.ShowError(er);
}
}
private void openMenuItem_Click(object sender, EventArgs e)
{
try
{
common.controls.baseDataGridView resultDataGrid = this.CurrentDataGridView;
if (resultDataGrid == null)
{
return;
}
string stockCode = resultTab.SelectedTab.Name;
data.baseDS.stockCodeRow stockCodeRow = application.dataLibs.FindAndCache(myDataSet.stockCode, stockCode);
if (stockCodeRow != null)
{
return;
}
AppTypes.TimeRanges timeRange = AppTypes.TimeRangeFromCode(resultDataGrid.Columns[resultDataGrid.ColumnCount - 1].Name);
ShowStock(stockCodeRow, timeRange, cbTimeScale.myValue);
}
catch (Exception er)
{
this.ShowError(er);
}
}
private void profitDetailMenu_Click(object sender, EventArgs e)
{
try
{
common.controls.baseDataGridView resultDataGrid = this.CurrentDataGridView;
if (resultDataGrid == null || resultDataGrid.CurrentRow == null || resultDataGrid.CurrentCell == null)
{
return;
}
if (resultDataGrid.CurrentCell.ColumnIndex <= 0)
{
return;
}
string stockCode = resultTab.SelectedTab.Name;
data.tmpDS.stockCodeRow stockCodeRow = DataAccess.Libs.myStockCodeTbl.FindBycode(stockCode);
if (stockCodeRow == null)
{
return;
}
application.Strategy.Meta meta = application.Strategy.Libs.FindMetaByName(resultDataGrid.CurrentRow.Cells[0].Value.ToString());
int colId = resultDataGrid.CurrentCell.ColumnIndex;
AppTypes.TimeRanges timeRange = AppTypes.TimeRangeFromCode(resultDataGrid.Columns[colId].DataPropertyName);
ShowTradeTransactions(stockCodeRow, meta.Code, timeRange, timeScaleCb.myValue);
}
catch (Exception er)
{
this.ShowError(er);
}
}
public List <double[]> Estimate_Matrix_LastBizWeight(AppTypes.TimeRanges timeRange, string timeScaleCode,
string[] stockCodeList, string[] strategyList)
{
return(application.Strategy.Libs.Estimate_Matrix_LastBizWeight(timeRange, AppTypes.TimeScaleFromCode(timeScaleCode),
common.system.List2Collection(stockCodeList),
common.system.List2Collection(strategyList)));
}
/// <summary>
/// Constructors to create a market indicator's data for all enable stock
/// </summary>
/// <param name="timeRange"></param>
/// <param name="timeScale"></param>
public MarketData(AppTypes.TimeRanges timeRange, AppTypes.TimeScale timeScale)
{
DateTime startDate = DateTime.Today, endDate = DateTime.Today;
AppTypes.GetDate(timeRange, out startDate, out endDate);
this.Init(startDate, endDate, timeScale, null);
}
public List <decimal[]> Estimate_Matrix_Profit(AppTypes.TimeRanges timeRange, string timeScaleCode,
string[] stockCodeList, string[] strategyList,
EstimateOptions option)
{
return(application.Strategy.Libs.Estimate_Matrix_Profit(timeRange, AppTypes.TimeScaleFromCode(timeScaleCode),
common.system.List2Collection(stockCodeList),
common.system.List2Collection(strategyList), option));
}
protected void ShowStock(string stockCode, AppTypes.TimeRanges timeRange, AppTypes.TimeScale timeScale)
{
if (myShowStock == null)
{
return;
}
myShowStock(stockCode, timeRange, timeScale);
}
public BaseAnalysisData(string stockCode, AppTypes.TimeScale timeScale, AppTypes.TimeRanges timeRange, int dataMaxCount)
{
this.DataStockCode = stockCode;
this.DataTimeScale = timeScale;
this.DataTimeRange = timeRange;
this.DataMaxCount = dataMaxCount;
ClearCache();
LoadData();
}
public TradePointInfo[] GetTradePointWithEstimationDetail(AppTypes.TimeRanges timeRange, string timeScaleCode,
string stockCode, string strategyCode, EstimateOptions options,
out data.tmpDS.tradeEstimateDataTable toTbl)
{
string dataKey = LoadAnalysisData(timeRange, timeScaleCode, stockCode, false);
TradePointInfo[] tradePoints = Analysis(dataKey, strategyCode);
toTbl = application.Strategy.Libs.EstimateTrading_Details(sysDataCache.Find(dataKey) as AnalysisData, tradePoints, options);
return(tradePoints);
}
/// <summary>
/// Get data and store in cache. Depend on forceReadNew, cached data can be used to boost perfomance
/// </summary>
/// <param name="timeRange"></param>
/// <param name="timeScaleCode"></param>
/// <param name="code"></param>
/// <param name="forceReadNew"> if true always read from database, ignore the cached data</param>
/// <returns>Data key used for data accessing</returns>
public string LoadAnalysisData(AppTypes.TimeRanges timeRange, string timeScaleCode, string code, bool forceReadNew)
{
string cacheName = MakeCacheKey(timeRange, timeScaleCode, code);
if (forceReadNew || sysDataCache.Find(cacheName) == null)
{
AnalysisData myData = new AnalysisData(timeRange, AppTypes.TimeScaleFromCode(timeScaleCode), code, DataAccessMode.Local);
sysDataCache.Add(cacheName, myData);
}
return(cacheName);
}
private void DoBackTesting()
{
this.ShowReccount("");
this.myValueType = ValueTypes.Amount;
this.Amount2PercentDenominator = Settings.sysStockTotalCapAmt;
StringCollection strategyList = strategyClb.myCheckedValues;
StringCollection stockCodeList = codeSelectLb.myValues;
//Analysis cached data so we MUST reset to clear cache to ensure the system run correctly
DataAccess.Libs.ClearCache();
EstimateOptions estimateOption = new EstimateOptions();
DataTable retsultTbl = CreateEstimateTbl(strategyList);
SetDataGrid(resultDataGrid, retsultTbl);
progressBar.Value = 0; progressBar.Minimum = 0; progressBar.Maximum = stockCodeList.Count;
AppTypes.TimeRanges timeRange = periodicityEd.myTimeRange;
string timeScaleCode = periodicityEd.myTimeScale.Code;
string[] strategy = common.system.Collection2List(strategyList);
this.ShowReccount(progressBar.Value.ToString() + "/" + progressBar.Maximum.ToString());
int codeStartIdx = 0, codeEndIdx = 0;
while (codeStartIdx < stockCodeList.Count)
{
codeEndIdx += Settings.sysNumberOfItemsInBatchProcess;
if (codeEndIdx >= stockCodeList.Count)
{
codeEndIdx = stockCodeList.Count - 1;
}
string[] stocks = common.system.Collection2List(stockCodeList, codeStartIdx, codeEndIdx);
decimal[][] retList = DataAccess.Libs.Estimate_Matrix_Profit(timeRange, timeScaleCode, stocks, strategy, estimateOption);
for (int idx = 0; idx < retList.Length; idx++)
{
DataRow row = retsultTbl.Rows.Add(stockCodeList[idx + codeStartIdx]);
for (int colId = 0; colId < retList[idx].Length; colId++)
{
row[colId + 1] = retList[idx][colId];
}
}
Application.DoEvents();
codeStartIdx = codeEndIdx + 1;
progressBar.Value = codeEndIdx + 1;
this.ShowReccount(progressBar.Value.ToString() + "/" + progressBar.Maximum.ToString());
}
common.system.RemoveEmptyItems(retsultTbl);
SetDataGrid(resultDataGrid, retsultTbl);
SetEstimateDataGrid(application.Strategy.Libs.GetStrategyStats(retsultTbl));
}
private void DoRankingDB()
{
this.myValueType = ValueTypes.Amount;
this.Amount2PercentDenominator = Settings.sysStockTotalCapAmt;
resultTab.TabPages.Clear();
StringCollection stockCodeList = codeListLb.myValues;
StringCollection timeRangeList = timeRangeLb.myCheckedValues;
string[] strategyList = common.system.Collection2List(strategyClb.myCheckedValues);
progressBar.Value = 0; progressBar.Minimum = 0; progressBar.Maximum = stockCodeList.Count * timeRangeList.Count;
EstimateOptions estimateOption = new EstimateOptions();
for (int stockCodeId = 0; stockCodeId < stockCodeList.Count; stockCodeId++)
{
string stockCode = stockCodeList[stockCodeId].ToString();
DataTable testRetsultTbl = CreateDataTable(timeRangeList, strategyList);
common.controls.baseDataGridView resultGrid = CreateResultGrid(stockCode, testRetsultTbl);
for (int colId = 0; colId < timeRangeList.Count; colId++)
{
try
{
progressBar.Value++;
Application.DoEvents();
this.ShowReccount(progressBar.Value.ToString() + "/" + progressBar.Maximum.ToString());
AppTypes.TimeRanges timeRange = AppTypes.TimeRangeFromCode(timeRangeList[colId]);
application.AnalysisData analysisData = new application.AnalysisData(timeRange, timeScaleCb.myValue, stockCode,
commonClass.DataAccessMode.WebService);
for (int rowId = 0; rowId < strategyList.Length; rowId++)
{
testRetsultTbl.Rows[rowId][colId + 1] = 0;
//Analysis cached data so we MUST clear cache to ensure the system run correctly
application.Strategy.Data.ClearCache();
application.Strategy.Data.TradePoints advices = application.Strategy.Libs.Analysis(analysisData, strategyList[rowId]);
if (advices != null)
{
testRetsultTbl.Rows[rowId][colId + 1] =
application.Strategy.Libs.EstimateTrading_Profit(analysisData, application.Strategy.Libs.ToTradePointInfo(advices), estimateOption);
}
}
}
catch (Exception er)
{
this.WriteError(stockCodeList[stockCodeId] + " : " + timeRangeList[colId] + " : " + strategyList[colId], er.Message);
//this.ShowError(er);
}
}
}
}
private void allProfitDetailMenu_Click(object sender, EventArgs e)
{
try
{
using (new DataAccess.PleaseWait())
{
common.controls.baseDataGridView resultDataGrid = this.CurrentDataGridView;
if (resultDataGrid == null)
{
return;
}
string stockCode = resultTab.SelectedTab.Name;
data.tmpDS.stockCodeRow stockCodeRow = DataAccess.Libs.myStockCodeTbl.FindBycode(stockCode);
if (stockCodeRow == null)
{
return;
}
if (resultDataGrid.SelectedRows.Count > 0)
{
for (int rowId = 0; rowId < resultDataGrid.SelectedRows.Count; rowId++)
{
application.Strategy.Meta meta = application.Strategy.Libs.FindMetaByName(resultDataGrid.SelectedRows[rowId].Cells[0].Value.ToString());
for (int idx = 1; idx < resultDataGrid.ColumnCount; idx++)
{
AppTypes.TimeRanges timeRange = AppTypes.TimeRangeFromCode(resultDataGrid.Columns[idx].DataPropertyName);
ShowTradeTransactions(stockCodeRow, meta.Code, timeRange, timeScaleCb.myValue);
}
}
}
else
{
if (resultDataGrid.CurrentRow != null)
{
application.Strategy.Meta meta = application.Strategy.Libs.FindMetaByName(resultDataGrid.CurrentRow.Cells[0].Value.ToString());
for (int idx = 1; idx < resultDataGrid.ColumnCount; idx++)
{
AppTypes.TimeRanges timeRange = AppTypes.TimeRangeFromCode(resultDataGrid.Columns[idx].DataPropertyName);
ShowTradeTransactions(stockCodeRow, meta.Code, timeRange, timeScaleCb.myValue);
}
}
}
}
}
catch (Exception er)
{
this.ShowError(er);
}
}
private void profitEstimateMenu_Click(object sender, EventArgs e)
{
try
{
common.controls.baseDataGridView resultDataGrid = this.CurrentDataGridView;
if (resultDataGrid == null)
{
return;
}
string stockCode = resultTab.SelectedTab.Name;
string strategyCode = "";
data.baseDS.stockCodeRow stockCodeRow = application.dataLibs.FindAndCache(myDataSet.stockCode, stockCode);
if (stockCodeRow == null)
{
return;
}
if (resultDataGrid.SelectedRows.Count > 0)
{
for (int rowId = 0; rowId < resultDataGrid.SelectedRows.Count; rowId++)
{
strategyCode = resultDataGrid.SelectedRows[rowId].Cells[0].Value.ToString();
for (int idx = 1; idx < resultDataGrid.ColumnCount; idx++)
{
AppTypes.TimeRanges timeRange = AppTypes.TimeRangeFromCode(resultDataGrid.Columns[idx].DataPropertyName);
ShowTradeTransactions(stockCodeRow, strategyCode, timeRange, cbTimeScale.myValue);
}
}
}
else
{
if (resultDataGrid.CurrentRow != null)
{
strategyCode = resultDataGrid.CurrentRow.Cells[0].Value.ToString();
for (int idx = 1; idx < resultDataGrid.ColumnCount; idx++)
{
AppTypes.TimeRanges timeRange = AppTypes.TimeRangeFromCode(resultDataGrid.Columns[idx].DataPropertyName);
ShowTradeTransactions(stockCodeRow, strategyCode, timeRange, cbTimeScale.myValue);
}
}
}
}
catch (Exception er)
{
this.ShowError(er);
}
}
public static tradeAnalysis GetForm(string stockCode, AppTypes.TimeRanges timeRange, AppTypes.TimeScale timeScale)
{
string cacheKey = typeof(tradeAnalysis).ToString();
tradeAnalysis form = (tradeAnalysis)common.Data.dataCache.Find(cacheKey);
if (form == null || form.IsDisposed)
{
form = new Forms.tradeAnalysis();
common.Data.dataCache.Add(cacheKey, form);
}
form.ChartTimeRange = timeRange;
form.ChartTimeScale = timeScale;
form.ChartPriceType = AppTypes.ChartTypes.Line;
form.UseStock(DataAccess.Libs.myStockCodeTbl.FindBycode(stockCode));
form.Visible = true;
return(form);
}
private void DoRanking()
{
this.myValueType = ValueTypes.Amount;
this.Amount2PercentDenominator = application.Settings.sysStockTotalCapAmt;
resultTab.TabPages.Clear();
StringCollection stockCodeList = stockCodeSelectLb.myValues;
StringCollection strategyList = strategyClb.myCheckedValues;
StringCollection timeRangeList = timeRangeLb.myCheckedValues;
progressBar.Value = 0; progressBar.Minimum = 0; progressBar.Maximum = stockCodeList.Count * timeRangeList.Count;
for (int stockCodeId = 0; stockCodeId < stockCodeList.Count; stockCodeId++)
{
string stockCode = stockCodeList[stockCodeId].ToString();
DataTable testRetsultTbl = CreateDataTable(timeRangeList, strategyList);
common.controls.baseDataGridView resultGrid = CreateResultGrid(stockCode, testRetsultTbl);
for (int colId = 0; colId < timeRangeList.Count; colId++)
{
AppTypes.TimeRanges timeRange = AppTypes.TimeRangeFromCode(timeRangeList[colId]);
decimal profit = 0;
application.Data analysisData = new application.Data(timeRange, cbTimeScale.myValue, stockCode);
for (int rowId = 0; rowId < strategyList.Count; rowId++)
{
profit = 0;
//Analysis cached data so we MUST clear cache to ensure the system run correctly
Strategy.Data.ClearCache();
Strategy.TradePoints advices = Strategy.Libs.Analysis(analysisData, strategyList[rowId]);
if (advices != null)
{
myTmpDS.tradeEstimate.Clear();
Strategy.Libs.EstimateTrading(analysisData, advices, new Strategy.Libs.EstimateOptions(), myTmpDS.tradeEstimate);
profit = (myTmpDS.tradeEstimate.Count == 0 ? 0 : profit = myTmpDS.tradeEstimate[myTmpDS.tradeEstimate.Count - 1].profit);
}
testRetsultTbl.Rows[rowId][colId + 1] = profit;
}
progressBar.Value++;
Application.DoEvents();
}
}
FormResize();
}
public strategyRanking()
{
try
{
InitializeComponent();
codeListLb.LoadData();
timeScaleCb.LoadData();
strategyClb.LoadData(AppTypes.StrategyTypes.Strategy, true, false);
AppTypes.TimeRanges[] timeRanges = new AppTypes.TimeRanges[]
{
AppTypes.TimeRanges.M1, AppTypes.TimeRanges.M3,AppTypes.TimeRanges.M6,
AppTypes.TimeRanges.Y1,AppTypes.TimeRanges.Y2,AppTypes.TimeRanges.Y3,AppTypes.TimeRanges.Y4,AppTypes.TimeRanges.Y5,
};
timeRangeLb.LoadData(timeRanges);
optionPnl.Location = new Point(0, 0);
}
catch (Exception er)
{
this.ShowError(er);
}
}
public strategyRanking()
{
try
{
InitializeComponent();
codeListLb.LoadData();
timeScaleCb.LoadData();
strategyClb.LoadData(AppTypes.StrategyTypes.Strategy, true, false);
AppTypes.TimeRanges[] timeRanges = new AppTypes.TimeRanges[]
{
AppTypes.TimeRanges.M1, AppTypes.TimeRanges.M3, AppTypes.TimeRanges.M6,
AppTypes.TimeRanges.Y1, AppTypes.TimeRanges.Y2, AppTypes.TimeRanges.Y3, AppTypes.TimeRanges.Y4, AppTypes.TimeRanges.Y5,
};
timeRangeLb.LoadData(timeRanges);
optionPnl.Location = new Point(0, 0);
}
catch (Exception er)
{
this.ShowError(er);
}
}
protected void ShowTradeTransactions(data.tmpDS.stockCodeRow stockCodeRow, string strategyCode,
AppTypes.TimeRanges timeRange, AppTypes.TimeScale timeScale)
{
string formName = stockCodeRow.code.Trim() + "," + timeRange.ToString() + "," + application.Strategy.Libs.GetMetaName(strategyCode) + "," + timeScale.Code;
profitEstimate myForm = profitEstimate.GetForm(formName);
myForm.myTimeRange = timeRange;
myForm.myTimeScale = timeScale;
myForm.myStockCode = stockCodeRow.code;
myForm.myOptions = new EstimateOptions();
myForm.myStrategyCode = strategyCode;
myForm.ReLoad();
myForm.Text = "(" + formName + ")";
if (this.myDockedPane != null)
{
myForm.Show(this.myDockedPane);
}
else
{
myForm.ShowDialog();
}
}
private void openMenuItem_Click(object sender, EventArgs e)
{
try
{
string stockCode = resultTab.SelectedTab.Name;
if (this.CurrentDataGridView == null)
{
return;
}
AppTypes.TimeRanges timeRange = AppTypes.TimeRanges.All;
common.controls.baseDataGridView resultDataGrid = this.CurrentDataGridView;
if (resultDataGrid.CurrentCell != null && resultDataGrid.CurrentCell.ColumnIndex > 0)
{
int colId = resultDataGrid.CurrentCell.ColumnIndex;
timeRange = AppTypes.TimeRangeFromCode(resultDataGrid.Columns[colId].DataPropertyName);
}
ShowStock(stockCode, timeRange, timeScaleCb.myValue);
}
catch (Exception er)
{
this.ShowError(er);
}
}
/// <summary>
/// Thuc hien viec sap xep chien luoc
/// </summary>
private void DoRanking()
{
this.ShowReccount("");
this.myValueType = ValueTypes.Amount;
this.Amount2PercentDenominator = Settings.sysStockTotalCapAmt;
resultTab.TabPages.Clear();
StringCollection stockCodeList = codeListLb.myValues;
StringCollection timeRangeList = timeRangeLb.myCheckedValues;
string[] strategyList = common.system.Collection2List(strategyClb.myCheckedValues);
progressBar.Value = 0; progressBar.Minimum = 0; progressBar.Maximum = stockCodeList.Count;
string timeScaleCode = timeScaleCb.myValue.Code;
EstimateOptions estimateOption = new EstimateOptions();
DataAccess.Libs.ClearCache();
ArrayList resulTblList = new ArrayList();
this.ShowReccount(progressBar.Value.ToString() + "/" + progressBar.Maximum.ToString());
int codeStartIdx = 0, codeEndIdx = 0;
while (codeStartIdx < stockCodeList.Count)
{
codeEndIdx += Settings.sysNumberOfItemsInBatchProcess;
if (codeEndIdx >= stockCodeList.Count)
{
codeEndIdx = stockCodeList.Count - 1;
}
//Create Tab and grid for each code
resulTblList.Clear();
string[] processCodeList = new string[codeEndIdx - codeStartIdx + 1];
for (int idx1 = codeStartIdx, idx2 = 0; idx1 <= codeEndIdx; idx1++, idx2++)
{
resulTblList.Add(CreateDataTable(timeRangeList, strategyList));
CreateResultGrid(stockCodeList[idx1], resulTblList[idx2] as DataTable);
processCodeList[idx2] = stockCodeList[idx1];
}
for (int colId = 0; colId < timeRangeList.Count; colId++)
{
AppTypes.TimeRanges timeRange = AppTypes.TimeRangeFromCode(timeRangeList[colId]);
decimal[][] profitList = DataAccess.Libs.Estimate_Matrix_Profit(timeRange, timeScaleCode, processCodeList, strategyList, estimateOption);
for (int idx1 = 0; idx1 < profitList.Length; idx1++)
{
DataTable tbl = resulTblList[idx1] as DataTable;
for (int idx2 = 0; idx2 < profitList[idx1].Length; idx2++)
{
tbl.Rows[idx2][colId + 1] = profitList[idx1][idx2];
}
}
Application.DoEvents();
}
progressBar.Value = codeEndIdx + 1;
this.ShowReccount(progressBar.Value.ToString() + "/" + progressBar.Maximum.ToString());
codeStartIdx = codeEndIdx + 1;
}
}
//Swicth language. Note that the order of items must be preserved
public static void SetLanguage(ComboBox.ObjectCollection items, Type type)
{
StringCollection saveKeys = new StringCollection();
for (int idx = 0; idx < items.Count; idx++)
{
common.myComboBoxItem item = (common.myComboBoxItem)items[idx];
saveKeys.Add(item.Value);
}
if (type == typeof(AppTypes.TimeScale))
{
items.Clear();
for (int idx = 0; idx < saveKeys.Count; idx++)
{
object obj = FindTimeScaleByCode(saveKeys[idx]);
if (obj == null)
{
continue;
}
AppTypes.TimeScale item = (AppTypes.TimeScale)obj;
items.Add(new common.myComboBoxItem(item.Description, item.Code));
}
return;
}
if (type == typeof(AppTypes.TradeActions))
{
items.Clear();
for (int idx = 0; idx < saveKeys.Count; idx++)
{
object obj = FindCodeInEnum(saveKeys[idx], typeof(AppTypes.TradeActions));
if (obj == null)
{
continue;
}
AppTypes.TradeActions item = (AppTypes.TradeActions)obj;
items.Add(new common.myComboBoxItem(AppTypes.Type2Text(item), item.ToString()));
}
return;
}
if (type == typeof(AppTypes.TimeRanges))
{
items.Clear();
for (int idx = 0; idx < saveKeys.Count; idx++)
{
object obj = FindCodeInEnum(saveKeys[idx], typeof(AppTypes.TimeRanges));
if (obj == null)
{
continue;
}
AppTypes.TimeRanges item = (AppTypes.TimeRanges)obj;
items.Add(new common.myComboBoxItem(AppTypes.Type2Text(item), item.ToString()));
}
return;
}
if (type == typeof(AppTypes.StrategyTypes))
{
items.Clear();
for (int idx = 0; idx < saveKeys.Count; idx++)
{
object obj = FindCodeInEnum(saveKeys[idx], typeof(AppTypes.StrategyTypes));
if (obj == null)
{
continue;
}
AppTypes.StrategyTypes item = (AppTypes.StrategyTypes)obj;
items.Add(new common.myComboBoxItem(AppTypes.Type2Text(item), item.ToString()));
}
return;
}
if (type == typeof(AppTypes.Sex))
{
items.Clear();
for (int idx = 0; idx < saveKeys.Count; idx++)
{
object obj = FindCodeInEnum(saveKeys[idx], typeof(AppTypes.Sex));
if (obj == null)
{
continue;
}
AppTypes.Sex item = (AppTypes.Sex)obj;
items.Add(new common.myComboBoxItem(AppTypes.Type2Text(item), item.ToString()));
}
return;
}
if (type == typeof(AppTypes.CommonStatus))
{
items.Clear();
for (int idx = 0; idx < saveKeys.Count; idx++)
{
object obj = FindCodeInEnum(saveKeys[idx], typeof(AppTypes.CommonStatus));
if (obj == null)
{
continue;
}
AppTypes.CommonStatus item = (AppTypes.CommonStatus)obj;
items.Add(new common.myComboBoxItem(AppTypes.Type2Text(item), item.ToString()));
}
return;
}
if (type == typeof(AppTypes.ChartTypes))
{
items.Clear();
for (int idx = 0; idx < saveKeys.Count; idx++)
{
object obj = FindCodeInEnum(saveKeys[idx], typeof(AppTypes.ChartTypes));
if (obj == null)
{
continue;
}
AppTypes.ChartTypes item = (AppTypes.ChartTypes)obj;
items.Add(new common.myComboBoxItem(AppTypes.Type2Text(item), item.ToString()));
}
return;
}
if (type == typeof(AppTypes.BizSectorTypes))
{
items.Clear();
for (int idx = 0; idx < saveKeys.Count; idx++)
{
object obj = FindCodeInEnum(saveKeys[idx], typeof(AppTypes.BizSectorTypes));
if (obj == null)
{
continue;
}
AppTypes.BizSectorTypes item = (AppTypes.BizSectorTypes)obj;
items.Add(new common.myComboBoxItem(AppTypes.Type2Text(item), item.ToString()));
}
return;
}
}
public DataParams(string timeScale,AppTypes.TimeRanges timeRange,int maxDataCount)
{
this.TimeRange = timeRange;
this.MaxDataCount = maxDataCount;
this.TimeScale = timeScale;
}
public static double[][] Estimate_Matrix_LastBizWeight(AppTypes.TimeRanges timeRange, string timeScaleCode,
string[] stockCodeList, string[] strategyList)
{
return(myClient.Estimate_Matrix_LastBizWeight(timeRange, timeScaleCode, stockCodeList, strategyList));
}
private static string MakeCacheKey(AppTypes.TimeRanges timeRange, string timeScaleCode, string code)
{
return("data" + "-" + code + "-" + timeRange.ToString() + "-" + timeScaleCode);
}
public static decimal[][] Estimate_Matrix_Profit(AppTypes.TimeRanges timeRange, string timeScaleCode,
string[] stocks, string[] strategyList, EstimateOptions option)
{
return(myClient.Estimate_Matrix_Profit(timeRange, timeScaleCode, stocks, strategyList, option));
}
public static TradePointInfo[] GetTradePointWithEstimationDetail(AppTypes.TimeRanges timeRange, string timeScaleCode,
string stockCode, string strategyCode, EstimateOptions options,
out data.tmpDS.tradeEstimateDataTable toTbl)
{
return(myClient.GetTradePointWithEstimationDetail(out toTbl, timeRange, timeScaleCode, stockCode, strategyCode, options));
}
public data.baseDS.priceDataDataTable GetAnalysis_Data(AppTypes.TimeRanges timeRange, string timeScaleCode, string stockCode, out int firstData)
{
string dataKey = LoadAnalysisData(timeRange, timeScaleCode, stockCode, true);
return(GetAnalysis_Data_ByKey(dataKey, out firstData));
}
