示例#1
0
        private bool IsMovedBetter(T movedSol, T solBeforeMove, Criterion <T> criterion)
        {
            if (criterion.IsFirstOneBetter(movedSol, solBeforeMove))
            {
                return(true);
            }

            double movedSolValue, unmovedSolValue;

            if (movedSol.IsFeasible)
            {
                movedSolValue   = criterion.CalculateSolutionValue(movedSol);
                unmovedSolValue = criterion.CalculateSolutionValue(solBeforeMove);
            }
            else
            {
                movedSolValue   = movedSol.CalculatedPenalty;
                unmovedSolValue = solBeforeMove.CalculatedPenalty;
            }

            var diff =
                criterion.OptimizationType == OptimizationType.Minimization
                    ? unmovedSolValue - movedSolValue
                    : movedSolValue - unmovedSolValue;

            if (diff == 0)
            {
                return(false);
            }

            return(diff > 0 || AtEndOfIsMovedBetter(diff));
        }
示例#2
0
        private void IsFirstOneBetter_FirstShouldBeBetter_BetterValue_BothFeasible()
        {
            var first = new Mock <Solution>();

            first.CallBase = true;
            first.SetupProperty(s => s.CalculatedValue, 0);
            first.SetupProperty(s => s.CalculatedPenalty, 0);
            first.SetupProperty(s => s.PenaltyWasCalculated, true);
            first.SetupProperty(s => s.ValueWasCalculated, true);
            first.SetupProperty(s => s.IsFeasible, true);

            var second = new Mock <Solution>();

            second.CallBase = true;
            second.SetupProperty(s => s.CalculatedValue, 10);
            second.SetupProperty(s => s.CalculatedPenalty, 0);
            second.SetupProperty(s => s.PenaltyWasCalculated, true);
            second.SetupProperty(s => s.ValueWasCalculated, true);
            second.SetupProperty(s => s.IsFeasible, true);

            var result = _criterion.IsFirstOneBetter(first.Object, second.Object);

            Assert.True(result);
        }
示例#3
0
        public override T Solve(T solution, Criterion <T> criterion)
        {
            ResetToInitialState();

            var iter = 0;

            solution.Reset();
            _saver?.Open();

            criterion.InitialEvaluation(solution);

            var bestSol       = (T)solution.Clone();
            var solBeforeMove = (T)solution.Clone();

            while (!StopCriteria.ShouldStop(solution))
            {
                solution.Copy(solBeforeMove);
                Mover.MoveSolution(solution);

                criterion.CalculateSolutionPenalty(solution);

                if (IsMovedBetter(solution, solBeforeMove, criterion))
                {
                    if (criterion.IsFirstOneBetter(solution, bestSol))
                    {
                        solution.Copy(bestSol);
                    }
                }
                else
                {
                    solBeforeMove.Copy(solution);
                }

                AtEndOfIteration(iter);
                _saver?.AppendToFile(bestSol);
                iter++;
            }

            Logger.LogInformation($"Finished in: '{iter}' iterations");
            _saver?.Close();

            if (!bestSol.IsFeasible)
            {
                throw new Exception("No feasible solution was found");
            }
            solution = bestSol;
            return(solution);
        }