/// <summary>
        /// Обработка новой точки
        /// </summary>
        /// <param name="point"></param>
        /// <returns></returns>
        private void AddNewPoint(PointInfo point, int seriesId)
        {
            using (var _context = new DissertationDbContext())
            {
                // увеличиваем общее количество обработанных точек
                _countPoints++;

                if (!point.F*x.HasValue)
                {//вычисляем функцию принадлежности и меру энтропии по функции принадлежности
                    point = ModelCalculator.CalcFUX(point, seriesId);
                    if (point == null)
                    {
                        throw new Exception("AddNewPoint: Не удалось получить функцию принадлежности");
                    }
                    point.EntropuUX = ModelCalculator.CalcEntropyByUX(point.F*x.Value);
                }

                if (_points.Count > 0)
                {//если уже есть точки, получить тенденцию
                    var labelFromId = _points[_points.Count - 1].FuzzyLabelId;
                    var rule        = _context.RuleTrends.SingleOrDefault(r =>
                                                                          r.FuzzyLabelFromId == labelFromId &&
                                                                          r.FuzzyLabelToId == point.FuzzyLabelId &&
                                                                          r.SeriesDiscriptionId == point.SeriesDiscriptionId);
                    if (rule == null)
                    {
                        throw new Exception(string.Format("AddNewPoint: Нет правила для такого сочитания нечетких меток: {0} и {1}",
                                                          _points[_points.Count - 1].FuzzyLabel.FuzzyLabelName,
                                                          point.FuzzyLabel.FuzzyLabelName));
                    }
                    point.FuzzyTrendId = rule.FuzzyTrendId;
                    point.FuzzyTrend   = _context.FuzzyTrends.Single(ft => ft.Id == rule.FuzzyTrendId);

                    if (_points.Count > 2)
                    {
                        point.EntropyFT = ModelCalculator.CalcEntropyByFT(point.FuzzyTrend.TrendName,
                                                                          _points[_points.Count - 1].FuzzyTrend.TrendName,
                                                                          _points[_points.Count - 2].FuzzyTrend.TrendName,
                                                                          point.SeriesDiscriptionId, out int pointNext);
                    }

                    if (_points.Count > 1)
                    {//получить состояния
                        var stateFuzzy = GetStateFuzzy(point);
                        if (stateFuzzy == null)
                        {
                            throw new Exception("AddNewPoint: Не определили номер ситуации по нечеткости");
                        }
                        point.StatisticsByFuzzyId = stateFuzzy.Id;
                        point.StatisticsByFuzzy   = stateFuzzy;
                        if (_points.Count > 4)
                        {
                            var stateEntropy = GetStateEntropy(point);
                            if (stateEntropy == null)
                            {
                                throw new Exception("AddNewPoint: Не определили номер ситуации по энтропии");
                            }
                            point.StatisticsByEntropyId = stateEntropy.Id;
                            point.StatisticsByEntropy   = stateEntropy;
                        }
                    }
                }
                if (_points.Count == _countPointsForMemmory)
                {//Храним не более _countPointsForMemmory точек
                    _points.RemoveAt(0);
                }
                _points.Add(point);//занести точку;
            }
        }
        /// <summary>
        /// Обработка новой точки
        /// </summary>
        /// <param name="point"></param>
        /// <param name="seriesId"></param>
        /// <returns></returns>
        private static bool AddNewPoint(PointInfo point, int seriesId)
        {
            using (var _context = new DissertationDbContext())
            {
                try
                {
                    if (_points.Count > 0)
                    {//если уже есть точки, получить тенденцию
                        point = ModelCalculator.CalcFUX(point, seriesId);
                        var fuzzyLabelId = _points[_points.Count - 1].FuzzyLabelId;
                        var rule         = _context.RuleTrends.SingleOrDefault(r => r.FuzzyLabelFromId == fuzzyLabelId && r.FuzzyLabelToId == point.FuzzyLabelId);
                        if (rule == null)
                        {
                            throw new Exception(string.Format("Нет правила для такого сочитания нечетких меток: {0} и {1}",
                                                              _points[_points.Count - 1].FuzzyLabel.FuzzyLabelName, point.FuzzyLabel.FuzzyLabelName));
                        }
                        point.FuzzyTrendId = rule.FuzzyTrendId;
                        point.FuzzyTrend   = _context.FuzzyTrends.Single(ft => ft.Id == rule.FuzzyTrendId);

                        if (_points.Count > 2)
                        {//если есть возможность, получить энтропию по тенденции
                            var xNow = Converter.ToFuzzyTrendLabelWeight(point.FuzzyTrend.TrendName);
                            if (xNow == Converter.TrendWeightNotFound)
                            {
                                throw new Exception(string.Format("Не найден вес для тенденции {0}", point.FuzzyTrend.TrendName));
                            }
                            var xLast = Converter.ToFuzzyTrendLabelWeight(_points[_points.Count - 1].FuzzyTrend.TrendName);
                            if (xLast == Converter.TrendWeightNotFound)
                            {
                                throw new Exception(string.Format("Не найден вес для тенденции {0}", _points[_points.Count - 1].FuzzyTrend.TrendName));
                            }
                            var xLastLast = Converter.ToFuzzyTrendLabelWeight(_points[_points.Count - 2].FuzzyTrend.TrendName);
                            if (xLastLast == Converter.TrendWeightNotFound)
                            {
                                throw new Exception(string.Format("Не найден вес для тенденции {0}", _points[_points.Count - 2].FuzzyTrend.TrendName));
                            }
                            // скорость преращения тенденции в предыдущей точке
                            var speedTrendLast = xLastLast - xLast;
                            // скорость преращения тенденции в ткущей точке
                            var speedTrend  = xLast - xNow;
                            int beforePoint = ModelCalculator.CalcPointOnPhasePlane(_points[_points.Count - 1].FuzzyTrend.TrendName, speedTrendLast);
                            int nextPoint   = ModelCalculator.CalcPointOnPhasePlane(point.FuzzyTrend.TrendName, speedTrend);
                            var pointTrend  = _context.PointTrends.FirstOrDefault(p => p.StartPoint == beforePoint && p.FinishPoint == nextPoint && p.SeriesDiscriptionId == seriesId);
                            if (pointTrend == null)
                            {
                                pointTrend = new PointTrend
                                {
                                    StartPoint          = beforePoint,
                                    FinishPoint         = nextPoint,
                                    Count               = 1,
                                    Weight              = 0,
                                    SeriesDiscriptionId = seriesId,
                                    Trends              = point.FuzzyTrend.TrendName.ToString()
                                };
                                _context.PointTrends.Add(pointTrend);
                            }
                            else
                            {
                                if (!pointTrend.Trends.Contains(point.FuzzyTrend.TrendName.ToString()))
                                {
                                    pointTrend.Trends += string.Format(", {0}", point.FuzzyTrend.TrendName);
                                }
                                pointTrend.Count++;
                            }
                            _context.SaveChanges();
                        }
                    }
                    else
                    {
                        point = ModelCalculator.CalcFUX(point, seriesId);
                    }
                    if (_points.Count == 5)
                    {
                        _points.RemoveAt(0);
                    }
                    _points.Add(point);//занести точку

                    return(true);
                }
                catch (Exception)
                {
                    throw;
                }
            }
        }