Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
12/15/15 16:38:08 (9 years ago)
Author:
abeham
Message:

#2221:

  • implemented review comments
    • hid rng as private class, implemented djb2 hash function (hash function implementation may also change)
    • added missing probabilities
    • base class for instance providers
    • prebuild event events
    • build platforms
    • unit test will be removed on trunk integration
    • corrected assembly file version
    • distance calculator parameter was not hidden, can be changed by user, updates distance matrix
    • fixed performance problems (ouch!) also for estimated ptsp (inlined GetDistance method)
  • added moves (full evaluation) for analytical tsp
  • added local improvement operators for analytical ptsp
  • added recalculation of distance matrix when parameters change
  • still lots of other changes
Location:
branches/PTSP/HeuristicLab.Problems.PTSP/3.3/Moves
Files:
4 edited
4 copied
1 moved

Legend:

Unmodified
Added
Removed

  • branches/PTSP/HeuristicLab.Problems.PTSP/3.3/Moves/AnalyticalPTSPMoveEvaluator.cs

    r13451 r13470  
    3030
    3131namespace HeuristicLab.Problems.PTSP {
    32   [Item("EstimatedPTSPMoveEvaluator", "A base class for operators which evaluate TSP moves.")]
     32  [Item("AnalyticalPTSPMoveEvaluator", "A base class for operators which evaluate PTSP moves.")]
    3333  [StorableClass]
    34   public abstract class EstimatedPTSPMoveEvaluator : SingleSuccessorOperator, IEstimatedPTSPMoveEvaluator {
     34  public abstract class AnalyticalPTSPMoveEvaluator : SingleSuccessorOperator, IAnalyticalPTSPMoveEvaluator {
    3535
    3636    public override bool CanChangeName {
    … …  
    5050      get { return (ILookupParameter<BoolValue>)Parameters["UseDistanceMatrix"]; }
    5151    }
    52     public ILookupParameter<ItemList<BoolArray>> RealizationsParameter {
    53       get { return (ILookupParameter<ItemList<BoolArray>>)Parameters["Realizations"]; }
     52    public ILookupParameter<DoubleArray> ProbabilitiesParameter {
     53      get { return (ILookupParameter<DoubleArray>)Parameters["Probabilities"]; }
    5454    }
    5555    public ILookupParameter<DoubleValue> QualityParameter {
    … …  
    6464
    6565    [StorableConstructor]
    66     protected EstimatedPTSPMoveEvaluator(bool deserializing) : base(deserializing) { }
    67     protected EstimatedPTSPMoveEvaluator(EstimatedPTSPMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
    68     protected EstimatedPTSPMoveEvaluator()
     66    protected AnalyticalPTSPMoveEvaluator(bool deserializing) : base(deserializing) { }
     67    protected AnalyticalPTSPMoveEvaluator(AnalyticalPTSPMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
     68    protected AnalyticalPTSPMoveEvaluator()
    6969      : base() {
    7070      Parameters.Add(new LookupParameter<Permutation>("Permutation", "The solution as permutation."));
    … …  
    7272      Parameters.Add(new LookupParameter<DistanceMatrix>("DistanceMatrix", "The matrix which contains the distances between the cities."));
    7373      Parameters.Add(new LookupParameter<BoolValue>("UseDistanceMatrix", "True if a distance matrix should be calculated (if it does not exist already) and used for evaluation, otherwise false."));
    74       Parameters.Add(new LookupParameter<ItemList<BoolArray>>("Realizations", "The list of samples drawn from all possible stochastic instances."));
     74      Parameters.Add(new LookupParameter<DoubleArray>("Probabilities", "The list of probabilities for each city to appear."));
    7575      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of a TSP solution."));
    7676      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The evaluated quality of a move on a TSP solution."));
    … …  
    8181      var permutation = PermutationParameter.ActualValue;
    8282      var coordinates = CoordinatesParameter.ActualValue;
    83       double relativeQualityDifference = 0;
     83      var probabilities = ProbabilitiesParameter.ActualValue;
     84      Func<int, int, double> distance = null;
    8485      if (UseDistanceMatrixParameter.ActualValue.Value) {
    8586        var distanceMatrix = DistanceMatrixParameter.ActualValue;
    8687        if (distanceMatrix == null) throw new InvalidOperationException("The distance matrix has not been calculated.");
    87         relativeQualityDifference = EvaluateByDistanceMatrix(permutation, distanceMatrix);
     88        distance = (a, b) => distanceMatrix[a, b];
    8889      } else {
    8990        if (coordinates == null) throw new InvalidOperationException("No coordinates were given.");
    9091        var distanceCalculator = DistanceCalculatorParameter.ActualValue;
    9192        if (distanceCalculator == null) throw new InvalidOperationException("Distance calculator is null!");
    92         relativeQualityDifference = EvaluateByCoordinates(permutation, coordinates, distanceCalculator);
     93        distance = (a, b) => distanceCalculator.Calculate(a, b, coordinates);
    9394      }
     95      // here moves are not delta-evaluated
     96      var newQuality = EvaluateMove(permutation, distance, probabilities);
    9497      var moveQuality = MoveQualityParameter.ActualValue;
    95       if (moveQuality == null) MoveQualityParameter.ActualValue = new DoubleValue(QualityParameter.ActualValue.Value + relativeQualityDifference);
    96       else moveQuality.Value = QualityParameter.ActualValue.Value + relativeQualityDifference;
     98      if (moveQuality == null) MoveQualityParameter.ActualValue = new DoubleValue(newQuality);
     99      else moveQuality.Value = newQuality;
     100
    97101      return base.Apply();
    98102    }
    99103
    100     protected abstract double EvaluateByDistanceMatrix(Permutation permutation, DistanceMatrix distanceMatrix);
    101     protected abstract double EvaluateByCoordinates(Permutation permutation, DoubleMatrix coordinates, DistanceCalculator distanceCalculator);
     104    protected abstract double EvaluateMove(Permutation permutation, Func<int, int, double> distance, DoubleArray probabilities);
    102105  }
    103106}

  • branches/PTSP/HeuristicLab.Problems.PTSP/3.3/Moves/EstimatedPTSPMoveEvaluator.cs

    r13412 r13470  
    3030
    3131namespace HeuristicLab.Problems.PTSP {
    32   [Item("EstimatedPTSPMoveEvaluator", "A base class for operators which evaluate TSP moves.")]
     32  [Item("EstimatedPTSPMoveEvaluator", "A base class for operators which evaluate PTSP moves.")]
    3333  [StorableClass]
    3434  public abstract class EstimatedPTSPMoveEvaluator : SingleSuccessorOperator, IEstimatedPTSPMoveEvaluator {
    … …  
    8181      var permutation = PermutationParameter.ActualValue;
    8282      var coordinates = CoordinatesParameter.ActualValue;
    83       double relativeQualityDifference = 0;
     83      var realizations = RealizationsParameter.ActualValue;
     84      Func<int, int, double> distance = null;
    8485      if (UseDistanceMatrixParameter.ActualValue.Value) {
    8586        var distanceMatrix = DistanceMatrixParameter.ActualValue;
    8687        if (distanceMatrix == null) throw new InvalidOperationException("The distance matrix has not been calculated.");
    87         relativeQualityDifference = EvaluateByDistanceMatrix(permutation, distanceMatrix);
     88        distance = (a, b) => distanceMatrix[a, b];
    8889      } else {
    8990        if (coordinates == null) throw new InvalidOperationException("No coordinates were given.");
    9091        var distanceCalculator = DistanceCalculatorParameter.ActualValue;
    9192        if (distanceCalculator == null) throw new InvalidOperationException("Distance calculator is null!");
    92         relativeQualityDifference = EvaluateByCoordinates(permutation, coordinates, distanceCalculator);
     93        distance = (a, b) => distanceCalculator.Calculate(a, b, coordinates);
    9394      }
     95      var relativeQualityDifference = EvaluateMove(permutation, distance, realizations);
    9496      var moveQuality = MoveQualityParameter.ActualValue;
    9597      if (moveQuality == null) MoveQualityParameter.ActualValue = new DoubleValue(QualityParameter.ActualValue.Value + relativeQualityDifference);
    … …  
    98100    }
    99101
    100     protected abstract double EvaluateByDistanceMatrix(Permutation permutation, DistanceMatrix distanceMatrix);
    101     protected abstract double EvaluateByCoordinates(Permutation permutation, DoubleMatrix coordinates, DistanceCalculator distanceCalculator);
     102    protected abstract double EvaluateMove(Permutation permutation, Func<int, int, double> distance, ItemList<BoolArray> realizations);
    102103  }
    103104}

  • branches/PTSP/HeuristicLab.Problems.PTSP/3.3/Moves/OneShift/PTSPAnalyticalInsertionMoveEvaluator.cs

    r13451 r13470  
    2929
    3030namespace HeuristicLab.Problems.PTSP {
    31   [Item("PTSPEstimatedInsertionMoveEvaluator", "Evaluates an insertion move (1-shift)")]
     31  [Item("PTSP Analytical Insertion Move Evaluator", "Evaluates an insertion move (1-shift) by a full solution evaluation")]
    3232  [StorableClass]
    33   public class PTSPEstimatedInsertionMoveEvaluator : EstimatedPTSPMoveEvaluator, IPermutationTranslocationMoveOperator {
     33  public class PTSPAnalyticalInsertionMoveEvaluator : AnalyticalPTSPMoveEvaluator, IPermutationTranslocationMoveOperator {
    3434
    3535    public ILookupParameter<TranslocationMove> TranslocationMoveParameter {
    … …  
    3838
    3939    [StorableConstructor]
    40     protected PTSPEstimatedInsertionMoveEvaluator(bool deserializing) : base(deserializing) { }
    41     protected PTSPEstimatedInsertionMoveEvaluator(PTSPEstimatedInsertionMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
    42     public PTSPEstimatedInsertionMoveEvaluator()
     40    protected PTSPAnalyticalInsertionMoveEvaluator(bool deserializing) : base(deserializing) { }
     41    protected PTSPAnalyticalInsertionMoveEvaluator(PTSPAnalyticalInsertionMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
     42    public PTSPAnalyticalInsertionMoveEvaluator()
    4343      : base() {
    4444      Parameters.Add(new LookupParameter<TranslocationMove>("TranslocationMove", "The move to evaluate."));
    … …  
    4646
    4747    public override IDeepCloneable Clone(Cloner cloner) {
    48       return new PTSPEstimatedInsertionMoveEvaluator(this, cloner);
     48      return new PTSPAnalyticalInsertionMoveEvaluator(this, cloner);
    4949    }
    5050
    51     public static double EvaluateByCoordinates(Permutation permutation, TranslocationMove move, DoubleMatrix coordinates, DistanceCalculator distanceCalculator, ItemList<BoolArray> realizations) {
    52       var afterMove = new Permutation(PermutationTypes.RelativeUndirected, permutation);
     51    public static double EvaluateMove(Permutation tour, TranslocationMove move, Func<int, int, double> distance, DoubleArray probabilities) {
     52      var afterMove = (Permutation)tour.Clone();
    5353      TranslocationManipulator.Apply(afterMove, move.Index1, move.Index1, move.Index3);
    54       double moveQuality = 0;
    55       var edges = new int[12];
    56       var indices = new int[12];
    57       edges[0] = permutation.GetCircular(move.Index1 - 1);
    58       indices[0] = DecreaseCircularIndex(permutation.Length, move.Index1);
    59       edges[1] = permutation[move.Index1];
    60       indices[1] = move.Index1;
    61       edges[2] = permutation[move.Index1];
    62       indices[2] = move.Index1;
    63       edges[3] = permutation.GetCircular(move.Index1 + 1);
    64       indices[3] = IncreaseCircularIndex(permutation.Length, move.Index1);
    65 
    66       edges[6] = afterMove.GetCircular(move.Index3 - 1);
    67       indices[6] = DecreaseCircularIndex(afterMove.Length, move.Index3);
    68       edges[7] = afterMove[move.Index3];
    69       indices[7] = move.Index3;
    70       edges[8] = afterMove[move.Index3];
    71       indices[8] = move.Index3;
    72       edges[9] = afterMove.GetCircular(move.Index3 + 1);
    73       indices[9] = IncreaseCircularIndex(afterMove.Length, move.Index3);
    74 
    75       if (move.Index3 > move.Index1) {
    76         edges[4] = permutation[move.Index3];
    77         indices[4] = move.Index3;
    78         edges[5] = permutation.GetCircular(move.Index3 + 1);
    79         indices[5] = indices[9];
    80         edges[10] = afterMove.GetCircular(move.Index1 - 1);
    81         indices[10] = indices[0];
    82         edges[11] = afterMove[move.Index1];
    83         indices[11] = move.Index1;
    84       } else {
    85         edges[4] = permutation.GetCircular(move.Index3 - 1);
    86         indices[4] = indices[6];
    87         edges[5] = permutation[move.Index3];
    88         indices[5] = move.Index3;
    89         edges[10] = afterMove[move.Index1];
    90         indices[10] = move.Index1;
    91         edges[11] = afterMove.GetCircular(move.Index1 + 1);
    92         indices[11] = indices[3];
    93       }
    94       int[] aPosteriori = new int[12];
    95       foreach (var realization in realizations) {
    96         for (int i = 0; i < edges.Length; i++) {
    97           Permutation tempPermutation;
    98           if (i < 6) {
    99             tempPermutation = permutation;
    100           } else {
    101             tempPermutation = afterMove;
    102           }
    103           if (realization[edges[i]]) {
    104             aPosteriori[i] = edges[i];
    105           } else {
    106             int j = 1;
    107             if (i % 2 == 0) {
    108               // find nearest predecessor in realization if source edge
    109               while (!realization[tempPermutation.GetCircular(indices[i] - j)]) {
    110                 j++;
    111               }
    112               aPosteriori[i] = tempPermutation.GetCircular(indices[i] - j);
    113             } else {
    114               // find nearest successor in realization if target edge
    115               while (!realization[tempPermutation.GetCircular(indices[i] + j)]) {
    116                 j++;
    117               }
    118               aPosteriori[i] = tempPermutation.GetCircular(indices[i] + j);
    119             }
    120           }
    121         }
    122         if (!(aPosteriori[0] == aPosteriori[2] && aPosteriori[1] == aPosteriori[3]) &&
    123           !(aPosteriori[0] == aPosteriori[4] && aPosteriori[1] == aPosteriori[5]) &&
    124           !(aPosteriori[2] == aPosteriori[4] && aPosteriori[3] == aPosteriori[5])) {
    125           // compute cost difference between the two a posteriori solutions
    126 
    127           moveQuality += distanceCalculator.Calculate(aPosteriori[6], aPosteriori[7], coordinates)
    128                        + distanceCalculator.Calculate(aPosteriori[8], aPosteriori[9], coordinates)
    129                        + distanceCalculator.Calculate(aPosteriori[10], aPosteriori[11], coordinates)
    130                        - distanceCalculator.Calculate(aPosteriori[0], aPosteriori[1], coordinates)
    131                        - distanceCalculator.Calculate(aPosteriori[2], aPosteriori[3], coordinates)
    132                        - distanceCalculator.Calculate(aPosteriori[4], aPosteriori[5], coordinates);
    133         }
    134         Array.Clear(aPosteriori, 0, aPosteriori.Length);
    135       }
    136       // return average of cost differences
    137       return moveQuality / realizations.Count;
     54      return AnalyticalProbabilisticTravelingSalesmanProblem.Evaluate(afterMove, distance, probabilities);
    13855    }
    13956
    140     public static double EvaluateByDistanceMatrix(Permutation permutation, TranslocationMove move, DistanceMatrix distanceMatrix, ItemList<BoolArray> realizations) {
    141       var afterMove = new Permutation(PermutationTypes.RelativeUndirected, permutation);
    142       TranslocationManipulator.Apply(afterMove, move.Index1, move.Index1, move.Index3);
    143       double moveQuality = 0;
    144       var edges = new int[12];
    145       var indices = new int[12];
    146       edges[0] = permutation.GetCircular(move.Index1 - 1);
    147       indices[0] = DecreaseCircularIndex(permutation.Length, move.Index1);
    148       edges[1] = permutation[move.Index1];
    149       indices[1] = move.Index1;
    150       edges[2] = permutation[move.Index1];
    151       indices[2] = move.Index1;
    152       edges[3] = permutation.GetCircular(move.Index1 + 1);
    153       indices[3] = IncreaseCircularIndex(permutation.Length, move.Index1);
    154 
    155       edges[6] = afterMove.GetCircular(move.Index3 - 1);
    156       indices[6] = DecreaseCircularIndex(afterMove.Length, move.Index3);
    157       edges[7] = afterMove[move.Index3];
    158       indices[7] = move.Index3;
    159       edges[8] = afterMove[move.Index3];
    160       indices[8] = move.Index3;
    161       edges[9] = afterMove.GetCircular(move.Index3 + 1);
    162       indices[9] = IncreaseCircularIndex(afterMove.Length, move.Index3);
    163 
    164       if (move.Index3 > move.Index1) {
    165         edges[4] = permutation[move.Index3];
    166         indices[4] = move.Index3;
    167         edges[5] = permutation.GetCircular(move.Index3 + 1);
    168         indices[5] = indices[9];
    169         edges[10] = afterMove.GetCircular(move.Index1 - 1);
    170         indices[10] = indices[0];
    171         edges[11] = afterMove[move.Index1];
    172         indices[11] = move.Index1;
    173       } else {
    174         edges[4] = permutation.GetCircular(move.Index3 - 1);
    175         indices[4] = indices[6];
    176         edges[5] = permutation[move.Index3];
    177         indices[5] = move.Index3;
    178         edges[10] = afterMove[move.Index1];
    179         indices[10] = move.Index1;
    180         edges[11] = afterMove.GetCircular(move.Index1 + 1);
    181         indices[11] = indices[3];
    182       }
    183       int[] aPosteriori = new int[12];
    184       foreach (var realization in realizations) {
    185         for (int i = 0; i < edges.Length; i++) {
    186           Permutation tempPermutation;
    187           if (i < 6) {
    188             tempPermutation = permutation;
    189           } else {
    190             tempPermutation = afterMove;
    191           }
    192           if (realization[edges[i]]) {
    193             aPosteriori[i] = edges[i];
    194           } else {
    195             int j = 1;
    196             if (i % 2 == 0) {
    197               // find nearest predecessor in realization if source edge
    198               while (!realization[tempPermutation.GetCircular(indices[i] - j)]) {
    199                 j++;
    200               }
    201               aPosteriori[i] = tempPermutation.GetCircular(indices[i] - j);
    202             } else {
    203               // find nearest successor in realization if target edge
    204               while (!realization[tempPermutation.GetCircular(indices[i] + j)]) {
    205                 j++;
    206               }
    207               aPosteriori[i] = tempPermutation.GetCircular(indices[i] + j);
    208             }
    209           }
    210         }
    211         if (!(aPosteriori[0] == aPosteriori[2] && aPosteriori[1] == aPosteriori[3]) &&
    212           !(aPosteriori[0] == aPosteriori[4] && aPosteriori[1] == aPosteriori[5]) &&
    213           !(aPosteriori[2] == aPosteriori[4] && aPosteriori[3] == aPosteriori[5])) {
    214           // compute cost difference between the two a posteriori solutions
    215           moveQuality = moveQuality + distanceMatrix[aPosteriori[6], aPosteriori[7]] + distanceMatrix[aPosteriori[8], aPosteriori[9]] + distanceMatrix[aPosteriori[10], aPosteriori[11]];
    216           moveQuality = moveQuality - distanceMatrix[aPosteriori[0], aPosteriori[1]] - distanceMatrix[aPosteriori[2], aPosteriori[3]] - distanceMatrix[aPosteriori[4], aPosteriori[5]];
    217         }
    218         Array.Clear(aPosteriori, 0, aPosteriori.Length);
    219       }
    220       // return average of cost differences
    221       return moveQuality / realizations.Count;
    222     }
    223 
    224     private static int DecreaseCircularIndex(int length, int index) {
    225       var result = index - 1;
    226       if (result == -1) {
    227         result = length - 1;
    228       }
    229       return result;
    230     }
    231 
    232     private static int IncreaseCircularIndex(int length, int index) {
    233       var result = index + 1;
    234       if (result == length + 1) {
    235         result = 0;
    236       }
    237       return result;
    238     }
    239 
    240     protected override double EvaluateByCoordinates(Permutation permutation, DoubleMatrix coordinates, DistanceCalculator distanceCalculator) {
    241       return EvaluateByCoordinates(permutation, TranslocationMoveParameter.ActualValue, coordinates, distanceCalculator, RealizationsParameter.ActualValue);
    242     }
    243 
    244     protected override double EvaluateByDistanceMatrix(Permutation permutation, DistanceMatrix distanceMatrix) {
    245       return EvaluateByDistanceMatrix(permutation, TranslocationMoveParameter.ActualValue, distanceMatrix, RealizationsParameter.ActualValue);
     57    protected override double EvaluateMove(Permutation tour, Func<int, int, double> distance, DoubleArray probabilities) {
     58      return EvaluateMove(tour, TranslocationMoveParameter.ActualValue, distance, probabilities);
    24659    }
    24760  }

  • branches/PTSP/HeuristicLab.Problems.PTSP/3.3/Moves/OneShift/PTSPEstimatedInsertionMoveEvaluator.cs

    r13412 r13470  
    2929
    3030namespace HeuristicLab.Problems.PTSP {
    31   [Item("PTSPEstimatedInsertionMoveEvaluator", "Evaluates an insertion move (1-shift)")]
     31  [Item("PTSP Estimated Insertion Move Evaluator", "Evaluates an insertion move (1-shift)")]
    3232  [StorableClass]
    3333  public class PTSPEstimatedInsertionMoveEvaluator : EstimatedPTSPMoveEvaluator, IPermutationTranslocationMoveOperator {
    … …  
    4949    }
    5050
    51     public static double EvaluateByCoordinates(Permutation permutation, TranslocationMove move, DoubleMatrix coordinates, DistanceCalculator distanceCalculator, ItemList<BoolArray> realizations) {
    52       var afterMove = new Permutation(PermutationTypes.RelativeUndirected, permutation);
     51    public static double EvaluateMove(Permutation tour, TranslocationMove move, Func<int, int, double> distance, ItemList<BoolArray> realizations) {
     52      var afterMove = (Permutation)tour.Clone();
    5353      TranslocationManipulator.Apply(afterMove, move.Index1, move.Index1, move.Index3);
    5454      double moveQuality = 0;
    5555      var edges = new int[12];
    5656      var indices = new int[12];
    57       edges[0] = permutation.GetCircular(move.Index1 - 1);
    58       indices[0] = DecreaseCircularIndex(permutation.Length, move.Index1);
    59       edges[1] = permutation[move.Index1];
     57      edges[0] = tour.GetCircular(move.Index1 - 1);
     58      indices[0] = DecreaseCircularIndex(tour.Length, move.Index1);
     59      edges[1] = tour[move.Index1];
    6060      indices[1] = move.Index1;
    61       edges[2] = permutation[move.Index1];
     61      edges[2] = tour[move.Index1];
    6262      indices[2] = move.Index1;
    63       edges[3] = permutation.GetCircular(move.Index1 + 1);
    64       indices[3] = IncreaseCircularIndex(permutation.Length, move.Index1);
     63      edges[3] = tour.GetCircular(move.Index1 + 1);
     64      indices[3] = IncreaseCircularIndex(tour.Length, move.Index1);
    6565
    6666      edges[6] = afterMove.GetCircular(move.Index3 - 1);
    … …  
    7474
    7575      if (move.Index3 > move.Index1) {
    76         edges[4] = permutation[move.Index3];
     76        edges[4] = tour[move.Index3];
    7777        indices[4] = move.Index3;
    78         edges[5] = permutation.GetCircular(move.Index3 + 1);
     78        edges[5] = tour.GetCircular(move.Index3 + 1);
    7979        indices[5] = indices[9];
    8080        edges[10] = afterMove.GetCircular(move.Index1 - 1);
    … …  
    8383        indices[11] = move.Index1;
    8484      } else {
    85         edges[4] = permutation.GetCircular(move.Index3 - 1);
     85        edges[4] = tour.GetCircular(move.Index3 - 1);
    8686        indices[4] = indices[6];
    87         edges[5] = permutation[move.Index3];
     87        edges[5] = tour[move.Index3];
    8888        indices[5] = move.Index3;
    8989        edges[10] = afterMove[move.Index1];
    … …  
    9797          Permutation tempPermutation;
    9898          if (i < 6) {
    99             tempPermutation = permutation;
     99            tempPermutation = tour;
    100100          } else {
    101101            tempPermutation = afterMove;
    … …  
    124124          !(aPosteriori[2] == aPosteriori[4] && aPosteriori[3] == aPosteriori[5])) {
    125125          // compute cost difference between the two a posteriori solutions
    126 
    127           moveQuality += distanceCalculator.Calculate(aPosteriori[6], aPosteriori[7], coordinates)
    128                        + distanceCalculator.Calculate(aPosteriori[8], aPosteriori[9], coordinates)
    129                        + distanceCalculator.Calculate(aPosteriori[10], aPosteriori[11], coordinates)
    130                        - distanceCalculator.Calculate(aPosteriori[0], aPosteriori[1], coordinates)
    131                        - distanceCalculator.Calculate(aPosteriori[2], aPosteriori[3], coordinates)
    132                        - distanceCalculator.Calculate(aPosteriori[4], aPosteriori[5], coordinates);
    133         }
    134         Array.Clear(aPosteriori, 0, aPosteriori.Length);
    135       }
    136       // return average of cost differences
    137       return moveQuality / realizations.Count;
    138     }
    139 
    140     public static double EvaluateByDistanceMatrix(Permutation permutation, TranslocationMove move, DistanceMatrix distanceMatrix, ItemList<BoolArray> realizations) {
    141       var afterMove = new Permutation(PermutationTypes.RelativeUndirected, permutation);
    142       TranslocationManipulator.Apply(afterMove, move.Index1, move.Index1, move.Index3);
    143       double moveQuality = 0;
    144       var edges = new int[12];
    145       var indices = new int[12];
    146       edges[0] = permutation.GetCircular(move.Index1 - 1);
    147       indices[0] = DecreaseCircularIndex(permutation.Length, move.Index1);
    148       edges[1] = permutation[move.Index1];
    149       indices[1] = move.Index1;
    150       edges[2] = permutation[move.Index1];
    151       indices[2] = move.Index1;
    152       edges[3] = permutation.GetCircular(move.Index1 + 1);
    153       indices[3] = IncreaseCircularIndex(permutation.Length, move.Index1);
    154 
    155       edges[6] = afterMove.GetCircular(move.Index3 - 1);
    156       indices[6] = DecreaseCircularIndex(afterMove.Length, move.Index3);
    157       edges[7] = afterMove[move.Index3];
    158       indices[7] = move.Index3;
    159       edges[8] = afterMove[move.Index3];
    160       indices[8] = move.Index3;
    161       edges[9] = afterMove.GetCircular(move.Index3 + 1);
    162       indices[9] = IncreaseCircularIndex(afterMove.Length, move.Index3);
    163 
    164       if (move.Index3 > move.Index1) {
    165         edges[4] = permutation[move.Index3];
    166         indices[4] = move.Index3;
    167         edges[5] = permutation.GetCircular(move.Index3 + 1);
    168         indices[5] = indices[9];
    169         edges[10] = afterMove.GetCircular(move.Index1 - 1);
    170         indices[10] = indices[0];
    171         edges[11] = afterMove[move.Index1];
    172         indices[11] = move.Index1;
    173       } else {
    174         edges[4] = permutation.GetCircular(move.Index3 - 1);
    175         indices[4] = indices[6];
    176         edges[5] = permutation[move.Index3];
    177         indices[5] = move.Index3;
    178         edges[10] = afterMove[move.Index1];
    179         indices[10] = move.Index1;
    180         edges[11] = afterMove.GetCircular(move.Index1 + 1);
    181         indices[11] = indices[3];
    182       }
    183       int[] aPosteriori = new int[12];
    184       foreach (var realization in realizations) {
    185         for (int i = 0; i < edges.Length; i++) {
    186           Permutation tempPermutation;
    187           if (i < 6) {
    188             tempPermutation = permutation;
    189           } else {
    190             tempPermutation = afterMove;
    191           }
    192           if (realization[edges[i]]) {
    193             aPosteriori[i] = edges[i];
    194           } else {
    195             int j = 1;
    196             if (i % 2 == 0) {
    197               // find nearest predecessor in realization if source edge
    198               while (!realization[tempPermutation.GetCircular(indices[i] - j)]) {
    199                 j++;
    200               }
    201               aPosteriori[i] = tempPermutation.GetCircular(indices[i] - j);
    202             } else {
    203               // find nearest successor in realization if target edge
    204               while (!realization[tempPermutation.GetCircular(indices[i] + j)]) {
    205                 j++;
    206               }
    207               aPosteriori[i] = tempPermutation.GetCircular(indices[i] + j);
    208             }
    209           }
    210         }
    211         if (!(aPosteriori[0] == aPosteriori[2] && aPosteriori[1] == aPosteriori[3]) &&
    212           !(aPosteriori[0] == aPosteriori[4] && aPosteriori[1] == aPosteriori[5]) &&
    213           !(aPosteriori[2] == aPosteriori[4] && aPosteriori[3] == aPosteriori[5])) {
    214           // compute cost difference between the two a posteriori solutions
    215           moveQuality = moveQuality + distanceMatrix[aPosteriori[6], aPosteriori[7]] + distanceMatrix[aPosteriori[8], aPosteriori[9]] + distanceMatrix[aPosteriori[10], aPosteriori[11]];
    216           moveQuality = moveQuality - distanceMatrix[aPosteriori[0], aPosteriori[1]] - distanceMatrix[aPosteriori[2], aPosteriori[3]] - distanceMatrix[aPosteriori[4], aPosteriori[5]];
     126          moveQuality = moveQuality + distance(aPosteriori[6], aPosteriori[7]) + distance(aPosteriori[8], aPosteriori[9]) + distance(aPosteriori[10], aPosteriori[11]);
     127          moveQuality = moveQuality - distance(aPosteriori[0], aPosteriori[1]) - distance(aPosteriori[2], aPosteriori[3]) - distance(aPosteriori[4], aPosteriori[5]);
    217128        }
    218129        Array.Clear(aPosteriori, 0, aPosteriori.Length);
    … …  
    238149    }
    239150
    240     protected override double EvaluateByCoordinates(Permutation permutation, DoubleMatrix coordinates, DistanceCalculator distanceCalculator) {
    241       return EvaluateByCoordinates(permutation, TranslocationMoveParameter.ActualValue, coordinates, distanceCalculator, RealizationsParameter.ActualValue);
    242     }
    243 
    244     protected override double EvaluateByDistanceMatrix(Permutation permutation, DistanceMatrix distanceMatrix) {
    245       return EvaluateByDistanceMatrix(permutation, TranslocationMoveParameter.ActualValue, distanceMatrix, RealizationsParameter.ActualValue);
     151    protected override double EvaluateMove(Permutation tour, Func<int, int, double> distance, ItemList<BoolArray> realizations) {
     152      return EvaluateMove(tour, TranslocationMoveParameter.ActualValue, distance, realizations);
    246153    }
    247154  }

  • branches/PTSP/HeuristicLab.Problems.PTSP/3.3/Moves/TwoOpt/PTSPAnalyticalInversionMoveEvaluator.cs

    r13451 r13470  
    2929
    3030namespace HeuristicLab.Problems.PTSP {
    31   [Item("PTSPEstimatedInversionMoveEvaluator", "Evaluates an inversion move (2-opt) over several realizations of tours by summing up the length of all added edges and subtracting the length of all deleted edges.")]
     31  [Item("PTSP Analytical Inversion Move Evaluator", "Evaluates an inversion move (2-opt) by a full solution evaluation.")]
    3232  [StorableClass]
    33   public class PTSPEstimatedInversionMoveEvaluator : EstimatedPTSPMoveEvaluator, IPermutationInversionMoveOperator {
     33  public class PTSPAnalyticalInversionMoveEvaluator : AnalyticalPTSPMoveEvaluator, IPermutationInversionMoveOperator {
    3434
    3535    public ILookupParameter<InversionMove> InversionMoveParameter {
    … …  
    3838
    3939    [StorableConstructor]
    40     protected PTSPEstimatedInversionMoveEvaluator(bool deserializing) : base(deserializing) { }
    41     protected PTSPEstimatedInversionMoveEvaluator(PTSPEstimatedInversionMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
    42     public PTSPEstimatedInversionMoveEvaluator()
     40    protected PTSPAnalyticalInversionMoveEvaluator(bool deserializing) : base(deserializing) { }
     41    protected PTSPAnalyticalInversionMoveEvaluator(PTSPAnalyticalInversionMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
     42    public PTSPAnalyticalInversionMoveEvaluator()
    4343      : base() {
    4444      Parameters.Add(new LookupParameter<InversionMove>("InversionMove", "The move to evaluate."));
    … …  
    4646
    4747    public override IDeepCloneable Clone(Cloner cloner) {
    48       return new PTSPEstimatedInversionMoveEvaluator(this, cloner);
     48      return new PTSPAnalyticalInversionMoveEvaluator(this, cloner);
    4949    }
    5050
    51     public static double EvaluateByCoordinates(Permutation permutation, InversionMove move, DoubleMatrix coordinates, DistanceCalculator distanceCalculator, ItemList<BoolArray> realizations) {
    52       double moveQuality = 0;
    53       var edges = new int[4];
    54       var indices = new int[4];
    55       edges[0] = permutation.GetCircular(move.Index1 - 1);
    56       indices[0] = move.Index1 - 1;
    57       if (indices[0] == -1) indices[0] = permutation.Length - 1;
    58       edges[1] = permutation[move.Index1];
    59       indices[1] = move.Index1;
    60       edges[2] = permutation[move.Index2];
    61       indices[2] = move.Index2;
    62       edges[3] = permutation.GetCircular(move.Index2 + 1);
    63       indices[3] = move.Index2 + 1;
    64       if (indices[3] == permutation.Length + 1) indices[3] = 0;
    65       var aPosteriori = new int[4];
    66       foreach (var realization in realizations) {
    67         for (var i = 0; i < edges.Length; i++) {
    68           if (realization[edges[i]]) {
    69             aPosteriori[i] = edges[i];
    70           } else {
    71             var j = 1;
    72             if (i % 2 == 0) {
    73               // find nearest predecessor in realization if source edge
    74               while (!realization[permutation.GetCircular(indices[i] - j)]) {
    75                 j++;
    76               }
    77               aPosteriori[i] = permutation.GetCircular(indices[i] - j);
    78             } else {
    79               // find nearest successor in realization if target edge
    80               while (!realization[permutation.GetCircular(indices[i] + j)]) {
    81                 j++;
    82               }
    83               aPosteriori[i] = permutation.GetCircular(indices[i] + j);
    84             }
    85           }
    86         }
    87         // compute cost difference between the two a posteriori solutions
    88         if (!(aPosteriori[0] == aPosteriori[2] && aPosteriori[1] == aPosteriori[3])) {
    89           moveQuality = moveQuality
    90             + distanceCalculator.Calculate(0, 2, coordinates)
    91             + distanceCalculator.Calculate(1, 3, coordinates)
    92             - distanceCalculator.Calculate(0, 1, coordinates)
    93             - distanceCalculator.Calculate(2, 3, coordinates);
    94         }
    95         Array.Clear(aPosteriori, 0, aPosteriori.Length);
    96       }
    97       // return average of cost differences
    98       return moveQuality / realizations.Count;
     51    public static double EvaluateMove(Permutation tour, InversionMove move, Func<int, int, double> distance, DoubleArray probabilities) {
     52      var afterMove = (Permutation)tour.Clone();
     53      InversionManipulator.Apply(afterMove, move.Index1, move.Index2);
     54      return AnalyticalProbabilisticTravelingSalesmanProblem.Evaluate(afterMove, distance, probabilities);
    9955    }
    10056
    101     public static double EvaluateByDistanceMatrix(Permutation permutation, InversionMove move, DistanceMatrix distanceMatrix, ItemList<BoolArray> realizations) {
    102       double moveQuality = 0;
    103       var edges = new int[4];
    104       var indices = new int[4];
    105       edges[0] = permutation.GetCircular(move.Index1 - 1);
    106       indices[0] = move.Index1 - 1;
    107       if (indices[0] == -1) indices[0] = permutation.Length - 1;
    108       edges[1] = permutation[move.Index1];
    109       indices[1] = move.Index1;
    110       edges[2] = permutation[move.Index2];
    111       indices[2] = move.Index2;
    112       edges[3] = permutation.GetCircular(move.Index2 + 1);
    113       indices[3] = move.Index2 + 1;
    114       if (indices[3] == permutation.Length + 1) indices[3] = 0;
    115       var aPosteriori = new int[4];
    116       foreach (var realization in realizations) {
    117         for (var i = 0; i < edges.Length; i++) {
    118           if (realization[edges[i]]) {
    119             aPosteriori[i] = edges[i];
    120           } else {
    121             var j = 1;
    122             if (i % 2 == 0) {
    123               // find nearest predecessor in realization if source edge
    124               while (!realization[permutation.GetCircular(indices[i] - j)]) {
    125                 j++;
    126               }
    127               aPosteriori[i] = permutation.GetCircular(indices[i] - j);
    128             } else {
    129               // find nearest successor in realization if target edge
    130               while (!realization[permutation.GetCircular(indices[i] + j)]) {
    131                 j++;
    132               }
    133               aPosteriori[i] = permutation.GetCircular(indices[i] + j);
    134             }
    135           }
    136         }
    137         // compute cost difference between the two a posteriori solutions
    138         if (!(aPosteriori[0] == aPosteriori[2] && aPosteriori[1] == aPosteriori[3])) {
    139           moveQuality = moveQuality + distanceMatrix[aPosteriori[0], aPosteriori[2]] + distanceMatrix[aPosteriori[1], aPosteriori[3]] - distanceMatrix[aPosteriori[0], aPosteriori[1]] - distanceMatrix[aPosteriori[2], aPosteriori[3]];
    140         }
    141         Array.Clear(aPosteriori, 0, aPosteriori.Length);
    142       }
    143       // return average of cost differences
    144       return moveQuality / realizations.Count;
    145     }
    146 
    147     protected override double EvaluateByCoordinates(Permutation permutation, DoubleMatrix coordinates, DistanceCalculator distanceCalculator) {
    148       return EvaluateByCoordinates(permutation, InversionMoveParameter.ActualValue, coordinates, distanceCalculator, RealizationsParameter.ActualValue);
    149     }
    150 
    151     protected override double EvaluateByDistanceMatrix(Permutation permutation, DistanceMatrix distanceMatrix) {
    152       return EvaluateByDistanceMatrix(permutation, InversionMoveParameter.ActualValue, distanceMatrix, RealizationsParameter.ActualValue);
     57    protected override double EvaluateMove(Permutation tour, Func<int, int, double> distance, DoubleArray probabilities) {
     58      return EvaluateMove(tour, InversionMoveParameter.ActualValue, distance, probabilities);
    15359    }
    15460  }

  • branches/PTSP/HeuristicLab.Problems.PTSP/3.3/Moves/TwoOpt/PTSPEstimatedInversionMoveEvaluator.cs

    r13412 r13470  
    2929
    3030namespace HeuristicLab.Problems.PTSP {
    31   [Item("PTSPEstimatedInversionMoveEvaluator", "Evaluates an inversion move (2-opt) over several realizations of tours by summing up the length of all added edges and subtracting the length of all deleted edges.")]
     31  [Item("PTSP Estimated Inversion Move Evaluator", "Evaluates an inversion move (2-opt) over several realizations of tours by summing up the length of all added edges and subtracting the length of all deleted edges.")]
    3232  [StorableClass]
    3333  public class PTSPEstimatedInversionMoveEvaluator : EstimatedPTSPMoveEvaluator, IPermutationInversionMoveOperator {
    … …  
    4949    }
    5050
    51     public static double EvaluateByCoordinates(Permutation permutation, InversionMove move, DoubleMatrix coordinates, DistanceCalculator distanceCalculator, ItemList<BoolArray> realizations) {
     51    public static double EvaluateMove(Permutation tour, InversionMove move, Func<int, int, double> distance, ItemList<BoolArray> realizations) {
    5252      double moveQuality = 0;
    5353      var edges = new int[4];
    5454      var indices = new int[4];
    55       edges[0] = permutation.GetCircular(move.Index1 - 1);
     55      edges[0] = tour.GetCircular(move.Index1 - 1);
    5656      indices[0] = move.Index1 - 1;
    57       if (indices[0] == -1) indices[0] = permutation.Length - 1;
    58       edges[1] = permutation[move.Index1];
     57      if (indices[0] == -1) indices[0] = tour.Length - 1;
     58      edges[1] = tour[move.Index1];
    5959      indices[1] = move.Index1;
    60       edges[2] = permutation[move.Index2];
     60      edges[2] = tour[move.Index2];
    6161      indices[2] = move.Index2;
    62       edges[3] = permutation.GetCircular(move.Index2 + 1);
     62      edges[3] = tour.GetCircular(move.Index2 + 1);
    6363      indices[3] = move.Index2 + 1;
    64       if (indices[3] == permutation.Length + 1) indices[3] = 0;
     64      if (indices[3] == tour.Length + 1) indices[3] = 0;
    6565      var aPosteriori = new int[4];
    6666      foreach (var realization in realizations) {
    … …  
    7272            if (i % 2 == 0) {
    7373              // find nearest predecessor in realization if source edge
    74               while (!realization[permutation.GetCircular(indices[i] - j)]) {
     74              while (!realization[tour.GetCircular(indices[i] - j)]) {
    7575                j++;
    7676              }
    77               aPosteriori[i] = permutation.GetCircular(indices[i] - j);
     77              aPosteriori[i] = tour.GetCircular(indices[i] - j);
    7878            } else {
    7979              // find nearest successor in realization if target edge
    80               while (!realization[permutation.GetCircular(indices[i] + j)]) {
     80              while (!realization[tour.GetCircular(indices[i] + j)]) {
    8181                j++;
    8282              }
    83               aPosteriori[i] = permutation.GetCircular(indices[i] + j);
     83              aPosteriori[i] = tour.GetCircular(indices[i] + j);
    8484            }
    8585          }
    … …  
    8787        // compute cost difference between the two a posteriori solutions
    8888        if (!(aPosteriori[0] == aPosteriori[2] && aPosteriori[1] == aPosteriori[3])) {
    89           moveQuality = moveQuality
    90             + distanceCalculator.Calculate(0, 2, coordinates)
    91             + distanceCalculator.Calculate(1, 3, coordinates)
    92             - distanceCalculator.Calculate(0, 1, coordinates)
    93             - distanceCalculator.Calculate(2, 3, coordinates);
     89          moveQuality = moveQuality + distance(aPosteriori[0], aPosteriori[2]) + distance(aPosteriori[1], aPosteriori[3])
     90            - distance(aPosteriori[0], aPosteriori[1]) - distance(aPosteriori[2], aPosteriori[3]);
    9491        }
    9592        Array.Clear(aPosteriori, 0, aPosteriori.Length);
    … …  
    9996    }
    10097
    101     public static double EvaluateByDistanceMatrix(Permutation permutation, InversionMove move, DistanceMatrix distanceMatrix, ItemList<BoolArray> realizations) {
    102       double moveQuality = 0;
    103       var edges = new int[4];
    104       var indices = new int[4];
    105       edges[0] = permutation.GetCircular(move.Index1 - 1);
    106       indices[0] = move.Index1 - 1;
    107       if (indices[0] == -1) indices[0] = permutation.Length - 1;
    108       edges[1] = permutation[move.Index1];
    109       indices[1] = move.Index1;
    110       edges[2] = permutation[move.Index2];
    111       indices[2] = move.Index2;
    112       edges[3] = permutation.GetCircular(move.Index2 + 1);
    113       indices[3] = move.Index2 + 1;
    114       if (indices[3] == permutation.Length + 1) indices[3] = 0;
    115       var aPosteriori = new int[4];
    116       foreach (var realization in realizations) {
    117         for (var i = 0; i < edges.Length; i++) {
    118           if (realization[edges[i]]) {
    119             aPosteriori[i] = edges[i];
    120           } else {
    121             var j = 1;
    122             if (i % 2 == 0) {
    123               // find nearest predecessor in realization if source edge
    124               while (!realization[permutation.GetCircular(indices[i] - j)]) {
    125                 j++;
    126               }
    127               aPosteriori[i] = permutation.GetCircular(indices[i] - j);
    128             } else {
    129               // find nearest successor in realization if target edge
    130               while (!realization[permutation.GetCircular(indices[i] + j)]) {
    131                 j++;
    132               }
    133               aPosteriori[i] = permutation.GetCircular(indices[i] + j);
    134             }
    135           }
    136         }
    137         // compute cost difference between the two a posteriori solutions
    138         if (!(aPosteriori[0] == aPosteriori[2] && aPosteriori[1] == aPosteriori[3])) {
    139           moveQuality = moveQuality + distanceMatrix[aPosteriori[0], aPosteriori[2]] + distanceMatrix[aPosteriori[1], aPosteriori[3]] - distanceMatrix[aPosteriori[0], aPosteriori[1]] - distanceMatrix[aPosteriori[2], aPosteriori[3]];
    140         }
    141         Array.Clear(aPosteriori, 0, aPosteriori.Length);
    142       }
    143       // return average of cost differences
    144       return moveQuality / realizations.Count;
    145     }
    146 
    147     protected override double EvaluateByCoordinates(Permutation permutation, DoubleMatrix coordinates, DistanceCalculator distanceCalculator) {
    148       return EvaluateByCoordinates(permutation, InversionMoveParameter.ActualValue, coordinates, distanceCalculator, RealizationsParameter.ActualValue);
    149     }
    150 
    151     protected override double EvaluateByDistanceMatrix(Permutation permutation, DistanceMatrix distanceMatrix) {
    152       return EvaluateByDistanceMatrix(permutation, InversionMoveParameter.ActualValue, distanceMatrix, RealizationsParameter.ActualValue);
     98    protected override double EvaluateMove(Permutation tour, Func<int, int, double> distance, ItemList<BoolArray> realizations) {
     99      return EvaluateMove(tour, InversionMoveParameter.ActualValue, distance, realizations);
    153100    }
    154101  }

  • branches/PTSP/HeuristicLab.Problems.PTSP/3.3/Moves/TwoPointFiveOpt/PTSPAnalyticalTwoPointFiveMoveEvaluator.cs

    r13451 r13470  
    2020#endregion
    2121
     22using System;
    2223using HeuristicLab.Common;
    2324using HeuristicLab.Core;
    … …  
    2829
    2930namespace HeuristicLab.Problems.PTSP {
    30   [Item("PTSP 2.5-MoveEvaluator", "Operator that evaluates 2.5-p-opt moves of PTSP")]
     31  [Item("PTSP Analytical 2.5-MoveEvaluator", "Operator that evaluates 2.5-p-opt moves of PTSP by a full solution evaluation.")]
    3132  [StorableClass]
    32   public class PTSPTwoPointFiveMoveEvaluator : EstimatedPTSPMoveEvaluator, ITwoPointFiveMoveOperator {
     33  public class PTSPAnalyticalTwoPointFiveMoveEvaluator : AnalyticalPTSPMoveEvaluator, ITwoPointFiveMoveOperator {
    3334
    3435    public ILookupParameter<TwoPointFiveMove> TwoPointFiveMoveParameter {
    … …  
    3738
    3839    [StorableConstructor]
    39     protected PTSPTwoPointFiveMoveEvaluator(bool deserializing) : base(deserializing) { }
    40     protected PTSPTwoPointFiveMoveEvaluator(PTSPTwoPointFiveMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
    41     public PTSPTwoPointFiveMoveEvaluator()
     40    protected PTSPAnalyticalTwoPointFiveMoveEvaluator(bool deserializing) : base(deserializing) { }
     41    protected PTSPAnalyticalTwoPointFiveMoveEvaluator(PTSPAnalyticalTwoPointFiveMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
     42    public PTSPAnalyticalTwoPointFiveMoveEvaluator()
    4243      : base() {
    4344      Parameters.Add(new LookupParameter<TwoPointFiveMove>("TwoPointFiveMove", "The move to evaluate."));
    … …  
    4546
    4647    public override IDeepCloneable Clone(Cloner cloner) {
    47       return new PTSPTwoPointFiveMoveEvaluator(this, cloner);
     48      return new PTSPAnalyticalTwoPointFiveMoveEvaluator(this, cloner);
    4849    }
    4950
    50     protected override double EvaluateByCoordinates(Permutation permutation, DoubleMatrix coordinates, DistanceCalculator distanceCalculator) {
    51       var move = TwoPointFiveMoveParameter.ActualValue;
    52       var realizations = RealizationsParameter.ActualValue;
    53       return EvaluateByCoordinates(permutation, coordinates, distanceCalculator, move, realizations);
     51    protected override double EvaluateMove(Permutation permutation, Func<int, int, double> distance, DoubleArray probabilities) {
     52      return EvaluateMove(permutation, TwoPointFiveMoveParameter.ActualValue, distance, probabilities);
    5453    }
    5554
    56     public static double EvaluateByCoordinates(Permutation permutation, DoubleMatrix coordinates, DistanceCalculator distanceCalculator, TwoPointFiveMove move, ItemList<BoolArray> realizations) {
     55    public static double EvaluateMove(Permutation permutation, TwoPointFiveMove move, Func<int, int, double> distance, DoubleArray probabilities) {
    5756      if (move.IsInvert) {
    58         return PTSPEstimatedInversionMoveEvaluator.EvaluateByCoordinates(permutation,
    59           new InversionMove(move.Index1, move.Index2, move.Permutation),
    60           coordinates, distanceCalculator, realizations);
     57        return PTSPAnalyticalInversionMoveEvaluator.EvaluateMove(permutation,
     58          new InversionMove(move.Index1, move.Index2, move.Permutation), distance, probabilities);
    6159      } else {
    62         return PTSPEstimatedInsertionMoveEvaluator.EvaluateByCoordinates(permutation,
    63           new TranslocationMove(move.Index1, move.Index1, move.Index2),
    64           coordinates, distanceCalculator, realizations);
    65       }
    66     }
    67 
    68     protected override double EvaluateByDistanceMatrix(Permutation permutation, DistanceMatrix distanceMatrix) {
    69       var move = TwoPointFiveMoveParameter.ActualValue;
    70       var realizations = RealizationsParameter.ActualValue;
    71       return EvaluateByDistanceMatrix(permutation, distanceMatrix, move, realizations);
    72     }
    73 
    74     public static double EvaluateByDistanceMatrix(Permutation permutation, DistanceMatrix distanceMatrix, TwoPointFiveMove move, ItemList<BoolArray> realizations) {
    75       if (move.IsInvert) {
    76         return PTSPEstimatedInversionMoveEvaluator.EvaluateByDistanceMatrix(permutation,
    77           new InversionMove(move.Index1, move.Index2, move.Permutation),
    78           distanceMatrix, realizations);
    79       } else {
    80         return PTSPEstimatedInsertionMoveEvaluator.EvaluateByDistanceMatrix(permutation,
    81           new TranslocationMove(move.Index1, move.Index1, move.Index2),
    82           distanceMatrix, realizations);
     60        return PTSPAnalyticalInsertionMoveEvaluator.EvaluateMove(permutation,
     61          new TranslocationMove(move.Index1, move.Index1, move.Index2), distance, probabilities);
    8362      }
    8463    }

  • branches/PTSP/HeuristicLab.Problems.PTSP/3.3/Moves/TwoPointFiveOpt/PTSPEstimatedTwoPointFiveMoveEvaluator.cs

    r13469 r13470  
    2020#endregion
    2121
     22using System;
    2223using HeuristicLab.Common;
    2324using HeuristicLab.Core;
    … …  
    2829
    2930namespace HeuristicLab.Problems.PTSP {
    30   [Item("PTSP 2.5-MoveEvaluator", "Operator that evaluates 2.5-p-opt moves of PTSP")]
     31  [Item("PTSP Estimated 2.5-MoveEvaluator", "Operator that evaluates 2.5-p-opt moves of PTSP")]
    3132  [StorableClass]
    32   public class PTSPTwoPointFiveMoveEvaluator : EstimatedPTSPMoveEvaluator, ITwoPointFiveMoveOperator {
     33  public class PTSPEstimatedTwoPointFiveMoveEvaluator : EstimatedPTSPMoveEvaluator, ITwoPointFiveMoveOperator {
    3334
    3435    public ILookupParameter<TwoPointFiveMove> TwoPointFiveMoveParameter {
    … …  
    3738
    3839    [StorableConstructor]
    39     protected PTSPTwoPointFiveMoveEvaluator(bool deserializing) : base(deserializing) { }
    40     protected PTSPTwoPointFiveMoveEvaluator(PTSPTwoPointFiveMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
    41     public PTSPTwoPointFiveMoveEvaluator()
     40    protected PTSPEstimatedTwoPointFiveMoveEvaluator(bool deserializing) : base(deserializing) { }
     41    protected PTSPEstimatedTwoPointFiveMoveEvaluator(PTSPEstimatedTwoPointFiveMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
     42    public PTSPEstimatedTwoPointFiveMoveEvaluator()
    4243      : base() {
    4344      Parameters.Add(new LookupParameter<TwoPointFiveMove>("TwoPointFiveMove", "The move to evaluate."));
    … …  
    4546
    4647    public override IDeepCloneable Clone(Cloner cloner) {
    47       return new PTSPTwoPointFiveMoveEvaluator(this, cloner);
     48      return new PTSPEstimatedTwoPointFiveMoveEvaluator(this, cloner);
    4849    }
    4950
    50     protected override double EvaluateByCoordinates(Permutation permutation, DoubleMatrix coordinates, DistanceCalculator distanceCalculator) {
    51       var move = TwoPointFiveMoveParameter.ActualValue;
    52       var realizations = RealizationsParameter.ActualValue;
    53       return EvaluateByCoordinates(permutation, coordinates, distanceCalculator, move, realizations);
     51    protected override double EvaluateMove(Permutation permutation, Func<int, int, double> distance, ItemList<BoolArray> realizations) {
     52      return EvaluateMove(permutation, TwoPointFiveMoveParameter.ActualValue, distance, realizations);
    5453    }
    5554
    56     public static double EvaluateByCoordinates(Permutation permutation, DoubleMatrix coordinates, DistanceCalculator distanceCalculator, TwoPointFiveMove move, ItemList<BoolArray> realizations) {
     55    public static double EvaluateMove(Permutation permutation, TwoPointFiveMove move, Func<int, int, double> distance, ItemList<BoolArray> realizations) {
    5756      if (move.IsInvert) {
    58         return PTSPEstimatedInversionMoveEvaluator.EvaluateByCoordinates(permutation,
    59           new InversionMove(move.Index1, move.Index2, move.Permutation),
    60           coordinates, distanceCalculator, realizations);
     57        return PTSPEstimatedInversionMoveEvaluator.EvaluateMove(permutation,
     58          new InversionMove(move.Index1, move.Index2, move.Permutation), distance, realizations);
    6159      } else {
    62         return PTSPEstimatedInsertionMoveEvaluator.EvaluateByCoordinates(permutation,
    63           new TranslocationMove(move.Index1, move.Index1, move.Index2),
    64           coordinates, distanceCalculator, realizations);
    65       }
    66     }
    67 
    68     protected override double EvaluateByDistanceMatrix(Permutation permutation, DistanceMatrix distanceMatrix) {
    69       var move = TwoPointFiveMoveParameter.ActualValue;
    70       var realizations = RealizationsParameter.ActualValue;
    71       return EvaluateByDistanceMatrix(permutation, distanceMatrix, move, realizations);
    72     }
    73 
    74     public static double EvaluateByDistanceMatrix(Permutation permutation, DistanceMatrix distanceMatrix, TwoPointFiveMove move, ItemList<BoolArray> realizations) {
    75       if (move.IsInvert) {
    76         return PTSPEstimatedInversionMoveEvaluator.EvaluateByDistanceMatrix(permutation,
    77           new InversionMove(move.Index1, move.Index2, move.Permutation),
    78           distanceMatrix, realizations);
    79       } else {
    80         return PTSPEstimatedInsertionMoveEvaluator.EvaluateByDistanceMatrix(permutation,
    81           new TranslocationMove(move.Index1, move.Index1, move.Index2),
    82           distanceMatrix, realizations);
     60        return PTSPEstimatedInsertionMoveEvaluator.EvaluateMove(permutation,
     61          new TranslocationMove(move.Index1, move.Index1, move.Index2), distance, realizations);
    8362      }
    8463    }

  • branches/PTSP/HeuristicLab.Problems.PTSP/3.3/Moves/TwoPointFiveOpt/TwoPointFiveMoveMaker.cs

    r13412 r13470  
    7171      var quality = QualityParameter.ActualValue;
    7272
     73      Apply(permutation, move);
     74
     75      quality.Value = moveQuality.Value;
     76
     77      return base.Apply();
     78    }
     79
     80    public static void Apply(Permutation permutation, TwoPointFiveMove move) {
    7381      if (move.IsInvert) {
    7482        InversionManipulator.Apply(permutation, move.Index1, move.Index2);
    … …  
    7684        TranslocationManipulator.Apply(permutation, move.Index1, move.Index1, move.Index2);
    7785      }
    78 
    79       quality.Value = moveQuality.Value;
    80 
    81       return base.Apply();
    8286    }
    8387  }
Note: See TracChangeset for help on using the changeset viewer.