public static InversionMove[] Apply(Permutation permutation, IRandom random, int sampleSize) {
int length = permutation.Length;
InversionMove[] moves = new InversionMove[sampleSize];
for (int i = 0; i < sampleSize; i++) {
moves[i] = StochasticInversionSingleMoveGenerator.Apply(permutation, random);
}
return moves;
}
public static InversionMove[] Apply(Permutation permutation, IRandom random, int sampleSize)
{
int length = permutation.Length;
InversionMove[] moves = new InversionMove[sampleSize];
for (int i = 0; i < sampleSize; i++)
{
moves[i] = StochasticInversionSingleMoveGenerator.Apply(permutation, random);
}
return(moves);
}
public override IOperation Apply()
{
InversionMove move = InversionMoveParameter.ActualValue;
Permutation permutation = PermutationParameter.ActualValue;
DoubleValue moveQuality = MoveQualityParameter.ActualValue;
DoubleValue quality = QualityParameter.ActualValue;
InversionManipulator.Apply(permutation, move.Index1, move.Index2);
quality.Value = moveQuality.Value;
return(base.Apply());
}
public static double EvaluateByDistanceMatrix(Permutation permutation, InversionMove move, DistanceMatrix distanceMatrix) {
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 -= distanceMatrix[edge1source, edge1target];
moveQuality -= distanceMatrix[edge2source, edge2target];
// add two edges
moveQuality += distanceMatrix[edge1source, edge2source];
moveQuality += distanceMatrix[edge1target, edge2target];
return moveQuality;
}
public static double EvaluateMove(Permutation tour, InversionMove move, Func<int, int, double> distance, ItemList<BoolArray> realizations) {
double moveQuality = 0;
var edges = new int[4];
var indices = new int[4];
edges[0] = tour.GetCircular(move.Index1 - 1);
indices[0] = move.Index1 - 1;
if (indices[0] == -1) indices[0] = tour.Length - 1;
edges[1] = tour[move.Index1];
indices[1] = move.Index1;
edges[2] = tour[move.Index2];
indices[2] = move.Index2;
edges[3] = tour.GetCircular(move.Index2 + 1);
indices[3] = move.Index2 + 1;
if (indices[3] == tour.Length + 1) indices[3] = 0;
var aPosteriori = new int[4];
foreach (var realization in realizations) {
for (var i = 0; i < edges.Length; i++) {
if (realization[edges[i]]) {
aPosteriori[i] = edges[i];
} else {
var j = 1;
if (i % 2 == 0) {
// find nearest predecessor in realization if source edge
while (!realization[tour.GetCircular(indices[i] - j)]) {
j++;
}
aPosteriori[i] = tour.GetCircular(indices[i] - j);
} else {
// find nearest successor in realization if target edge
while (!realization[tour.GetCircular(indices[i] + j)]) {
j++;
}
aPosteriori[i] = tour.GetCircular(indices[i] + j);
}
}
}
// compute cost difference between the two a posteriori solutions
if (!(aPosteriori[0] == aPosteriori[2] && aPosteriori[1] == aPosteriori[3])) {
moveQuality = moveQuality + distance(aPosteriori[0], aPosteriori[2]) + distance(aPosteriori[1], aPosteriori[3])
- distance(aPosteriori[0], aPosteriori[1]) - distance(aPosteriori[2], aPosteriori[3]);
}
Array.Clear(aPosteriori, 0, aPosteriori.Length);
}
// return average of cost differences
return moveQuality / realizations.Count;
}
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;
}
public static double Apply(Permutation assignment, InversionMove move, DoubleMatrix weights, DoubleMatrix distances) {
if (move.Index1 == move.Index2) return 0;
double moveQuality = 0;
int min = Math.Min(move.Index1, move.Index2);
int max = Math.Max(move.Index1, move.Index2);
for (int i = min; i <= max; i++) {
int locI = assignment[i];
int newlocI = assignment[max - i + min];
for (int j = 0; j < assignment.Length; j++) {
int locJ = assignment[j];
if (j >= min && j <= max) {
int newlocJ = assignment[max - j + min];
moveQuality += weights[i, j] * (distances[newlocI, newlocJ] - distances[locI, locJ]);
} else {
moveQuality += weights[i, j] * (distances[newlocI, locJ] - distances[locI, locJ]);
moveQuality += weights[j, i] * (distances[locJ, newlocI] - distances[locJ, locI]);
}
}
}
return moveQuality;
}
protected override IItem GetTabuAttribute(bool maximization, double quality, double moveQuality)
{
InversionMove move = InversionMoveParameter.ActualValue;
Permutation permutation = PermutationParameter.ActualValue;
double baseQuality = moveQuality;
if (maximization && quality > moveQuality || !maximization && quality < moveQuality)
{
baseQuality = quality; // we make an uphill move, the lower bound is the solution quality
}
if (permutation.PermutationType == PermutationTypes.Absolute)
{
return(new InversionMoveAbsoluteAttribute(move.Index1, permutation[move.Index1], move.Index2, permutation[move.Index2], baseQuality));
}
else
{
return(new InversionMoveRelativeAttribute(permutation.GetCircular(move.Index1 - 1),
permutation[move.Index1],
permutation[move.Index2],
permutation.GetCircular(move.Index2 + 1),
baseQuality));
}
}
protected InversionMove(InversionMove original, Cloner cloner) : base(original, cloner)
{
}
protected InversionMove(InversionMove original, Cloner cloner) : base(original, cloner) { }
public override IOperation Apply()
{
ItemList <IItem> tabuList = TabuListParameter.ActualValue;
InversionMove move = InversionMoveParameter.ActualValue;
Permutation permutation = PermutationParameter.ActualValue;
int length = permutation.Length;
double moveQuality = MoveQualityParameter.ActualValue.Value;
bool maximization = MaximizationParameter.ActualValue.Value;
bool useAspiration = UseAspirationCriterion.Value;
bool isTabu = false;
foreach (IItem tabuMove in tabuList)
{
PermutationMoveAttribute attrib = (tabuMove as PermutationMoveAttribute);
if (!useAspiration ||
maximization && moveQuality <= attrib.MoveQuality ||
!maximization && moveQuality >= attrib.MoveQuality)
{
switch (permutation.PermutationType)
{
case PermutationTypes.RelativeUndirected: {
int E1S = permutation.GetCircular(move.Index1 - 1);
int E1T = permutation[move.Index1];
int E2S = permutation[move.Index2];
int E2T = permutation.GetCircular(move.Index2 + 1);
InversionMoveRelativeAttribute relAttrib = (attrib as InversionMoveRelativeAttribute);
if (relAttrib != null)
{
if (relAttrib.Edge1Source == E1S && relAttrib.Edge2Source == E1T || relAttrib.Edge1Source == E1T && relAttrib.Edge2Source == E1S ||
relAttrib.Edge1Source == E2S && relAttrib.Edge2Source == E2T || relAttrib.Edge1Source == E2T && relAttrib.Edge2Source == E2S
// if previously added Edge1Target-Edge2Target is deleted
|| relAttrib.Edge1Target == E2S && relAttrib.Edge2Target == E2T || relAttrib.Edge1Target == E2T && relAttrib.Edge2Target == E2S ||
relAttrib.Edge1Target == E1S && relAttrib.Edge2Target == E1T || relAttrib.Edge1Target == E1T && relAttrib.Edge2Target == E1S)
{
isTabu = true;
}
}
}
break;
case PermutationTypes.RelativeDirected: {
int E1S = permutation.GetCircular(move.Index1 - 1);
int E1T = permutation[move.Index1];
int E2S = permutation[move.Index2];
int E2T = permutation.GetCircular(move.Index2 + 1);
InversionMoveRelativeAttribute relAttrib = (attrib as InversionMoveRelativeAttribute);
if (relAttrib != null)
{
if (relAttrib.Edge1Source == E1S && relAttrib.Edge2Source == E1T ||
relAttrib.Edge1Source == E2S && relAttrib.Edge2Source == E2T
// if previously added Edge1Target-Edge2Target is deleted
|| relAttrib.Edge1Target == E2S && relAttrib.Edge2Target == E2T ||
relAttrib.Edge1Target == E1S && relAttrib.Edge2Target == E1T)
{
isTabu = true;
}
}
}
break;
case PermutationTypes.Absolute: {
int i1 = move.Index1;
int n1 = permutation[move.Index1];
int i2 = move.Index2;
int n2 = permutation[move.Index2];
InversionMoveAbsoluteAttribute absAttrib = (attrib as InversionMoveAbsoluteAttribute);
if (absAttrib != null)
{
if (absAttrib.Number1 == n1 || absAttrib.Number1 == n2 ||
absAttrib.Number2 == n2 || absAttrib.Number2 == n1)
{
isTabu = true;
}
}
}
break;
default: {
throw new InvalidOperationException(Name + ": Unknown permutation type.");
}
}
}
if (isTabu)
{
break;
}
}
MoveTabuParameter.ActualValue = new BoolValue(isTabu);
return(base.Apply());
}
public static double EvaluateMove(Permutation tour, InversionMove move, Func<int, int, double> distance, DoubleArray probabilities) {
var afterMove = (Permutation)tour.Clone();
InversionManipulator.Apply(afterMove, move.Index1, move.Index2);
return AnalyticalProbabilisticTravelingSalesmanProblem.Evaluate(afterMove, distance, probabilities);
}