Example #1
0
        public override PredictedResult JudgePredictDataResult(LotteryInfoDto lotteryInfo, PredictDataDto startPeriodData,
                                                               NormConfigDto userNormConfig)
        {
            var planInfo    = _planInfoQueryService.GetPlanInfoById(userNormConfig.PlanId);
            var lotteryData = _lotteryDataQueryService.GetPredictPeriodData(lotteryInfo.Id, startPeriodData.CurrentPredictPeriod);

            if (lotteryData == null)
            {
                return(PredictedResult.Running);
            }
            var lotteryNumber   = new LotteryNumber(lotteryData);
            var lotteryNumCount = lotteryNumber.Datas.Length;
            var lotteryNumbers  = new List <int>();

            foreach (var position in planInfo.PositionInfos)
            {
                var lotteryNumberData = GetLotteryNumberData(lotteryNumber, position.Position, planInfo);
                lotteryNumbers.Add(Convert.ToInt32(lotteryNumberData));
            }

            var predictNumber = startPeriodData.PredictedData.Split(',').Select(p => Convert.ToInt32(p)).ToArray();


            if (userNormConfig.ForecastCount <= lotteryNumCount)
            {
                if (predictNumber.All(p => lotteryNumbers.Contains(p)))
                {
                    return(PredictedResult.Right);
                }
                else if (startPeriodData.CurrentPredictPeriod >= startPeriodData.EndPeriod)
                {
                    return(PredictedResult.Error);
                }
            }
            else
            {
                if (predictNumber.All(p => lotteryNumber.Datas.Contains(p)))
                {
                    return(PredictedResult.Right);
                }
                else if (startPeriodData.CurrentPredictPeriod >= startPeriodData.EndPeriod)
                {
                    return(PredictedResult.Error);
                }
            }
            return(PredictedResult.Running);
        }
Example #2
0
 public override PredictedResult JudgePredictDataResult(LotteryInfoDto lotteryInfo, PredictDataDto startPeriodData,
                                                        NormConfigDto userNormConfig)
 {
     throw new System.NotImplementedException();
 }
Example #3
0
        public override PredictedResult JudgePredictDataResult(LotteryInfoDto lotteryInfo, PredictDataDto startPeriodData,
                                                               NormConfigDto userNormConfig)
        {
            var planInfo    = _planInfoQueryService.GetPlanInfoById(userNormConfig.PlanId);
            var lotteryData = _lotteryDataQueryService.GetPredictPeriodData(lotteryInfo.Id, startPeriodData.CurrentPredictPeriod);

            if (lotteryData == null)
            {
                return(PredictedResult.Running);
            }
            var lotteryNumber = new LotteryNumber(lotteryData);

            var  postion           = planInfo.PositionInfos.First().Position;
            var  lotteryNumberData = GetLotteryNumberData(lotteryNumber, postion, planInfo).ToString();
            bool isRight;
            var  numPredictData = startPeriodData.PredictedData.Split(',').Select(p => p.ToString());

            if (planInfo.DsType == PredictType.Fix)
            {
                isRight = numPredictData.Contains(lotteryNumberData);
            }
            else
            {
                isRight = !numPredictData.Contains(lotteryNumberData);
            }
            if (isRight)
            {
                return(PredictedResult.Right);
            }
            else
            {
                if (startPeriodData.CurrentPredictPeriod >= startPeriodData.EndPeriod)
                {
                    return(PredictedResult.Error);
                }
                return(PredictedResult.Running);
            }
        }
Example #4
0
 public abstract PredictedResult JudgePredictDataResult(LotteryInfoDto lotteryInfo,
                                                        PredictDataDto startPeriodData,
                                                        NormConfigDto userNormConfig);
Example #5
0
        public override PredictedResult JudgePredictDataResult(LotteryInfoDto lotteryInfo, PredictDataDto startPeriodData,
                                                               NormConfigDto userNormConfig)
        {
            var planInfo    = _planInfoQueryService.GetPlanInfoById(userNormConfig.PlanId);
            var lotteryData = _lotteryDataQueryService.GetPredictPeriodData(lotteryInfo.Id, startPeriodData.CurrentPredictPeriod);

            if (lotteryData == null)
            {
                return(PredictedResult.Running);
            }
            var lotteryNumber     = new LotteryNumber(lotteryData);
            var rank              = planInfo.PositionInfos.First().Position;
            var lotteryNumberData = lotteryNumber.GetRankNumber(rank);

            if (startPeriodData.PredictedData.Contains(lotteryNumberData.ToString()))
            {
                if (planInfo.DsType == PredictType.Fix)
                {
                    return(PredictedResult.Right);
                }
            }
            else
            {
                if (planInfo.DsType == PredictType.Kill)
                {
                    return(PredictedResult.Right);
                }
            }
            if (startPeriodData.CurrentPredictPeriod >= startPeriodData.EndPeriod)
            {
                return(PredictedResult.Error);
            }
            return(PredictedResult.Running);
        }
Example #6
0
        public override PredictedResult JudgePredictDataResult(LotteryInfoDto lotteryInfo, PredictDataDto startPeriodData,
                                                               NormConfigDto userNormConfig)
        {
            var planInfo    = _planInfoQueryService.GetPlanInfoById(userNormConfig.PlanId);
            var lotteryData = _lotteryDataQueryService.GetPredictPeriodData(lotteryInfo.Id, startPeriodData.CurrentPredictPeriod);

            if (lotteryData == null)
            {
                return(PredictedResult.Running);
            }
            var lotteryNumber = new LotteryNumber(lotteryData);

            var sum = 0;

            foreach (var position in planInfo.PositionInfos)
            {
                var lotteryNumberData = GetLotteryNumberData(lotteryNumber, position.Position, planInfo);
                sum += Convert.ToInt32(lotteryNumberData);
            }

            var junzhi = (int)(sum / planInfo.PositionInfos.Count);

            bool isRight;
            var  numPredictData = startPeriodData.PredictedData.Split(',').Select(p => Convert.ToInt32(p));

            if (planInfo.DsType == PredictType.Fix)
            {
                isRight = numPredictData.Contains(junzhi);
            }
            else
            {
                isRight = !numPredictData.Contains(junzhi);
            }
            if (isRight)
            {
                return(PredictedResult.Right);
            }
            else
            {
                if (startPeriodData.CurrentPredictPeriod >= startPeriodData.EndPeriod)
                {
                    return(PredictedResult.Error);
                }
                return(PredictedResult.Running);
            }
        }
Example #7
0
        private int GetLastPredictNormPeriod(string lotteryId, NormConfigDto userNorm, string lotteryCode, out PredictDataDto lastPredictData, out bool isNewPredict)
        {
            var normPlanInfo = _planInfoQueryService.GetPlanInfoById(userNorm.PlanId);

            lastPredictData = _lotteryPredictDataQueryService.GetLastPredictData(userNorm.Id, normPlanInfo.PlanNormTable, lotteryCode);
            var lastLotteryData          = _lotteryFinalDataQueryService.GetFinalData(lotteryId);
            var predictCount             = userNorm.PlanCycle * userNorm.LookupPeriodCount;
            var theoryStartPredictPreoid = lastLotteryData.FinalPeriod - predictCount;

            if (lastPredictData != null)
            {
                var userNormPredictPeroid = lastPredictData.StartPeriod + lastPredictData.MinorCycle - 1;
                if (userNormPredictPeroid > theoryStartPredictPreoid)
                {
                    isNewPredict = false;
                    return(userNormPredictPeroid);
                }
            }
            isNewPredict = true;
            return(theoryStartPredictPreoid);
        }
Example #8
0
        //private string GetPredictedDataByRate(IDictionary<int, double> predictedDataRate, PredictType dsType, NormConfigDto userNorm)
        //{
        //    if (dsType == PredictType.Fix)
        //    {
        //        var predictedDataList = predictedDataRate.OrderByDescending(p => p.Value).Select(p => p.Key).ToList();
        //        var result = predictedDataList.Take(userNorm.ForecastCount).ToString(",");
        //        return result;
        //    }
        //    else
        //    {
        //        var predictedDataList = predictedDataRate.OrderBy(p => p.Value).Select(p => p.Key).ToList();
        //        var result = predictedDataList.Take(userNorm.ForecastCount).ToString(",");
        //        return result;
        //    }
        //}

        private PredictedResult JudgePredictDataResult(string lotteryId, PredictDataDto startPeriodData, NormConfigDto userNormConfig)
        {
            var planInfo    = _planInfoQueryService.GetPlanInfoById(userNormConfig.PlanId);
            var lotteryInfo = _lotteryQueryService.GetLotteryInfoById(lotteryId);
            var judgeResult = JudgePredictDataResultFatory.CreateJudgePredictDataResult(planInfo.PredictCode);

            return(judgeResult.JudgePredictDataResult(lotteryInfo, startPeriodData, userNormConfig));

            //var planInfo = _planInfoQueryService.GetPlanInfoById(userNormConfig.PlanId);
            //var lotteryData = _lotteryDataQueryService.GetPredictPeriodData(lotteryId, startPeriodData.CurrentPredictPeriod);
            //if (lotteryData == null)
            //{
            //    return PredictedResult.Running;
            //}
            //var lotteryNumber = new LotteryNumber(lotteryData);
            //var normPlanInfo = _planInfoQueryService.GetPlanInfoById(userNormConfig.PlanId);
            //if (planInfo.PlanPosition == PlanPosition.Single)
            //{
            //    var postion = planInfo.PositionInfos.First().Position;

            //    var lotteryNumberData = GetLotteryNumberData(lotteryNumber, postion, normPlanInfo); //lotteryNumber[postion];
            //    bool isRight;
            //    if (normPlanInfo.PredictCode == PredictCodeDefinition.NumCode)
            //    {
            //        var numPredictData = startPeriodData.PredictedData.Split(',').Select(p => Convert.ToInt32(p));
            //        var numLotteryNum = Convert.ToInt32(lotteryNumberData);
            //        if (normPlanInfo.DsType == PredictType.Fix)
            //        {
            //            isRight = numPredictData.Contains(numLotteryNum);
            //        }
            //        else
            //        {
            //            isRight = !numPredictData.Contains(numLotteryNum);
            //        }
            //    }
            //    else
            //    {
            //        if (normPlanInfo.DsType == PredictType.Fix)
            //        {
            //            isRight = startPeriodData.PredictedData
            //                .Contains(lotteryNumberData.ToString());
            //        }
            //        else
            //        {
            //            isRight = !startPeriodData.PredictedData
            //                .Contains(lotteryNumberData.ToString());
            //        }
            //    }
            //    if (isRight) //:todo bug
            //    {
            //        return PredictedResult.Right;
            //    }
            //    else
            //    {
            //        if (startPeriodData.CurrentPredictPeriod >= startPeriodData.EndPeriod)
            //        {
            //            return PredictedResult.Error;
            //        }
            //        return PredictedResult.Running;
            //    }
            //}
            //else if (planInfo.PlanPosition == PlanPosition.Multiple)
            //{
            //    #region 不定位预测结果判定正错

            //    var positions = planInfo.PositionInfos.Select(p => p.Position).ToArray();
            //    var lotteryNumbers = new List<object>(); // lotteryNumber.GetLotteryNumbers(positions);
            //    foreach (var position in positions)
            //    {
            //        lotteryNumbers.Add(GetLotteryNumberData(lotteryNumber, position, normPlanInfo));
            //    }
            //    if (normPlanInfo.PredictCode == PredictCodeDefinition.NumCode)
            //    {
            //        var predictNumber = startPeriodData.PredictedData.Split(',').Select(p => Convert.ToInt32(p))
            //            .ToArray();
            //        if (planInfo.DsType == PredictType.Fix)
            //        {
            //            if (lotteryNumbers.Any(p => predictNumber.Contains(Convert.ToInt32(p))))
            //            {
            //                return PredictedResult.Right;
            //            }
            //            else if (startPeriodData.CurrentPredictPeriod >= startPeriodData.EndPeriod)
            //            {
            //                return PredictedResult.Error;
            //            }
            //            return PredictedResult.Running;
            //        }
            //        else
            //        {
            //            if (!lotteryNumbers.Any(p => predictNumber.Contains(Convert.ToInt32(p))))
            //            {
            //                return PredictedResult.Right;
            //            }
            //            else if (startPeriodData.CurrentPredictPeriod >= startPeriodData.EndPeriod)
            //            {
            //                return PredictedResult.Error;
            //            }
            //            return PredictedResult.Running;
            //        }
            //    }
            //    else
            //    {
            //        var predictNumber = startPeriodData.PredictedData.Split(',').Select(p => p)
            //            .ToArray();
            //        if (planInfo.DsType == PredictType.Fix)
            //        {
            //            if (lotteryNumbers.Any(p => predictNumber.Contains(p)))
            //            {
            //                return PredictedResult.Right;
            //            }
            //            else if (startPeriodData.CurrentPredictPeriod >= startPeriodData.EndPeriod)
            //            {
            //                return PredictedResult.Error;
            //            }
            //            return PredictedResult.Running;
            //        }
            //        else
            //        {
            //            if (!lotteryNumbers.Any(p => predictNumber.Contains(p)))
            //            {
            //                return PredictedResult.Right;
            //            }
            //            else if (startPeriodData.CurrentPredictPeriod >= startPeriodData.EndPeriod)
            //            {
            //                return PredictedResult.Error;
            //            }
            //            return PredictedResult.Running;
            //        }
            //    }

            //    #endregion 不定位预测结果判定正错
            //}
            //else
            //{
            //    var rank = planInfo.PositionInfos.First().Position;
            //    var lotteryNumberData = lotteryNumber.GetRankNumber(rank);
            //    if (startPeriodData.PredictedData.Contains(lotteryNumberData.ToString()))
            //    {
            //        if (planInfo.DsType == PredictType.Fix)
            //        {
            //            return PredictedResult.Right;
            //        }
            //        else if (startPeriodData.CurrentPredictPeriod >= startPeriodData.EndPeriod)
            //        {
            //            return PredictedResult.Error;
            //        }
            //        return PredictedResult.Running;
            //    }
            //    else
            //    {
            //        if (planInfo.DsType == PredictType.Kill)
            //        {
            //            return PredictedResult.Right;
            //        }
            //        else if (startPeriodData.CurrentPredictPeriod >= startPeriodData.EndPeriod)
            //        {
            //            return PredictedResult.Error;
            //        }
            //        return PredictedResult.Running;
            //    }
            //}
        }
Example #9
0
        private PredictDataDto PredictAppointedPeroidNormData(string lotteryId, int predictPeriod, NormConfigDto userNorm, bool isSwitchFormula = false)
        {
            var lotteryCount = GetHistoryLotteryCount(userNorm);

            var predictLotteryData = _lotteryDataQueryService.GetPredictPeriodDatas(lotteryId, predictPeriod - 1, lotteryCount);

            var lotteryDataList = new LotteryDataList(predictLotteryData);
            var lotteryEngine   = EngineContext.LotterEngine(lotteryId);
            var normPlanInfo    = _planInfoQueryService.GetPlanInfoById(userNorm.PlanId);

            var predictData = GetPredictData(normPlanInfo, lotteryDataList);

            var    positionInfo  = normPlanInfo.PositionInfos.First();
            var    count         = positionInfo.MaxValue - positionInfo.MinValue + 1;
            string predictedData = String.Empty;
            IDictionary <int, double> predictedDataRate;

            try
            {
                AlgorithmType algorithmType = normPlanInfo.AlgorithmType;
                if (isSwitchFormula)
                {
                    algorithmType = AlgorithmType.Mock;
                }

                try
                {
                    predictedDataRate = lotteryEngine.GetPerdictor(algorithmType)
                                        .Predictor(predictData, count, userNorm.UnitHistoryCount, userNorm.HistoryCount, new Tuple <int, int>(positionInfo.MinValue, positionInfo.MaxValue));
                }
                catch (Exception e)
                {
                    try
                    {
                        algorithmType     = AlgorithmType.Temperature;
                        predictedDataRate = lotteryEngine.GetPerdictor(algorithmType)
                                            .Predictor(predictData, count, userNorm.UnitHistoryCount, userNorm.HistoryCount, new Tuple <int, int>(positionInfo.MinValue, positionInfo.MaxValue));
                    }
                    catch (Exception e2)
                    {
                        algorithmType     = AlgorithmType.Mock;
                        predictedDataRate = lotteryEngine.GetPerdictor(algorithmType)
                                            .Predictor(predictData, count, userNorm.UnitHistoryCount, userNorm.HistoryCount, new Tuple <int, int>(positionInfo.MinValue, positionInfo.MaxValue));
                    }
                }

                var computePredictResult = ComputePredictFatory.CreateComputePredictResult(normPlanInfo.PredictCode, predictedDataRate);

                predictedData = computePredictResult.GetPredictedData(normPlanInfo, userNorm);
                //predictedDataRate != null ?
                //GetPredictedDataByRate(predictedDataRate, normPlanInfo.DsType, userNorm)
                //: GetPredictedDataMock(normPlanInfo, userNorm);
            }
            catch (Exception ex)
            {
                _logger.Error(ex);
                predictedData = GetPredictedDataMock(normPlanInfo, userNorm);
            }
            var predictDataInfo = new PredictDataDto()
            {
                NormConfigId         = userNorm.Id,
                CurrentPredictPeriod = predictPeriod,
                StartPeriod          = predictPeriod,
                EndPeriod            = predictPeriod + userNorm.PlanCycle - 1,
                MinorCycle           = 1,
                PredictedData        = predictedData,
                PredictedResult      = (int)PredictedResult.Running,
                PredictType          = normPlanInfo.DsType,
            };

            return(predictDataInfo);
        }
Example #10
0
        private bool NeedNewPredictData(int period, int startPredict, string lotteryId, NormConfigDto userNormConfig, ref Dictionary <int, PredictDataDto> predictDataResults, string lotteryCode)
        {
            var            normPlanInfo    = _planInfoQueryService.GetPlanInfoById(userNormConfig.PlanId);
            PredictDataDto startPeriodData = null;

            if (!predictDataResults.Safe().Any())
            {
                startPeriodData = _lotteryPredictDataQueryService.GetPredictDataByStartPeriod(startPredict, userNormConfig.Id, normPlanInfo.PlanNormTable, lotteryCode);
                if (startPeriodData == null)
                {
                    return(true);
                }

                var predictedResult = JudgePredictDataResult(lotteryId, startPeriodData, userNormConfig);

                if (predictedResult == PredictedResult.Right)
                {
                    startPeriodData.EndPeriod       = period;
                    startPeriodData.PredictedResult = (int)PredictedResult.Right;
                    predictDataResults.Add(startPredict, startPeriodData);
                    return(true);
                }
                else if (predictedResult == PredictedResult.Error)
                {
                    startPeriodData.EndPeriod       = period;
                    startPeriodData.PredictedResult = (int)PredictedResult.Error;
                    predictDataResults.Add(startPredict, startPeriodData);
                    return(true);
                }
                else
                {
                    startPeriodData.CurrentPredictPeriod += 1;
                    startPeriodData.MinorCycle            = startPeriodData.MinorCycle + 1;
                    startPeriodData.PredictedResult       = (int)PredictedResult.Running;
                    predictDataResults.Add(startPredict, startPeriodData);
                    return(false);
                }
            }
            else
            {
                startPeriodData = predictDataResults[startPredict];
                var predictedResult = JudgePredictDataResult(lotteryId, startPeriodData, userNormConfig);
                if (predictedResult == PredictedResult.Right)
                {
                    startPeriodData.EndPeriod       = period;
                    startPeriodData.PredictedResult = (int)PredictedResult.Right;

                    return(true);
                }
                else if (predictedResult == PredictedResult.Error)
                {
                    startPeriodData.EndPeriod       = period;
                    startPeriodData.PredictedResult = (int)PredictedResult.Error;

                    return(true);
                }
                else
                {
                    startPeriodData.MinorCycle            = startPeriodData.MinorCycle + 1;
                    startPeriodData.CurrentPredictPeriod += 1;
                    startPeriodData.PredictedResult       = (int)PredictedResult.Running;

                    return(false);
                }
            }
        }