private static bool EvaluateRelativeTabuState(ItemList <IItem> tabuList, Swap2Move move, Permutation permutation, double moveQuality, bool maximization, bool useAspiration)
{
bool isTabu = false;
StandardEdgeEqualityComparer eq = new StandardEdgeEqualityComparer();
bool bidirectional = permutation.PermutationType == PermutationTypes.RelativeUndirected;
List <Edge> deleted = new List <Edge>();
deleted.Add(new Edge(permutation.GetCircular(move.Index1 - 1), permutation[move.Index1], bidirectional));
deleted.Add(new Edge(permutation[move.Index1], permutation.GetCircular(move.Index1 + 1), bidirectional));
deleted.Add(new Edge(permutation.GetCircular(move.Index2 - 1), permutation[move.Index2], bidirectional));
deleted.Add(new Edge(permutation[move.Index2], permutation.GetCircular(move.Index2 + 1), bidirectional));
List <Edge> added = new List <Edge>();
added.Add(new Edge(permutation.GetCircular(move.Index1 - 1), permutation[move.Index2], bidirectional));
added.Add(new Edge(permutation[move.Index2], permutation.GetCircular(move.Index1 + 1), bidirectional));
added.Add(new Edge(permutation.GetCircular(move.Index2 - 1), permutation[move.Index1], bidirectional));
added.Add(new Edge(permutation[move.Index1], permutation.GetCircular(move.Index2 + 1), bidirectional));
foreach (IItem tabuMove in tabuList)
{
Swap2MoveRelativeAttribute relAttrib = (tabuMove as Swap2MoveRelativeAttribute);
if (relAttrib != null &&
(!useAspiration ||
maximization && moveQuality <= relAttrib.MoveQuality ||
!maximization && moveQuality >= relAttrib.MoveQuality))
{
for (int i = 0; i < relAttrib.AddedEdges.Count; i++)
{
isTabu = eq.Equals(relAttrib.AddedEdges[i], deleted[0]) ||
eq.Equals(relAttrib.AddedEdges[i], deleted[1]) ||
eq.Equals(relAttrib.AddedEdges[i], deleted[2]) ||
eq.Equals(relAttrib.AddedEdges[i], deleted[3]);
if (isTabu)
{
break;
}
}
if (isTabu)
{
break;
}
for (int i = 0; i < relAttrib.DeletedEdges.Count; i++)
{
isTabu = eq.Equals(relAttrib.DeletedEdges[i], added[0]) ||
eq.Equals(relAttrib.DeletedEdges[i], added[1]) ||
eq.Equals(relAttrib.DeletedEdges[i], added[2]) ||
eq.Equals(relAttrib.DeletedEdges[i], added[3]);
if (isTabu)
{
break;
}
}
}
if (isTabu)
{
break;
}
}
return(isTabu);
}
private bool EvaluateAbsoluteTabuState(ItemList <IItem> tabuList, Swap2Move move, Permutation permutation, double moveQuality, bool maximization, bool useAspiration)
{
bool isTabu = false;
foreach (IItem tabuMove in tabuList)
{
Swap2MoveAbsoluteAttribute attrib = (tabuMove as Swap2MoveAbsoluteAttribute);
if (attrib != null &&
(!useAspiration ||
maximization && moveQuality <= attrib.MoveQuality ||
!maximization && moveQuality >= attrib.MoveQuality))
{
int i1 = move.Index1;
int n1 = permutation[move.Index1];
int i2 = move.Index2;
int n2 = permutation[move.Index2];
if ((attrib.Index1 == i1 || attrib.Index1 == i2) && (attrib.Number1 == n1 || attrib.Number1 == n2) ||
(attrib.Index2 == i2 || attrib.Index2 == i1) && (attrib.Number2 == n2 || attrib.Number2 == n1))
{
isTabu = true;
}
}
if (isTabu)
{
break;
}
}
return(isTabu);
}
protected override IItem GetTabuAttribute(bool maximization, double quality, double moveQuality)
{
Swap2Move move = Swap2MoveParameter.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 Swap2MoveAbsoluteAttribute(move.Index1, permutation[move.Index1], move.Index2, permutation[move.Index2], baseQuality));
}
else
{
Swap2MoveRelativeAttribute attrib = new Swap2MoveRelativeAttribute(baseQuality);
bool bidirectional = permutation.PermutationType == PermutationTypes.RelativeUndirected;
attrib.DeletedEdges.Add(new Edge(permutation.GetCircular(move.Index1 - 1), permutation[move.Index1], bidirectional));
attrib.DeletedEdges.Add(new Edge(permutation[move.Index1], permutation.GetCircular(move.Index1 + 1), bidirectional));
attrib.DeletedEdges.Add(new Edge(permutation.GetCircular(move.Index2 - 1), permutation[move.Index2], bidirectional));
attrib.DeletedEdges.Add(new Edge(permutation[move.Index2], permutation.GetCircular(move.Index2 + 1), bidirectional));
attrib.AddedEdges.Add(new Edge(permutation.GetCircular(move.Index1 - 1), permutation[move.Index2], bidirectional));
attrib.AddedEdges.Add(new Edge(permutation[move.Index2], permutation.GetCircular(move.Index1 + 1), bidirectional));
attrib.AddedEdges.Add(new Edge(permutation.GetCircular(move.Index2 - 1), permutation[move.Index1], bidirectional));
attrib.AddedEdges.Add(new Edge(permutation[move.Index1], permutation.GetCircular(move.Index2 + 1), bidirectional));
return(attrib);
}
}
public static Swap2Move[] Apply(Permutation permutation, IRandom random, int sampleSize) {
int length = permutation.Length;
Swap2Move[] moves = new Swap2Move[sampleSize];
for (int i = 0; i < sampleSize; i++) {
moves[i] = StochasticSwap2SingleMoveGenerator.Apply(permutation, random);
}
return moves;
}
public static Swap2Move[] Apply(Permutation permutation) {
int length = permutation.Length;
int totalMoves = (length) * (length - 1) / 2;
Swap2Move[] moves = new Swap2Move[totalMoves];
int count = 0;
foreach (Swap2Move move in Generate(permutation)) {
moves[count++] = move;
}
return moves;
}
public static Swap2Move[] Apply(Permutation permutation, IRandom random, int sampleSize)
{
int length = permutation.Length;
Swap2Move[] moves = new Swap2Move[sampleSize];
for (int i = 0; i < sampleSize; i++)
{
moves[i] = StochasticSwap2SingleMoveGenerator.Apply(permutation, random);
}
return(moves);
}
public override IOperation Apply()
{
Swap2Move move = Swap2MoveParameter.ActualValue;
Permutation permutation = PermutationParameter.ActualValue;
DoubleValue moveQuality = MoveQualityParameter.ActualValue;
DoubleValue quality = QualityParameter.ActualValue;
Swap2Manipulator.Apply(permutation, move.Index1, move.Index2);
quality.Value = moveQuality.Value;
return(base.Apply());
}
public static Swap2Move[] Apply(Permutation permutation)
{
int length = permutation.Length;
int totalMoves = (length) * (length - 1) / 2;
Swap2Move[] moves = new Swap2Move[totalMoves];
int count = 0;
foreach (Swap2Move move in Generate(permutation))
{
moves[count++] = move;
}
return(moves);
}
public override IOperation Apply()
{
ItemList <IItem> tabuList = TabuListParameter.ActualValue;
Swap2Move move = Swap2MoveParameter.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;
if (permutation.PermutationType != PermutationTypes.Absolute)
{
isTabu = EvaluateRelativeTabuState(tabuList, move, permutation, moveQuality, maximization, useAspiration);
}
else
{
isTabu = EvaluateAbsoluteTabuState(tabuList, move, permutation, moveQuality, maximization, useAspiration);
}
MoveTabuParameter.ActualValue = new BoolValue(isTabu);
return(base.Apply());
}
/// <summary>
/// Calculates the quality of the move <paramref name="move"/> by evaluating the changes.
/// The runtime complexity of this method is O(N) with N being the size of the permutation.
/// </summary>
/// <param name="assignment">The current permutation.</param>
/// <param name="move">The move that is to be evaluated if it was applied to the current permutation.</param>
/// <param name="weights">The weights matrix.</param>
/// <param name="distances">The distances matrix.</param>
/// <returns>The relative change in quality if <paramref name="move"/> was applied to <paramref name="assignment"/>.</returns>
public static double Apply(Permutation assignment, Swap2Move move, DoubleMatrix weights, DoubleMatrix distances) {
if (move.Index1 == move.Index2) return 0;
double moveQuality = 0;
int fac1 = move.Index1, fac2 = move.Index2;
int loc1 = assignment[fac1], loc2 = assignment[fac2];
for (int j = 0; j < assignment.Length; j++) {
if (j == fac1) {
moveQuality += weights[fac1, fac1] * (distances[loc2, loc2] - distances[loc1, loc1]);
moveQuality += weights[fac1, fac2] * (distances[loc2, loc1] - distances[loc1, loc2]);
} else if (j == fac2) {
moveQuality += weights[fac2, fac2] * (distances[loc1, loc1] - distances[loc2, loc2]);
moveQuality += weights[fac2, fac1] * (distances[loc1, loc2] - distances[loc2, loc1]);
} else {
int locJ = assignment[j];
moveQuality += weights[fac1, j] * (distances[loc2, locJ] - distances[loc1, locJ]);
moveQuality += weights[j, fac1] * (distances[locJ, loc2] - distances[locJ, loc1]);
moveQuality += weights[fac2, j] * (distances[loc1, locJ] - distances[loc2, locJ]);
moveQuality += weights[j, fac2] * (distances[locJ, loc1] - distances[locJ, loc2]);
}
}
return moveQuality;
}
private bool EvaluateAbsoluteTabuState(ItemList<IItem> tabuList, Swap2Move move, Permutation permutation, double moveQuality, bool maximization, bool useAspiration) {
bool isTabu = false;
foreach (IItem tabuMove in tabuList) {
Swap2MoveAbsoluteAttribute attrib = (tabuMove as Swap2MoveAbsoluteAttribute);
if (attrib != null
&& (!useAspiration
|| maximization && moveQuality <= attrib.MoveQuality
|| !maximization && moveQuality >= attrib.MoveQuality)) {
int i1 = move.Index1;
int n1 = permutation[move.Index1];
int i2 = move.Index2;
int n2 = permutation[move.Index2];
if ((attrib.Index1 == i1 || attrib.Index1 == i2) && (attrib.Number1 == n1 || attrib.Number1 == n2)
|| (attrib.Index2 == i2 || attrib.Index2 == i1) && (attrib.Number2 == n2 || attrib.Number2 == n1))
isTabu = true;
}
if (isTabu) break;
}
return isTabu;
}
private static bool EvaluateRelativeTabuState(ItemList<IItem> tabuList, Swap2Move move, Permutation permutation, double moveQuality, bool maximization, bool useAspiration) {
bool isTabu = false;
StandardEdgeEqualityComparer eq = new StandardEdgeEqualityComparer();
bool bidirectional = permutation.PermutationType == PermutationTypes.RelativeUndirected;
List<Edge> added = new List<Edge>();
added.Add(new Edge(permutation.GetCircular(move.Index1 - 1), permutation[move.Index2], bidirectional));
added.Add(new Edge(permutation[move.Index2], permutation.GetCircular(move.Index1 + 1), bidirectional));
added.Add(new Edge(permutation.GetCircular(move.Index2 - 1), permutation[move.Index1], bidirectional));
added.Add(new Edge(permutation[move.Index1], permutation.GetCircular(move.Index2 + 1), bidirectional));
foreach (IItem tabuMove in tabuList) {
Swap2MoveRelativeAttribute relAttrib = (tabuMove as Swap2MoveRelativeAttribute);
if (relAttrib != null
&& (!useAspiration
|| maximization && moveQuality <= relAttrib.MoveQuality
|| !maximization && moveQuality >= relAttrib.MoveQuality)) {
for (int i = 0; i < relAttrib.DeletedEdges.Count; i++) {
isTabu = eq.Equals(relAttrib.DeletedEdges[i], added[0])
|| eq.Equals(relAttrib.DeletedEdges[i], added[1])
|| eq.Equals(relAttrib.DeletedEdges[i], added[2])
|| eq.Equals(relAttrib.DeletedEdges[i], added[3]);
if (isTabu) break;
}
}
if (isTabu) break;
}
return isTabu;
}
protected Swap2Move(Swap2Move original, Cloner cloner) : base(original, cloner)
{
}
protected Swap2Move(Swap2Move original, Cloner cloner) : base(original, cloner) { }
/// <summary>
/// Is able to compute the move qualities faster O(1) in some cases if it knows the quality of
/// performing the move <paramref name="move"/> previously. In other cases it performs a
/// standard move quality calculation with runtime complexity O(N).
/// </summary>
/// <remarks>
/// The number of cases that the calculation can be performed faster grows with N^2
/// while the number of cases which require a larger recalculation grows linearly with N.
/// Larger problem instances thus benefit from this faster method to a larger degree.
/// </remarks>
/// <param name="assignment">The current permutation.</param>
/// <param name="move">The current move that is to be evaluated.</param>
/// <param name="previousQuality">The quality of that move as evaluated for the previous permutation.</param>
/// <param name="weights">The weigths matrix.</param>
/// <param name="distances">The distances matrix.</param>
/// <param name="lastMove">The move that was applied to transform the permutation from the previous to the current one.</param>
/// <returns>The relative change in quality if <paramref name="move"/> was applied to <paramref name="assignment"/>.</returns>
public static double Apply(Permutation assignment, Swap2Move move, double previousQuality,
DoubleMatrix weights, DoubleMatrix distances, Swap2Move lastMove) {
bool overlapsLastMove = move.Index1 == lastMove.Index1
|| move.Index2 == lastMove.Index1
|| move.Index1 == lastMove.Index2
|| move.Index2 == lastMove.Index2;
if (!overlapsLastMove) {
int r = lastMove.Index1, u = move.Index1, s = lastMove.Index2, v = move.Index2;
int pR = assignment[lastMove.Index1], pU = assignment[move.Index1], pS = assignment[lastMove.Index2], pV = assignment[move.Index2];
return previousQuality
+ (weights[r, u] - weights[r, v] + weights[s, v] - weights[s, u])
* (distances[pS, pU] - distances[pS, pV] + distances[pR, pV] - distances[pR, pU])
+ (weights[u, r] - weights[v, r] + weights[v, s] - weights[u, s])
* (distances[pU, pS] - distances[pV, pS] + distances[pV, pR] - distances[pU, pR]);
} else {
return Apply(assignment, move, weights, distances);
}
}
public void Swap2MoveEvaluatorFastEvaluationTest() {
for (int i = 0; i < 500; i++) {
Swap2Move lastMove = new Swap2Move(random.Next(ProblemSize), random.Next(ProblemSize));
Permutation prevAssignment = (Permutation)assignment.Clone();
Swap2Manipulator.Apply(assignment, lastMove.Index1, lastMove.Index2);
Permutation nextAssignment = (Permutation)assignment.Clone();
Swap2Move currentMove = new Swap2Move(random.Next(ProblemSize), random.Next(ProblemSize));
Swap2Manipulator.Apply(nextAssignment, currentMove.Index1, currentMove.Index2);
double moveBefore = QAPSwap2MoveEvaluator.Apply(prevAssignment, currentMove, symmetricWeights, symmetricDistances);
double moveAfter = QAPSwap2MoveEvaluator.Apply(assignment, currentMove,
moveBefore, symmetricWeights, symmetricDistances, lastMove);
double before = QAPEvaluator.Apply(assignment, symmetricWeights, symmetricDistances);
double after = QAPEvaluator.Apply(nextAssignment, symmetricWeights, symmetricDistances);
Assert.IsTrue(moveAfter.IsAlmost(after - before), "Failed on symmetric matrices: " + Environment.NewLine
+ "Quality changed from " + before + " to " + after + " (" + (after - before).ToString() + "), but move quality change was " + moveAfter + ".");
moveBefore = QAPSwap2MoveEvaluator.Apply(prevAssignment, currentMove, asymmetricWeights, asymmetricDistances);
moveAfter = QAPSwap2MoveEvaluator.Apply(assignment, currentMove,
moveBefore, asymmetricWeights, asymmetricDistances, lastMove);
before = QAPEvaluator.Apply(assignment, asymmetricWeights, asymmetricDistances);
after = QAPEvaluator.Apply(nextAssignment, asymmetricWeights, asymmetricDistances);
Assert.IsTrue(moveAfter.IsAlmost(after - before), "Failed on asymmetric matrices: " + Environment.NewLine
+ "Quality changed from " + before + " to " + after + " (" + (after - before).ToString() + "), but move quality change was " + moveAfter + ".");
moveBefore = QAPSwap2MoveEvaluator.Apply(prevAssignment, currentMove, nonZeroDiagonalWeights, nonZeroDiagonalDistances);
moveAfter = QAPSwap2MoveEvaluator.Apply(assignment, currentMove,
moveBefore, nonZeroDiagonalWeights, nonZeroDiagonalDistances, lastMove);
before = QAPEvaluator.Apply(assignment, nonZeroDiagonalWeights, nonZeroDiagonalDistances);
after = QAPEvaluator.Apply(nextAssignment, nonZeroDiagonalWeights, nonZeroDiagonalDistances);
Assert.IsTrue(moveAfter.IsAlmost(after - before), "Failed on non-zero diagonal matrices: " + Environment.NewLine
+ "Quality changed from " + before + " to " + after + " (" + (after - before).ToString() + "), but move quality change was " + moveAfter + ".");
}
}
