public void MaximalPreservativeCrossoverApplyTest()
{
TestRandom random = new TestRandom();
Permutation parent1, parent2, expected, actual;
// The following test is based on an example from Larranaga, 1999. Genetic Algorithms for the Traveling Salesman Problem.
random.Reset();
random.IntNumbers = new int[] { 3, 2 };
parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
Assert.IsTrue(parent1.Validate());
parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 1, 3, 5, 7, 6, 4, 2, 0 });
Assert.IsTrue(parent2.Validate());
expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 1, 0, 2, 3, 4, 5, 7, 6 });
Assert.IsTrue(expected.Validate());
actual = MaximalPreservativeCrossover.Apply(random, parent1, parent2);
Assert.IsTrue(actual.Validate());
Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, actual));
// perform a test when the two permutations are of unequal length
random.Reset();
bool exceptionFired = false;
try {
MaximalPreservativeCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
}
catch (System.ArgumentException) {
exceptionFired = true;
}
Assert.IsTrue(exceptionFired);
}
public void TestPermutationReverse()
{
var permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
permutation.Reverse(0, 0);
Assert.IsTrue(permutation.Validate());
var expected = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation));
permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
permutation.Reverse(9, 1);
Assert.IsTrue(permutation.Validate());
expected = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation));
permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
permutation.Reverse(0, 10);
Assert.IsTrue(permutation.Validate());
expected = new Permutation(PermutationTypes.Absolute, new[] { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 });
Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation));
permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
permutation.Reverse(1, 4);
Assert.IsTrue(permutation.Validate());
expected = new Permutation(PermutationTypes.Absolute, new[] { 0, 4, 3, 2, 1, 5, 6, 7, 8, 9 });
Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation));
}
public void TestPermutationReplace()
{
var permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
permutation.Replace(0, new int[0]);
Assert.IsTrue(permutation.Validate());
var expected = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation));
permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
permutation.Replace(3, new [] { 3 });
Assert.IsTrue(permutation.Validate());
expected = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation));
permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
permutation.Replace(5, new [] { 8, 6, 5, 7 });
Assert.IsTrue(permutation.Validate());
expected = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 8, 6, 5, 7, 9 });
Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation));
permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
permutation.Replace(0, new [] { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 });
Assert.IsTrue(permutation.Validate());
expected = new Permutation(PermutationTypes.Absolute, new[] { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 });
Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation));
permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
permutation.Replace(3, new[] { 5, 6, 7 });
Assert.IsFalse(permutation.Validate());
expected = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 5, 6, 7, 6, 7, 8, 9 });
Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation));
}
public void CyclicCrossover2ApplyTest()
{
TestRandom random = new TestRandom();
Permutation parent1, parent2, expected, actual;
// The following test is based on an example from Affenzeller, M. et al. 2009. Genetic Algorithms and Genetic Programming - Modern Concepts and Practical Applications. CRC Press. pp. 134.
random.Reset();
random.IntNumbers = new int[] { 0 };
parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
Assert.IsTrue(parent1.Validate());
parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 2, 5, 6, 0, 7, 1, 3, 8, 4, 9 });
Assert.IsTrue(parent2.Validate());
expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 5, 2, 3, 7, 1, 6, 8, 4, 9 });
Assert.IsTrue(expected.Validate());
actual = CyclicCrossover2.Apply(random, parent1, parent2);
Assert.IsTrue(actual.Validate());
Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, actual));
// perform a test when the two permutations are of unequal length
random.Reset();
bool exceptionFired = false;
try {
CyclicCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
}
catch (System.ArgumentException) {
exceptionFired = true;
}
Assert.IsTrue(exceptionFired);
}
public void CosaCrossoverApplyTest()
{
TestRandom random = new TestRandom();
Permutation parent1, parent2, expected, actual;
// The following test is based on an example from Wendt, O. 1994. COSA: COoperative Simulated Annealing - Integration von Genetischen Algorithmen und Simulated Annealing am Beispiel der Tourenplanung. Dissertation Thesis. IWI Frankfurt.
random.Reset();
random.IntNumbers = new int[] { 1 };
parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 5, 2, 4, 3 });
Assert.IsTrue(parent1.Validate());
parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 3, 0, 2, 1, 4, 5 });
Assert.IsTrue(parent2.Validate());
expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 4, 2, 5, 3 });
Assert.IsTrue(expected.Validate());
actual = CosaCrossover.Apply(random, parent1, parent2);
Assert.IsTrue(actual.Validate());
Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, actual));
// The following test is not based on published examples
random.Reset();
random.IntNumbers = new int[] { 4 };
parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
Assert.IsTrue(parent1.Validate());
parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 1, 3, 5, 7, 6, 4, 2, 0 });
Assert.IsTrue(parent2.Validate());
expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 7, 6, 5, 3, 4, 2, 1, 0 });
Assert.IsTrue(expected.Validate());
actual = CosaCrossover.Apply(random, parent1, parent2);
Assert.IsTrue(actual.Validate());
Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, actual));
// The following test is not based on published examples
random.Reset();
random.IntNumbers = new int[] { 5 };
parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
Assert.IsTrue(parent1.Validate());
parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 4, 3, 5, 1, 0, 9, 7, 2, 8, 6 });
Assert.IsTrue(parent2.Validate());
expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 7, 6, 2, 3, 4, 5, 1, 0, 9, 8 });
Assert.IsTrue(expected.Validate());
actual = CosaCrossover.Apply(random, parent1, parent2);
Assert.IsTrue(actual.Validate());
Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, actual));
// perform a test when the two permutations are of unequal length
random.Reset();
bool exceptionFired = false;
try {
CosaCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
}
catch (System.ArgumentException) {
exceptionFired = true;
}
Assert.IsTrue(exceptionFired);
}
public void ScrambleManipulatorApplyTest()
{
TestRandom random = new TestRandom();
Permutation parent, expected;
// The following test is based on an example from Larranaga, P. et al. 1999. Genetic Algorithms for the Travelling Salesman Problem: A Review of Representations and Operators. Artificial Intelligence Review, 13
random.Reset();
random.IntNumbers = new int[] { 3, 6, 1, 1, 1, 0 };
parent = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
Assert.IsTrue(parent.Validate());
expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 4, 5, 6, 3, 7 });
Assert.IsTrue(expected.Validate());
ScrambleManipulator.Apply(random, parent);
Assert.IsTrue(parent.Validate());
Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, parent));
}
public void InversionManipulatorApplyTest()
{
TestRandom random = new TestRandom();
Permutation parent, expected;
// The following test is based on an example from Eiben, A.E. and Smith, J.E. 2003. Introduction to Evolutionary Computation. Natural Computing Series, Springer-Verlag Berlin Heidelberg, pp. 46-47
random.Reset();
random.IntNumbers = new int[] { 1, 4 };
parent = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 });
Assert.IsTrue(parent.Validate());
expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 4, 3, 2, 1, 5, 6, 7, 8 });
Assert.IsTrue(expected.Validate());
InversionManipulator.Apply(random, parent);
Assert.IsTrue(parent.Validate());
Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, parent));
}
public void Swap3ManipulatorApplyTest()
{
TestRandom random = new TestRandom();
Permutation parent, expected;
// Test manipulator
random.Reset();
random.IntNumbers = new int[] { 1, 3, 6 };
random.DoubleNumbers = new double[] { 0 };
parent = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 });
Assert.IsTrue(parent.Validate());
expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 3, 2, 6, 4, 5, 1, 7, 8 });
Assert.IsTrue(expected.Validate());
Swap3Manipulator.Apply(random, parent);
Assert.IsTrue(parent.Validate());
Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, parent));
}
public void UniformLikeCrossoverApplyTest()
{
// test from the paper
IRandom random = new TestRandom(new int[] { 0 }, new double[] { 0.2, 0.7, 0.2, 0.2 }); // TODO: Initialize to an appropriate value
Permutation parent1 = new Permutation(PermutationTypes.Absolute,
new int[] { 3, 2, 0, 7, 5, 4, 1, 6 });
Assert.IsTrue(parent1.Validate());
Permutation parent2 = new Permutation(PermutationTypes.Absolute,
new int[] { 5, 0, 4, 7, 1, 3, 2, 6 });
Assert.IsTrue(parent2.Validate());
Permutation expected = new Permutation(PermutationTypes.Absolute,
new int[] { 3, 0, 4, 7, 5, 2, 1, 6 });
Assert.IsTrue(expected.Validate());
Permutation actual;
actual = UniformLikeCrossover.Apply(random, parent1, parent2);
Assert.IsTrue(actual.Validate());
Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, actual));
}
public void TestPermutationSwap()
{
var permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
permutation.Swap(0, 0);
Assert.IsTrue(permutation.Validate());
var expected = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation));
permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
permutation.Swap(0, 9);
Assert.IsTrue(permutation.Validate());
expected = new Permutation(PermutationTypes.Absolute, new[] { 9, 1, 2, 3, 4, 5, 6, 7, 8, 0 });
Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation));
permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
permutation.Swap(1, 3);
permutation.Swap(3, 5);
Assert.IsTrue(permutation.Validate());
expected = new Permutation(PermutationTypes.Absolute, new[] { 0, 3, 2, 5, 4, 1, 6, 7, 8, 9 });
Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation));
}
public void TestPermutationMove()
{
var permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
permutation.Move(0, 0, 0);
Assert.IsTrue(permutation.Validate());
var expected = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation));
permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
permutation.Move(0, 0, 1);
Assert.IsTrue(permutation.Validate());
expected = new Permutation(PermutationTypes.Absolute, new[] { 1, 0, 2, 3, 4, 5, 6, 7, 8, 9 });
Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation));
permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
permutation.Move(0, 2, 3);
Assert.IsTrue(permutation.Validate());
expected = new Permutation(PermutationTypes.Absolute, new[] { 3, 4, 5, 0, 1, 2, 6, 7, 8, 9 });
Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation));
permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
permutation.Move(3, 5, 0);
Assert.IsTrue(permutation.Validate());
expected = new Permutation(PermutationTypes.Absolute, new[] { 3, 4, 5, 0, 1, 2, 6, 7, 8, 9 });
Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation));
permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
permutation.Move(3, 5, 2);
Assert.IsTrue(permutation.Validate());
expected = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 3, 4, 5, 2, 6, 7, 8, 9 });
Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation));
permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
permutation.Move(5, 6, 8);
Assert.IsTrue(permutation.Validate());
expected = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 7, 8, 9, 5, 6 });
Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation));
permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
permutation.Move(5, 7, 7);
Assert.IsTrue(permutation.Validate());
expected = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 8, 9, 5, 6, 7 });
Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation));
permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
permutation.Move(2, 6, 5);
Assert.IsTrue(permutation.Validate());
expected = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 7, 8, 9, 2, 3, 4, 5, 6 });
Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation));
permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
permutation.Move(3, 5, 4);
Assert.IsTrue(permutation.Validate());
expected = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 6, 3, 4, 5, 7, 8, 9 });
Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation));
permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
var exception = false;
try {
permutation.Move(0, 5, 7);
} catch { exception = true; }
Assert.IsTrue(exception);
}
public void OrderCrossoverApplyTest()
{
TestRandom random = new TestRandom();
Permutation parent1, parent2, expected, actual;
// The following test is based on an example from Eiben, A.E. and Smith, J.E. 2003. Introduction to Evolutionary Computation. Natural Computing Series, Springer-Verlag Berlin Heidelberg, pp. 55-56
random.Reset();
random.IntNumbers = new int[] { 3, 6 };
parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 });
Assert.IsTrue(parent1.Validate());
parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 8, 2, 6, 7, 1, 5, 4, 0, 3 });
Assert.IsTrue(parent2.Validate());
expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 2, 7, 1, 3, 4, 5, 6, 0, 8 });
Assert.IsTrue(expected.Validate());
actual = OrderCrossover.Apply(random, parent1, parent2);
Assert.IsTrue(actual.Validate());
Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, actual));
// The following test is based on an example from Larranaga, P. et al. 1999. Genetic Algorithms for the Travelling Salesman Problem: A Review of Representations and Operators. Artificial Intelligence Review, 13, pp. 129-170.
random.Reset();
random.IntNumbers = new int[] { 2, 4 };
parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
Assert.IsTrue(parent1.Validate());
parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 1, 3, 5, 7, 6, 4, 2, 0 });
Assert.IsTrue(parent2.Validate());
expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 7, 6, 2, 3, 4, 0, 1, 5 });
actual = OrderCrossover.Apply(random, parent1, parent2);
Assert.IsTrue(actual.Validate());
Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, actual));
// The following test is based on an example from Talbi, E.G. 2009. Metaheuristics - From Design to Implementation. Wiley, p. 218.
random.Reset();
random.IntNumbers = new int[] { 2, 5 };
parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 });
Assert.IsTrue(parent1.Validate());
parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 7, 3, 0, 4, 8, 2, 5, 1, 6 });
Assert.IsTrue(parent2.Validate());
expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 8, 2, 3, 4, 5, 1, 6, 7 });
Assert.IsTrue(expected.Validate());
actual = OrderCrossover.Apply(random, parent1, parent2);
Assert.IsTrue(actual.Validate());
Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, actual));
// The following test is not based on published examples
random.Reset();
random.IntNumbers = new int[] { 0, 5 };
parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 2, 1, 4, 3, 7, 8, 6, 0, 5, 9 });
Assert.IsTrue(parent1.Validate());
parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 5, 3, 4, 0, 9, 8, 2, 7, 1, 6 });
Assert.IsTrue(parent2.Validate());
expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 2, 1, 4, 3, 7, 8, 6, 5, 0, 9 });
Assert.IsTrue(expected.Validate());
actual = OrderCrossover.Apply(random, parent1, parent2);
Assert.IsTrue(actual.Validate());
Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, actual));
// based on the previous with changed breakpoints
random.Reset();
random.IntNumbers = new int[] { 6, 9 };
expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 3, 4, 8, 2, 7, 1, 6, 0, 5, 9 });
Assert.IsTrue(expected.Validate());
actual = OrderCrossover.Apply(random, parent1, parent2);
Assert.IsTrue(actual.Validate());
Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, actual));
// another one based on the previous with changed breakpoints
random.Reset();
random.IntNumbers = new int[] { 0, 9 };
expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 2, 1, 4, 3, 7, 8, 6, 0, 5, 9 });
Assert.IsTrue(expected.Validate());
actual = OrderCrossover.Apply(random, parent1, parent2);
Assert.IsTrue(actual.Validate());
Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, actual));
// perform a test when the two permutations are of unequal length
random.Reset();
bool exceptionFired = false;
try {
OrderCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
}
catch (System.ArgumentException) {
exceptionFired = true;
}
Assert.IsTrue(exceptionFired);
}
