Example #1
0
        public void Test_1()
        {
            Prepare();

            var trace = TraceBuilder.CalculateTrace(model);

            Assert.AreEqual(0, trace.Points[1].X);
            Assert.AreEqual(1, trace.Points[1].Y);

            Assert.AreEqual(0, trace.Points[2].X);
            Assert.AreEqual(2, trace.Points[2].Y);
        }
Example #2
0
        private static void AddSide(Model _answer, int turn,
                                    List <Block> blocks, List <RouteSide> sides,
                                    ref int i, out TraceBuilder.Result trace, ref int startI)
        {
            var firstTurn = GetTurnElements(blocks);

            _answer.Order.AddRange(firstTurn);

            for (int j = 0; j < firstTurn.Count; j++)
            {
                _answer.Topology.Add(new TopologyItem(i, i + 1, turn));
                i++;
            }

            trace = TraceBuilder.CalculateTrace(_answer);
            sides.Add(new RouteSide(trace.Points[startI], startI, 4, turn, firstTurn.Count));

            for (int j = 0; j < firstTurn.Count; j++)
            {
                sides[sides.Count - 1].details.Add(trace.Points[startI]);
                startI++;
            }
        }
Example #3
0
        public void Start()
        {
            Iteration = 0;

            while (true)
            {
                if (Token.IsCancellationRequested)
                {
                    var model = Model.Copy(Best.Model);
                    model.Blocks.Clear();
                    model.Blocks.AddRange(_model.Blocks);

                    OnStepEvent?.Invoke(this, new FinalAnswer(model, _checker.Solve(model)));

                    throw new OperationCanceledException("Работа алгоритма остановлена в связи с отменой задачи");
                }

                if (Bots.Count(_ => !_.IsDead) == 0)
                {
                    NextGeneration();

                    continue;
                }

                for (var i = 0; i < Bots.Count; i++)
                {
                    var bot = Bots[i];

                    if (bot.IsDead)
                    {
                        continue;
                    }

                    ExecuteCommand(bot);

                    bot.Cur++;

                    var answer = bot.Root.ConvertToModel(bot.Current.Model);
                    var price  = _checker.Solve(answer);
                    var trace  = TraceBuilder.CalculateTrace(answer);

                    if (trace.Exceptions.Any() ||
                        price.Result < -1000) // TODO: const MIN_PRICE
                    {
                        bot.IsDead = true;
                    }

                    if (Math.Abs(price.Result - bot.Current.Price.Result) < Constants.Precision)
                    {
                        bot.DeadLoops++;

                        if (bot.DeadLoops > 100)
                        {
                            bot.IsDead = true;
                        }
                    }
                    else
                    {
                        bot.DeadLoops = 0;
                    }

                    bot.Current = new FinalAnswer(answer, price);

                    //OnStepEvent?.Invoke(this, bot.Current);

                    if (price > bot.Best.Price)
                    {
                        bot.Best = bot.Current;

                        if (price > Best.Price)
                        {
                            Best = bot.Best;
                            OnStepEvent?.Invoke(this, Best);
                        }
                    }
                }

                OnStepEvent?.Invoke(this, Best);

                Iteration++;
            }
        }