Index: trunk/sources/HeuristicLab 3.3.sln
===================================================================
--- trunk/sources/HeuristicLab 3.3.sln	(revision 3047)
+++ trunk/sources/HeuristicLab 3.3.sln	(revision 3048)
@@ -46,4 +46,5 @@
 		{662B4B15-8F4D-4AE5-B3EB-D91C215F5AF2} = {662B4B15-8F4D-4AE5-B3EB-D91C215F5AF2}
 		{E226881D-315F-423D-B419-A766FE0D8685} = {E226881D-315F-423D-B419-A766FE0D8685}
+		{E61C8E23-B5ED-4B6B-8DD1-670537B57E79} = {E61C8E23-B5ED-4B6B-8DD1-670537B57E79}
 		{14AB8D24-25BC-400C-A846-4627AA945192} = {14AB8D24-25BC-400C-A846-4627AA945192}
 		{C36BD924-A541-4A00-AFA8-41701378DDC5} = {C36BD924-A541-4A00-AFA8-41701378DDC5}
@@ -62,4 +63,5 @@
 		{2D4E4565-3ED9-4BEB-AE75-39D871843D24} = {2D4E4565-3ED9-4BEB-AE75-39D871843D24}
 		{56F9106A-079F-4C61-92F6-86A84C2D84B7} = {56F9106A-079F-4C61-92F6-86A84C2D84B7}
+		{A400DB6D-A343-49A8-B6F8-C8927112A1AE} = {A400DB6D-A343-49A8-B6F8-C8927112A1AE}
 		{DC3D7072-7999-4719-B65D-3997744D5DC1} = {DC3D7072-7999-4719-B65D-3997744D5DC1}
 		{F42F3576-7233-4B28-90F7-36AE15F30F92} = {F42F3576-7233-4B28-90F7-36AE15F30F92}
@@ -67,7 +69,9 @@
 		{57F38579-409D-4DD8-AB19-3F2C4A665126} = {57F38579-409D-4DD8-AB19-3F2C4A665126}
 		{4ABA047D-46DD-4608-9E4A-41C5F92FDBB1} = {4ABA047D-46DD-4608-9E4A-41C5F92FDBB1}
+		{B622D391-FB36-4E3D-B5F6-AEDF237DE890} = {B622D391-FB36-4E3D-B5F6-AEDF237DE890}
 		{BF7D9494-A586-457B-8DF9-ED599F9E6A71} = {BF7D9494-A586-457B-8DF9-ED599F9E6A71}
 		{600287A3-8714-453E-B875-A05F3EB72315} = {600287A3-8714-453E-B875-A05F3EB72315}
 		{887425B4-4348-49ED-A457-B7D2C26DDBF9} = {887425B4-4348-49ED-A457-B7D2C26DDBF9}
+		{5BF9C5B5-8DF3-414B-A4D6-0DD1EF456C8A} = {5BF9C5B5-8DF3-414B-A4D6-0DD1EF456C8A}
 		{F4539FB6-4708-40C9-BE64-0A1390AEA197} = {F4539FB6-4708-40C9-BE64-0A1390AEA197}
 		{958B43BC-CC5C-4FA2-8628-2B3B01D890B6} = {958B43BC-CC5C-4FA2-8628-2B3B01D890B6}
@@ -812,34 +816,50 @@
 		{5BF9C5B5-8DF3-414B-A4D6-0DD1EF456C8A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{5BF9C5B5-8DF3-414B-A4D6-0DD1EF456C8A}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{5BF9C5B5-8DF3-414B-A4D6-0DD1EF456C8A}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{5BF9C5B5-8DF3-414B-A4D6-0DD1EF456C8A}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{5BF9C5B5-8DF3-414B-A4D6-0DD1EF456C8A}.Debug|x64.ActiveCfg = Debug|x64
+		{5BF9C5B5-8DF3-414B-A4D6-0DD1EF456C8A}.Debug|x64.Build.0 = Debug|x64
+		{5BF9C5B5-8DF3-414B-A4D6-0DD1EF456C8A}.Debug|x86.ActiveCfg = Debug|x86
+		{5BF9C5B5-8DF3-414B-A4D6-0DD1EF456C8A}.Debug|x86.Build.0 = Debug|x86
 		{5BF9C5B5-8DF3-414B-A4D6-0DD1EF456C8A}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{5BF9C5B5-8DF3-414B-A4D6-0DD1EF456C8A}.Release|Any CPU.Build.0 = Release|Any CPU
-		{5BF9C5B5-8DF3-414B-A4D6-0DD1EF456C8A}.Release|x64.ActiveCfg = Release|Any CPU
-		{5BF9C5B5-8DF3-414B-A4D6-0DD1EF456C8A}.Release|x86.ActiveCfg = Release|Any CPU
+		{5BF9C5B5-8DF3-414B-A4D6-0DD1EF456C8A}.Release|x64.ActiveCfg = Release|x64
+		{5BF9C5B5-8DF3-414B-A4D6-0DD1EF456C8A}.Release|x64.Build.0 = Release|x64
+		{5BF9C5B5-8DF3-414B-A4D6-0DD1EF456C8A}.Release|x86.ActiveCfg = Release|x86
+		{5BF9C5B5-8DF3-414B-A4D6-0DD1EF456C8A}.Release|x86.Build.0 = Release|x86
 		{B622D391-FB36-4E3D-B5F6-AEDF237DE890}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{B622D391-FB36-4E3D-B5F6-AEDF237DE890}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{B622D391-FB36-4E3D-B5F6-AEDF237DE890}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{B622D391-FB36-4E3D-B5F6-AEDF237DE890}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{B622D391-FB36-4E3D-B5F6-AEDF237DE890}.Debug|x64.ActiveCfg = Debug|x64
+		{B622D391-FB36-4E3D-B5F6-AEDF237DE890}.Debug|x64.Build.0 = Debug|x64
+		{B622D391-FB36-4E3D-B5F6-AEDF237DE890}.Debug|x86.ActiveCfg = Debug|x86
+		{B622D391-FB36-4E3D-B5F6-AEDF237DE890}.Debug|x86.Build.0 = Debug|x86
 		{B622D391-FB36-4E3D-B5F6-AEDF237DE890}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{B622D391-FB36-4E3D-B5F6-AEDF237DE890}.Release|Any CPU.Build.0 = Release|Any CPU
-		{B622D391-FB36-4E3D-B5F6-AEDF237DE890}.Release|x64.ActiveCfg = Release|Any CPU
-		{B622D391-FB36-4E3D-B5F6-AEDF237DE890}.Release|x86.ActiveCfg = Release|Any CPU
+		{B622D391-FB36-4E3D-B5F6-AEDF237DE890}.Release|x64.ActiveCfg = Release|x64
+		{B622D391-FB36-4E3D-B5F6-AEDF237DE890}.Release|x64.Build.0 = Release|x64
+		{B622D391-FB36-4E3D-B5F6-AEDF237DE890}.Release|x86.ActiveCfg = Release|x86
+		{B622D391-FB36-4E3D-B5F6-AEDF237DE890}.Release|x86.Build.0 = Release|x86
 		{E61C8E23-B5ED-4B6B-8DD1-670537B57E79}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{E61C8E23-B5ED-4B6B-8DD1-670537B57E79}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{E61C8E23-B5ED-4B6B-8DD1-670537B57E79}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{E61C8E23-B5ED-4B6B-8DD1-670537B57E79}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{E61C8E23-B5ED-4B6B-8DD1-670537B57E79}.Debug|x64.ActiveCfg = Debug|x64
+		{E61C8E23-B5ED-4B6B-8DD1-670537B57E79}.Debug|x64.Build.0 = Debug|x64
+		{E61C8E23-B5ED-4B6B-8DD1-670537B57E79}.Debug|x86.ActiveCfg = Debug|x86
+		{E61C8E23-B5ED-4B6B-8DD1-670537B57E79}.Debug|x86.Build.0 = Debug|x86
 		{E61C8E23-B5ED-4B6B-8DD1-670537B57E79}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{E61C8E23-B5ED-4B6B-8DD1-670537B57E79}.Release|Any CPU.Build.0 = Release|Any CPU
-		{E61C8E23-B5ED-4B6B-8DD1-670537B57E79}.Release|x64.ActiveCfg = Release|Any CPU
-		{E61C8E23-B5ED-4B6B-8DD1-670537B57E79}.Release|x86.ActiveCfg = Release|Any CPU
+		{E61C8E23-B5ED-4B6B-8DD1-670537B57E79}.Release|x64.ActiveCfg = Release|x64
+		{E61C8E23-B5ED-4B6B-8DD1-670537B57E79}.Release|x64.Build.0 = Release|x64
+		{E61C8E23-B5ED-4B6B-8DD1-670537B57E79}.Release|x86.ActiveCfg = Release|x86
+		{E61C8E23-B5ED-4B6B-8DD1-670537B57E79}.Release|x86.Build.0 = Release|x86
 		{A400DB6D-A343-49A8-B6F8-C8927112A1AE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{A400DB6D-A343-49A8-B6F8-C8927112A1AE}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{A400DB6D-A343-49A8-B6F8-C8927112A1AE}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{A400DB6D-A343-49A8-B6F8-C8927112A1AE}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{A400DB6D-A343-49A8-B6F8-C8927112A1AE}.Debug|x64.ActiveCfg = Debug|x64
+		{A400DB6D-A343-49A8-B6F8-C8927112A1AE}.Debug|x64.Build.0 = Debug|x64
+		{A400DB6D-A343-49A8-B6F8-C8927112A1AE}.Debug|x86.ActiveCfg = Debug|x86
+		{A400DB6D-A343-49A8-B6F8-C8927112A1AE}.Debug|x86.Build.0 = Debug|x86
 		{A400DB6D-A343-49A8-B6F8-C8927112A1AE}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{A400DB6D-A343-49A8-B6F8-C8927112A1AE}.Release|Any CPU.Build.0 = Release|Any CPU
-		{A400DB6D-A343-49A8-B6F8-C8927112A1AE}.Release|x64.ActiveCfg = Release|Any CPU
-		{A400DB6D-A343-49A8-B6F8-C8927112A1AE}.Release|x86.ActiveCfg = Release|Any CPU
+		{A400DB6D-A343-49A8-B6F8-C8927112A1AE}.Release|x64.ActiveCfg = Release|x64
+		{A400DB6D-A343-49A8-B6F8-C8927112A1AE}.Release|x64.Build.0 = Release|x64
+		{A400DB6D-A343-49A8-B6F8-C8927112A1AE}.Release|x86.ActiveCfg = Release|x86
+		{A400DB6D-A343-49A8-B6F8-C8927112A1AE}.Release|x86.Build.0 = Release|x86
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
Index: trunk/sources/HeuristicLab.Algorithms.SGA/3.3/SGA.cs
===================================================================
--- trunk/sources/HeuristicLab.Algorithms.SGA/3.3/SGA.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Algorithms.SGA/3.3/SGA.cs	(revision 3048)
@@ -51,12 +51,12 @@
 
     #region Parameter Properties
-    private ValueParameter<IntData> SeedParameter {
-      get { return (ValueParameter<IntData>)Parameters["Seed"]; }
-    }
-    private ValueParameter<BoolData> SetSeedRandomlyParameter {
-      get { return (ValueParameter<BoolData>)Parameters["SetSeedRandomly"]; }
-    }
-    private ValueParameter<IntData> PopulationSizeParameter {
-      get { return (ValueParameter<IntData>)Parameters["PopulationSize"]; }
+    private ValueParameter<IntValue> SeedParameter {
+      get { return (ValueParameter<IntValue>)Parameters["Seed"]; }
+    }
+    private ValueParameter<BoolValue> SetSeedRandomlyParameter {
+      get { return (ValueParameter<BoolValue>)Parameters["SetSeedRandomly"]; }
+    }
+    private ValueParameter<IntValue> PopulationSizeParameter {
+      get { return (ValueParameter<IntValue>)Parameters["PopulationSize"]; }
     }
     private ConstrainedValueParameter<ISelector> SelectorParameter {
@@ -66,28 +66,28 @@
       get { return (ConstrainedValueParameter<ICrossover>)Parameters["Crossover"]; }
     }
-    private ValueParameter<DoubleData> MutationProbabilityParameter {
-      get { return (ValueParameter<DoubleData>)Parameters["MutationProbability"]; }
+    private ValueParameter<DoubleValue> MutationProbabilityParameter {
+      get { return (ValueParameter<DoubleValue>)Parameters["MutationProbability"]; }
     }
     private OptionalConstrainedValueParameter<IManipulator> MutatorParameter {
       get { return (OptionalConstrainedValueParameter<IManipulator>)Parameters["Mutator"]; }
     }
-    private ValueParameter<IntData> ElitesParameter {
-      get { return (ValueParameter<IntData>)Parameters["Elites"]; }
-    }
-    private ValueParameter<IntData> MaximumGenerationsParameter {
-      get { return (ValueParameter<IntData>)Parameters["MaximumGenerations"]; }
+    private ValueParameter<IntValue> ElitesParameter {
+      get { return (ValueParameter<IntValue>)Parameters["Elites"]; }
+    }
+    private ValueParameter<IntValue> MaximumGenerationsParameter {
+      get { return (ValueParameter<IntValue>)Parameters["MaximumGenerations"]; }
     }
     #endregion
 
     #region Properties
-    public IntData Seed {
+    public IntValue Seed {
       get { return SeedParameter.Value; }
       set { SeedParameter.Value = value; }
     }
-    public BoolData SetSeedRandomly {
+    public BoolValue SetSeedRandomly {
       get { return SetSeedRandomlyParameter.Value; }
       set { SetSeedRandomlyParameter.Value = value; }
     }
-    public IntData PopulationSize {
+    public IntValue PopulationSize {
       get { return PopulationSizeParameter.Value; }
       set { PopulationSizeParameter.Value = value; }
@@ -101,5 +101,5 @@
       set { CrossoverParameter.Value = value; }
     }
-    public DoubleData MutationProbability {
+    public DoubleValue MutationProbability {
       get { return MutationProbabilityParameter.Value; }
       set { MutationProbabilityParameter.Value = value; }
@@ -109,9 +109,9 @@
       set { MutatorParameter.Value = value; }
     }
-    public IntData Elites {
+    public IntValue Elites {
       get { return ElitesParameter.Value; }
       set { ElitesParameter.Value = value; }
     }
-    public IntData MaximumGenerations {
+    public IntValue MaximumGenerations {
       get { return MaximumGenerationsParameter.Value; }
       set { MaximumGenerationsParameter.Value = value; }
@@ -134,13 +134,13 @@
     public SGA()
       : base() {
-      Parameters.Add(new ValueParameter<IntData>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntData(0)));
-      Parameters.Add(new ValueParameter<BoolData>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolData(true)));
-      Parameters.Add(new ValueParameter<IntData>("PopulationSize", "The size of the population of solutions.", new IntData(100)));
+      Parameters.Add(new ValueParameter<IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
+      Parameters.Add(new ValueParameter<BoolValue>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
+      Parameters.Add(new ValueParameter<IntValue>("PopulationSize", "The size of the population of solutions.", new IntValue(100)));
       Parameters.Add(new ConstrainedValueParameter<ISelector>("Selector", "The operator used to select solutions for reproduction."));
       Parameters.Add(new ConstrainedValueParameter<ICrossover>("Crossover", "The operator used to cross solutions."));
-      Parameters.Add(new ValueParameter<DoubleData>("MutationProbability", "The probability that the mutation operator is applied on a solution.", new DoubleData(0.05)));
+      Parameters.Add(new ValueParameter<DoubleValue>("MutationProbability", "The probability that the mutation operator is applied on a solution.", new DoubleValue(0.05)));
       Parameters.Add(new OptionalConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions."));
-      Parameters.Add(new ValueParameter<IntData>("Elites", "The numer of elite solutions which are kept in each generation.", new IntData(1)));
-      Parameters.Add(new ValueParameter<IntData>("MaximumGenerations", "The maximum number of generations which should be processed.", new IntData(1000)));
+      Parameters.Add(new ValueParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation.", new IntValue(1)));
+      Parameters.Add(new ValueParameter<IntValue>("MaximumGenerations", "The maximum number of generations which should be processed.", new IntValue(1000)));
 
       RandomCreator randomCreator = new RandomCreator();
@@ -266,6 +266,6 @@
     private void ParameterizeSelectors() {
       foreach (ISelector selector in Selectors) {
-        selector.CopySelected = new BoolData(true);
-        selector.NumberOfSelectedSubScopesParameter.Value = new IntData(2 * (PopulationSizeParameter.Value.Value - ElitesParameter.Value.Value));
+        selector.CopySelected = new BoolValue(true);
+        selector.NumberOfSelectedSubScopesParameter.Value = new IntValue(2 * (PopulationSizeParameter.Value.Value - ElitesParameter.Value.Value));
         ParameterizeStochasticOperator(selector);
       }
Index: trunk/sources/HeuristicLab.Algorithms.SGA/3.3/SGAMainLoop.cs
===================================================================
--- trunk/sources/HeuristicLab.Algorithms.SGA/3.3/SGAMainLoop.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Algorithms.SGA/3.3/SGAMainLoop.cs	(revision 3048)
@@ -41,9 +41,9 @@
       get { return (ValueLookupParameter<IRandom>)Parameters["Random"]; }
     }
-    public ValueLookupParameter<BoolData> MaximizationParameter {
-      get { return (ValueLookupParameter<BoolData>)Parameters["Maximization"]; }
-    }
-    public SubScopesLookupParameter<DoubleData> QualityParameter {
-      get { return (SubScopesLookupParameter<DoubleData>)Parameters["Quality"]; }
+    public ValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (ValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+    public SubScopesLookupParameter<DoubleValue> QualityParameter {
+      get { return (SubScopesLookupParameter<DoubleValue>)Parameters["Quality"]; }
     }
     public ValueLookupParameter<IOperator> SelectorParameter {
@@ -53,6 +53,6 @@
       get { return (ValueLookupParameter<IOperator>)Parameters["Crossover"]; }
     }
-    public ValueLookupParameter<DoubleData> MutationProbabilityParameter {
-      get { return (ValueLookupParameter<DoubleData>)Parameters["MutationProbability"]; }
+    public ValueLookupParameter<DoubleValue> MutationProbabilityParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["MutationProbability"]; }
     }
     public ValueLookupParameter<IOperator> MutatorParameter {
@@ -62,9 +62,9 @@
       get { return (ValueLookupParameter<IOperator>)Parameters["Evaluator"]; }
     }
-    public ValueLookupParameter<IntData> ElitesParameter {
-      get { return (ValueLookupParameter<IntData>)Parameters["Elites"]; }
-    }
-    public ValueLookupParameter<IntData> MaximumGenerationsParameter {
-      get { return (ValueLookupParameter<IntData>)Parameters["MaximumGenerations"]; }
+    public ValueLookupParameter<IntValue> ElitesParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["Elites"]; }
+    }
+    public ValueLookupParameter<IntValue> MaximumGenerationsParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["MaximumGenerations"]; }
     }
     public ValueLookupParameter<VariableCollection> ResultsParameter {
@@ -84,13 +84,13 @@
       #region Create parameters
       Parameters.Add(new ValueLookupParameter<IRandom>("Random", "A pseudo random number generator."));
-      Parameters.Add(new ValueLookupParameter<BoolData>("Maximization", "True if the problem is a maximization problem, otherwise false."));
-      Parameters.Add(new SubScopesLookupParameter<DoubleData>("Quality", "The value which represents the quality of a solution."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
+      Parameters.Add(new SubScopesLookupParameter<DoubleValue>("Quality", "The value which represents the quality of a solution."));
       Parameters.Add(new ValueLookupParameter<IOperator>("Selector", "The operator used to select solutions for reproduction."));
       Parameters.Add(new ValueLookupParameter<IOperator>("Crossover", "The operator used to cross solutions."));
-      Parameters.Add(new ValueLookupParameter<DoubleData>("MutationProbability", "The probability that the mutation operator is applied on a solution."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("MutationProbability", "The probability that the mutation operator is applied on a solution."));
       Parameters.Add(new ValueLookupParameter<IOperator>("Mutator", "The operator used to mutate solutions."));
       Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator", "The operator used to evaluate solutions."));
-      Parameters.Add(new ValueLookupParameter<IntData>("Elites", "The numer of elite solutions which are kept in each generation."));
-      Parameters.Add(new ValueLookupParameter<IntData>("MaximumGenerations", "The maximum number of generations which should be processed."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("MaximumGenerations", "The maximum number of generations which should be processed."));
       Parameters.Add(new ValueLookupParameter<VariableCollection>("Results", "The variable collection where results should be stored."));
       Parameters.Add(new ScopeParameter("CurrentScope", "The current scope which represents a population of solutions on which the SGA should be applied."));
@@ -123,15 +123,15 @@
       OperatorGraph.InitialOperator = variableCreator;
 
-      variableCreator.CollectedValues.Add(new ValueParameter<IntData>("Generations", new IntData(0)));
-      variableCreator.CollectedValues.Add(new ValueParameter<DoubleData>("Best Quality", new DoubleData(0)));
-      variableCreator.CollectedValues.Add(new ValueParameter<DoubleData>("Average Quality", new DoubleData(0)));
-      variableCreator.CollectedValues.Add(new ValueParameter<DoubleData>("Worst Quality", new DoubleData(0)));
+      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Generations", new IntValue(0)));
+      variableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("Best Quality", new DoubleValue(0)));
+      variableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("Average Quality", new DoubleValue(0)));
+      variableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("Worst Quality", new DoubleValue(0)));
       variableCreator.CollectedValues.Add(new ValueParameter<DataTable>("Qualities", new DataTable("Qualities")));
       variableCreator.Successor = resultsCollector;
 
-      resultsCollector.CollectedValues.Add(new LookupParameter<IntData>("Generations"));
-      resultsCollector.CollectedValues.Add(new LookupParameter<DoubleData>("Best Quality"));
-      resultsCollector.CollectedValues.Add(new LookupParameter<DoubleData>("Average Quality"));
-      resultsCollector.CollectedValues.Add(new LookupParameter<DoubleData>("Worst Quality"));
+      resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Generations"));
+      resultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Best Quality"));
+      resultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Average Quality"));
+      resultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Worst Quality"));
       resultsCollector.CollectedValues.Add(new LookupParameter<DataTable>("Qualities"));
       resultsCollector.ResultsParameter.ActualName = "Results";
@@ -150,5 +150,5 @@
       sequentialSubScopesProcessor1.Successor = sequentialSubScopesProcessor2;
 
-      childrenCreator.ParentsPerChild = new IntData(2);
+      childrenCreator.ParentsPerChild = new IntValue(2);
       childrenCreator.Successor = uniformSequentialSubScopesProcessor;
 
@@ -185,5 +185,5 @@
       sequentialSubScopesProcessor2.Successor = mergingReducer;
 
-      leftSelector.CopySelected = new BoolData(false);
+      leftSelector.CopySelected = new BoolValue(false);
       leftSelector.NumberOfSelectedSubScopesParameter.ActualName = "Elites";
       leftSelector.Successor = rightReducer;
@@ -193,9 +193,9 @@
       mergingReducer.Successor = intCounter;
 
-      intCounter.Increment = new IntData(1);
+      intCounter.Increment = new IntValue(1);
       intCounter.ValueParameter.ActualName = "Generations";
       intCounter.Successor = comparator;
 
-      comparator.Comparison = new ComparisonData(Comparison.GreaterOrEqual);
+      comparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
       comparator.LeftSideParameter.ActualName = "Generations";
       comparator.ResultParameter.ActualName = "Terminate";
@@ -210,7 +210,7 @@
       bestAverageWorstQualityCalculator.Successor = dataTableValuesCollector;
 
-      dataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleData>("Best Quality"));
-      dataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleData>("Average Quality"));
-      dataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleData>("Worst Quality"));
+      dataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Best Quality"));
+      dataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Average Quality"));
+      dataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Worst Quality"));
       dataTableValuesCollector.DataTableParameter.ActualName = "Qualities";
       dataTableValuesCollector.Successor = conditionalBranch;
Index: trunk/sources/HeuristicLab.Algorithms.TS/3.3/TS.cs
===================================================================
--- trunk/sources/HeuristicLab.Algorithms.TS/3.3/TS.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Algorithms.TS/3.3/TS.cs	(revision 3048)
@@ -35,24 +35,24 @@
   public sealed class TS : EngineAlgorithm {
     /*#region Parameter Properties
-    private ValueParameter<IntData> SeedParameter {
-      get { return (ValueParameter<IntData>)Parameters["Seed"]; }
-    }
-    private ValueParameter<BoolData> SetSeedRandomlyParameter {
-      get { return (ValueParameter<BoolData>)Parameters["SetSeedRandomly"]; }
+    private ValueParameter<IntValue> SeedParameter {
+      get { return (ValueParameter<IntValue>)Parameters["Seed"]; }
+    }
+    private ValueParameter<BoolValue> SetSeedRandomlyParameter {
+      get { return (ValueParameter<BoolValue>)Parameters["SetSeedRandomly"]; }
     }
     private ConstrainedValueParameter<IMoveGenerator> MoveGeneratorParameter {
       get { return (ConstrainedValueParameter<IMoveGenerator>)Parameters["MoveGenerator"]; }
     }
-    private ValueParameter<IntData> MaximumIterationsParameter {
-      get { return (ValueParameter<IntData>)Parameters["MaximumIterations"]; }
+    private ValueParameter<IntValue> MaximumIterationsParameter {
+      get { return (ValueParameter<IntValue>)Parameters["MaximumIterations"]; }
     }
     #endregion
 
     #region Properties
-    public IntData Seed {
+    public IntValue Seed {
       get { return SeedParameter.Value; }
       set { SeedParameter.Value = value; }
     }
-    public BoolData SetSeedRandomly {
+    public BoolValue SetSeedRandomly {
       get { return SetSeedRandomlyParameter.Value; }
       set { SetSeedRandomlyParameter.Value = value; }
@@ -62,5 +62,5 @@
       set { MoveGeneratorParameter.Value = value; }
     }
-    public IntData MaximumIterations {
+    public IntValue MaximumIterations {
       get { return MaximumIterationsParameter.Value; }
       set { MaximumIterationsParameter.Value = value; }
@@ -79,8 +79,8 @@
     public TS()
       : base() {
-      Parameters.Add(new ValueParameter<IntData>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntData(0)));
-      Parameters.Add(new ValueParameter<BoolData>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolData(true)));
+      Parameters.Add(new ValueParameter<IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
+      Parameters.Add(new ValueParameter<BoolValue>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
       Parameters.Add(new ConstrainedValueParameter<IMoveGenerator>("MoveGenerator", "The operator used to generate moves to the neighborhood of the current solution."));
-      Parameters.Add(new ValueParameter<IntData>("MaximumIterations", "The maximum number of generations which should be processed.", new IntData(1000)));
+      Parameters.Add(new ValueParameter<IntValue>("MaximumIterations", "The maximum number of generations which should be processed.", new IntValue(1000)));
 
       RandomCreator randomCreator = new RandomCreator();
@@ -96,5 +96,5 @@
       randomCreator.Successor = solutionsCreator;
 
-      solutionsCreator.NumberOfSolutions = new IntData(1);
+      solutionsCreator.NumberOfSolutions = new IntValue(1);
       solutionsCreator.Successor = tsMainLoop;
 
@@ -206,6 +206,6 @@
     private void ParameterizeSelectors() {
       foreach (ISelector selector in Selectors) {
-        selector.CopySelected = new BoolData(true);
-        selector.NumberOfSelectedSubScopesParameter.Value = new IntData(2 * (PopulationSizeParameter.Value.Value - ElitesParameter.Value.Value));
+        selector.CopySelected = new BoolValue(true);
+        selector.NumberOfSelectedSubScopesParameter.Value = new IntValue(2 * (PopulationSizeParameter.Value.Value - ElitesParameter.Value.Value));
         ParameterizeStochasticOperator(selector);
       }
Index: trunk/sources/HeuristicLab.Algorithms.TS/3.3/TSMainLoop.cs
===================================================================
--- trunk/sources/HeuristicLab.Algorithms.TS/3.3/TSMainLoop.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Algorithms.TS/3.3/TSMainLoop.cs	(revision 3048)
@@ -39,15 +39,15 @@
       get { return (ValueLookupParameter<IRandom>)Parameters["Random"]; }
     }
-    public ValueLookupParameter<BoolData> MaximizationParameter {
-      get { return (ValueLookupParameter<BoolData>)Parameters["Maximization"]; }
-    }
-    public SubScopesLookupParameter<DoubleData> QualityParameter {
-      get { return (SubScopesLookupParameter<DoubleData>)Parameters["Quality"]; }
-    }
-    public ValueLookupParameter<IntData> MaximumIterationsParameter {
-      get { return (ValueLookupParameter<IntData>)Parameters["MaximumIterations"]; }
-    }
-    public ValueLookupParameter<IntData> TabuTenureParameter {
-      get { return (ValueLookupParameter<IntData>)Parameters["TabuTenure"]; }
+    public ValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (ValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+    public SubScopesLookupParameter<DoubleValue> QualityParameter {
+      get { return (SubScopesLookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    public ValueLookupParameter<IntValue> MaximumIterationsParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["MaximumIterations"]; }
+    }
+    public ValueLookupParameter<IntValue> TabuTenureParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["TabuTenure"]; }
     }
     public ValueLookupParameter<VariableCollection> ResultsParameter {
@@ -85,8 +85,8 @@
       #region Create parameters
       Parameters.Add(new ValueLookupParameter<IRandom>("Random", "A pseudo random number generator."));
-      Parameters.Add(new ValueLookupParameter<BoolData>("Maximization", "True if the problem is a maximization problem, otherwise false."));
-      Parameters.Add(new SubScopesLookupParameter<DoubleData>("Quality", "The value which represents the quality of a solution."));
-      Parameters.Add(new ValueLookupParameter<IntData>("MaximumIterations", "The maximum number of generations which should be processed."));
-      Parameters.Add(new ValueLookupParameter<IntData>("TabuTenure", "The length of the tabu list, and also means the number of iterations a move is kept tabu"));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
+      Parameters.Add(new SubScopesLookupParameter<DoubleValue>("Quality", "The value which represents the quality of a solution."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("MaximumIterations", "The maximum number of generations which should be processed."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("TabuTenure", "The length of the tabu list, and also means the number of iterations a move is kept tabu"));
       Parameters.Add(new ValueLookupParameter<VariableCollection>("Results", "The variable collection where results should be stored."));
 
@@ -124,15 +124,15 @@
       EmptyOperator finished = new EmptyOperator();
 
-      variableCreator.CollectedValues.Add(new ValueParameter<IntData>("Iterations", new IntData(0)));
-      variableCreator.CollectedValues.Add(new ValueParameter<DoubleData>("Best Move Quality", new DoubleData(0)));
-      variableCreator.CollectedValues.Add(new ValueParameter<DoubleData>("Average Move Quality", new DoubleData(0)));
-      variableCreator.CollectedValues.Add(new ValueParameter<DoubleData>("Worst Move Quality", new DoubleData(0)));
+      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Iterations", new IntValue(0)));
+      variableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("Best Move Quality", new DoubleValue(0)));
+      variableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("Average Move Quality", new DoubleValue(0)));
+      variableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("Worst Move Quality", new DoubleValue(0)));
       variableCreator.CollectedValues.Add(new ValueParameter<DataTable>("MoveQualities", new DataTable("MoveQualities")));
 
-      resultsCollector.CollectedValues.Add(new LookupParameter<IntData>("Iterations"));
-      resultsCollector.CollectedValues.Add(new LookupParameter<DoubleData>("Best Quality") { ActualName = "BestQuality" });
-      resultsCollector.CollectedValues.Add(new LookupParameter<DoubleData>("Best Move Quality"));
-      resultsCollector.CollectedValues.Add(new LookupParameter<DoubleData>("Average Move Quality"));
-      resultsCollector.CollectedValues.Add(new LookupParameter<DoubleData>("Worst Move Quality"));
+      resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Iterations"));
+      resultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Best Quality") { ActualName = "BestQuality" });
+      resultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Best Move Quality"));
+      resultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Average Move Quality"));
+      resultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Worst Move Quality"));
       resultsCollector.CollectedValues.Add(new LookupParameter<DataTable>("MoveQualities"));
       resultsCollector.ResultsParameter.ActualName = "Results";
@@ -158,5 +158,5 @@
       bestAverageWorstMoveQualityCalculator.WorstQualityParameter.ActualName = "Worst Move Quality";
 
-      tabuSelector.NumberOfSelectedSubScopes = new IntData(1);
+      tabuSelector.NumberOfSelectedSubScopes = new IntValue(1);
 
       moveMakingProcessor.Name = "MoveMaking processor (UniformSequentialSubScopesProcessor)";
@@ -168,7 +168,7 @@
       moveMaker.OperatorParameter.ActualName = "MoveMaker";
 
-      valuesCollector.CollectedValues.Add(new LookupParameter<DoubleData>("Best Move Quality"));
-      valuesCollector.CollectedValues.Add(new LookupParameter<DoubleData>("Average Move Quality"));
-      valuesCollector.CollectedValues.Add(new LookupParameter<DoubleData>("Worst Move Quality"));
+      valuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Best Move Quality"));
+      valuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Average Move Quality"));
+      valuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Worst Move Quality"));
       valuesCollector.DataTableParameter.ActualName = "MoveQualities";
 
@@ -176,9 +176,9 @@
 
       iterationsCounter.Name = "Iterations Counter";
-      iterationsCounter.Increment = new IntData(1);
+      iterationsCounter.Increment = new IntValue(1);
       iterationsCounter.ValueParameter.ActualName = "Iterations";
 
       iterationsComparator.Name = "Iterations Comparator";
-      iterationsComparator.Comparison = new ComparisonData(Comparison.Less);
+      iterationsComparator.Comparison = new Comparison(ComparisonType.Less);
       iterationsComparator.LeftSideParameter.ActualName = "Iterations";
       iterationsComparator.RightSideParameter.ActualName = "MaximumIterations";
Index: trunk/sources/HeuristicLab.Algorithms.TS/3.3/TabuSelector.cs
===================================================================
--- trunk/sources/HeuristicLab.Algorithms.TS/3.3/TabuSelector.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Algorithms.TS/3.3/TabuSelector.cs	(revision 3048)
@@ -42,33 +42,33 @@
     /// The best found quality so far.
     /// </summary>
-    public LookupParameter<DoubleData> BestQualityParameter {
-      get { return (LookupParameter<DoubleData>)Parameters["BestQuality"]; }
+    public LookupParameter<DoubleValue> BestQualityParameter {
+      get { return (LookupParameter<DoubleValue>)Parameters["BestQuality"]; }
     }
     /// <summary>
     /// Whether to use the default aspiration criteria or not.
     /// </summary>
-    public ValueLookupParameter<BoolData> AspirationParameter {
-      get { return (ValueLookupParameter<BoolData>)Parameters["Aspiration"]; }
+    public ValueLookupParameter<BoolValue> AspirationParameter {
+      get { return (ValueLookupParameter<BoolValue>)Parameters["Aspiration"]; }
     }
     /// <summary>
     /// Whether the problem is a maximization problem or not.
     /// </summary>
-    public IValueLookupParameter<BoolData> MaximizationParameter {
-      get { return (IValueLookupParameter<BoolData>)Parameters["Maximization"]; }
+    public IValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
     }
     /// <summary>
     /// The parameter for the move qualities.
     /// </summary>
-    public ILookupParameter<ItemArray<DoubleData>> MoveQualityParameter {
-      get { return (ILookupParameter<ItemArray<DoubleData>>)Parameters["MoveQuality"]; }
+    public ILookupParameter<ItemArray<DoubleValue>> MoveQualityParameter {
+      get { return (ILookupParameter<ItemArray<DoubleValue>>)Parameters["MoveQuality"]; }
     }
     /// <summary>
     /// The parameter for the tabu status of the moves.
     /// </summary>
-    public ILookupParameter<ItemArray<BoolData>> MoveTabuParameter {
-      get { return (ILookupParameter<ItemArray<BoolData>>)Parameters["MoveTabu"]; }
+    public ILookupParameter<ItemArray<BoolValue>> MoveTabuParameter {
+      get { return (ILookupParameter<ItemArray<BoolValue>>)Parameters["MoveTabu"]; }
     }
 
-    public IntData NumberOfSelectedSubScopes {
+    public IntValue NumberOfSelectedSubScopes {
       set { NumberOfSelectedSubScopesParameter.Value = value; }
     }
@@ -80,9 +80,9 @@
     public TabuSelector()
       : base() {
-      Parameters.Add(new LookupParameter<DoubleData>("BestQuality", "The best found quality so far."));
-      Parameters.Add(new ValueLookupParameter<BoolData>("Aspiration", "Whether the default aspiration criterion should be used or not. The default aspiration criterion accepts a tabu move if it results in a better solution than the best solution found so far.", new BoolData(true)));
-      Parameters.Add(new ValueLookupParameter<BoolData>("Maximization", "Whether the problem is a maximization or minimization problem (used to decide whether a solution is better"));
-      Parameters.Add(new SubScopesLookupParameter<DoubleData>("MoveQuality", "The quality of the move."));
-      Parameters.Add(new SubScopesLookupParameter<BoolData>("MoveTabu", "The tabu status of the move."));
+      Parameters.Add(new LookupParameter<DoubleValue>("BestQuality", "The best found quality so far."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Aspiration", "Whether the default aspiration criterion should be used or not. The default aspiration criterion accepts a tabu move if it results in a better solution than the best solution found so far.", new BoolValue(true)));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "Whether the problem is a maximization or minimization problem (used to decide whether a solution is better"));
+      Parameters.Add(new SubScopesLookupParameter<DoubleValue>("MoveQuality", "The quality of the move."));
+      Parameters.Add(new SubScopesLookupParameter<BoolValue>("MoveTabu", "The tabu status of the move."));
     }
 
@@ -99,6 +99,6 @@
       bool maximization = MaximizationParameter.ActualValue.Value;
       double bestQuality = BestQualityParameter.ActualValue.Value;
-      ItemArray<DoubleData> moveQualities = MoveQualityParameter.ActualValue;
-      ItemArray<BoolData> moveTabus = MoveTabuParameter.ActualValue;
+      ItemArray<DoubleValue> moveQualities = MoveQualityParameter.ActualValue;
+      ItemArray<BoolValue> moveTabus = MoveTabuParameter.ActualValue;
 
       IScope[] selected = new IScope[count];
Index: trunk/sources/HeuristicLab.Analysis/3.3/BestAverageWorstQualityCalculator.cs
===================================================================
--- trunk/sources/HeuristicLab.Analysis/3.3/BestAverageWorstQualityCalculator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Analysis/3.3/BestAverageWorstQualityCalculator.cs	(revision 3048)
@@ -34,32 +34,32 @@
   [Creatable("Test")]
   public sealed class BestAverageWorstQualityCalculator : SingleSuccessorOperator {
-    public IValueLookupParameter<BoolData> MaximizationParameter {
-      get { return (IValueLookupParameter<BoolData>)Parameters["Maximization"]; }
+    public IValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
     }
-    public ILookupParameter<ItemArray<DoubleData>> QualityParameter {
-      get { return (ILookupParameter<ItemArray<DoubleData>>)Parameters["Quality"]; }
+    public ILookupParameter<ItemArray<DoubleValue>> QualityParameter {
+      get { return (ILookupParameter<ItemArray<DoubleValue>>)Parameters["Quality"]; }
     }
-    public IValueLookupParameter<DoubleData> BestQualityParameter {
-      get { return (IValueLookupParameter<DoubleData>)Parameters["BestQuality"]; }
+    public IValueLookupParameter<DoubleValue> BestQualityParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["BestQuality"]; }
     }
-    public IValueLookupParameter<DoubleData> AverageQualityParameter {
-      get { return (IValueLookupParameter<DoubleData>)Parameters["AverageQuality"]; }
+    public IValueLookupParameter<DoubleValue> AverageQualityParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["AverageQuality"]; }
     }
-    public IValueLookupParameter<DoubleData> WorstQualityParameter {
-      get { return (IValueLookupParameter<DoubleData>)Parameters["WorstQuality"]; }
+    public IValueLookupParameter<DoubleValue> WorstQualityParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["WorstQuality"]; }
     }
 
     public BestAverageWorstQualityCalculator()
       : base() {
-      Parameters.Add(new ValueLookupParameter<BoolData>("Maximization", "True if the current problem is a maximization problem, otherwise false."));
-      Parameters.Add(new SubScopesLookupParameter<DoubleData>("Quality", "The value contained in each sub-scope which represents the solution quality."));
-      Parameters.Add(new ValueLookupParameter<DoubleData>("BestQuality", "The quality value of the best solution."));
-      Parameters.Add(new ValueLookupParameter<DoubleData>("AverageQuality", "The average quality of all solutions."));
-      Parameters.Add(new ValueLookupParameter<DoubleData>("WorstQuality", "The quality value of the worst solution."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the current problem is a maximization problem, otherwise false."));
+      Parameters.Add(new SubScopesLookupParameter<DoubleValue>("Quality", "The value contained in each sub-scope which represents the solution quality."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("BestQuality", "The quality value of the best solution."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("AverageQuality", "The average quality of all solutions."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("WorstQuality", "The quality value of the worst solution."));
     }
 
 
     public override IOperation Apply() {
-      ItemArray<DoubleData> qualities = QualityParameter.ActualValue;
+      ItemArray<DoubleValue> qualities = QualityParameter.ActualValue;
       bool maximization = MaximizationParameter.ActualValue.Value;
 
@@ -77,12 +77,12 @@
         }
 
-        DoubleData best = BestQualityParameter.ActualValue;
-        if (best == null) BestQualityParameter.ActualValue = new DoubleData(max);
+        DoubleValue best = BestQualityParameter.ActualValue;
+        if (best == null) BestQualityParameter.ActualValue = new DoubleValue(max);
         else best.Value = max;
-        DoubleData average = AverageQualityParameter.ActualValue;
-        if (average == null) AverageQualityParameter.ActualValue = new DoubleData(sum / qualities.Length);
+        DoubleValue average = AverageQualityParameter.ActualValue;
+        if (average == null) AverageQualityParameter.ActualValue = new DoubleValue(sum / qualities.Length);
         else average.Value = sum / qualities.Length;
-        DoubleData worst = WorstQualityParameter.ActualValue;
-        if (worst == null) WorstQualityParameter.ActualValue = new DoubleData(min);
+        DoubleValue worst = WorstQualityParameter.ActualValue;
+        if (worst == null) WorstQualityParameter.ActualValue = new DoubleValue(min);
         else worst.Value = min;
       }
Index: trunk/sources/HeuristicLab.Analysis/3.3/BestQualityMemorizer.cs
===================================================================
--- trunk/sources/HeuristicLab.Analysis/3.3/BestQualityMemorizer.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Analysis/3.3/BestQualityMemorizer.cs	(revision 3048)
@@ -33,31 +33,31 @@
   [StorableClass]
   public class BestQualityMemorizer : SingleSuccessorOperator {
-    public IValueLookupParameter<BoolData> MaximizationParameter {
-      get { return (IValueLookupParameter<BoolData>)Parameters["Maximization"]; }
+    public IValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
     }
-    public ILookupParameter<ItemArray<DoubleData>> QualityParameter {
-      get { return (ILookupParameter<ItemArray<DoubleData>>)Parameters["Quality"]; }
+    public ILookupParameter<ItemArray<DoubleValue>> QualityParameter {
+      get { return (ILookupParameter<ItemArray<DoubleValue>>)Parameters["Quality"]; }
     }
-    public IValueLookupParameter<DoubleData> BestQualityParameter {
-      get { return (IValueLookupParameter<DoubleData>)Parameters["BestQuality"]; }
+    public IValueLookupParameter<DoubleValue> BestQualityParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["BestQuality"]; }
     }
 
     public BestQualityMemorizer()
       : base() {
-      Parameters.Add(new ValueLookupParameter<BoolData>("Maximization", "True if the current problem is a maximization problem, otherwise false."));
-      Parameters.Add(new SubScopesLookupParameter<DoubleData>("Quality", "The value contained in each sub-scope which represents the solution quality."));
-      Parameters.Add(new ValueLookupParameter<DoubleData>("BestQuality", "The quality value of the best solution."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the current problem is a maximization problem, otherwise false."));
+      Parameters.Add(new SubScopesLookupParameter<DoubleValue>("Quality", "The value contained in each sub-scope which represents the solution quality."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("BestQuality", "The quality value of the best solution."));
     }
 
     public override IOperation Apply() {
-      ItemArray<DoubleData> qualities = QualityParameter.ActualValue;
+      ItemArray<DoubleValue> qualities = QualityParameter.ActualValue;
       bool maximization = MaximizationParameter.ActualValue.Value;
-      DoubleData best = BestQualityParameter.ActualValue;
+      DoubleValue best = BestQualityParameter.ActualValue;
       double max = (best != null) ? (best.Value) : ((maximization) ? (double.MinValue) : (double.MaxValue));
       
-      foreach (DoubleData quality in qualities)
+      foreach (DoubleValue quality in qualities)
         if (IsBetter(maximization, quality.Value, max)) max = quality.Value;
 
-      if (best == null) BestQualityParameter.ActualValue = new DoubleData(max);
+      if (best == null) BestQualityParameter.ActualValue = new DoubleValue(max);
       else best.Value = max;
       return base.Apply();
Index: trunk/sources/HeuristicLab.Analysis/3.3/DataTableValuesCollector.cs
===================================================================
--- trunk/sources/HeuristicLab.Analysis/3.3/DataTableValuesCollector.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Analysis/3.3/DataTableValuesCollector.cs	(revision 3048)
@@ -52,5 +52,5 @@
 
       foreach (IParameter param in CollectedValues) {
-        DoubleData data = param.ActualValue as DoubleData;
+        DoubleValue data = param.ActualValue as DoubleValue;
         if (data == null) throw new InvalidOperationException("Only double data values can be collected by a DataTableValuesCollector.");
 
Index: trunk/sources/HeuristicLab.Data.Views/3.3/BoolValueView.Designer.cs
===================================================================
--- trunk/sources/HeuristicLab.Data.Views/3.3/BoolValueView.Designer.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Data.Views/3.3/BoolValueView.Designer.cs	(revision 3048)
@@ -21,5 +21,5 @@
 
 namespace HeuristicLab.Data.Views {
-  partial class BoolDataView {
+  partial class BoolValueView {
     /// <summary> 
     /// Required designer variable.
@@ -60,10 +60,10 @@
       this.valueCheckBox.CheckedChanged += new System.EventHandler(this.valueCheckBox_CheckedChanged);
       // 
-      // BoolDataView
+      // BoolValueView
       // 
       this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
       this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
       this.Controls.Add(this.valueCheckBox);
-      this.Name = "BoolDataView";
+      this.Name = "BoolValueView";
       this.Size = new System.Drawing.Size(71, 27);
       this.ResumeLayout(false);
Index: trunk/sources/HeuristicLab.Data.Views/3.3/BoolValueView.cs
===================================================================
--- trunk/sources/HeuristicLab.Data.Views/3.3/BoolValueView.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Data.Views/3.3/BoolValueView.cs	(revision 3048)
@@ -26,17 +26,17 @@
 
 namespace HeuristicLab.Data.Views {
-  [View("BoolData View")]
-  [Content(typeof(BoolData), true)]
-  public partial class BoolDataView : ItemView {
-    public new BoolData Content {
-      get { return (BoolData)base.Content; }
+  [View("BoolValue View")]
+  [Content(typeof(BoolValue), true)]
+  public partial class BoolValueView : ItemView {
+    public new BoolValue Content {
+      get { return (BoolValue)base.Content; }
       set { base.Content = value; }
     }
 
-    public BoolDataView() {
+    public BoolValueView() {
       InitializeComponent();
-      Caption = "BoolData View";
+      Caption = "BoolValue View";
     }
-    public BoolDataView(BoolData content)
+    public BoolValueView(BoolValue content)
       : this() {
       Content = content;
@@ -56,5 +56,5 @@
       base.OnContentChanged();
       if (Content == null) {
-        Caption = "BoolData View";
+        Caption = "BoolValue View";
         valueCheckBox.Checked = false;
         valueCheckBox.Enabled = false;
Index: trunk/sources/HeuristicLab.Data.Views/3.3/ComparisonView.Designer.cs
===================================================================
--- trunk/sources/HeuristicLab.Data.Views/3.3/ComparisonView.Designer.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Data.Views/3.3/ComparisonView.Designer.cs	(revision 3048)
@@ -21,5 +21,5 @@
 
 namespace HeuristicLab.Data.Views {
-  partial class ComparisonDataView {
+  partial class ComparisonView {
     /// <summary> 
     /// Required designer variable.
@@ -71,5 +71,5 @@
       this.valueComboBox.SelectedIndexChanged += new System.EventHandler(this.valueComboBox_SelectedIndexChanged);
       // 
-      // ComparisonDataView
+      // ComparisonView
       // 
       this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
@@ -77,5 +77,5 @@
       this.Controls.Add(this.valueComboBox);
       this.Controls.Add(this.valueLabel);
-      this.Name = "ComparisonDataView";
+      this.Name = "ComparisonView";
       this.Size = new System.Drawing.Size(265, 29);
       this.ResumeLayout(false);
Index: trunk/sources/HeuristicLab.Data.Views/3.3/ComparisonView.cs
===================================================================
--- trunk/sources/HeuristicLab.Data.Views/3.3/ComparisonView.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Data.Views/3.3/ComparisonView.cs	(revision 3048)
@@ -26,18 +26,18 @@
 
 namespace HeuristicLab.Data.Views {
-  [View("ComparisonData View")]
-  [Content(typeof(ComparisonData), true)]
-  public partial class ComparisonDataView : ItemView {
-    public new ComparisonData Content {
-      get { return (ComparisonData)base.Content; }
+  [View("Comparison View")]
+  [Content(typeof(Comparison), true)]
+  public partial class ComparisonView : ItemView {
+    public new Comparison Content {
+      get { return (Comparison)base.Content; }
       set { base.Content = value; }
     }
 
-    public ComparisonDataView() {
+    public ComparisonView() {
       InitializeComponent();
-      Caption = "ComparisonData View";
-      valueComboBox.DataSource = Enum.GetValues(typeof(Comparison));
+      Caption = "Comparison View";
+      valueComboBox.DataSource = Enum.GetValues(typeof(ComparisonType));
     }
-    public ComparisonDataView(ComparisonData content)
+    public ComparisonView(Comparison content)
       : this() {
       Content = content;
@@ -57,5 +57,5 @@
       base.OnContentChanged();
       if (Content == null) {
-        Caption = "ComparisonData View";
+        Caption = "Comparison View";
         valueComboBox.Enabled = false;
       } else {
@@ -74,5 +74,5 @@
 
     private void valueComboBox_SelectedIndexChanged(object sender, EventArgs e) {
-      if (Content != null) Content.Value = (Comparison)valueComboBox.SelectedItem;
+      if (Content != null) Content.Value = (ComparisonType)valueComboBox.SelectedItem;
     }
   }
Index: trunk/sources/HeuristicLab.Data.Views/3.3/StringConvertibleArrayView.Designer.cs
===================================================================
--- trunk/sources/HeuristicLab.Data.Views/3.3/StringConvertibleArrayView.Designer.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Data.Views/3.3/StringConvertibleArrayView.Designer.cs	(revision 3048)
@@ -21,5 +21,5 @@
 
 namespace HeuristicLab.Data.Views {
-  partial class StringConvertibleArrayDataView {
+  partial class StringConvertibleArrayView {
     /// <summary> 
     /// Required designer variable.
@@ -98,5 +98,5 @@
       this.errorProvider.ContainerControl = this;
       // 
-      // StringConvertibleArrayDataView
+      // StringConvertibleArrayView
       // 
       this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
@@ -105,5 +105,5 @@
       this.Controls.Add(this.lengthTextBox);
       this.Controls.Add(this.lengthLabel);
-      this.Name = "StringConvertibleArrayDataView";
+      this.Name = "StringConvertibleArrayView";
       this.Size = new System.Drawing.Size(424, 404);
       ((System.ComponentModel.ISupportInitialize)(this.dataGridView)).EndInit();
Index: trunk/sources/HeuristicLab.Data.Views/3.3/StringConvertibleArrayView.cs
===================================================================
--- trunk/sources/HeuristicLab.Data.Views/3.3/StringConvertibleArrayView.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Data.Views/3.3/StringConvertibleArrayView.cs	(revision 3048)
@@ -29,19 +29,19 @@
 
 namespace HeuristicLab.Data.Views {
-  [View("StringConvertibleArrayData View")]
-  [Content(typeof(IStringConvertibleArrayData), true)]
-  public partial class StringConvertibleArrayDataView : ContentView {
-    public new IStringConvertibleArrayData Content {
-      get { return (IStringConvertibleArrayData)base.Content; }
+  [View("StringConvertibleArray View")]
+  [Content(typeof(IStringConvertibleArray), true)]
+  public partial class StringConvertibleArrayView : ContentView {
+    public new IStringConvertibleArray Content {
+      get { return (IStringConvertibleArray)base.Content; }
       set { base.Content = value; }
     }
 
-    public StringConvertibleArrayDataView() {
+    public StringConvertibleArrayView() {
       InitializeComponent();
-      Caption = "StringConvertibleArrayData View";
+      Caption = "StringConvertibleArray View";
       errorProvider.SetIconAlignment(lengthTextBox, ErrorIconAlignment.MiddleLeft);
       errorProvider.SetIconPadding(lengthTextBox, 2);
     }
-    public StringConvertibleArrayDataView(IStringConvertibleArrayData content)
+    public StringConvertibleArrayView(IStringConvertibleArray content)
       : this() {
       Content = content;
@@ -64,5 +64,5 @@
       base.OnContentChanged();
       if (Content == null) {
-        Caption = "StringConvertibleArrayData View";
+        Caption = "StringConvertibleArray View";
         lengthTextBox.Text = "";
         lengthTextBox.Enabled = false;
@@ -71,5 +71,5 @@
         dataGridView.Enabled = false;
       } else {
-        Caption = "StringConvertibleArrayData (" + Content.GetType().Name + ")";
+        Caption = "StringConvertibleArray (" + Content.GetType().Name + ")";
         UpdateData();
       }
Index: trunk/sources/HeuristicLab.Data.Views/3.3/StringConvertibleMatrixView.Designer.cs
===================================================================
--- trunk/sources/HeuristicLab.Data.Views/3.3/StringConvertibleMatrixView.Designer.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Data.Views/3.3/StringConvertibleMatrixView.Designer.cs	(revision 3048)
@@ -21,5 +21,5 @@
 
 namespace HeuristicLab.Data.Views {
-  partial class StringConvertibleMatrixDataView {
+  partial class StringConvertibleMatrixView {
     /// <summary> 
     /// Required designer variable.
@@ -121,5 +121,5 @@
       this.columnsLabel.Text = "&Columns:";
       // 
-      // StringConvertibleMatrixDataView
+      // StringConvertibleMatrixView
       // 
       this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
@@ -130,5 +130,5 @@
       this.Controls.Add(this.columnsLabel);
       this.Controls.Add(this.rowsLabel);
-      this.Name = "StringConvertibleMatrixDataView";
+      this.Name = "StringConvertibleMatrixView";
       this.Size = new System.Drawing.Size(424, 404);
       ((System.ComponentModel.ISupportInitialize)(this.dataGridView)).EndInit();
Index: trunk/sources/HeuristicLab.Data.Views/3.3/StringConvertibleMatrixView.cs
===================================================================
--- trunk/sources/HeuristicLab.Data.Views/3.3/StringConvertibleMatrixView.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Data.Views/3.3/StringConvertibleMatrixView.cs	(revision 3048)
@@ -29,15 +29,15 @@
 
 namespace HeuristicLab.Data.Views {
-  [View("StringConvertibleMatrixData View")]
-  [Content(typeof(IStringConvertibleMatrixData), true)]
-  public partial class StringConvertibleMatrixDataView : ContentView {
-    public new IStringConvertibleMatrixData Content {
-      get { return (IStringConvertibleMatrixData)base.Content; }
+  [View("StringConvertibleMatrix View")]
+  [Content(typeof(IStringConvertibleMatrix), true)]
+  public partial class StringConvertibleMatrixView : ContentView {
+    public new IStringConvertibleMatrix Content {
+      get { return (IStringConvertibleMatrix)base.Content; }
       set { base.Content = value; }
     }
 
-    public StringConvertibleMatrixDataView() {
+    public StringConvertibleMatrixView() {
       InitializeComponent();
-      Caption = "StringConvertibleMatrixData View";
+      Caption = "StringConvertibleMatrix View";
       errorProvider.SetIconAlignment(rowsTextBox, ErrorIconAlignment.MiddleLeft);
       errorProvider.SetIconPadding(rowsTextBox, 2);
@@ -45,5 +45,5 @@
       errorProvider.SetIconPadding(columnsTextBox, 2);
     }
-    public StringConvertibleMatrixDataView(IStringConvertibleMatrixData content)
+    public StringConvertibleMatrixView(IStringConvertibleMatrix content)
       : this() {
       Content = content;
@@ -66,5 +66,5 @@
       base.OnContentChanged();
       if (Content == null) {
-        Caption = "StringConvertibleMatrixData View";
+        Caption = "StringConvertibleMatrix View";
         rowsTextBox.Text = "";
         rowsTextBox.Enabled = false;
@@ -75,5 +75,5 @@
         dataGridView.Enabled = false;
       } else {
-        Caption = "StringConvertibleMatrixData (" + Content.GetType().Name + ")";
+        Caption = "StringConvertibleMatrix (" + Content.GetType().Name + ")";
         UpdateData();
       }
Index: trunk/sources/HeuristicLab.Data.Views/3.3/StringConvertibleValueView.Designer.cs
===================================================================
--- trunk/sources/HeuristicLab.Data.Views/3.3/StringConvertibleValueView.Designer.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Data.Views/3.3/StringConvertibleValueView.Designer.cs	(revision 3048)
@@ -21,5 +21,5 @@
 
 namespace HeuristicLab.Data.Views {
-  partial class StringConvertibleDataView {
+  partial class StringConvertibleValueView {
     /// <summary> 
     /// Required designer variable.
@@ -78,5 +78,5 @@
       this.valueLabel.Text = "&Value:";
       // 
-      // StringConvertibleDataView
+      // StringConvertibleValueView
       // 
       this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
@@ -84,5 +84,5 @@
       this.Controls.Add(this.valueLabel);
       this.Controls.Add(this.valueTextBox);
-      this.Name = "StringConvertibleDataView";
+      this.Name = "StringConvertibleValueView";
       this.Size = new System.Drawing.Size(250, 38);
       ((System.ComponentModel.ISupportInitialize)(this.errorProvider)).EndInit();
Index: trunk/sources/HeuristicLab.Data.Views/3.3/StringConvertibleValueView.cs
===================================================================
--- trunk/sources/HeuristicLab.Data.Views/3.3/StringConvertibleValueView.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Data.Views/3.3/StringConvertibleValueView.cs	(revision 3048)
@@ -27,19 +27,19 @@
 
 namespace HeuristicLab.Data.Views {
-  [View("StringConvertibleData View")]
-  [Content(typeof(IStringConvertibleData), true)]
-  public partial class StringConvertibleDataView : ContentView {
-    public new IStringConvertibleData Content {
-      get { return (IStringConvertibleData)base.Content; }
+  [View("StringConvertibleValue View")]
+  [Content(typeof(IStringConvertibleValue), true)]
+  public partial class StringConvertibleValueView : ContentView {
+    public new IStringConvertibleValue Content {
+      get { return (IStringConvertibleValue)base.Content; }
       set { base.Content = value; }
     }
 
-    public StringConvertibleDataView() {
+    public StringConvertibleValueView() {
       InitializeComponent();
-      Caption = "StringConvertibleData View";
+      Caption = "StringConvertibleValue View";
       errorProvider.SetIconAlignment(valueTextBox, ErrorIconAlignment.MiddleLeft);
       errorProvider.SetIconPadding(valueTextBox, 2);
     }
-    public StringConvertibleDataView(IStringConvertibleData content)
+    public StringConvertibleValueView(IStringConvertibleValue content)
       : this() {
       Content = content;
@@ -59,5 +59,5 @@
       base.OnContentChanged();
       if (Content == null) {
-        Caption = "StringConvertibleData View";
+        Caption = "StringConvertibleValue View";
         valueTextBox.Text = string.Empty;
         valueTextBox.Enabled = false;
Index: trunk/sources/HeuristicLab.Data/3.3/BoolArray.cs
===================================================================
--- trunk/sources/HeuristicLab.Data/3.3/BoolArray.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Data/3.3/BoolArray.cs	(revision 3048)
@@ -25,26 +25,26 @@
 
 namespace HeuristicLab.Data {
-  [Item("BoolArrayData", "Represents an array of boolean values.")]
+  [Item("BoolArray", "Represents an array of boolean values.")]
   [Creatable("Test")]
   [StorableClass]
-  public sealed class BoolArrayData : ValueTypeArrayData<bool>, IStringConvertibleArrayData {
-    public BoolArrayData() : base() { }
-    public BoolArrayData(int length) : base(length) { }
-    public BoolArrayData(bool[] elements) : base(elements) { }
-    private BoolArrayData(BoolArrayData elements) : base(elements) { }
+  public sealed class BoolArray : ValueTypeArray<bool>, IStringConvertibleArray {
+    public BoolArray() : base() { }
+    public BoolArray(int length) : base(length) { }
+    public BoolArray(bool[] elements) : base(elements) { }
+    private BoolArray(BoolArray elements) : base(elements) { }
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      BoolArrayData clone = new BoolArrayData(this);
+      BoolArray clone = new BoolArray(this);
       cloner.RegisterClonedObject(this, clone);
       return clone;
     }
 
-    #region IStringConvertibleArrayData Members
-    int IStringConvertibleArrayData.Length {
+    #region IStringConvertibleArray Members
+    int IStringConvertibleArray.Length {
       get { return Length; }
       set { Length = value; }
     }
 
-    bool IStringConvertibleArrayData.Validate(string value, out string errorMessage) {
+    bool IStringConvertibleArray.Validate(string value, out string errorMessage) {
       bool val;
       bool valid = bool.TryParse(value, out val);
@@ -59,8 +59,8 @@
       return valid;
     }
-    string IStringConvertibleArrayData.GetValue(int index) {
+    string IStringConvertibleArray.GetValue(int index) {
       return this[index].ToString();
     }
-    bool IStringConvertibleArrayData.SetValue(string value, int index) {
+    bool IStringConvertibleArray.SetValue(string value, int index) {
       bool val;
       if (bool.TryParse(value, out val)) {
Index: trunk/sources/HeuristicLab.Data/3.3/BoolMatrix.cs
===================================================================
--- trunk/sources/HeuristicLab.Data/3.3/BoolMatrix.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Data/3.3/BoolMatrix.cs	(revision 3048)
@@ -25,30 +25,30 @@
 
 namespace HeuristicLab.Data {
-  [Item("BoolMatrixData", "Represents a matrix of boolean values.")]
+  [Item("BoolMatrix", "Represents a matrix of boolean values.")]
   [Creatable("Test")]
   [StorableClass]
-  public sealed class BoolMatrixData : ValueTypeMatrixData<bool>, IStringConvertibleMatrixData {
-    public BoolMatrixData() : base() { }
-    public BoolMatrixData(int rows, int columns) : base(rows, columns) { }
-    public BoolMatrixData(bool[,] elements) : base(elements) { }
-    private BoolMatrixData(BoolMatrixData elements) : base(elements) { }
+  public sealed class BoolMatrix : ValueTypeMatrix<bool>, IStringConvertibleMatrix {
+    public BoolMatrix() : base() { }
+    public BoolMatrix(int rows, int columns) : base(rows, columns) { }
+    public BoolMatrix(bool[,] elements) : base(elements) { }
+    private BoolMatrix(BoolMatrix elements) : base(elements) { }
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      BoolMatrixData clone = new BoolMatrixData(this);
+      BoolMatrix clone = new BoolMatrix(this);
       cloner.RegisterClonedObject(this, clone);
       return clone;
     }
 
-    #region IStringConvertibleMatrixData Members
-    int IStringConvertibleMatrixData.Rows {
+    #region IStringConvertibleMatrix Members
+    int IStringConvertibleMatrix.Rows {
       get { return Rows; }
       set { Rows = value; }
     }
-    int IStringConvertibleMatrixData.Columns {
+    int IStringConvertibleMatrix.Columns {
       get { return Columns; }
       set { Columns = value; }
     }
 
-    bool IStringConvertibleMatrixData.Validate(string value, out string errorMessage) {
+    bool IStringConvertibleMatrix.Validate(string value, out string errorMessage) {
       bool val;
       bool valid = bool.TryParse(value, out val);
@@ -63,8 +63,8 @@
       return valid;
     }
-    string IStringConvertibleMatrixData.GetValue(int rowIndex, int columIndex) {
+    string IStringConvertibleMatrix.GetValue(int rowIndex, int columIndex) {
       return this[rowIndex, columIndex].ToString();
     }
-    bool IStringConvertibleMatrixData.SetValue(string value, int rowIndex, int columnIndex) {
+    bool IStringConvertibleMatrix.SetValue(string value, int rowIndex, int columnIndex) {
       bool val;
       if (bool.TryParse(value, out val)) {
Index: trunk/sources/HeuristicLab.Data/3.3/BoolValue.cs
===================================================================
--- trunk/sources/HeuristicLab.Data/3.3/BoolValue.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Data/3.3/BoolValue.cs	(revision 3048)
@@ -26,13 +26,13 @@
 
 namespace HeuristicLab.Data {
-  [Item("BoolData", "Represents a boolean value.")]
+  [Item("BoolValue", "Represents a boolean value.")]
   [Creatable("Test")]
   [StorableClass]
-  public sealed class BoolData : ValueTypeData<bool>, IComparable, IStringConvertibleData {
-    public BoolData() : base() { }
-    public BoolData(bool value) : base(value) { }
+  public sealed class BoolValue : ValueTypeValue<bool>, IComparable, IStringConvertibleValue {
+    public BoolValue() : base() { }
+    public BoolValue(bool value) : base(value) { }
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      BoolData clone = new BoolData(Value);
+      BoolValue clone = new BoolValue(Value);
       cloner.RegisterClonedObject(this, clone);
       return clone;
@@ -40,5 +40,5 @@
 
     public int CompareTo(object obj) {
-      BoolData other = obj as BoolData;
+      BoolValue other = obj as BoolValue;
       if (other != null)
         return Value.CompareTo(other.Value);
@@ -47,6 +47,6 @@
     }
 
-    #region IStringConvertibleData Members
-    bool IStringConvertibleData.Validate(string value, out string errorMessage) {
+    #region IStringConvertibleValue Members
+    bool IStringConvertibleValue.Validate(string value, out string errorMessage) {
       bool val;
       bool valid = bool.TryParse(value, out val);
@@ -61,8 +61,8 @@
       return valid;
     }
-    string IStringConvertibleData.GetValue() {
+    string IStringConvertibleValue.GetValue() {
       return Value.ToString();
     }
-    bool IStringConvertibleData.SetValue(string value) {
+    bool IStringConvertibleValue.SetValue(string value) {
       bool val;
       if (bool.TryParse(value, out val)) {
Index: trunk/sources/HeuristicLab.Data/3.3/Comparison.cs
===================================================================
--- trunk/sources/HeuristicLab.Data/3.3/Comparison.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Data/3.3/Comparison.cs	(revision 3048)
@@ -25,13 +25,13 @@
 
 namespace HeuristicLab.Data {
-  [Item("ComparisonData", "Represents a comparison.")]
+  [Item("Comparison", "Represents a comparison.")]
   [Creatable("Test")]
   [StorableClass]
-  public sealed class ComparisonData : ValueTypeData<Comparison>, IComparable {
-    public ComparisonData() : base() { }
-    public ComparisonData(Comparison value) : base(value) { }
+  public sealed class Comparison : ValueTypeValue<ComparisonType>, IComparable {
+    public Comparison() : base() { }
+    public Comparison(ComparisonType value) : base(value) { }
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      ComparisonData clone = new ComparisonData(Value);
+      Comparison clone = new Comparison(Value);
       cloner.RegisterClonedObject(this, clone);
       return clone;
@@ -39,5 +39,5 @@
 
     public int CompareTo(object obj) {
-      ComparisonData other = obj as ComparisonData;
+      Comparison other = obj as Comparison;
       if (other != null)
         return Value.CompareTo(other.Value);
Index: trunk/sources/HeuristicLab.Data/3.3/ComparisonType.cs
===================================================================
--- trunk/sources/HeuristicLab.Data/3.3/ComparisonType.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Data/3.3/ComparisonType.cs	(revision 3048)
@@ -21,5 +21,5 @@
 
 namespace HeuristicLab.Data {
-  public enum Comparison {
+  public enum ComparisonType {
     Less,
     LessOrEqual,
Index: trunk/sources/HeuristicLab.Data/3.3/DateTimeValue.cs
===================================================================
--- trunk/sources/HeuristicLab.Data/3.3/DateTimeValue.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Data/3.3/DateTimeValue.cs	(revision 3048)
@@ -25,13 +25,13 @@
 
 namespace HeuristicLab.Data {
-  [Item("DateTimeData", "Represents a date and time value.")]
+  [Item("DateTimeValue", "Represents a date and time value.")]
   [Creatable("Test")]
   [StorableClass]
-  public sealed class DateTimeData : ValueTypeData<DateTime>, IComparable, IStringConvertibleData {
-    public DateTimeData() : base() { }
-    public DateTimeData(DateTime value) : base(value) { }
+  public sealed class DateTimeValue : ValueTypeValue<DateTime>, IComparable, IStringConvertibleValue {
+    public DateTimeValue() : base() { }
+    public DateTimeValue(DateTime value) : base(value) { }
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      DateTimeData clone = new DateTimeData(Value);
+      DateTimeValue clone = new DateTimeValue(Value);
       cloner.RegisterClonedObject(this, clone);
       return clone;
@@ -43,5 +43,5 @@
 
     public int CompareTo(object obj) {
-      DateTimeData other = obj as DateTimeData;
+      DateTimeValue other = obj as DateTimeValue;
       if (other != null)
         return Value.CompareTo(other.Value);
@@ -50,6 +50,6 @@
     }
 
-    #region IStringConvertibleData Members
-    bool IStringConvertibleData.Validate(string value, out string errorMessage) {
+    #region IStringConvertibleValue Members
+    bool IStringConvertibleValue.Validate(string value, out string errorMessage) {
       DateTime val;
       bool valid = DateTime.TryParse(value, out val);
@@ -57,8 +57,8 @@
       return valid;
     }
-    string IStringConvertibleData.GetValue() {
+    string IStringConvertibleValue.GetValue() {
       return Value.ToString("o");  // round-trip format
     }
-    bool IStringConvertibleData.SetValue(string value) {
+    bool IStringConvertibleValue.SetValue(string value) {
       DateTime val;
       if (DateTime.TryParse(value, out val)) {
Index: trunk/sources/HeuristicLab.Data/3.3/DoubleArray.cs
===================================================================
--- trunk/sources/HeuristicLab.Data/3.3/DoubleArray.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Data/3.3/DoubleArray.cs	(revision 3048)
@@ -25,26 +25,26 @@
 
 namespace HeuristicLab.Data {
-  [Item("DoubleArrayData", "Represents an array of double values.")]
+  [Item("DoubleArray", "Represents an array of double values.")]
   [Creatable("Test")]
   [StorableClass]
-  public sealed class DoubleArrayData : ValueTypeArrayData<double>, IStringConvertibleArrayData {
-    public DoubleArrayData() : base() { }
-    public DoubleArrayData(int length) : base(length) { }
-    public DoubleArrayData(double[] elements) : base(elements) { }
-    private DoubleArrayData(DoubleArrayData elements) : base(elements) { }
+  public sealed class DoubleArray : ValueTypeArray<double>, IStringConvertibleArray {
+    public DoubleArray() : base() { }
+    public DoubleArray(int length) : base(length) { }
+    public DoubleArray(double[] elements) : base(elements) { }
+    private DoubleArray(DoubleArray elements) : base(elements) { }
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      DoubleArrayData clone = new DoubleArrayData(this);
+      DoubleArray clone = new DoubleArray(this);
       cloner.RegisterClonedObject(this, clone);
       return clone;
     }
 
-    #region IStringConvertibleArrayData Members
-    int IStringConvertibleArrayData.Length {
+    #region IStringConvertibleArray Members
+    int IStringConvertibleArray.Length {
       get { return Length; }
       set { Length = value; }
     }
 
-    bool IStringConvertibleArrayData.Validate(string value, out string errorMessage) {
+    bool IStringConvertibleArray.Validate(string value, out string errorMessage) {
       double val;
       bool valid = double.TryParse(value, out val);
@@ -59,8 +59,8 @@
       return valid;
     }
-    string IStringConvertibleArrayData.GetValue(int index) {
+    string IStringConvertibleArray.GetValue(int index) {
       return this[index].ToString();
     }
-    bool IStringConvertibleArrayData.SetValue(string value, int index) {
+    bool IStringConvertibleArray.SetValue(string value, int index) {
       double val;
       if (double.TryParse(value, out val)) {
Index: trunk/sources/HeuristicLab.Data/3.3/DoubleMatrix.cs
===================================================================
--- trunk/sources/HeuristicLab.Data/3.3/DoubleMatrix.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Data/3.3/DoubleMatrix.cs	(revision 3048)
@@ -25,30 +25,30 @@
 
 namespace HeuristicLab.Data {
-  [Item("DoubleMatrixData", "Represents a matrix of double values.")]
+  [Item("DoubleMatrix", "Represents a matrix of double values.")]
   [Creatable("Test")]
   [StorableClass]
-  public sealed class DoubleMatrixData : ValueTypeMatrixData<double>, IStringConvertibleMatrixData {
-    public DoubleMatrixData() : base() { }
-    public DoubleMatrixData(int rows, int columns) : base(rows, columns) { }
-    public DoubleMatrixData(double[,] elements) : base(elements) { }
-    private DoubleMatrixData(DoubleMatrixData elements) : base(elements) { }
+  public sealed class DoubleMatrix : ValueTypeMatrix<double>, IStringConvertibleMatrix {
+    public DoubleMatrix() : base() { }
+    public DoubleMatrix(int rows, int columns) : base(rows, columns) { }
+    public DoubleMatrix(double[,] elements) : base(elements) { }
+    private DoubleMatrix(DoubleMatrix elements) : base(elements) { }
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      DoubleMatrixData clone = new DoubleMatrixData(this);
+      DoubleMatrix clone = new DoubleMatrix(this);
       cloner.RegisterClonedObject(this, clone);
       return clone;
     }
 
-    #region IStringConvertibleMatrixData Members
-    int IStringConvertibleMatrixData.Rows {
+    #region IStringConvertibleMatrix Members
+    int IStringConvertibleMatrix.Rows {
       get { return Rows; }
       set { Rows = value; }
     }
-    int IStringConvertibleMatrixData.Columns {
+    int IStringConvertibleMatrix.Columns {
       get { return Columns; }
       set { Columns = value; }
     }
 
-    bool IStringConvertibleMatrixData.Validate(string value, out string errorMessage) {
+    bool IStringConvertibleMatrix.Validate(string value, out string errorMessage) {
       double val;
       bool valid = double.TryParse(value, out val);
@@ -63,8 +63,8 @@
       return valid;
     }
-    string IStringConvertibleMatrixData.GetValue(int rowIndex, int columIndex) {
+    string IStringConvertibleMatrix.GetValue(int rowIndex, int columIndex) {
       return this[rowIndex, columIndex].ToString();
     }
-    bool IStringConvertibleMatrixData.SetValue(string value, int rowIndex, int columnIndex) {
+    bool IStringConvertibleMatrix.SetValue(string value, int rowIndex, int columnIndex) {
       double val;
       if (double.TryParse(value, out val)) {
Index: trunk/sources/HeuristicLab.Data/3.3/DoubleValue.cs
===================================================================
--- trunk/sources/HeuristicLab.Data/3.3/DoubleValue.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Data/3.3/DoubleValue.cs	(revision 3048)
@@ -26,13 +26,13 @@
 
 namespace HeuristicLab.Data {
-  [Item("DoubleData", "Represents a double value.")]
+  [Item("DoubleValue", "Represents a double value.")]
   [Creatable("Test")]
   [StorableClass]
-  public sealed class DoubleData : ValueTypeData<double>, IComparable, IStringConvertibleData {
-    public DoubleData() : base() { }
-    public DoubleData(double value) : base(value) { }
+  public sealed class DoubleValue : ValueTypeValue<double>, IComparable, IStringConvertibleValue {
+    public DoubleValue() : base() { }
+    public DoubleValue(double value) : base(value) { }
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      DoubleData clone = new DoubleData(Value);
+      DoubleValue clone = new DoubleValue(Value);
       cloner.RegisterClonedObject(this, clone);
       return clone;
@@ -44,5 +44,5 @@
 
     public int CompareTo(object obj) {
-      DoubleData other = obj as DoubleData;
+      DoubleValue other = obj as DoubleValue;
       if (other != null)
         return Value.CompareTo(other.Value);
@@ -51,6 +51,6 @@
     }
 
-    #region IStringConvertibleData Members
-    bool IStringConvertibleData.Validate(string value, out string errorMessage) {
+    #region IStringConvertibleValue Members
+    bool IStringConvertibleValue.Validate(string value, out string errorMessage) {
       double val;
       bool valid = double.TryParse(value, out val);
@@ -65,8 +65,8 @@
       return valid;
     }
-    string IStringConvertibleData.GetValue() {
+    string IStringConvertibleValue.GetValue() {
       return Value.ToString("r");  // round-trip format
     }
-    bool IStringConvertibleData.SetValue(string value) {
+    bool IStringConvertibleValue.SetValue(string value) {
       double val;
       if (double.TryParse(value, out val)) {
Index: trunk/sources/HeuristicLab.Data/3.3/IStringConvertibleArray.cs
===================================================================
--- trunk/sources/HeuristicLab.Data/3.3/IStringConvertibleArray.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Data/3.3/IStringConvertibleArray.cs	(revision 3048)
@@ -24,5 +24,5 @@
 
 namespace HeuristicLab.Data {
-  public interface IStringConvertibleArrayData {
+  public interface IStringConvertibleArray {
     int Length { get; set; }
 
Index: trunk/sources/HeuristicLab.Data/3.3/IStringConvertibleMatrix.cs
===================================================================
--- trunk/sources/HeuristicLab.Data/3.3/IStringConvertibleMatrix.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Data/3.3/IStringConvertibleMatrix.cs	(revision 3048)
@@ -24,5 +24,5 @@
 
 namespace HeuristicLab.Data {
-  public interface IStringConvertibleMatrixData {
+  public interface IStringConvertibleMatrix {
     int Rows { get; set; }
     int Columns { get; set; }
Index: trunk/sources/HeuristicLab.Data/3.3/IStringConvertibleValue.cs
===================================================================
--- trunk/sources/HeuristicLab.Data/3.3/IStringConvertibleValue.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Data/3.3/IStringConvertibleValue.cs	(revision 3048)
@@ -23,5 +23,5 @@
 
 namespace HeuristicLab.Data {
-  public interface IStringConvertibleData {
+  public interface IStringConvertibleValue {
     bool Validate(string value, out string errorMessage);
     string GetValue();
Index: trunk/sources/HeuristicLab.Data/3.3/IntArray.cs
===================================================================
--- trunk/sources/HeuristicLab.Data/3.3/IntArray.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Data/3.3/IntArray.cs	(revision 3048)
@@ -25,26 +25,26 @@
 
 namespace HeuristicLab.Data {
-  [Item("IntArrayData", "Represents an array of integer values.")]
+  [Item("IntArray", "Represents an array of integer values.")]
   [Creatable("Test")]
   [StorableClass]
-  public sealed class IntArrayData : ValueTypeArrayData<int>, IStringConvertibleArrayData {
-    public IntArrayData() : base() { }
-    public IntArrayData(int length) : base(length) { }
-    public IntArrayData(int[] elements) : base(elements) { }
-    private IntArrayData(IntArrayData elements) : base(elements) { }
+  public sealed class IntArray : ValueTypeArray<int>, IStringConvertibleArray {
+    public IntArray() : base() { }
+    public IntArray(int length) : base(length) { }
+    public IntArray(int[] elements) : base(elements) { }
+    private IntArray(IntArray elements) : base(elements) { }
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      IntArrayData clone = new IntArrayData(this);
+      IntArray clone = new IntArray(this);
       cloner.RegisterClonedObject(this, clone);
       return clone;
     }
 
-    #region IStringConvertibleArrayData Members
-    int IStringConvertibleArrayData.Length {
+    #region IStringConvertibleArray Members
+    int IStringConvertibleArray.Length {
       get { return Length; }
       set { Length = value; }
     }
 
-    bool IStringConvertibleArrayData.Validate(string value, out string errorMessage) {
+    bool IStringConvertibleArray.Validate(string value, out string errorMessage) {
       int val;
       bool valid = int.TryParse(value, out val);
@@ -59,8 +59,8 @@
       return valid;
     }
-    string IStringConvertibleArrayData.GetValue(int index) {
+    string IStringConvertibleArray.GetValue(int index) {
       return this[index].ToString();
     }
-    bool IStringConvertibleArrayData.SetValue(string value, int index) {
+    bool IStringConvertibleArray.SetValue(string value, int index) {
       int val;
       if (int.TryParse(value, out val)) {
Index: trunk/sources/HeuristicLab.Data/3.3/IntMatrix.cs
===================================================================
--- trunk/sources/HeuristicLab.Data/3.3/IntMatrix.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Data/3.3/IntMatrix.cs	(revision 3048)
@@ -25,30 +25,30 @@
 
 namespace HeuristicLab.Data {
-  [Item("IntMatrixData", "Represents a matrix of integer values.")]
+  [Item("IntMatrix", "Represents a matrix of integer values.")]
   [Creatable("Test")]
   [StorableClass]
-  public sealed class IntMatrixData : ValueTypeMatrixData<int>, IStringConvertibleMatrixData {
-    public IntMatrixData() : base() { }
-    public IntMatrixData(int rows, int columns) : base(rows, columns) { }
-    public IntMatrixData(int[,] elements) : base(elements) { }
-    private IntMatrixData(IntMatrixData elements) : base(elements) { }
+  public sealed class IntMatrix : ValueTypeMatrix<int>, IStringConvertibleMatrix {
+    public IntMatrix() : base() { }
+    public IntMatrix(int rows, int columns) : base(rows, columns) { }
+    public IntMatrix(int[,] elements) : base(elements) { }
+    private IntMatrix(IntMatrix elements) : base(elements) { }
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      IntMatrixData clone = new IntMatrixData(this);
+      IntMatrix clone = new IntMatrix(this);
       cloner.RegisterClonedObject(this, clone);
       return clone;
     }
 
-    #region IStringConvertibleMatrixData Members
-    int IStringConvertibleMatrixData.Rows {
+    #region IStringConvertibleMatrix Members
+    int IStringConvertibleMatrix.Rows {
       get { return Rows; }
       set { Rows = value; }
     }
-    int IStringConvertibleMatrixData.Columns {
+    int IStringConvertibleMatrix.Columns {
       get { return Columns; }
       set { Columns = value; }
     }
 
-    bool IStringConvertibleMatrixData.Validate(string value, out string errorMessage) {
+    bool IStringConvertibleMatrix.Validate(string value, out string errorMessage) {
       int val;
       bool valid = int.TryParse(value, out val);
@@ -63,8 +63,8 @@
       return valid;
     }
-    string IStringConvertibleMatrixData.GetValue(int rowIndex, int columIndex) {
+    string IStringConvertibleMatrix.GetValue(int rowIndex, int columIndex) {
       return this[rowIndex, columIndex].ToString();
     }
-    bool IStringConvertibleMatrixData.SetValue(string value, int rowIndex, int columnIndex) {
+    bool IStringConvertibleMatrix.SetValue(string value, int rowIndex, int columnIndex) {
       int val;
       if (int.TryParse(value, out val)) {
Index: trunk/sources/HeuristicLab.Data/3.3/IntValue.cs
===================================================================
--- trunk/sources/HeuristicLab.Data/3.3/IntValue.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Data/3.3/IntValue.cs	(revision 3048)
@@ -26,13 +26,13 @@
 
 namespace HeuristicLab.Data {
-  [Item("IntData", "Represents an integer value.")]
+  [Item("IntValue", "Represents an integer value.")]
   [Creatable("Test")]
   [StorableClass]
-  public sealed class IntData : ValueTypeData<int>, IComparable, IStringConvertibleData {
-    public IntData() : base() { }
-    public IntData(int value) : base(value) { }
+  public sealed class IntValue : ValueTypeValue<int>, IComparable, IStringConvertibleValue {
+    public IntValue() : base() { }
+    public IntValue(int value) : base(value) { }
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      IntData clone = new IntData(Value);
+      IntValue clone = new IntValue(Value);
       cloner.RegisterClonedObject(this, clone);
       return clone;
@@ -40,5 +40,5 @@
 
     public int CompareTo(object obj) {
-      IntData other = obj as IntData;
+      IntValue other = obj as IntValue;
       if (other != null)
         return Value.CompareTo(other.Value);
@@ -47,6 +47,6 @@
     }
 
-    #region IStringConvertibleData Members
-    bool IStringConvertibleData.Validate(string value, out string errorMessage) {
+    #region IStringConvertibleValue Members
+    bool IStringConvertibleValue.Validate(string value, out string errorMessage) {
       int val;
       bool valid = int.TryParse(value, out val);
@@ -61,8 +61,8 @@
       return valid;
     }
-    string IStringConvertibleData.GetValue() {
+    string IStringConvertibleValue.GetValue() {
       return Value.ToString();
     }
-    bool IStringConvertibleData.SetValue(string value) {
+    bool IStringConvertibleValue.SetValue(string value) {
       int val;
       if (int.TryParse(value, out val)) {
Index: trunk/sources/HeuristicLab.Data/3.3/StringArray.cs
===================================================================
--- trunk/sources/HeuristicLab.Data/3.3/StringArray.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Data/3.3/StringArray.cs	(revision 3048)
@@ -28,8 +28,8 @@
 
 namespace HeuristicLab.Data {
-  [Item("StringArrayData", "Represents an array of strings.")]
+  [Item("StringArray", "Represents an array of strings.")]
   [Creatable("Test")]
   [StorableClass]
-  public sealed class StringArrayData : Item, IEnumerable, IStringConvertibleArrayData {
+  public sealed class StringArray : Item, IEnumerable, IStringConvertibleArray {
     [Storable]
     private string[] array;
@@ -56,13 +56,13 @@
     }
 
-    public StringArrayData() {
+    public StringArray() {
       array = new string[0];
     }
-    public StringArrayData(int length) {
+    public StringArray(int length) {
       array = new string[length];
       for (int i = 0; i < array.Length; i++)
         array[i] = string.Empty;
     }
-    public StringArrayData(string[] elements) {
+    public StringArray(string[] elements) {
       if (elements == null) throw new ArgumentNullException();
       array = new string[elements.Length];
@@ -70,5 +70,5 @@
         array[i] = elements[i] == null ? string.Empty : elements[i];
     }
-    private StringArrayData(StringArrayData elements) {
+    private StringArray(StringArray elements) {
       if (elements == null) throw new ArgumentNullException();
       array = (string[])elements.array.Clone();
@@ -76,5 +76,5 @@
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      StringArrayData clone = new StringArrayData(this);
+      StringArray clone = new StringArray(this);
       cloner.RegisterClonedObject(this, clone);
       return clone;
@@ -97,11 +97,11 @@
     }
 
-    #region IStringConvertibleArrayData Members
-    int IStringConvertibleArrayData.Length {
+    #region IStringConvertibleArray Members
+    int IStringConvertibleArray.Length {
       get { return Length; }
       set { Length = value; }
     }
 
-    bool IStringConvertibleArrayData.Validate(string value, out string errorMessage) {
+    bool IStringConvertibleArray.Validate(string value, out string errorMessage) {
       if (value == null) {
         errorMessage = "Invalid Value (string must not be null)";
@@ -112,8 +112,8 @@
       }
     }
-    string IStringConvertibleArrayData.GetValue(int index) {
+    string IStringConvertibleArray.GetValue(int index) {
       return this[index];
     }
-    bool IStringConvertibleArrayData.SetValue(string value, int index) {
+    bool IStringConvertibleArray.SetValue(string value, int index) {
       if (value != null) {
         this[index] = value;
Index: trunk/sources/HeuristicLab.Data/3.3/StringMatrix.cs
===================================================================
--- trunk/sources/HeuristicLab.Data/3.3/StringMatrix.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Data/3.3/StringMatrix.cs	(revision 3048)
@@ -28,8 +28,8 @@
 
 namespace HeuristicLab.Data {
-  [Item("StringMatrixData", "Represents a matrix of strings.")]
+  [Item("StringMatrix", "Represents a matrix of strings.")]
   [Creatable("Test")]
   [StorableClass]
-  public sealed class StringMatrixData : Item, IEnumerable, IStringConvertibleMatrixData {
+  public sealed class StringMatrix : Item, IEnumerable, IStringConvertibleMatrix {
     [Storable]
     private string[,] array;
@@ -70,8 +70,8 @@
     }
 
-    public StringMatrixData() {
+    public StringMatrix() {
       array = new string[0, 0];
     }
-    public StringMatrixData(int rows, int columns) {
+    public StringMatrix(int rows, int columns) {
       array = new string[rows, columns];
       for (int i = 0; i < array.GetLength(0); i++) {
@@ -80,5 +80,5 @@
       }
     }
-    public StringMatrixData(string[,] elements) {
+    public StringMatrix(string[,] elements) {
       if (elements == null) throw new ArgumentNullException();
       array = new string[elements.GetLength(0), elements.GetLength(1)];
@@ -88,5 +88,5 @@
       }
     }
-    private StringMatrixData(StringMatrixData elements) {
+    private StringMatrix(StringMatrix elements) {
       if (elements == null) throw new ArgumentNullException();
       array = (string[,])elements.array.Clone();
@@ -94,5 +94,5 @@
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      StringMatrixData clone = new StringMatrixData(this);
+      StringMatrix clone = new StringMatrix(this);
       cloner.RegisterClonedObject(this, clone);
       return clone;
@@ -118,15 +118,15 @@
     }
 
-    #region IStringConvertibleMatrixData Members
-    int IStringConvertibleMatrixData.Rows {
+    #region IStringConvertibleMatrix Members
+    int IStringConvertibleMatrix.Rows {
       get { return Rows; }
       set { Rows = value; }
     }
-    int IStringConvertibleMatrixData.Columns {
+    int IStringConvertibleMatrix.Columns {
       get { return Columns; }
       set { Columns = value; }
     }
 
-    bool IStringConvertibleMatrixData.Validate(string value, out string errorMessage) {
+    bool IStringConvertibleMatrix.Validate(string value, out string errorMessage) {
       if (value == null) {
         errorMessage = "Invalid Value (string must not be null)";
@@ -137,8 +137,8 @@
       }
     }
-    string IStringConvertibleMatrixData.GetValue(int rowIndex, int columIndex) {
+    string IStringConvertibleMatrix.GetValue(int rowIndex, int columIndex) {
       return this[rowIndex, columIndex];
     }
-    bool IStringConvertibleMatrixData.SetValue(string value, int rowIndex, int columnIndex) {
+    bool IStringConvertibleMatrix.SetValue(string value, int rowIndex, int columnIndex) {
       if (value != null) {
         this[rowIndex, columnIndex] = value;
Index: trunk/sources/HeuristicLab.Data/3.3/StringValue.cs
===================================================================
--- trunk/sources/HeuristicLab.Data/3.3/StringValue.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Data/3.3/StringValue.cs	(revision 3048)
@@ -25,8 +25,8 @@
 
 namespace HeuristicLab.Data {
-  [Item("StringData", "Represents a string.")]
+  [Item("StringValue", "Represents a string.")]
   [Creatable("Test")]
   [StorableClass]
-  public sealed class StringData : Item, IComparable, IStringConvertibleData {
+  public sealed class StringValue : Item, IComparable, IStringConvertibleValue {
     [Storable]
     private string value;
@@ -43,13 +43,13 @@
     }
 
-    public StringData() {
+    public StringValue() {
       this.value = string.Empty;
     }
-    public StringData(string value) {
+    public StringValue(string value) {
       this.value = value != null ? value : string.Empty;
     }
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      StringData clone = new StringData(Value);
+      StringValue clone = new StringValue(Value);
       cloner.RegisterClonedObject(this, clone);
       return clone;
@@ -61,5 +61,5 @@
 
     public int CompareTo(object obj) {
-      StringData other = obj as StringData;
+      StringValue other = obj as StringValue;
       if (other != null)
         return Value.CompareTo(other.Value);
@@ -75,6 +75,6 @@
     }
 
-    #region IStringConvertibleData Members
-    bool IStringConvertibleData.Validate(string value, out string errorMessage) {
+    #region IStringConvertibleValue Members
+    bool IStringConvertibleValue.Validate(string value, out string errorMessage) {
       if (value == null) {
         errorMessage = "Invalid Value (string must not be null)";
@@ -85,8 +85,8 @@
       }
     }
-    string IStringConvertibleData.GetValue() {
+    string IStringConvertibleValue.GetValue() {
       return Value;
     }
-    bool IStringConvertibleData.SetValue(string value) {
+    bool IStringConvertibleValue.SetValue(string value) {
       if (value != null) {
         Value = value;
Index: trunk/sources/HeuristicLab.Data/3.3/TimeSpanValue.cs
===================================================================
--- trunk/sources/HeuristicLab.Data/3.3/TimeSpanValue.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Data/3.3/TimeSpanValue.cs	(revision 3048)
@@ -26,13 +26,13 @@
 
 namespace HeuristicLab.Data {
-  [Item("TimeSpanData", "Represents a duration of time.")]
+  [Item("TimeSpanValue", "Represents a duration of time.")]
   [Creatable("Test")]
   [StorableClass]
-  public sealed class TimeSpanData : ValueTypeData<TimeSpan>, IComparable, IStringConvertibleData {
-    public TimeSpanData() : base() { }
-    public TimeSpanData(TimeSpan value) : base(value) { }
+  public sealed class TimeSpanValue : ValueTypeValue<TimeSpan>, IComparable, IStringConvertibleValue {
+    public TimeSpanValue() : base() { }
+    public TimeSpanValue(TimeSpan value) : base(value) { }
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      TimeSpanData clone = new TimeSpanData(Value);
+      TimeSpanValue clone = new TimeSpanValue(Value);
       cloner.RegisterClonedObject(this, clone);
       return clone;
@@ -40,5 +40,5 @@
 
     public int CompareTo(object obj) {
-      TimeSpanData other = obj as TimeSpanData;
+      TimeSpanValue other = obj as TimeSpanValue;
       if (other != null)
         return Value.CompareTo(other.Value);
@@ -47,6 +47,6 @@
     }
 
-    #region IStringConvertibleData Members
-    bool IStringConvertibleData.Validate(string value, out string errorMessage) {
+    #region IStringConvertibleValue Members
+    bool IStringConvertibleValue.Validate(string value, out string errorMessage) {
       TimeSpan val;
       bool valid = TimeSpan.TryParse(value, out val);
@@ -61,8 +61,8 @@
       return valid;
     }
-    string IStringConvertibleData.GetValue() {
+    string IStringConvertibleValue.GetValue() {
       return Value.ToString();
     }
-    bool IStringConvertibleData.SetValue(string value) {
+    bool IStringConvertibleValue.SetValue(string value) {
       TimeSpan val;
       if (TimeSpan.TryParse(value, out val)) {
Index: trunk/sources/HeuristicLab.Data/3.3/ValueTypeArray.cs
===================================================================
--- trunk/sources/HeuristicLab.Data/3.3/ValueTypeArray.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Data/3.3/ValueTypeArray.cs	(revision 3048)
@@ -28,7 +28,7 @@
 
 namespace HeuristicLab.Data {
-  [Item("ValueTypeArrayData<T>", "A base class for representing arrays of value types.")]
+  [Item("ValueTypeArray<T>", "A base class for representing arrays of value types.")]
   [StorableClass]
-  public class ValueTypeArrayData<T> : Item, IEnumerable where T : struct {
+  public class ValueTypeArray<T> : Item, IEnumerable where T : struct {
     [Storable]
     private T[] array;
@@ -53,15 +53,15 @@
     }
 
-    public ValueTypeArrayData() {
+    public ValueTypeArray() {
       array = new T[0];
     }
-    public ValueTypeArrayData(int length) {
+    public ValueTypeArray(int length) {
       array = new T[length];
     }
-    public ValueTypeArrayData(T[] elements) {
+    public ValueTypeArray(T[] elements) {
       if (elements == null) throw new ArgumentNullException();
       array = (T[])elements.Clone();
     }
-    protected ValueTypeArrayData(ValueTypeArrayData<T> elements) {
+    protected ValueTypeArray(ValueTypeArray<T> elements) {
       if (elements == null) throw new ArgumentNullException();
       array = (T[])elements.array.Clone();
@@ -69,5 +69,5 @@
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      ValueTypeArrayData<T> clone = (ValueTypeArrayData<T>)base.Clone(cloner);
+      ValueTypeArray<T> clone = (ValueTypeArray<T>)base.Clone(cloner);
       clone.array = (T[])array.Clone();
       return clone;
Index: trunk/sources/HeuristicLab.Data/3.3/ValueTypeMatrix.cs
===================================================================
--- trunk/sources/HeuristicLab.Data/3.3/ValueTypeMatrix.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Data/3.3/ValueTypeMatrix.cs	(revision 3048)
@@ -28,7 +28,7 @@
 
 namespace HeuristicLab.Data {
-  [Item("ValueTypeMatrixData<T>", "A base class for representing matrices of value types.")]
+  [Item("ValueTypeMatrix<T>", "A base class for representing matrices of value types.")]
   [StorableClass]
-  public class ValueTypeMatrixData<T> : Item, IEnumerable where T : struct {
+  public class ValueTypeMatrix<T> : Item, IEnumerable where T : struct {
     [Storable]
     private T[,] array;
@@ -67,15 +67,15 @@
     }
 
-    public ValueTypeMatrixData() {
+    public ValueTypeMatrix() {
       array = new T[0, 0];
     }
-    public ValueTypeMatrixData(int rows, int columns) {
+    public ValueTypeMatrix(int rows, int columns) {
       array = new T[rows, columns];
     }
-    public ValueTypeMatrixData(T[,] elements) {
+    public ValueTypeMatrix(T[,] elements) {
       if (elements == null) throw new ArgumentNullException();
       array = (T[,])elements.Clone();
     }
-    protected ValueTypeMatrixData(ValueTypeMatrixData<T> elements) {
+    protected ValueTypeMatrix(ValueTypeMatrix<T> elements) {
       if (elements == null) throw new ArgumentNullException();
       array = (T[,])elements.array.Clone();
@@ -83,5 +83,5 @@
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      ValueTypeMatrixData<T> clone = (ValueTypeMatrixData<T>)base.Clone(cloner);
+      ValueTypeMatrix<T> clone = (ValueTypeMatrix<T>)base.Clone(cloner);
       clone.array = (T[,])array.Clone();
       return clone;
Index: trunk/sources/HeuristicLab.Data/3.3/ValueTypeValue.cs
===================================================================
--- trunk/sources/HeuristicLab.Data/3.3/ValueTypeValue.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Data/3.3/ValueTypeValue.cs	(revision 3048)
@@ -25,7 +25,7 @@
 
 namespace HeuristicLab.Data {
-  [Item("ValueTypeData<T>", "A base class for representing value types.")]
+  [Item("ValueTypeValue<T>", "A base class for representing value types.")]
   [StorableClass]
-  public class ValueTypeData<T> : Item where T : struct {
+  public class ValueTypeValue<T> : Item where T : struct {
     [Storable]
     private T value;
@@ -40,13 +40,13 @@
     }
 
-    public ValueTypeData() {
+    public ValueTypeValue() {
       this.value = default(T);
     }
-    public ValueTypeData(T value) {
+    public ValueTypeValue(T value) {
       this.value = value;
     }
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      ValueTypeData<T> clone = (ValueTypeData<T>)base.Clone(cloner);
+      ValueTypeValue<T> clone = (ValueTypeValue<T>)base.Clone(cloner);
       clone.value = value;
       return clone;
Index: trunk/sources/HeuristicLab.Encodings.BinaryVectors/3.3/BinaryVectorCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.BinaryVectors/3.3/BinaryVectorCreator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.BinaryVectors/3.3/BinaryVectorCreator.cs	(revision 3048)
@@ -37,9 +37,9 @@
       get { return (LookupParameter<IRandom>)Parameters["Random"]; }
     }
-    public ILookupParameter<BoolArrayData> BinaryVectorParameter {
-      get { return (ILookupParameter<BoolArrayData>)Parameters["BinaryVector"]; }
+    public ILookupParameter<BoolArray> BinaryVectorParameter {
+      get { return (ILookupParameter<BoolArray>)Parameters["BinaryVector"]; }
     }
-    public IValueLookupParameter<IntData> LengthParameter {
-      get { return (IValueLookupParameter<IntData>)Parameters["Length"]; }
+    public IValueLookupParameter<IntValue> LengthParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["Length"]; }
     }
 
@@ -47,6 +47,6 @@
       : base() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
-      Parameters.Add(new LookupParameter<IntArrayData>("BinaryVector", "The vector which should be manipulated."));
-      Parameters.Add(new ValueLookupParameter<IntData>("Length", "The length of the vector."));
+      Parameters.Add(new LookupParameter<IntArray>("BinaryVector", "The vector which should be manipulated."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("Length", "The length of the vector."));
     }
 
@@ -56,5 +56,5 @@
     }
 
-    protected abstract BoolArrayData Create(IRandom random, IntData length);
+    protected abstract BoolArray Create(IRandom random, IntValue length);
   }
 }
Index: trunk/sources/HeuristicLab.Encodings.BinaryVectors/3.3/BinaryVectorCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.BinaryVectors/3.3/BinaryVectorCrossover.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.BinaryVectors/3.3/BinaryVectorCrossover.cs	(revision 3048)
@@ -37,9 +37,9 @@
       get { return (LookupParameter<IRandom>)Parameters["Random"]; }
     }
-    public ILookupParameter<ItemArray<BoolArrayData>> ParentsParameter {
-      get { return (SubScopesLookupParameter<BoolArrayData>)Parameters["Parents"]; }
+    public ILookupParameter<ItemArray<BoolArray>> ParentsParameter {
+      get { return (SubScopesLookupParameter<BoolArray>)Parameters["Parents"]; }
     }
-    public ILookupParameter<BoolArrayData> ChildParameter {
-      get { return (ILookupParameter<BoolArrayData>)Parameters["Child"]; }
+    public ILookupParameter<BoolArray> ChildParameter {
+      get { return (ILookupParameter<BoolArray>)Parameters["Child"]; }
     }
 
@@ -47,6 +47,6 @@
       : base() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic crossover operators."));
-      Parameters.Add(new SubScopesLookupParameter<IntArrayData>("Parents", "The parent vectors which should be crossed."));
-      Parameters.Add(new LookupParameter<IntArrayData>("Child", "The child vector resulting from the crossover."));
+      Parameters.Add(new SubScopesLookupParameter<IntArray>("Parents", "The parent vectors which should be crossed."));
+      Parameters.Add(new LookupParameter<IntArray>("Child", "The child vector resulting from the crossover."));
     }
 
@@ -56,5 +56,5 @@
     }
 
-    protected abstract BoolArrayData Cross(IRandom random, ItemArray<BoolArrayData> parents);
+    protected abstract BoolArray Cross(IRandom random, ItemArray<BoolArray> parents);
   }
 }
Index: trunk/sources/HeuristicLab.Encodings.BinaryVectors/3.3/BinaryVectorManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.BinaryVectors/3.3/BinaryVectorManipulator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.BinaryVectors/3.3/BinaryVectorManipulator.cs	(revision 3048)
@@ -37,6 +37,6 @@
       get { return (LookupParameter<IRandom>)Parameters["Random"]; }
     }
-    public ILookupParameter<BoolArrayData> BinaryVectorParameter {
-      get { return (ILookupParameter<BoolArrayData>)Parameters["BinaryVector"]; }
+    public ILookupParameter<BoolArray> BinaryVectorParameter {
+      get { return (ILookupParameter<BoolArray>)Parameters["BinaryVector"]; }
     }
 
@@ -44,5 +44,5 @@
       : base() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
-      Parameters.Add(new LookupParameter<IntArrayData>("BinaryVector", "The vector which should be manipulated."));
+      Parameters.Add(new LookupParameter<IntArray>("BinaryVector", "The vector which should be manipulated."));
     }
 
@@ -52,5 +52,5 @@
     }
 
-    protected abstract void Manipulate(IRandom random, BoolArrayData binaryVector);
+    protected abstract void Manipulate(IRandom random, BoolArray binaryVector);
   }
 }
Index: trunk/sources/HeuristicLab.Encodings.BinaryVectors/3.3/HeuristicLab.Encodings.BinaryVectors-3.3.csproj
===================================================================
--- trunk/sources/HeuristicLab.Encodings.BinaryVectors/3.3/HeuristicLab.Encodings.BinaryVectors-3.3.csproj	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.BinaryVectors/3.3/HeuristicLab.Encodings.BinaryVectors-3.3.csproj	(revision 3048)
@@ -32,4 +32,36 @@
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x64\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
+    <OutputPath>bin\x64\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x86\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
+    <OutputPath>bin\x86\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
   </PropertyGroup>
   <ItemGroup>
Index: trunk/sources/HeuristicLab.Encodings.BinaryVectors/3.3/Interfaces/IBinaryVectorCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.BinaryVectors/3.3/Interfaces/IBinaryVectorCreator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.BinaryVectors/3.3/Interfaces/IBinaryVectorCreator.cs	(revision 3048)
@@ -29,6 +29,6 @@
   /// </summary>
   public interface IBinaryVectorCreator : IBinaryVectorOperator, ISolutionCreator {
-    IValueLookupParameter<IntData> LengthParameter { get; }
-    ILookupParameter<BoolArrayData> BinaryVectorParameter { get; }
+    IValueLookupParameter<IntValue> LengthParameter { get; }
+    ILookupParameter<BoolArray> BinaryVectorParameter { get; }
   }
 }
Index: trunk/sources/HeuristicLab.Encodings.BinaryVectors/3.3/Interfaces/IBinaryVectorCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.BinaryVectors/3.3/Interfaces/IBinaryVectorCrossover.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.BinaryVectors/3.3/Interfaces/IBinaryVectorCrossover.cs	(revision 3048)
@@ -29,6 +29,6 @@
   /// </summary>
   public interface IBinaryVectorCrossover : IBinaryVectorOperator, ICrossover {
-    ILookupParameter<ItemArray<BoolArrayData>> ParentsParameter { get; }
-    ILookupParameter<BoolArrayData> ChildParameter { get; }
+    ILookupParameter<ItemArray<BoolArray>> ParentsParameter { get; }
+    ILookupParameter<BoolArray> ChildParameter { get; }
   }
 }
Index: trunk/sources/HeuristicLab.Encodings.BinaryVectors/3.3/Interfaces/IBinaryVectorManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.BinaryVectors/3.3/Interfaces/IBinaryVectorManipulator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.BinaryVectors/3.3/Interfaces/IBinaryVectorManipulator.cs	(revision 3048)
@@ -29,5 +29,5 @@
   /// </summary>
   public interface IBinaryVectorManipulator : IBinaryVectorOperator, IManipulator {
-    ILookupParameter<BoolArrayData> BinaryVectorParameter { get; }
+    ILookupParameter<BoolArray> BinaryVectorParameter { get; }
   }
 }
Index: trunk/sources/HeuristicLab.Encodings.BinaryVectors/3.3/Tests/Auxiliary.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.BinaryVectors/3.3/Tests/Auxiliary.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.BinaryVectors/3.3/Tests/Auxiliary.cs	(revision 3048)
@@ -25,5 +25,5 @@
 namespace HeuristicLab.Encodings.IntVector_33.Tests {
   public static class Auxiliary {
-    public static bool BoolVectorIsEqualByPosition(BoolArrayData p1, BoolArrayData p2) {
+    public static bool BoolVectorIsEqualByPosition(BoolArray p1, BoolArray p2) {
       bool equal = (p1.Length == p2.Length);
       if (equal) {
Index: trunk/sources/HeuristicLab.Encodings.BinaryVectors/3.3/Tests/HeuristicLab.Encodings.BinaryVectors-3.3.Tests.csproj
===================================================================
--- trunk/sources/HeuristicLab.Encodings.BinaryVectors/3.3/Tests/HeuristicLab.Encodings.BinaryVectors-3.3.Tests.csproj	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.BinaryVectors/3.3/Tests/HeuristicLab.Encodings.BinaryVectors-3.3.Tests.csproj	(revision 3048)
@@ -30,4 +30,36 @@
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x64\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
+    <OutputPath>bin\x64\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x86\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
+    <OutputPath>bin\x86\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
   </PropertyGroup>
   <ItemGroup>
Index: trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Creators/UniformRandomIntVectorCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Creators/UniformRandomIntVectorCreator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Creators/UniformRandomIntVectorCreator.cs	(revision 3048)
@@ -43,9 +43,9 @@
     /// <param name="max">The maximum value of the sampling range for each vector element (exclusive).</param>
     /// <returns>The newly created integer vector.</returns>
-    public static IntArrayData Apply(IRandom random, int length, int min, int max) {
+    public static IntArray Apply(IRandom random, int length, int min, int max) {
       int[] result = new int[length];
       for (int i = 0; i < length; i++)
         result[i] = random.Next(min, max);
-      return new IntArrayData(result);
+      return new IntArray(result);
     }
 
@@ -58,5 +58,5 @@
     /// <param name="maximum">The maximum value of the sampling range for each vector element (exclusive).</param>
     /// <returns>The newly created int vector.</returns>
-    protected override IntArrayData Create(IRandom random, IntData length, IntData minimum, IntData maximum) {
+    protected override IntArray Create(IRandom random, IntValue length, IntValue minimum, IntValue maximum) {
       return Apply(random, length.Value, minimum.Value, maximum.Value);
     }
Index: trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Crossovers/DiscreteCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Crossovers/DiscreteCrossover.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Crossovers/DiscreteCrossover.cs	(revision 3048)
@@ -45,5 +45,5 @@
     /// <param name="parent2">The second parent for the crossover operation.</param>
     /// <returns>The newly created integer vector, resulting from the crossover operation.</returns>
-    public static IntArrayData Apply(IRandom random, IntArrayData parent1, IntArrayData parent2) {
+    public static IntArray Apply(IRandom random, IntArray parent1, IntArray parent2) {
       if(parent1.Length != parent2.Length)
         throw new ArgumentException("DiscreteCrossover: The parents are of different length.");
@@ -58,5 +58,5 @@
           result[i] = parent2[i];
       }
-      return new IntArrayData(result);
+      return new IntArray(result);
     }
 
@@ -68,5 +68,5 @@
     /// <param name="parents">An array containing the two integer vectors that should be crossed.</param>
     /// <returns>The newly created integer vector, resulting from the crossover operation.</returns>
-    protected override IntArrayData Cross(IRandom random, ItemArray<IntArrayData> parents) {
+    protected override IntArray Cross(IRandom random, ItemArray<IntArray> parents) {
       if (parents.Length != 2) throw new ArgumentException("ERROR in DiscreteCrossover: The number of parents is not equal to 2");
       return Apply(random, parents[0], parents[1]);
Index: trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Crossovers/SinglePointCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Crossovers/SinglePointCrossover.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Crossovers/SinglePointCrossover.cs	(revision 3048)
@@ -45,5 +45,5 @@
     /// <param name="parent2">The second parent for crossover.</param>
     /// <returns>The newly created integer vector, resulting from the single point crossover.</returns>
-    public static IntArrayData Apply(IRandom random, IntArrayData parent1, IntArrayData parent2) {
+    public static IntArray Apply(IRandom random, IntArray parent1, IntArray parent2) {
       if (parent1.Length != parent2.Length)
         throw new ArgumentException("DiscreteCrossover: The parents are of different length.");
@@ -58,5 +58,5 @@
         result[i] = parent2[i];
 
-      return new IntArrayData(result);
+      return new IntArray(result);
     }
 
@@ -69,5 +69,5 @@
     /// <param name="parents">An array containing the two integer vectors that should be crossed.</param>
     /// <returns>The newly created integer vector, resulting from the single point crossover.</returns>
-    protected override IntArrayData Cross(IRandom random, ItemArray<IntArrayData> parents) {
+    protected override IntArray Cross(IRandom random, ItemArray<IntArray> parents) {
       if (parents.Length != 2) throw new ArgumentException("ERROR in SinglePointCrossover: The number of parents is not equal to 2");
       return Apply(random, parents[0], parents[1]);
Index: trunk/sources/HeuristicLab.Encodings.IntVector/3.3/HeuristicLab.Encodings.IntVector-3.3.csproj
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntVector/3.3/HeuristicLab.Encodings.IntVector-3.3.csproj	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.IntVector/3.3/HeuristicLab.Encodings.IntVector-3.3.csproj	(revision 3048)
@@ -32,4 +32,36 @@
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x64\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
+    <OutputPath>bin\x64\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x86\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
+    <OutputPath>bin\x86\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
   </PropertyGroup>
   <ItemGroup>
Index: trunk/sources/HeuristicLab.Encodings.IntVector/3.3/IntVectorCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntVector/3.3/IntVectorCreator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.IntVector/3.3/IntVectorCreator.cs	(revision 3048)
@@ -37,15 +37,15 @@
       get { return (LookupParameter<IRandom>)Parameters["Random"]; }
     }
-    public ILookupParameter<IntArrayData> IntVectorParameter {
-      get { return (ILookupParameter<IntArrayData>)Parameters["IntVector"]; }
+    public ILookupParameter<IntArray> IntVectorParameter {
+      get { return (ILookupParameter<IntArray>)Parameters["IntVector"]; }
     }
-    public IValueLookupParameter<IntData> LengthParameter {
-      get { return (IValueLookupParameter<IntData>)Parameters["Length"]; }
+    public IValueLookupParameter<IntValue> LengthParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["Length"]; }
     }
-    public IValueLookupParameter<IntData> MinimumParameter {
-      get { return (IValueLookupParameter<IntData>)Parameters["Minimum"]; }
+    public IValueLookupParameter<IntValue> MinimumParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["Minimum"]; }
     }
-    public IValueLookupParameter<IntData> MaximumParameter {
-      get { return (IValueLookupParameter<IntData>)Parameters["Maximum"]; }
+    public IValueLookupParameter<IntValue> MaximumParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["Maximum"]; }
     }
 
@@ -53,8 +53,8 @@
       : base() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
-      Parameters.Add(new LookupParameter<IntArrayData>("IntVector", "The vector which should be manipulated."));
-      Parameters.Add(new ValueLookupParameter<IntData>("Length", "The length of the vector."));
-      Parameters.Add(new ValueLookupParameter<IntData>("Minimum", "The lower bound for each element in the vector."));
-      Parameters.Add(new ValueLookupParameter<IntData>("Maximum", "The upper bound for each element in the vector."));
+      Parameters.Add(new LookupParameter<IntArray>("IntVector", "The vector which should be manipulated."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("Length", "The length of the vector."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("Minimum", "The lower bound for each element in the vector."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("Maximum", "The upper bound for each element in the vector."));
     }
 
@@ -64,5 +64,5 @@
     }
 
-    protected abstract IntArrayData Create(IRandom random, IntData length, IntData minimum, IntData maximum);
+    protected abstract IntArray Create(IRandom random, IntValue length, IntValue minimum, IntValue maximum);
   }
 }
Index: trunk/sources/HeuristicLab.Encodings.IntVector/3.3/IntVectorCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntVector/3.3/IntVectorCrossover.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.IntVector/3.3/IntVectorCrossover.cs	(revision 3048)
@@ -37,9 +37,9 @@
       get { return (LookupParameter<IRandom>)Parameters["Random"]; }
     }
-    public ILookupParameter<ItemArray<IntArrayData>> ParentsParameter {
-      get { return (SubScopesLookupParameter<IntArrayData>)Parameters["Parents"]; }
+    public ILookupParameter<ItemArray<IntArray>> ParentsParameter {
+      get { return (SubScopesLookupParameter<IntArray>)Parameters["Parents"]; }
     }
-    public ILookupParameter<IntArrayData> ChildParameter {
-      get { return (ILookupParameter<IntArrayData>)Parameters["Child"]; }
+    public ILookupParameter<IntArray> ChildParameter {
+      get { return (ILookupParameter<IntArray>)Parameters["Child"]; }
     }
 
@@ -47,6 +47,6 @@
       : base() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic crossover operators."));
-      Parameters.Add(new SubScopesLookupParameter<IntArrayData>("Parents", "The parent vectors which should be crossed."));
-      Parameters.Add(new LookupParameter<IntArrayData>("Child", "The child vector resulting from the crossover."));
+      Parameters.Add(new SubScopesLookupParameter<IntArray>("Parents", "The parent vectors which should be crossed."));
+      Parameters.Add(new LookupParameter<IntArray>("Child", "The child vector resulting from the crossover."));
     }
 
@@ -56,5 +56,5 @@
     }
 
-    protected abstract IntArrayData Cross(IRandom random, ItemArray<IntArrayData> parents);
+    protected abstract IntArray Cross(IRandom random, ItemArray<IntArray> parents);
   }
 }
Index: trunk/sources/HeuristicLab.Encodings.IntVector/3.3/IntVectorManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntVector/3.3/IntVectorManipulator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.IntVector/3.3/IntVectorManipulator.cs	(revision 3048)
@@ -37,6 +37,6 @@
       get { return (LookupParameter<IRandom>)Parameters["Random"]; }
     }
-    public ILookupParameter<IntArrayData> IntVectorParameter {
-      get { return (ILookupParameter<IntArrayData>)Parameters["IntVector"]; }
+    public ILookupParameter<IntArray> IntVectorParameter {
+      get { return (ILookupParameter<IntArray>)Parameters["IntVector"]; }
     }
 
@@ -44,5 +44,5 @@
       : base() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
-      Parameters.Add(new LookupParameter<IntArrayData>("IntVector", "The vector which should be manipulated."));
+      Parameters.Add(new LookupParameter<IntArray>("IntVector", "The vector which should be manipulated."));
     }
 
@@ -52,5 +52,5 @@
     }
 
-    protected abstract void Manipulate(IRandom random, IntArrayData intVector);
+    protected abstract void Manipulate(IRandom random, IntArray intVector);
   }
 }
Index: trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Interfaces/IIntVectorCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Interfaces/IIntVectorCreator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Interfaces/IIntVectorCreator.cs	(revision 3048)
@@ -29,8 +29,8 @@
   /// </summary>
   public interface IIntVectorCreator : IIntVectorOperator, ISolutionCreator {
-    IValueLookupParameter<IntData> LengthParameter { get; }
-    IValueLookupParameter<IntData> MinimumParameter { get; }
-    IValueLookupParameter<IntData> MaximumParameter { get; }
-    ILookupParameter<IntArrayData> IntVectorParameter { get; }
+    IValueLookupParameter<IntValue> LengthParameter { get; }
+    IValueLookupParameter<IntValue> MinimumParameter { get; }
+    IValueLookupParameter<IntValue> MaximumParameter { get; }
+    ILookupParameter<IntArray> IntVectorParameter { get; }
   }
 }
Index: trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Interfaces/IIntVectorCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Interfaces/IIntVectorCrossover.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Interfaces/IIntVectorCrossover.cs	(revision 3048)
@@ -29,6 +29,6 @@
   /// </summary>
   public interface IIntVectorCrossover : IIntVectorOperator, ICrossover {
-    ILookupParameter<ItemArray<IntArrayData>> ParentsParameter { get; }
-    ILookupParameter<IntArrayData> ChildParameter { get; }
+    ILookupParameter<ItemArray<IntArray>> ParentsParameter { get; }
+    ILookupParameter<IntArray> ChildParameter { get; }
   }
 }
Index: trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Interfaces/IIntVectorManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Interfaces/IIntVectorManipulator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Interfaces/IIntVectorManipulator.cs	(revision 3048)
@@ -29,5 +29,5 @@
   /// </summary>
   public interface IIntVectorManipulator : IIntVectorOperator, IManipulator {
-    ILookupParameter<IntArrayData> IntVectorParameter { get; }
+    ILookupParameter<IntArray> IntVectorParameter { get; }
   }
 }
Index: trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Manipulators/UniformOnePositionManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Manipulators/UniformOnePositionManipulator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Manipulators/UniformOnePositionManipulator.cs	(revision 3048)
@@ -42,12 +42,12 @@
     /// The lower bound of the values in the int vector.
     /// </summary>
-    public ValueLookupParameter<IntData> MinimumParameter {
-      get { return (ValueLookupParameter<IntData>)Parameters["Minimum"]; }
+    public ValueLookupParameter<IntValue> MinimumParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["Minimum"]; }
     }
     /// <summary>
     /// The upper bound of the values in the int vector.
     /// </summary>
-    public ValueLookupParameter<IntData> MaximumParameter {
-      get { return (ValueLookupParameter<IntData>)Parameters["Maximum"]; }
+    public ValueLookupParameter<IntValue> MaximumParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["Maximum"]; }
     }
 
@@ -57,6 +57,6 @@
     /// </summary>
     public UniformOnePositionManipulator() {
-      Parameters.Add(new ValueLookupParameter<IntData>("Minimum", "Minimum of the sampling range for the vector element (included)"));
-      Parameters.Add(new ValueLookupParameter<IntData>("Maximum", "Maximum of the sampling range for the vector element (excluded)"));
+      Parameters.Add(new ValueLookupParameter<IntValue>("Minimum", "Minimum of the sampling range for the vector element (included)"));
+      Parameters.Add(new ValueLookupParameter<IntValue>("Maximum", "Maximum of the sampling range for the vector element (excluded)"));
     }
 
@@ -70,5 +70,5 @@
     /// <param name="max">The maximum value of the sampling range for
     /// the vector element to change (exclusive).</param>
-    public static void Apply(IRandom random, IntArrayData vector, IntData min, IntData max) {
+    public static void Apply(IRandom random, IntArray vector, IntValue min, IntValue max) {
       int index = random.Next(vector.Length);
       vector[index] = random.Next(min.Value, max.Value);
@@ -81,5 +81,5 @@
     /// <param name="random">A random number generator.</param>
     /// <param name="vector">The integer vector to manipulate.</param>
-    protected override void Manipulate(IRandom random, IntArrayData vector) {
+    protected override void Manipulate(IRandom random, IntArray vector) {
       if (MinimumParameter.ActualValue == null) throw new InvalidOperationException("UniformOnePositionManipulator: Parameter " + MinimumParameter.ActualName + " could not be found.");
       if (MaximumParameter.ActualValue == null) throw new InvalidOperationException("UniformOnePositionManipulator: Parameter " + MaximumParameter.ActualName + " could not be found.");
Index: trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Tests/Auxiliary.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Tests/Auxiliary.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Tests/Auxiliary.cs	(revision 3048)
@@ -25,5 +25,5 @@
 namespace HeuristicLab.Encodings.IntVector_33.Tests {
   public static class Auxiliary {
-    public static bool IntVectorIsEqualByPosition(IntArrayData p1, IntArrayData p2) {
+    public static bool IntVectorIsEqualByPosition(IntArray p1, IntArray p2) {
       bool equal = (p1.Length == p2.Length);
       if (equal) {
Index: trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Tests/DiscreteCrossoverTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Tests/DiscreteCrossoverTest.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Tests/DiscreteCrossoverTest.cs	(revision 3048)
@@ -68,13 +68,13 @@
     public void DiscreteCrossoverCrossTest() {
       DiscreteCrossover_Accessor target = new DiscreteCrossover_Accessor(new PrivateObject(typeof(DiscreteCrossover)));
-      ItemArray<IntArrayData> parents;
+      ItemArray<IntArray> parents;
       TestRandom random = new TestRandom();
       bool exceptionFired;
       // The following test checks if there is an exception when there are less than 2 parents
       random.Reset();
-      parents = new ItemArray<IntArrayData>(new IntArrayData[] { new IntArrayData(4) });
+      parents = new ItemArray<IntArray>(new IntArray[] { new IntArray(4) });
       exceptionFired = false;
       try {
-        IntArrayData actual;
+        IntArray actual;
         actual = target.Cross(random, parents);
       } catch (System.ArgumentException) {
@@ -90,12 +90,12 @@
     public void DiscreteCrossoverApplyTest() {
       TestRandom random = new TestRandom();
-      IntArrayData parent1, parent2, expected, actual;
+      IntArray parent1, parent2, expected, actual;
       bool exceptionFired;
       // The following test is not based on published examples
       random.Reset();
       random.DoubleNumbers = new double[] { 0, 0, 0.9, 0, 0.9 };
-      parent1 = new IntArrayData(new int[] { 2, 2, 3, 5, 1 });
-      parent2 = new IntArrayData(new int[] { 4, 1, 3, 2, 8 });
-      expected = new IntArrayData(new int[] { 2, 2, 3, 5, 8 });
+      parent1 = new IntArray(new int[] { 2, 2, 3, 5, 1 });
+      parent2 = new IntArray(new int[] { 4, 1, 3, 2, 8 });
+      expected = new IntArray(new int[] { 2, 2, 3, 5, 8 });
       actual = DiscreteCrossover.Apply(random, parent1, parent2);
       Assert.IsTrue(Auxiliary.IntVectorIsEqualByPosition(actual, expected));
@@ -104,6 +104,6 @@
       random.Reset();
       random.DoubleNumbers = new double[] { 0, 0, 0.9, 0, 0.9 };
-      parent1 = new IntArrayData(new int[] { 2, 2, 3, 5, 1, 9 }); // this parent is longer
-      parent2 = new IntArrayData(new int[] { 4, 1, 3, 2, 8 });
+      parent1 = new IntArray(new int[] { 2, 2, 3, 5, 1, 9 }); // this parent is longer
+      parent2 = new IntArray(new int[] { 4, 1, 3, 2, 8 });
       exceptionFired = false;
       try {
Index: trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Tests/HeuristicLab.Encodings.IntVector-3.3.Tests.csproj
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Tests/HeuristicLab.Encodings.IntVector-3.3.Tests.csproj	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Tests/HeuristicLab.Encodings.IntVector-3.3.Tests.csproj	(revision 3048)
@@ -30,4 +30,36 @@
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x64\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
+    <OutputPath>bin\x64\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x86\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
+    <OutputPath>bin\x86\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
   </PropertyGroup>
   <ItemGroup>
Index: trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Tests/SinglePointCrossoverTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Tests/SinglePointCrossoverTest.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Tests/SinglePointCrossoverTest.cs	(revision 3048)
@@ -68,13 +68,13 @@
     public void SinglePointCrossoverCrossTest() {
       SinglePointCrossover_Accessor target = new SinglePointCrossover_Accessor(new PrivateObject(typeof(SinglePointCrossover)));
-      ItemArray<IntArrayData> parents;
+      ItemArray<IntArray> parents;
       TestRandom random = new TestRandom();
       bool exceptionFired;
       // The following test checks if there is an exception when there are more than 2 parents
       random.Reset();
-      parents = new ItemArray<IntArrayData>(new IntArrayData[] { new IntArrayData(5), new IntArrayData(6), new IntArrayData(4) });
+      parents = new ItemArray<IntArray>(new IntArray[] { new IntArray(5), new IntArray(6), new IntArray(4) });
       exceptionFired = false;
       try {
-        IntArrayData actual;
+        IntArray actual;
         actual = target.Cross(random, parents);
       }
@@ -85,8 +85,8 @@
       // The following test checks if there is an exception when there are less than 2 parents
       random.Reset();
-      parents = new ItemArray<IntArrayData>(new IntArrayData[] { new IntArrayData(4) });
+      parents = new ItemArray<IntArray>(new IntArray[] { new IntArray(4) });
       exceptionFired = false;
       try {
-        IntArrayData actual;
+        IntArray actual;
         actual = target.Cross(random, parents);
       } catch (System.ArgumentException) {
@@ -102,12 +102,12 @@
     public void SinglePointCrossoverApplyTest() {
       TestRandom random = new TestRandom();
-      IntArrayData parent1, parent2, expected, actual;
+      IntArray parent1, parent2, expected, actual;
       bool exceptionFired;
       // The following test is not based on published examples
       random.Reset();
       random.IntNumbers = new int[] { 3 };
-      parent1 = new IntArrayData(new int[] { 2, 2, 3, 5, 1 });
-      parent2 = new IntArrayData(new int[] { 4, 1, 3, 2, 8 });
-      expected = new IntArrayData(new int[] { 2, 2, 3, 2, 8 });
+      parent1 = new IntArray(new int[] { 2, 2, 3, 5, 1 });
+      parent2 = new IntArray(new int[] { 4, 1, 3, 2, 8 });
+      expected = new IntArray(new int[] { 2, 2, 3, 2, 8 });
       actual = SinglePointCrossover.Apply(random, parent1, parent2);
       Assert.IsTrue(Auxiliary.IntVectorIsEqualByPosition(actual, expected));
@@ -115,6 +115,6 @@
       random.Reset();
       random.IntNumbers = new int[] { 2 };
-      parent1 = new IntArrayData(new int[] { 2, 2, 3, 5, 1, 9 }); // this parent is longer
-      parent2 = new IntArrayData(new int[] { 4, 1, 3, 2, 8 });
+      parent1 = new IntArray(new int[] { 2, 2, 3, 5, 1, 9 }); // this parent is longer
+      parent2 = new IntArray(new int[] { 4, 1, 3, 2, 8 });
       exceptionFired = false;
       try {
Index: trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Tests/UniformOnePositionManipulatorTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Tests/UniformOnePositionManipulatorTest.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Tests/UniformOnePositionManipulatorTest.cs	(revision 3048)
@@ -85,13 +85,13 @@
     public void UniformOnePositionManipulatorApplyTest() {
       TestRandom random = new TestRandom();
-      IntArrayData parent, expected;
-      IntData min, max;
+      IntArray parent, expected;
+      IntValue min, max;
       // The following test is not based on published examples
       random.Reset();
       random.IntNumbers = new int[] { 3, 3 };
-      parent = new IntArrayData(new int[] { 2, 2, 3, 5, 1 });
-      expected = new IntArrayData(new int[] { 2, 2, 3, 3, 1 });
-      min = new IntData(2);
-      max = new IntData(7);
+      parent = new IntArray(new int[] { 2, 2, 3, 5, 1 });
+      expected = new IntArray(new int[] { 2, 2, 3, 3, 1 });
+      min = new IntValue(2);
+      max = new IntValue(7);
       UniformOnePositionManipulator.Apply(random, parent, min, max);
       Assert.IsTrue(Auxiliary.IntVectorIsEqualByPosition(expected, parent));
Index: trunk/sources/HeuristicLab.Encodings.Permutation/3.3/Creators/RandomPermutationCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.Permutation/3.3/Creators/RandomPermutationCreator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.Permutation/3.3/Creators/RandomPermutationCreator.cs	(revision 3048)
@@ -42,6 +42,6 @@
       get { return (LookupParameter<IRandom>)Parameters["Random"]; }
     }
-    public IValueLookupParameter<IntData> LengthParameter {
-      get { return (IValueLookupParameter<IntData>)Parameters["Length"]; }
+    public IValueLookupParameter<IntValue> LengthParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["Length"]; }
     }
     public ILookupParameter<Permutation> PermutationParameter {
@@ -52,5 +52,5 @@
       : base() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used to initialize the new random permutation."));
-      Parameters.Add(new ValueLookupParameter<IntData>("Length", "The length of the new random permutation."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("Length", "The length of the new random permutation."));
       Parameters.Add(new LookupParameter<Permutation>("Permutation", "The new random permutation."));
     }
Index: trunk/sources/HeuristicLab.Encodings.Permutation/3.3/Interfaces/IPermutationCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.Permutation/3.3/Interfaces/IPermutationCreator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.Permutation/3.3/Interfaces/IPermutationCreator.cs	(revision 3048)
@@ -29,5 +29,5 @@
   /// </summary>
   public interface IPermutationCreator : IPermutationOperator, ISolutionCreator {
-    IValueLookupParameter<IntData> LengthParameter { get; }
+    IValueLookupParameter<IntValue> LengthParameter { get; }
     ILookupParameter<Permutation> PermutationParameter { get; }
   }
Index: trunk/sources/HeuristicLab.Encodings.Permutation/3.3/Moves/TwoOpt/StochasticTwoOptMoveGenerator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.Permutation/3.3/Moves/TwoOpt/StochasticTwoOptMoveGenerator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.Permutation/3.3/Moves/TwoOpt/StochasticTwoOptMoveGenerator.cs	(revision 3048)
@@ -34,6 +34,6 @@
       get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
     }
-    private ValueLookupParameter<IntData> SampleSizeParameter {
-      get { return (ValueLookupParameter<IntData>)Parameters["SampleSize"]; }
+    private ValueLookupParameter<IntValue> SampleSizeParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["SampleSize"]; }
     }
 
@@ -41,5 +41,5 @@
       : base() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator."));
-      Parameters.Add(new ValueLookupParameter<IntData>("SampleSize", "The number of moves to generate."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("SampleSize", "The number of moves to generate."));
     }
 
Index: trunk/sources/HeuristicLab.Encodings.Permutation/3.3/Moves/TwoOpt/TwoOptMoveMaker.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.Permutation/3.3/Moves/TwoOpt/TwoOptMoveMaker.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.Permutation/3.3/Moves/TwoOpt/TwoOptMoveMaker.cs	(revision 3048)
@@ -32,9 +32,9 @@
   [StorableClass]
   public class TwoOptMoveMaker : SingleSuccessorOperator, ITwoOptPermutationMoveOperator, IMoveMaker {
-    public ILookupParameter<DoubleData> QualityParameter {
-      get { return (LookupParameter<DoubleData>)Parameters["Quality"]; }
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (LookupParameter<DoubleValue>)Parameters["Quality"]; }
     }
-    public ILookupParameter<DoubleData> MoveQualityParameter {
-      get { return (LookupParameter<DoubleData>)Parameters["MoveQuality"]; }
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (LookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
     }
     public ILookupParameter<TwoOptMove> TwoOptMoveParameter {
@@ -47,7 +47,7 @@
     public TwoOptMoveMaker()
       : base() {
-      Parameters.Add(new LookupParameter<DoubleData>("Quality", "The quality of the solution."));
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of the solution."));
       Parameters.Add(new LookupParameter<TwoOptMove>("Move", "The move to evaluate."));
-      Parameters.Add(new LookupParameter<DoubleData>("MoveQuality", "The relative quality of the move."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The relative quality of the move."));
       Parameters.Add(new LookupParameter<Permutation>("Permutation", "The solution as permutation."));
     }
@@ -56,6 +56,6 @@
       TwoOptMove move = TwoOptMoveParameter.ActualValue;
       Permutation permutation = PermutationParameter.ActualValue;
-      DoubleData moveQuality = MoveQualityParameter.ActualValue;
-      DoubleData quality = QualityParameter.ActualValue;
+      DoubleValue moveQuality = MoveQualityParameter.ActualValue;
+      DoubleValue quality = QualityParameter.ActualValue;
 
       InversionManipulator.Apply(permutation, move.Index1, move.Index2);
Index: trunk/sources/HeuristicLab.Encodings.Permutation/3.3/Moves/TwoOpt/TwoOptMoveTabuEvaluator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.Permutation/3.3/Moves/TwoOpt/TwoOptMoveTabuEvaluator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.Permutation/3.3/Moves/TwoOpt/TwoOptMoveTabuEvaluator.cs	(revision 3048)
@@ -41,6 +41,6 @@
       get { return (LookupParameter<ItemList<IItem>>)Parameters["TabuList"]; }
     }
-    public LookupParameter<BoolData> MoveTabuParameter {
-      get { return (LookupParameter<BoolData>)Parameters["MoveTabu"]; }
+    public LookupParameter<BoolValue> MoveTabuParameter {
+      get { return (LookupParameter<BoolValue>)Parameters["MoveTabu"]; }
     }
     private ScopeParameter CurrentScopeParameter {
@@ -51,5 +51,5 @@
       : base() {
       Parameters.Add(new LookupParameter<TwoOptMove>("Move", "The move to evaluate."));
-      Parameters.Add(new LookupParameter<BoolData>("MoveTabu", "The variable to store if a move was tabu."));
+      Parameters.Add(new LookupParameter<BoolValue>("MoveTabu", "The variable to store if a move was tabu."));
       Parameters.Add(new LookupParameter<Permutation>("Permutation", "The solution as permutation."));
       Parameters.Add(new LookupParameter<ItemList<IItem>>("TabuList", "The tabu list."));
@@ -83,5 +83,5 @@
         }
       }
-      MoveTabuParameter.ActualValue = new BoolData(isTabu);
+      MoveTabuParameter.ActualValue = new BoolValue(isTabu);
       return base.Apply();
     }
Index: trunk/sources/HeuristicLab.Encodings.Permutation/3.3/Moves/TwoOpt/TwoOptMoveTabuMaker.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.Permutation/3.3/Moves/TwoOpt/TwoOptMoveTabuMaker.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.Permutation/3.3/Moves/TwoOpt/TwoOptMoveTabuMaker.cs	(revision 3048)
@@ -41,6 +41,6 @@
       get { return (LookupParameter<ItemList<IItem>>)Parameters["TabuList"]; }
     }
-    public ValueLookupParameter<IntData> TabuTenureParameter {
-      get { return (ValueLookupParameter<IntData>)Parameters["TabuTenure"]; }
+    public ValueLookupParameter<IntValue> TabuTenureParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["TabuTenure"]; }
     }
 
@@ -49,5 +49,5 @@
       Parameters.Add(new LookupParameter<TwoOptMove>("Move", "The move that was made."));
       Parameters.Add(new LookupParameter<ItemList<IItem>>("TabuList", "The tabu list where move attributes are stored."));
-      Parameters.Add(new ValueLookupParameter<IntData>("TabuTenure", "The tenure of the tabu list."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("TabuTenure", "The tenure of the tabu list."));
       Parameters.Add(new LookupParameter<Permutation>("Permutation", "The solution as permutation."));
     }
@@ -56,5 +56,5 @@
       ItemList<IItem> tabuList = TabuListParameter.ActualValue;
       TwoOptMove move = TwoOptMoveParameter.ActualValue;
-      IntData tabuTenure = TabuTenureParameter.ActualValue;
+      IntValue tabuTenure = TabuTenureParameter.ActualValue;
       Permutation permutation = PermutationParameter.ActualValue;
       
Index: trunk/sources/HeuristicLab.Encodings.Permutation/3.3/Permutation.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.Permutation/3.3/Permutation.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.Permutation/3.3/Permutation.cs	(revision 3048)
@@ -31,5 +31,5 @@
   [Item("Permutation", "Represents a permutation of integer values.")]
   [Creatable("Test")]
-  public sealed class Permutation : ValueTypeArrayData<int>, IStringConvertibleArrayData {
+  public sealed class Permutation : ValueTypeArray<int>, IStringConvertibleArray {
     public Permutation() : base() { }
     public Permutation(int length)
@@ -92,10 +92,10 @@
 
     #region IStringConvertibleArrayData Members
-    int IStringConvertibleArrayData.Length {
+    int IStringConvertibleArray.Length {
       get { return Length; }
       set { Length = value; }
     }
 
-    bool IStringConvertibleArrayData.Validate(string value, out string errorMessage) {
+    bool IStringConvertibleArray.Validate(string value, out string errorMessage) {
       int val;
       bool valid = int.TryParse(value, out val);
@@ -110,8 +110,8 @@
       return valid;
     }
-    string IStringConvertibleArrayData.GetValue(int index) {
+    string IStringConvertibleArray.GetValue(int index) {
       return this[index].ToString();
     }
-    bool IStringConvertibleArrayData.SetValue(string value, int index) {
+    bool IStringConvertibleArray.SetValue(string value, int index) {
       int val;
       if (int.TryParse(value, out val)) {
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/BoundsChecker.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/BoundsChecker.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/BoundsChecker.cs	(revision 3048)
@@ -35,12 +35,12 @@
   [StorableClass]
   public class BoundsChecker : SingleSuccessorOperator {
-    public LookupParameter<DoubleArrayData> RealVectorParameter {
-      get { return (LookupParameter<DoubleArrayData>)Parameters["RealVector"]; }
+    public LookupParameter<DoubleArray> RealVectorParameter {
+      get { return (LookupParameter<DoubleArray>)Parameters["RealVector"]; }
     }
-    public ValueLookupParameter<DoubleData> MinimumParameter {
-      get { return (ValueLookupParameter<DoubleData>)Parameters["Minimum"]; }
+    public ValueLookupParameter<DoubleValue> MinimumParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Minimum"]; }
     }
-    public ValueLookupParameter<DoubleData> MaximumParameter {
-      get { return (ValueLookupParameter<DoubleData>)Parameters["Maximum"]; }
+    public ValueLookupParameter<DoubleValue> MaximumParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Maximum"]; }
     }
 
@@ -51,7 +51,7 @@
     public BoundsChecker()
       : base() {
-      Parameters.Add(new LookupParameter<DoubleArrayData>("RealVector", "The real-valued vector for which the bounds should be checked."));
-      Parameters.Add(new ValueLookupParameter<DoubleData>("Minimum", "The lower bound for each element in the vector."));
-      Parameters.Add(new ValueLookupParameter<DoubleData>("Maximum", "The upper bound for each element in the vector."));
+      Parameters.Add(new LookupParameter<DoubleArray>("RealVector", "The real-valued vector for which the bounds should be checked."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Minimum", "The lower bound for each element in the vector."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Maximum", "The upper bound for each element in the vector."));
     }
 
@@ -64,5 +64,5 @@
     /// <param name="vector">The vector to check.</param>
     /// <returns>The corrected real vector.</returns>
-    public static void Apply(DoubleArrayData vector, DoubleData min, DoubleData max) {
+    public static void Apply(DoubleArray vector, DoubleValue min, DoubleValue max) {
       for (int i = 0; i < vector.Length; i++) {
         if (vector[i] < min.Value) vector[i] = min.Value;
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Creators/UniformRandomRealVectorCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Creators/UniformRandomRealVectorCreator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Creators/UniformRandomRealVectorCreator.cs	(revision 3048)
@@ -51,8 +51,8 @@
     /// <param name="max">The maximum value of the sampling range for each vector element (exclusive).</param>
     /// <returns>The newly created real vector.</returns>
-    public static DoubleArrayData Apply(IRandom random, int length, double min, double max) {
+    public static DoubleArray Apply(IRandom random, int length, double min, double max) {
       if (length <= 0) throw new ArgumentException("UniformRandomRealVectorCreator: Length is smaller or equal to 0.", "length");
       if (min > max) throw new ArgumentException("UniformRandomRealVectorCreator: Minimum is greater than Maximum.", "min");
-      DoubleArrayData result = new DoubleArrayData(length);
+      DoubleArray result = new DoubleArray(length);
       for (int i = 0; i < length; i++)
         result[i] = min + random.NextDouble() * (max - min);
@@ -68,5 +68,5 @@
     /// <param name="maximum">The maximum value of the sampling range for each vector element (exclusive).</param>
     /// <returns>The newly created real vector.</returns>
-    protected override DoubleArrayData Create(IRandom random, IntData length, DoubleData minimum, DoubleData maximum) {
+    protected override DoubleArray Create(IRandom random, IntValue length, DoubleValue minimum, DoubleValue maximum) {
       return Apply(random, length.Value, minimum.Value, maximum.Value);
     }
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/AverageCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/AverageCrossover.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/AverageCrossover.cs	(revision 3048)
@@ -45,8 +45,8 @@
     /// <param name="parents">The list of parents.</param>
     /// <returns>The child vector (average) of the parents.</returns>
-    public static DoubleArrayData Apply(IRandom random, ItemArray<DoubleArrayData> parents) {
+    public static DoubleArray Apply(IRandom random, ItemArray<DoubleArray> parents) {
       int length = parents[0].Length, parentsCount = parents.Length;
       if (parents.Length < 2) throw new ArgumentException("AverageCrossover: The number of parents is less than 2.", "parents");
-      DoubleArrayData result = new DoubleArrayData(length);
+      DoubleArray result = new DoubleArray(length);
       try {
         double avg;
@@ -65,10 +65,10 @@
 
     /// <summary>
-    /// Forwards the call to <see cref="Apply(IRandom, ItemArray<DoubleArrayData>)"/>.
+    /// Forwards the call to <see cref="Apply(IRandom, ItemArray<DoubleArray>)"/>.
     /// </summary>
     /// <param name="random">The random number generator.</param>
     /// <param name="parents">The list of parents.</param>
     /// <returns>The child vector (average) of the parents.</returns>
-    protected override DoubleArrayData Cross(IRandom random, ItemArray<DoubleArrayData> parents) {
+    protected override DoubleArray Cross(IRandom random, ItemArray<DoubleArray> parents) {
       return Apply(random, parents);
     }
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/BlendAlphaBetaCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/BlendAlphaBetaCrossover.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/BlendAlphaBetaCrossover.cs	(revision 3048)
@@ -43,24 +43,24 @@
     /// Whether the problem is a maximization or minimization problem.
     /// </summary>
-    public ValueLookupParameter<BoolData> MaximizationParameter {
-      get { return (ValueLookupParameter<BoolData>)Parameters["Maximization"]; }
+    public ValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (ValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
     }
     /// <summary>
     /// The quality of the parents.
     /// </summary>
-    public SubScopesLookupParameter<DoubleData> QualityParameter {
-      get { return (SubScopesLookupParameter<DoubleData>)Parameters["Quality"]; }
+    public SubScopesLookupParameter<DoubleValue> QualityParameter {
+      get { return (SubScopesLookupParameter<DoubleValue>)Parameters["Quality"]; }
     }
     /// <summary>
     /// The alpha parameter specifies how much the interval between the parents should be extended in direction of the better parent.
     /// </summary>
-    public ValueLookupParameter<DoubleData> AlphaParameter {
-      get { return (ValueLookupParameter<DoubleData>)Parameters["Alpha"]; }
+    public ValueLookupParameter<DoubleValue> AlphaParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Alpha"]; }
     }
     /// <summary>
     /// The beta parameter specifies how much the interval between the parents should be extended in direction of the worse parent.
     /// </summary>
-    public ValueLookupParameter<DoubleData> BetaParameter {
-      get { return (ValueLookupParameter<DoubleData>)Parameters["Beta"]; }
+    public ValueLookupParameter<DoubleValue> BetaParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Beta"]; }
     }
 
@@ -71,8 +71,8 @@
     public BlendAlphaBetaCrossover()
       : base() {
-      Parameters.Add(new ValueLookupParameter<BoolData>("Maximization", "Whether the problem is a maximization problem or not."));
-      Parameters.Add(new SubScopesLookupParameter<DoubleData>("Quality", "The quality values of the parents."));
-      Parameters.Add(new ValueLookupParameter<DoubleData>("Alpha", "The value for alpha.", new DoubleData(0.75)));
-      Parameters.Add(new ValueLookupParameter<DoubleData>("Beta", "The value for beta.", new DoubleData(0.25)));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "Whether the problem is a maximization problem or not."));
+      Parameters.Add(new SubScopesLookupParameter<DoubleValue>("Quality", "The quality values of the parents."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Alpha", "The value for alpha.", new DoubleValue(0.75)));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Beta", "The value for beta.", new DoubleValue(0.25)));
     }
 
@@ -94,5 +94,5 @@
     /// <param name="beta">The parameter beta.</param>
     /// <returns>The real vector that results from the crossover.</returns>
-    public static DoubleArrayData Apply(IRandom random, DoubleArrayData betterParent, DoubleArrayData worseParent, DoubleData alpha, DoubleData beta) {
+    public static DoubleArray Apply(IRandom random, DoubleArray betterParent, DoubleArray worseParent, DoubleValue alpha, DoubleValue beta) {
       if (betterParent.Length != worseParent.Length) throw new ArgumentException("BlendAlphaBetaCrossover: The parents' vectors are of different length.", "betterParent");
       if (alpha.Value < 0) throw new ArgumentException("BlendAlphaBetaCrossover: Parameter alpha must be greater or equal to 0.", "alpha");
@@ -100,5 +100,5 @@
       int length = betterParent.Length;
       double min, max, d;
-      DoubleArrayData result = new DoubleArrayData(length);
+      DoubleArray result = new DoubleArray(length);
 
       for (int i = 0; i < length; i++) {
@@ -117,5 +117,5 @@
 
     /// <summary>
-    /// Checks if the number of parents is equal to 2, if all parameters are available and forwards the call to <see cref="Apply(IRandom, DoubleArrayData, DoubleArrayData, DoubleData, DoubleData)"/>.
+    /// Checks if the number of parents is equal to 2, if all parameters are available and forwards the call to <see cref="Apply(IRandom, DoubleArray, DoubleArray, DoubleValue, DoubleValue)"/>.
     /// </summary>
     /// <exception cref="ArgumentException">Thrown when the number of parents is not equal to 2.</exception>
@@ -132,5 +132,5 @@
     /// <param name="parents">The collection of parents (must be of size 2).</param>
     /// <returns>The real vector that results from the crossover.</returns>
-    protected override DoubleArrayData Cross(IRandom random, ItemArray<DoubleArrayData> parents) {
+    protected override DoubleArray Cross(IRandom random, ItemArray<DoubleArray> parents) {
       if (parents.Length != 2) throw new ArgumentException("BlendAlphaBetaCrossover: Number of parents is not equal to 2.", "parents");
       if (MaximizationParameter.ActualValue == null) throw new InvalidOperationException("BlendAlphaBetaCrossover: Parameter " + MaximizationParameter.ActualName + " could not be found.");
@@ -138,5 +138,5 @@
       if (AlphaParameter.ActualValue == null || BetaParameter.ActualValue == null) throw new InvalidOperationException("BlendAlphaBetaCrossover: Parameter " + AlphaParameter.ActualName + " or paramter " + BetaParameter.ActualName + " could not be found.");
       
-      ItemArray<DoubleData> qualities = QualityParameter.ActualValue;
+      ItemArray<DoubleValue> qualities = QualityParameter.ActualValue;
       bool maximization = MaximizationParameter.ActualValue.Value;
       // the better parent 
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/BlendAlphaCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/BlendAlphaCrossover.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/BlendAlphaCrossover.cs	(revision 3048)
@@ -45,6 +45,6 @@
     /// values left and right of the min and max value for each gene.
     /// </summary>
-    public ValueLookupParameter<DoubleData> AlphaParameter {
-      get { return (ValueLookupParameter<DoubleData>)Parameters["Alpha"]; }
+    public ValueLookupParameter<DoubleValue> AlphaParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Alpha"]; }
     }
     /// <summary>
@@ -53,5 +53,5 @@
     public BlendAlphaCrossover()
       : base() {
-      Parameters.Add(new ValueLookupParameter<DoubleData>("Alpha", "Value for alpha", new DoubleData(0.5)));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Alpha", "Value for alpha", new DoubleValue(0.5)));
     }
 
@@ -70,9 +70,9 @@
     /// <param name="alpha">The alpha value for the crossover.</param>
     /// <returns>The newly created real vector resulting from the crossover operation.</returns>
-    public static DoubleArrayData Apply(IRandom random, DoubleArrayData parent1, DoubleArrayData parent2, DoubleData alpha) {
+    public static DoubleArray Apply(IRandom random, DoubleArray parent1, DoubleArray parent2, DoubleValue alpha) {
       if (parent1.Length != parent2.Length) throw new ArgumentException("BlendAlphaCrossover: The parents' vectors are of different length.", "parent1");
       if (alpha.Value < 0) throw new ArgumentException("BlendAlphaCrossover: Paramter alpha must be greater or equal than 0.", "alpha");
       int length = parent1.Length;
-      DoubleArrayData result = new DoubleArrayData(length);
+      DoubleArray result = new DoubleArray(length);
       double max = 0, min = 0, d = 0, resMin = 0, resMax = 0;
 
@@ -90,5 +90,5 @@
 
     /// <summary>
-    /// Checks that the number of parents is equal to 2 and forwards the call to <see cref="Apply(IRandom, DoubleArrayData, DoubleArrayData, DoubleData)"/>.
+    /// Checks that the number of parents is equal to 2 and forwards the call to <see cref="Apply(IRandom, DoubleArray, DoubleArray, DoubleValue)"/>.
     /// </summary>
     /// <exception cref="ArgumentException">Thrown when the number of parents is not equal to 2.</exception>
@@ -97,5 +97,5 @@
     /// <param name="parents">The collection of parents (must be of size 2).</param>
     /// <returns>The real vector resulting from the crossover operation.</returns>
-    protected override DoubleArrayData Cross(IRandom random, ItemArray<DoubleArrayData> parents) {
+    protected override DoubleArray Cross(IRandom random, ItemArray<DoubleArray> parents) {
       if (parents.Length != 2) throw new ArgumentException("BlendAlphaCrossover: The number of parents is not equal to 2", "parents");
       if (AlphaParameter.ActualValue == null) throw new InvalidOperationException("BlendAlphaCrossover: Parameter " + AlphaParameter.ActualName + " could not be found.");
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/DiscreteCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/DiscreteCrossover.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/DiscreteCrossover.cs	(revision 3048)
@@ -45,5 +45,5 @@
     /// <param name="parents">An array containing the parents that should be crossed.</param>
     /// <returns>The newly created real vector, resulting from the crossover operation.</returns>
-    public static DoubleArrayData Apply(IRandom random, ItemArray<DoubleArrayData> parents) {
+    public static DoubleArray Apply(IRandom random, ItemArray<DoubleArray> parents) {
       int length = parents[0].Length;
       
@@ -53,5 +53,5 @@
       }
       
-      DoubleArrayData result = new DoubleArrayData(length);
+      DoubleArray result = new DoubleArray(length);
       for (int i = 0; i < length; i++) {
         result[i] = parents[random.Next(parents.Length)][i];
@@ -62,5 +62,5 @@
 
     /// <summary>
-    /// Checks number of parents and forwards the call to <see cref="Apply(IRandom, ItemArray<DoubleArrayData>)"/>.
+    /// Checks number of parents and forwards the call to <see cref="Apply(IRandom, ItemArray<DoubleArray>)"/>.
     /// </summary>
     /// <exception cref="ArgumentException">Thrown when <paramref name="parents"/> contains less than 2 elements.</exception>
@@ -68,5 +68,5 @@
     /// <param name="parents">The collection of parents (must be of size 2 or greater).</param>
     /// <returns>The real vector resulting from the crossover.</returns>
-    protected override DoubleArrayData Cross(IRandom random, ItemArray<DoubleArrayData> parents) {
+    protected override DoubleArray Cross(IRandom random, ItemArray<DoubleArray> parents) {
       if (parents.Length < 2) throw new ArgumentException("DiscreteCrossover: The number of parents is less than 2.", "parents");
       return Apply(random, parents);
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/HeuristicCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/HeuristicCrossover.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/HeuristicCrossover.cs	(revision 3048)
@@ -40,12 +40,12 @@
     /// Whether the problem is a maximization or minimization problem.
     /// </summary>
-    public ValueLookupParameter<BoolData> MaximizationParameter {
-      get { return (ValueLookupParameter<BoolData>)Parameters["Maximization"]; }
+    public ValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (ValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
     }
     /// <summary>
     /// The quality of the parents.
     /// </summary>
-    public SubScopesLookupParameter<DoubleData> QualityParameter {
-      get { return (SubScopesLookupParameter<DoubleData>)Parameters["Quality"]; }
+    public SubScopesLookupParameter<DoubleValue> QualityParameter {
+      get { return (SubScopesLookupParameter<DoubleValue>)Parameters["Quality"]; }
     }
 
@@ -56,6 +56,6 @@
     public HeuristicCrossover()
       : base() {
-      Parameters.Add(new ValueLookupParameter<BoolData>("Maximization", "Whether the problem is a maximization problem or not."));
-      Parameters.Add(new SubScopesLookupParameter<DoubleData>("Quality", "The quality values of the parents."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "Whether the problem is a maximization problem or not."));
+      Parameters.Add(new SubScopesLookupParameter<DoubleValue>("Quality", "The quality values of the parents."));
     }
 
@@ -68,5 +68,5 @@
     /// <param name="worseParent">The second parent for the crossover operation.</param>
     /// <returns>The newly created real vector, resulting from the heuristic crossover.</returns>
-    public static DoubleArrayData Apply(IRandom random, DoubleArrayData betterParent, DoubleArrayData worseParent) {
+    public static DoubleArray Apply(IRandom random, DoubleArray betterParent, DoubleArray worseParent) {
       if (betterParent.Length != worseParent.Length)
         throw new ArgumentException("HeuristicCrossover: the two parents are not of the same length");
@@ -79,5 +79,5 @@
         result[i] = betterParent[i] + factor * (betterParent[i] - worseParent[i]);
       }
-      return new DoubleArrayData(result);
+      return new DoubleArray(result);
     }
 
@@ -96,5 +96,5 @@
     /// <param name="parents">An array containing the two real vectors that should be crossed.</param>
     /// <returns>The newly created real vector, resulting from the crossover operation.</returns>
-    protected override DoubleArrayData Cross(IRandom random, ItemArray<DoubleArrayData> parents) {
+    protected override DoubleArray Cross(IRandom random, ItemArray<DoubleArray> parents) {
       if (parents.Length != 2) throw new ArgumentException("HeuristicCrossover: The number of parents is not equal to 2");
 
@@ -102,5 +102,5 @@
       if (QualityParameter.ActualValue == null || QualityParameter.ActualValue.Length != parents.Length) throw new InvalidOperationException("HeuristicCrossover: Parameter " + QualityParameter.ActualName + " could not be found, or not in the same quantity as there are parents.");
 
-      ItemArray<DoubleData> qualities = QualityParameter.ActualValue;
+      ItemArray<DoubleValue> qualities = QualityParameter.ActualValue;
       bool maximization = MaximizationParameter.ActualValue.Value;
 
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/LocalCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/LocalCrossover.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/LocalCrossover.cs	(revision 3048)
@@ -43,5 +43,5 @@
     /// <param name="parent2">The second parent for the crossover operation.</param>
     /// <returns>The newly created real vector, resulting from the local crossover.</returns>
-    public static DoubleArrayData Apply(IRandom random, DoubleArrayData parent1, DoubleArrayData parent2) {
+    public static DoubleArray Apply(IRandom random, DoubleArray parent1, DoubleArray parent2) {
       if (parent1.Length != parent2.Length)
         throw new ArgumentException("LocalCrossover: the two parents are not of the same length");
@@ -55,5 +55,5 @@
         result[i] = (factor * parent1[i]) + ((1 - factor) * parent2[i]);
       }
-      return new DoubleArrayData(result);
+      return new DoubleArray(result);
     }
 
@@ -65,5 +65,5 @@
     /// <param name="parents">An array containing the two real vectors that should be crossed.</param>
     /// <returns>The newly created real vector, resulting from the crossover operation.</returns>
-    protected override DoubleArrayData Cross(IRandom random, ItemArray<DoubleArrayData> parents) {
+    protected override DoubleArray Cross(IRandom random, ItemArray<DoubleArray> parents) {
       if (parents.Length != 2) throw new ArgumentException("LocalCrossover: The number of parents is not equal to 2");
       return Apply(random, parents[0], parents[1]);
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/RandomConvexCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/RandomConvexCrossover.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/RandomConvexCrossover.cs	(revision 3048)
@@ -43,5 +43,5 @@
     /// <param name="parent2">The second parent vector for the crossover.</param>
     /// <returns>The newly created real vector, resulting from the random convex crossover.</returns>
-    public static DoubleArrayData Apply(IRandom random, DoubleArrayData parent1, DoubleArrayData parent2) {
+    public static DoubleArray Apply(IRandom random, DoubleArray parent1, DoubleArray parent2) {
       if (parent1.Length != parent2.Length)
         throw new ArgumentException("ERROR in RandomConvexCrossover: the two parents are not of the same length");
@@ -53,5 +53,5 @@
       for (int i = 0; i < length; i++)
         result[i] = (factor * parent1[i]) + ((1 - factor) * parent2[i]);
-      return new DoubleArrayData(result);
+      return new DoubleArray(result);
     }
 
@@ -63,5 +63,5 @@
     /// <param name="parents">An array containing the two real vectors that should be crossed.</param>
     /// <returns>The newly created real vector, resulting from the crossover operation.</returns>
-    protected override DoubleArrayData Cross(IRandom random, ItemArray<DoubleArrayData> parents) {
+    protected override DoubleArray Cross(IRandom random, ItemArray<DoubleArray> parents) {
       if (parents.Length != 2) throw new ArgumentException("ERROR in RandomConvexCrossover: The number of parents is not equal to 2");
       return Apply(random, parents[0], parents[1]);
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/SimulatedBinaryCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/SimulatedBinaryCrossover.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/SimulatedBinaryCrossover.cs	(revision 3048)
@@ -40,6 +40,6 @@
     /// The parameter must be greater or equal than 0. Common values are in the range [0;5] and more often just [2;5].
     /// </summary>
-    public ValueLookupParameter<DoubleData> ContiguityParameter {
-      get { return (ValueLookupParameter<DoubleData>)Parameters["Contiguity"]; }
+    public ValueLookupParameter<DoubleValue> ContiguityParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Contiguity"]; }
     }
 
@@ -50,5 +50,5 @@
     public SimulatedBinaryCrossover()
       : base() {
-      Parameters.Add(new ValueLookupParameter<DoubleData>("Contiguity", "Specifies whether the crossover should produce very different (small value) or very similar (large value) children. Valid values must be greater or equal to 0.", new DoubleData(2)));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Contiguity", "Specifies whether the crossover should produce very different (small value) or very similar (large value) children. Valid values must be greater or equal to 0.", new DoubleValue(2)));
     }
 
@@ -66,9 +66,9 @@
     /// <param name="contiguity">The contiguity value that specifies how close a child should be to its parents (larger value means closer). The value must be greater or equal than 0. Typical values are in the range [2;5].</param>
     /// <returns>The vector resulting from the crossover.</returns>
-    public static DoubleArrayData Apply(IRandom random, DoubleArrayData parent1, DoubleArrayData parent2, DoubleData contiguity) {
+    public static DoubleArray Apply(IRandom random, DoubleArray parent1, DoubleArray parent2, DoubleValue contiguity) {
       if (parent1.Length != parent2.Length) throw new ArgumentException("SimulatedBinaryCrossover: Parents are of unequal length");
       if (contiguity.Value < 0) throw new ArgumentException("SimulatedBinaryCrossover: Contiguity value is smaller than 0", "contiguity");
       int length = parent1.Length;
-      DoubleArrayData result = new DoubleArrayData(length);
+      DoubleArray result = new DoubleArray(length);
       for (int i = 0; i < length; i++) {
         if (length == 1 || random.NextDouble() < 0.5) { // cross this variable
@@ -92,5 +92,5 @@
 
     /// <summary>
-    /// Checks number of parents, availability of the parameters and forwards the call to <see cref="Apply(IRandom, DoubleArrayData, DoubleArrayData, DoubleData)"/>.
+    /// Checks number of parents, availability of the parameters and forwards the call to <see cref="Apply(IRandom, DoubleArray, DoubleArray, DoubleValue)"/>.
     /// </summary>
     /// <exception cref="ArgumentException">Thrown when there are not exactly 2 parents or when the contiguity parameter could not be found.</exception>
@@ -98,5 +98,5 @@
     /// <param name="parents">The collection of parents (must be of size 2).</param>
     /// <returns>The real vector resulting from the crossover.</returns>
-    protected override DoubleArrayData Cross(IRandom random, ItemArray<DoubleArrayData> parents) {
+    protected override DoubleArray Cross(IRandom random, ItemArray<DoubleArray> parents) {
       if (parents.Length != 2) throw new ArgumentException("SimulatedBinaryCrossover: The number of parents is not equal to 2");
       if (ContiguityParameter.ActualValue == null) throw new InvalidOperationException("SimulatedBinaryCrossover: Parameter " + ContiguityParameter.ActualName + " could not be found.");
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/SinglePointCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/SinglePointCrossover.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/SinglePointCrossover.cs	(revision 3048)
@@ -46,8 +46,8 @@
     /// <param name="parent2">The second parent for crossover.</param>
     /// <returns>The newly created real vector, resulting from the single point crossover.</returns>
-    public static DoubleArrayData Apply(IRandom random, DoubleArrayData parent1, DoubleArrayData parent2) {
+    public static DoubleArray Apply(IRandom random, DoubleArray parent1, DoubleArray parent2) {
       if (parent1.Length != parent2.Length) throw new ArgumentException("SinglePointCrossover: Parents are of unequal length");
       int length = parent1.Length;
-      DoubleArrayData result = new DoubleArrayData(length);
+      DoubleArray result = new DoubleArray(length);
       int breakPoint = random.Next(1, length - 1);
 
@@ -61,5 +61,5 @@
 
     /// <summary>
-    /// Checks number of parents and forwards the call to <see cref="Apply(IRandom, DoubleArrayData, DoubleArrayData)"/>.
+    /// Checks number of parents and forwards the call to <see cref="Apply(IRandom, DoubleArray, DoubleArray)"/>.
     /// </summary> 
     /// <exception cref="ArgumentException">Thrown when the parents' vectors are of unequal length or when <paramref name="contiguity"/> is smaller than 0.</exception>
@@ -67,5 +67,5 @@
     /// <param name="parents">The list of parents.</param>
     /// <returns>A new real vector.</returns>
-    protected override HeuristicLab.Data.DoubleArrayData Cross(IRandom random, ItemArray<DoubleArrayData> parents) {
+    protected override HeuristicLab.Data.DoubleArray Cross(IRandom random, ItemArray<DoubleArray> parents) {
       if (parents.Length != 2) throw new ArgumentException("SinglePointCrossover: The number of parents is not equal to 2");
       return Apply(random, parents[0], parents[1]);
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/UniformAllPositionsArithmeticCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/UniformAllPositionsArithmeticCrossover.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/UniformAllPositionsArithmeticCrossover.cs	(revision 3048)
@@ -40,6 +40,6 @@
     /// The alpha parameter needs to be in the interval [0;1] and specifies how close the resulting offspring should be either to parent1 (alpha -> 0) or parent2 (alpha -> 1).
     /// </summary>
-    public ValueLookupParameter<DoubleData> AlphaParameter {
-      get { return (ValueLookupParameter<DoubleData>)Parameters["Alpha"]; }
+    public ValueLookupParameter<DoubleValue> AlphaParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Alpha"]; }
     }
 
@@ -49,5 +49,5 @@
     public UniformAllPositionsArithmeticCrossover()
       : base() {
-      Parameters.Add(new ValueLookupParameter<DoubleData>("Alpha", "The alpha value in the range [0;1]", new DoubleData(0.33)));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Alpha", "The alpha value in the range [0;1]", new DoubleValue(0.33)));
     }
 
@@ -61,9 +61,9 @@
     /// <param name="alpha">The alpha parameter (<see cref="AlphaParameter"/>).</param>
     /// <returns>The vector resulting from the crossover.</returns>
-    public static DoubleArrayData Apply(IRandom random, DoubleArrayData parent1, DoubleArrayData parent2, DoubleData alpha) {
+    public static DoubleArray Apply(IRandom random, DoubleArray parent1, DoubleArray parent2, DoubleValue alpha) {
       int length = parent1.Length;
       if (length != parent2.Length) throw new ArgumentException("UniformAllPositionsArithmeticCrossover: The parent vectors are of different length.", "parent1");
       if (alpha.Value < 0 || alpha.Value > 1) throw new ArgumentException("UniformAllPositionsArithmeticCrossover: Parameter alpha must be in the range [0;1]", "alpha");
-      DoubleArrayData result = new DoubleArrayData(length);
+      DoubleArray result = new DoubleArray(length);
       for (int i = 0; i < length; i++) {
         result[i] = alpha.Value * parent1[i] + (1 - alpha.Value) * parent2[i];
@@ -73,5 +73,5 @@
 
     /// <summary>
-    /// Checks that there are exactly 2 parents, that the alpha parameter is not null and fowards the call to <see cref="Apply(IRandom, DoubleArrayData, DoubleArrrayData, DoubleData)"/>.
+    /// Checks that there are exactly 2 parents, that the alpha parameter is not null and fowards the call to <see cref="Apply(IRandom, DoubleArray, DoubleArrrayData, DoubleValue)"/>.
     /// </summary>
     /// <exception cref="ArgumentException">Thrown when there are not exactly two parents.</exception>
@@ -80,5 +80,5 @@
     /// <param name="parents">The collection of parents (must be of size 2).</param>
     /// <returns>The vector resulting from the crossover.</returns>
-    protected override DoubleArrayData Cross(IRandom random, ItemArray<DoubleArrayData> parents) {
+    protected override DoubleArray Cross(IRandom random, ItemArray<DoubleArray> parents) {
  	    if (parents.Length != 2) throw new ArgumentException("UniformAllPositionsArithmeticCrossover: There must be exactly two parents.", "parents");
       if (AlphaParameter.ActualValue == null) throw new InvalidOperationException("UniformAllPositionsArithmeticCrossover: Parameter " + AlphaParameter.ActualName + " could not be found.");
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/UniformSomePositionsArithmeticCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/UniformSomePositionsArithmeticCrossover.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/UniformSomePositionsArithmeticCrossover.cs	(revision 3048)
@@ -40,12 +40,12 @@
     /// The alpha parameter needs to be in the interval [0;1] and specifies how close the resulting offspring should be either to parent1 (alpha -> 0) or parent2 (alpha -> 1).
     /// </summary>
-    public ValueLookupParameter<DoubleData> AlphaParameter {
-      get { return (ValueLookupParameter<DoubleData>)Parameters["Alpha"]; }
+    public ValueLookupParameter<DoubleValue> AlphaParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Alpha"]; }
     }
     /// <summary>
     /// The probability in the range [0;1] for each position in the vector to be crossed.
     /// </summary>
-    public ValueLookupParameter<DoubleData> ProbabilityParameter {
-      get { return (ValueLookupParameter<DoubleData>)Parameters["Probability"]; }
+    public ValueLookupParameter<DoubleValue> ProbabilityParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Probability"]; }
     }
 
@@ -55,6 +55,6 @@
     public UniformSomePositionsArithmeticCrossover()
       : base() {
-      Parameters.Add(new ValueLookupParameter<DoubleData>("Alpha", "The alpha value in the range [0;1]", new DoubleData(0.5)));
-      Parameters.Add(new ValueLookupParameter<DoubleData>("Probability", "The probability for crossing a position in the range [0;1]", new DoubleData(0.5)));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Alpha", "The alpha value in the range [0;1]", new DoubleValue(0.5)));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Probability", "The probability for crossing a position in the range [0;1]", new DoubleValue(0.5)));
     }
 
@@ -68,5 +68,5 @@
     /// <param name="probability">The probability parameter (<see cref="ProbabilityParameter"/>).</param>
     /// <returns>The vector resulting from the crossover.</returns>
-    public static DoubleArrayData Apply(IRandom random, DoubleArrayData parent1, DoubleArrayData parent2, DoubleData alpha, DoubleData probability) {
+    public static DoubleArray Apply(IRandom random, DoubleArray parent1, DoubleArray parent2, DoubleValue alpha, DoubleValue probability) {
       int length = parent1.Length;
       if (length != parent2.Length) throw new ArgumentException("UniformSomePositionsArithmeticCrossover: The parent vectors are of different length.", "parent1");
@@ -74,5 +74,5 @@
       if (probability.Value < 0 || probability.Value > 1) throw new ArgumentException("UniformSomePositionsArithmeticCrossover: Parameter probability must be in the range [0;1]", "probability");
       
-      DoubleArrayData result = new DoubleArrayData(length);
+      DoubleArray result = new DoubleArray(length);
       for (int i = 0; i < length; i++) {
         if (random.NextDouble() < probability.Value)
@@ -84,5 +84,5 @@
 
     /// <summary>
-    /// Checks that there are exactly 2 parents, that the alpha and the probability parameter are not null and fowards the call to <see cref="Apply(IRandom, DoubleArrayData, DoubleArrrayData, DoubleData)"/>.
+    /// Checks that there are exactly 2 parents, that the alpha and the probability parameter are not null and fowards the call to <see cref="Apply(IRandom, DoubleArray, DoubleArrrayData, DoubleValue)"/>.
     /// </summary>
     /// <exception cref="ArgumentException">Thrown when there are not exactly two parents.</exception>
@@ -91,5 +91,5 @@
     /// <param name="parents">The collection of parents (must be of size 2).</param>
     /// <returns>The vector resulting from the crossover.</returns>
-    protected override DoubleArrayData  Cross(IRandom random, ItemArray<DoubleArrayData> parents) {
+    protected override DoubleArray  Cross(IRandom random, ItemArray<DoubleArray> parents) {
       if (parents.Length != 2) throw new ArgumentException("UniformSomePositionsArithmeticCrossover: There must be exactly two parents.", "parents");
       if (AlphaParameter.ActualValue == null) throw new InvalidOperationException("UniformSomePositionsArithmeticCrossover: Parameter " + AlphaParameter.ActualName + " could not be found.");
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Interfaces/IRealVectorCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Interfaces/IRealVectorCreator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Interfaces/IRealVectorCreator.cs	(revision 3048)
@@ -29,8 +29,8 @@
   /// </summary>
   public interface IRealVectorCreator : IRealVectorOperator, ISolutionCreator {
-    IValueLookupParameter<IntData> LengthParameter { get; }
-    IValueLookupParameter<DoubleData> MinimumParameter { get; }
-    IValueLookupParameter<DoubleData> MaximumParameter { get; }
-    ILookupParameter<DoubleArrayData> RealVectorParameter { get; }
+    IValueLookupParameter<IntValue> LengthParameter { get; }
+    IValueLookupParameter<DoubleValue> MinimumParameter { get; }
+    IValueLookupParameter<DoubleValue> MaximumParameter { get; }
+    ILookupParameter<DoubleArray> RealVectorParameter { get; }
   }
 }
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Interfaces/IRealVectorCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Interfaces/IRealVectorCrossover.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Interfaces/IRealVectorCrossover.cs	(revision 3048)
@@ -29,6 +29,6 @@
   /// </summary>
   public interface IRealVectorCrossover : IRealVectorOperator, ICrossover {
-    ILookupParameter<ItemArray<DoubleArrayData>> ParentsParameter { get; }
-    ILookupParameter<DoubleArrayData> ChildParameter { get; }
+    ILookupParameter<ItemArray<DoubleArray>> ParentsParameter { get; }
+    ILookupParameter<DoubleArray> ChildParameter { get; }
   }
 }
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Interfaces/IRealVectorManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Interfaces/IRealVectorManipulator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Interfaces/IRealVectorManipulator.cs	(revision 3048)
@@ -29,5 +29,5 @@
   /// </summary>
   public interface IRealVectorManipulator : IRealVectorOperator, IManipulator {
-    ILookupParameter<DoubleArrayData> RealVectorParameter { get; }
+    ILookupParameter<DoubleArray> RealVectorParameter { get; }
   }
 }
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Manipulators/BreederGeneticAlgorithmManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Manipulators/BreederGeneticAlgorithmManipulator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Manipulators/BreederGeneticAlgorithmManipulator.cs	(revision 3048)
@@ -38,12 +38,12 @@
   public class BreederGeneticAlgorithmManipulator : RealVectorManipulator {
     private static readonly double[] powerOfTwo = new double[] { 1, 0.5, 0.25, 0.125, 0.0625, 0.03125, 0.015625, 0.0078125, 0.00390625, 0.001953125, 0.0009765625, 0.00048828125, 0.000244140625, 0.0001220703125, 0.00006103515625, 0.000030517578125 };
-    public ValueLookupParameter<DoubleData> MinimumParameter {
-      get { return (ValueLookupParameter<DoubleData>)Parameters["Minimum"]; }
+    public ValueLookupParameter<DoubleValue> MinimumParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Minimum"]; }
     }
-    public ValueLookupParameter<DoubleData> MaximumParameter {
-      get { return (ValueLookupParameter<DoubleData>)Parameters["Maximum"]; }
+    public ValueLookupParameter<DoubleValue> MaximumParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Maximum"]; }
     }
-    public ValueLookupParameter<DoubleData> SearchIntervalFactorParameter {
-      get { return (ValueLookupParameter<DoubleData>)Parameters["SearchIntervalFactor"]; }
+    public ValueLookupParameter<DoubleValue> SearchIntervalFactorParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["SearchIntervalFactor"]; }
     }
     /// <summary>
@@ -53,7 +53,7 @@
     public BreederGeneticAlgorithmManipulator()
       : base() {
-      Parameters.Add(new ValueLookupParameter<DoubleData>("Minimum", "The lower bound for each element in the vector."));
-      Parameters.Add(new ValueLookupParameter<DoubleData>("Maximum", "The upper bound for each element in the vector."));
-      Parameters.Add(new ValueLookupParameter<DoubleData>("SearchIntervalFactor", "The factor determining the size of the search interval, that will be added/removed to/from the allele selected for manipulation.", new DoubleData(0.1)));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Minimum", "The lower bound for each element in the vector."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Maximum", "The upper bound for each element in the vector."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("SearchIntervalFactor", "The factor determining the size of the search interval, that will be added/removed to/from the allele selected for manipulation.", new DoubleValue(0.1)));
     }
 
@@ -66,5 +66,5 @@
     /// <param name="max">The maximum number of the sampling range for the vector element (exclusive).</param>
     /// <param name="searchIntervalFactor">The factor determining the size of the search interval.</param>
-    public static void Apply(IRandom random, DoubleArrayData vector, DoubleData min, DoubleData max, DoubleData searchIntervalFactor) {
+    public static void Apply(IRandom random, DoubleArray vector, DoubleValue min, DoubleValue max, DoubleValue searchIntervalFactor) {
       int length = vector.Length;
       double prob, value;
@@ -114,9 +114,9 @@
 
     /// <summary>
-    /// Checks the parameters Minimum, Maximum, and SearchIntervalFactor and forwards the call to <see cref="Apply(IRandom, DoubleArrayData, DoubleData, DoubleData, DoubleData)"/>.
+    /// Checks the parameters Minimum, Maximum, and SearchIntervalFactor and forwards the call to <see cref="Apply(IRandom, DoubleArray, DoubleValue, DoubleValue, DoubleValue)"/>.
     /// </summary>
     /// <param name="random">A random number generator.</param>
     /// <param name="realVector">The real vector to manipulate.</param>
-    protected override void Manipulate(IRandom random, DoubleArrayData realVector) {
+    protected override void Manipulate(IRandom random, DoubleArray realVector) {
       if (MinimumParameter.ActualValue == null) throw new InvalidOperationException("BreederGeneticAlgorithmManipulator: Parameter " + MinimumParameter.ActualName + " could not be found.");
       if (MaximumParameter.ActualValue == null) throw new InvalidOperationException("BreederGeneticAlgorithmManipulator: Paraemter " + MaximumParameter.ActualName + " could not be found.");
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Manipulators/MichalewiczNonUniformAllPositionsManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Manipulators/MichalewiczNonUniformAllPositionsManipulator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Manipulators/MichalewiczNonUniformAllPositionsManipulator.cs	(revision 3048)
@@ -40,30 +40,30 @@
     /// The lower bound of the values in the real vector.
     /// </summary>
-    public ValueLookupParameter<DoubleData> MinimumParameter {
-      get { return (ValueLookupParameter<DoubleData>)Parameters["Minimum"]; }
+    public ValueLookupParameter<DoubleValue> MinimumParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Minimum"]; }
     }
     /// <summary>
     /// The upper bound of the values in the real vector.
     /// </summary>
-    public ValueLookupParameter<DoubleData> MaximumParameter {
-      get { return (ValueLookupParameter<DoubleData>)Parameters["Maximum"]; }
+    public ValueLookupParameter<DoubleValue> MaximumParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Maximum"]; }
     }
     /// <summary>
     /// The current generation.
     /// </summary>
-    public LookupParameter<IntData> GenerationParameter {
-      get { return (LookupParameter<IntData>)Parameters["Generation"]; }
+    public LookupParameter<IntValue> GenerationParameter {
+      get { return (LookupParameter<IntValue>)Parameters["Generation"]; }
     }
     /// <summary>
     /// The maximum generation.
     /// </summary>
-    public LookupParameter<IntData> MaximumGenerationsParameter {
-      get { return (LookupParameter<IntData>)Parameters["MaximumGenerations"]; }
+    public LookupParameter<IntValue> MaximumGenerationsParameter {
+      get { return (LookupParameter<IntValue>)Parameters["MaximumGenerations"]; }
     }
     /// <summary>
     /// The parameter describing how much the mutation should depend on the progress towards the maximum generation.
     /// </summary>
-    public ValueLookupParameter<DoubleData> GenerationDependencyParameter {
-      get { return (ValueLookupParameter<DoubleData>)Parameters["GenerationDependency"]; }
+    public ValueLookupParameter<DoubleValue> GenerationDependencyParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["GenerationDependency"]; }
     }
 
@@ -75,9 +75,9 @@
     public MichalewiczNonUniformAllPositionsManipulator()
       : base() {
-      Parameters.Add(new ValueLookupParameter<DoubleData>("Minimum", "Minimum of the sampling range for the vector element (included)"));
-      Parameters.Add(new ValueLookupParameter<DoubleData>("Maximum", "Maximum of the sampling range for the vector element (excluded)"));
-      Parameters.Add(new LookupParameter<IntData>("Generation", "Current generation of the algorithm"));
-      Parameters.Add(new LookupParameter<IntData>("MaximumGenerations", "Maximum number of generations"));
-      Parameters.Add(new ValueLookupParameter<DoubleData>("GenerationDependency", "Specifies the degree of dependency on the number of generations", new DoubleData(5)));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Minimum", "Minimum of the sampling range for the vector element (included)"));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Maximum", "Maximum of the sampling range for the vector element (excluded)"));
+      Parameters.Add(new LookupParameter<IntValue>("Generation", "Current generation of the algorithm"));
+      Parameters.Add(new LookupParameter<IntValue>("MaximumGenerations", "Maximum number of generations"));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("GenerationDependency", "Specifies the degree of dependency on the number of generations", new DoubleValue(5)));
     }
 
@@ -95,5 +95,5 @@
     /// <param name="generationsDependency">Specifies the degree of dependency on the number of generations.</param>
     /// <returns>The manipulated real vector.</returns>
-    public static void Apply(IRandom random, DoubleArrayData vector, DoubleData min, DoubleData max, IntData currentGeneration, IntData maximumGenerations, DoubleData generationsDependency) {
+    public static void Apply(IRandom random, DoubleArray vector, DoubleValue min, DoubleValue max, IntValue currentGeneration, IntValue maximumGenerations, DoubleValue generationsDependency) {
       if (currentGeneration.Value > maximumGenerations.Value) throw new ArgumentException("MichalewiczNonUniformAllPositionManipulator: CurrentGeneration must be smaller or equal than MaximumGeneration", "currentGeneration");
       int length = vector.Length;
@@ -111,9 +111,9 @@
 
     /// <summary>
-    /// Checks if all parameters are available and forwards the call to <see cref="Apply(IRandom, DoubleArrayData, DoubleData, DoubleData, IntData, IntData, DoubleData)"/>.
+    /// Checks if all parameters are available and forwards the call to <see cref="Apply(IRandom, DoubleArray, DoubleValue, DoubleValue, IntValue, IntValue, DoubleValue)"/>.
     /// </summary>
     /// <param name="random">The random number generator.</param>
     /// <param name="realVector">The real vector that should be manipulated.</param>
-    protected override void Manipulate(IRandom random, DoubleArrayData realVector) {
+    protected override void Manipulate(IRandom random, DoubleArray realVector) {
       if (MinimumParameter.ActualValue == null) throw new InvalidOperationException("MichalewiczNonUniformAllPositionManipulator: Parameter " + MinimumParameter.ActualName + " could not be found.");
       if (MaximumParameter.ActualValue == null) throw new InvalidOperationException("MichalewiczNonUniformAllPositionManipulator: Parameter " + MaximumParameter.ActualName + " could not be found.");
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Manipulators/MichalewiczNonUniformOnePositionManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Manipulators/MichalewiczNonUniformOnePositionManipulator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Manipulators/MichalewiczNonUniformOnePositionManipulator.cs	(revision 3048)
@@ -40,30 +40,30 @@
     /// The lower bound of the values in the real vector.
     /// </summary>
-    public ValueLookupParameter<DoubleData> MinimumParameter {
-      get { return (ValueLookupParameter<DoubleData>)Parameters["Minimum"]; }
+    public ValueLookupParameter<DoubleValue> MinimumParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Minimum"]; }
     }
     /// <summary>
     /// The upper bound of the values in the real vector.
     /// </summary>
-    public ValueLookupParameter<DoubleData> MaximumParameter {
-      get { return (ValueLookupParameter<DoubleData>)Parameters["Maximum"]; }
+    public ValueLookupParameter<DoubleValue> MaximumParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Maximum"]; }
     }
     /// <summary>
     /// The current generation.
     /// </summary>
-    public LookupParameter<IntData> GenerationParameter {
-      get { return (LookupParameter<IntData>)Parameters["Generation"]; }
+    public LookupParameter<IntValue> GenerationParameter {
+      get { return (LookupParameter<IntValue>)Parameters["Generation"]; }
     }
     /// <summary>
     /// The maximum generation.
     /// </summary>
-    public LookupParameter<IntData> MaximumGenerationsParameter {
-      get { return (LookupParameter<IntData>)Parameters["MaximumGenerations"]; }
+    public LookupParameter<IntValue> MaximumGenerationsParameter {
+      get { return (LookupParameter<IntValue>)Parameters["MaximumGenerations"]; }
     }
     /// <summary>
     /// The parameter describing how much the mutation should depend on the progress towards the maximum generation.
     /// </summary>
-    public ValueLookupParameter<DoubleData> GenerationDependencyParameter {
-      get { return (ValueLookupParameter<DoubleData>)Parameters["GenerationDependency"]; }
+    public ValueLookupParameter<DoubleValue> GenerationDependencyParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["GenerationDependency"]; }
     }
 
@@ -75,9 +75,9 @@
     public MichalewiczNonUniformOnePositionManipulator()
       : base() {
-      Parameters.Add(new ValueLookupParameter<DoubleData>("Minimum", "Minimum of the sampling range for the vector element (included)"));
-      Parameters.Add(new ValueLookupParameter<DoubleData>("Maximum", "Maximum of the sampling range for the vector element (excluded)"));
-      Parameters.Add(new LookupParameter<IntData>("Generation", "Current generation of the algorithm"));
-      Parameters.Add(new LookupParameter<IntData>("MaximumGenerations", "Maximum number of generations"));
-      Parameters.Add(new ValueLookupParameter<DoubleData>("GenerationDependency", "Specifies the degree of dependency on the number of generations", new DoubleData(5)));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Minimum", "Minimum of the sampling range for the vector element (included)"));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Maximum", "Maximum of the sampling range for the vector element (excluded)"));
+      Parameters.Add(new LookupParameter<IntValue>("Generation", "Current generation of the algorithm"));
+      Parameters.Add(new LookupParameter<IntValue>("MaximumGenerations", "Maximum number of generations"));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("GenerationDependency", "Specifies the degree of dependency on the number of generations", new DoubleValue(5)));
     }
 
@@ -95,5 +95,5 @@
     /// <param name="generationsDependency">Specifies the degree of dependency on the number of generations.</param>
     /// <returns>The manipulated real vector.</returns>
-    public static void Apply(IRandom random, DoubleArrayData vector, DoubleData min, DoubleData max, IntData currentGeneration, IntData maximumGenerations, DoubleData generationsDependency) {
+    public static void Apply(IRandom random, DoubleArray vector, DoubleValue min, DoubleValue max, IntValue currentGeneration, IntValue maximumGenerations, DoubleValue generationsDependency) {
       if (currentGeneration.Value > maximumGenerations.Value) throw new ArgumentException("MichalewiczNonUniformOnePositionManipulator: CurrentGeneration must be smaller or equal than MaximumGeneration", "currentGeneration");
       int length = vector.Length;
@@ -110,9 +110,9 @@
 
     /// <summary>
-    /// Checks if all parameters are available and forwards the call to <see cref="Apply(IRandom, DoubleArrayData, DoubleData, DoubleData, IntData, IntData, DoubleData)"/>.
+    /// Checks if all parameters are available and forwards the call to <see cref="Apply(IRandom, DoubleArray, DoubleValue, DoubleValue, IntValue, IntValue, DoubleValue)"/>.
     /// </summary>
     /// <param name="random">The random number generator.</param>
     /// <param name="realVector">The real vector that should be manipulated.</param>
-    protected override void Manipulate(IRandom random, DoubleArrayData realVector) {
+    protected override void Manipulate(IRandom random, DoubleArray realVector) {
       if (MinimumParameter.ActualValue == null) throw new InvalidOperationException("MichalewiczNonUniformOnePositionManipulator: Parameter " + MinimumParameter.ActualName + " could not be found.");
       if (MaximumParameter.ActualValue == null) throw new InvalidOperationException("MichalewiczNonUniformOnePositionManipulator: Parameter " + MaximumParameter.ActualName + " could not be found.");
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Manipulators/PolynomialAllPositionManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Manipulators/PolynomialAllPositionManipulator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Manipulators/PolynomialAllPositionManipulator.cs	(revision 3048)
@@ -41,6 +41,6 @@
     /// A higher value will shape the density function such that values closer to 0 (little manipulation) are more likely than values closer to 1 or -1 (maximum manipulation).
     /// </summary>
-    public ValueLookupParameter<DoubleData> ContiguityParameter {
-      get { return (ValueLookupParameter<DoubleData>)Parameters["Contiguity"]; }
+    public ValueLookupParameter<DoubleValue> ContiguityParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Contiguity"]; }
     }
     /// <summary>
@@ -50,6 +50,6 @@
     /// The manipulated value is not restricted by the (possibly) specified lower and upper bounds. Use the <see cref="BoundsChecker"/> to correct the values after performing the mutation.
     /// </remarks>
-    public ValueLookupParameter<DoubleData> MaximumManipulationParameter {
-      get { return (ValueLookupParameter<DoubleData>)Parameters["MaximumManipulation"]; }
+    public ValueLookupParameter<DoubleValue> MaximumManipulationParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["MaximumManipulation"]; }
     }
 
@@ -60,6 +60,6 @@
     public PolynomialAllPositionManipulator()
       : base() {
-      Parameters.Add(new ValueLookupParameter<DoubleData>("Contiguity", "Specifies whether the manipulation should produce far stretching (small value) or close (large value) manipulations with higher probability. Valid values must be greater or equal to 0.", new DoubleData(2)));
-      Parameters.Add(new ValueLookupParameter<DoubleData>("MaximumManipulation", "Specifies the maximum value that should be added or subtracted by the manipulation. If this value is set to 0 no mutation will be performed.", new DoubleData(1)));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Contiguity", "Specifies whether the manipulation should produce far stretching (small value) or close (large value) manipulations with higher probability. Valid values must be greater or equal to 0.", new DoubleValue(2)));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("MaximumManipulation", "Specifies the maximum value that should be added or subtracted by the manipulation. If this value is set to 0 no mutation will be performed.", new DoubleValue(1)));
     }
 
@@ -71,5 +71,5 @@
     /// <param name="contiguity">A parameter describing the shape of the probability density function which influences the strength of the manipulation.</param>
     /// <param name="maxManipulation">The maximum strength of the manipulation.</param>
-    public static void Apply(IRandom random, DoubleArrayData vector, DoubleData contiguity, DoubleData maxManipulation) {
+    public static void Apply(IRandom random, DoubleArray vector, DoubleValue contiguity, DoubleValue maxManipulation) {
       if (contiguity.Value < 0) throw new ArgumentException("PolynomialAllPositionManipulator: Contiguity value is smaller than 0", "contiguity");
       double u, delta = 0;
@@ -88,9 +88,9 @@
 
     /// <summary>
-    /// Checks the availability of the parameters and forwards the call to <see cref="Apply(IRandom, DoubleArrayData, DoubleData, DoubleData)"/>.
+    /// Checks the availability of the parameters and forwards the call to <see cref="Apply(IRandom, DoubleArray, DoubleValue, DoubleValue)"/>.
     /// </summary>
     /// <param name="random">The random number generator to use.</param>
     /// <param name="realVector">The vector of real values to manipulate.</param>
-    protected override void Manipulate(IRandom random, DoubleArrayData realVector) {
+    protected override void Manipulate(IRandom random, DoubleArray realVector) {
       if (ContiguityParameter.ActualValue == null) throw new InvalidOperationException("PolynomialAllPositionManipulator: Parameter " + ContiguityParameter.ActualName + " could not be found.");
       if (MaximumManipulationParameter.ActualValue == null) throw new InvalidOperationException("PolynomialAllPositionManipulator: Parameter " + MaximumManipulationParameter.ActualName + " could not be found.");
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Manipulators/PolynomialOnePositionManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Manipulators/PolynomialOnePositionManipulator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Manipulators/PolynomialOnePositionManipulator.cs	(revision 3048)
@@ -40,6 +40,6 @@
     /// A higher value will shape the density function such that values closer to 0 (little manipulation) are more likely than values closer to 1 or -1 (maximum manipulation).
     /// </summary>
-    public ValueLookupParameter<DoubleData> ContiguityParameter {
-      get { return (ValueLookupParameter<DoubleData>)Parameters["Contiguity"]; }
+    public ValueLookupParameter<DoubleValue> ContiguityParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Contiguity"]; }
     }
     /// <summary>
@@ -49,6 +49,6 @@
     /// The manipulated value is not restricted by the (possibly) specified lower and upper bounds. Use the <see cref="BoundsChecker"/> to correct the values after performing the mutation.
     /// </remarks>
-    public ValueLookupParameter<DoubleData> MaximumManipulationParameter {
-      get { return (ValueLookupParameter<DoubleData>)Parameters["MaximumManipulation"]; }
+    public ValueLookupParameter<DoubleValue> MaximumManipulationParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["MaximumManipulation"]; }
     }
 
@@ -59,6 +59,6 @@
     public PolynomialOnePositionManipulator()
       : base() {
-      Parameters.Add(new ValueLookupParameter<DoubleData>("Contiguity", "Specifies whether the manipulation should produce far stretching (small value) or close (large value) manipulations with higher probability. Valid values must be greater or equal to 0.", new DoubleData(2)));
-      Parameters.Add(new ValueLookupParameter<DoubleData>("MaximumManipulation", "Specifies the maximum value that should be added or subtracted by the manipulation. If this value is set to 0 no mutation will be performed.", new DoubleData(1)));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Contiguity", "Specifies whether the manipulation should produce far stretching (small value) or close (large value) manipulations with higher probability. Valid values must be greater or equal to 0.", new DoubleValue(2)));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("MaximumManipulation", "Specifies the maximum value that should be added or subtracted by the manipulation. If this value is set to 0 no mutation will be performed.", new DoubleValue(1)));
     }
 
@@ -70,5 +70,5 @@
     /// <param name="contiguity">A parameter describing the shape of the probability density function which influences the strength of the manipulation.</param>
     /// <param name="maxManipulation">The maximum strength of the manipulation.</param>
-    public static void Apply(IRandom random, DoubleArrayData vector, DoubleData contiguity, DoubleData maxManipulation) {
+    public static void Apply(IRandom random, DoubleArray vector, DoubleValue contiguity, DoubleValue maxManipulation) {
       if (contiguity.Value < 0) throw new ArgumentException("PolynomialOnePositionManipulator: Contiguity value is smaller than 0", "contiguity");
       int index = random.Next(vector.Length);
@@ -85,9 +85,9 @@
 
     /// <summary>
-    /// Checks the availability of the parameters and forwards the call to <see cref="Apply(IRandom, DoubleArrayData, DoubleData, DoubleData)"/>.
+    /// Checks the availability of the parameters and forwards the call to <see cref="Apply(IRandom, DoubleArray, DoubleValue, DoubleValue)"/>.
     /// </summary>
     /// <param name="random">The random number generator to use.</param>
     /// <param name="realVector">The vector of real values to manipulate.</param>
-    protected override void Manipulate(IRandom random, DoubleArrayData realVector) {
+    protected override void Manipulate(IRandom random, DoubleArray realVector) {
       if (ContiguityParameter.ActualValue == null) throw new InvalidOperationException("PolynomialOnePositionManipulator: Parameter " + ContiguityParameter.ActualName + " could not be found.");
       if (MaximumManipulationParameter.ActualValue == null) throw new InvalidOperationException("PolynomialOnePositionManipulator: Parameter " + MaximumManipulationParameter.ActualName + " could not be found.");
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Manipulators/SelfAdaptiveNormalAllPositionsManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Manipulators/SelfAdaptiveNormalAllPositionsManipulator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Manipulators/SelfAdaptiveNormalAllPositionsManipulator.cs	(revision 3048)
@@ -42,6 +42,6 @@
     /// Parameter for the strategy vector.
     /// </summary>
-    public LookupParameter<DoubleArrayData> StrategyVectorParameter {
-      get { return (LookupParameter<DoubleArrayData>)Parameters["StrategyVector"]; }
+    public LookupParameter<DoubleArray> StrategyVectorParameter {
+      get { return (LookupParameter<DoubleArray>)Parameters["StrategyVector"]; }
     }
     /// <summary>
@@ -51,5 +51,5 @@
     public SelfAdaptiveNormalAllPositionsManipulator()
       : base() {
-      Parameters.Add(new LookupParameter<DoubleArrayData>("StrategyVector", "The vector containing the endogenous strategy parameters."));
+      Parameters.Add(new LookupParameter<DoubleArray>("StrategyVector", "The vector containing the endogenous strategy parameters."));
     }
 
@@ -64,5 +64,5 @@
     /// <param name="vector">The real vector to manipulate.</param>
     /// <returns>The manipulated real vector.</returns>
-    public static void Apply(IRandom random, DoubleArrayData vector, DoubleArrayData strategyParameters) {
+    public static void Apply(IRandom random, DoubleArray vector, DoubleArray strategyParameters) {
       NormalDistributedRandom N = new NormalDistributedRandom(random, 0.0, 1.0);
       for (int i = 0; i < vector.Length; i++) {
@@ -72,9 +72,9 @@
 
     /// <summary>
-    /// Checks that the strategy vector is not null and forwards the call to <see cref="Apply(IRandom, DoubleArrayData, DoubleArrayData)"/>.
+    /// Checks that the strategy vector is not null and forwards the call to <see cref="Apply(IRandom, DoubleArray, DoubleArray)"/>.
     /// </summary>
     /// <param name="random">The random number generator.</param>
     /// <param name="realVector">The vector of real values that is manipulated.</param>
-    protected override void Manipulate(IRandom random, DoubleArrayData realVector) {
+    protected override void Manipulate(IRandom random, DoubleArray realVector) {
       if (StrategyVectorParameter.ActualValue == null) throw new InvalidOperationException("SelfAdaptiveNormalAllPositionsManipulator: Parameter " + StrategyVectorParameter.ActualName + " could not be found.");
       Apply(random, realVector, StrategyVectorParameter.ActualValue);
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Manipulators/UniformOnePositionManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Manipulators/UniformOnePositionManipulator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Manipulators/UniformOnePositionManipulator.cs	(revision 3048)
@@ -39,12 +39,12 @@
     /// The lower bound of the values in the real vector.
     /// </summary>
-    public ValueLookupParameter<DoubleData> MinimumParameter {
-      get { return (ValueLookupParameter<DoubleData>)Parameters["Minimum"]; }
+    public ValueLookupParameter<DoubleValue> MinimumParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Minimum"]; }
     }
     /// <summary>
     /// The upper bound of the values in the real vector.
     /// </summary>
-    public ValueLookupParameter<DoubleData> MaximumParameter {
-      get { return (ValueLookupParameter<DoubleData>)Parameters["Maximum"]; }
+    public ValueLookupParameter<DoubleValue> MaximumParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Maximum"]; }
     }
 
@@ -54,6 +54,6 @@
     /// </summary>
     public UniformOnePositionManipulator() {
-      Parameters.Add(new ValueLookupParameter<DoubleData>("Minimum", "Minimum of the sampling range for the vector element (included)"));
-      Parameters.Add(new ValueLookupParameter<DoubleData>("Maximum", "Maximum of the sampling range for the vector element (excluded)"));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Minimum", "Minimum of the sampling range for the vector element (included)"));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Maximum", "Maximum of the sampling range for the vector element (excluded)"));
     }
 
@@ -67,5 +67,5 @@
     /// <param name="max">The maximum value of the sampling range for
     /// the vector element to change (exclusive).</param>
-    public static void Apply(IRandom random, DoubleArrayData vector, DoubleData min, DoubleData max) {
+    public static void Apply(IRandom random, DoubleArray vector, DoubleValue min, DoubleValue max) {
       int index = random.Next(vector.Length);
       vector[index] = min.Value + random.NextDouble() * (max.Value - min.Value);
@@ -73,9 +73,9 @@
 
     /// <summary>
-    /// Checks if the minimum and maximum parameters are available and forwards the call to <see cref="Apply(IRandom, DoubleArrayData, DoubleData, DoubleData)"/>.
+    /// Checks if the minimum and maximum parameters are available and forwards the call to <see cref="Apply(IRandom, DoubleArray, DoubleValue, DoubleValue)"/>.
     /// </summary>
     /// <param name="random">The random number generator to use.</param>
     /// <param name="realVector">The real vector to manipulate.</param>
-    protected override void Manipulate(IRandom random, DoubleArrayData realVector) {
+    protected override void Manipulate(IRandom random, DoubleArray realVector) {
       if (MinimumParameter.ActualValue == null) throw new InvalidOperationException("UniformOnePositionManipulator: Parameter " + MinimumParameter.ActualName + " could not be found.");
       if (MaximumParameter.ActualValue == null) throw new InvalidOperationException("UniformOnePositionManipulator: Parameter " + MaximumParameter.ActualName + " could not be found.");
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/RealVectorCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/RealVectorCreator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/RealVectorCreator.cs	(revision 3048)
@@ -41,15 +41,15 @@
       get { return (LookupParameter<IRandom>)Parameters["Random"]; }
     }
-    public ILookupParameter<DoubleArrayData> RealVectorParameter {
-      get { return (ILookupParameter<DoubleArrayData>)Parameters["RealVector"]; }
+    public ILookupParameter<DoubleArray> RealVectorParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["RealVector"]; }
     }
-    public IValueLookupParameter<IntData> LengthParameter {
-      get { return (IValueLookupParameter<IntData>)Parameters["Length"]; }
+    public IValueLookupParameter<IntValue> LengthParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["Length"]; }
     }
-    public IValueLookupParameter<DoubleData> MinimumParameter {
-      get { return (IValueLookupParameter<DoubleData>)Parameters["Minimum"]; }
+    public IValueLookupParameter<DoubleValue> MinimumParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["Minimum"]; }
     }
-    public IValueLookupParameter<DoubleData> MaximumParameter {
-      get { return (IValueLookupParameter<DoubleData>)Parameters["Maximum"]; }
+    public IValueLookupParameter<DoubleValue> MaximumParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["Maximum"]; }
     }
 
@@ -57,8 +57,8 @@
       : base() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
-      Parameters.Add(new LookupParameter<DoubleArrayData>("RealVector", "The vector which should be manipulated."));
-      Parameters.Add(new ValueLookupParameter<IntData>("Length", "The length of the vector."));
-      Parameters.Add(new ValueLookupParameter<DoubleData>("Minimum", "The lower bound for each element in the vector."));
-      Parameters.Add(new ValueLookupParameter<DoubleData>("Maximum", "The upper bound for each element in the vector."));
+      Parameters.Add(new LookupParameter<DoubleArray>("RealVector", "The vector which should be manipulated."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("Length", "The length of the vector."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Minimum", "The lower bound for each element in the vector."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Maximum", "The upper bound for each element in the vector."));
     }
 
@@ -68,5 +68,5 @@
     }
 
-    protected abstract DoubleArrayData Create(IRandom random, IntData length, DoubleData minimum, DoubleData maximum);
+    protected abstract DoubleArray Create(IRandom random, IntValue length, DoubleValue minimum, DoubleValue maximum);
   }
 }
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/RealVectorCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/RealVectorCrossover.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/RealVectorCrossover.cs	(revision 3048)
@@ -41,9 +41,9 @@
       get { return (LookupParameter<IRandom>)Parameters["Random"]; }
     }
-    public ILookupParameter<ItemArray<DoubleArrayData>> ParentsParameter {
-      get { return (SubScopesLookupParameter<DoubleArrayData>)Parameters["Parents"]; }
+    public ILookupParameter<ItemArray<DoubleArray>> ParentsParameter {
+      get { return (SubScopesLookupParameter<DoubleArray>)Parameters["Parents"]; }
     }
-    public ILookupParameter<DoubleArrayData> ChildParameter {
-      get { return (ILookupParameter<DoubleArrayData>)Parameters["Child"]; }
+    public ILookupParameter<DoubleArray> ChildParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["Child"]; }
     }
 
@@ -51,6 +51,6 @@
       : base() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic crossover operators."));
-      Parameters.Add(new SubScopesLookupParameter<DoubleArrayData>("Parents", "The parent vectors which should be crossed."));
-      Parameters.Add(new LookupParameter<DoubleArrayData>("Child", "The child vector resulting from the crossover."));
+      Parameters.Add(new SubScopesLookupParameter<DoubleArray>("Parents", "The parent vectors which should be crossed."));
+      Parameters.Add(new LookupParameter<DoubleArray>("Child", "The child vector resulting from the crossover."));
     }
 
@@ -60,5 +60,5 @@
     }
 
-    protected abstract DoubleArrayData Cross(IRandom random, ItemArray<DoubleArrayData> parents);
+    protected abstract DoubleArray Cross(IRandom random, ItemArray<DoubleArray> parents);
   }
 }
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/RealVectorManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/RealVectorManipulator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/RealVectorManipulator.cs	(revision 3048)
@@ -41,6 +41,6 @@
       get { return (LookupParameter<IRandom>)Parameters["Random"]; }
     }
-    public ILookupParameter<DoubleArrayData> RealVectorParameter {
-      get { return (ILookupParameter<DoubleArrayData>)Parameters["RealVector"]; }
+    public ILookupParameter<DoubleArray> RealVectorParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["RealVector"]; }
     }
 
@@ -48,5 +48,5 @@
       : base() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
-      Parameters.Add(new LookupParameter<DoubleArrayData>("RealVector", "The vector which should be manipulated."));
+      Parameters.Add(new LookupParameter<DoubleArray>("RealVector", "The vector which should be manipulated."));
     }
 
@@ -56,5 +56,5 @@
     }
 
-    protected abstract void Manipulate(IRandom random, DoubleArrayData realVector);
+    protected abstract void Manipulate(IRandom random, DoubleArray realVector);
   }
 }
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/Auxiliary.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/Auxiliary.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/Auxiliary.cs	(revision 3048)
@@ -25,5 +25,5 @@
 namespace HeuristicLab.Encodings.RealVector_33.Tests {
   public static class Auxiliary {
-    public static bool RealVectorIsAlmostEqualByPosition(DoubleArrayData p1, DoubleArrayData p2) {
+    public static bool RealVectorIsAlmostEqualByPosition(DoubleArray p1, DoubleArray p2) {
       bool equal = (p1.Length == p2.Length);
       if (equal) {
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/BlendAlphaBetaCrossoverTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/BlendAlphaBetaCrossoverTest.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/BlendAlphaBetaCrossoverTest.cs	(revision 3048)
@@ -68,13 +68,13 @@
     public void BlendAlphaBetaCrossoverCrossTest() {
       BlendAlphaBetaCrossover_Accessor target = new BlendAlphaBetaCrossover_Accessor(new PrivateObject(typeof(BlendAlphaBetaCrossover)));
-      ItemArray<DoubleArrayData> parents;
+      ItemArray<DoubleArray> parents;
       TestRandom random = new TestRandom();
       bool exceptionFired;
       // The following test checks if there is an exception when there are more than 2 parents
       random.Reset();
-      parents = new ItemArray<DoubleArrayData>(new DoubleArrayData[] { new DoubleArrayData(5), new DoubleArrayData(6), new DoubleArrayData(4) });
+      parents = new ItemArray<DoubleArray>(new DoubleArray[] { new DoubleArray(5), new DoubleArray(6), new DoubleArray(4) });
       exceptionFired = false;
       try {
-        DoubleArrayData actual;
+        DoubleArray actual;
         actual = target.Cross(random, parents);
       } catch (System.ArgumentException) {
@@ -84,8 +84,8 @@
       // The following test checks if there is an exception when there are less than 2 parents
       random.Reset();
-      parents = new ItemArray<DoubleArrayData>(new DoubleArrayData[] { new DoubleArrayData(4) });
+      parents = new ItemArray<DoubleArray>(new DoubleArray[] { new DoubleArray(4) });
       exceptionFired = false;
       try {
-        DoubleArrayData actual;
+        DoubleArray actual;
         actual = target.Cross(random, parents);
       } catch (System.ArgumentException) {
@@ -101,16 +101,16 @@
     public void BlendAlphaBetaCrossoverApplyTest() {
       TestRandom random = new TestRandom();
-      DoubleArrayData parent1, parent2, expected, actual;
-      DoubleData alpha;
-      DoubleData beta;
+      DoubleArray parent1, parent2, expected, actual;
+      DoubleValue alpha;
+      DoubleValue beta;
       bool exceptionFired;
       // The following test is not based on published examples
       random.Reset();
       random.DoubleNumbers = new double[] { 0.5, 0.5, 0.5, 0.5, 0.5 };
-      alpha = new DoubleData(0.5);
-      beta = new DoubleData(0.5);
-      parent1 = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
-      parent2 = new DoubleArrayData(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
-      expected = new DoubleArrayData(new double[] { 0.3, 0.15, 0.3, 0.35, 0.45 });
+      alpha = new DoubleValue(0.5);
+      beta = new DoubleValue(0.5);
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      expected = new DoubleArray(new double[] { 0.3, 0.15, 0.3, 0.35, 0.45 });
       actual = BlendAlphaBetaCrossover.Apply(random, parent1, parent2, alpha, beta);
       Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(actual, expected));
@@ -118,7 +118,7 @@
       random.Reset();
       random.DoubleNumbers = new double[] { 0.25, 0.75, 0.25, 0.75, 0.25 };
-      alpha = new DoubleData(-0.25); // negative values for alpha are not allowed
-      parent1 = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
-      parent2 = new DoubleArrayData(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      alpha = new DoubleValue(-0.25); // negative values for alpha are not allowed
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
       exceptionFired = false;
       try {
@@ -131,7 +131,7 @@
       random.Reset();
       random.DoubleNumbers = new double[] { 0.25, 0.75, 0.25, 0.75, 0.25, .75 };
-      alpha = new DoubleData(0.25);
-      parent1 = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1, 0.9 }); // this parent is longer
-      parent2 = new DoubleArrayData(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      alpha = new DoubleValue(0.25);
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1, 0.9 }); // this parent is longer
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
       exceptionFired = false;
       try {
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/BlendAlphaCrossoverTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/BlendAlphaCrossoverTest.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/BlendAlphaCrossoverTest.cs	(revision 3048)
@@ -68,13 +68,13 @@
     public void BlendAlphaCrossoverCrossTest() {
       BlendAlphaCrossover_Accessor target = new BlendAlphaCrossover_Accessor(new PrivateObject(typeof(BlendAlphaCrossover)));
-      ItemArray<DoubleArrayData> parents;
+      ItemArray<DoubleArray> parents;
       TestRandom random = new TestRandom();
       bool exceptionFired;
       // The following test checks if there is an exception when there are more than 2 parents
       random.Reset();
-      parents = new ItemArray<DoubleArrayData>(new DoubleArrayData[] { new DoubleArrayData(5), new DoubleArrayData(6), new DoubleArrayData(4) });
+      parents = new ItemArray<DoubleArray>(new DoubleArray[] { new DoubleArray(5), new DoubleArray(6), new DoubleArray(4) });
       exceptionFired = false;
       try {
-        DoubleArrayData actual;
+        DoubleArray actual;
         actual = target.Cross(random, parents);
       } catch (System.ArgumentException) {
@@ -84,8 +84,8 @@
       // The following test checks if there is an exception when there are less than 2 parents
       random.Reset();
-      parents = new ItemArray<DoubleArrayData>(new DoubleArrayData[] { new DoubleArrayData(4) });
+      parents = new ItemArray<DoubleArray>(new DoubleArray[] { new DoubleArray(4) });
       exceptionFired = false;
       try {
-        DoubleArrayData actual;
+        DoubleArray actual;
         actual = target.Cross(random, parents);
       } catch (System.ArgumentException) {
@@ -101,14 +101,14 @@
     public void BlendAlphaCrossoverApplyTest() {
       TestRandom random = new TestRandom();
-      DoubleArrayData parent1, parent2, expected, actual;
-      DoubleData alpha;
+      DoubleArray parent1, parent2, expected, actual;
+      DoubleValue alpha;
       bool exceptionFired;
       // The following test is not based on published examples
       random.Reset();
       random.DoubleNumbers = new double[] { 0.5, 0.5, 0.5, 0.5, 0.5 };
-      alpha = new DoubleData(0.5);
-      parent1 = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
-      parent2 = new DoubleArrayData(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
-      expected = new DoubleArrayData(new double[] { 0.3, 0.15, 0.3, 0.35, 0.45 });
+      alpha = new DoubleValue(0.5);
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      expected = new DoubleArray(new double[] { 0.3, 0.15, 0.3, 0.35, 0.45 });
       actual = BlendAlphaCrossover.Apply(random, parent1, parent2, alpha);
       Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(actual, expected));
@@ -116,8 +116,8 @@
       random.Reset();
       random.DoubleNumbers = new double[] { 0.25, 0.75, 0.25, 0.75, 0.25 };
-      alpha = new DoubleData(0.25);
-      parent1 = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
-      parent2 = new DoubleArrayData(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
-      expected = new DoubleArrayData(new double[] { 0.225, 0.1875, 0.3, 0.4625, 0.1875 });
+      alpha = new DoubleValue(0.25);
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      expected = new DoubleArray(new double[] { 0.225, 0.1875, 0.3, 0.4625, 0.1875 });
       actual = BlendAlphaCrossover.Apply(random, parent1, parent2, alpha);
       Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(actual, expected));
@@ -125,8 +125,8 @@
       random.Reset();
       random.DoubleNumbers = new double[] { 0.25, 0.75, 0.25, 0.75, 0.25 };
-      alpha = new DoubleData(-0.25); // negative values for alpha are not allowed
-      parent1 = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
-      parent2 = new DoubleArrayData(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
-      expected = new DoubleArrayData(new double[] { 0.225, 0.1875, 0.3, 0.4625, 0.1875 });
+      alpha = new DoubleValue(-0.25); // negative values for alpha are not allowed
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      expected = new DoubleArray(new double[] { 0.225, 0.1875, 0.3, 0.4625, 0.1875 });
       exceptionFired = false;
       try {
@@ -139,8 +139,8 @@
       random.Reset();
       random.DoubleNumbers = new double[] { 0.25, 0.75, 0.25, 0.75, 0.25, .75 };
-      alpha = new DoubleData(0.25);
-      parent1 = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1, 0.9 }); // this parent is longer
-      parent2 = new DoubleArrayData(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
-      expected = new DoubleArrayData(new double[] { 0.225, 0.1875, 0.3, 0.4625, 0.1875 });
+      alpha = new DoubleValue(0.25);
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1, 0.9 }); // this parent is longer
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      expected = new DoubleArray(new double[] { 0.225, 0.1875, 0.3, 0.4625, 0.1875 });
       exceptionFired = false;
       try {
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/DiscreteCrossoverTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/DiscreteCrossoverTest.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/DiscreteCrossoverTest.cs	(revision 3048)
@@ -68,13 +68,13 @@
     public void DiscreteCrossoverCrossTest() {
       DiscreteCrossover_Accessor target = new DiscreteCrossover_Accessor(new PrivateObject(typeof(DiscreteCrossover)));
-      ItemArray<DoubleArrayData> parents;
+      ItemArray<DoubleArray> parents;
       TestRandom random = new TestRandom();
       bool exceptionFired;
       // The following test checks if there is an exception when there are less than 2 parents
       random.Reset();
-      parents = new ItemArray<DoubleArrayData>(new DoubleArrayData[] { new DoubleArrayData(4) });
+      parents = new ItemArray<DoubleArray>(new DoubleArray[] { new DoubleArray(4) });
       exceptionFired = false;
       try {
-        DoubleArrayData actual;
+        DoubleArray actual;
         actual = target.Cross(random, parents);
       } catch (System.ArgumentException) {
@@ -90,14 +90,14 @@
     public void DiscreteCrossoverApplyTest() {
       TestRandom random = new TestRandom();
-      DoubleArrayData parent1, parent2, expected, actual;
-      ItemArray<DoubleArrayData> parents;
+      DoubleArray parent1, parent2, expected, actual;
+      ItemArray<DoubleArray> parents;
       bool exceptionFired;
       // The following test is not based on published examples
       random.Reset();
       random.IntNumbers = new int[] { 0, 0, 1, 0, 1 };
-      parent1 = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
-      parent2 = new DoubleArrayData(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
-      parents = new ItemArray<DoubleArrayData>( new DoubleArrayData[] { parent1, parent2 } );
-      expected = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.8 });
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      parents = new ItemArray<DoubleArray>( new DoubleArray[] { parent1, parent2 } );
+      expected = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.8 });
       actual = DiscreteCrossover.Apply(random, parents);
       Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(actual, expected));
@@ -105,7 +105,7 @@
       random.Reset();
       random.IntNumbers = new int[] { 0, 0, 1, 0, 1, 0 };
-      parent1 = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1, 0.9 }); // this parent is longer
-      parent2 = new DoubleArrayData(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
-      parents = new ItemArray<DoubleArrayData>(new DoubleArrayData[] { parent1, parent2 });
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1, 0.9 }); // this parent is longer
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      parents = new ItemArray<DoubleArray>(new DoubleArray[] { parent1, parent2 });
       exceptionFired = false;
       try {
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/HeuristicCrossoverTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/HeuristicCrossoverTest.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/HeuristicCrossoverTest.cs	(revision 3048)
@@ -68,13 +68,13 @@
     public void HeuristicCrossoverCrossTest() {
       HeuristicCrossover_Accessor target = new HeuristicCrossover_Accessor(new PrivateObject(typeof(HeuristicCrossover)));
-      ItemArray<DoubleArrayData> parents;
+      ItemArray<DoubleArray> parents;
       TestRandom random = new TestRandom();
       bool exceptionFired;
       // The following test checks if there is an exception when there are more than 2 parents
       random.Reset();
-      parents = new ItemArray<DoubleArrayData>(new DoubleArrayData[] { new DoubleArrayData(5), new DoubleArrayData(6), new DoubleArrayData(4) });
+      parents = new ItemArray<DoubleArray>(new DoubleArray[] { new DoubleArray(5), new DoubleArray(6), new DoubleArray(4) });
       exceptionFired = false;
       try {
-        DoubleArrayData actual;
+        DoubleArray actual;
         actual = target.Cross(random, parents);
       }
@@ -85,8 +85,8 @@
       // The following test checks if there is an exception when there are less than 2 parents
       random.Reset();
-      parents = new ItemArray<DoubleArrayData>(new DoubleArrayData[] { new DoubleArrayData(4) });
+      parents = new ItemArray<DoubleArray>(new DoubleArray[] { new DoubleArray(4) });
       exceptionFired = false;
       try {
-        DoubleArrayData actual;
+        DoubleArray actual;
         actual = target.Cross(random, parents);
       } catch (System.ArgumentException) {
@@ -102,12 +102,12 @@
     public void HeuristicCrossoverApplyTest() {
       TestRandom random = new TestRandom();
-      DoubleArrayData parent1, parent2, expected, actual;
+      DoubleArray parent1, parent2, expected, actual;
       bool exceptionFired;
       // The following test is not based on published examples
       random.Reset();
       random.DoubleNumbers = new double[] { 0.3 };
-      parent1 = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
-      parent2 = new DoubleArrayData(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
-      expected = new DoubleArrayData(new double[] { 0.14, 0.23, 0.3, 0.59, -0.11 });
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      expected = new DoubleArray(new double[] { 0.14, 0.23, 0.3, 0.59, -0.11 });
       actual = HeuristicCrossover.Apply(random, parent1, parent2);
       Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(actual, expected));
@@ -115,6 +115,6 @@
       random.Reset();
       random.DoubleNumbers = new double[] { 0.3 };
-      parent1 = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1, 0.9 }); // this parent is longer
-      parent2 = new DoubleArrayData(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1, 0.9 }); // this parent is longer
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
       exceptionFired = false;
       try {
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/LocalCrossoverTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/LocalCrossoverTest.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/LocalCrossoverTest.cs	(revision 3048)
@@ -68,13 +68,13 @@
     public void LocalCrossoverCrossTest() {
       LocalCrossover_Accessor target = new LocalCrossover_Accessor(new PrivateObject(typeof(LocalCrossover)));
-      ItemArray<DoubleArrayData> parents;
+      ItemArray<DoubleArray> parents;
       TestRandom random = new TestRandom();
       bool exceptionFired;
       // The following test checks if there is an exception when there are more than 2 parents
       random.Reset();
-      parents = new ItemArray<DoubleArrayData>(new DoubleArrayData[] { new DoubleArrayData(5), new DoubleArrayData(6), new DoubleArrayData(4) });
+      parents = new ItemArray<DoubleArray>(new DoubleArray[] { new DoubleArray(5), new DoubleArray(6), new DoubleArray(4) });
       exceptionFired = false;
       try {
-        DoubleArrayData actual;
+        DoubleArray actual;
         actual = target.Cross(random, parents);
       }
@@ -85,8 +85,8 @@
       // The following test checks if there is an exception when there are less than 2 parents
       random.Reset();
-      parents = new ItemArray<DoubleArrayData>(new DoubleArrayData[] { new DoubleArrayData(4) });
+      parents = new ItemArray<DoubleArray>(new DoubleArray[] { new DoubleArray(4) });
       exceptionFired = false;
       try {
-        DoubleArrayData actual;
+        DoubleArray actual;
         actual = target.Cross(random, parents);
       } catch (System.ArgumentException) {
@@ -102,12 +102,12 @@
     public void LocalCrossoverApplyTest() {
       TestRandom random = new TestRandom();
-      DoubleArrayData parent1, parent2, expected, actual;
+      DoubleArray parent1, parent2, expected, actual;
       bool exceptionFired;
       // The following test is not based on published examples
       random.Reset();
       random.DoubleNumbers = new double[] { 0.3, 0.1, 0.2, 0.4, 0.23 };
-      parent1 = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
-      parent2 = new DoubleArrayData(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
-      expected = new DoubleArrayData(new double[] { 0.34, 0.11, 0.3, 0.32, 0.639 });
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      expected = new DoubleArray(new double[] { 0.34, 0.11, 0.3, 0.32, 0.639 });
       actual = LocalCrossover.Apply(random, parent1, parent2);
       Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(actual, expected));
@@ -115,6 +115,6 @@
       random.Reset();
       random.DoubleNumbers = new double[] { 0.3, 0.1, 0.2, 0.4, 0.23, 0.5};
-      parent1 = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1, 0.9 }); // this parent is longer
-      parent2 = new DoubleArrayData(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1, 0.9 }); // this parent is longer
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
       exceptionFired = false;
       try {
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/MichalewiczNonUniformAllPositionsManipulatorTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/MichalewiczNonUniformAllPositionsManipulatorTest.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/MichalewiczNonUniformAllPositionsManipulatorTest.cs	(revision 3048)
@@ -85,18 +85,18 @@
     public void MichalewiczNonUniformAllPositionsManipulatorApplyTest() {
       TestRandom random = new TestRandom();
-      DoubleArrayData parent, expected;
-      DoubleData min, max, generationsDependency;
-      IntData currentGeneration, maximumGenerations;
+      DoubleArray parent, expected;
+      DoubleValue min, max, generationsDependency;
+      IntValue currentGeneration, maximumGenerations;
       bool exceptionFired;
       // The following test is not based on published examples
       random.Reset();
       random.DoubleNumbers = new double[] { 0.2, 0.5, 0.7, 0.8, 0.9, 0.5, 0.2, 0.5, 0.7, 0.8 };
-      parent = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
-      expected = new DoubleArrayData(new double[] { 0.45, 0.22, 0.3, 0.6, 0.14 });
-      min = new DoubleData(0.3);
-      max = new DoubleData(0.7);
-      generationsDependency = new DoubleData(0.1);
-      currentGeneration = new IntData(1);
-      maximumGenerations = new IntData(4);
+      parent = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      expected = new DoubleArray(new double[] { 0.45, 0.22, 0.3, 0.6, 0.14 });
+      min = new DoubleValue(0.3);
+      max = new DoubleValue(0.7);
+      generationsDependency = new DoubleValue(0.1);
+      currentGeneration = new IntValue(1);
+      maximumGenerations = new IntValue(4);
       MichalewiczNonUniformAllPositionsManipulator.Apply(random, parent, min, max, currentGeneration, maximumGenerations, generationsDependency);
       Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(expected, parent));
@@ -105,10 +105,10 @@
       random.Reset();
       random.DoubleNumbers = new double[] { 0.2, 0.5, 0.7, 0.8, 0.9, 0.5, 0.2, 0.5, 0.7, 0.8 };
-      parent = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
-      min = new DoubleData(0.3);
-      max = new DoubleData(0.7);
-      generationsDependency = new DoubleData(0.1);
-      currentGeneration = new IntData(5); //current generation > max generation
-      maximumGenerations = new IntData(4);
+      parent = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      min = new DoubleValue(0.3);
+      max = new DoubleValue(0.7);
+      generationsDependency = new DoubleValue(0.1);
+      currentGeneration = new IntValue(5); //current generation > max generation
+      maximumGenerations = new IntValue(4);
       try {
         MichalewiczNonUniformAllPositionsManipulator.Apply(random, parent, min, max, currentGeneration, maximumGenerations, generationsDependency);
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/MichalewiczNonUniformOnePositionManipulatorTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/MichalewiczNonUniformOnePositionManipulatorTest.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/MichalewiczNonUniformOnePositionManipulatorTest.cs	(revision 3048)
@@ -85,7 +85,7 @@
     public void MichalewiczNonUniformOnePositionManipulatorApplyTest() {
       TestRandom random = new TestRandom();
-      DoubleArrayData parent, expected;
-      DoubleData min, max, generationsDependency;
-      IntData currentGeneration, maximumGenerations;
+      DoubleArray parent, expected;
+      DoubleValue min, max, generationsDependency;
+      IntValue currentGeneration, maximumGenerations;
       bool exceptionFired;
       // The following test is not based on published examples
@@ -93,11 +93,11 @@
       random.IntNumbers = new int[] { 3 };
       random.DoubleNumbers = new double[] { 0.2, 0.7 };
-      parent = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
-      expected = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.34, 0.1 });
-      min = new DoubleData(0.3);
-      max = new DoubleData(0.7);
-      generationsDependency = new DoubleData(0.1);
-      currentGeneration = new IntData(1);
-      maximumGenerations = new IntData(4);
+      parent = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      expected = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.34, 0.1 });
+      min = new DoubleValue(0.3);
+      max = new DoubleValue(0.7);
+      generationsDependency = new DoubleValue(0.1);
+      currentGeneration = new IntValue(1);
+      maximumGenerations = new IntValue(4);
       MichalewiczNonUniformOnePositionManipulator.Apply(random, parent, min, max, currentGeneration, maximumGenerations, generationsDependency);
       Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(expected, parent));
@@ -107,10 +107,10 @@
       random.IntNumbers = new int[] { 3 };
       random.DoubleNumbers = new double[] { 0.2, 0.7 };
-      parent = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
-      min = new DoubleData(0.3);
-      max = new DoubleData(0.7);
-      generationsDependency = new DoubleData(0.1);
-      currentGeneration = new IntData(5); //current generation > max generation
-      maximumGenerations = new IntData(4);
+      parent = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      min = new DoubleValue(0.3);
+      max = new DoubleValue(0.7);
+      generationsDependency = new DoubleValue(0.1);
+      currentGeneration = new IntValue(5); //current generation > max generation
+      maximumGenerations = new IntValue(4);
       try {
         MichalewiczNonUniformOnePositionManipulator.Apply(random, parent, min, max, currentGeneration, maximumGenerations, generationsDependency);
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/PolynomialAllPositionManipulatorTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/PolynomialAllPositionManipulatorTest.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/PolynomialAllPositionManipulatorTest.cs	(revision 3048)
@@ -85,14 +85,14 @@
     public void PolynomialAllPositionManipulatorApplyTest() {
       TestRandom random = new TestRandom();
-      DoubleArrayData parent, expected;
-      DoubleData contiguity, maxManipulation;
+      DoubleArray parent, expected;
+      DoubleValue contiguity, maxManipulation;
       bool exceptionFired;
       // The following test is not based on published examples
       random.Reset();
       random.DoubleNumbers = new double[] { 0.2, 0.7, 0.8, 0.01, 0.1 };
-      parent = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
-      expected = new DoubleArrayData(new double[] { 0.120213215256006, 0.336631954950876, 0.474551336679454, 0.322759240811056, -0.0182075293954083 });
-      contiguity = new DoubleData(0.8);
-      maxManipulation = new DoubleData(0.2);
+      parent = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      expected = new DoubleArray(new double[] { 0.120213215256006, 0.336631954950876, 0.474551336679454, 0.322759240811056, -0.0182075293954083 });
+      contiguity = new DoubleValue(0.8);
+      maxManipulation = new DoubleValue(0.2);
       PolynomialAllPositionManipulator.Apply(random, parent, contiguity, maxManipulation);
       Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(expected, parent));
@@ -101,7 +101,7 @@
       random.Reset();
       random.DoubleNumbers = new double[] { 0.2, 0.7, 0.8, 0.01, 0.1 };
-      parent = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
-      contiguity = new DoubleData(-1); //Contiguity value < 0
-      maxManipulation = new DoubleData(0.2);
+      parent = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      contiguity = new DoubleValue(-1); //Contiguity value < 0
+      maxManipulation = new DoubleValue(0.2);
       try {
         PolynomialAllPositionManipulator.Apply(random, parent, contiguity, maxManipulation);
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/PolynomialOnePositionManipulatorTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/PolynomialOnePositionManipulatorTest.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/PolynomialOnePositionManipulatorTest.cs	(revision 3048)
@@ -85,6 +85,6 @@
     public void PolynomialOnePositionManipulatorApplyTest() {
       TestRandom random = new TestRandom();
-      DoubleArrayData parent, expected;
-      DoubleData contiguity, maxManipulation;
+      DoubleArray parent, expected;
+      DoubleValue contiguity, maxManipulation;
       bool exceptionFired;
       // The following test is not based on published examples
@@ -92,8 +92,8 @@
       random.IntNumbers = new int[] { 3 };
       random.DoubleNumbers = new double[] { 0.2 };
-      parent = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
-      expected = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.1261980542102, 0.1 });
-      contiguity = new DoubleData(0.2);
-      maxManipulation = new DoubleData(0.7);
+      parent = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      expected = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.1261980542102, 0.1 });
+      contiguity = new DoubleValue(0.2);
+      maxManipulation = new DoubleValue(0.7);
       PolynomialOnePositionManipulator.Apply(random, parent, contiguity, maxManipulation);
       Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(expected, parent));
@@ -103,7 +103,7 @@
       random.IntNumbers = new int[] { 3 };
       random.DoubleNumbers = new double[] { 0.2 };
-      parent = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
-      contiguity = new DoubleData(-1); //Contiguity value < 0
-      maxManipulation = new DoubleData(0.2);
+      parent = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      contiguity = new DoubleValue(-1); //Contiguity value < 0
+      maxManipulation = new DoubleValue(0.2);
       try {
         PolynomialOnePositionManipulator.Apply(random, parent, contiguity, maxManipulation);
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/RandomConvexCrossoverTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/RandomConvexCrossoverTest.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/RandomConvexCrossoverTest.cs	(revision 3048)
@@ -68,13 +68,13 @@
     public void RandomConvexCrossoverCrossTest() {
       RandomConvexCrossover_Accessor target = new RandomConvexCrossover_Accessor(new PrivateObject(typeof(RandomConvexCrossover)));
-      ItemArray<DoubleArrayData> parents;
+      ItemArray<DoubleArray> parents;
       TestRandom random = new TestRandom();
       bool exceptionFired;
       // The following test checks if there is an exception when there are more than 2 parents
       random.Reset();
-      parents = new ItemArray<DoubleArrayData>(new DoubleArrayData[] { new DoubleArrayData(5), new DoubleArrayData(6), new DoubleArrayData(4) });
+      parents = new ItemArray<DoubleArray>(new DoubleArray[] { new DoubleArray(5), new DoubleArray(6), new DoubleArray(4) });
       exceptionFired = false;
       try {
-        DoubleArrayData actual;
+        DoubleArray actual;
         actual = target.Cross(random, parents);
       }
@@ -85,8 +85,8 @@
       // The following test checks if there is an exception when there are less than 2 parents
       random.Reset();
-      parents = new ItemArray<DoubleArrayData>(new DoubleArrayData[] { new DoubleArrayData(4) });
+      parents = new ItemArray<DoubleArray>(new DoubleArray[] { new DoubleArray(4) });
       exceptionFired = false;
       try {
-        DoubleArrayData actual;
+        DoubleArray actual;
         actual = target.Cross(random, parents);
       } catch (System.ArgumentException) {
@@ -102,12 +102,12 @@
     public void RandomConvexCrossoverApplyTest() {
       TestRandom random = new TestRandom();
-      DoubleArrayData parent1, parent2, expected, actual;
+      DoubleArray parent1, parent2, expected, actual;
       bool exceptionFired;
       // The following test is not based on published examples
       random.Reset();
       random.DoubleNumbers = new double[] { 0.3 };
-      parent1 = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
-      parent2 = new DoubleArrayData(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
-      expected = new DoubleArrayData(new double[] { 0.34, 0.13, 0.3, 0.29, 0.59 });
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      expected = new DoubleArray(new double[] { 0.34, 0.13, 0.3, 0.29, 0.59 });
       actual = RandomConvexCrossover.Apply(random, parent1, parent2);
       Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(actual, expected));
@@ -115,6 +115,6 @@
       random.Reset();
       random.DoubleNumbers = new double[] { 0.3 };
-      parent1 = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1, 0.9 }); // this parent is longer
-      parent2 = new DoubleArrayData(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1, 0.9 }); // this parent is longer
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
       exceptionFired = false;
       try {
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/SimulatedBinaryCrossoverTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/SimulatedBinaryCrossoverTest.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/SimulatedBinaryCrossoverTest.cs	(revision 3048)
@@ -68,13 +68,13 @@
     public void SimulatedBinaryCrossoverCrossTest() {
       SimulatedBinaryCrossover_Accessor target = new SimulatedBinaryCrossover_Accessor(new PrivateObject(typeof(SimulatedBinaryCrossover)));
-      ItemArray<DoubleArrayData> parents;
+      ItemArray<DoubleArray> parents;
       TestRandom random = new TestRandom();
       bool exceptionFired;
       // The following test checks if there is an exception when there are more than 2 parents
       random.Reset();
-      parents = new ItemArray<DoubleArrayData>(new DoubleArrayData[] { new DoubleArrayData(5), new DoubleArrayData(6), new DoubleArrayData(4) });
+      parents = new ItemArray<DoubleArray>(new DoubleArray[] { new DoubleArray(5), new DoubleArray(6), new DoubleArray(4) });
       exceptionFired = false;
       try {
-        DoubleArrayData actual;
+        DoubleArray actual;
         actual = target.Cross(random, parents);
       }
@@ -85,8 +85,8 @@
       // The following test checks if there is an exception when there are less than 2 parents
       random.Reset();
-      parents = new ItemArray<DoubleArrayData>(new DoubleArrayData[] { new DoubleArrayData(4) });
+      parents = new ItemArray<DoubleArray>(new DoubleArray[] { new DoubleArray(4) });
       exceptionFired = false;
       try {
-        DoubleArrayData actual;
+        DoubleArray actual;
         actual = target.Cross(random, parents);
       } catch (System.ArgumentException) {
@@ -102,14 +102,14 @@
     public void SimulatedBinaryCrossoverApplyTest() {
       TestRandom random = new TestRandom();
-      DoubleArrayData parent1, parent2, expected, actual;
-      DoubleData contiguity;
+      DoubleArray parent1, parent2, expected, actual;
+      DoubleValue contiguity;
       bool exceptionFired;
       // The following test is not based on published examples
       random.Reset();
       random.DoubleNumbers = new double[] { 0.3, 0.9, 0.7, 0.2, 0.8, 0.1, 0.2, 0.3, 0.4, 0.8, 0.7 };
-      contiguity = new DoubleData(0.3);
-      parent1 = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
-      parent2 = new DoubleArrayData(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
-      expected = new DoubleArrayData(new double[] { 1.11032829834638, -0.0145477755417797, 0.3, 0.5, 0.1 });
+      contiguity = new DoubleValue(0.3);
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      expected = new DoubleArray(new double[] { 1.11032829834638, -0.0145477755417797, 0.3, 0.5, 0.1 });
       actual = SimulatedBinaryCrossover.Apply(random, parent1, parent2, contiguity);
       Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(actual, expected));
@@ -117,7 +117,7 @@
       random.Reset();
       random.DoubleNumbers = new double[] { 0.3, 0.9, 0.7, 0.2, 0.8, 0.1, 0.2, 0.3, 0.4, 0.8, 0.7 };
-      contiguity = new DoubleData(0.3);
-      parent1 = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1, 0.9 }); // this parent is longer
-      parent2 = new DoubleArrayData(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      contiguity = new DoubleValue(0.3);
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1, 0.9 }); // this parent is longer
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
       exceptionFired = false;
       try {
@@ -130,7 +130,7 @@
       random.Reset();
       random.DoubleNumbers = new double[] { 0.3, 0.9, 0.7, 0.2, 0.8, 0.1, 0.2, 0.3, 0.4, 0.8, 0.7 };
-      contiguity = new DoubleData(-0.3);  //  contiguity < 0
-      parent1 = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1}); 
-      parent2 = new DoubleArrayData(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      contiguity = new DoubleValue(-0.3);  //  contiguity < 0
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1}); 
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
       exceptionFired = false;
       try {
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/SinglePointCrossoverTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/SinglePointCrossoverTest.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/SinglePointCrossoverTest.cs	(revision 3048)
@@ -68,13 +68,13 @@
     public void SinglePointCrossoverCrossTest() {
       SinglePointCrossover_Accessor target = new SinglePointCrossover_Accessor(new PrivateObject(typeof(SinglePointCrossover)));
-      ItemArray<DoubleArrayData> parents;
+      ItemArray<DoubleArray> parents;
       TestRandom random = new TestRandom();
       bool exceptionFired;
       // The following test checks if there is an exception when there are more than 2 parents
       random.Reset();
-      parents = new ItemArray<DoubleArrayData>(new DoubleArrayData[] { new DoubleArrayData(5), new DoubleArrayData(6), new DoubleArrayData(4) });
+      parents = new ItemArray<DoubleArray>(new DoubleArray[] { new DoubleArray(5), new DoubleArray(6), new DoubleArray(4) });
       exceptionFired = false;
       try {
-        DoubleArrayData actual;
+        DoubleArray actual;
         actual = target.Cross(random, parents);
       }
@@ -85,8 +85,8 @@
       // The following test checks if there is an exception when there are less than 2 parents
       random.Reset();
-      parents = new ItemArray<DoubleArrayData>(new DoubleArrayData[] { new DoubleArrayData(4) });
+      parents = new ItemArray<DoubleArray>(new DoubleArray[] { new DoubleArray(4) });
       exceptionFired = false;
       try {
-        DoubleArrayData actual;
+        DoubleArray actual;
         actual = target.Cross(random, parents);
       } catch (System.ArgumentException) {
@@ -102,12 +102,12 @@
     public void SinglePointCrossoverApplyTest() {
       TestRandom random = new TestRandom();
-      DoubleArrayData parent1, parent2, expected, actual;
+      DoubleArray parent1, parent2, expected, actual;
       bool exceptionFired;
       // The following test is not based on published examples
       random.Reset();
       random.IntNumbers = new int[] { 3 };
-      parent1 = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
-      parent2 = new DoubleArrayData(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
-      expected = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.2, 0.8 });
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      expected = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.2, 0.8 });
       actual = SinglePointCrossover.Apply(random, parent1, parent2);
       Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(actual, expected));
@@ -115,6 +115,6 @@
       random.Reset();
       random.IntNumbers = new int[] { 2 };
-      parent1 = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1, 0.9 }); // this parent is longer
-      parent2 = new DoubleArrayData(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1, 0.9 }); // this parent is longer
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
       exceptionFired = false;
       try {
Index: trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/UniformOnePositionManipulatorTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/UniformOnePositionManipulatorTest.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/UniformOnePositionManipulatorTest.cs	(revision 3048)
@@ -85,14 +85,14 @@
     public void UniformOnePositionManipulatorApplyTest() {
       TestRandom random = new TestRandom();
-      DoubleArrayData parent, expected;
-      DoubleData min, max;
+      DoubleArray parent, expected;
+      DoubleValue min, max;
       // The following test is not based on published examples
       random.Reset();
       random.IntNumbers = new int[] { 3 };
       random.DoubleNumbers = new double[] { 0.2 };
-      parent = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
-      expected = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.3, 0.1 });
-      min = new DoubleData(0.2);
-      max = new DoubleData(0.7);
+      parent = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      expected = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.3, 0.1 });
+      min = new DoubleValue(0.2);
+      max = new DoubleValue(0.7);
       UniformOnePositionManipulator.Apply(random, parent, min, max);
       Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(expected, parent));
Index: trunk/sources/HeuristicLab.Operators.Programmable/3.3/ProgrammableOperator.cs
===================================================================
--- trunk/sources/HeuristicLab.Operators.Programmable/3.3/ProgrammableOperator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Operators.Programmable/3.3/ProgrammableOperator.cs	(revision 3048)
@@ -222,5 +222,5 @@
       typeof(System.Data.Linq.DataContext).Assembly,
       typeof(HeuristicLab.Core.Item).Assembly,
-      typeof(HeuristicLab.Data.IntData).Assembly,
+      typeof(HeuristicLab.Data.IntValue).Assembly,
     };
 
Index: trunk/sources/HeuristicLab.Operators/3.3/Comparator.cs
===================================================================
--- trunk/sources/HeuristicLab.Operators/3.3/Comparator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Operators/3.3/Comparator.cs	(revision 3048)
@@ -40,11 +40,11 @@
       get { return (ValueLookupParameter<IItem>)Parameters["RightSide"]; }
     }
-    private ValueParameter<ComparisonData> ComparisonParameter {
-      get { return (ValueParameter<ComparisonData>)Parameters["Comparison"]; }
+    private ValueParameter<Comparison> ComparisonParameter {
+      get { return (ValueParameter<Comparison>)Parameters["Comparison"]; }
     }
-    public LookupParameter<BoolData> ResultParameter {
-      get { return (LookupParameter<BoolData>)Parameters["Result"]; }
+    public LookupParameter<BoolValue> ResultParameter {
+      get { return (LookupParameter<BoolValue>)Parameters["Result"]; }
     }
-    public ComparisonData Comparison {
+    public Comparison Comparison {
       get { return ComparisonParameter.Value; }
       set { ComparisonParameter.Value = value; }
@@ -55,6 +55,6 @@
       Parameters.Add(new LookupParameter<IItem>("LeftSide", "The left side of the comparison."));
       Parameters.Add(new ValueLookupParameter<IItem>("RightSide", "The right side of the comparison."));
-      Parameters.Add(new ValueParameter<ComparisonData>("Comparison", "The type of comparison.", new ComparisonData(Data.Comparison.Equal)));
-      Parameters.Add(new LookupParameter<BoolData>("Result", "The result of the comparison."));
+      Parameters.Add(new ValueParameter<Comparison>("Comparison", "The type of comparison.", new Comparison(Data.ComparisonType.Equal)));
+      Parameters.Add(new LookupParameter<BoolValue>("Result", "The result of the comparison."));
     }
 
@@ -68,18 +68,18 @@
       bool b = false;
       switch (Comparison.Value) {
-        case HeuristicLab.Data.Comparison.Less:
+        case HeuristicLab.Data.ComparisonType.Less:
           b = i < 0; break;
-        case HeuristicLab.Data.Comparison.LessOrEqual:
+        case HeuristicLab.Data.ComparisonType.LessOrEqual:
           b = i <= 0; break;
-        case HeuristicLab.Data.Comparison.Equal:
+        case HeuristicLab.Data.ComparisonType.Equal:
           b = i == 0; break;
-        case HeuristicLab.Data.Comparison.GreaterOrEqual:
+        case HeuristicLab.Data.ComparisonType.GreaterOrEqual:
           b = i >= 0; break;
-        case HeuristicLab.Data.Comparison.Greater:
+        case HeuristicLab.Data.ComparisonType.Greater:
           b = i > 0; break;
-        case HeuristicLab.Data.Comparison.NotEqual:
+        case HeuristicLab.Data.ComparisonType.NotEqual:
           b = i != 0; break;
       }
-      ResultParameter.ActualValue = new BoolData(b);
+      ResultParameter.ActualValue = new BoolValue(b);
       return base.Apply();
     }
Index: trunk/sources/HeuristicLab.Operators/3.3/ConditionalBranch.cs
===================================================================
--- trunk/sources/HeuristicLab.Operators/3.3/ConditionalBranch.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Operators/3.3/ConditionalBranch.cs	(revision 3048)
@@ -33,6 +33,6 @@
   [StorableClass]
   public class ConditionalBranch : SingleSuccessorOperator {
-    public LookupParameter<BoolData> ConditionParameter {
-      get { return (LookupParameter<BoolData>)Parameters["Condition"]; }
+    public LookupParameter<BoolValue> ConditionParameter {
+      get { return (LookupParameter<BoolValue>)Parameters["Condition"]; }
     }
     protected OperatorParameter TrueBranchParameter {
@@ -53,5 +53,5 @@
     public ConditionalBranch()
       : base() {
-      Parameters.Add(new LookupParameter<BoolData>("Condition", "A boolean variable which defines which branch is executed."));
+      Parameters.Add(new LookupParameter<BoolValue>("Condition", "A boolean variable which defines which branch is executed."));
       Parameters.Add(new OperatorParameter("TrueBranch", "The operator which is executed if the condition is true."));
       Parameters.Add(new OperatorParameter("FalseBranch", "The operator which is executed if the condition is false."));
Index: trunk/sources/HeuristicLab.Operators/3.3/DoubleCounter.cs
===================================================================
--- trunk/sources/HeuristicLab.Operators/3.3/DoubleCounter.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Operators/3.3/DoubleCounter.cs	(revision 3048)
@@ -33,11 +33,11 @@
   [Creatable("Test")]
   public sealed class DoubleCounter : SingleSuccessorOperator {
-    public LookupParameter<DoubleData> ValueParameter {
-      get { return (LookupParameter<DoubleData>)Parameters["Value"]; }
+    public LookupParameter<DoubleValue> ValueParameter {
+      get { return (LookupParameter<DoubleValue>)Parameters["Value"]; }
     }
-    public ValueLookupParameter<DoubleData> IncrementParameter {
-      get { return (ValueLookupParameter<DoubleData>)Parameters["Increment"]; }
+    public ValueLookupParameter<DoubleValue> IncrementParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Increment"]; }
     }
-    public DoubleData Increment {
+    public DoubleValue Increment {
       get { return IncrementParameter.Value; }
       set { IncrementParameter.Value = value; }
@@ -46,10 +46,10 @@
     public DoubleCounter()
       : base() {
-      Parameters.Add(new LookupParameter<DoubleData>("Value", "The value which should be incremented."));
-      Parameters.Add(new ValueLookupParameter<DoubleData>("Increment", "The increment which is added to the value.", new DoubleData(1)));
+      Parameters.Add(new LookupParameter<DoubleValue>("Value", "The value which should be incremented."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Increment", "The increment which is added to the value.", new DoubleValue(1)));
     }
 
     public override IOperation Apply() {
-      if (ValueParameter.ActualValue == null) ValueParameter.ActualValue = new DoubleData();
+      if (ValueParameter.ActualValue == null) ValueParameter.ActualValue = new DoubleValue();
       ValueParameter.ActualValue.Value += IncrementParameter.ActualValue.Value;
       return base.Apply();
Index: trunk/sources/HeuristicLab.Operators/3.3/IntCounter.cs
===================================================================
--- trunk/sources/HeuristicLab.Operators/3.3/IntCounter.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Operators/3.3/IntCounter.cs	(revision 3048)
@@ -33,11 +33,11 @@
   [Creatable("Test")]
   public sealed class IntCounter : SingleSuccessorOperator {
-    public LookupParameter<IntData> ValueParameter {
-      get { return (LookupParameter<IntData>)Parameters["Value"]; }
+    public LookupParameter<IntValue> ValueParameter {
+      get { return (LookupParameter<IntValue>)Parameters["Value"]; }
     }
-    public ValueLookupParameter<IntData> IncrementParameter {
-      get { return (ValueLookupParameter<IntData>)Parameters["Increment"]; }
+    public ValueLookupParameter<IntValue> IncrementParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["Increment"]; }
     }
-    public IntData Increment {
+    public IntValue Increment {
       get { return IncrementParameter.Value; }
       set { IncrementParameter.Value = value; }
@@ -46,10 +46,10 @@
     public IntCounter()
       : base() {
-      Parameters.Add(new LookupParameter<IntData>("Value", "The value which should be incremented."));
-      Parameters.Add(new ValueLookupParameter<IntData>("Increment", "The increment which is added to the value.", new IntData(1)));
+      Parameters.Add(new LookupParameter<IntValue>("Value", "The value which should be incremented."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("Increment", "The increment which is added to the value.", new IntValue(1)));
     }
 
     public override IOperation Apply() {
-      if (ValueParameter.ActualValue == null) ValueParameter.ActualValue = new IntData();
+      if (ValueParameter.ActualValue == null) ValueParameter.ActualValue = new IntValue();
       ValueParameter.ActualValue.Value += IncrementParameter.ActualValue.Value;
       return base.Apply();
Index: trunk/sources/HeuristicLab.Operators/3.3/StochasticBranch.cs
===================================================================
--- trunk/sources/HeuristicLab.Operators/3.3/StochasticBranch.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Operators/3.3/StochasticBranch.cs	(revision 3048)
@@ -36,6 +36,6 @@
       get { return (LookupParameter<IRandom>)Parameters["Random"]; }
     }
-    public ValueLookupParameter<DoubleData> ProbabilityParameter {
-      get { return (ValueLookupParameter<DoubleData>)Parameters["Probability"]; }
+    public ValueLookupParameter<DoubleValue> ProbabilityParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Probability"]; }
     }
     protected OperatorParameter FirstBranchParameter {
@@ -57,5 +57,5 @@
       : base() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "A pseudo random number generator."));
-      Parameters.Add(new ValueLookupParameter<DoubleData>("Probability", "The probability to execute the first branch."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Probability", "The probability to execute the first branch."));
       Parameters.Add(new OperatorParameter("FirstBranch", "The operator which is executed with the given probability."));
       Parameters.Add(new OperatorParameter("SecondBranch", "The operator which is executed if the first branch is not executed."));
Index: trunk/sources/HeuristicLab.Operators/3.3/SubScopesCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Operators/3.3/SubScopesCreator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Operators/3.3/SubScopesCreator.cs	(revision 3048)
@@ -33,6 +33,6 @@
   [Creatable("Test")]
   public class SubScopesCreator : SingleSuccessorOperator {
-    public ValueLookupParameter<IntData> NumberOfSubScopesParameter {
-      get { return (ValueLookupParameter<IntData>)Parameters["NumberOfSubScopes"]; }
+    public ValueLookupParameter<IntValue> NumberOfSubScopesParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["NumberOfSubScopes"]; }
     }
     protected ScopeParameter CurrentScopeParameter {
@@ -45,5 +45,5 @@
     public SubScopesCreator()
       : base() {
-      Parameters.Add(new ValueLookupParameter<IntData>("NumberOfSubScopes", "The number of new and empty sub-scopes which should be added to the current scope."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("NumberOfSubScopes", "The number of new and empty sub-scopes which should be added to the current scope."));
       Parameters.Add(new ScopeParameter("CurrentScope", "The current scope to which the new and empty sub-scopes are added."));
     }
Index: trunk/sources/HeuristicLab.Operators/3.3/SubScopesRemover.cs
===================================================================
--- trunk/sources/HeuristicLab.Operators/3.3/SubScopesRemover.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Operators/3.3/SubScopesRemover.cs	(revision 3048)
@@ -33,9 +33,9 @@
   [Creatable("Test")]
   public sealed class SubScopesRemover : SingleSuccessorOperator {
-    private ValueParameter<BoolData> RemoveAllSubScopesParameter {
-      get { return (ValueParameter<BoolData>)Parameters["RemoveAllSubScopes"]; }
+    private ValueParameter<BoolValue> RemoveAllSubScopesParameter {
+      get { return (ValueParameter<BoolValue>)Parameters["RemoveAllSubScopes"]; }
     }
-    public ValueLookupParameter<IntData> SubScopeIndexParameter {
-      get { return (ValueLookupParameter<IntData>)Parameters["SubScopeIndex"]; }
+    public ValueLookupParameter<IntValue> SubScopeIndexParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["SubScopeIndex"]; }
     }
     private ScopeParameter CurrentScopeParameter {
@@ -53,6 +53,6 @@
     public SubScopesRemover()
       : base() {
-      Parameters.Add(new ValueParameter<BoolData>("RemoveAllSubScopes", "True if all sub-scopes of the current scope should be removed, otherwise false.", new BoolData(true)));
-      Parameters.Add(new ValueLookupParameter<IntData>("SubScopeIndex", "The index of the sub-scope which should be removed. This parameter is ignored, if RemoveAllSubScopes is true."));
+      Parameters.Add(new ValueParameter<BoolValue>("RemoveAllSubScopes", "True if all sub-scopes of the current scope should be removed, otherwise false.", new BoolValue(true)));
+      Parameters.Add(new ValueLookupParameter<IntValue>("SubScopeIndex", "The index of the sub-scope which should be removed. This parameter is ignored, if RemoveAllSubScopes is true."));
       Parameters.Add(new ScopeParameter("CurrentScope", "The current scope from which one or all sub-scopes should be removed."));
     }
Index: trunk/sources/HeuristicLab.Operators/3.3/SubScopesSorter.cs
===================================================================
--- trunk/sources/HeuristicLab.Operators/3.3/SubScopesSorter.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Operators/3.3/SubScopesSorter.cs	(revision 3048)
@@ -36,9 +36,9 @@
     private string actualName;
 
-    public SubScopesLookupParameter<DoubleData> ValueParameter {
-      get { return (SubScopesLookupParameter<DoubleData>)Parameters["Value"]; }
+    public SubScopesLookupParameter<DoubleValue> ValueParameter {
+      get { return (SubScopesLookupParameter<DoubleValue>)Parameters["Value"]; }
     }
-    public ValueLookupParameter<BoolData> DescendingParameter {
-      get { return (ValueLookupParameter<BoolData>)Parameters["Descending"]; }
+    public ValueLookupParameter<BoolValue> DescendingParameter {
+      get { return (ValueLookupParameter<BoolValue>)Parameters["Descending"]; }
     }
     private ScopeParameter CurrentScopeParameter {
@@ -51,6 +51,6 @@
     public SubScopesSorter()
       : base() {
-      Parameters.Add(new SubScopesLookupParameter<DoubleData>("Value", "The values contained in each sub-scope acording which the sub-scopes of the current scope are sorted."));
-      Parameters.Add(new ValueLookupParameter<BoolData>("Descending", "True if the sub-scopes should be sorted in descending order, otherwise false."));
+      Parameters.Add(new SubScopesLookupParameter<DoubleValue>("Value", "The values contained in each sub-scope acording which the sub-scopes of the current scope are sorted."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Descending", "True if the sub-scopes should be sorted in descending order, otherwise false."));
       Parameters.Add(new ScopeParameter("CurrentScope", "The current scope whose sub-scopes are sorted."));
     }
@@ -58,5 +58,5 @@
     public override IOperation Apply() {
       descending = DescendingParameter.ActualValue.Value;
-      actualName = LookupParameter<ItemArray<DoubleData>>.TranslateName(ValueParameter.Name, ExecutionContext);
+      actualName = LookupParameter<ItemArray<DoubleValue>>.TranslateName(ValueParameter.Name, ExecutionContext);
       CurrentScope.SubScopes.Sort(SortScopes);
       return base.Apply();
@@ -75,5 +75,5 @@
         return -1;
       else {
-        int result = ((DoubleData)var1.Value).CompareTo((DoubleData)var2.Value);
+        int result = ((DoubleValue)var1.Value).CompareTo((DoubleValue)var2.Value);
         if (descending) result = result * -1;
         return result;
Index: trunk/sources/HeuristicLab.Optimization.Operators/3.3/ChildrenCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Optimization.Operators/3.3/ChildrenCreator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Optimization.Operators/3.3/ChildrenCreator.cs	(revision 3048)
@@ -43,11 +43,11 @@
       get { return (ScopeParameter)Parameters["CurrentScope"]; }
     }
-    public ValueLookupParameter<IntData> ParentsPerChildParameter {
-      get { return (ValueLookupParameter<IntData>)Parameters["ParentsPerChild"]; }
+    public ValueLookupParameter<IntValue> ParentsPerChildParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["ParentsPerChild"]; }
     }
     public IScope CurrentScope {
       get { return CurrentScopeParameter.ActualValue; }
     }
-    public IntData ParentsPerChild {
+    public IntValue ParentsPerChild {
       get { return ParentsPerChildParameter.Value; }
       set { ParentsPerChildParameter.Value = value; }
@@ -57,5 +57,5 @@
       : base() {
       Parameters.Add(new ScopeParameter("CurrentScope", "The current scope whose sub-scopes represent the parents."));
-      Parameters.Add(new ValueLookupParameter<IntData>("ParentsPerChild", "The number of parents that should be crossed per child. Note that some of the typical crossover operators require exactly two parents.", new IntData(2)));
+      Parameters.Add(new ValueLookupParameter<IntValue>("ParentsPerChild", "The number of parents that should be crossed per child. Note that some of the typical crossover operators require exactly two parents.", new IntValue(2)));
     }
 
Index: trunk/sources/HeuristicLab.Optimization.Operators/3.3/SolutionsCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Optimization.Operators/3.3/SolutionsCreator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Optimization.Operators/3.3/SolutionsCreator.cs	(revision 3048)
@@ -35,6 +35,6 @@
   [Creatable("Test")]
   public sealed class SolutionsCreator : SingleSuccessorOperator {
-    public ValueLookupParameter<IntData> NumberOfSolutionsParameter {
-      get { return (ValueLookupParameter<IntData>)Parameters["NumberOfSolutions"]; }
+    public ValueLookupParameter<IntValue> NumberOfSolutionsParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["NumberOfSolutions"]; }
     }
     public ValueLookupParameter<IOperator> SolutionCreatorParameter {
@@ -50,5 +50,5 @@
       get { return CurrentScopeParameter.ActualValue; }
     }
-    public IntData NumberOfSolutions {
+    public IntValue NumberOfSolutions {
       get { return NumberOfSolutionsParameter.Value; }
       set { NumberOfSolutionsParameter.Value = value; }
@@ -57,5 +57,5 @@
     public SolutionsCreator()
       : base() {
-      Parameters.Add(new ValueLookupParameter<IntData>("NumberOfSolutions", "The number of solutions that should be created."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("NumberOfSolutions", "The number of solutions that should be created."));
       Parameters.Add(new ValueLookupParameter<IOperator>("SolutionCreator", "The operator which is used to create new solutions."));
       Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator", "The operator which is used to evaluate new solutions."));
Index: trunk/sources/HeuristicLab.Optimization/3.3/Interfaces/IMoveMaker.cs
===================================================================
--- trunk/sources/HeuristicLab.Optimization/3.3/Interfaces/IMoveMaker.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Optimization/3.3/Interfaces/IMoveMaker.cs	(revision 3048)
@@ -25,6 +25,6 @@
 namespace HeuristicLab.Optimization {
   public interface IMoveMaker : IOperator {
-    ILookupParameter<DoubleData> QualityParameter { get; }
-    ILookupParameter<DoubleData> MoveQualityParameter { get; }
+    ILookupParameter<DoubleValue> QualityParameter { get; }
+    ILookupParameter<DoubleValue> MoveQualityParameter { get; }
   }
 }
Index: trunk/sources/HeuristicLab.Optimization/3.3/Interfaces/IMultiObjectiveEvaluator.cs
===================================================================
--- trunk/sources/HeuristicLab.Optimization/3.3/Interfaces/IMultiObjectiveEvaluator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Optimization/3.3/Interfaces/IMultiObjectiveEvaluator.cs	(revision 3048)
@@ -28,5 +28,5 @@
   /// </summary>
   public interface IMultiObjectiveEvaluator : IEvaluator {
-    ILookupParameter<DoubleArrayData> QualitiesParameter { get; }
+    ILookupParameter<DoubleArray> QualitiesParameter { get; }
   }
 }
Index: trunk/sources/HeuristicLab.Optimization/3.3/Interfaces/IMultiObjectiveSelector.cs
===================================================================
--- trunk/sources/HeuristicLab.Optimization/3.3/Interfaces/IMultiObjectiveSelector.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Optimization/3.3/Interfaces/IMultiObjectiveSelector.cs	(revision 3048)
@@ -28,5 +28,5 @@
   /// </summary>
   public interface IMultiObjectiveSelector : ISelector {
-    ILookupParameter<ItemArray<DoubleArrayData>> QualitiesParameter { get; }
+    ILookupParameter<ItemArray<DoubleArray>> QualitiesParameter { get; }
   }
 }
Index: trunk/sources/HeuristicLab.Optimization/3.3/Interfaces/ISelector.cs
===================================================================
--- trunk/sources/HeuristicLab.Optimization/3.3/Interfaces/ISelector.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Optimization/3.3/Interfaces/ISelector.cs	(revision 3048)
@@ -28,6 +28,6 @@
   /// </summary>
   public interface ISelector : IOperator {
-    BoolData CopySelected { get; set; }
-    IValueLookupParameter<IntData> NumberOfSelectedSubScopesParameter { get; }
+    BoolValue CopySelected { get; set; }
+    IValueLookupParameter<IntValue> NumberOfSelectedSubScopesParameter { get; }
   }
 }
Index: trunk/sources/HeuristicLab.Optimization/3.3/Interfaces/ISingleObjectiveEvaluator.cs
===================================================================
--- trunk/sources/HeuristicLab.Optimization/3.3/Interfaces/ISingleObjectiveEvaluator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Optimization/3.3/Interfaces/ISingleObjectiveEvaluator.cs	(revision 3048)
@@ -28,5 +28,5 @@
   /// </summary>
   public interface ISingleObjectiveEvaluator : IEvaluator {
-    ILookupParameter<DoubleData> QualityParameter { get; }
+    ILookupParameter<DoubleValue> QualityParameter { get; }
   }
 }
Index: trunk/sources/HeuristicLab.Optimization/3.3/Interfaces/ISingleObjectiveMoveEvaluator.cs
===================================================================
--- trunk/sources/HeuristicLab.Optimization/3.3/Interfaces/ISingleObjectiveMoveEvaluator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Optimization/3.3/Interfaces/ISingleObjectiveMoveEvaluator.cs	(revision 3048)
@@ -26,6 +26,6 @@
 namespace HeuristicLab.Optimization {
   public interface ISingleObjectiveMoveEvaluator : IOperator {
-    ILookupParameter<DoubleData> QualityParameter { get; }
-    ILookupParameter<DoubleData> MoveQualityParameter { get; }
+    ILookupParameter<DoubleValue> QualityParameter { get; }
+    ILookupParameter<DoubleValue> MoveQualityParameter { get; }
   }
 }
Index: trunk/sources/HeuristicLab.Optimization/3.3/Interfaces/ISingleObjectiveSelector.cs
===================================================================
--- trunk/sources/HeuristicLab.Optimization/3.3/Interfaces/ISingleObjectiveSelector.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Optimization/3.3/Interfaces/ISingleObjectiveSelector.cs	(revision 3048)
@@ -28,6 +28,6 @@
   /// </summary>
   public interface ISingleObjectiveSelector : ISelector {
-    IValueLookupParameter<BoolData> MaximizationParameter { get; }
-    ILookupParameter<ItemArray<DoubleData>> QualityParameter { get; }
+    IValueLookupParameter<BoolValue> MaximizationParameter { get; }
+    ILookupParameter<ItemArray<DoubleValue>> QualityParameter { get; }
   }
 }
Index: trunk/sources/HeuristicLab.Problems.TSP/3.3/Evaluators/TSPCoordinatesPathEvaluator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.TSP/3.3/Evaluators/TSPCoordinatesPathEvaluator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Problems.TSP/3.3/Evaluators/TSPCoordinatesPathEvaluator.cs	(revision 3048)
@@ -36,6 +36,6 @@
       get { return (ILookupParameter<Permutation>)Parameters["Permutation"]; }
     }
-    public ILookupParameter<DoubleMatrixData> CoordinatesParameter {
-      get { return (ILookupParameter<DoubleMatrixData>)Parameters["Coordinates"]; }
+    public ILookupParameter<DoubleMatrix> CoordinatesParameter {
+      get { return (ILookupParameter<DoubleMatrix>)Parameters["Coordinates"]; }
     }
 
@@ -43,10 +43,10 @@
       : base() {
       Parameters.Add(new LookupParameter<Permutation>("Permutation", "The TSP solution given in path representation which should be evaluated."));
-      Parameters.Add(new LookupParameter<DoubleMatrixData>("Coordinates", "The x- and y-Coordinates of the cities."));
+      Parameters.Add(new LookupParameter<DoubleMatrix>("Coordinates", "The x- and y-Coordinates of the cities."));
     }
 
     public sealed override IOperation Apply() {
       Permutation p = PermutationParameter.ActualValue;
-      DoubleMatrixData c = CoordinatesParameter.ActualValue;
+      DoubleMatrix c = CoordinatesParameter.ActualValue;
 
       double length = 0;
@@ -54,5 +54,5 @@
         length += CalculateDistance(c[p[i], 0], c[p[i], 1], c[p[i + 1], 0], c[p[i + 1], 1]);
       length += CalculateDistance(c[p[p.Length - 1], 0], c[p[p.Length - 1], 1], c[p[0], 0], c[p[0], 1]);
-      QualityParameter.ActualValue = new DoubleData(length);
+      QualityParameter.ActualValue = new DoubleValue(length);
 
       return base.Apply();
Index: trunk/sources/HeuristicLab.Problems.TSP/3.3/Evaluators/TSPDistanceMatrixPathEvaluator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.TSP/3.3/Evaluators/TSPDistanceMatrixPathEvaluator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Problems.TSP/3.3/Evaluators/TSPDistanceMatrixPathEvaluator.cs	(revision 3048)
@@ -37,6 +37,6 @@
       get { return (ILookupParameter<Permutation>)Parameters["Permutation"]; }
     }
-    public ILookupParameter<DoubleMatrixData> DistanceMatrixParameter {
-      get { return (ILookupParameter<DoubleMatrixData>)Parameters["DistanceMatrix"]; }
+    public ILookupParameter<DoubleMatrix> DistanceMatrixParameter {
+      get { return (ILookupParameter<DoubleMatrix>)Parameters["DistanceMatrix"]; }
     }
 
@@ -44,10 +44,10 @@
       : base() {
       Parameters.Add(new LookupParameter<Permutation>("Permutation", "The TSP solution given in path representation which should be evaluated."));
-      Parameters.Add(new LookupParameter<DoubleMatrixData>("DistanceMatrix", "The distance matrix of the cities."));
+      Parameters.Add(new LookupParameter<DoubleMatrix>("DistanceMatrix", "The distance matrix of the cities."));
     }
 
     public sealed override IOperation Apply() {
       Permutation p = PermutationParameter.ActualValue;
-      DoubleMatrixData d = DistanceMatrixParameter.ActualValue;
+      DoubleMatrix d = DistanceMatrixParameter.ActualValue;
 
       double length = 0;
@@ -55,5 +55,5 @@
         length += d[p[i], p[i + 1]];
       length += d[p[p.Length - 1], p[0]];
-      QualityParameter.ActualValue = new DoubleData(length);
+      QualityParameter.ActualValue = new DoubleValue(length);
 
       return base.Apply();
Index: trunk/sources/HeuristicLab.Problems.TSP/3.3/Evaluators/TSPEvaluator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.TSP/3.3/Evaluators/TSPEvaluator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Problems.TSP/3.3/Evaluators/TSPEvaluator.cs	(revision 3048)
@@ -33,11 +33,11 @@
   [StorableClass]
   public abstract class TSPEvaluator : SingleSuccessorOperator, ITSPEvaluator {
-    public ILookupParameter<DoubleData> QualityParameter {
-      get { return (ILookupParameter<DoubleData>)Parameters["Quality"]; }
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
     }
 
     protected TSPEvaluator()
       : base() {
-      Parameters.Add(new LookupParameter<DoubleData>("Quality", "The evaluated quality of the TSP solution."));
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The evaluated quality of the TSP solution."));
     }
   }
Index: trunk/sources/HeuristicLab.Problems.TSP/3.3/Interfaces/ITSPCoordinatesPathEvaluator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.TSP/3.3/Interfaces/ITSPCoordinatesPathEvaluator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Problems.TSP/3.3/Interfaces/ITSPCoordinatesPathEvaluator.cs	(revision 3048)
@@ -28,5 +28,5 @@
   /// </summary>
   public interface ITSPCoordinatesPathEvaluator : ITSPPathEvaluator {
-    ILookupParameter<DoubleMatrixData> CoordinatesParameter { get; }
+    ILookupParameter<DoubleMatrix> CoordinatesParameter { get; }
   }
 }
Index: trunk/sources/HeuristicLab.Problems.TSP/3.3/Interfaces/ITSPDistanceMatrixPathEvaluator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.TSP/3.3/Interfaces/ITSPDistanceMatrixPathEvaluator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Problems.TSP/3.3/Interfaces/ITSPDistanceMatrixPathEvaluator.cs	(revision 3048)
@@ -28,5 +28,5 @@
   /// </summary>
   public interface ITSPDistanceMatrixPathEvaluator : ITSPPathEvaluator {
-    ILookupParameter<DoubleMatrixData> DistanceMatrixParameter { get; }
+    ILookupParameter<DoubleMatrix> DistanceMatrixParameter { get; }
   }
 }
Index: trunk/sources/HeuristicLab.Problems.TSP/3.3/MoveEvaluators/TwoOptMoveTSPEvaluator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.TSP/3.3/MoveEvaluators/TwoOptMoveTSPEvaluator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Problems.TSP/3.3/MoveEvaluators/TwoOptMoveTSPEvaluator.cs	(revision 3048)
@@ -35,27 +35,27 @@
   [StorableClass]
   public class TwoOptMoveTSPEvaluator : SingleSuccessorOperator {
-    public ILookupParameter<DoubleData> QualityParameter {
-      get { return (ILookupParameter<DoubleData>)Parameters["Quality"]; }
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
     }
     public LookupParameter<TwoOptMove> MoveParameter {
       get { return (LookupParameter<TwoOptMove>)Parameters["Move"]; }
     }
-    public LookupParameter<DoubleData> MoveQualityParameter {
-      get { return (LookupParameter<DoubleData>)Parameters["MoveQuality"]; }
+    public LookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (LookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
     }
     public ILookupParameter<Permutation> PermutationParameter {
       get { return (ILookupParameter<Permutation>)Parameters["Permutation"]; }
     }
-    public ILookupParameter<DoubleMatrixData> CoordinatesParameter {
-      get { return (ILookupParameter<DoubleMatrixData>)Parameters["Coordinates"]; }
+    public ILookupParameter<DoubleMatrix> CoordinatesParameter {
+      get { return (ILookupParameter<DoubleMatrix>)Parameters["Coordinates"]; }
     }
 
     public TwoOptMoveTSPEvaluator()
       : base() {
-      Parameters.Add(new LookupParameter<DoubleData>("Quality", "The evaluated quality of the TSP solution."));
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The evaluated quality of the TSP solution."));
       Parameters.Add(new LookupParameter<TwoOptMove>("Move", "The move to evaluate."));
-      Parameters.Add(new LookupParameter<DoubleData>("MoveQuality", "Where to store the move quality."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "Where to store the move quality."));
       Parameters.Add(new LookupParameter<Permutation>("Permutation", "The solution as permutation."));
-      Parameters.Add(new LookupParameter<DoubleMatrixData>("Coordinates", "The city's coordinates."));
+      Parameters.Add(new LookupParameter<DoubleMatrix>("Coordinates", "The city's coordinates."));
     }
 
@@ -63,5 +63,5 @@
       TwoOptMove move = MoveParameter.ActualValue;
       Permutation permutation = PermutationParameter.ActualValue;
-      DoubleMatrixData coordinates = CoordinatesParameter.ActualValue;
+      DoubleMatrix coordinates = CoordinatesParameter.ActualValue;
       double moveQuality = QualityParameter.ActualValue.Value;
       int edge1source = permutation.GetCircular(move.Index1 - 1);
@@ -79,5 +79,5 @@
       moveQuality += CalculateDistance(coordinates[edge1target, 0], coordinates[edge1target, 1],
         coordinates[edge2target, 0], coordinates[edge2target, 1]);
-      if (MoveQualityParameter.ActualValue == null) MoveQualityParameter.ActualValue = new DoubleData(moveQuality);
+      if (MoveQualityParameter.ActualValue == null) MoveQualityParameter.ActualValue = new DoubleValue(moveQuality);
       else MoveQualityParameter.ActualValue.Value = moveQuality;
       return base.Apply();
Index: trunk/sources/HeuristicLab.Problems.TSP/3.3/TSP.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.TSP/3.3/TSP.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Problems.TSP/3.3/TSP.cs	(revision 3048)
@@ -43,12 +43,12 @@
 
     #region Parameter Properties
-    public ValueParameter<BoolData> MaximizationParameter {
-      get { return (ValueParameter<BoolData>)Parameters["Maximization"]; }
+    public ValueParameter<BoolValue> MaximizationParameter {
+      get { return (ValueParameter<BoolValue>)Parameters["Maximization"]; }
     }
     IParameter ISingleObjectiveProblem.MaximizationParameter {
       get { return MaximizationParameter; }
     }
-    public ValueParameter<DoubleMatrixData> CoordinatesParameter {
-      get { return (ValueParameter<DoubleMatrixData>)Parameters["Coordinates"]; }
+    public ValueParameter<DoubleMatrix> CoordinatesParameter {
+      get { return (ValueParameter<DoubleMatrix>)Parameters["Coordinates"]; }
     }
     public ValueParameter<IPermutationCreator> SolutionCreatorParameter {
@@ -64,11 +64,11 @@
       get { return EvaluatorParameter; }
     }
-    public OptionalValueParameter<DoubleData> BestKnownQualityParameter {
-      get { return (OptionalValueParameter<DoubleData>)Parameters["BestKnownQuality"]; }
+    public OptionalValueParameter<DoubleValue> BestKnownQualityParameter {
+      get { return (OptionalValueParameter<DoubleValue>)Parameters["BestKnownQuality"]; }
     }
     #endregion
 
     #region Properties
-    public DoubleMatrixData Coordinates {
+    public DoubleMatrix Coordinates {
       get { return CoordinatesParameter.Value; }
       set { CoordinatesParameter.Value = value; }
@@ -91,5 +91,5 @@
       get { return EvaluatorParameter.Value; }
     }
-    public DoubleData BestKnownQuality {
+    public DoubleValue BestKnownQuality {
       get { return BestKnownQualityParameter.Value; }
       set { BestKnownQualityParameter.Value = value; }
@@ -106,9 +106,9 @@
       TSPRoundedEuclideanPathEvaluator evaluator = new TSPRoundedEuclideanPathEvaluator();
 
-      Parameters.Add(new ValueParameter<BoolData>("Maximization", "Set to false as the Traveling Salesman Problem is a minimization problem.", new BoolData(false)));
-      Parameters.Add(new ValueParameter<DoubleMatrixData>("Coordinates", "The x- and y-Coordinates of the cities.", new DoubleMatrixData(0, 0)));
+      Parameters.Add(new ValueParameter<BoolValue>("Maximization", "Set to false as the Traveling Salesman Problem is a minimization problem.", new BoolValue(false)));
+      Parameters.Add(new ValueParameter<DoubleMatrix>("Coordinates", "The x- and y-Coordinates of the cities.", new DoubleMatrix(0, 0)));
       Parameters.Add(new ValueParameter<IPermutationCreator>("SolutionCreator", "The operator which should be used to create new TSP solutions.", creator));
       Parameters.Add(new ValueParameter<ITSPEvaluator>("Evaluator", "The operator which should be used to evaluate TSP solutions.", evaluator));
-      Parameters.Add(new OptionalValueParameter<DoubleData>("BestKnownQuality", "The quality of the best known solution of this TSP instance."));
+      Parameters.Add(new OptionalValueParameter<DoubleValue>("BestKnownQuality", "The quality of the best known solution of this TSP instance."));
 
       creator.PermutationParameter.ActualName = "TSPTour";
@@ -131,5 +131,5 @@
       TSPLIBParser parser = new TSPLIBParser(filename);
       parser.Parse();
-      Coordinates = new DoubleMatrixData(parser.Vertices);
+      Coordinates = new DoubleMatrix(parser.Vertices);
     }
 
@@ -190,5 +190,5 @@
     }
     private void ParameterizeSolutionCreator() {
-      SolutionCreator.LengthParameter.Value = new IntData(Coordinates.Rows);
+      SolutionCreator.LengthParameter.Value = new IntValue(Coordinates.Rows);
     }
     private void ParameterizeEvaluator() {
Index: trunk/sources/HeuristicLab.Random/3.3/RandomCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Random/3.3/RandomCreator.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Random/3.3/RandomCreator.cs	(revision 3048)
@@ -34,18 +34,18 @@
   [Creatable("Test")]
   public sealed class RandomCreator : SingleSuccessorOperator {
-    public ValueLookupParameter<BoolData> SetSeedRandomlyParameter {
-      get { return (ValueLookupParameter<BoolData>)Parameters["SetSeedRandomly"]; }
+    public ValueLookupParameter<BoolValue> SetSeedRandomlyParameter {
+      get { return (ValueLookupParameter<BoolValue>)Parameters["SetSeedRandomly"]; }
     }
-    public ValueLookupParameter<IntData> SeedParameter {
-      get { return (ValueLookupParameter<IntData>)Parameters["Seed"]; }
+    public ValueLookupParameter<IntValue> SeedParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["Seed"]; }
     }
     public LookupParameter<IRandom> RandomParameter {
       get { return (LookupParameter<IRandom>)Parameters["Random"]; }
     }
-    public BoolData SetSeedRandomly {
+    public BoolValue SetSeedRandomly {
       get { return SetSeedRandomlyParameter.Value; }
       set { SetSeedRandomlyParameter.Value = value; }
     }
-    public IntData Seed {
+    public IntValue Seed {
       get { return SeedParameter.Value; }
       set { SeedParameter.Value = value; }
@@ -54,14 +54,14 @@
     public RandomCreator()
       : base() {
-      Parameters.Add(new ValueLookupParameter<BoolData>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolData(true)));
-      Parameters.Add(new ValueLookupParameter<IntData>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntData(0)));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
+      Parameters.Add(new ValueLookupParameter<IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
       Parameters.Add(new LookupParameter<IRandom>("Random", "The new pseudo random number generator which is initialized with the given seed."));
     }
 
     public override IOperation Apply() {
-      if (SetSeedRandomlyParameter.ActualValue == null) SetSeedRandomlyParameter.ActualValue = new BoolData(true);
+      if (SetSeedRandomlyParameter.ActualValue == null) SetSeedRandomlyParameter.ActualValue = new BoolValue(true);
       bool setSeedRandomly = SetSeedRandomlyParameter.ActualValue.Value;
-      if (SeedParameter.ActualValue == null) SeedParameter.ActualValue = new IntData(0);
-      IntData seed = SeedParameter.ActualValue;
+      if (SeedParameter.ActualValue == null) SeedParameter.ActualValue = new IntValue(0);
+      IntValue seed = SeedParameter.ActualValue;
 
       if (setSeedRandomly) seed.Value = new System.Random().Next();
Index: trunk/sources/HeuristicLab.Selection/3.3/LinearRankSelector.cs
===================================================================
--- trunk/sources/HeuristicLab.Selection/3.3/LinearRankSelector.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Selection/3.3/LinearRankSelector.cs	(revision 3048)
@@ -44,5 +44,5 @@
       IRandom random = RandomParameter.ActualValue;
       bool maximization = MaximizationParameter.ActualValue.Value;
-      ItemArray<DoubleData> qualities = QualityParameter.ActualValue;
+      ItemArray<DoubleValue> qualities = QualityParameter.ActualValue;
       IScope[] selected = new IScope[count];
 
Index: trunk/sources/HeuristicLab.Selection/3.3/ProportionalSelector.cs
===================================================================
--- trunk/sources/HeuristicLab.Selection/3.3/ProportionalSelector.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Selection/3.3/ProportionalSelector.cs	(revision 3048)
@@ -36,9 +36,9 @@
   [Creatable("Test")]
   public sealed class ProportionalSelector : StochasticSingleObjectiveSelector {
-    private ValueParameter<BoolData> WindowingParameter {
-      get { return (ValueParameter<BoolData>)Parameters["Windowing"]; }
+    private ValueParameter<BoolValue> WindowingParameter {
+      get { return (ValueParameter<BoolValue>)Parameters["Windowing"]; }
     }
 
-    public BoolData Windowing {
+    public BoolValue Windowing {
       get { return WindowingParameter.Value; }
       set { WindowingParameter.Value = value; }
@@ -47,5 +47,5 @@
     public ProportionalSelector()
       : base() {
-      Parameters.Add(new ValueParameter<BoolData>("Windowing", "Apply windowing strategy (selection probability is proportional to the quality differences and not to the total quality).", new BoolData(true)));
+      Parameters.Add(new ValueParameter<BoolValue>("Windowing", "Apply windowing strategy (selection probability is proportional to the quality differences and not to the total quality).", new BoolValue(true)));
       CopySelected.Value = true;
     }
Index: trunk/sources/HeuristicLab.Selection/3.3/Selector.cs
===================================================================
--- trunk/sources/HeuristicLab.Selection/3.3/Selector.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Selection/3.3/Selector.cs	(revision 3048)
@@ -39,9 +39,9 @@
     }
 
-    protected ValueParameter<BoolData> CopySelectedParameter {
-      get { return (ValueParameter<BoolData>)Parameters["CopySelected"]; }
+    protected ValueParameter<BoolValue> CopySelectedParameter {
+      get { return (ValueParameter<BoolValue>)Parameters["CopySelected"]; }
     }
-    public IValueLookupParameter<IntData> NumberOfSelectedSubScopesParameter {
-      get { return (ValueLookupParameter<IntData>)Parameters["NumberOfSelectedSubScopes"]; }
+    public IValueLookupParameter<IntValue> NumberOfSelectedSubScopesParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["NumberOfSelectedSubScopes"]; }
     }
     protected ScopeParameter CurrentScopeParameter {
@@ -49,5 +49,5 @@
     }
 
-    public BoolData CopySelected {
+    public BoolValue CopySelected {
       get { return CopySelectedParameter.Value; }
       set { CopySelectedParameter.Value = value; }
@@ -59,6 +59,6 @@
     protected Selector()
       : base() {
-      Parameters.Add(new ValueParameter<BoolData>("CopySelected", "True if the selected sub-scopes should be copied, otherwise false.", new BoolData(false)));
-      Parameters.Add(new ValueLookupParameter<IntData>("NumberOfSelectedSubScopes", "The number of sub-scopes which should be selected."));
+      Parameters.Add(new ValueParameter<BoolValue>("CopySelected", "True if the selected sub-scopes should be copied, otherwise false.", new BoolValue(false)));
+      Parameters.Add(new ValueLookupParameter<IntValue>("NumberOfSelectedSubScopes", "The number of sub-scopes which should be selected."));
       Parameters.Add(new ScopeParameter("CurrentScope", "The current scope from which sub-scopes should be selected."));
     }
Index: trunk/sources/HeuristicLab.Selection/3.3/StochasticSingleObjectiveSelector.cs
===================================================================
--- trunk/sources/HeuristicLab.Selection/3.3/StochasticSingleObjectiveSelector.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Selection/3.3/StochasticSingleObjectiveSelector.cs	(revision 3048)
@@ -33,15 +33,15 @@
   [StorableClass]
   public abstract class StochasticSingleObjectiveSelector : StochasticSelector, ISingleObjectiveSelector {
-    public IValueLookupParameter<BoolData> MaximizationParameter {
-      get { return (IValueLookupParameter<BoolData>)Parameters["Maximization"]; }
+    public IValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
     }
-    public ILookupParameter<ItemArray<DoubleData>> QualityParameter {
-      get { return (ILookupParameter<ItemArray<DoubleData>>)Parameters["Quality"]; }
+    public ILookupParameter<ItemArray<DoubleValue>> QualityParameter {
+      get { return (ILookupParameter<ItemArray<DoubleValue>>)Parameters["Quality"]; }
     }
 
     protected StochasticSingleObjectiveSelector()
       : base() {
-      Parameters.Add(new ValueLookupParameter<BoolData>("Maximization", "True if the current problem is a maximization problem, otherwise false."));
-      Parameters.Add(new SubScopesLookupParameter<DoubleData>("Quality", "The quality value contained in each sub-scope which is used for selection."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the current problem is a maximization problem, otherwise false."));
+      Parameters.Add(new SubScopesLookupParameter<DoubleValue>("Quality", "The quality value contained in each sub-scope which is used for selection."));
     }
   }
Index: trunk/sources/HeuristicLab.Selection/3.3/TournamentSelector.cs
===================================================================
--- trunk/sources/HeuristicLab.Selection/3.3/TournamentSelector.cs	(revision 3047)
+++ trunk/sources/HeuristicLab.Selection/3.3/TournamentSelector.cs	(revision 3048)
@@ -35,10 +35,10 @@
   [Creatable("Test")]
   public sealed class TournamentSelector : StochasticSingleObjectiveSelector {
-    public ValueLookupParameter<IntData> GroupSizeParameter {
-      get { return (ValueLookupParameter<IntData>)Parameters["GroupSize"]; }
+    public ValueLookupParameter<IntValue> GroupSizeParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["GroupSize"]; }
     }
 
     public TournamentSelector() : base() {
-      Parameters.Add(new ValueLookupParameter<IntData>("GroupSize", "The size of the tournament group.", new IntData(2)));
+      Parameters.Add(new ValueLookupParameter<IntValue>("GroupSize", "The size of the tournament group.", new IntValue(2)));
       CopySelected.Value = true;
     }
