Free cookie consent management tool by TermsFeed Policy Generator

Changeset 3231


Ignore:
Timestamp:
03/29/10 17:53:12 (13 years ago)
Author:
abeham
Message:

Added a permutation type property specifying whether it's a relative (directed or undirected) or absolute permutation #889

Location:
trunk/sources
Files:
2 added
1 deleted
32 edited

Legend:

Unmodified
Added
Removed
  • trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Creators/RandomPermutationCreator.cs

    r3160 r3231  
    4747      get { return (ILookupParameter<Permutation>)Parameters["Permutation"]; }
    4848    }
     49    public IValueParameter<PermutationType> PermutationTypeParameter {
     50      get { return (IValueParameter<PermutationType>)Parameters["PermutationType"]; }
     51    }
     52
     53    public PermutationTypes PermutationType {
     54      get { return PermutationTypeParameter.Value.Value; }
     55      set { PermutationTypeParameter.Value.Value = value; }
     56    }
    4957
    5058    public RandomPermutationCreator()
     
    5361      Parameters.Add(new ValueLookupParameter<IntValue>("Length", "The length of the new random permutation."));
    5462      Parameters.Add(new LookupParameter<Permutation>("Permutation", "The new random permutation."));
     63      Parameters.Add(new ValueParameter<PermutationType>("PermutationType", "The type of the permutation.", new PermutationType(PermutationTypes.RelativeUndirected)));
    5564    }
    5665
    5766    public override IOperation Apply() {
    58       PermutationParameter.ActualValue = new Permutation(LengthParameter.ActualValue.Value, RandomParameter.ActualValue);
     67      PermutationParameter.ActualValue = new Permutation(PermutationType, LengthParameter.ActualValue.Value, RandomParameter.ActualValue);
    5968      return base.Apply();
    6069    }
  • trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/CosaCrossover.cs

    r3160 r3231  
    8484        }
    8585      }
    86       return new Permutation(result);
     86      return new Permutation(parent1.PermutationType, result);
    8787    }
    8888
  • trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/CyclicCrossover.cs

    r3160 r3231  
    9090      } while (j < length);
    9191
    92       return new Permutation(result);
     92      return new Permutation(parent1.PermutationType, result);
    9393    }
    9494
  • trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/CyclicCrossover2.cs

    r3160 r3231  
    7777        }
    7878      }
    79       return new Permutation(result);
     79      return new Permutation(parent1.PermutationType, result);
    8080    }
    8181
  • trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/EdgeRecombinationCrossover.cs

    r3160 r3231  
    136136        }
    137137      }
    138       return new Permutation(result);
     138      return new Permutation(parent1.PermutationType, result);
    139139    }
    140140
  • trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/MaximalPreservativeCrossover.cs

    r3160 r3231  
    117117      } while (index != breakPoint1);
    118118
    119       return new Permutation(result);
     119      return new Permutation(parent1.PermutationType, result);
    120120    }
    121121
  • trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/OrderBasedCrossover.cs

    r3160 r3231  
    8989        }
    9090      }
    91       return new Permutation(result);
     91      return new Permutation(parent1.PermutationType, result);
    9292    }
    9393
  • trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/OrderCrossover.cs

    r3160 r3231  
    8080        throw new InvalidOperationException("OrderCrossover: The permutation must consist of numbers in the interval [0;N) with N = length of the permutation.");
    8181      }
    82       return new Permutation(result);
     82      return new Permutation(parent1.PermutationType, result);
    8383    }
    8484
  • trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/OrderCrossover2.cs

    r3160 r3231  
    7272        }
    7373      }
    74       return new Permutation(result);
     74      return new Permutation(parent1.PermutationType, result);
    7575    }
    7676
  • trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/PartiallyMatchedCrossover.cs

    r3160 r3231  
    8484      }
    8585
    86       return new Permutation(result);
     86      return new Permutation(parent1.PermutationType, result);
    8787    }
    8888
  • trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/PositionBasedCrossover.cs

    r3160 r3231  
    7575      }
    7676
    77       return new Permutation(result);
     77      return new Permutation(parent1.PermutationType, result);
    7878    }
    7979
  • trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/HeuristicLab.Encodings.PermutationEncoding-3.3.csproj

    r3221 r3231  
    108108    <Compile Include="Manipulators\TranslocationManipulator.cs" />
    109109    <Compile Include="Moves\ThreeIndexMove.cs" />
    110     <Compile Include="Moves\ThreeOpt\PreventDeleteThreeOptTabuMoveEvaluator.cs" />
    111     <Compile Include="Moves\ThreeOpt\PreventReaddThreeOptTabuMoveEvaluator.cs" />
    112     <Compile Include="Moves\ThreeOpt\PreventReaddDeleteThreeOptTabuMoveEvaluator.cs" />
    113     <Compile Include="Moves\ThreeOpt\StochasticThreeOptSingleMoveGenerator.cs" />
    114110    <Compile Include="Moves\ThreeOpt\Insertion\ExhaustiveInsertionMoveGenerator.cs">
    115111      <SubType>Code</SubType>
    116112    </Compile>
     113    <Compile Include="Moves\ThreeOpt\PreventDeleteThreeOptTabuMoveEvaluator.cs">
     114      <SubType>Code</SubType>
     115    </Compile>
     116    <Compile Include="Moves\ThreeOpt\PreventReaddDeleteThreeOptTabuMoveEvaluator.cs">
     117      <SubType>Code</SubType>
     118    </Compile>
     119    <Compile Include="Moves\ThreeOpt\PreventReaddThreeOptTabuMoveEvaluator.cs">
     120      <SubType>Code</SubType>
     121    </Compile>
    117122    <Compile Include="Moves\ThreeOpt\StochasticThreeOptMultiMoveGenerator.cs">
    118123      <SubType>Code</SubType>
    119124    </Compile>
     125    <Compile Include="Moves\ThreeOpt\StochasticThreeOptSingleMoveGenerator.cs">
     126      <SubType>Code</SubType>
     127    </Compile>
    120128    <Compile Include="Moves\ThreeOpt\ThreeOptMove.cs">
    121129      <SubType>Code</SubType>
     
    127135      <SubType>Code</SubType>
    128136    </Compile>
    129     <Compile Include="Moves\ThreeOpt\ThreeOptTabuMoveAttribute.cs" />
    130     <Compile Include="Moves\ThreeOpt\ThreeOptTabuMoveMaker.cs" />
    131     <Compile Include="Moves\TwoOpt\PreventDeleteTwoOptTabuMoveEvaluator.cs" />
    132     <Compile Include="Moves\TwoOpt\PreventReaddTwoOptTabuMoveEvaluator.cs" />
    133     <Compile Include="Moves\TwoOpt\StochasticTwoOptSingleMoveGenerator.cs" />
     137    <Compile Include="Moves\ThreeOpt\ThreeOptTabuMoveAttribute.cs">
     138      <SubType>Code</SubType>
     139    </Compile>
     140    <Compile Include="Moves\ThreeOpt\ThreeOptTabuMoveMaker.cs">
     141      <SubType>Code</SubType>
     142    </Compile>
     143    <Compile Include="Moves\TwoIndexMove.cs">
     144      <SubType>Code</SubType>
     145    </Compile>
    134146    <Compile Include="Moves\TwoOpt\ExhaustiveTwoOptMoveGenerator.cs">
    135147      <SubType>Code</SubType>
    136148    </Compile>
    137     <Compile Include="Moves\TwoIndexMove.cs">
    138       <SubType>Code</SubType>
    139     </Compile>
    140     <Compile Include="Moves\TwoOpt\StochasticTwoOptMultiMoveGenerator.cs" />
     149    <Compile Include="Moves\TwoOpt\PreventDeleteTwoOptTabuMoveEvaluator.cs">
     150      <SubType>Code</SubType>
     151    </Compile>
     152    <Compile Include="Moves\TwoOpt\PreventReaddDeleteTwoOptTabuMoveEvaluator.cs">
     153      <SubType>Code</SubType>
     154    </Compile>
     155    <Compile Include="Moves\TwoOpt\PreventReaddTwoOptTabuMoveEvaluator.cs">
     156      <SubType>Code</SubType>
     157    </Compile>
     158    <Compile Include="Moves\TwoOpt\StochasticTwoOptMultiMoveGenerator.cs">
     159      <SubType>Code</SubType>
     160    </Compile>
     161    <Compile Include="Moves\TwoOpt\StochasticTwoOptSingleMoveGenerator.cs">
     162      <SubType>Code</SubType>
     163    </Compile>
    141164    <Compile Include="Moves\TwoOpt\TwoOptMove.cs">
    142165      <SubType>Code</SubType>
    143166    </Compile>
    144     <Compile Include="Moves\TwoOpt\TwoOptMoveGenerator.cs" />
     167    <Compile Include="Moves\TwoOpt\TwoOptMoveGenerator.cs">
     168      <SubType>Code</SubType>
     169    </Compile>
    145170    <Compile Include="Moves\TwoOpt\TwoOptMoveMaker.cs">
    146171      <SubType>Code</SubType>
    147172    </Compile>
    148     <Compile Include="Moves\TwoOpt\TwoOptTabuMoveAttribute.cs" />
    149     <Compile Include="Moves\TwoOpt\PreventReaddDeleteTwoOptTabuMoveEvaluator.cs" />
    150     <Compile Include="Moves\TwoOpt\TwoOptTabuMoveMaker.cs" />
     173    <Compile Include="Moves\TwoOpt\TwoOptTabuMoveAttribute.cs">
     174      <SubType>Code</SubType>
     175    </Compile>
     176    <Compile Include="Moves\TwoOpt\TwoOptTabuMoveMaker.cs">
     177      <SubType>Code</SubType>
     178    </Compile>
    151179    <Compile Include="PermutationManipulator.cs" />
    152180    <Compile Include="PermutationCrossover.cs" />
    153181    <Compile Include="Permutation.cs" />
     182    <Compile Include="PermutationType.cs" />
     183    <Compile Include="PermutationTypes.cs" />
    154184    <Compile Include="Properties\AssemblyInfo.cs" />
    155185  </ItemGroup>
  • trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Interfaces/IPermutationCreator.cs

    r3053 r3231  
    3131    IValueLookupParameter<IntValue> LengthParameter { get; }
    3232    ILookupParameter<Permutation> PermutationParameter { get; }
     33    IValueParameter<PermutationType> PermutationTypeParameter { get; }
    3334  }
    3435}
  • trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Permutation.cs

    r3160 r3231  
    2525
    2626namespace HeuristicLab.Encodings.PermutationEncoding {
     27  [Item("Permutation", "Represents a permutation of integer values.")]
    2728  [StorableClass]
    28   [Item("Permutation", "Represents a permutation of integer values.")]
    2929  public class Permutation : IntArray {
    30     public Permutation() : base() { }
    31     public Permutation(int length)
     30    [Storable]
     31    private PermutationTypes permutationType;
     32    /// <summary>
     33    /// Gets the type of the permutation (see <see cref="PermutationType"/>).
     34    /// </summary>
     35    public PermutationTypes PermutationType {
     36      get { return permutationType; }
     37    }
     38
     39    public Permutation() : base() {
     40      permutationType = PermutationTypes.RelativeUndirected;
     41    }
     42    public Permutation(PermutationTypes type) : base() {
     43      permutationType = type;
     44    }
     45
     46    public Permutation(PermutationTypes type, int length)
    3247      : base(length) {
    3348      for (int i = 0; i < length; i++)
    3449        this[i] = i;
     50      permutationType = type;
    3551    }
    36     public Permutation(int length, IRandom random)
    37       : this(length) {
     52    public Permutation(PermutationTypes type, int length, IRandom random)
     53      : this(type, length) {
    3854      Randomize(random);
    3955    }
    40     public Permutation(int[] elements) : base(elements) { }
    41     public Permutation(IntArray elements)
    42       : this(elements.Length) {
     56    public Permutation(PermutationTypes type, int[] elements) : base(elements) {
     57      permutationType = type;
     58    }
     59    public Permutation(PermutationTypes type, IntArray elements) : this(type, elements.Length) {
    4360      for (int i = 0; i < array.Length; i++)
    4461        array[i] = elements[i];
     
    4663
    4764    public override IDeepCloneable Clone(Cloner cloner) {
    48       Permutation clone = new Permutation(array);
     65      Permutation clone = new Permutation(permutationType, array);
    4966      cloner.RegisterClonedObject(this, clone);
    5067      return clone;
  • trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/CosaCrossoverTest.cs

    r3063 r3231  
    9393      try {
    9494        target.Cross(random, new ItemArray<Permutation>(new Permutation[] {
    95           new Permutation(4), new Permutation(4), new Permutation(4)}));
     95          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
    9696      } catch (System.InvalidOperationException) {
    9797        exceptionFired = true;
     
    110110      random.Reset();
    111111      random.IntNumbers = new int[] { 1 };
    112       parent1 = new Permutation(new int[] { 0, 1, 5, 2, 4, 3 });
     112      parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 5, 2, 4, 3 });
    113113      Assert.IsTrue(parent1.Validate());
    114       parent2 = new Permutation(new int[] { 3, 0, 2, 1, 4, 5 });
     114      parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 3, 0, 2, 1, 4, 5 });
    115115      Assert.IsTrue(parent2.Validate());
    116       expected = new Permutation(new int[] { 0, 1, 4, 2, 5, 3 });
     116      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 4, 2, 5, 3 });
    117117      Assert.IsTrue(expected.Validate());
    118118      actual = CosaCrossover.Apply(random, parent1, parent2);
     
    122122      random.Reset();
    123123      random.IntNumbers = new int[] { 4 };
    124       parent1 = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
     124      parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
    125125      Assert.IsTrue(parent1.Validate());
    126       parent2 = new Permutation(new int[] { 1, 3, 5, 7, 6, 4, 2, 0 });
     126      parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 1, 3, 5, 7, 6, 4, 2, 0 });
    127127      Assert.IsTrue(parent2.Validate());
    128       expected = new Permutation(new int[] { 7, 6, 5, 3, 4, 2, 1, 0 });
     128      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 7, 6, 5, 3, 4, 2, 1, 0 });
    129129      Assert.IsTrue(expected.Validate());
    130130      actual = CosaCrossover.Apply(random, parent1, parent2);
     
    134134      random.Reset();
    135135      random.IntNumbers = new int[] { 5 };
    136       parent1 = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
     136      parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
    137137      Assert.IsTrue(parent1.Validate());
    138       parent2 = new Permutation(new int[] { 4, 3, 5, 1, 0, 9, 7, 2, 8, 6 });
     138      parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 4, 3, 5, 1, 0, 9, 7, 2, 8, 6 });
    139139      Assert.IsTrue(parent2.Validate());
    140       expected = new Permutation(new int[] { 7, 6, 2, 3, 4, 5, 1, 0, 9, 8 });
     140      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 7, 6, 2, 3, 4, 5, 1, 0, 9, 8 });
    141141      Assert.IsTrue(expected.Validate());
    142142      actual = CosaCrossover.Apply(random, parent1, parent2);
     
    148148      bool exceptionFired = false;
    149149      try {
    150         CosaCrossover.Apply(random, new Permutation(8), new Permutation(6));
     150        CosaCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
    151151      } catch (System.ArgumentException) {
    152152        exceptionFired = true;
  • trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/CyclicCrossover2Test.cs

    r3063 r3231  
    7171      try {
    7272        target.Cross(random, new ItemArray<Permutation>(new Permutation[] {
    73           new Permutation(4), new Permutation(4), new Permutation(4)}));
     73          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
    7474      } catch (System.InvalidOperationException) {
    7575        exceptionFired = true;
     
    8888      random.Reset();
    8989      random.IntNumbers = new int[] { 0 };
    90       parent1 = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
     90      parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
    9191      Assert.IsTrue(parent1.Validate());
    92       parent2 = new Permutation(new int[] { 2, 5, 6, 0, 7, 1, 3, 8, 4, 9 });
     92      parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 2, 5, 6, 0, 7, 1, 3, 8, 4, 9 });
    9393      Assert.IsTrue(parent2.Validate());
    94       expected = new Permutation(new int[] { 0, 5, 2, 3, 7, 1, 6, 8, 4, 9 });
     94      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 5, 2, 3, 7, 1, 6, 8, 4, 9 });
    9595      Assert.IsTrue(expected.Validate());
    9696      actual = CyclicCrossover2.Apply(random, parent1, parent2);
     
    102102      bool exceptionFired = false;
    103103      try {
    104         CyclicCrossover.Apply(random, new Permutation(8), new Permutation(6));
     104        CyclicCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
    105105      } catch (System.ArgumentException) {
    106106        exceptionFired = true;
  • trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/CyclicCrossoverTest.cs

    r3063 r3231  
    9393      try {
    9494        target.Cross(random, new ItemArray<Permutation>(new Permutation[] {
    95           new Permutation(4), new Permutation(4), new Permutation(4)}));
     95          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
    9696      }
    9797      catch (System.InvalidOperationException) {
     
    111111      random.Reset();
    112112      random.DoubleNumbers = new double[] { 0.9 };
    113       parent1 = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
     113      parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
    114114      Assert.IsTrue(parent1.Validate());
    115       parent2 = new Permutation(new int[] { 1, 3, 5, 7, 6, 4, 2, 0 });
     115      parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 1, 3, 5, 7, 6, 4, 2, 0 });
    116116      Assert.IsTrue(parent2.Validate());
    117       expected = new Permutation(new int[] { 0, 1, 5, 3, 6, 4, 2, 7 });
     117      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 5, 3, 6, 4, 2, 7 });
    118118      Assert.IsTrue(expected.Validate());
    119119      actual = CyclicCrossover.Apply(random, parent1, parent2);
     
    125125      bool exceptionFired = false;
    126126      try {
    127         CyclicCrossover.Apply(random, new Permutation(8), new Permutation(6));
     127        CyclicCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
    128128      }
    129129      catch (System.ArgumentException) {
  • trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/EdgeRecombinationCrossoverTest.cs

    r3063 r3231  
    9393      try {
    9494        target.Cross(random, new ItemArray<Permutation>(new Permutation[] {
    95           new Permutation(4), new Permutation(4), new Permutation(4)}));
     95          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
    9696      }
    9797      catch (System.InvalidOperationException) {
     
    112112      random.IntNumbers = new int[] { 0 };
    113113      random.DoubleNumbers = new double[] { 0.5, 0, 0, 0 };
    114       parent1 = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 });
     114      parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 });
    115115      Assert.IsTrue(parent1.Validate());
    116       parent2 = new Permutation(new int[] { 8, 2, 6, 7, 1, 5, 4, 0, 3 });
     116      parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 8, 2, 6, 7, 1, 5, 4, 0, 3 });
    117117      Assert.IsTrue(parent2.Validate());
    118       expected = new Permutation(new int[] { 0, 4, 5, 1, 7, 6, 2, 8, 3 });
     118      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 4, 5, 1, 7, 6, 2, 8, 3 });
    119119      Assert.IsTrue(expected.Validate());
    120120      actual = EdgeRecombinationCrossover.Apply(random, parent1, parent2);
     
    126126      bool exceptionFired = false;
    127127      try {
    128         EdgeRecombinationCrossover.Apply(random, new Permutation(8), new Permutation(6));
     128        EdgeRecombinationCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
    129129      }
    130130      catch (System.ArgumentException) {
  • trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/InsertionManipulatorTest.cs

    r3053 r3231  
    8888      random.Reset();
    8989      random.IntNumbers = new int[] { 3, 6 };
    90       parent = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
     90      parent = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
    9191      Assert.IsTrue(parent.Validate());
    9292     
    93       expected = new Permutation(new int[] { 0, 1, 2, 4, 5, 6, 3, 7 });
     93      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 4, 5, 6, 3, 7 });
    9494      Assert.IsTrue(expected.Validate());
    9595      InsertionManipulator.Apply(random, parent);
  • trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/InversionManipulatorTest.cs

    r3053 r3231  
    8888      random.Reset();
    8989      random.IntNumbers = new int[] { 1, 4 };
    90       parent = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 });
     90      parent = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 });
    9191      Assert.IsTrue(parent.Validate());
    9292     
    93       expected = new Permutation(new int[] { 0, 4, 3, 2, 1, 5, 6, 7, 8 });
     93      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 4, 3, 2, 1, 5, 6, 7, 8 });
    9494      Assert.IsTrue(expected.Validate());
    9595      InversionManipulator.Apply(random, parent);
  • trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/MaximalPreservativeCrossoverTest.cs

    r3063 r3231  
    9393      try {
    9494        target.Cross(random, new ItemArray<Permutation>(new Permutation[] {
    95           new Permutation(4), new Permutation(4), new Permutation(4)}));
     95          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
    9696      }
    9797      catch (System.InvalidOperationException) {
     
    111111      random.Reset();
    112112      random.IntNumbers = new int[] { 3, 2 };
    113       parent1 = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
     113      parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
    114114      Assert.IsTrue(parent1.Validate());
    115       parent2 = new Permutation(new int[] { 1, 3, 5, 7, 6, 4, 2, 0 });
     115      parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 1, 3, 5, 7, 6, 4, 2, 0 });
    116116      Assert.IsTrue(parent2.Validate());
    117       expected = new Permutation(new int[] { 1, 0, 2, 3, 4, 5, 7, 6 });
     117      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 1, 0, 2, 3, 4, 5, 7, 6 });
    118118      Assert.IsTrue(expected.Validate());
    119119      actual = MaximalPreservativeCrossover.Apply(random, parent1, parent2);
     
    125125      bool exceptionFired = false;
    126126      try {
    127         MaximalPreservativeCrossover.Apply(random, new Permutation(8), new Permutation(6));
     127        MaximalPreservativeCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
    128128      }
    129129      catch (System.ArgumentException) {
  • trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/OrderBasedCrossoverTest.cs

    r3063 r3231  
    9393      try {
    9494        target.Cross(random, new ItemArray<Permutation>(new Permutation[] {
    95           new Permutation(4), new Permutation(4), new Permutation(4)}));
     95          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
    9696      } catch (System.InvalidOperationException) {
    9797        exceptionFired = true;
     
    110110      random.Reset();
    111111      random.IntNumbers = new int[] { 3, 5, 2, 1 };
    112       parent1 = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
     112      parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
    113113      Assert.IsTrue(parent1.Validate());
    114       parent2 = new Permutation(new int[] { 1, 3, 5, 7, 6, 4, 2, 0 });
     114      parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 1, 3, 5, 7, 6, 4, 2, 0 });
    115115      Assert.IsTrue(parent2.Validate());
    116       expected = new Permutation(new int[] { 1, 3, 2, 7, 6, 4, 5, 0 });
     116      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 1, 3, 2, 7, 6, 4, 5, 0 });
    117117      actual = OrderBasedCrossover.Apply(random, parent1, parent2);
    118118      Assert.IsTrue(actual.Validate());
     
    122122      bool exceptionFired = false;
    123123      try {
    124         OrderBasedCrossover.Apply(random, new Permutation(8), new Permutation(6));
     124        OrderBasedCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
    125125      } catch (System.ArgumentException) {
    126126        exceptionFired = true;
  • trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/OrderCrossover2Test.cs

    r3063 r3231  
    7070      try {
    7171        target.Cross(random, new ItemArray<Permutation>(new Permutation[] {
    72           new Permutation(4), new Permutation(4), new Permutation(4)}));
     72          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
    7373      } catch (System.InvalidOperationException) {
    7474        exceptionFired = true;
     
    8787      random.Reset();
    8888      random.IntNumbers = new int[] { 5, 7 };
    89       parent1 = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
     89      parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
    9090      Assert.IsTrue(parent1.Validate());
    91       parent2 = new Permutation(new int[] { 2, 5, 6, 0, 9, 1, 3, 8, 4, 7 });
     91      parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 2, 5, 6, 0, 9, 1, 3, 8, 4, 7 });
    9292      Assert.IsTrue(parent2.Validate());
    93       expected = new Permutation(new int[] { 2, 0, 9, 1, 3, 5, 6, 7, 8, 4 });
     93      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 2, 0, 9, 1, 3, 5, 6, 7, 8, 4 });
    9494      Assert.IsTrue(expected.Validate());
    9595      actual = OrderCrossover2.Apply(random, parent1, parent2);
     
    101101      bool exceptionFired = false;
    102102      try {
    103         OrderCrossover.Apply(random, new Permutation(8), new Permutation(6));
     103        OrderCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
    104104      } catch (System.ArgumentException) {
    105105        exceptionFired = true;
  • trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/OrderCrossoverTest.cs

    r3063 r3231  
    9393      try {
    9494        target.Cross(random, new ItemArray<Permutation>(new Permutation[] {
    95           new Permutation(4), new Permutation(4), new Permutation(4)}));
     95          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
    9696      } catch (System.InvalidOperationException) {
    9797        exceptionFired = true;
     
    110110      random.Reset();
    111111      random.IntNumbers = new int[] { 3, 6 };
    112       parent1 = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 });
     112      parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 });
    113113      Assert.IsTrue(parent1.Validate());
    114       parent2 = new Permutation(new int[] { 8, 2, 6, 7, 1, 5, 4, 0, 3 });
     114      parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 8, 2, 6, 7, 1, 5, 4, 0, 3 });
    115115      Assert.IsTrue(parent2.Validate());
    116       expected = new Permutation(new int[] { 2, 7, 1, 3, 4, 5, 6, 0, 8 });
     116      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 2, 7, 1, 3, 4, 5, 6, 0, 8 });
    117117      Assert.IsTrue(expected.Validate());
    118118      actual = OrderCrossover.Apply(random, parent1, parent2);
     
    122122      random.Reset();
    123123      random.IntNumbers = new int[] { 2, 4 };
    124       parent1 = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
     124      parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
    125125      Assert.IsTrue(parent1.Validate());
    126       parent2 = new Permutation(new int[] { 1, 3, 5, 7, 6, 4, 2, 0 });
     126      parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 1, 3, 5, 7, 6, 4, 2, 0 });
    127127      Assert.IsTrue(parent2.Validate());
    128       expected = new Permutation(new int[] { 7, 6, 2, 3, 4, 0, 1, 5 });
     128      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 7, 6, 2, 3, 4, 0, 1, 5 });
    129129      actual = OrderCrossover.Apply(random, parent1, parent2);
    130130      Assert.IsTrue(actual.Validate());
     
    133133      random.Reset();
    134134      random.IntNumbers = new int[] { 2, 5 };
    135       parent1 = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 });
     135      parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 });
    136136      Assert.IsTrue(parent1.Validate());
    137       parent2 = new Permutation(new int[] { 7, 3, 0, 4, 8, 2, 5, 1, 6 });
     137      parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 7, 3, 0, 4, 8, 2, 5, 1, 6 });
    138138      Assert.IsTrue(parent2.Validate());
    139       expected = new Permutation(new int[] { 0, 8, 2, 3, 4, 5, 1, 6, 7 });
     139      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 8, 2, 3, 4, 5, 1, 6, 7 });
    140140      Assert.IsTrue(expected.Validate());
    141141      actual = OrderCrossover.Apply(random, parent1, parent2);
     
    145145      random.Reset();
    146146      random.IntNumbers = new int[] { 0, 5 };
    147       parent1 = new Permutation(new int[] { 2, 1, 4, 3, 7, 8, 6, 0, 5, 9 });
     147      parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 2, 1, 4, 3, 7, 8, 6, 0, 5, 9 });
    148148      Assert.IsTrue(parent1.Validate());
    149       parent2 = new Permutation(new int[] { 5, 3, 4, 0, 9, 8, 2, 7, 1, 6 });
     149      parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 5, 3, 4, 0, 9, 8, 2, 7, 1, 6 });
    150150      Assert.IsTrue(parent2.Validate());
    151       expected = new Permutation(new int[] { 2, 1, 4, 3, 7, 8, 6, 5, 0, 9 });
     151      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 2, 1, 4, 3, 7, 8, 6, 5, 0, 9 });
    152152      Assert.IsTrue(expected.Validate());
    153153      actual = OrderCrossover.Apply(random, parent1, parent2);
     
    157157      random.Reset();
    158158      random.IntNumbers = new int[] { 6, 9 };
    159       expected = new Permutation(new int[] { 3, 4, 8, 2, 7, 1, 6, 0, 5, 9 });
     159      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 3, 4, 8, 2, 7, 1, 6, 0, 5, 9 });
    160160      Assert.IsTrue(expected.Validate());
    161161      actual = OrderCrossover.Apply(random, parent1, parent2);
     
    165165      random.Reset();
    166166      random.IntNumbers = new int[] { 0, 9 };
    167       expected = new Permutation(new int[] { 2, 1, 4, 3, 7, 8, 6, 0, 5, 9 });
     167      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 2, 1, 4, 3, 7, 8, 6, 0, 5, 9 });
    168168      Assert.IsTrue(expected.Validate());
    169169      actual = OrderCrossover.Apply(random, parent1, parent2);
     
    175175      bool exceptionFired = false;
    176176      try {
    177         OrderCrossover.Apply(random, new Permutation(8), new Permutation(6));
     177        OrderCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
    178178      } catch (System.ArgumentException) {
    179179        exceptionFired = true;
  • trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/PartiallyMatchedCrossoverTest.cs

    r3063 r3231  
    9393      try {
    9494        target.Cross(random, new ItemArray<Permutation>(new Permutation[] {
    95           new Permutation(4), new Permutation(4), new Permutation(4)}));
     95          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
    9696      }
    9797      catch (System.InvalidOperationException) {
     
    111111      random.Reset();
    112112      random.IntNumbers = new int[] { 3, 5 };
    113       parent1 = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
     113      parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
    114114      Assert.IsTrue(parent1.Validate());
    115       parent2 = new Permutation(new int[] { 2, 6, 4, 0, 5, 7, 1, 3 });
     115      parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 2, 6, 4, 0, 5, 7, 1, 3 });
    116116      Assert.IsTrue(parent2.Validate());
    117       expected = new Permutation(new int[] { 2, 6, 7, 3, 4, 5, 1, 0 });
     117      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 2, 6, 7, 3, 4, 5, 1, 0 });
    118118      Assert.IsTrue(expected.Validate());
    119119      actual = PartiallyMatchedCrossover.Apply(random, parent1, parent2);
     
    123123      random.Reset();
    124124      random.IntNumbers = new int[] { 5, 7 };
    125       parent1 = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
     125      parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
    126126      Assert.IsTrue(parent1.Validate());
    127       parent2 = new Permutation(new int[] { 2, 5, 6, 0, 9, 1, 3, 8, 4, 7 });
     127      parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 2, 5, 6, 0, 9, 1, 3, 8, 4, 7 });
    128128      Assert.IsTrue(parent2.Validate());
    129       expected = new Permutation(new int[] { 2, 1, 3, 0, 9, 5, 6, 7, 4, 8 });
     129      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 2, 1, 3, 0, 9, 5, 6, 7, 4, 8 });
    130130      Assert.IsTrue(expected.Validate());
    131131      actual = PartiallyMatchedCrossover.Apply(random, parent1, parent2);
     
    137137      bool exceptionFired = false;
    138138      try {
    139         PartiallyMatchedCrossover.Apply(random, new Permutation(8), new Permutation(6));
     139        PartiallyMatchedCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
    140140      }
    141141      catch (System.ArgumentException) {
  • trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/PositionBasedCrossoverTest.cs

    r3063 r3231  
    9494      try {
    9595        target.Cross(random, new ItemArray<Permutation>(new Permutation[] {
    96           new Permutation(4), new Permutation(4), new Permutation(4) }));
     96          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4) }));
    9797      }
    9898      catch (System.InvalidOperationException) {
     
    114114      random.Reset();
    115115      random.IntNumbers = new int[] { 3, 1, 2, 5 };
    116       parent1 = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
     116      parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
    117117      Assert.IsTrue(parent1.Validate());
    118       parent2 = new Permutation(new int[] { 1, 3, 5, 7, 6, 4, 2, 0 });
     118      parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 1, 3, 5, 7, 6, 4, 2, 0 });
    119119      Assert.IsTrue(parent2.Validate());
    120120
    121       expected = new Permutation(new int[] { 0, 3, 5, 1, 2, 4, 6, 7 });
     121      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 3, 5, 1, 2, 4, 6, 7 });
    122122      Assert.IsTrue(expected.Validate());
    123123      actual = PositionBasedCrossover.Apply(random, parent1, parent2);
     
    129129      bool exceptionFired = false;
    130130      try {
    131         PositionBasedCrossover.Apply(random, new Permutation(8), new Permutation(6));
     131        PositionBasedCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
    132132      } catch (System.ArgumentException) {
    133133        exceptionFired = true;
  • trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/ScrambleManipulatorTest.cs

    r3053 r3231  
    8888      random.Reset();
    8989      random.IntNumbers = new int[] { 3, 6, 1, 1, 1, 0 };
    90       parent = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
     90      parent = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
    9191      Assert.IsTrue(parent.Validate());
    9292     
    93       expected = new Permutation(new int[] { 0, 1, 2, 4, 5, 6, 3, 7 });
     93      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 4, 5, 6, 3, 7 });
    9494      Assert.IsTrue(expected.Validate());
    9595      ScrambleManipulator.Apply(random, parent);
  • trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/Swap2ManipulatorTest.cs

    r3053 r3231  
    8888      random.Reset();
    8989      random.IntNumbers = new int[] { 1, 4 };
    90       parent = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 });
     90      parent = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 });
    9191      Assert.IsTrue(parent.Validate());
    9292
    93       expected = new Permutation(new int[] { 0, 4, 2, 3, 1, 5, 6, 7, 8 });
     93      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 4, 2, 3, 1, 5, 6, 7, 8 });
    9494      Assert.IsTrue(expected.Validate());
    9595      Swap2Manipulator.Apply(random, parent);
  • trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/Swap3ManipulatorTest.cs

    r3053 r3231  
    8989      random.IntNumbers = new int[] { 1, 3, 6 };
    9090      random.DoubleNumbers = new double[] { 0 };
    91       parent = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 });
     91      parent = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 });
    9292      Assert.IsTrue(parent.Validate());
    9393
    94       expected = new Permutation(new int[] { 0, 3, 2, 6, 4, 5, 1, 7, 8 });
     94      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 3, 2, 6, 4, 5, 1, 7, 8 });
    9595      Assert.IsTrue(expected.Validate());
    9696      Swap3Manipulator.Apply(random, parent);
  • trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/TranslocationInversionManipulatorTest.cs

    r3053 r3231  
    8888      random.Reset();
    8989      random.IntNumbers = new int[] { 2, 4, 4 };
    90       parent = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
     90      parent = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
    9191      Assert.IsTrue(parent.Validate());
    9292     
    93       expected = new Permutation(new int[] { 0, 1, 5, 6, 4, 3, 2, 7 });
     93      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 5, 6, 4, 3, 2, 7 });
    9494      Assert.IsTrue(expected.Validate());
    9595      TranslocationInversionManipulator.Apply(random, parent);
  • trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/TranslocationManipulatorTest.cs

    r3053 r3231  
    8888      random.Reset();
    8989      random.IntNumbers = new int[] { 2, 4, 4 };
    90       parent = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
     90      parent = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
    9191      Assert.IsTrue(parent.Validate());
    9292     
    93       expected = new Permutation(new int[] { 0, 1, 5, 6, 2, 3, 4, 7 });
     93      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 5, 6, 2, 3, 4, 7 });
    9494      Assert.IsTrue(expected.Validate());
    9595      TranslocationManipulator.Apply(random, parent);
  • trunk/sources/HeuristicLab.Problems.TravelingSalesman/3.3/TravelingSalesmanProblem.cs

    r3209 r3231  
    194194        tourParser.Parse();
    195195        if (tourParser.Tour.Length != Coordinates.Rows) throw new InvalidDataException("Length of optimal tour is not equal to number of cities.");
    196         BestKnownSolution = new Permutation(tourParser.Tour);
     196        BestKnownSolution = new Permutation(PermutationTypes.RelativeUndirected, tourParser.Tour);
    197197      }
    198198    }
     
    326326    private void ParameterizeSolutionCreator() {
    327327      SolutionCreator.LengthParameter.Value = new IntValue(Coordinates.Rows);
     328      SolutionCreator.PermutationTypeParameter.Value = new PermutationType(PermutationTypes.RelativeUndirected);
    328329    }
    329330    private void ParameterizeEvaluator() {
Note: See TracChangeset for help on using the changeset viewer.