public override IOperation Apply()
        {
            var    permutation = PermutationParameter.ActualValue;
            double relativeQualityDifference = 0;
            var    distanceMatrix            = DistanceMatrixParameter.ActualValue;

            if (distanceMatrix == null)
            {
                throw new InvalidOperationException("The distance matrix is not given.");
            }
            var move = InversionMoveParameter.ActualValue;

            relativeQualityDifference = TSPInversionMovePathEvaluator.EvaluateByDistanceMatrix(permutation, move, distanceMatrix);

            var moveQuality = MoveQualityParameter.ActualValue;

            if (moveQuality == null)
            {
                MoveQualityParameter.ActualValue = new DoubleValue(QualityParameter.ActualValue.Value + relativeQualityDifference);
            }
            else
            {
                moveQuality.Value = QualityParameter.ActualValue.Value + relativeQualityDifference;
            }
            return(base.Apply());
        }
Example #2
0
        public override IOperation Apply()
        {
            var solution = CurrentScope.Variables[SolutionParameter.ActualName].Value as Permutation;

            if (solution == null)
            {
                throw new ArgumentException("Cannot improve solution because it has the wrong type.");
            }
            if (solution.PermutationType != PermutationTypes.RelativeUndirected)
            {
                throw new ArgumentException("Cannot improve solution because the permutation type is not supported.");
            }

            for (int i = 0; i < ImprovementAttempts.Value; i++)
            {
                var    move        = StochasticInversionSingleMoveGenerator.Apply(solution, Random);
                double moveQualtiy = TSPInversionMovePathEvaluator.EvaluateByDistanceMatrix(solution, move, DistanceMatrix);
                if (moveQualtiy < 0)
                {
                    InversionManipulator.Apply(solution, move.Index1, move.Index2);
                }
            }

            CurrentScope.Variables.Add(new Variable("LocalEvaluatedSolutions", ImprovementAttempts));

            return(base.Apply());
        }
 public static double EvaluateByCoordinates(Permutation permutation, InversionMove move, DoubleMatrix coordinates, TSPInversionMovePathEvaluator evaluator) {
   int edge1source = permutation.GetCircular(move.Index1 - 1);
   int edge1target = permutation[move.Index1];
   int edge2source = permutation[move.Index2];
   int edge2target = permutation.GetCircular(move.Index2 + 1);
   if (move.Index2 - move.Index1 >= permutation.Length - 2) return 0;
   double moveQuality = 0;
   // remove two edges
   moveQuality -= evaluator.CalculateDistance(coordinates[edge1source, 0], coordinates[edge1source, 1],
         coordinates[edge1target, 0], coordinates[edge1target, 1]);
   moveQuality -= evaluator.CalculateDistance(coordinates[edge2source, 0], coordinates[edge2source, 1],
     coordinates[edge2target, 0], coordinates[edge2target, 1]);
   // add two edges
   moveQuality += evaluator.CalculateDistance(coordinates[edge1source, 0], coordinates[edge1source, 1],
     coordinates[edge2source, 0], coordinates[edge2source, 1]);
   moveQuality += evaluator.CalculateDistance(coordinates[edge1target, 0], coordinates[edge1target, 1],
     coordinates[edge2target, 0], coordinates[edge2target, 1]);
   return moveQuality;
 }
 protected TSPInversionMovePathEvaluator(TSPInversionMovePathEvaluator original, Cloner cloner) : base(original, cloner) { }
Example #5
0
        public static double EvaluateByCoordinates(Permutation permutation, InversionMove move, DoubleMatrix coordinates, TSPInversionMovePathEvaluator evaluator)
        {
            int edge1source = permutation.GetCircular(move.Index1 - 1);
            int edge1target = permutation[move.Index1];
            int edge2source = permutation[move.Index2];
            int edge2target = permutation.GetCircular(move.Index2 + 1);

            if (move.Index2 - move.Index1 >= permutation.Length - 2)
            {
                return(0);
            }
            double moveQuality = 0;

            // remove two edges
            moveQuality -= evaluator.CalculateDistance(coordinates[edge1source, 0], coordinates[edge1source, 1],
                                                       coordinates[edge1target, 0], coordinates[edge1target, 1]);
            moveQuality -= evaluator.CalculateDistance(coordinates[edge2source, 0], coordinates[edge2source, 1],
                                                       coordinates[edge2target, 0], coordinates[edge2target, 1]);
            // add two edges
            moveQuality += evaluator.CalculateDistance(coordinates[edge1source, 0], coordinates[edge1source, 1],
                                                       coordinates[edge2source, 0], coordinates[edge2source, 1]);
            moveQuality += evaluator.CalculateDistance(coordinates[edge1target, 0], coordinates[edge1target, 1],
                                                       coordinates[edge2target, 0], coordinates[edge2target, 1]);
            return(moveQuality);
        }
Example #6
0
 protected TSPInversionMovePathEvaluator(TSPInversionMovePathEvaluator original, Cloner cloner) : base(original, cloner)
 {
 }