void RefreshPK10NoClosedChances()
{
DbChanceList dc = new PK10ExpectReader().getNoCloseChances(null);
if (dc == null)
{
return;
}
DataTable dt = dc.Table;
SetDataGridDataTable(dg_NoCloseChances, dt);
}
void TestML()
{
ExpectList el = new PK10ExpectReader().ReadNewestData(DateTime.Now.AddDays(-17));//至少180*16天+当天的记录数>1000
//MessageBox.Show(el.LastData.OpenCode);
var mapping = new DaXiao_Mapping();
var classifier = BayesPointMachineClassifier.CreateMulticlassClassifier(mapping);
FeatureLabeItems trainingSet = new PKDataListSetFactory(el).OccurFeatureAndLabels();
classifier.Train(trainingSet.FeatureVectors, trainingSet.Labels);
List <Vector> testVector = new List <Vector>();//1
Vector v = Vector.Zero(1);
v[0] = 1;
testVector.Add(v);
var predictions = classifier.PredictDistribution(testVector);
string estimate = classifier.Predict(0, testVector);
MessageBox.Show(estimate);
}
private void ReceivePK10CData()
{
Log("接收数据", "准备接收数据");
PK10_HtmlDataClass hdc = new PK10_HtmlDataClass();
ExpectList el = hdc.getExpectList();
////if(el != null && el.Count>0)
////{
//// Log("接收到的最新数据",el.LastData.ToString());
////}
if (el == null || el.Count == 0)
{
Log("接收数据", "未接收到数据");
return;
}
DateTime CurrTime = DateTime.Now;
try
{
PK10ExpectReader rd = new PK10ExpectReader();
ExpectList currEl = rd.ReadNewestData(DateTime.Today.AddDays(-1));
if ((currEl == null || currEl.Count == 0) || (el.Count > 0 && currEl.Count > 0 && el.LastData.ExpectIndex > currEl.LastData.ExpectIndex))//获取到新数据
{
Log("接收到数据", string.Format("接收到数据！{0}", el.LastData.ToString()));
int CurrMin = DateTime.Now.Minute % 5;
int CurrSec = DateTime.Now.Second;
this.Tm_ForPK10.Interval = (CurrMin % 5 < 2 ? 2 : 7 - CurrMin) * 60000 - (CurrSec + 5) * 1000;//5分钟以后见,减掉5秒不断收敛时间，防止延迟接收
if (rd.SaveNewestData(rd.getNewestData(el, currEl)) > 0)
{
CurrDataList = rd.ReadNewestData(DateTime.Now.AddDays(-10));//前十天的数据 尽量的大于reviewcnt,免得需要再取一次数据
CurrExpectNo = el.LastData.Expect;
Program.AllServiceConfig.LastDataSector = CurrDataList;
AfterReceiveProcess();
}
else
{
Log("保存数据错误", "保存数据数量为0！");
}
}
else
{
Log("接收到非最新数据", string.Format("id:{0}", el.LastData.Expect));
if (CurrTime.Hour < 9)//如果在9点前
{
//下一个时间点是9：07
DateTime TargetTime = DateTime.Today.AddHours(9).AddMinutes(8);
this.Tm_ForPK10.Interval = TargetTime.Subtract(CurrTime).TotalMilliseconds;
}
else
{
Log("接收数据", "未接收到数据！");
if (CurrTime.Subtract(PK10_LastSignTime).Minutes > 7)//如果离上期时间超过7分钟，说明数据未接收到，那不要再频繁以10秒访问服务器
{
this.Tm_ForPK10.Interval = 60 * 1000;
}
else //一般未接收到，10秒以后再试
{
this.Tm_ForPK10.Interval = 10 * 1000;
}
}
}
}
catch (Exception e)
{
Log(e.Message, e.StackTrace);
}
Log("接收数据", string.Format("当前访问时间为：{0},{1}秒后继续访问！", CurrTime.ToString(), this.Tm_ForPK10.Interval / 1000));
//FillOrgData(listView_TXFFCData, currEl);
}
public Dictionary <string, ChanceClass> CloseTheChances(bool IsTestBack)
{
List <ChanceClass> cl = new List <ChanceClass>();
DateTime currTime = DateTime.Now;
Dictionary <string, ChanceClass> CloseList = new Dictionary <string, ChanceClass>();
if (IsTestBack)//如果回测，使用内存数据
{
cl = Program.AllServiceConfig.AllNoClosedChanceList.Values.ToList <ChanceClass>();
}
else//非回测，使用数据库数据
{
DbChanceList dcl = new PK10ExpectReader().getNoCloseChances(null);
cl = dcl.Values.ToList <ChanceClass>();
}
Dictionary <string, ChanceClass> rl = new Dictionary <string, ChanceClass>();
if (cl.Count > 0)
{
Log("未关闭机会列表数量为", string.Format("{0}", cl.Count));
}
for (int i = 0; i < cl.Count; i++)
{
string sGUId = cl[i].StragId;
if (!Program.AllServiceConfig.AllStrags.ContainsKey(sGUId)) //如果策略已注销，立即关闭机会
{
if (cl[i].Tracerable) //如果是自我跟踪机会，不理会，让它自己去跟踪
{
}
else
{
CloseList.Add(cl[i].GUID, cl[i]);
//cl.Remove(cl[i].ChanceIndex);
Log("强制结束机会", string.Format("该机会所属策略已经注销，并且该机会是非跟踪机会！{0}", cl[i].ChanceCode));
continue;
}
}
List <string> AllUsePans = Program.AllServiceConfig.AllRunningPlanGrps.SelectMany(a => a.Value.UseSPlans.Select(t => t.PlanStrag.GUID)).ToList <string>();
if (!AllUsePans.Contains(sGUId))//不在执行的计划内
{
if (cl[i].Tracerable)
{
}
else
{
CloseList.Add(cl[i].GUID, cl[i]);
Log("强制结束机会", string.Format("不存在绑定该机会所属策略的计划，并且该机会是非跟踪机会！{0}", cl[i].ChanceCode));
continue;
}
}
//如果策略已经超出时间
List <string> StopedPlans = Program.AllServiceConfig.AllRunningPlanGrps.SelectMany(a => a.Value.UseSPlans.Where(t => (InitServerClass.JudgeInRunTime(currTime, t) == false))).Select(a => a.GUID).ToList <string>();
if (!IsTestBack)
{
if (StopedPlans.Contains(sGUId))//停止的计划产生的机会
{
if (cl[i].Tracerable)
{
}
else
{
Log("强制结束机会", string.Format("该机会所属策略超出计划运行时间！{0}", cl[i].ChanceCode));
CloseList.Add(cl[i].GUID, cl[i]);
continue;
}
}
}
StopedPlans = Program.AllServiceConfig.AllRunningPlanGrps.SelectMany(a => a.Value.UseSPlans.Where(t => (t.Running == false))).Select(a => a.GUID).ToList <string>();
if (StopedPlans.Contains(sGUId))//停止的计划产生的机会
{
if (cl[i].Tracerable)
{
}
else
{
Log("强制结束机会", string.Format("该机会所属策略的计划状态为停止！{0}", cl[i].ChanceCode));
CloseList.Add(cl[i].GUID, cl[i]);
continue;
}
}
//如果策略已经停止
//获得策略
StragClass sc = Program.AllServiceConfig.AllStrags[sGUId];
int mcnt = 0;
bool Matched = cl[i].Matched(CurrDataList, out mcnt);
cl[i].MatchChips += mcnt;
if (sc is ITraceChance)//优先关闭程序跟踪
{
cl[i].Closed = (sc as ITraceChance).CheckNeedEndTheChance(cl[i], Matched);
}
else
{
cl[i].Closed = Matched;
}
if (cl[i].Tracerable && Matched)//如果是策略自我跟踪，无论其策略是否是跟踪策略，先关了。
{
cl[i].Closed = true;
}
//////if (cl[i].MaxHoldTimeCnt > 0 && cl[i].HoldTimeCnt == cl[i].MaxHoldTimeCnt)
//////{
////// cl[i].Closed = true;
//////}
if (cl[i].Closed)//如果已经关闭
{
CloseList.Add(cl[i].GUID, cl[i]);
continue;
}
rl.Add(cl[i].GUID, cl[i]);
}
//Log("结束机会", "所有非法，以及命中并确认需要结束的机会");
if (!IsTestBack) //如果非回测，保存交易记录
{
DbChanceList dbsavelist = new DbChanceList();
CloseList.Values.ToList <ChanceClass>().ForEach(p => dbsavelist.Add(p.ChanceIndex, p));
CloseChanceInDBAndExchangeService(dbsavelist);
}
return(rl);
}
void TestSerial()
{
//ExpectList el = new PK10ExpectReader().ReadNewestData(DateTime.Now.AddDays(-17));//至少180*16天+当天的记录数>1000
//ExpectList el = new PK10ExpectReader().ReadNewestData(725888,1200);//725888以前1200
ExpectList el = new PK10ExpectReader().ReadHistory()
//MessageBox.Show(el.LastData.OpenCode);
var mapping = new Serial_Mapping();
DataTable dtAll = new DataTable();
Dictionary <int, string> ret = new Dictionary <int, string>();
PKDataListSetFactory pksf = new PKDataListSetFactory(el);
Dictionary <int, int> res = pksf.OccurProbList(1000, 1);
MessageBox.Show(string.Join(";", res.Values.ToList()));
////////////////for (int i=0;i<10;i++)
////////////////{
//////////////// dtAll.Columns.Add(string.Format("key{0}", i), typeof(string));
//////////////// dtAll.Columns.Add(string.Format("val{0}", i), typeof(double));
////////////////}
////////////////for(int i=0;i<10;i++)
////////////////{
//////////////// dtAll.Rows.Add(dtAll.NewRow());
////////////////}
////////////////StringBuilder sb = new StringBuilder();//删除packages
////////////////for (int i = 0; i < 10; i++)
////////////////{
//////////////// var classifier = BayesPointMachineClassifier.CreateMulticlassClassifier(mapping);
//////////////// FeatureLabeItems trainingSet = pksf.OccurColumnFeatureAndLabels(i, 1000, 1);
//////////////// classifier.Train(trainingSet.FeatureVectors, trainingSet.Labels);
//////////////// List<Vector> testVector = new List<Vector>();//1
//////////////// Vector v = Vector.Zero(1);
//////////////// v[0] = int.Parse(el.LastData.ValueList[i]=="0"?"10":el.LastData.ValueList[i]);
//////////////// testVector.Add(v);
//////////////// var predictions = classifier.PredictDistribution(testVector);
//////////////// string estimate = classifier.Predict(0, testVector);
//////////////// sb.AppendLine(estimate);
//////////////// int row1 = 0;
//////////////// foreach(var vv in predictions)
//////////////// {
//////////////// foreach(string key in vv.Keys)
//////////////// {
//////////////// dtAll.Rows[row1][string.Format("key{0}", i)] = key;
//////////////// dtAll.Rows[row1][string.Format("val{0}", i)] = vv[key];
//////////////// row1++;
//////////////// }
//////////////// }
////////////////}
////////////////DataTable mydt = new DataTable();
////////////////for (int i = 0; i < 10; i++)
////////////////{
//////////////// mydt.Columns.Add(string.Format("key{0}", i), typeof(string));
//////////////// mydt.Columns.Add(string.Format("val{0}", i), typeof(double));
////////////////}
////////////////for (int i = 0; i < 101; i++)
////////////////{
//////////////// mydt.Rows.Add(mydt.NewRow());
////////////////}
////////////////for (int i = 0; i < 10; i++)
////////////////{
//////////////// Dictionary<string, double> mydata = pksf.OccurColumnProb(i, 1000, 1);
////////////////}
////////////////int row = 0;
////////////////double sum = 0;
////////////////foreach(string key in mydata.Keys)
////////////////{
//////////////// mydt.Rows[row][string.Format("key{0}", 0)] = key;
//////////////// mydt.Rows[row][string.Format("val{0}", 0)] = mydata[key];
//////////////// sum += mydata[key];
//////////////// row++;
////////////////}
////////////////DataView dv = new DataView(dtAll);
////////////////mydt.Rows[100][string.Format("key{0}", 0)] = "合计";
////////////////mydt.Rows[100][string.Format("val{0}", 0)] = sum;
////////////////this.dataGridView1.DataSource = mydt;
////////////////MessageBox.Show(BayesDicClass.getBAMaxValue(mydata, 5).ToString());
//MessageBox.Show(sb.ToString());
}
public void ExecRun(object data)
{
ExpectList el = data as ExpectList;
//Log("计算服务","准备数据", "为每个策略分配数据");
foreach (string key in UseStrags.Keys)
{
UseStrags[key].SetLastUserData(el);
}
//准备数据
CommCollection cc = null;
int maxViewCnt = (int)this.UseStrags.Max(t => t.Value.ReviewExpectCnt);
//Log("计算服务", "最大回览期数", maxViewCnt.ToString());
cc = new ExpectListProcess(el).getSerialData(maxViewCnt, this.UseSerial);
// cc.orgData = el;//必须指定原始数据？
//Log("计算服务", "中间数据长度",cc.Data.Count.ToString());
Dictionary <StragClass, List <ChanceClass> > css = new Dictionary <StragClass, List <ChanceClass> >();
//Log("计算服务", "计算数据", "为每个策略计算最大回顾周期数据");
//遍历每个策略获得机会
DbChanceList OldDbList = new DbChanceList();
Dictionary <string, ChanceClass> OldList = new Dictionary <string, ChanceClass>();
List <ChanceClass> NewList = new List <ChanceClass>();
//Log("计算服务", "遍历所有策略", string.Format("策略数量:{0}",this.UseStrags.Count));
CloseAllExchance(el);//清空所有可视化机会
#region 获取交易机会
for (int i = 0; i < this.UseSPlans.Count; i++)
{
StragRunPlanClass currPlan = UseSPlans[i];
if (currPlan.PlanStrag == null)//如果计划所执行的策略为空，只在chance上执行tracer
{
List <ChanceClass> emptycs = CurrExistChanceList.Values.Where(p => p.StragId == null).ToList <ChanceClass>();
for (int c = 0; c < emptycs.Count; c++)
{
ChanceClass CurrCc = emptycs[c];
TraceChance tcc = CurrCc as TraceChance;
CurrCc.UnitCost = tcc.getChipAmount(GlobalClass.DefaultMaxLost, CurrCc, GlobalClass._DefaultHoldAmtSerials.Value);
CurrCc.HoldTimeCnt = CurrCc.HoldTimeCnt + 1;
CurrCc.Cost += CurrCc.ChipCount * CurrCc.UnitCost;
CurrCc.UpdateTime = CurrCc.CreateTime;
OldList.Add(CurrCc.GUID, CurrCc);
if (!IsBackTest)//非回测需要额外保存数据
{
OldDbList.Add(CurrCc.ChanceIndex, CurrCc);
}
}
continue;
}
StragClass currStrag = UseStrags[currPlan.PlanStrag.GUID];
currStrag.SetLastUserData(el); //必须给策略填充数据
List <ChanceClass> cs = currStrag.getChances(cc, el.LastData); //获取该策略的机会
if (currStrag is TotalStdDevTraceStragClass) //如果是整体标准差类，记录所有的标准差数据
{
grpTotolStdDic = (currStrag as TotalStdDevTraceStragClass).getAllStdDev();
}
if (cs.Count > 0)
{
Log("计算服务", string.Format("策略[{0}/{1}]", currStrag.GUID, currStrag.StragScript), string.Format("取得机会数量为:{0}", cs.Count));
}
Dictionary <string, ChanceClass> StragChances = CurrExistChanceList.Where(p => p.Value.StragId == currStrag.GUID).ToDictionary(p => p.Value.ChanceCode, p => p.Value);
AmoutSerials amts = GlobalClass.getOptSerials(CurrSetting.Odds, currPlan.InitCash, 1);
Int64 restAmt = currStrag.CommSetting.GetGlobalSetting().DefMaxLost; //初始资金
#region 遍历各机会
for (int j = 0; j < cs.Count; j++) //对每个机会，检查上期遗留的机会是否包括
{
bool NeedUseOldData = false;
ChanceClass CurrCc = cs[j];
CurrCc.HoldTimeCnt = 1;
CurrCc.AllowMaxHoldTimeCnt = currPlan.AllowMaxHoldTimeCnt;
CurrCc.IncrementType = currPlan.IncreamType;
if (currPlan.IncreamType == InterestType.CompoundInterest)
{
CurrCc.FixRate = currPlan.FixRate;
}
else
{
CurrCc.FixAmt = currPlan.FixAmt;
}
//该语句存在机会重复的风险
if (StragChances.ContainsKey(CurrCc.ChanceCode))//未关闭的及机会列表中存在该机会
{
ChanceClass OldCc = StragChances[CurrCc.ChanceCode];
//Log("计算服务", "老机会信息", string.Format("idx:{0};holdcnt:{1}", OldCc.ChanceIndex, OldCc.HoldTimeCnt));
//Log("计算服务", "老记录", string.Format("上期相同的机会{0}", CurrCc.ChanceCode));
//Log("计算服务", "判断是否允许重复", currStrag.AllowRepeat.ToString());
if (!currStrag.AllowRepeat)//如果不允许重复
{
CurrCc = OldCc;
CurrCc.HoldTimeCnt = CurrCc.HoldTimeCnt + 1;
NeedUseOldData = true;
Log("计算服务", "相同处理", string.Format("出现相同的机会{0},持有次数增1->{1}", CurrCc.ChanceCode, CurrCc.HoldTimeCnt));
}
}
else
{
//Log("计算服务", string.Format("上期相同未关闭的机会数{0},{1}", CurrExistChanceList.Count, CurrCc.ChanceCode), "本期未出现");
}
if (currPlan.AssetUnitInfo != null)
{
if (this.UseAssetUnits.ContainsKey(currPlan.AssetUnitInfo.UnitId))
{
AssetUnitClass useUnit = UseAssetUnits[currPlan.AssetUnitInfo.UnitId];
if (!useUnit.Running)
{
useUnit.Run();
}
restAmt = (long)useUnit.ExchangeServer.summary;
}
else
{
continue;
}
}
//Log("计算服务", "再次检查数据", string.Format("出现相同的机会{0},持有次数增1->{1}", CurrCc.ChanceCode, CurrCc.HoldTimeCnt));
CurrCc.UnitCost = -1; //先默认为-1
if (currStrag is ISpecAmount) //先从策略级别判断
{
ISpecAmount testStrag = (currStrag as ISpecAmount);
if (testStrag == null)
{
//等待下一步按机会级别判断
}
else
{
CurrCc.UnitCost = testStrag.getChipAmount(restAmt, CurrCc, amts);
}
}
if (CurrCc.UnitCost < 0) //如果策略级别未改变值
{
if (CurrCc.IsTracer == 1) //如果是自我追踪机会
{
Log("计算服务", "自我跟踪机会，当前持有次数", string.Format("HoldTimes:{0}", CurrCc.HoldTimeCnt));
TraceChance useCc = Convert.ChangeType(CurrCc, currStrag.getTheChanceType()) as TraceChance;
//Log("计算服务", "使用的机会持有次数", string.Format("HoldTimes:{0}", useCc.HoldTimeCnt));
if (useCc == null) //获得的类型并非跟踪类型
{
CurrCc.UnitCost = (currStrag as ChanceTraceStragClass).getChipAmount(restAmt, CurrCc, amts);
}
else
{
CurrCc.UnitCost = useCc.getChipAmount(restAmt, CurrCc, amts);
}
}
else//默认为ChanceTraceStragClass,其实是不可能触发的，而且会出错，因为ChanceTraceStragClass本身就是ispaceamount
{
Log("计算服务", "非跟踪机会，持有次数", string.Format("HoldTimes:{0}", CurrCc.HoldTimeCnt));
CurrCc.UnitCost = (currStrag as ChanceTraceStragClass).getChipAmount(restAmt, CurrCc, amts);
}
}
//Log("计算服务", "再二次检查数据", string.Format("出现相同的机会{0},持有次数增1->{1}", CurrCc.ChanceCode, CurrCc.HoldTimeCnt));
if (NeedUseOldData)//未关闭的及机会列表中存在该机会
{
Log("计算服务", "策略不可以出现重复", string.Format("策略编号:{0}", CurrCc.UnitCost));
CurrCc.Cost += CurrCc.UnitCost * CurrCc.ChipCount;
CurrCc.UpdateTime = DateTime.Now;
OldList.Add(CurrCc.GUID, CurrCc);
if (!IsBackTest)
{
OldDbList.Add(CurrCc.ChanceIndex, CurrCc);
}
continue;
}
CurrCc.HoldTimeCnt = 1;
CurrCc.Cost = CurrCc.ChipCount * CurrCc.UnitCost;
CurrCc.Gained = 0;
CurrCc.Profit = 0;
CurrCc.ExecDate = DateTime.Today;
CurrCc.CreateTime = DateTime.Now;
CurrCc.UpdateTime = CurrCc.CreateTime;
CurrCc.StragId = currStrag.GUID;
CurrCc.ExpectCode = el.LastData.Expect;
CurrCc.MaxHoldTimeCnt = currPlan.AllowMaxHoldTimeCnt;
CurrCc.ChanceType = currPlan.OutPutType;
NewList.Add(CurrCc);
}
#endregion
#region 未关闭的机会需要自我跟踪
foreach (string code in StragChances.Keys)
{
ChanceClass CurrCc = StragChances[code];
//if (!CurrCc.Tracerable) continue;
int cnt = OldList.Values.Where(p => p.ChanceCode.Equals(code)).Count();
if (cnt > 0)
{
continue;
}
if (currStrag is ISpecAmount)//先从策略级检查
{
ISpecAmount specStrag = currStrag as ISpecAmount;
if (specStrag != null)//如果没有方法，再从机会级检查
{
CurrCc.HoldTimeCnt++;
CurrCc.UnitCost = specStrag.getChipAmount(restAmt, CurrCc, amts);
CurrCc.Cost += CurrCc.ChipCount * CurrCc.UnitCost;
CurrCc.UpdateTime = DateTime.Now;
OldList.Add(CurrCc.GUID, CurrCc);
if (!IsBackTest)
{
OldDbList.Add(CurrCc.ChanceIndex, CurrCc);
}
continue;
}
}
if (CurrCc.Tracerable)//再检查机会级
{
CurrCc.HoldTimeCnt++;
TraceChance testCc = (TraceChance)CurrCc;
if (testCc == null)
{
continue;
}
CurrCc.UnitCost = testCc.getChipAmount(restAmt, CurrCc, amts);
CurrCc.Cost += CurrCc.ChipCount * CurrCc.UnitCost;
CurrCc.UpdateTime = DateTime.Now;
OldList.Add(CurrCc.GUID, CurrCc);
if (!IsBackTest)
{
OldDbList.Add(CurrCc.ChanceIndex, CurrCc);
}
continue;
}
else
{
CurrCc.HoldTimeCnt++;
ISpecAmount Strag = (ISpecAmount)currStrag;
if (Strag == null)
{
continue;
}
CurrCc.UnitCost = Strag.getChipAmount(restAmt, CurrCc, amts);
CurrCc.Cost = CurrCc.ChipCount * CurrCc.UnitCost;
CurrCc.UpdateTime = DateTime.Now;
OldList.Add(CurrCc.GUID, CurrCc);
if (!IsBackTest)
{
OldDbList.Add(CurrCc.ChanceIndex, CurrCc);
}
}
}
#endregion
}
#endregion
if (!IsBackTest)//额外保存
{
int savecnt = OldDbList.Save(null);
if (OldList.Count > 0)
{
Log("计算服务", "保存已有机会", string.Format("条数：{0};实际条数:{1}", OldList.Count, savecnt));
}
savecnt = new PK10ExpectReader().SaveChances(NewList, null);
if (NewList.Count > 0)
{
Log("计算服务", "保存新增机会", string.Format("条数：{0};实际条数:{1}", NewList.Count, savecnt));
}
}
//合并到未关闭机会列表中
NewList.ForEach(p => AllNoClosedChances.Add(p.GUID, p));
OldList.Values.ToList <ChanceClass>().ForEach(p => AllNoClosedChances.Add(p.GUID, p)); //就算是老记录未有guid,当ToTable时已经生成了guid
ExChange(AllNoClosedChances.Values.ToList <ChanceClass>()); //执行交易提供可视化
}
