public long getChipAmount(double RestCash, ChanceClass cc, AmoutSerials amts)
{
int chips = 0;
int maxcnt = amts.MaxHoldCnts[chips];
int bShift = 0;
int eShift = 0;
int bHold = cc.HoldTimeCnt;// HoldCnt - CurrChancesCnt + 1;
if (cc.IncrementType == InterestType.CompoundInterest)
{
if (cc.AllowMaxHoldTimeCnt > 0 && cc.HoldTimeCnt > cc.AllowMaxHoldTimeCnt)
{
return(0);
}
return((long)Math.Floor(cc.FixRate.Value * RestCash / cc.ChipCount));
}
//Log("获取机会金额处理", string.Format("当前持有次数：{0}", HoldCnt));
if (bHold > maxcnt)
{
Log("风险", "通用重复策略开始次数达到最大上限", string.Format("机会{0}持有次数达到{1}次总投入金额已为{2}", cc.ChanceCode, bHold, "未知"));
bShift = (int)maxcnt * 2 / 3;
}
int HoldCnt = bHold;
int bRCnt = (bHold % (maxcnt + 1)) + bShift - 1;
int eRCnt = (HoldCnt % (maxcnt + 1)) + eShift - 1;
if (cc.ChipCount < 4)//如果是4码以下取平均值
{
return((amts.Serials[chips][bRCnt] + amts.Serials[chips][eRCnt]) / 2);
}
//四码以上取最大值，防止投入不够导致亏损
return(amts.Serials[chips][eRCnt]);
}
public override long getChipAmount(double RestCash, ChanceClass cc, AmoutSerials amts)
{
try
{
if (cc.IncrementType == InterestType.CompoundInterest)
{
if (cc.AllowMaxHoldTimeCnt > 0 && cc.HoldTimeCnt > 1)
{
return(0);
}
//
double rate = cc.FixRate.Value;
//double rate = KellyMethodClass.KellyFormula(1, 9.75, 0.1032);
long ret = (long)Math.Ceiling((double)(RestCash * rate));
return(ret);
}
if (cc.HoldTimeCnt > 1)
{
return(0);
}
return(cc.FixAmt.Value);
}
catch (Exception e)
{
Log("错误", string.Format("获取单码金额错误:{0}", e.Message), e.StackTrace);
}
return(1);
}
public override StagConfigSetting getInitStagSetting()
{
StagConfigSetting sett = new StagConfigSetting();
sett.BaseType = new BaseTypeSetting();
string[] list = new string[] {};
GlobalClass gc = this.CommSetting.GetGlobalSetting();
AmoutSerials As = GlobalClass.getOptSerials(gc.Odds, gc.DefMaxLost, gc.DefFirstAmt);
if (As.MaxHoldCnts.Length > 0)
{
Int64[] UnitAmtArr = As.Serials[this.ChipCount - 1];
list = UnitAmtArr.ToList().Select(t => t.ToString()).ToArray();
}
else
{
list = this.CommSetting.GetGlobalSetting().UnitChipArray(this.ChipCount);
}
List <int> ret = new List <int>();
for (int i = 0; i < list.Length; i++)
{
ret.Add(int.Parse(list[i]));
}
sett.BaseType.ChipSerial = ret;
return(sett);
}
public override long getChipAmount(double RestCash, ChanceClass cc, AmoutSerials amts)
{
try
{
if (cc.HoldTimeCnt > cc.MaxHoldTimeCnt && cc.MaxHoldTimeCnt > 0)//但是只有第一次有投入
{
return(0);
}
if (cc.IncrementType == InterestType.CompoundInterest)
{
double rate = KellyMethodClass.KellyFormula(cc.ChipCount, 10, 9.75, 1.001);
//double rate = KellyMethodClass.KellyFormula(cc.ChipCount, 9.75, 0.3396);
long ret = (long)Math.Floor((double)(RestCash * rate) / cc.ChipCount);
return(ret);
}
int chips = cc.ChipCount - 1;
int maxcnt = amts.MaxHoldCnts[chips];
int bShift = 0;
if (cc.HoldTimeCnt > maxcnt)
{
Log("风险", "达到最大上限", string.Format("机会{0}持有次数达到{1}次总投入金额已为{2}", cc.ChanceCode, cc.HoldTimeCnt, cc.Cost));
bShift = (int)maxcnt * 2 / 3;
}
int RCnt = (cc.HoldTimeCnt % (maxcnt + 1)) + bShift - 1;
return(amts.Serials[chips][RCnt]);
}
catch
{
}
return(0);
}
public long getDefaultChipAmount(double RestCash, ChanceClass cc, AmoutSerials amts)
{
try
{
int chips = cc.ChipCount - 1;
int maxcnt = amts.MaxHoldCnts[chips];
int eShift = 0;
int bHold = cc.HoldTimeCnt;// HoldCnt - CurrChancesCnt + 1;
if (cc.IncrementType == InterestType.CompoundInterest)
{
if (cc.AllowMaxHoldTimeCnt > 0 && cc.HoldTimeCnt > cc.AllowMaxHoldTimeCnt)
{
return(0);
}
return((long)Math.Floor(cc.FixRate.Value * RestCash / cc.ChipCount));
}
//Log("获取机会金额处理", string.Format("当前持有次数：{0}", HoldCnt));
bool firstTimes = true;
if (bHold > maxcnt)
{
firstTimes = false;
Log("风险", "通用重复策略开始次数达到最大上限", string.Format("机会{0}持有次数达到{1}次总投入金额已为{2}", cc.ChanceCode, bHold, "未知"));
eShift = (int)maxcnt * 2 / 3;
}
//int eRCnt = (bHold % (maxcnt + 1)) + eShift - 1;
int eRCnt = firstTimes?bHold - 1:Math.Min(maxcnt - 1, eShift + ((bHold - maxcnt) % (maxcnt - eShift)));
return(amts.Serials[chips][eRCnt]);
}
catch (Exception ce)
{
return(1);
}
}
public override long getChipAmount(double RestCash, ChanceClass cc, AmoutSerials amts)
{
int chips = 0;
int maxcnt = amts.MaxHoldCnts[chips];
int bShift = 0;
int eShift = 0;
int bHold = HoldCnt - cc.ChipCount + 1;// HoldCnt - CurrChancesCnt + 1;
if (cc.IncrementType == InterestType.CompoundInterest)
{
if (cc.AllowMaxHoldTimeCnt > 0 && cc.HoldTimeCnt > cc.AllowMaxHoldTimeCnt)
{
return(0);
}
return((long)Math.Floor(cc.FixRate.Value * RestCash / cc.ChipCount));
}
//Log("获取机会金额处理", string.Format("当前持有次数：{0}", HoldCnt));
if (HoldCnt < 0)//如果超出指定的最大持仓次数，跟踪不投注，直到实现后继续跟踪
{
return(0);
}
if (bHold > maxcnt)
{
Log("风险", "通用重复策略开始次数达到最大上限", string.Format("机会{0}持有次数达到{1}次总投入金额已为{2}", cc.ChanceCode, bHold, "未知"));
bShift = (int)maxcnt * 2 / 3;
}
if (HoldCnt > maxcnt)
{
Log("风险", "通用重复策略结束次数达到最大上限", string.Format("机会{0}持有次数达到{1}次总投入金额已为{2}", cc.ChanceCode, HoldCnt, "未知"));
eShift = (int)maxcnt * 2 / 3;
}
Log("状态", string.Format("HoldCnt:{0};HoldTimes:{1};Chips:{2}", HoldCnt, cc.HoldTimeCnt, cc.ChipCount));
try
{
int bRCnt = (bHold % (maxcnt + 1)) + bShift - 1;
////int eRCnt = (HoldCnt % (maxcnt + 1)) + eShift - 1;
////if (CurrChancesCnt < 4)//如果是4码以下取平均值 --需要改变
////{
//// return (amts.Serials[chips][bRCnt] + amts.Serials[chips][eRCnt]) / 2;
////}
//////四码以上取最大值，防止投入不够导致亏损
////return amts.Serials[chips][eRCnt];
if (cc.ChipCount == 1)
{
return(amts.Serials[chips][bRCnt]);
}
return(calcMutliChanceAmount(cc, amts, bRCnt));
}
catch (Exception e)
{
Log(e.Message, e.StackTrace);
return(1);
}
}
public override long getChipAmount(double RestCash, ChanceClass cc, AmoutSerials amts)
{
ExpectList data = LastUseData();
if (data == null)
{
return(0);
}
if (data.LastData.Expect == cc.ExpectCode)
{
return(1);
}
return(0);
}
public override long getChipAmount(double RestCash, ChanceClass cc, AmoutSerials amts)
{
DataTypePoint dtp = UsingDpt;
if (mSc != null)
{
string strCode = cc.ChanceCode;
string type = strCode.Substring(0, 1);
string target = strCode.Substring(1, 1);
amts = mSc.getOptSerials(dtp, type, int.Parse(target), this.CommSetting.Odds, allowInvestmentMaxValue, 1, false);
}
if (amts.Serials == null)
{
return(1);
}
return(getDefaultChipAmount(RestCash, cc, amts));
}
public override Int64 getChipAmount(double RestCash, ChanceClass cc, AmoutSerials ams)
{
if (cc.IncrementType == InterestType.SimpleInterest)
{
return((int)Math.Floor(this.CommSetting.InitCash * 0.01));
}
double p = (double)(cc.ChipCount / this.CommSetting.Odds);
double Normal_p = (double)cc.ChipCount / 10;
double _MinRate = Normal_p + this.MinWinRate * (p - Normal_p);
p = _MinRate;
double b = (double)this.CommSetting.Odds;
double q = 1 - p;
double rate = (p * b - q) / b / 10;
return((int)Math.Floor(RestCash * rate / cc.ChipCount));
}
long calcMutliChanceAmount(ChanceClass cc, AmoutSerials amts, int holdTimes)
{
if (holdTimes < 2)
{
return(1);
}
int HavingHoldTime = holdTimes;
long[] arr = amts.Serials[0];
long[] HaveArr = new long[HavingHoldTime];
Array.Copy(arr, HaveArr, HavingHoldTime);
long HaveSum = HaveArr.Sum();
long minAmount = (long)Math.Ceiling(HaveSum / (this.CommSetting.GetGlobalSetting().Odds - cc.ChipCount));
if (minAmount <= 1)
{
minAmount = 1;
}
return(minAmount);
}
public override long getChipAmount(double RestCash, ChanceClass cc, AmoutSerials amts)
{
try
{
if (cc.IncrementType == InterestType.CompoundInterest)
{
if (cc.MaxHoldTimeCnt > 0 && cc.HoldTimeCnt > cc.MaxHoldTimeCnt)
{
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);
}
if (cc.ChipCount <= 3 && cc.HoldTimeCnt > cc.MaxHoldTimeCnt && cc.MaxHoldTimeCnt > 0)
{
return(0);
}
if (cc.HoldTimeCnt <= cc.MaxHoldTimeCnt && cc.MaxHoldTimeCnt > 0) //如果小于等于1
{
return(cc.FixAmt.Value);
}
int chips = cc.ChipCount - 1;
int maxcnt = amts.MaxHoldCnts[chips];
int bShift = 0;
if (cc.HoldTimeCnt > maxcnt)
{
Log("风险", "达到最大上限", string.Format("机会{0}持有次数达到{1}次总投入金额已为{2}", cc.ChanceCode, cc.HoldTimeCnt, cc.Cost));
bShift = (int)maxcnt * 2 / 3;
}
int RCnt = (cc.HoldTimeCnt % (maxcnt + 1)) + bShift - 1;
return(amts.Serials[chips][RCnt]);
}
catch (Exception e)
{
Log("错误", "获取单码金额错误", e.Message);
}
return(1);
}
/// <summary>
/// 统一下注数量
/// </summary>
/// <param name="RestCash"></param>
/// <param name="cc"></param>
/// <returns></returns>
public override Int64 getChipAmount(double RestCash, ChanceClass cc, AmoutSerials ams)
{
////if (this.UseAmountList.ContainsKey(this.LastUseData.LastData.Expect))
////{
//// //return this.UseAmountList[this.LastUseData.LastData.Expect];
////}
if (cc.IncrementType == InterestType.SimpleInterest)
{
return((int)Math.Floor(this.CommSetting.InitCash * 0.01));
}
double p = (double)(cc.ChipCount / this.CommSetting.Odds);
double Normal_p = (double)cc.ChipCount / 10;
double _MinRate = Normal_p + this.MinWinRate * (p - Normal_p);
p = _MinRate;
double b = (double)this.CommSetting.Odds;
double q = 1 - p;
double rate = (p * b - q) / b;
double cs = Math.Sqrt(this.CommSetting.MaxHoldingCnt);
Int64 AllAmount = (Int64)Math.Floor(RestCash * rate / cc.ChipCount);
//this.UseAmountList.Add(this.LastUseData.LastData.Expect, AllAmount);
return(AllAmount);
}
public new void ExecRun(object data)
{
ExpectList <T> el = data as ExpectList <T>;
//2019/4/22日出现错过732497，732496两期记录错过，但是732498却收到的情况，同时，正好在732498多次重复策略正好开出结束，因错过2期导致一直未归零，
//一直长时间追号开出近60期
//为避免出现这种情况
//判断是否错过了期数，如果错过期数，将所有追踪策略归零，不再追号,也不再执行选号程序，
//是否要连续停几期？执行完后，在接收策略里面发现前10期有不连续的情况，直接跳过，只接收数据不执行选号。
if (el.MissExpectCount() > 1)//期号不连续
{
}
//Log("计算服务","准备数据", "为每个策略分配数据");
foreach (string key in UseStrags.Keys)
{
UseStrags[key].SetLastUserData(el);
}
//准备数据
BaseCollection <T> cc = null;
int maxViewCnt = (int)this.UseStrags.Max(t => t.Value.ReviewExpectCnt);
//Log("计算服务", "最大回览期数", maxViewCnt.ToString());
cc = new ExpectListProcessBuilder <T>(dtp, el).getProcess().getSerialData(maxViewCnt, this.UseSerial);
// cc.orgData = el;//必须指定原始数据？
//Log("计算服务", "中间数据长度",cc.Data.Count.ToString());
Dictionary <StragClass, List <ChanceClass> > css = new Dictionary <StragClass, List <ChanceClass> >();
//Log("计算服务", "计算数据", "为每个策略计算最大回顾周期数据");
//遍历每个策略获得机会
DbChanceList <T> OldDbList = new DbChanceList <T>();
Dictionary <string, ChanceClass <T> > OldList = new Dictionary <string, ChanceClass <T> >();
List <ChanceClass <T> > NewList = new List <ChanceClass <T> >();
//Log("计算服务", "遍历所有策略", string.Format("策略数量:{0}",this.UseStrags.Count));
CloseAllExchance(el);//清空所有可视化机会
#region 获取交易机会
for (int i = 0; i < this.UseSPlans.Count; i++)
{
StragRunPlanClass <T> currPlan = UseSPlans[i];
if (currPlan.PlanStrag == null)//如果计划所执行的策略为空，只在chance上执行tracer
{
List <ChanceClass <T> > emptycs = CurrExistChanceList.Values.Where(p => p.StragId == null).ToList <ChanceClass <T> >();
for (int c = 0; c < emptycs.Count; c++)
{
ChanceClass <T> CurrCc = emptycs[c];
TraceChance <T> tcc = CurrCc as TraceChance <T>;
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;
}
BaseStragClass <T> currStrag = UseStrags[currPlan.PlanStrag.GUID];
currStrag.SetLastUserData(el); //必须<T>给策略填充数据
List <ChanceClass <T> > 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 <T> > 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 <T> 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 <T> 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.getCurrExchangeServer().summary;
}
else
{
continue;
}
}
//Log("计算服务", "再次检查数据", string.Format("出现相同的机会{0},持有次数增1.->{1}", CurrCc.ChanceCode, CurrCc.HoldTimeCnt));
CurrCc.UnitCost = -1; //先默认为-1
if (currStrag is WolfInv.com.BaseObjectsLib.ISpecAmount) //先从策略级别判断
{
WolfInv.com.BaseObjectsLib.ISpecAmount testStrag = (currStrag as WolfInv.com.BaseObjectsLib.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 <T> useCc = Convert.ChangeType(CurrCc, currStrag.getTheChanceType()) as TraceChance <T>;
//Log("计算服务", "使用的机会持有次数", string.Format("HoldTimes:{0}", useCc.HoldTimeCnt));
if (useCc == null) //获得的类型并非跟踪类型
{
CurrCc.UnitCost = (currStrag as ChanceTraceStragClass).getChipAmount(restAmt, CurrCc, amts);
}
else
{
CurrCc.UnitCost = useCc.getChipAmount <T>(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.AllowMaxHoldTimeCnt = currPlan.AllowMaxHoldTimeCnt;
CurrCc.ChanceType = currPlan.OutPutType;
NewList.Add(CurrCc);
}
#endregion
#region 未关闭的机会需要自我跟踪
foreach (string code in StragChances.Keys)
{
ChanceClass <T> 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 WolfInv.com.BaseObjectsLib.ISpecAmount)//先从策略级检查
{
WolfInv.com.BaseObjectsLib.ISpecAmount specStrag = currStrag as WolfInv.com.BaseObjectsLib.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 <T> testCc = (TraceChance <T>)CurrCc;
if (testCc == null)
{
continue;
}
CurrCc.UnitCost = testCc.getChipAmount <T>(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++;
WolfInv.com.BaseObjectsLib.ISpecAmount Strag = (WolfInv.com.BaseObjectsLib.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);
DataReader dr = DataReaderBuild.CreateReader(GlobalClass.DataTypes.First().Key, null, null);
//int savecnt = new PK10ExpectReader().SaveChances<T>(OldDbList.Values.ToList<ChanceClass<T>>(), null);
int savecnt = dr.SaveChances <T>(OldDbList.Values.ToList <ChanceClass <T> >(), null);
if (OldList.Count > 0)
{
Log("计算服务", "保存已有机会", string.Format("条数：{0};实际条数:{1}", OldList.Count, savecnt));
}
savecnt = dr.SaveChances <T>(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 <T> >().ForEach(p => AllNoClosedChances.Add(p.GUID, p)); //就算是老记录未有guid,当ToTable时已经生成了guid
ExChange(AllNoClosedChances.Values.ToList <ChanceClass <T> >(), el.LastData.Expect); //执行交易提供可视化
}
public override long getChipAmount(double RestCash, ChanceClass cc, AmoutSerials amts)
{
return(getDefaultChipAmount(RestCash, cc, amts));
return(amts.Serials[0][HoldCnt - 1]);
}
public abstract long getChipAmount(double RestCash, ChanceClass cc, AmoutSerials amts);
public override long getChipAmount <T>(double RestCash, ChanceClass <T> cc, AmoutSerials amts)
{
return(getChipAmount(RestCash, cc, amts));
}
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 long getChipAmount <T1>(double RestCash, ChanceClass <T1> cc, AmoutSerials amts) where T1 : TimeSerialData;
public override long getChipAmount(double RestCash, ChanceClass cc, AmoutSerials amts)
{
return((Int64)Math.Floor(RestCash * 0.001));//ProbMath.GetFactorial
}
long ISpecAmount.getChipAmount(double RestCash, ChanceClass cc, AmoutSerials amts)
{
throw new NotImplementedException();
}
public long getChipAmount <T>(double RestCash, ChanceClass <T> cc, AmoutSerials amts) where T : TimeSerialData
{
throw new NotImplementedException();
}
AmoutSerials getOptSerials_detail(string type, int len, double odds, Int64 MaxValue, int FirstAmt, bool NeedAddFirst)
{
string model = "key_{0}_{1}_{2}_{3}_{4}";
string key = string.Format(model, type, len, odds, MaxValue, FirstAmt);
if (AllSerialSettings == null)
{
AllSerialSettings = new Dictionary <string, AmoutSerials>();
}
if (AllSerialSettings.ContainsKey(key))
{
return(AllSerialSettings[key]);
}
AmoutSerials retval = new AmoutSerials();
if (double.IsNaN(odds) || MaxValue == 0)
{
return(retval);
}
int calcLen = 1;
int[] ret = new int[calcLen];
double[] Rates = new double[calcLen];
Int64[] MaxSum = new Int64[calcLen];
Int64[][] Serials = new Int64[calcLen][];
//int MaxValue = 20000;
//double odds = 9.75;
for (int i = 0; i < ret.Length; i++)
{
Int64[] Ser = new Int64[0];
int MaxCnts = 1;
double bRate = 0.0005;
double stepRate = 0.001;
Int64 CurrSum = getSum(i + 1, MaxCnts, FirstAmt, odds, 0, out Ser);
while (CurrSum < MaxValue)//计算出在指定资金范围内保本所能达到的次数
{
MaxCnts++;
CurrSum = getSum(i + 1, MaxCnts, 1, odds, 0, out Ser);
}
MaxCnts--; //回退1
long TestSum = getSum(i + 1, MaxCnts, FirstAmt, odds, bRate, out Ser);
if (TestSum > MaxValue) //如果最少盈利下所需资金大于指定值，所能达到的次数减一
{
bRate = 0;
stepRate = 0.0001;
CurrSum = getSum(i + 1, MaxCnts, FirstAmt, odds, bRate, out Ser);
}
else
{
CurrSum = TestSum;
}
Int64 LastSum = CurrSum;
double LastRate = bRate;
while (CurrSum < MaxValue)
{
LastSum = CurrSum;
LastRate = bRate;
bRate += stepRate;
CurrSum = getSum(i + 1, MaxCnts, FirstAmt, odds, bRate, out Ser);
}
CurrSum = getSum(i + 1, MaxCnts, FirstAmt, odds, LastRate, out Ser);
if (i == 0)//对于单注，多加10个元素，给重复策略用。
{
getSum(i + 1, MaxCnts + 10, FirstAmt, odds, LastRate, out Ser);
}
if (NeedAddFirst)
{
List <long> list = Ser.ToList();
ret[i] = MaxCnts + 1;
list.Insert(0, FirstAmt);
Rates[i] = bRate - stepRate;
MaxSum[i] = LastSum + FirstAmt;
Serials[i] = list.ToArray();
}
else
{
ret[i] = MaxCnts;
Rates[i] = bRate - stepRate;
MaxSum[i] = LastSum;
Serials[i] = Ser;
}
}
retval.MaxHoldCnts = ret;
retval.MaxRates = Rates;
retval.Serials = Serials;
if (!AllSerialSettings.ContainsKey(key))//防止计算过程中有其他设置请求了
{
AllSerialSettings.Add(key, retval);
}
return(retval);
}
public string getUserInsts(GlobalClass setting, DataTypePoint dtp, string NewExpectNo, string forweb, Func <string, string, int, SelectTimeInstClass> getRemoteCnt)
{
string ret = "";
List <string> allTxt = new List <string>();
AmoutSerials amts = setting.DefaultHoldAmtSerials;
for (int i = 0; i < this.Count; i++)
{
ChanceClass cc = this[i];
string strAssetId = cc.AssetId;
int AssetCnt = 0;
string strccNewInst = "";
if (cc.ChanceCode.Trim().Length == 0)
{
continue;
}
if (cc.UnitCost == 0)
{
continue;
}
string strCurrExpect = cc.ExpectCode;
int calcHoldTimes = (int)DataReader.getInterExpectCnt(strCurrExpect, NewExpectNo, dtp);
if (cc.HoldTimeCnt + 1 < calcHoldTimes)
{
continue;
}
if (!cc.Tracerable) //只要是非跟踪策略
{
if (calcHoldTimes > 1) //和要下注的期数大于1就过滤，因为不要跟踪，只有当期才要下注
{
continue;
}
}
if (setting.AssetUnits.ContainsKey(strAssetId))
{
AssetInfoConfig aic = setting.AssetUnits[strAssetId];
if (aic == null)
{
continue;
}
AssetCnt = aic.value;
if (aic.NeedSelectTimes == 1)
{
int newVal = 0;
if (SelectTimeDic == null)
{
SelectTimeDic = new Dictionary <string, int>();
}
if (SelectTimeDic.ContainsKey(cc.GUID))
{
newVal = SelectTimeDic[cc.GUID];
}
else
{
SelectTimeInstClass obj = getSelectTimeAmt(dtp, cc.ExpectCode, AssetCnt, getRemoteCnt);
if (obj == null)
{
continue;
}
newVal = obj.RetCnt;
SelectTimeChanged?.Invoke(strAssetId, AssetCnt, obj);
AssetCnt = obj.RetCnt;
setting.AssetUnits[strAssetId].value = newVal;
SelectTimeDic.Add(cc.GUID, newVal);
}
AssetCnt = newVal;
}
}
//修改为自动计算出来的结果
//Int64 Amt = cc.UnitCost*setting.SerTotal(cc.ChipCount);
int chips = cc.ChipCount - 1;
int maxcnt = 1;
if (amts.MaxHoldCnts.Length < chips)//只支持小注数策略，大注数全部使用1
{
maxcnt = amts.MaxHoldCnts[chips];
}
int bShift = 0;
if (cc.HoldTimeCnt > maxcnt)
{
bShift = (int)maxcnt * 2 / 3;
}
int RCnt = (cc.HoldTimeCnt % (maxcnt + 1)) + bShift - 1;
Int64 Amt = 1;
if (amts.MaxHoldCnts.Length < chips)
{
Amt = amts.Serials[chips][RCnt] * AssetCnt;
}
if (cc.ChanceType != 2) //非对冲
{
if (cc.ChanceType == 1) //一次性下注
{
Amt = cc.UnitCost * setting.SerTotal(1) * AssetCnt;
}
strccNewInst = string.Format("{0}/{1}", cc.ChanceCode.Replace("+", string.Format("/{0}+", Amt)), Amt);
}
else
{
if (!setting.JoinHedge)//不参与对冲
{
continue;
}
Amt = cc.UnitCost * setting.HedgeTimes * AssetCnt;//对冲倍数
if (setting.AllowHedge)
{
Int64 BaseAmt = cc.BaseCost * setting.HedgeTimes * AssetCnt;
strccNewInst = string.Format("{0}/{1}+{2}/{3}", cc.ChanceCode, Amt + BaseAmt, ChanceClass.getRevChance(cc.ChanceCode), BaseAmt);
}
else
{
strccNewInst = string.Format("{0}/{1}", cc.ChanceCode, Amt);
}
}
allTxt.Add(strccNewInst);
}
GlobalClass.SetConfig(forweb);
return(string.Join(" ", allTxt.ToArray()).Trim());
}
//{
// return false;
//}
public long getChipAmount <T>(double RestCash, ChanceClass <T> cc, AmoutSerials amts) where T : TimeSerialData
{
ChanceClass scc = cc.CopyTo <ChanceClass>();
return(getChipAmount(RestCash, scc, amts));
}
