Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/Crossovers/ParameterConfigurationCrossover.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/Crossovers/ParameterConfigurationCrossover.cs	(revision 5267)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/Crossovers/ParameterConfigurationCrossover.cs	(revision 5277)
@@ -58,5 +58,5 @@
       ParameterConfigurationTree child2 = (ParameterConfigurationTree)ParentsParameter.ActualValue[1];
 
-      child1.Cross(RandomParameter.ActualValue, child2, Cross, this);
+      child1.Cross(RandomParameter.ActualValue, child2, Cross, IntValueCrossoverParameter.ActualValue, DoubleValueCrossoverParameter.ActualValue);
       this.ChildParameter.ActualValue = child1;
 
@@ -64,19 +64,27 @@
     }
 
-    private static void Cross(IRandom random, IOptimizable configuartion, ParameterConfigurationCrossover pccross) {
-      if (configuartion is IValueConfiguration) {
-        var vc = configuartion as IValueConfiguration;
+    public static void Apply(IRandom random, IOptimizable configuartion, IOptimizable other, IIntValueCrossover intValueCrossover, IDoubleValueCrossover doubleValueCrossover) {
+      configuartion.Cross(random, other, Cross, intValueCrossover, doubleValueCrossover);
+    }
+
+    private static void Cross(IRandom random, IOptimizable configuartion, IOptimizable other, IIntValueCrossover intValueCrossover, IDoubleValueCrossover doubleValueCrossover) {
+      var vc = configuartion as IValueConfiguration;
+      var pc = configuartion as IParameterConfiguration;
+      if (vc != null) {
         var value = vc.ActualValue.Value;
         var range = vc.RangeConstraint;
 
         if (value is IntValue) {
-          pccross.IntValueCrossoverParameter.ActualValue.Apply(random, (IntValue)value, (IntValueRange)range);
+          intValueCrossover.Apply(random, (IntValue)value, (IntValue)((IValueConfiguration)other).ActualValue.Value, (IntValueRange)range);
         } else if (value is PercentValue) {
-          pccross.DoubleValueCrossoverParameter.ActualValue.Apply(random, (PercentValue)value, ((PercentValueRange)range).AsDoubleValueRange());
+          doubleValueCrossover.Apply(random, (PercentValue)value, (DoubleValue)((IValueConfiguration)other).ActualValue.Value, ((PercentValueRange)range).AsDoubleValueRange());
         } else if (value is DoubleValue) {
-          pccross.DoubleValueCrossoverParameter.ActualValue.Apply(random, (DoubleValue)value, (DoubleValueRange)range);
+          doubleValueCrossover.Apply(random, (DoubleValue)value, (DoubleValue)((IValueConfiguration)other).ActualValue.Value, (DoubleValueRange)range);
         }
-      } else if (configuartion is IParameterConfiguration) {
-
+      } else if (pc != null) {
+        if (random.NextDouble() > 0.5) {
+          pc.ActualValueConfigurationIndex = ((ParameterConfiguration)other).ActualValueConfigurationIndex;
+        }
+        pc.ActualValue = pc.ValueConfigurations[pc.ActualValueConfigurationIndex].ActualValue;
       }
     }
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/Manipulators/ParameterConfigurationManipulator.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/Manipulators/ParameterConfigurationManipulator.cs	(revision 5267)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/Manipulators/ParameterConfigurationManipulator.cs	(revision 5277)
@@ -49,28 +49,31 @@
 
     public sealed override IOperation Apply() {
-      Apply(RandomParameter.ActualValue, ParameterConfigurationTreeParameter.ActualValue, this);
+      Apply(RandomParameter.ActualValue, ParameterConfigurationTreeParameter.ActualValue, IntValueManipulatorParameter.ActualValue, DoubleValueManipulatorParameter.ActualValue);
       return base.Apply();
     }
 
-    public static void Apply(IRandom random, IValueConfiguration configuration, ParameterConfigurationManipulator pcmanip) {
-      configuration.Mutate(random, Mutate, pcmanip);
+    public static void Apply(IRandom random, IValueConfiguration configuration, IIntValueManipulator intValueManipulator, IDoubleValueManipulator doubleValueManipulator) {
+      configuration.Mutate(random, Mutate, intValueManipulator, doubleValueManipulator);
     }
 
-    private static void Mutate(IRandom random, IOptimizable configuration, ParameterConfigurationManipulator pcmanip) {
-      if (configuration is IValueConfiguration) {
-        var vc = configuration as IValueConfiguration;
+    private static void Mutate(IRandom random, IOptimizable configuration, IIntValueManipulator intValueManipulator, IDoubleValueManipulator doubleValueManipulator) {
+      var vc = configuration as IValueConfiguration;
+      var pc = configuration as IParameterConfiguration;
+
+      if (vc != null) {
         var value = vc.ActualValue.Value;
         var range = vc.RangeConstraint;
         if (value is IntValue) {
-          pcmanip.IntValueManipulatorParameter.ActualValue.Apply(random, (IntValue)value, (IntValueRange)range);
+          intValueManipulator.Apply(random, (IntValue)value, (IntValueRange)range);
         } else if (value is PercentValue) {
-          pcmanip.DoubleValueManipulatorParameter.ActualValue.Apply(random, (PercentValue)value, ((PercentValueRange)range).AsDoubleValueRange());
+          doubleValueManipulator.Apply(random, (PercentValue)value, ((PercentValueRange)range).AsDoubleValueRange());
         } else if (value is DoubleValue) {
-          pcmanip.DoubleValueManipulatorParameter.ActualValue.Apply(random, (DoubleValue)value, (DoubleValueRange)range);
+          doubleValueManipulator.Apply(random, (DoubleValue)value, (DoubleValueRange)range);
         }
-      } else if (configuration is IParameterConfiguration) {
-        var pc = configuration as IParameterConfiguration;
-        pc.ActualValueConfigurationIndex = random.Next(pc.ValueConfigurations.CheckedItems.Count());
-        pc.ActualValue = pc.ValueConfigurations.CheckedItems.ElementAt(pc.ActualValueConfigurationIndex).ActualValue;
+      } else if (pc != null) {
+        do {
+          pc.ActualValueConfigurationIndex = random.Next(pc.ValueConfigurations.Count());
+        } while (!pc.ValueConfigurations.ItemChecked(pc.ValueConfigurations[pc.ActualValueConfigurationIndex]));
+        pc.ActualValue = pc.ValueConfigurations[pc.ActualValueConfigurationIndex].ActualValue;
       }
     }
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/ParameterCombinationsEnumerator.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/ParameterCombinationsEnumerator.cs	(revision 5267)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/ParameterCombinationsEnumerator.cs	(revision 5277)
@@ -82,10 +82,10 @@
 
         foreach (var valueConfiguration in pc.ValueConfigurations.CheckedItems) {
-          if (valueConfiguration.Optimize) {
-            var enumerator = new ParameterCombinationsEnumerator(valueConfiguration);
+          if (valueConfiguration.Value.Optimize) {
+            var enumerator = new ParameterCombinationsEnumerator(valueConfiguration.Value);
             enumerator.Reset();
             valueEnumerator.AddEnumerator(enumerator);
           } else {
-            valueEnumerator.AddEnumerator(new List<IItem> { valueConfiguration }.GetEnumerator());
+            valueEnumerator.AddEnumerator(new List<IItem> { valueConfiguration.Value }.GetEnumerator());
           }
         }
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/ParameterConfigurations/ParameterConfiguration.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/ParameterConfigurations/ParameterConfiguration.cs	(revision 5267)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/ParameterConfigurations/ParameterConfiguration.cs	(revision 5277)
@@ -12,4 +12,5 @@
 using System.Reflection;
 using HeuristicLab.Optimization;
+using HeuristicLab.Collections;
 
 namespace HeuristicLab.Problems.MetaOptimization {
@@ -78,6 +79,6 @@
 
     [Storable]
-    protected ICheckedValueConfigurationCollection valueConfigurations;
-    public ICheckedValueConfigurationCollection ValueConfigurations {
+    protected ICheckedValueConfigurationList valueConfigurations;
+    public ICheckedValueConfigurationList ValueConfigurations {
       get { return this.valueConfigurations; }
       protected set {
@@ -135,5 +136,5 @@
         validTypes = new List<Type>(validTypes) { typeof(NullValue) }.ToArray();
       }
-      this.ValueConfigurations = new CheckedValueConfigurationCollection();
+      this.ValueConfigurations = new CheckedValueConfigurationList();
       this.ActualValue = new ConstrainedValue(
         valueParameter.Value != null ? (IItem)valueParameter.Value.Clone() : null, 
@@ -173,13 +174,13 @@
 
     private void RegisterValueConfigurationEvents() {
-      this.ValueConfigurations.CheckedItemsChanged += new Collections.CollectionItemsChangedEventHandler<IValueConfiguration>(ValueConfigurations_CheckedItemsChanged);
-      this.ValueConfigurations.ItemsAdded += new Collections.CollectionItemsChangedEventHandler<IValueConfiguration>(ValueConfigurations_ItemsAdded);
-      this.ValueConfigurations.ItemsRemoved += new Collections.CollectionItemsChangedEventHandler<IValueConfiguration>(ValueConfigurations_ItemsRemoved);
+      this.ValueConfigurations.CheckedItemsChanged += new CollectionItemsChangedEventHandler<IndexedItem<IValueConfiguration>>(ValueConfigurations_CheckedItemsChanged);
+      this.ValueConfigurations.ItemsAdded += new CollectionItemsChangedEventHandler<IndexedItem<IValueConfiguration>>(ValueConfigurations_ItemsAdded);
+      this.ValueConfigurations.ItemsRemoved += new CollectionItemsChangedEventHandler<IndexedItem<IValueConfiguration>>(ValueConfigurations_ItemsRemoved);
     }
 
     private void DeregisterValueConfigurationEvents() {
-      this.ValueConfigurations.CheckedItemsChanged -= new Collections.CollectionItemsChangedEventHandler<IValueConfiguration>(ValueConfigurations_CheckedItemsChanged);
-      this.ValueConfigurations.ItemsAdded -= new Collections.CollectionItemsChangedEventHandler<IValueConfiguration>(ValueConfigurations_ItemsAdded);
-      this.ValueConfigurations.ItemsRemoved -= new Collections.CollectionItemsChangedEventHandler<IValueConfiguration>(ValueConfigurations_ItemsRemoved);
+      this.ValueConfigurations.CheckedItemsChanged -= new CollectionItemsChangedEventHandler<IndexedItem<IValueConfiguration>>(ValueConfigurations_CheckedItemsChanged);
+      this.ValueConfigurations.ItemsAdded -= new CollectionItemsChangedEventHandler<IndexedItem<IValueConfiguration>>(ValueConfigurations_ItemsAdded);
+      this.ValueConfigurations.ItemsRemoved -= new CollectionItemsChangedEventHandler<IndexedItem<IValueConfiguration>>(ValueConfigurations_ItemsRemoved);
     }
 
@@ -268,11 +269,11 @@
     }
 
-    void ValueConfigurations_CheckedItemsChanged(object sender, Collections.CollectionItemsChangedEventArgs<IValueConfiguration> e) {
+    void ValueConfigurations_CheckedItemsChanged(object sender, Collections.CollectionItemsChangedEventArgs<IndexedItem<IValueConfiguration>> e) {
       OnToStringChanged();
     }
-    void ValueConfigurations_ItemsRemoved(object sender, Collections.CollectionItemsChangedEventArgs<IValueConfiguration> e) {
+    void ValueConfigurations_ItemsRemoved(object sender, Collections.CollectionItemsChangedEventArgs<IndexedItem<IValueConfiguration>> e) {
       OnToStringChanged();
     }
-    void ValueConfigurations_ItemsAdded(object sender, Collections.CollectionItemsChangedEventArgs<IValueConfiguration> e) {
+    void ValueConfigurations_ItemsAdded(object sender, Collections.CollectionItemsChangedEventArgs<IndexedItem<IValueConfiguration>> e) {
       OnToStringChanged();
     }
@@ -360,5 +361,5 @@
 
           if (this.ActualValue.Value is IParameterizedItem) {
-            string subParams = this.ValueConfigurations.CheckedItems.ElementAt(actualValueConfigurationIndex).ParameterInfoString;
+            string subParams = this.ValueConfigurations[actualValueConfigurationIndex].ParameterInfoString;
             if (!string.IsNullOrEmpty(subParams)) {
               sb.Append(" (");
@@ -383,5 +384,5 @@
       if (Optimize) {
         if (this.ActualValue.Value is IParameterizedItem) {
-          this.ValueConfigurations.CheckedItems.ElementAt(actualValueConfigurationIndex).Parameterize((IParameterizedItem)this.ActualValue.Value);
+          this.ValueConfigurations[actualValueConfigurationIndex].Parameterize((IParameterizedItem)this.ActualValue.Value);
         }
       }
@@ -410,38 +411,42 @@
     public void Randomize(IRandom random) {
       if (Optimize) {
-        foreach (var vc in this.ValueConfigurations.CheckedItems) {
-          vc.Randomize(random);
-        }
-        actualValueConfigurationIndex = random.Next(ValueConfigurations.CheckedItems.Count());
-        this.ActualValue = this.ValueConfigurations.CheckedItems.ElementAt(actualValueConfigurationIndex).ActualValue;
-      }
-    }
-
-    public void Mutate(IRandom random, MutateDelegate mutate, ParameterConfigurationManipulator pcmanip) {
-      if (Optimize) {
-        foreach (IValueConfiguration vc in this.ValueConfigurations.CheckedItems) {
-          vc.Mutate(random, mutate, pcmanip);
-        }
-        mutate(random, this, pcmanip);
-      }
-    }
-
-    public void Cross(IRandom random, IOptimizable other, CrossDelegate cross, ParameterConfigurationCrossover pccross) {
+        foreach (var vc in this.ValueConfigurations) {
+          if (this.ValueConfigurations.ItemChecked(vc)) {
+            vc.Randomize(random);
+          }
+        }
+        do {
+          actualValueConfigurationIndex = random.Next(ValueConfigurations.Count());
+        } while (!this.ValueConfigurations.ItemChecked(this.ValueConfigurations[actualValueConfigurationIndex]));
+        this.ActualValue = this.ValueConfigurations[actualValueConfigurationIndex].ActualValue;
+      }
+    }
+
+    public void Mutate(IRandom random, MutateDelegate mutate, IIntValueManipulator intValueManipulator, IDoubleValueManipulator doubleValueManipulator) {
+      if (Optimize) {
+        foreach (var vc in this.ValueConfigurations) {
+          if (this.ValueConfigurations.ItemChecked(vc)) {
+            vc.Mutate(random, mutate, intValueManipulator, doubleValueManipulator);
+          }
+        }
+        mutate(random, this, intValueManipulator, doubleValueManipulator);
+      }
+    }
+
+    public void Cross(IRandom random, IOptimizable other, CrossDelegate cross, IIntValueCrossover intValueCrossover, IDoubleValueCrossover doubleValueCrossover) {
       if (Optimize) {
         IParameterConfiguration otherPc = (IParameterConfiguration)other;
         for (int i = 0; i < this.ValueConfigurations.Count; i++) {
-          cross(random, other, pccross);
-          //this.ValueConfigurations.ElementAt(i).Cross(otherPc.ValueConfigurations.ElementAt(i), random);
-        }
-        //if (random.NextDouble() > 0.5) {
-        //  actualValueConfigurationIndex = ((ParameterConfiguration)other).actualValueConfigurationIndex;
-        //}
-        //this.ActualValue = this.ValueConfigurations.CheckedItems.ElementAt(actualValueConfigurationIndex).ActualValue;
+          if (this.ValueConfigurations.ItemChecked(this.ValueConfigurations[i])) {
+            this.ValueConfigurations[i].Cross(random, otherPc.ValueConfigurations[i], cross, intValueCrossover, doubleValueCrossover);
+          }
+        }
+        cross(random, this, other, intValueCrossover, doubleValueCrossover);
       }
     }
 
     public void UpdateActualValueIndexToItem(IValueConfiguration vc) {
-      for (int i = 0; i < this.ValueConfigurations.CheckedItems.Count(); i++) {
-        if (this.ValueConfigurations.CheckedItems.ElementAt(i) == vc) {
+      for (int i = 0; i < this.ValueConfigurations.Count(); i++) {
+        if (this.ValueConfigurations.ElementAt(i) == vc) {
           this.actualValueConfigurationIndex = i;
           return;
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/ValueConfigurations/CheckedValueConfigurationCollection.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/ValueConfigurations/CheckedValueConfigurationCollection.cs	(revision 5267)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/ValueConfigurations/CheckedValueConfigurationCollection.cs	(revision 5277)
@@ -6,4 +6,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Collections;
 
 namespace HeuristicLab.Problems.MetaOptimization {
@@ -11,5 +12,5 @@
   // todo: control creatable item types
   [StorableClass]
-  public class CheckedValueConfigurationCollection : CheckedItemCollection<IValueConfiguration>, ICheckedValueConfigurationCollection {
+  public class CheckedValueConfigurationList : CheckedItemList<IValueConfiguration>, ICheckedValueConfigurationList {
     [Storable]
     private int minItemCount = 1;
@@ -24,16 +25,16 @@
     }
 
-    public CheckedValueConfigurationCollection(ItemSet<IItem> validValues) {
+    public CheckedValueConfigurationList(ItemSet<IItem> validValues) {
       this.validValues = validValues;
       RegisterEvents();
     }
-    public CheckedValueConfigurationCollection() {
+    public CheckedValueConfigurationList() {
       RegisterEvents();
     }
     [StorableConstructor]
-    protected CheckedValueConfigurationCollection(bool deserializing) : base(deserializing) {
+    protected CheckedValueConfigurationList(bool deserializing) : base(deserializing) {
       RegisterEvents();
     }
-    protected CheckedValueConfigurationCollection(CheckedValueConfigurationCollection original, Cloner cloner) : base(original, cloner) {
+    protected CheckedValueConfigurationList(CheckedValueConfigurationList original, Cloner cloner) : base(original, cloner) {
       this.minItemCount = original.MinItemCount;
       this.validValues = original.validValues;
@@ -41,5 +42,5 @@
     }
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new CheckedValueConfigurationCollection(this, cloner);
+      return new CheckedValueConfigurationList(this, cloner);
     }
     [StorableHook(HookType.AfterDeserialization)]
@@ -49,11 +50,12 @@
 
     private void RegisterEvents() {
-      this.ItemsRemoved += new Collections.CollectionItemsChangedEventHandler<IValueConfiguration>(CheckedValueConfigurationCollection_ItemsRemoved);
-    }
-    private void DeregisterEvents() {
-      this.ItemsRemoved -= new Collections.CollectionItemsChangedEventHandler<IValueConfiguration>(CheckedValueConfigurationCollection_ItemsRemoved);
+      this.ItemsRemoved += new CollectionItemsChangedEventHandler<IndexedItem<IValueConfiguration>>(CheckedValueConfigurationList_ItemsRemoved);
     }
 
-    private void CheckedValueConfigurationCollection_ItemsRemoved(object sender, Collections.CollectionItemsChangedEventArgs<IValueConfiguration> e) {
+    private void DeregisterEvents() {
+      this.ItemsRemoved -= new CollectionItemsChangedEventHandler<IndexedItem<IValueConfiguration>>(CheckedValueConfigurationList_ItemsRemoved);
+    }
+
+    private void CheckedValueConfigurationList_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<IndexedItem<IValueConfiguration>> e) {
       // auch collectionreset gehört berücksichtigt
       // funktioniert so nicht ganz, weil die view das hinzufügen nicht mitkriegt
@@ -66,4 +68,5 @@
       //}
     }
+
   }
 }
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/ValueConfigurations/ValueConfiguration.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/ValueConfigurations/ValueConfiguration.cs	(revision 5267)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/ValueConfigurations/ValueConfiguration.cs	(revision 5277)
@@ -245,68 +245,24 @@
     }
 
-    public void Mutate(IRandom random, MutateDelegate mutate, ParameterConfigurationManipulator pcmanip) {
+    public void Mutate(IRandom random, MutateDelegate mutate, IIntValueManipulator intValueManipulator, IDoubleValueManipulator doubleValueManipulator) {
       if (Optimize) {
         if (rangeConstraint != null) {
-          mutate(random, this, pcmanip);
+          mutate(random, this, intValueManipulator, doubleValueManipulator);
         } else {
           foreach (IParameterConfiguration pc in this.ParameterConfigurations) {
-            pc.Mutate(random, mutate, pcmanip);
-          }
-        }
-      }
-    }
-
-    public void Cross(IRandom random, IOptimizable other, CrossDelegate cross, ParameterConfigurationCrossover pccross) {
+            pc.Mutate(random, mutate, intValueManipulator, doubleValueManipulator);
+          }
+        }
+      }
+    }
+
+    public void Cross(IRandom random, IOptimizable other, CrossDelegate cross, IIntValueCrossover intValueCrossover, IDoubleValueCrossover doubleValueCrossover) {
       if (Optimize) {
-        IValueConfiguration otherVc = (IValueConfiguration)other;
         if (rangeConstraint != null) {
-          cross(random, this, pccross);
-
-          //if (this.actualValue.ValueDataType == typeof(IntValue)) {
-          //  //this.actualValue.Value = new IntValue((((IntValue)this.actualValue.Value).Value + ((IntValue)other.ActualValue.Value).Value) / 2);
-
-          //  IntegerVector[] parents = new IntegerVector[2];
-          //  parents[0] = new IntegerVector(new int[] { ((IntValue)this.actualValue.Value).Value });
-          //  parents[1] = new IntegerVector(new int[] { ((IntValue)other.ActualValue.Value).Value });
-
-          //  this.actualValue.Value = new IntValue(HeuristicLab.Encodings.IntegerVectorEncoding.DiscreteCrossover.Apply(random, parents[0], parents[1]).First());
-
-          //} else if (this.actualValue.ValueDataType == typeof(DoubleValue)) {
-          //  //this.actualValue.Value = new DoubleValue((((DoubleValue)this.actualValue.Value).Value + ((DoubleValue)other.ActualValue.Value).Value) / 2);
-          //  RealVector[] parents = new RealVector[2];
-          //  parents[0] = new RealVector(new double[] { ((DoubleValue)this.actualValue.Value).Value });
-          //  parents[1] = new RealVector(new double[] { ((DoubleValue)other.ActualValue.Value).Value });
-
-          //  if (random.NextDouble() < 0.5) {
-          //    this.actualValue.Value = new DoubleValue(AverageCrossover.Apply(random, new ItemArray<RealVector>(parents)).First());
-          //  } else {
-          //    this.actualValue.Value = new DoubleValue(HeuristicLab.Encodings.RealVectorEncoding.DiscreteCrossover.Apply(random, new ItemArray<RealVector>(parents)).First());
-          //  }
-          //  //this.actualValue.Value = new DoubleValue(AverageCrossover.Apply(random, new ItemArray<RealVector>(parents)).First());
-
-          //} else if (this.actualValue.ValueDataType == typeof(PercentValue)) {
-          //  //this.actualValue.Value = new PercentValue((((PercentValue)this.actualValue.Value).Value + ((PercentValue)other.ActualValue.Value).Value) / 2);
-
-          //  RealVector[] parents = new RealVector[2];
-          //  parents[0] = new RealVector(new double[] { ((PercentValue)this.actualValue.Value).Value });
-          //  parents[1] = new RealVector(new double[] { ((PercentValue)other.ActualValue.Value).Value });
-
-          //  if (random.NextDouble() < 0.5) {
-          //    this.actualValue.Value = new PercentValue(AverageCrossover.Apply(random, new ItemArray<RealVector>(parents)).First());
-          //  } else {
-          //    this.actualValue.Value = new PercentValue(HeuristicLab.Encodings.RealVectorEncoding.DiscreteCrossover.Apply(random, new ItemArray<RealVector>(parents)).First());
-          //  }
-
-          //} else if (this.actualValue.ValueDataType == typeof(BoolValue)) {
-          //  if (random.NextDouble() > 0.5)
-          //    this.actualValue.Value = this.actualValue.Value;
-          //  else
-          //    this.actualValue.Value = other.ActualValue.Value;
-          //} else {
-          //  throw new NotImplementedException();
-          //}
-        } else {
+          cross(random, this, other, intValueCrossover, doubleValueCrossover);
+        } else {
+          IValueConfiguration otherVc = (IValueConfiguration)other;
           for (int i = 0; i < this.ParameterConfigurations.Count; i++) {
-            this.ParameterConfigurations.ElementAt(i).Cross(random, otherVc.ParameterConfigurations.ElementAt(i), cross, pccross);
+            this.ParameterConfigurations.ElementAt(i).Cross(random, otherVc.ParameterConfigurations.ElementAt(i), cross, intValueCrossover, doubleValueCrossover);
           }
         }
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/HeuristicLab.Problems.MetaOptimization-3.3.csproj
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/HeuristicLab.Problems.MetaOptimization-3.3.csproj	(revision 5267)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/HeuristicLab.Problems.MetaOptimization-3.3.csproj	(revision 5277)
@@ -149,4 +149,6 @@
     <Compile Include="Interfaces\IParameterConfigurationCrossover.cs" />
     <Compile Include="Interfaces\ICheckedValueConfigurationCollection.cs" />
+    <Compile Include="Operators\Crossovers\AverageDoubleValueCrossover.cs" />
+    <Compile Include="Operators\Crossovers\DiscreteDoubleValueCrossover.cs" />
     <Compile Include="Operators\Crossovers\DiscreteIntValueCrossover.cs" />
     <Compile Include="Operators\Interfaces\IDoubleValueCrossover.cs" />
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/ICheckedValueConfigurationCollection.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/ICheckedValueConfigurationCollection.cs	(revision 5267)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/ICheckedValueConfigurationCollection.cs	(revision 5277)
@@ -6,5 +6,5 @@
 
 namespace HeuristicLab.Problems.MetaOptimization {
-  public interface ICheckedValueConfigurationCollection : ICheckedItemCollection<IValueConfiguration> {
+  public interface ICheckedValueConfigurationList : ICheckedItemList<IValueConfiguration> {
     int MinItemCount { get; }
     IItemSet<IItem> ValidValues { get; }
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IOptimizable.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IOptimizable.cs	(revision 5267)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IOptimizable.cs	(revision 5277)
@@ -7,6 +7,6 @@
 
 namespace HeuristicLab.Problems.MetaOptimization {
-  public delegate void MutateDelegate(IRandom random, IOptimizable configuartion, ParameterConfigurationManipulator pcmanip);
-  public delegate void CrossDelegate(IRandom random, IOptimizable configuartion, ParameterConfigurationCrossover pccross);
+  public delegate void MutateDelegate(IRandom random, IOptimizable configuartion, IIntValueManipulator intValueManipulator, IDoubleValueManipulator doubleValueManipulator);
+  public delegate void CrossDelegate(IRandom random, IOptimizable configuartion, IOptimizable other, IIntValueCrossover intValueCrossover, IDoubleValueCrossover doubleValueCrossover);
 
   public interface IOptimizable : IItem {
@@ -16,6 +16,6 @@
     
     void Randomize(IRandom random);
-    void Mutate(IRandom random, MutateDelegate mutate, ParameterConfigurationManipulator pcmanip);
-    void Cross(IRandom random, IOptimizable other, CrossDelegate cross, ParameterConfigurationCrossover pccross);
+    void Mutate(IRandom random, MutateDelegate mutate, IIntValueManipulator intValueManipulator, IDoubleValueManipulator doubleValueManipulator);
+    void Cross(IRandom random, IOptimizable other, CrossDelegate cross, IIntValueCrossover intValueCrossover, IDoubleValueCrossover doubleValueCrossover);
     string ParameterInfoString { get; }
 
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IParameterConfiguration.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IParameterConfiguration.cs	(revision 5267)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IParameterConfiguration.cs	(revision 5277)
@@ -9,5 +9,5 @@
     string ParameterName { get; set; }
     Type ParameterDataType { get; }
-    ICheckedValueConfigurationCollection ValueConfigurations { get; }
+    ICheckedValueConfigurationList ValueConfigurations { get; }
     Type[] ValidTypes { get; }
     int ActualValueConfigurationIndex { get; set; }
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/MetaOptimizationProblem.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/MetaOptimizationProblem.cs	(revision 5267)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/MetaOptimizationProblem.cs	(revision 5277)
@@ -109,6 +109,10 @@
       var validIntManipulators = new ItemSet<IIntValueManipulator>( ApplicationManager.Manager.GetInstances<IIntValueManipulator>());
       var validDoubleManipulators = new ItemSet<IDoubleValueManipulator>(ApplicationManager.Manager.GetInstances<IDoubleValueManipulator>());
+      var validIntCrossovers = new ItemSet<IIntValueCrossover>(ApplicationManager.Manager.GetInstances<IIntValueCrossover>());
+      var validDoubleCrossovers = new ItemSet<IDoubleValueCrossover>(ApplicationManager.Manager.GetInstances<IDoubleValueCrossover>());
       Parameters.Add(new ConstrainedValueParameter<IIntValueManipulator>(IntValueManipulatorParameterName, "", validIntManipulators, validIntManipulators.First()));
       Parameters.Add(new ConstrainedValueParameter<IDoubleValueManipulator>(DoubleValueManipulatorParameterName, "", validDoubleManipulators, validDoubleManipulators.First()));
+      Parameters.Add(new ConstrainedValueParameter<IIntValueCrossover>(IntValueCrossoverParameterName, "", validIntCrossovers, validIntCrossovers.First()));
+      Parameters.Add(new ConstrainedValueParameter<IDoubleValueCrossover>(DoubleValueCrossoverParameterName, "", validDoubleCrossovers, validDoubleCrossovers.Where(x => x.GetType() == typeof(AverageDoubleValueCrossover)).SingleOrDefault()));
 
       Maximization = new BoolValue(false);
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/AverageDoubleValueCrossover.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/AverageDoubleValueCrossover.cs	(revision 5277)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/AverageDoubleValueCrossover.cs	(revision 5277)
@@ -0,0 +1,39 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Parameters;
+using HeuristicLab.Common;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.MetaOptimization {
+  [StorableClass]
+  public class AverageDoubleValueCrossover : SingleSuccessorOperator, IDoubleValueCrossover, IStochasticOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    public AverageDoubleValueCrossover() { }
+    [StorableConstructor]
+    protected AverageDoubleValueCrossover(bool deserializing) : base(deserializing) { }
+    protected AverageDoubleValueCrossover(AverageDoubleValueCrossover original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new AverageDoubleValueCrossover(this, cloner);
+    }
+
+    public void Apply(IRandom random, DoubleValue value, DoubleValue other, DoubleValueRange range) {
+      ApplyStatic(random, value, other, range);
+    }
+
+    public static void ApplyStatic(IRandom random, DoubleValue value, DoubleValue other, DoubleValueRange range) {
+      value.Value = (value.Value + other.Value) / 2;
+      range.ApplyStepSize(value);
+    }
+  }
+}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/DiscreteDoubleValueCrossover.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/DiscreteDoubleValueCrossover.cs	(revision 5277)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/DiscreteDoubleValueCrossover.cs	(revision 5277)
@@ -0,0 +1,40 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Parameters;
+using HeuristicLab.Common;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.MetaOptimization {
+  [StorableClass]
+  public class DiscreteDoubleValueCrossover : SingleSuccessorOperator, IDoubleValueCrossover, IStochasticOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    public DiscreteDoubleValueCrossover() { }
+    [StorableConstructor]
+    protected DiscreteDoubleValueCrossover(bool deserializing) : base(deserializing) { }
+    protected DiscreteDoubleValueCrossover(DiscreteDoubleValueCrossover original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new DiscreteDoubleValueCrossover(this, cloner);
+    }
+
+    public void Apply(IRandom random, DoubleValue value, DoubleValue other, DoubleValueRange range) {
+      ApplyStatic(random, value, other, range);
+    }
+
+    public static void ApplyStatic(IRandom random, DoubleValue value, DoubleValue other, DoubleValueRange range) {
+      if (random.NextDouble() > 0.5) {
+        value.Value = other.Value;
+      }
+    }
+  }
+}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/DiscreteIntValueCrossover.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/DiscreteIntValueCrossover.cs	(revision 5267)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/DiscreteIntValueCrossover.cs	(revision 5277)
@@ -28,10 +28,12 @@
     }
 
-    public void Apply(IRandom random, IntValue value, IntValueRange range) {
-      Apply(random, value, range);
+    public void Apply(IRandom random, IntValue value, IntValue other, IntValueRange range) {
+      ApplyStatic(random, value, other, range);
     }
 
-    public static void ApplyStatic(IRandom random, IntValue value, IntValueRange range) {
-
+    public static void ApplyStatic(IRandom random, IntValue value, IntValue other, IntValueRange range) {
+      if (random.NextDouble() > 0.5) {
+        value.Value = other.Value;
+      }
     }
   }
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Interfaces/IDoubleValueCrossover.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Interfaces/IDoubleValueCrossover.cs	(revision 5267)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Interfaces/IDoubleValueCrossover.cs	(revision 5277)
@@ -9,5 +9,5 @@
 namespace HeuristicLab.Problems.MetaOptimization {
   public interface IDoubleValueCrossover : ICrossover {
-    void Apply(IRandom random, DoubleValue value, DoubleValueRange range);
+    void Apply(IRandom random, DoubleValue value, DoubleValue other, DoubleValueRange range);
   }
 }
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Interfaces/IIntValueCrossover.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Interfaces/IIntValueCrossover.cs	(revision 5267)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Interfaces/IIntValueCrossover.cs	(revision 5277)
@@ -9,5 +9,5 @@
 namespace HeuristicLab.Problems.MetaOptimization {
   public interface IIntValueCrossover : ICrossover {
-    void Apply(IRandom random, IntValue value, IntValueRange range);
+    void Apply(IRandom random, IntValue value, IntValue other, IntValueRange range);
   }
 }
