Exemple #1
0
 /// <summary>
 /// 返回一个本控件的窗体
 /// </summary>
 public static FormModel CreateForm(RuleInfo[] rules)
 {
     DataFilter dm = new DataFilter();
     dm.AllRules = rules;           
     dm.Dock = DockStyle.Fill;
     FormModel tf = new FormModel();
     tf.Size = new Size(dm.Width + 17, dm.Size.Height + 40);
     tf.Controls.Add(dm);//将控件添加到窗体中            
     tf.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle;
     return tf;           
 }
Exemple #2
0
 /// <param name="ruleList">规则列表</param>
 public override bool[][] ValidateRuleList(RuleInfo[] ruleList)
 {
     bool[][] res = new bool[ruleList.Length][];
     for (int i = 0; i < ruleList.Length; i++)
     {
         //首先获取计算的数据,直接从data中获取              
         ruleList[i].IndexSelector.RuleInfoParams = ruleList[i];
         res[i] = ruleList[i].IndexSelector.GetValidateResult
             (GetNeedDataByCache(ruleList[i].CalcuteRows + ruleList[i].NeedRows));//已经考虑多期指标
     }
     return res;
 }
Exemple #3
0
 private static LotTickData[] FilterData(RuleInfo[] rules)
 {          
     Dictionary<int, string> dic;
     LotTickData[] result = TwoColorBall.FilteByRuleList(rules, out dic);
     //过滤结果写入数据库,并刷新
     foreach (var item in dic)
     {
         tb_Rules temp = tb_Rules.FindById(item.Key);
         temp.FilterInfo = item.Value;
         temp.Update();
     }
     return result;           
 }
 /// <summary>
 /// 需要自定义的长度L
 /// </summary>        
 public Index_红求余覆盖数(RuleInfo ruleInfo, bool isDeleteMode = false)
 {
     this.RuleInfoParams = ruleInfo;
     IsDeleteNumberMode = isDeleteMode;
     if (ruleInfo.CondtionParams.ParamsValue != null)
     {
         L = Convert.ToInt32(ruleInfo.CondtionParams.ParamsValue);
     }
     else
     {
         L = 17;
     }
 }
Exemple #5
0
 /// <summary>
 /// 初始化,传入参数对象
 /// TODO:传入一个实际的彩票类型对象(包括了需要计算的数据和参数),指标根据参数计算得到需要计算的数据
 /// </summary>        
 public LotIndex(RuleInfo ruleInfo,bool isDeleteMode = false)
 {
     this.RuleInfoParams = ruleInfo;
     IsDeleteNumberMode = isDeleteMode;
 }
Exemple #6
0
 public Index_Base杀号(RuleInfo ruleInfo)
 {
     this.RuleInfoParams = ruleInfo;
     this.IsDeleteNumberMode = true;//默认为杀号模式
 }
Exemple #7
0
 /// <summary>
 /// 根据过滤规则数据,对数据进行过滤:这是不使用提前方案
 /// 直接对所有数据过滤,速度较慢
 /// </summary>
 /// <param name="ruleList">规则列表</param>
 /// <param name="filterInfos">过滤信息</param>
 /// <returns>过滤后的数据集合</returns>
 /// <param name="fileName">需要加载的初始数据文件名称</param>
 public static LotTickData[] FilteByRuleList(RuleInfo[] ruleList, 
     out Dictionary<int, string> filterInfos,string fileName = null )
 {
     if (fileName == null)
         return FilterByNotUsePrepareData(ruleList, out filterInfos);//不使用预处理数据
     else
         return FilterByUsePrepareData(ruleList,out filterInfos,fileName );//使用初始数据
 }
Exemple #8
0
 //保存方案数据
 public static void SaveData(RuleInfo[] ruleList, string fileName)
 {
     List<int> RedBall = new List<int>(33);
     for (int i = 0; i <33 ; i++) RedBall.Add (i +1);
     int[][] Red = new Combination(RedBall.Count , 6).Rows.Select
         (n => Combination.Permute(n, RedBall ).ToArray()).ToArray();
     LotTickData[] res = Red.Select (n=>new LotTickData (n )).ToArray ();
     Dictionary<int, string> filterInfos = new Dictionary<int,string> ();
     LotTickData[] data = FilterByRules(res ,ruleList , out filterInfos);
     //方案保存不涉及最高优先级的杀号,因此可以直接进行过滤操作
     if (!File.Exists(fileName)) throw new Exception("文件不存在");
     NewLife.Serialization.BinaryWriterX binX = new NewLife.Serialization.BinaryWriterX();
     FileStream fs = new FileStream(fileName, FileMode.Create);
     binX.Writer = new BinaryWriter(fs); 
     binX.WriteObject (ruleList,typeof (LotTickData[]),null );
 }
Exemple #9
0
 /// <summary>
 /// 保存方案和数据
 /// </summary>
 /// <param name="ruleList">规则列表</param>
 /// <param name="fileName">保存的文件名称</param>
 /// <param name="isSaveData">是否保存数据,false则只保存规则</param>
 public static void SaveProjectData(RuleInfo[] ruleList,string fileName ,bool isSaveData = false )
 {
     SaveRules(ruleList, fileName);//先保存规则信息
     if (isSaveData)
         SaveData(ruleList, fileName); //保存数据
 }
Exemple #10
0
 public static void SaveRules(RuleInfo[] ruleList, string fileName)
 {
     //保存规则
     if (File.Exists(fileName)) File.Delete(fileName);
     NewLife.Xml.XmlWriterX xml = new NewLife.Xml.XmlWriterX();
     //写入格式控制
     XmlWriterSettings settings = new XmlWriterSettings();
     settings.Indent = true;
     settings.OmitXmlDeclaration = true;
     settings.NewLineOnAttributes = true;
     using (XmlWriter writer = XmlWriter.Create(fileName,settings ))
     {                 
         xml.Writer = writer;
         xml.WriteObject(ruleList, typeof(RuleInfo[]), null);
     }
 }
Exemple #11
0
 /// <summary>
 /// 获取杀号类型规则后形成的列表:适用于不是用预处理直接获取数据的情况
 /// </summary>
 /// <param name="ruleList">杀号规则列表</param>
 public static LotTickData[] GetInitiaDataByNotUserPrepareData(RuleInfo[] ruleList)
 {
     List<int> RedBall = new List<int>(33);
     List<int> BlueBall = new List<int>(16);
     //初始化            
     for (int i = 0; i <33 ; i++) RedBall.Add (i +1);
     for (int i = 0; i <16 ; i++) BlueBall.Add (i +1);
     for (int i = 0; i < ruleList.Length ; i++)
     {
         LotTickData[] curData = new LotTickData[ruleList[i].CalcuteRows + ruleList[i].NeedRows];
         if (ruleList[i].IndexSelector.ToString().Contains("红")) //杀红
             RedBall =RedBall.Except(ruleList[i].IndexSelector.DeleteNumbers(curData)).ToList ();
         else                                                     //杀篮
             BlueBall =BlueBall.Except(ruleList[i].IndexSelector.DeleteNumbers(curData)).ToList ();
     }
     //对红和蓝进行组合、迭代获取所有组合序列,并对每个序列进行判断         
     int[][] Red = new Combination(RedBall.Count , 6).Rows.Select
         (n => Combination.Permute(n, RedBall ).ToArray()).ToArray();
     LotTickData[] res = new LotTickData[Red.GetLength(0) * BlueBall.Count];//总数
     int count = 0;
     for (int i = 0; i < Red.GetLength(0); i++)
     {
         for (int j = 0; j < BlueBall.Count ; j++)
         {
             res[count] = new LotTickData();//红蓝组合
             res[count].NormalData = Red[i];
             res[count++].SpecialData = BlueBall[j];
         }
     }
     return res ;
 }
Exemple #12
0
 public static LotTickData[] DeleteNoProcess(LotTickData[] preData, RuleInfo[] ruleList)
 {
     for (int i = 0; i < ruleList.Length; i++)
     {
         preData = ruleList[i].IndexSelector.GetFilterResult(preData);             
     }
     return preData;
 }
Exemple #13
0
 public static LotTickData[] FilterByUsePrepareData(RuleInfo[] ruleList,
     out Dictionary<int, string> filterInfos, string fileName )
 {
     //先加载初始数据,初始数据只有红球,然后对最高优先级进行处理,然后合并,再进行其他处理
     LotTickData[] firData = ReadData(fileName);
     //TODO:最高优先级处理,并杀号,再组合,并进行其他过滤
     RuleInfo[] First = ruleList.Where(n => tb_IndexInfo.Find(tb_IndexInfo._.IndexName,
         n.IndexSelector.ToString().Replace("LotTick.Index_", "")).PriorLevel == 6).ToArray();
     LotTickData[] secData = FilterByRules(firData, First, out filterInfos);//过滤
     //排序,按照优先级大小进行
     RuleInfo[] LastOrder = ruleList.OrderByDescending(n=>tb_IndexInfo.Find(tb_IndexInfo._.IndexName,
         n.IndexSelector.ToString().Replace("LotTick.Index_", "")).PriorLevel).ToArray();            
     return FilterByRules(firData, LastOrder, out filterInfos);
 }
Exemple #14
0
 public static LotTickData[] FilterByRules(LotTickData[] InitData,RuleInfo[] rules,
     out Dictionary<int, string> filterInfos)
 {
     filterInfos = new Dictionary<int, string>();
     for (int i = 0; i < rules.Length; i++)
     {
         //首先获取计算的数据,直接从data中获取              
         rules[i].IndexSelector.RuleInfoParams = rules[i];
         int firCount = InitData.Length;
         InitData = rules[i].IndexSelector.GetFilterResult(InitData,
             GetNeedDataByCache(rules[i].NeedRows));
         int lastCount = InitData.Length;
         //如何返回过滤信息?用字典,加一个规则编号和结果信息
         filterInfos.Add(rules[i].RuleID, (firCount - lastCount).ToString());
     }
     return InitData;
 }
Exemple #15
0
 public static LotTickData[] FilterByNotUsePrepareData(RuleInfo[] ruleList, out Dictionary<int, string> filterInfos)
 {
     //先获取优先级列表,从指标数据表中获取
     RuleInfo[] First = ruleList.Where(n => tb_IndexInfo.Find(tb_IndexInfo._.IndexName,
         n.IndexSelector.ToString().Replace("LotTick.Index_", "")).PriorLevel == 6).ToArray();
     RuleInfo[] Last = ruleList.Where(n => tb_IndexInfo.Find(tb_IndexInfo._.IndexName,
         n.IndexSelector.ToString().Replace("LotTick.Index_", "")).PriorLevel < 6).ToArray();           
     //先按照优先级进行划分,对最高级进行处理后,分为杀红号和杀蓝号
     LotTickData[] InitData = GetInitiaDataByNotUserPrepareData(First);
     //组合为LotTickData[],再进行其他的过滤,并输出过滤信息,过滤前后的数目
     return FilterByRules(InitData, Last, out filterInfos);
 }