public override bool CheckNeedEndTheChance(ChanceClass cc1, bool LastExpectMatched1)
{
return(LastExpectMatched1);
}
public override List <ChanceClass> getChances(BaseCollection sc, ExpectData ed)
{
List <ChanceClass> ret = new List <ChanceClass>();
DataTableEx dt = null;
if (this.BySer)
{
dt = sc.SerialDistributionTable;
}
else
{
dt = sc.CarDistributionTable;
}
if (dt == null)
{
throw new Exception("无法获得概率分布表！");
}
string strCodes = "";
int AllChipCnt = 0;
for (int i = 0; i < 10; i++)
{
//获得各项的最小的
List <double> coldata = null;
string strCol = string.Format("{0}", (i + 1) % 10);
dt.getColumnData(strCol, ref coldata);
double avgval = coldata.Average();
double stdval = ProbMath.CalculateStdDev(coldata);
string strSql = string.Format("[{0}]<{1}", strCol, avgval - this.StdvCnt * stdval);
string strSort = string.Format("[{0}] asc", "Id");
DataRow[] drs = dt.Select(strSql, strSort);
if (drs.Length < this.ChipCount)
{
continue;
}
string strCode = "";
StringBuilder sb = new StringBuilder();
bool Matched = false;
for (int j = 0; j < drs.Length; j++)
{
string strId = drs[j]["Id"].ToString();
int RowCnt = sc.FindLastDataExistCount(this.InputMinTimes, strCol, strId);
if (RowCnt > 0)//任何一个不匹配最近5期内出现，不满足条件
{
Matched = false;
break;
}
sb.Append(drs[j]["Id"].ToString());
Matched = true;
}
if (!Matched)
{
continue;
}
AllChipCnt += drs.Length;
if (BySer)
{
strCode = string.Format("{0}/{1}", strCol, sb.ToString());
}
else
{
strCode = string.Format("{0}/{1}", sb.ToString(), strCol);
}
if (strCode.Length > 0)
{
strCodes = string.Format("{0}{1}{2}", strCodes, strCodes.Length > 0?"+":"", strCode);
}
}
if (strCodes.Length < 2 * (this.ChipCount + 2))
{
return(ret);
}
ChanceClass cc = new ChanceClass();
cc.SignExpectNo = ed.Expect;
cc.ChanceType = 3;
cc.InputTimes = 1;
cc.strInputTimes = "1";
cc.AllowMaxHoldTimeCnt = 1;
cc.InputExpect = ed;
cc.ChipCount = AllChipCnt;
cc.ChanceCode = strCodes;
cc.CreateTime = ed.OpenTime;
cc.Closed = false;
ret.Add(cc);
return(ret);
}
public void Run(DataTypePoint dtp, ExpectList <T> testData, BaseStragClass <T> teststrag, ref List <ChanceClass <T> > ChanceList, ref Dictionary <string, ChanceClass <T> > NoCloseChances, ref Dictionary <int, int> HoldCntDic)
{
tmpChances = new Dictionary <string, ChanceClass <T> >();
if (ChanceList == null)
{
ChanceList = new List <ChanceClass <T> >();
}
BaseCollection <T> sc = new ExpectListProcessBuilder <T>(dtp, testData).getProcess().getSerialData(teststrag.ReviewExpectCnt, teststrag.BySer);
foreach (string key in NoCloseChances.Keys)
{
ChanceClass <T> cc = NoCloseChances[key];
if (cc.Closed == false)
{
int matchcnt = 0;
if (teststrag.GetRev) //如果求相反组合
{
if (cc.Matched(testData.LastData, out matchcnt, true)) //不关闭
{
cc.HoldTimeCnt = (int)(testData.LastData.ExpectIndex - cc.InputExpect.ExpectIndex);
}
}
if (cc.Matched(testData.LastData, out matchcnt, false))//如果用相反组合，不改变真正关闭
{
cc.Closed = true;
cc.EndExpectNo = testData.LastData.Expect;
if (!teststrag.GetRev)//只有不求相反值的情况下，才赋持有是次数
{
cc.HoldTimeCnt = (int)(testData.LastData.ExpectIndex - cc.InputExpect.ExpectIndex);
}
cc.MatchChips = matchcnt;
cc.UpdateTime = testData.LastData.OpenTime;
ChanceList.Add(cc);
int HCnt = 1;
if (HoldCntDic == null)
{
HoldCntDic = new Dictionary <int, int>();
}
if (HoldCntDic.ContainsKey(cc.HoldTimeCnt))
{
HCnt = HoldCntDic[cc.HoldTimeCnt];
HCnt++;
HoldCntDic[cc.HoldTimeCnt] = HCnt;
}
else
{
HoldCntDic.Add(cc.HoldTimeCnt, 1);
}
}
else
{
tmpChances.Add(key, cc);
}
}
}
//List<ChanceClass<T>> cs = teststrag.getChances(testData);
List <ChanceClass <T> > cs = teststrag.getChances(sc, testData.LastData);
if (ChanceList == null)
{
ChanceList = new List <ChanceClass <T> >();
}
//ret.ChanceList.AddRange(cs);
NoCloseChances = new Dictionary <string, ChanceClass <T> >();
foreach (string key in tmpChances.Keys)
{
ChanceClass <T> cc = tmpChances[key];
NoCloseChances.Add(key, cc);
}
for (int i = 0; i < cs.Count; i++)
{
//string key = string.Format("{0}_{1}", cs[i].SignExpectNo, cs[i].ChanceCode);
string key = string.Format("{0}", cs[i].ChanceCode);
if (NoCloseChances.ContainsKey(key))
{
if (teststrag.AllowRepeat)
{
string test = key;
//NoCloseChances.Add(key, cs[i]);
}
}
else
{
NoCloseChances.Add(key, cs[i]);
}
}
}
public override List <PK10CorePress.ChanceClass> getChances(PK10CorePress.CommCollection sc, PK10CorePress.ExpectData ed)
{
List <ChanceClass> ret = new List <ChanceClass>();
DataTableEx dt = null;
if (this.BySer)
{
dt = sc.SerialDistributionTable;
}
else
{
dt = sc.CarDistributionTable;
}
if (dt == null)
{
throw new Exception("无法获得概率分布表！");
}
int MatchCnt = 0;
string strAllCodes = "";
double MinSucRate = 0;
if (this.FixChipCnt)
{
MinSucRate = this.CommSetting.Odds / this.ChipCount; //指定注数需要的最小胜率
}
for (int i = 0; i < 10; i++)
{
//获得各项的最小的
List <double> coldata = null;
string strCol = string.Format("{0}", (i + 1) % 10);
string strVal = ed.ValueList[i];
int ExistCnt = sc.FindLastDataExistCount(this.InputMinTimes, strCol, strVal);
if (ExistCnt > 1)//前n次不是最后一次才出现
{
continue;
}
dt.getColumnData(strCol, ref coldata);
double avgval = coldata.Average();
double stdval = ProbMath.CalculateStdDev(coldata);
string strSql = string.Format("[{0}]={1}", "Id", strVal);
string strSort = string.Format("[{0}] asc", "Id");
DataRow[] drs = dt.Select(strSql, "");
if (drs.Length != 1)
{
throw new Exception("概率数据表错乱！");
}
int InAllViewExistCnt = int.Parse(drs[0][strCol].ToString()); //前100（指定的viewcnt）期出现的次数
if (InAllViewExistCnt > avgval - stdval * this.StdvCnt) //如果前100期内出现的概率大于指定的标准差数，跳过
{
continue;
}
if (InAllViewExistCnt > this.ReviewExpectCnt * (1 - MinSucRate))//如果成功数小于对应注数的失败数
{
continue;
}
string strCode = string.Format("{0}/{1}", BySer ? strCol : strVal, BySer ? strVal : strCol);
MatchCnt++;
strAllCodes = string.Format("{0}{1}{2}", strAllCodes, MatchCnt > 1 ? "+" : "", strCode);
}
if (MatchCnt < this.ChipCount)
{
return(ret);
}
ChanceClass cc = new ChanceClass();
cc.SignExpectNo = ed.Expect;
cc.ChanceType = 3;
cc.InputTimes = 1;
cc.strInputTimes = "1";
cc.AllowMaxHoldTimeCnt = 1;
cc.InputExpect = ed;
cc.ChipCount = MatchCnt;
cc.ChanceCode = strAllCodes;
cc.CreateTime = ed.OpenTime;
cc.NeedConditionEnd = true;
cc.OnCheckTheChance += CheckNeedEndTheChance;
cc.Closed = false;
ret.Add(cc);
return(ret);
}
public override List <ChanceClass> getChances(CommCollection sc, ExpectData ed)
{
List <ChanceClass> ret = new List <ChanceClass>();
//ExpectListProcess elp = new ExpectListProcess(Data);
//CommCollection sc = elp.getSerialData(ReviewExpectCnt,BySer);
// Log("策略关键参数",string.Format("name:{4};ViewCnt:{0};MinInput:{1};DataCnt:{2};Chipcnt:{3}",this.ReviewExpectCnt,this.InputMinTimes,sc.Data[0].Count,this.ChipCount,this.StragScript));
for (int i = 0; i < 10; i++)
{
Dictionary <int, string> SerStrs = sc.Data[i];
if (!SerStrs.ContainsKey(this.InputMinTimes - 1))
{
continue;
}
if (SerStrs[this.InputMinTimes - 1].Length < this.ChipCount)
{
continue;
}
int ishift = this.InputMinTimes - 1;
//Log("起始位置", ishift.ToString());
List <string> strCcs = ChanceClass.getAllSubCode(SerStrs[ishift].Trim(), this.ChipCount);
for (int j = 0; j < strCcs.Count; j++)
{
string strCars = strCcs[j];
if (this.ExcludeBS && ChanceClass.isBS(strCars))
{
continue;
}
if (this.ExcludeSD && ChanceClass.isSD(strCars))
{
continue;
}
if (this.OnlyBS && !ChanceClass.isBS(strCars))
{
continue;
}
if (this.OnlySD && !ChanceClass.isSD(strCars))
{
continue;
}
NolimitTraceChance cc = new NolimitTraceChance();
cc.SignExpectNo = ed.Expect;
cc.ChanceType = 0;
cc.ChipCount = strCars.Length;
cc.InputTimes = ishift + 1;
cc.strInputTimes = cc.InputTimes.ToString();
//cc.AllowMaxHoldTimeCnt = this.AllowMaxHoldTimeCnt;
cc.InputExpect = ed;
cc.StragId = this.GUID;
cc.MinWinRate = this.CommSetting.GetGlobalSetting().DefaultHoldAmtSerials.MaxRates[cc.ChipCount - 1];
cc.IsTracer = 1;
cc.HoldTimeCnt = 1;
cc.Odds = this.CommSetting.GetGlobalSetting().Odds;
cc.ExpectCode = ed.Expect;
string strCode = "";
if (BySer)
{
strCode = string.Format("{0}/{1}", (i + 1) % 10, strCcs[j].Trim());
}
else
{
strCode = string.Format("{0}/{1}", strCcs[j].Trim(), i);
}
cc.ChanceCode = strCode;
cc.CreateTime = DateTime.Now;
cc.UpdateTime = DateTime.Now;
cc.Closed = false;
ret.Add(cc);
}
//}
//}
}
return(ret);
}
public override long getChipAmount(double RestCash, ChanceClass cc, AmoutSerials amts)
{
cc.AllowMaxHoldTimeCnt = 1;
try
{
if (LastUseData().LastData.Expect != cc.ExpectCode)
{
return(0);
}
if (cc.IncrementType == InterestType.CompoundInterest)
{
if (cc.HoldTimeCnt > 1)
{
return(0);
}
if (cc.AllowMaxHoldTimeCnt > 0 && cc.HoldTimeCnt > cc.AllowMaxHoldTimeCnt)
{
return(0);
}
if (LastUseData().LastData.Expect != cc.ExpectCode)
{
return(0);
}
//
double rate = KellyMethodClass.KellyFormula(1, 10, 9.75, 1.001);
//double rate = KellyMethodClass.KellyFormula(1, 9.75, 0.1032);
long ret = (long)Math.Ceiling((double)(RestCash * rate));
return(ret);
}
//大于5码的不受限制
int shift = 0;
if (cc.ChipCount < this.InputMinTimes && cc.HoldTimeCnt > cc.AllowMaxHoldTimeCnt && cc.AllowMaxHoldTimeCnt > 0)
{
int CurrChipCount = ChanceClass.getChipsByCode(cc.ChanceCode);
if (CurrChipCount >= 2)//大于等于3的，超过了一定期数以后可以跟号。4码5次，3码7次,2码11次。6-n+(6-n+1)^2
{
shift = (this.InputMinTimes + 1 - CurrChipCount) + (int)(Math.Pow((this.InputMinTimes + 1 - CurrChipCount + 1), 2));
//shift = (6 - CurrChipCount) + (6 - CurrChipCount + 1) ^ 2;
}
else
{
shift = 50;
}
// [组合信息:1/0+6/7;组合长度:2;指定最小长度:6:Log]当前次数:10;最小入场次数:9
Log(string.Format("组合信息:{0};组合长度:{1};指定最小长度:{2}", cc.ChanceCode, CurrChipCount, this.InputMinTimes), string.Format("当前次数:{0};最小入场次数:{1}", cc.HoldTimeCnt, shift));
if (cc.HoldTimeCnt < shift)
{
return(0);
}
}
if (cc.HoldTimeCnt <= cc.AllowMaxHoldTimeCnt && cc.AllowMaxHoldTimeCnt > 0) //如果小于等于1
{
return(cc.FixAmt.Value);
}
int hcnt = cc.HoldTimeCnt - shift;
if (hcnt < 0)
{
return(0);
}
int chips = cc.ChipCount - 1;
int maxcnt = amts.MaxHoldCnts[chips];
int bShift = 0;
if (hcnt > maxcnt)
{
Log("风险", "达到最大上限", string.Format("机会{0}持有次数达到{1}次总投入金额已为{2}", cc.ChanceCode, hcnt, cc.Cost));
bShift = (int)maxcnt * 2 / 3;
}
int RCnt = (hcnt % (maxcnt + 1)) + bShift - 1;
return(amts.Serials[chips][RCnt]);
}
catch (Exception e)
{
Log("错误", string.Format("二项分布，获取单码金额错误:{0}", e.Message), e.StackTrace);
}
return(1);
}
public abstract bool CheckNeedEndTheChance <T>(ChanceClass <T> cc, bool LastExpectMatched) where T : TimeSerialData;
public void Run()
{
LoopCnt = 0;
testIndex = 0;
ret = new BackTestReturnClass();
long begNo = BegExpect;
ExpectReader er = new ExpectReader();
ExpectList el = null;
long cnt = 0;
ret.HoldCntDic = new Dictionary <int, int>();
ret.HoldWinCntDic = new Dictionary <int, int>();
ret.InChipsDic = new Dictionary <int, int>();
ret.WinChipsDic = new Dictionary <int, int>();
ExpectList AllData = new ExpectList();
testIndex = teststrag.ReviewExpectCnt - 1;
ExpectList testData = null;
Dictionary <string, ChanceClass> NoCloseChances = new Dictionary <string, ChanceClass>();
Dictionary <string, ChanceClass> tmpChances = new Dictionary <string, ChanceClass>();
while (el == null || el.Count > 0) //如果取到的数据长度大于0
{
el = er.ReadHistory(begNo, LoopCnt);
if (el == null)
{
ret.LoopCnt = cnt * LoopCnt;
ret.succ = false;
ret.Msg = "读取历史数据错误！";
break;
}
if (el.Count == 0)
{
ret.LoopCnt = testIndex;
ret.succ = true;
ret.Msg = string.Format("成功遍历{0}条记录！共发现机会{1}次！其中,{2}.", testIndex, ret.ChanceList.Count, ret.HoldInfo);
break;
}
AllData = ExpectList.Concat(AllData, el);
begNo = el.LastData.LExpectNo + 1;
cnt++;
//Todo:
while (testIndex < AllData.Count)
{
if (testData == null)
{
testData = AllData.getSubArray(0, teststrag.ReviewExpectCnt);
}
else
{
if (AllData[(int)testIndex].ExpectIndex != testData.LastData.ExpectIndex + 1)
{
throw new Exception(string.Format("{1}第{0}期后出现数据遗漏，请补充数据后继续测试！", testData.LastData.Expect, testData.LastData.OpenTime));
}
testData.RemoveAt(0);
testData.Add(AllData[(int)testIndex]);
}
tmpChances = new Dictionary <string, ChanceClass>();
foreach (string key in NoCloseChances.Keys)
{
ChanceClass cc = NoCloseChances[key];
if (cc.Closed == false)
{
int matchcnt = 0;
if (teststrag.GetRev) //如果求相反组合
{
if (cc.Matched(testData.LastData, out matchcnt, true)) //不关闭
{
if (cc.HoldTimeCnt < 0)
{
cc.HoldTimeCnt = (int)(testData.LastData.ExpectIndex - cc.InputExpect.ExpectIndex);
}
}
}
bool Matched = cc.Matched(testData.LastData, out matchcnt, false);
if (cc.NeedConditionEnd)
{
cc.MatchChips += matchcnt;
if (Matched)
{
int LastMatchId = cc.LastMatchTimesId;//最后一次匹配次序号
int maxHoldCnt = cc.MaxHoldTimeCnt;
if (cc.HoldTimeCnt - cc.LastMatchTimesId > maxHoldCnt)
{
cc.MaxHoldTimeCnt = cc.HoldTimeCnt - cc.LastMatchTimesId;
}
cc.LastMatchTimesId = cc.HoldTimeCnt;
}
if (teststrag is ITraceChance)
{
ITraceChance its = teststrag as ITraceChance;
if (its == null)
{
cc.Closed = cc.OnCheckTheChance(cc, Matched);
}
else
{
cc.Closed = its.CheckNeedEndTheChance(cc, Matched);
}
}
else
{
cc.Closed = cc.OnCheckTheChance(cc, Matched);
}
if (cc.Closed)
{
cc.EndExpectNo = testData.LastData.Expect;
cc.UpdateTime = testData.LastData.OpenTime;
}
else
{
cc.HoldTimeCnt++;
tmpChances.Add(key, cc);
}
}
else
{
if (Matched || (cc.HoldTimeCnt > 0 && cc.HoldTimeCnt == cc.AllowMaxHoldTimeCnt))//关闭
{
cc.Closed = true;
cc.EndExpectNo = testData.LastData.Expect;
cc.MatchChips = matchcnt;
if (!teststrag.GetRev)//只有不求相反值的情况下，才赋持有是次数
{
cc.HoldTimeCnt = (int)(testData.LastData.ExpectIndex - cc.InputExpect.ExpectIndex);
}
else
{
if (cc.HoldTimeCnt < 0)
{
cc.HoldTimeCnt = 999;
}
}
cc.UpdateTime = testData.LastData.OpenTime;
ret.ChanceList.Add(cc);
}
else
{
cc.HoldTimeCnt++;
tmpChances.Add(key, cc);
}
}
if (cc.Closed)
{
int HCnt = 1;
if (ret.HoldCntDic.ContainsKey(cc.HoldTimeCnt))
{
HCnt = ret.HoldCntDic[cc.HoldTimeCnt];
HCnt++;
ret.HoldCntDic[cc.HoldTimeCnt] = HCnt;
ret.HoldWinCntDic[cc.HoldTimeCnt] = ret.HoldWinCntDic[cc.HoldTimeCnt] + matchcnt;
ret.InChipsDic[cc.HoldTimeCnt] = ret.InChipsDic[cc.HoldTimeCnt] + cc.ChipCount;
ret.WinChipsDic[cc.HoldTimeCnt] = ret.WinChipsDic[cc.HoldTimeCnt] + cc.MatchChips;
}
else
{
ret.HoldCntDic.Add(cc.HoldTimeCnt, 1);
ret.HoldWinCntDic.Add(cc.HoldTimeCnt, matchcnt);
ret.InChipsDic.Add(cc.HoldTimeCnt, cc.ChipCount);
ret.WinChipsDic.Add(cc.HoldTimeCnt, cc.MatchChips);
}
}
}
}
CommCollection sc = new ExpectListProcess(testData).getSerialData(teststrag.ReviewExpectCnt, teststrag.BySer);
if (testData.Count == 0)
{
break;
}
teststrag.SetLastUserData(testData);
List <ChanceClass> cs = teststrag.getChances(sc, testData.LastData);//获取所有机会
if (ret.ChanceList == null)
{
ret.ChanceList = new List <ChanceClass>();
}
//ret.ChanceList.AddRange(cs);
NoCloseChances = new Dictionary <string, ChanceClass>();
foreach (string key in tmpChances.Keys)
{
ChanceClass cc = tmpChances[key];
NoCloseChances.Add(key, cc);
}
for (int i = 0; i < cs.Count; i++)
{
//string key = string.Format("{0}_{1}", cs[i].SignExpectNo, cs[i].ChanceCode);
string key = string.Format("{0}", cs[i].ChanceCode);
if (NoCloseChances.ContainsKey(key))
{
if (teststrag.AllowRepeat)
{
string test = key;
//NoCloseChances.Add(key, cs[i]);
}
}
else
{
NoCloseChances.Add(key, cs[i]);
}
}
testIndex++;
}
}
FinishedProcess();
//return ret;
}
public BackTestReturnClass VirExchange_oldLogic(ExchangeService es, StragRunPlanClass[] teststragplans)
{
long begNo = BegExpect;
ExpectReader er = new ExpectReader();
ExpectList el = null;
long cnt = 0;
BackTestReturnClass ret = new BackTestReturnClass();
ret.HoldCntDic = new Dictionary <int, int>();
ret.HoldWinCntDic = new Dictionary <int, int>();
ret.InChipsDic = new Dictionary <int, int>();
ret.WinChipsDic = new Dictionary <int, int>();
ExpectList AllData = new ExpectList();
//long testIndex = teststrag.ReviewExpectCnt - 1;
StragClass[] teststrags = teststragplans.Select(p => p.PlanStrag).ToArray <StragClass>();
long testIndex = teststrags.Max <StragClass>(s => s.ReviewExpectCnt);//取所有策略中回览期最大的开始，之前的数据不看
long InitIndex = testIndex;
ExpectList testData = null;
Dictionary <string, StragChance> NoCloseChances = new Dictionary <string, StragChance>();
Dictionary <string, StragChance> tmpChances = new Dictionary <string, StragChance>();
Dictionary <Int64, ExchangeChance> NewExchangeRecord = new Dictionary <Int64, ExchangeChance>();
int AllCnt = 0;
while (el == null || el.Count > 0) //如果取到的数据长度大于0
{
el = er.ReadHistory(begNo, LoopCnt);
if (el == null)
{
ret.LoopCnt = cnt * LoopCnt;
ret.succ = false;
ret.Msg = "读取历史数据错误！";
break;
}
if (el.Count == 0)
{
ret.LoopCnt = testIndex;
ret.succ = true;
ret.Msg = string.Format("成功遍历{0}条记录！共发现机会{1}次！其中,{2}.", testIndex, ret.ChanceList.Count, ret.HoldInfo);
break;
}
AllData = ExpectList.Concat(AllData, el);
begNo = el.LastData.LExpectNo + 1;
cnt++;
//Todo:
while (testIndex < AllData.Count)
{
int CurrExpectClose = 0;
AllCnt++;
es.UpdateExpectCnt(AllCnt);
if (testData == null)
{
//testData = AllData.getSubArray(0, teststrag.ReviewExpectCnt);
testData = AllData.getSubArray(0, (int)InitIndex + 1);
}
else
{
if (AllData[(int)testIndex].ExpectIndex != testData.LastData.ExpectIndex + 1)
{
throw new Exception(string.Format("{1}第{0}期后出现数据遗漏，请补充数据后继续测试！", testData.LastData.Expect, testData.LastData.OpenTime));
}
testData.RemoveAt(0);
testData.Add(AllData[(int)testIndex]);
}
for (int i = 0; i < teststrags.Length; i++)//专门针对需要程序话关闭机会，且关闭时需要知道当前数据策略使用
{
teststrags[i].SetLastUserData(testData);
}
tmpChances = new Dictionary <string, StragChance>();
//关闭所有交易
foreach (int id in NewExchangeRecord.Keys)
{
ExchangeChance ec = NewExchangeRecord[id];
int matchcnt = 0;
ec.OwnerChance.Matched(testData.LastData, out matchcnt, false);
ec.MatchChips = matchcnt;
es.Update(ec);
ec = null;
}
NewExchangeRecord = new Dictionary <Int64, ExchangeChance>();
foreach (string key in NoCloseChances.Keys)
{
StragChance scc = NoCloseChances[key];
ChanceClass cc = scc.Chance;
if (cc.Closed == false)
{
int matchcnt = 0;
//////if (teststrag.GetRev)//如果求相反组合
//////{
////// if (cc.Matched(testData.LastData, out matchcnt, true))//不关闭
////// {
////// if (cc.HoldTimeCnt < 0)
////// {
////// cc.HoldTimeCnt = (int)(testData.LastData.ExpectIndex - cc.InputExpect.ExpectIndex);
////// }
////// }
//////}
bool Matched = cc.Matched(testData.LastData, out matchcnt, false);
if (cc.NeedConditionEnd) //需要策略自定义条件结束
{
cc.MatchChips += matchcnt;
if (Matched) //匹配到了
{
int LastMatchId = cc.LastMatchTimesId; //最后一次匹配次序号
int maxHoldCnt = cc.MaxHoldTimeCnt;
if (cc.HoldTimeCnt - cc.LastMatchTimesId > maxHoldCnt)
{
cc.MaxHoldTimeCnt = cc.HoldTimeCnt - cc.LastMatchTimesId;
}
cc.LastMatchTimesId = cc.HoldTimeCnt;
}
if (CurrExpectClose == 1)//如果当期已关闭，后面所有机会均关闭
{
cc.Closed = true;
}
else if (CurrExpectClose == -1)
{
cc.Closed = Matched;
}
else
{
cc.Closed = cc.OnCheckTheChance(cc, Matched);
if (teststrags[0].StagSetting.IsLongTermCalc) //如果是长期计算，设置当期是否关闭
{
if (!Matched && cc.Closed) //匹配和状态相背，一定是状态已关闭
{
CurrExpectClose = 1;
}
if (!Matched && !cc.Closed)//第一次非匹配状态能判断出当期是否关闭
{
CurrExpectClose = -1;
}
}
}
if (cc.Closed)
{
cc.EndExpectNo = testData.LastData.Expect;
cc.UpdateTime = testData.LastData.OpenTime;
}
else
{
cc.HoldTimeCnt++;
tmpChances.Add(key, scc);
}
}
else
{
if (Matched || cc.HoldTimeCnt == cc.AllowMaxHoldTimeCnt)//关闭
{
cc.Closed = true;
cc.EndExpectNo = testData.LastData.Expect;
cc.MatchChips = matchcnt;
//////if (!teststrag.GetRev)//只有不求相反值的情况下，才赋持有是次数
//////{
cc.HoldTimeCnt = (int)(testData.LastData.ExpectIndex - cc.InputExpect.ExpectIndex);
//////}
//////else
//////{
////// if (cc.HoldTimeCnt < 0)
////// {
////// cc.HoldTimeCnt = 999;
////// }
//////}
cc.UpdateTime = testData.LastData.OpenTime;
ret.ChanceList.Add(cc);
}
else
{
cc.HoldTimeCnt++;
tmpChances.Add(key, scc);
}
}
#region
//////////if (cc.Closed)
//////////{
////////// int HCnt = 1;
////////// if (cc.NeedConditionEnd)
////////// {
////////// if (ret.HoldCntDic.ContainsKey(cc.MaxHoldTimeCnt))
////////// {
////////// HCnt = ret.HoldCntDic[cc.MaxHoldTimeCnt];
////////// HCnt++;
////////// ret.HoldCntDic[cc.MaxHoldTimeCnt] = HCnt;
////////// ret.HoldWinCntDic[cc.MaxHoldTimeCnt] = ret.HoldWinCntDic[cc.MaxHoldTimeCnt] + matchcnt;
////////// ret.InChipsDic[cc.MaxHoldTimeCnt] = ret.InChipsDic[cc.MaxHoldTimeCnt] + cc.ChipCount * cc.HoldTimeCnt;
////////// ret.WinChipsDic[cc.MaxHoldTimeCnt] = ret.WinChipsDic[cc.MaxHoldTimeCnt] + cc.MatchChips;
////////// }
////////// else
////////// {
////////// ret.HoldCntDic.Add(cc.MaxHoldTimeCnt, 1);
////////// ret.HoldWinCntDic.Add(cc.MaxHoldTimeCnt, matchcnt);
////////// ret.InChipsDic.Add(cc.MaxHoldTimeCnt, cc.ChipCount * cc.HoldTimeCnt);
////////// ret.WinChipsDic.Add(cc.MaxHoldTimeCnt, cc.MatchChips);
////////// }
////////// }
////////// else
////////// {
////////// if (ret.HoldCntDic.ContainsKey(cc.HoldTimeCnt))
////////// {
////////// HCnt = ret.HoldCntDic[cc.HoldTimeCnt];
////////// HCnt++;
////////// ret.HoldCntDic[cc.HoldTimeCnt] = HCnt;
////////// ret.HoldWinCntDic[cc.HoldTimeCnt] = ret.HoldWinCntDic[cc.HoldTimeCnt] + matchcnt;
////////// ret.InChipsDic[cc.HoldTimeCnt] = ret.InChipsDic[cc.HoldTimeCnt] + cc.ChipCount;
////////// ret.WinChipsDic[cc.HoldTimeCnt] = ret.WinChipsDic[cc.HoldTimeCnt] + cc.MatchChips;
////////// }
////////// else
////////// {
////////// ret.HoldCntDic.Add(cc.HoldTimeCnt, 1);
////////// ret.HoldWinCntDic.Add(cc.HoldTimeCnt, matchcnt);
////////// ret.InChipsDic.Add(cc.HoldTimeCnt, cc.ChipCount);
////////// ret.WinChipsDic.Add(cc.HoldTimeCnt, cc.MatchChips);
////////// }
////////// }
//////////}
#endregion
}
}
List <StragChance> cs = new List <StragChance>();
for (int i = 0; i < teststrags.Length; i++)
{
CommCollection sc = new ExpectListProcess(testData).getSerialData(teststrags[i].ReviewExpectCnt, teststrags[i].BySer);
if (testData.Count == 0)
{
break;
}
List <ChanceClass> scs = teststrags[i].getChances(sc, testData.LastData);//获取所有机会
for (int j = 0; j < scs.Count; j++)
{
ChanceClass CurrCc = scs[j];
////scs[j].IncrementType = teststragplans[i].IncreamType;
////scs[j].FixAmt = teststragplans[i].FixAmt;
////scs[j].FixRate = teststragplans[i].FixRate;
StragRunPlanClass currPlan = teststragplans[i];
StragClass currStrag = currPlan.PlanStrag;
CurrCc.HoldTimeCnt = 1;
CurrCc.Cost = CurrCc.ChipCount * CurrCc.UnitCost;
CurrCc.Gained = 0;
CurrCc.Profit = 0;
CurrCc.ExecDate = DateTime.Today;
CurrCc.CreateTime = el.LastData.OpenTime;
CurrCc.UpdateTime = CurrCc.CreateTime;
CurrCc.StragId = currStrag.GUID;
CurrCc.ExpectCode = el.LastData.Expect;
CurrCc.MaxHoldTimeCnt = currPlan.AllowMaxHoldTimeCnt;
CurrCc.FixAmt = currPlan.FixAmt;
CurrCc.FixRate = currPlan.FixRate;
CurrCc.IncrementType = currPlan.IncreamType;
cs.Add(new StragChance(teststrags[i], CurrCc));
}
}
if (ret.ChanceList == null)
{
ret.ChanceList = new List <ChanceClass>();
}
//ret.ChanceList.AddRange(cs);
NoCloseChances = new Dictionary <string, StragChance>();
foreach (string key in tmpChances.Keys)
{
StragChance scc = tmpChances[key];
ChanceClass cc = scc.Chance;
NoCloseChances.Add(key, scc);
//////ProbWaveSelectStragClass组合改为统一交易
////if ((scc.Strag is ProbWaveSelectStragClass) == false)
////{
//// ExchangeChance ec = new ExchangeChance(scc.Strag, testData.LastData.Expect, cc);
//// bool Suc = es.Push(ref ec);
//// if (Suc)
//// NewExchangeRecord.Add(ec.Id, ec);
////}
}
tmpChances = null;
//如果设置了最大持仓，必须按照最大持仓限制下注。
for (int i = 0; i < Math.Min(cs.Count, teststrags[0].CommSetting.MaxHoldingCnt - NoCloseChances.Count); i++)
{
//string key = string.Format("{0}_{1}", cs[i].SignExpectNo, cs[i].ChanceCode);
string key = string.Format("{0}", cs[i].Chance.ChanceCode);
if (NoCloseChances.ContainsKey(key))
{
//////if (teststrag.AllowRepeat)
//////{
////// string test = key;
////// //NoCloseChances.Add(key, cs[i]);
//////}
}
else
{
cs[i].Chance.BaseAmount = es.summary < es.InitCash?1:es.summary / es.InitCash;
NoCloseChances.Add(key, cs[i]);
////////ProbWaveSelectStragClass组合改为统一交易
//////if ((cs[i].Strag is ProbWaveSelectStragClass)==false)
//////{
////// ExchangeChance ec = new ExchangeChance(cs[i].Strag, testData.LastData.Expect, cs[i].Chance);//交易
////// bool Suc = es.Push(ref ec);
////// if (Suc)
////// NewExchangeRecord.Add(ec.Id, ec);
//////}
}
}
//if ((cs[0].Strag is ProbWaveSelectStragClass) == false)
//{
foreach (string key in NoCloseChances.Keys)
{
ExchangeChance ec = new ExchangeChance(es, NoCloseChances[key].Strag, testData.LastData.Expect, NoCloseChances[key].Chance); //交易
if (ec.OccurStrag is ProbWaveSelectStragClass) //对于ProbWaveSelectStragClass，一开始就计算好了Amount
{
ProbWaveSelectStragClass strag = ec.OccurStrag as ProbWaveSelectStragClass;
if (!strag.UseAmountList().ContainsKey(testData.LastData.Expect))
{
Int64 AllAmt = (ec.OccurStrag as ChanceTraceStragClass).getChipAmount(es.summary, ec.OwnerChance, ec.OccurStrag.CommSetting.GetGlobalSetting().DefaultHoldAmtSerials);
Int64 ChipAmt = (Int64)Math.Floor((double)AllAmt / NoCloseChances.Count);
ec.ExchangeAmount = ChipAmt;
ec.ExchangeRate = ChipAmt / es.summary;
if (!strag.UseAmountList().ContainsKey(testData.LastData.Expect))
{
strag.UseAmountList().Add(testData.LastData.Expect, ChipAmt);
}
}
else
{
ec.ExchangeAmount = strag.UseAmountList()[testData.LastData.Expect];
}
}
bool Suc = es.Push(ref ec);
if (Suc)
{
NewExchangeRecord.Add(ec.Id, ec);
}
}
//}
testIndex++;
}
}
return(ret);
}
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>()); //执行交易提供可视化
}
public override List <ChanceClass> getChances(CommCollection sc, ExpectData ed)
{
List <ChanceClass> ret = new List <ChanceClass>();
////ExpectListProcess elp = new ExpectListProcess(Data);
////CommCollection sc = elp.getSerialData(ReviewExpectCnt,BySer);
for (int i = 0; i < 10; i++)
{
Dictionary <int, string> SerStrs = sc.Data[i];
int MaxLen = CommSetting.minColTimes[4]; //5码线
int Max2Len = this.InputMaxTimes - 1; //7码线
if (SerStrs.ContainsKey(MaxLen + 1) && SerStrs[MaxLen].Trim().Length > 0) //最大长度超过了5码线,过滤
{
continue;
}
string strKey = "";
if (SerStrs.ContainsKey(Max2Len))
{
strKey = SerStrs[Max2Len];
}
if (strKey.Trim().Length >= 2) //7码线所包括的内容大于等于2
{
continue;
}
int ishift = sc.Data[0].Count - 1;
while (ishift >= this.ChipCount)
{
if (SerStrs.ContainsKey(ishift))
{
if (SerStrs[ishift].Trim().Length == (10 - this.ChipCount))
{
if (this.ExcludeBS && ChanceClass.isBS(SerStrs[ishift].Trim()))
{
break;
}
if (this.ExcludeSD && ChanceClass.isSD(SerStrs[ishift].Trim()))
{
break;
}
if (this.OnlyBS && !ChanceClass.isBS(SerStrs[ishift].Trim()))
{
break;
}
if (this.OnlySD && !ChanceClass.isSD(SerStrs[ishift].Trim()))
{
break;
}
ChanceClass cc = new ChanceClass();
cc.SignExpectNo = ed.Expect;
cc.ChanceType = 2;
cc.InputTimes = ishift;
cc.InputExpect = ed;
string strCode = "";
if (BySer)
{
strCode = string.Format("{0}/{1}", (i + 1) % 10, SerStrs[ishift].Trim());
}
else
{
strCode = string.Format("{0}/{1}", SerStrs[ishift].Trim(), i);
}
cc.ChanceCode = ChanceClass.getRevChance(strCode);
cc.CreateTime = ed.OpenTime;
cc.Closed = false;
ret.Add(cc);
break;
}
else
{
ishift--;
if (ishift < this.InputMinTimes - 1)
{
break;
}
}
}
}
}
return(ret);
}
double getSucRate(ExpectList el, strag_CommOldClass coc, bool OnlyOnceChance)
{
Dictionary <string, ChanceClass> NoEndChances = new Dictionary <string, ChanceClass>();
Dictionary <string, ChanceClass> TmpChances = new Dictionary <string, ChanceClass>();
int MatchTimes = 0;
int AllTimes = 0;
for (int i = this.InputMaxTimes; i < el.Count; i++)//因为最后一次数据如果下注就不知道结果，所以最后一次排除下注，只做验证上次结果用
{
ExpectList useList = el.getSubArray(i - this.InputMinTimes, this.InputMinTimes);
ExpectData CurrData = useList.LastData;
TmpChances = new Dictionary <string, ChanceClass>();
foreach (string key in NoEndChances.Keys)
{
ChanceClass cc = NoEndChances[key];
int MatchCnt = 0;
bool Matched = cc.Matched(CurrData, out MatchCnt, false);
if (Matched)
{
if (OnlyOnceChance)//如果是一次性机会
{
if (cc.HoldTimeCnt == 1)
{
MatchTimes++;
continue;
}
}
else
{
MatchTimes++;
}
}
else
{
if (!TmpChances.ContainsKey(key))
{
cc.HoldTimeCnt++;
cc.Closed = false;
TmpChances.Add(key, cc);
if (!OnlyOnceChance)//如果不是一次性机会，每次机会都加1
{
AllTimes++;
}
}
}
}
if (i == el.Count - 1)
{
break;//最后一期不找机会
}
NoEndChances = new Dictionary <string, ChanceClass>();
foreach (string key in TmpChances.Keys)//遗留机会
{
NoEndChances.Add(key, TmpChances[key]);
}
BaseCollection scc = new ExpectListProcess(useList).getSerialData(InputMinTimes, BySer) as BaseCollection;
List <ChanceClass> ccs = coc.getChances(scc, CurrData);
for (int j = 0; j < ccs.Count; j++)//新增机会
{
if (!NoEndChances.ContainsKey(ccs[j].ChanceCode))
{
NoEndChances.Add(ccs[j].ChanceCode, ccs[j]);
AllTimes++;
}
}
}
return((double)100 * MatchTimes / AllTimes);
}
public abstract long getChipAmount <T>(double RestCash, ChanceClass <T> cc, AmoutSerials amts) where T : TimeSerialData;
public abstract long getChipAmount(double RestCash, ChanceClass cc, AmoutSerials amts);
public override List <ChanceClass> getChances(CommCollection sc, ExpectData ed)
{
List <ChanceClass> ret = new List <ChanceClass>();
CurrChancesCnt = 0;//置零，防止后面留存
if (this.LastUseData().Count < ReviewExpectCnt)
{
Log("基础数据数量不足", string.Format("小于回览期数:{0}", ReviewExpectCnt));
return(ret);
}
ExpectList LastDataList = this.LastUseData();
ExpectData PreData = LastDataList[LastDataList.Count - 2];
//Log(string.Format("前期{0}:{1}", PreData.Expect, PreData.OpenCode), string.Format("当期{0}:{1}", LastDataList.LastData.Expect, LastDataList.LastData.OpenCode));
//Log(string.Format("el数据长度:{0},First:{1};Last{2}", LastDataList.Count,LastDataList.FirstData.Expect,LastDataList.LastData.Expect), string.Format("原始数据长度:{0};First:{1};Last:{2}", sc.orgData.Count,sc.orgData.FirstData.Expect,sc.orgData.LastData.Expect));
DataTableEx dt = sc.getSubTable(sc.orgData.Count - this.ReviewExpectCnt, this.ReviewExpectCnt);
List <string> strCodes = new List <string>();
for (int i = 0; i < 10; i++)//遍历每个车号/名次
{
List <int> coldata = null;
string strCol = string.Format("{0}", (i + 1) % 10);
dt.getColumnData(strCol, ref coldata);
//Log(string.Format("车/次:{0}",strCol), string.Format("取得的数据:{0}",string.Join(",",coldata)));
int RepeatCnt = 0;
for (int j = 1; j < ReviewExpectCnt; j++)
{
if (coldata[j] == coldata[j - 1])
{
RepeatCnt++;
}
}
if (RepeatCnt < this.ReviewExpectCnt - 1)//如果重复次数小于回顾次数减一，表示重复次数不够，跳过
{
continue;
}
string strCode = "";//其实无需比较，对单个车/名次来说，矩阵都一样,策略只需建立一个即可
strCode = string.Format("{0}/{1}", strCol, coldata[0]);
//Log(string.Format("车/次:{0}", strCol), strCode);
strCodes.Add(strCode);
if (HoldCnt >= 0) //当持有次数超过指定次数后，不再增加
{
HoldCnt++; //持有次数加1
}
//Log("获得机会处理", string.Format("当前持有次数：{0}", HoldCnt));
RealCnt++;
}
if (strCodes.Count == 0)//机会数为0
{
return(ret);
}
if (!GetRev)
{
OnceChance cc = new OnceChance();
cc.SignExpectNo = ed.Expect;
cc.ChanceType = 1;
cc.ChanceCode = string.Join("+", strCodes);
cc.ChipCount = strCodes.Count;//码数必须是实际码数，使用的金额队列必须是1码的队列
cc.InputTimes = RealCnt;
cc.strInputTimes = string.Format("{0}", cc.InputTimes);
cc.AllowMaxHoldTimeCnt = 1;
cc.InputExpect = ed;
cc.NeedConditionEnd = true;
cc.StragId = this.GUID;
//cc.MinWinRate = this.CommSetting.GetGlobalSetting().DefaultHoldAmtSerials.MaxRates[cc.ChipCount - 1];
cc.IsTracer = 0;
cc.Odds = this.CommSetting.GetGlobalSetting().Odds;
CurrChancesCnt = strCodes.Count;
//cc.UnitCost = this.getChipAmount(0,cc,);
ret.Add(cc);
//获得所有机会后，统一为本次机会分配资金
return(ret);
}
else
{
for (int i = 0; i < strCodes.Count; i++)
{
NolimitTraceChance cc = new NolimitTraceChance();
cc.SignExpectNo = ed.Expect;
cc.ChanceType = 1;
cc.ChanceCode = ChanceClass.getRevChance(strCodes[i]);
cc.ChipCount = 9;//码数必须是实际码数，使用的金额队列必须是1码的队列
cc.InputTimes = RealCnt;
cc.strInputTimes = string.Format("{0}", cc.InputTimes);
cc.AllowMaxHoldTimeCnt = 1;
cc.InputExpect = ed;
cc.StragId = this.GUID;
//cc.MinWinRate = this.CommSetting.GetGlobalSetting().DefaultHoldAmtSerials.MaxRates[cc.ChipCount - 1];
cc.IsTracer = 1;
cc.Odds = this.CommSetting.GetGlobalSetting().Odds;
CurrChancesCnt = strCodes.Count;
//cc.UnitCost = this.getChipAmount(0,cc,);
ret.Add(cc);
}
return(ret);
}
}
public RoundBackTestReturnClass RunRound(StragClass teststrag, long TestLong, long StepLong)//滚动获取
{
long begNo = BegExpect;
ExpectReader er = new ExpectReader();
ExpectList el = null;
long cnt = 0;
RoundBackTestReturnClass ret = new RoundBackTestReturnClass();
ExpectList AllData = new ExpectList();
long testIndex = teststrag.ReviewExpectCnt - 1;
ExpectList testData = null;
Dictionary <string, ChanceClass> NoCloseChances = new Dictionary <string, ChanceClass>();
Dictionary <string, ChanceClass> tmpChances = new Dictionary <string, ChanceClass>();
long roundId = 0;
int currRid = 0;
List <Dictionary <string, ChanceClass> > roundNoMatchedChances = new List <Dictionary <string, ChanceClass> >();
List <long> roundBegIds = new List <long>();
while (el == null || el.Count > 0) //如果取到的数据长度大于0
{
el = er.ReadHistory(begNo, LoopCnt);
if (el == null)
{
ret.LoopCnt = cnt * LoopCnt;
ret.succ = false;
ret.Msg = "读取历史数据错误！";
break;
}
if (el.Count == 0)
{
ret.LoopCnt = testIndex;
ret.succ = true;
ret.Msg = string.Format("成功遍历{0}条记录！", testIndex);
break;
}
AllData = ExpectList.Concat(AllData, el);
begNo = el.LastData.LExpectNo + 1;
cnt++;
//Todo:
while (testIndex < AllData.Count)
{
if (testData == null)
{
testData = AllData.getSubArray(0, teststrag.ReviewExpectCnt);
}
else
{
if (AllData[(int)testIndex].ExpectIndex != testData.LastData.ExpectIndex + 1)
{
throw new Exception(string.Format("{1}第{0}期后出现数据遗漏，请补充数据后继续测试！", testData.LastData.Expect, testData.LastData.OpenTime));
}
testData.RemoveAt(0);
testData.Add(AllData[(int)testIndex]);
}
if (roundBegIds.Count > 0 && testIndex == roundBegIds[currRid] + TestLong)//切换当前滚动id
{
//取出当前未完成队列，
Dictionary <string, ChanceClass> NoMatchDic = roundNoMatchedChances[currRid];
BackTestReturnClass brc = ret.RoundData[currRid];
foreach (string key in NoMatchDic.Keys)//结束所有未玩成的结果
{
ChanceClass cc = NoMatchDic[key];
int matchcnt = 0;
if (cc.Matched(testData.LastData, out matchcnt, teststrag.GetRev))
{
cc.HoldTimeCnt = (int)(testData.LastData.ExpectIndex - cc.InputExpect.ExpectIndex);
}
else
{
cc.HoldTimeCnt = 99;//还未开出但是已经结束了的
}
cc.MatchChips = matchcnt;
cc.Closed = true;
cc.EndExpectNo = testData.LastData.Expect;
cc.Closed = true;
cc.EndExpectNo = testData.LastData.Expect;
cc.UpdateTime = testData.LastData.OpenTime;
brc.ChanceList.Add(cc);
if (brc.HoldCntDic.ContainsKey(cc.HoldTimeCnt))
{
brc.HoldCntDic[cc.HoldTimeCnt] = brc.HoldCntDic[cc.HoldTimeCnt] + 1;
}
else
{
brc.HoldCntDic.Add(cc.HoldTimeCnt, 1);
}
}
currRid++;
}
if ((testIndex + 1 - teststrag.ReviewExpectCnt) % (StepLong) == 0) //每到周期整数倍，滚动开始id队列增加当前id
{
roundBegIds.Add(testIndex); //加入队列
roundNoMatchedChances.Add(new Dictionary <string, ChanceClass>()); //加入未完成的机会表到指定队列中
BackTestReturnClass brc = new BackTestReturnClass();
ret.RoundData.Add(brc);
roundId++;
}
for (int i = currRid; i < roundBegIds.Count; i++)//处理每个滚动周期的
{
ExchanceClass cc = new ExchanceClass();
Dictionary <string, ChanceClass> NoMatchDic = roundNoMatchedChances[i];
BackTestReturnClass brc = ret.RoundData[i];
cc.Run(testData, teststrag, ref brc.ChanceList, ref NoMatchDic, ref brc.HoldCntDic);
roundNoMatchedChances[i] = NoMatchDic;
brc.LoopCnt = testIndex - roundBegIds[i] + 1;
ret.RoundData[i] = brc;
}
testIndex++;
}
}
return(ret);
}
public new bool CheckNeedEndTheChance(ChanceClass cc, bool LastExpectMatched)
{
return(LastExpectMatched);
}
public override long getChipAmount(double RestCash, ChanceClass cc, AmoutSerials amts)
{
return(amts.Serials[0][HoldCnt - 1]);
}
public override List <ChanceClass> getChances(BaseCollection sc, ExpectData ed)
{
InitAllPeaks();//初始化峰值列表
List <ChanceClass> ret = new List <ChanceClass>();
if (sc == null || sc.Table == null || sc.Table.Rows.Count < this.ReviewExpectCnt)
{
return(ret);
}
int AllItemCnt = AllBinomPeaks.Count;
Dictionary <string, Dictionary <int, int> > AllList = new Dictionary <string, Dictionary <int, int> >();
for (int i = 0; i < 10; i++)//遍历各车/各名次
{
string strCol = string.Format("{0}", (i + 1) % 10);
//string strVal = ed.ValueList[i];
Dictionary <int, int> ValCntItems = new Dictionary <int, int>();
for (int val = 0; val < 10; val++)//对每个数字出现的次数检查
{
ValCntItems.Add(val, 0);
string strVal = string.Format("{0}", val);
foreach (string key in AllBinomPeaks.Keys) //遍历所有峰值清单
{
int ViewCnt = int.Parse(key.Split('_')[0]); //获得峰值清单对应的实验次数
int ExistCnt = sc.FindLastDataExistCount(ViewCnt, strCol, strVal); //获得前N-1次该车次出现的次数
if (AllBinomPeaks[key].Contains(ExistCnt + 1)) //如果该二项分布检查的峰值是7，8，9，值出现的次数是6，7，8,匹配，+1
{
ValCntItems[val] = ValCntItems[val] + 1;
}
}
}
//满足所有二项分布的才入选
Dictionary <int, int> ValidItems = ValCntItems.Where(c => c.Value == AllItemCnt).ToDictionary(a => a.Key, b => b.Value);
Dictionary <int, int> MatchPoisonItems = new Dictionary <int, int>();
foreach (int key in ValidItems.Keys)
{
int ViewCnt = MinFilterCnt - 1; //找出所有值在前100次里出现的次数
int ExistCnt = sc.FindLastDataExistCount(ViewCnt, strCol, key.ToString()); //满足最泊松分布最顶峰
if (ExistCnt == ViewCnt / 10 - 1)
{
MatchPoisonItems.Add(key, ValidItems[key]);
}
}
AllList.Add(strCol, MatchPoisonItems);
}
//检查所有满足条件的清单
Dictionary <string, int> AllCodes = new Dictionary <string, int>();
List <string> strCnts = new List <string>();
bool RetMutliChances = this.FixChipCnt;
foreach (string strcol in AllList.Keys)
{
if (AllList[strcol].Count == 0)
{
continue;
}
int MaxCnt = AllList[strcol].Values.Max();//选最优
//Dictionary<int,int> strCodeList = AllList[strcol].Where(a => a.Value == MaxCnt).ToDictionary(a => a.Key, b => b.Value);
Dictionary <int, int> strCodeList = AllList[strcol];
string StrCode = "";
string StrVal = string.Join("", strCodeList.Keys.ToArray());
string strCnt = string.Join("_", strCodeList.Values.ToArray());
strCnts.Add(strCnt);
if (BySer)
{
StrCode = string.Format("{0}/{1}", strcol, StrVal);
}
else
{
StrCode = string.Format("{0}/{1}", StrVal, strcol);
}
AllCodes.Add(StrCode, strCodeList.Count);
}
Log("所有选出来的记录", string.Join("+", AllCodes.Keys.ToArray()));
if (AllCodes.Count == 0)
{
return(ret);
}
if (RetMutliChances)
{
foreach (string key in AllCodes.Keys)
{
int Chips = AllCodes[key];
if (Chips == 1)
{
continue;
}
if (Chips < this.ChipCount)
{
continue;
}
ChanceClass cc = new ChanceClass();
cc.ChanceCode = key;
cc.SignExpectNo = ed.Expect;
cc.ChanceType = 2;
cc.ChipCount = AllCodes[key];
cc.InputTimes = 1;
cc.strInputTimes = "";// string.Join("_", strCnts.ToArray());
//cc.AllowMaxHoldTimeCnt = this.AllowMaxHoldTimeCnt;
cc.InputExpect = ed;
cc.StragId = this.GUID;
//cc.MinWinRate = this.CommSetting.GetGlobalSetting().DefaultHoldAmtSerials.MaxRates[cc.ChipCount - 1];
cc.IsTracer = 0;
cc.HoldTimeCnt = 1;
cc.Odds = this.CommSetting.GetGlobalSetting().Odds;
cc.ExpectCode = ed.Expect;
cc.CreateTime = DateTime.Now;
cc.UpdateTime = DateTime.Now;
cc.AllowMaxHoldTimeCnt = 1;
cc.Closed = false;
ret.Add(cc);
}
return(ret);
}
////if (AllCodes.Count == 1 && AllCodes.First().Value == 1)//独此一份
//// return ret;
string strAllCode = string.Join("+", AllCodes.Keys.ToArray());
if (ChanceClass.getChipsByCode(strAllCode) < this.ChipCount)
{
return(ret);
}
if (!RetMutliChances)
{
ChanceClass cc = new ChanceClass();
cc.SignExpectNo = ed.Expect;
cc.ChanceType = 2;
cc.ChipCount = AllCodes.Sum(p => p.Value);
cc.InputTimes = 1;
cc.strInputTimes = string.Join("_", strCnts.ToArray());
//cc.AllowMaxHoldTimeCnt = this.AllowMaxHoldTimeCnt;
cc.InputExpect = ed;
cc.StragId = this.GUID;
//cc.MinWinRate = this.CommSetting.GetGlobalSetting().DefaultHoldAmtSerials.MaxRates[cc.ChipCount - 1];
cc.IsTracer = 0;
cc.HoldTimeCnt = 1;
cc.Odds = this.CommSetting.GetGlobalSetting().Odds;
cc.ExpectCode = ed.Expect;
cc.ChanceCode = string.Join("+", AllCodes.Keys.ToArray());
cc.CreateTime = DateTime.Now;
cc.UpdateTime = DateTime.Now;
cc.AllowMaxHoldTimeCnt = 1;
cc.Closed = false;
ret.Add(cc);
}
return(ret);
}
public abstract bool CheckNeedEndTheChance(ChanceClass cc, bool LastExpectMatched);
