Index: branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/ConstrainedItemList.cs
===================================================================
--- branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/ConstrainedItemList.cs	(revision 8535)
+++ 	(revision )
@@ -1,58 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Encodings.ParameterConfigurationEncoding {
-  [StorableClass]
-  public class ConstrainedItemList<T> : ItemList<T> where T : class, IItem {
-    [Storable]
-    private Type type;
-    public Type Type {
-      get { return type; }
-      set {
-        if (type != value) {
-          type = value;
-          this.RemoveAll(x => x.GetType() != type);
-        }
-      }
-    }
-
-    #region Constructors and Cloning
-    [StorableConstructor]
-    protected ConstrainedItemList(bool deserializing) : base(deserializing) { }
-    protected ConstrainedItemList(ConstrainedItemList<T> original, Cloner cloner)
-      : base(original, cloner) {
-      this.Type = original.Type;
-    }
-    public ConstrainedItemList()
-      : base() {
-      Type = typeof(T);
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new ConstrainedItemList<T>(this, cloner);
-    }
-    #endregion
-  }
-}
Index: branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/ConstrainedTypeValue.cs
===================================================================
--- branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/ConstrainedTypeValue.cs	(revision 8535)
+++ 	(revision )
@@ -1,94 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.PluginInfrastructure;
-
-namespace HeuristicLab.Encodings.ParameterConfigurationEncoding {
-  [Item("ConstrainedTypeValue", "Represents a type with constraints.")]
-  [StorableClass]
-  public class ConstrainedTypeValue : TypeValue {
-    private IEnumerable<Type> validTypes;
-    public IEnumerable<Type> ValidTypes {
-      get { return validTypes; }
-      set { validTypes = value; }
-    }
-
-    public override Type Value {
-      set {
-        if (!ValidTypes.Contains(value)) throw new NotSupportedException("Value cannot be set. Type is not enlisted in ValidTypes");
-        base.Value = value;
-      }
-    }
-
-    #region Constructors and Cloning
-    [StorableConstructor]
-    protected ConstrainedTypeValue(bool deserializing) : base(deserializing) { }
-    protected ConstrainedTypeValue(ConstrainedTypeValue original, Cloner cloner)
-      : base(original, cloner) {
-      if (original.validTypes != null)
-        this.validTypes = new List<Type>(original.validTypes);
-    }
-    public ConstrainedTypeValue()
-      : base() {
-      this.readOnly = false;
-    }
-    public ConstrainedTypeValue(Type value)
-      : this() {
-      this.Value = value;
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new ConstrainedTypeValue(this, cloner);
-    }
-    #endregion
-  }
-
-  [Item("ConstrainedTypeValue<>", "Represents a type with constraints.")]
-  [StorableClass]
-  public class ConstrainedTypeValue<T> : ConstrainedTypeValue where T : class, IItem {
-    [StorableConstructor]
-    protected ConstrainedTypeValue(bool deserializing)
-      : base(deserializing) {
-      if (deserializing) {
-        this.ValidTypes = ApplicationManager.Manager.GetTypes(typeof(T), true).ToList();
-      }
-    }
-    protected ConstrainedTypeValue(ConstrainedTypeValue original, Cloner cloner) : base(original, cloner) { }
-    public ConstrainedTypeValue()
-      : base() {
-      this.ValidTypes = ApplicationManager.Manager.GetTypes(typeof(T), true).ToList();
-      this.Value = ValidTypes.First();
-    }
-    public ConstrainedTypeValue(Type value)
-      : base() {
-      this.ValidTypes = ApplicationManager.Manager.GetTypes(typeof(T), true).ToList();
-      this.Value = value;
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new ConstrainedTypeValue<T>(this, cloner);
-    }
-  }
-}
Index: branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Creators/RandomParameterConfigurationCreator.cs
===================================================================
--- branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Creators/RandomParameterConfigurationCreator.cs	(revision 8574)
+++ branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Creators/RandomParameterConfigurationCreator.cs	(revision 8574)
@@ -0,0 +1,73 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.ParameterConfigurationEncoding {
+  /// <summary>
+  /// An operator which creates a new set of parameters.
+  /// </summary>
+  [Item("RandomParameterVectorCreator", "An operator which creates a new set of parameters.")]
+  [StorableClass]
+  public sealed class RandomParameterConfigurationCreator : SingleSuccessorOperator, IStochasticOperator, IParameterConfigurationCreator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<ParameterConfigurationTree> InitialParameterConfigurationParameter {
+      get { return (ILookupParameter<ParameterConfigurationTree>)Parameters["ParameterConfiguration"]; }
+    }
+
+    public IValueLookupParameter<ParameterConfigurationTree> ParameterConfigurationParameter {
+      get { return (IValueLookupParameter<ParameterConfigurationTree>)Parameters["ParameterConfigurationTreeSolutionCandidate"]; }
+    }
+
+    #region Constructors and Cloning
+    public RandomParameterConfigurationCreator()
+      : 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 LookupParameter<ParameterConfigurationTree>("ParameterConfiguration", "The parameter configuration tree on which the new solution will be based on."));
+      Parameters.Add(new ValueLookupParameter<ParameterConfigurationTree>("ParameterConfigurationTreeSolutionCandidate", "The new random parameter set."));
+    }
+
+    [StorableConstructor]
+    private RandomParameterConfigurationCreator(bool deserializing) : base(deserializing) { }
+    private RandomParameterConfigurationCreator(RandomParameterConfigurationCreator original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RandomParameterConfigurationCreator(this, cloner);
+    }
+    #endregion
+
+    public override IOperation Apply() {
+      ParameterConfigurationParameter.ActualValue = (ParameterConfigurationTree)InitialParameterConfigurationParameter.ActualValue.Clone();
+      ParameterConfigurationParameter.ActualValue.Randomize(RandomParameter.ActualValue);
+      return base.Apply();
+    }
+  }
+}
Index: branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Crossovers/ParameterConfigurationCrossover.cs
===================================================================
--- branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Crossovers/ParameterConfigurationCrossover.cs	(revision 8574)
+++ branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Crossovers/ParameterConfigurationCrossover.cs	(revision 8574)
@@ -0,0 +1,141 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.ParameterConfigurationEncoding {
+  /// <summary>
+  /// An operator which crosses two sets of parameters.
+  /// </summary>
+  [Item("ParameterConfigurationCrossover", "An operator which crosses two sets of parameters.")]
+  [StorableClass]
+  public class ParameterConfigurationCrossover : SingleSuccessorOperator, IParameterConfigurationCrossover {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<ItemArray<ParameterConfigurationTree>> ParentsParameter {
+      get { return (ScopeTreeLookupParameter<ParameterConfigurationTree>)Parameters["Parents"]; }
+    }
+    public ILookupParameter<ParameterConfigurationTree> ChildParameter {
+      get { return (ILookupParameter<ParameterConfigurationTree>)Parameters["Child"]; }
+    }
+
+    public IValueLookupParameter<IIntValueCrossover> IntValueCrossoverParameter {
+      get { return (IValueLookupParameter<IIntValueCrossover>)Parameters["IntValueCrossover"]; }
+    }
+    public IValueLookupParameter<IDoubleValueCrossover> DoubleValueCrossoverParameter {
+      get { return (IValueLookupParameter<IDoubleValueCrossover>)Parameters["DoubleValueCrossover"]; }
+    }
+
+    /// <summary>
+    /// Whether the problem is a maximization or minimization problem.
+    /// </summary>
+    public ValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (ValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+
+    /// <summary>
+    /// The quality of the parents.
+    /// </summary>
+    public ScopeTreeLookupParameter<DoubleValue> QualityParameter {
+      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+
+    #region Constructors and Cloning
+    public ParameterConfigurationCrossover()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic crossover operators."));
+      Parameters.Add(new ScopeTreeLookupParameter<ParameterConfigurationTree>("Parents", "The parent vectors which should be crossed."));
+      Parameters.Add(new LookupParameter<ParameterConfigurationTree>("Child", "The child vector resulting from the crossover."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "Whether the problem is a maximization problem or not."));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The quality values of the parents."));
+      Parameters.Add(new ValueLookupParameter<IIntValueCrossover>("IntValueCrossover", ""));
+      Parameters.Add(new ValueLookupParameter<IDoubleValueCrossover>("DoubleValueCrossover", ""));
+    }
+
+    [StorableConstructor]
+    protected ParameterConfigurationCrossover(bool deserializing) : base(deserializing) { }
+    protected ParameterConfigurationCrossover(ParameterConfigurationCrossover original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ParameterConfigurationCrossover(this, cloner);
+    }
+    #endregion
+
+    public override IOperation Apply() {
+      if (MaximizationParameter.ActualValue == null) throw new InvalidOperationException("ParameterConfigurationCrossover: Parameter " + MaximizationParameter.ActualName + " could not be found.");
+      if (QualityParameter.ActualValue == null || QualityParameter.ActualValue.Length != 2) throw new InvalidOperationException("ParameterConfigurationCrossover: Parameter " + QualityParameter.ActualName + " could not be found, or not in the same quantity as there are parents.");
+      ItemArray<DoubleValue> qualities = QualityParameter.ActualValue;
+      bool maximization = MaximizationParameter.ActualValue.Value;
+
+      ParameterConfigurationTree child1;
+      ParameterConfigurationTree child2;
+
+      if (maximization && qualities[0].Value >= qualities[1].Value || !maximization && qualities[0].Value <= qualities[1].Value) {
+        child1 = (ParameterConfigurationTree)ParentsParameter.ActualValue[0].Clone();
+        child2 = ParentsParameter.ActualValue[1];
+      } else {
+        child1 = (ParameterConfigurationTree)ParentsParameter.ActualValue[1].Clone();
+        child2 = ParentsParameter.ActualValue[0];
+      }
+
+      Cross(RandomParameter.ActualValue, child1, child2, IntValueCrossoverParameter.ActualValue, DoubleValueCrossoverParameter.ActualValue);
+      this.ChildParameter.ActualValue = child1;
+
+      return base.Apply();
+    }
+
+    public static void Apply(IRandom random, IOptimizable configuartion, IOptimizable other, IIntValueCrossover intValueCrossover, IDoubleValueCrossover doubleValueCrossover) {
+      Cross(random, configuartion, other, intValueCrossover, doubleValueCrossover);
+    }
+
+    public static void Cross(IRandom random, IOptimizable configuration, IOptimizable other, IIntValueCrossover intValueCrossover, IDoubleValueCrossover doubleValueCrossover) {
+      var vc = configuration as RangeValueConfiguration;
+      var pc = configuration as IParameterConfiguration;
+      if (vc != null) {
+        var value = vc.ActualValue.Value;
+        var range = vc.RangeConstraint;
+
+        if (value is IntValue) {
+          intValueCrossover.Apply(random, (IntValue)value, (IntValue)other.ActualValue.Value, (IntValueRange)range);
+        } else if (value is PercentValue) {
+          doubleValueCrossover.Apply(random, (PercentValue)value, (DoubleValue)other.ActualValue.Value, ((PercentValueRange)range).AsDoubleValueRange());
+        } else if (value is DoubleValue) {
+          doubleValueCrossover.Apply(random, (DoubleValue)value, (DoubleValue)other.ActualValue.Value, (DoubleValueRange)range);
+        }
+      } else if (pc != null) {
+        if (random.NextDouble() > 0.5) {
+          pc.ActualValueConfigurationIndex = ((ParameterConfiguration)other).ActualValueConfigurationIndex;
+        }
+        pc.ActualValue = pc.ValueConfigurations[pc.ActualValueConfigurationIndex].ActualValue;
+      }
+    }
+  }
+}
Index: branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/ExperimentFactory.cs
===================================================================
--- branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/ExperimentFactory.cs	(revision 8574)
+++ branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/ExperimentFactory.cs	(revision 8574)
@@ -0,0 +1,87 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using HeuristicLab.Optimization;
+using HeuristicLab.Problems.Instances;
+
+namespace HeuristicLab.Encodings.ParameterConfigurationEncoding {
+  public class ExperimentFactory {
+    private double experimentGenerationProgress;
+    public double ExperimentGenerationProgress {
+      get { return experimentGenerationProgress; }
+      private set {
+        if (experimentGenerationProgress != value) {
+          experimentGenerationProgress = value;
+          OnExperimentGenerationProgressChanged();
+        }
+      }
+    }
+
+    public event EventHandler ExperimentGenerationProgressChanged;
+    private void OnExperimentGenerationProgressChanged() {
+      var handler = ExperimentGenerationProgressChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+
+    public Experiment GenerateExperiment(IAlgorithm algorithm, ParameterConfigurationTree configuration, bool createBatchRuns, int repetitions, Dictionary<IProblemInstanceProvider, HashSet<IDataDescriptor>> problemInstances, CancellationToken ct) {
+      var experiment = new Experiment();
+      var algorithms = new List<IAlgorithm>(1 + problemInstances.Values.Count) { (IAlgorithm)algorithm.Clone() };
+      foreach (var provider in problemInstances) {
+        foreach (var descriptor in provider.Value) {
+          var alg = (IAlgorithm)algorithm.Clone();
+          ProblemInstanceManager.LoadData(provider.Key, descriptor, (IProblemInstanceConsumer)alg.Problem);
+          algorithms.Add(alg);
+        }
+      }
+      ExperimentGenerationProgress = 0;
+      foreach (var alg in algorithms) {
+        foreach (ParameterizedValueConfiguration combination in configuration) {
+          ct.ThrowIfCancellationRequested();
+          var clonedAlg = (IAlgorithm)alg.Clone();
+          clonedAlg.Name = combination.ParameterInfoString;
+          combination.Parameterize(clonedAlg);
+          clonedAlg.StoreAlgorithmInEachRun = false;
+          if (createBatchRuns) {
+            var batchRun = new BatchRun(string.Format("BatchRun: {0}", combination.ParameterInfoString));
+            batchRun.Optimizer = clonedAlg;
+            batchRun.Repetitions = repetitions;
+            experiment.Optimizers.Add(batchRun);
+          } else {
+            experiment.Optimizers.Add(clonedAlg);
+          }
+          ExperimentGenerationProgress = (double)experiment.Optimizers.Count / (configuration.GetCombinationCount(0) * algorithms.Count);
+        }
+      }
+      return experiment;
+    }
+
+    public Experiment GenerateExperiment(IAlgorithm algorithm, ParameterConfigurationTree configuration) {
+      return GenerateExperiment(algorithm, configuration, false, 0, null, CancellationToken.None);
+    }
+
+    public Experiment GenerateExperiment(IAlgorithm algorithm, ParameterConfigurationTree configuration, bool createBatchRuns, int repetitions) {
+      return GenerateExperiment(algorithm, configuration, createBatchRuns, repetitions, null, CancellationToken.None);
+    }
+  }
+}
Index: branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/HeuristicLab.Encodings.ParameterConfigurationEncoding-3.3.csproj
===================================================================
--- branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/HeuristicLab.Encodings.ParameterConfigurationEncoding-3.3.csproj	(revision 8535)
+++ branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/HeuristicLab.Encodings.ParameterConfigurationEncoding-3.3.csproj	(revision 8574)
@@ -58,8 +58,11 @@
       <Private>False</Private>
     </Reference>
+    <Reference Include="HeuristicLab.Encodings.IntegerVectorEncoding-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
+    <Reference Include="HeuristicLab.Encodings.RealVectorEncoding-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
     <Reference Include="HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4">
       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4.dll</HintPath>
       <Private>False</Private>
     </Reference>
+    <Reference Include="HeuristicLab.Operators-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
     <Reference Include="HeuristicLab.Optimization-3.3">
       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Optimization-3.3.dll</HintPath>
@@ -78,4 +81,5 @@
       <Private>False</Private>
     </Reference>
+    <Reference Include="HeuristicLab.Problems.DataAnalysis-3.4, Version=3.4.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
     <Reference Include="HeuristicLab.Problems.DataAnalysis.Symbolic-3.4">
       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.dll</HintPath>
@@ -85,4 +89,6 @@
       <Private>False</Private>
     </Reference>
+    <Reference Include="HeuristicLab.Random-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
+    <Reference Include="Microsoft.CSharp" />
     <Reference Include="System" />
     <Reference Include="System.Core" />
@@ -94,12 +100,37 @@
     <Compile Include="AlgorithmProblemItem.cs" />
     <None Include="Plugin.cs.frame" />
-    <Compile Include="ConstrainedItemList.cs" />
-    <Compile Include="ConstrainedTypeValue.cs" />
+    <Compile Include="Creators\RandomParameterConfigurationCreator.cs" />
+    <Compile Include="Crossovers\ParameterConfigurationCrossover.cs" />
+    <Compile Include="ExperimentFactory.cs" />
     <Compile Include="Interfaces\ICheckedValueConfigurationCollection.cs" />
     <Compile Include="Interfaces\IOptimizable.cs" />
     <Compile Include="Interfaces\IParameterConfiguration.cs" />
+    <Compile Include="Interfaces\IParameterConfigurationCreator.cs" />
+    <Compile Include="Interfaces\IParameterConfigurationCrossover.cs" />
+    <Compile Include="Interfaces\IParameterConfigurationEvaluator.cs" />
+    <Compile Include="Interfaces\IParameterConfigurationManipulator.cs" />
+    <Compile Include="Interfaces\IParameterConfigurationOperator.cs" />
     <Compile Include="Interfaces\IRange.cs" />
     <Compile Include="Interfaces\IValueConfiguration.cs" />
+    <Compile Include="Manipulators\ParameterConfigurationAllPositionsManipulator.cs" />
+    <Compile Include="Manipulators\ParameterConfigurationManipulator.cs" />
+    <Compile Include="Manipulators\ParameterConfigurationOnePositionsManipulator.cs" />
     <Compile Include="NullValue.cs" />
+    <Compile Include="Operators\Crossovers\DoubleValue\AverageDoubleValueCrossover.cs" />
+    <Compile Include="Operators\Crossovers\DoubleValue\DiscreteDoubleValueCrossover.cs" />
+    <Compile Include="Operators\Crossovers\DoubleValue\NormalDoubleValueCrossover.cs" />
+    <Compile Include="Operators\Crossovers\IntValue\AverageIntValueCrossover.cs" />
+    <Compile Include="Operators\Crossovers\IntValue\DiscreteIntValueCrossover.cs" />
+    <Compile Include="Operators\Crossovers\IntValue\MultiIntValueCrossover.cs" />
+    <Compile Include="Operators\Crossovers\IntValue\NormalIntValueCrossover.cs" />
+    <Compile Include="Operators\Interfaces\IDoubleValueCrossover.cs" />
+    <Compile Include="Operators\Interfaces\IDoubleValueManipulator.cs" />
+    <Compile Include="Operators\Interfaces\IIntValueCrossover.cs" />
+    <Compile Include="Operators\Interfaces\IIntValueManipulator.cs" />
+    <Compile Include="Operators\Interfaces\IValueManipulator.cs" />
+    <Compile Include="Operators\Manipulators\DoubleValue\NormalDoubleValueManipulator.cs" />
+    <Compile Include="Operators\Manipulators\DoubleValue\UniformDoubleValueManipulator.cs" />
+    <Compile Include="Operators\Manipulators\IntValue\NormalIntValueManipulator.cs" />
+    <Compile Include="Operators\Manipulators\IntValue\UniformIntValueManipulator.cs" />
     <Compile Include="ParameterCombinationsEnumerator.cs" />
     <Compile Include="ParameterConfigurations\ParameterConfiguration.cs" />
@@ -126,5 +157,7 @@
     <None Include="HeuristicLab.snk" />
   </ItemGroup>
-  <ItemGroup />
+  <ItemGroup>
+    <Folder Include="Operators\Crossovers\SymbolicExpressionGrammar\" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <PropertyGroup>
Index: branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Interfaces/IParameterConfigurationCreator.cs
===================================================================
--- branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Interfaces/IParameterConfigurationCreator.cs	(revision 8574)
+++ branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Interfaces/IParameterConfigurationCreator.cs	(revision 8574)
@@ -0,0 +1,30 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Encodings.ParameterConfigurationEncoding {
+  /// <summary>
+  /// An interface which represents an creator for parameter configurations.
+  /// </summary>
+  public interface IParameterConfigurationCreator : ISolutionCreator, IParameterConfigurationOperator {
+  }
+}
Index: branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Interfaces/IParameterConfigurationCrossover.cs
===================================================================
--- branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Interfaces/IParameterConfigurationCrossover.cs	(revision 8574)
+++ branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Interfaces/IParameterConfigurationCrossover.cs	(revision 8574)
@@ -0,0 +1,33 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Encodings.ParameterConfigurationEncoding {
+  /// <summary>
+  /// An interface which represents a crossover operator for parameter configurations.
+  /// </summary>
+  public interface IParameterConfigurationCrossover : ICrossover, IParameterConfigurationOperator {
+    ILookupParameter<ItemArray<ParameterConfigurationTree>> ParentsParameter { get; }
+    ILookupParameter<ParameterConfigurationTree> ChildParameter { get; }
+  }
+}
Index: branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Interfaces/IParameterConfigurationEvaluator.cs
===================================================================
--- branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Interfaces/IParameterConfigurationEvaluator.cs	(revision 8574)
+++ branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Interfaces/IParameterConfigurationEvaluator.cs	(revision 8574)
@@ -0,0 +1,29 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Encodings.ParameterConfigurationEncoding {
+  /// <summary>
+  /// An interface which represents an evaluation operator for parameter configurations.
+  /// </summary>
+  public interface IParameterConfigurationEvaluator : ISingleObjectiveEvaluator, IParameterConfigurationOperator { }
+}
Index: branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Interfaces/IParameterConfigurationManipulator.cs
===================================================================
--- branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Interfaces/IParameterConfigurationManipulator.cs	(revision 8574)
+++ branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Interfaces/IParameterConfigurationManipulator.cs	(revision 8574)
@@ -0,0 +1,32 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Encodings.ParameterConfigurationEncoding {
+  /// <summary>
+  /// An interface which represents a manipulation operator for parameter configurations.
+  /// </summary>
+  public interface IParameterConfigurationManipulator : IParameterConfigurationOperator, IManipulator {
+    IValueLookupParameter<ParameterConfigurationTree> ParameterConfigurationTreeParameter { get; }
+  }
+}
Index: branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Interfaces/IParameterConfigurationOperator.cs
===================================================================
--- branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Interfaces/IParameterConfigurationOperator.cs	(revision 8574)
+++ branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Interfaces/IParameterConfigurationOperator.cs	(revision 8574)
@@ -0,0 +1,29 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Encodings.ParameterConfigurationEncoding {
+  /// <summary>
+  /// An interface which represents an operator dealing with parameter sets.
+  /// </summary>
+  public interface IParameterConfigurationOperator : IOperator { }
+}
Index: branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Interfaces/IRange.cs
===================================================================
--- branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Interfaces/IRange.cs	(revision 8535)
+++ branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Interfaces/IRange.cs	(revision 8574)
@@ -42,5 +42,5 @@
   }
 
-  public interface IRange<T> : IRange, IItem where T : class {
+  public interface IRange<T> : IRange where T : class {
     new T LowerBound { get; set; }
     new T UpperBound { get; set; }
Index: branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Manipulators/ParameterConfigurationAllPositionsManipulator.cs
===================================================================
--- branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Manipulators/ParameterConfigurationAllPositionsManipulator.cs	(revision 8574)
+++ branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Manipulators/ParameterConfigurationAllPositionsManipulator.cs	(revision 8574)
@@ -0,0 +1,53 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.ParameterConfigurationEncoding {
+  /// <summary>
+  /// TODO
+  /// </summary>
+  [Item("ParameterConfigurationAllPositionsManipulator", "TODO")]
+  [StorableClass]
+  public class ParameterConfigurationAllPositionsManipulator : ParameterConfigurationManipulator {
+    #region Constructors and Cloning
+    public ParameterConfigurationAllPositionsManipulator() : base() { }
+
+    [StorableConstructor]
+    protected ParameterConfigurationAllPositionsManipulator(bool deserializing) : base(deserializing) { }
+    protected ParameterConfigurationAllPositionsManipulator(ParameterConfigurationAllPositionsManipulator original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ParameterConfigurationAllPositionsManipulator(this, cloner);
+    }
+    #endregion
+
+    public sealed override IOperation Apply() {
+      Apply(RandomParameter.ActualValue, ParameterConfigurationTreeParameter.ActualValue, IntValueManipulatorParameter.ActualValue, DoubleValueManipulatorParameter.ActualValue);
+      return base.Apply();
+    }
+
+    public static new void Apply(IRandom random, IValueConfiguration configuration, IIntValueManipulator intValueManipulator, IDoubleValueManipulator doubleValueManipulator) {
+      Mutate(random, configuration, intValueManipulator, doubleValueManipulator);
+    }
+  }
+}
Index: branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Manipulators/ParameterConfigurationManipulator.cs
===================================================================
--- branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Manipulators/ParameterConfigurationManipulator.cs	(revision 8574)
+++ branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Manipulators/ParameterConfigurationManipulator.cs	(revision 8574)
@@ -0,0 +1,100 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.ParameterConfigurationEncoding {
+  /// <summary>
+  /// TODO
+  /// </summary>
+  [Item("ParameterConfigurationManipulator", "TODO")]
+  [StorableClass]
+  public abstract class ParameterConfigurationManipulator : SingleSuccessorOperator, IParameterConfigurationManipulator, IStochasticOperator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public IValueLookupParameter<ParameterConfigurationTree> ParameterConfigurationTreeParameter {
+      get { return (IValueLookupParameter<ParameterConfigurationTree>)Parameters["ParameterConfigurationTree"]; }
+    }
+
+    public IValueLookupParameter<IIntValueManipulator> IntValueManipulatorParameter {
+      get { return (IValueLookupParameter<IIntValueManipulator>)Parameters["IntValueManipulator"]; }
+    }
+    public IValueLookupParameter<IDoubleValueManipulator> DoubleValueManipulatorParameter {
+      get { return (IValueLookupParameter<IDoubleValueManipulator>)Parameters["DoubleValueManipulator"]; }
+    }
+
+    #region Constructors and Cloning
+    public ParameterConfigurationManipulator()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
+      Parameters.Add(new ValueLookupParameter<ParameterConfigurationTree>("ParameterConfigurationTree", "The parameter configuration which should be manipulated."));
+      Parameters.Add(new ValueLookupParameter<IIntValueManipulator>("IntValueManipulator", ""));
+      Parameters.Add(new ValueLookupParameter<IDoubleValueManipulator>("DoubleValueManipulator", ""));
+    }
+
+    [StorableConstructor]
+    protected ParameterConfigurationManipulator(bool deserializing) : base(deserializing) { }
+    protected ParameterConfigurationManipulator(ParameterConfigurationManipulator original, Cloner cloner) : base(original, cloner) { }
+    #endregion
+
+    public override IOperation Apply() {
+      Apply(RandomParameter.ActualValue, ParameterConfigurationTreeParameter.ActualValue, IntValueManipulatorParameter.ActualValue, DoubleValueManipulatorParameter.ActualValue);
+      return base.Apply();
+    }
+
+    public static void Apply(IRandom random, IValueConfiguration configuration, IIntValueManipulator intValueManipulator, IDoubleValueManipulator doubleValueManipulator) {
+      Mutate(random, configuration, intValueManipulator, doubleValueManipulator);
+    }
+
+    public static void Mutate(IRandom random, IOptimizable configuration, IIntValueManipulator intValueManipulator, IDoubleValueManipulator doubleValueManipulator) {
+      var vc = configuration as RangeValueConfiguration;
+      var pc = configuration as IParameterConfiguration;
+
+      if (vc != null) {
+        var value = vc.ActualValue.Value;
+        var range = vc.RangeConstraint;
+        if (value is IntValue) {
+          intValueManipulator.Apply(random, (IntValue)value, (IntValueRange)range);
+        } else if (value is PercentValue) {
+          doubleValueManipulator.Apply(random, (PercentValue)value, ((PercentValueRange)range).AsDoubleValueRange());
+        } else if (value is DoubleValue) {
+          doubleValueManipulator.Apply(random, (DoubleValue)value, (DoubleValueRange)range);
+        }
+      } 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/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Manipulators/ParameterConfigurationOnePositionsManipulator.cs
===================================================================
--- branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Manipulators/ParameterConfigurationOnePositionsManipulator.cs	(revision 8574)
+++ branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Manipulators/ParameterConfigurationOnePositionsManipulator.cs	(revision 8574)
@@ -0,0 +1,54 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.ParameterConfigurationEncoding {
+  /// <summary>
+  /// TODO
+  /// </summary>
+  [Item("ParameterConfigurationOnePositionsManipulator", "TODO")]
+  [StorableClass]
+  public class ParameterConfigurationOnePositionsManipulator : ParameterConfigurationManipulator {
+    #region Constructors and Cloning
+    public ParameterConfigurationOnePositionsManipulator() : base() { }
+
+    [StorableConstructor]
+    protected ParameterConfigurationOnePositionsManipulator(bool deserializing) : base(deserializing) { }
+    protected ParameterConfigurationOnePositionsManipulator(ParameterConfigurationOnePositionsManipulator original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ParameterConfigurationOnePositionsManipulator(this, cloner);
+    }
+    #endregion
+
+    public sealed override IOperation Apply() {
+      Apply(RandomParameter.ActualValue, ParameterConfigurationTreeParameter.ActualValue, IntValueManipulatorParameter.ActualValue, DoubleValueManipulatorParameter.ActualValue);
+      return base.Apply();
+    }
+
+    public static void Apply(IRandom random, ParameterConfigurationTree configuration, IIntValueManipulator intValueManipulator, IDoubleValueManipulator doubleValueManipulator) {
+      IOptimizable optimizable = configuration.GetRandomOptimizable(random);
+      Mutate(random, optimizable, intValueManipulator, doubleValueManipulator);
+    }
+  }
+}
Index: branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Crossovers/DoubleValue/AverageDoubleValueCrossover.cs
===================================================================
--- branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Crossovers/DoubleValue/AverageDoubleValueCrossover.cs	(revision 8574)
+++ branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Crossovers/DoubleValue/AverageDoubleValueCrossover.cs	(revision 8574)
@@ -0,0 +1,61 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.ParameterConfigurationEncoding {
+  /// <summary>
+  /// An operator which crosses two double values. TODO
+  /// </summary>
+  [Item("AverageDoubleValueCrossover", "An operator which crosses two double values. TODO")]
+  [StorableClass]
+  public class AverageDoubleValueCrossover : SingleSuccessorOperator, IDoubleValueCrossover, IStochasticOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    #region Constructors and Cloning
+    public AverageDoubleValueCrossover() : base() { }
+
+    [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);
+    }
+    #endregion
+
+    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;
+      value.Value = range.ApplyStepSize(value.Value);
+    }
+  }
+}
Index: branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Crossovers/DoubleValue/DiscreteDoubleValueCrossover.cs
===================================================================
--- branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Crossovers/DoubleValue/DiscreteDoubleValueCrossover.cs	(revision 8574)
+++ branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Crossovers/DoubleValue/DiscreteDoubleValueCrossover.cs	(revision 8574)
@@ -0,0 +1,62 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.ParameterConfigurationEncoding {
+  /// <summary>
+  /// An operator which crosses two double values. TODO
+  /// </summary>
+  [Item("DiscreteDoubleValueCrossover", "An operator which crosses two double values. TODO")]
+  [StorableClass]
+  public class DiscreteDoubleValueCrossover : SingleSuccessorOperator, IDoubleValueCrossover, IStochasticOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    #region Constructors and Cloning
+    public DiscreteDoubleValueCrossover() : base() { }
+
+    [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);
+    }
+    #endregion
+
+    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/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Crossovers/DoubleValue/NormalDoubleValueCrossover.cs
===================================================================
--- branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Crossovers/DoubleValue/NormalDoubleValueCrossover.cs	(revision 8574)
+++ branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Crossovers/DoubleValue/NormalDoubleValueCrossover.cs	(revision 8574)
@@ -0,0 +1,69 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Encodings.ParameterConfigurationEncoding {
+  /// <summary>
+  /// An operator which crosses two double values. TODO
+  /// </summary>
+  [Item("NormalDoubleValueCrossover", "An operator which crosses two double values. TODO")]
+  [StorableClass]
+  public class NormalDoubleValueCrossover : SingleSuccessorOperator, IDoubleValueCrossover, IStochasticOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    #region Constructors and Cloning
+    public NormalDoubleValueCrossover() : base() { }
+
+    [StorableConstructor]
+    protected NormalDoubleValueCrossover(bool deserializing) : base(deserializing) { }
+    protected NormalDoubleValueCrossover(NormalDoubleValueCrossover original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new NormalDoubleValueCrossover(this, cloner);
+    }
+    #endregion
+
+    public void Apply(IRandom random, DoubleValue value, DoubleValue other, DoubleValueRange range) {
+      value.Value = ApplyStatic(random, value, other, range).Value;
+    }
+
+    public static DoubleValue ApplyStatic(IRandom random, DoubleValue better, DoubleValue worse, DoubleValueRange range) {
+      NormalDistributedRandom N = new NormalDistributedRandom(random, better.Value, Math.Abs(better.Value - worse.Value) / 3);
+      var offspring = new DoubleValue();
+      do {
+        offspring.Value = N.NextDouble();
+        offspring.Value = range.ApplyStepSize(offspring.Value);
+      } while (!range.IsInRange(offspring.Value));
+
+      return offspring;
+    }
+  }
+}
Index: branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Crossovers/IntValue/AverageIntValueCrossover.cs
===================================================================
--- branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Crossovers/IntValue/AverageIntValueCrossover.cs	(revision 8574)
+++ branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Crossovers/IntValue/AverageIntValueCrossover.cs	(revision 8574)
@@ -0,0 +1,60 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.ParameterConfigurationEncoding {
+  /// <summary>
+  /// An operator which crosses two integer values. TODO
+  /// </summary>
+  [Item("AverageIntValueCrossover", "An operator which crosses two integer values. TODO")]
+  [StorableClass]
+  public class AverageIntValueCrossover : SingleSuccessorOperator, IIntValueCrossover, IStochasticOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    #region Constructors and Cloning
+    public AverageIntValueCrossover() : base() { }
+
+    [StorableConstructor]
+    protected AverageIntValueCrossover(bool deserializing) : base(deserializing) { }
+    protected AverageIntValueCrossover(AverageIntValueCrossover original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new AverageIntValueCrossover(this, cloner);
+    }
+    #endregion
+
+    public void Apply(IRandom random, IntValue value, IntValue other, IntValueRange range) {
+      ApplyStatic(random, value, other, range);
+    }
+
+    public static void ApplyStatic(IRandom random, IntValue value, IntValue other, IntValueRange range) {
+      value.Value = (value.Value + other.Value) / 2;
+    }
+  }
+}
Index: branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Crossovers/IntValue/DiscreteIntValueCrossover.cs
===================================================================
--- branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Crossovers/IntValue/DiscreteIntValueCrossover.cs	(revision 8574)
+++ branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Crossovers/IntValue/DiscreteIntValueCrossover.cs	(revision 8574)
@@ -0,0 +1,62 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.ParameterConfigurationEncoding {
+  /// <summary>
+  /// An operator which crosses two integer values. TODO
+  /// </summary>
+  [Item("DiscreteIntValueCrossover", "An operator which crosses two integer values. TODO")]
+  [StorableClass]
+  public class DiscreteIntValueCrossover : SingleSuccessorOperator, IIntValueCrossover, IStochasticOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    #region Constructors and Cloning
+    public DiscreteIntValueCrossover() : base() { }
+
+    [StorableConstructor]
+    protected DiscreteIntValueCrossover(bool deserializing) : base(deserializing) { }
+    protected DiscreteIntValueCrossover(DiscreteIntValueCrossover original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new DiscreteIntValueCrossover(this, cloner);
+    }
+    #endregion
+
+    public void Apply(IRandom random, IntValue value, IntValue other, IntValueRange range) {
+      ApplyStatic(random, value, other, range);
+    }
+
+    public static void ApplyStatic(IRandom random, IntValue value, IntValue other, IntValueRange range) {
+      if (random.NextDouble() > 0.5) {
+        value.Value = other.Value;
+      }
+    }
+  }
+}
Index: branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Crossovers/IntValue/MultiIntValueCrossover.cs
===================================================================
--- branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Crossovers/IntValue/MultiIntValueCrossover.cs	(revision 8574)
+++ branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Crossovers/IntValue/MultiIntValueCrossover.cs	(revision 8574)
@@ -0,0 +1,72 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.Encodings.ParameterConfigurationEncoding {
+  /// <summary>
+  /// An operator which crosses two integer values. TODO
+  /// </summary>
+  [Item("MultiIntValueCrossover", "An operator which crosses two integer values. It randomly selects and applies one of its crossovers every time it is called.")]
+  [StorableClass]
+  public class MultiIntValueCrossover : StochasticMultiBranch<IIntValueCrossover>, IIntValueCrossover, IStochasticOperator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    protected override bool CreateChildOperation {
+      get { return true; }
+    }
+
+    #region Constructors and Cloning
+    public MultiIntValueCrossover()
+      : base() {
+      foreach (Type type in ApplicationManager.Manager.GetTypes(typeof(IIntValueCrossover)).OrderBy(op => op.Name)) {
+        if (!typeof(MultiOperator<IIntValueCrossover>).IsAssignableFrom(type))
+          Operators.Add((IIntValueCrossover)Activator.CreateInstance(type), true);
+      }
+    }
+
+    [StorableConstructor]
+    protected MultiIntValueCrossover(bool deserializing) : base(deserializing) { }
+    protected MultiIntValueCrossover(MultiIntValueCrossover original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MultiIntValueCrossover(this, cloner);
+    }
+    #endregion
+
+    public override IOperation Apply() {
+      if (Operators.Count == 0) throw new InvalidOperationException(Name + ": Please add at least one crossover to choose from.");
+      return base.Apply();
+    }
+
+    public void Apply(IRandom random, IntValue value, IntValue other, IntValueRange range) {
+      // TODO
+    }
+  }
+}
Index: branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Crossovers/IntValue/NormalIntValueCrossover.cs
===================================================================
--- branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Crossovers/IntValue/NormalIntValueCrossover.cs	(revision 8574)
+++ branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Crossovers/IntValue/NormalIntValueCrossover.cs	(revision 8574)
@@ -0,0 +1,68 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Encodings.ParameterConfigurationEncoding {
+  /// <summary>
+  /// An operator which crosses two integer values. TODO
+  /// </summary>
+  [Item("NormalIntValueCrossover", "An operator which crosses two integer values. TODO")]
+  [StorableClass]
+  public class NormalIntValueCrossover : SingleSuccessorOperator, IIntValueCrossover, IStochasticOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    #region Constructors and Cloning
+    public NormalIntValueCrossover() : base() { }
+
+    [StorableConstructor]
+    protected NormalIntValueCrossover(bool deserializing) : base(deserializing) { }
+    protected NormalIntValueCrossover(NormalIntValueCrossover original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new NormalIntValueCrossover(this, cloner);
+    }
+    #endregion
+
+    public void Apply(IRandom random, IntValue value, IntValue other, IntValueRange range) {
+      value.Value = ApplyStatic(random, value, other, range).Value;
+    }
+
+    public static IntValue ApplyStatic(IRandom random, IntValue better, IntValue worse, IntValueRange range) {
+      NormalDistributedRandom N = new NormalDistributedRandom(random, better.Value, Math.Abs(better.Value - worse.Value) / 3);
+      var offspring = new IntValue();
+      do {
+        offspring.Value = (int)N.NextDouble();
+        offspring.Value = range.ApplyStepSize(offspring.Value);
+      } while (!range.IsInRange(offspring.Value));
+      return offspring;
+    }
+  }
+}
Index: branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Crossovers/SymbolicExpressionGrammar/SymbolicExpressionGrammarCrossover.cs
===================================================================
--- branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Crossovers/SymbolicExpressionGrammar/SymbolicExpressionGrammarCrossover.cs	(revision 8574)
+++ branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Crossovers/SymbolicExpressionGrammar/SymbolicExpressionGrammarCrossover.cs	(revision 8574)
@@ -0,0 +1,35 @@
+﻿using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.ParameterConfigurationEncoding {
+  [StorableClass]
+  public class SymbolicExpressionGrammarCrossover : SingleSuccessorOperator, IDoubleValueCrossover, IStochasticOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    public SymbolicExpressionGrammarCrossover() { }
+    [StorableConstructor]
+    protected SymbolicExpressionGrammarCrossover(bool deserializing) : base(deserializing) { }
+    protected SymbolicExpressionGrammarCrossover(SymbolicExpressionGrammarCrossover original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SymbolicExpressionGrammarCrossover(this, cloner);
+    }
+
+    public void Apply(IRandom random, ISymbolicExpressionGrammar value, ISymbolicExpressionGrammar other) {
+      ApplyStatic(random, value, other, range);
+    }
+
+    public static void ApplyStatic(IRandom random, ISymbolicExpressionGrammar value, ISymbolicExpressionGrammar other) {
+      value.Value = (value.Value + other.Value) / 2;
+      value.Value = range.ApplyStepSize(value.Value);
+    }
+  }
+}
Index: branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Interfaces/IDoubleValueCrossover.cs
===================================================================
--- branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Interfaces/IDoubleValueCrossover.cs	(revision 8574)
+++ branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Interfaces/IDoubleValueCrossover.cs	(revision 8574)
@@ -0,0 +1,33 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Encodings.ParameterConfigurationEncoding {
+  /// <summary>
+  /// An interface which represents a crossover operator for double values.
+  /// </summary>
+  public interface IDoubleValueCrossover : ICrossover {
+    void Apply(IRandom random, DoubleValue value, DoubleValue other, DoubleValueRange range);
+  }
+}
Index: branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Interfaces/IDoubleValueManipulator.cs
===================================================================
--- branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Interfaces/IDoubleValueManipulator.cs	(revision 8574)
+++ branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Interfaces/IDoubleValueManipulator.cs	(revision 8574)
@@ -0,0 +1,32 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Encodings.ParameterConfigurationEncoding {
+  /// <summary>
+  /// An interface which represents a manipulation operator for double values.
+  /// </summary>
+  public interface IDoubleValueManipulator : IValueManipulator {
+    void Apply(IRandom random, DoubleValue value, DoubleValueRange range);
+  }
+}
Index: branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Interfaces/IIntValueCrossover.cs
===================================================================
--- branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Interfaces/IIntValueCrossover.cs	(revision 8574)
+++ branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Interfaces/IIntValueCrossover.cs	(revision 8574)
@@ -0,0 +1,33 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Encodings.ParameterConfigurationEncoding {
+  /// <summary>
+  /// An interface which represents a crossover operator for integer values.
+  /// </summary>
+  public interface IIntValueCrossover : ICrossover {
+    void Apply(IRandom random, IntValue value, IntValue other, IntValueRange range);
+  }
+}
Index: branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Interfaces/IIntValueManipulator.cs
===================================================================
--- branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Interfaces/IIntValueManipulator.cs	(revision 8574)
+++ branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Interfaces/IIntValueManipulator.cs	(revision 8574)
@@ -0,0 +1,32 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Encodings.ParameterConfigurationEncoding {
+  /// <summary>
+  /// An interface which represents a manipulation operator for integer values.
+  /// </summary>
+  public interface IIntValueManipulator : IValueManipulator {
+    void Apply(IRandom random, IntValue value, IntValueRange range);
+  }
+}
Index: branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Interfaces/IValueManipulator.cs
===================================================================
--- branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Interfaces/IValueManipulator.cs	(revision 8574)
+++ branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Interfaces/IValueManipulator.cs	(revision 8574)
@@ -0,0 +1,30 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Encodings.ParameterConfigurationEncoding {
+  /// <summary>
+  /// An interface which represents a manipulation operator for values.
+  /// </summary>
+  public interface IValueManipulator : IManipulator {
+  }
+}
Index: branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Manipulators/DoubleValue/NormalDoubleValueManipulator.cs
===================================================================
--- branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Manipulators/DoubleValue/NormalDoubleValueManipulator.cs	(revision 8574)
+++ branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Manipulators/DoubleValue/NormalDoubleValueManipulator.cs	(revision 8574)
@@ -0,0 +1,71 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.ParameterConfigurationEncoding {
+  /// <summary>
+  /// An operator which manipulates two double values. TODO
+  /// </summary>
+  [Item("NormalDoubleValueManipulator", "An operator which manipulates two double values. TODO")]
+  [StorableClass]
+  public class NormalDoubleValueManipulator : SingleSuccessorOperator, IDoubleValueManipulator, IStochasticOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    #region Constructors and Cloning
+    public NormalDoubleValueManipulator() : base() { }
+
+    [StorableConstructor]
+    protected NormalDoubleValueManipulator(bool deserializing) : base(deserializing) { }
+    protected NormalDoubleValueManipulator(NormalDoubleValueManipulator original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new NormalDoubleValueManipulator(this, cloner);
+    }
+    #endregion
+
+    // TODO: override Apply
+    public void Apply(IRandom random, DoubleValue value, DoubleValueRange range) {
+      ApplyStatic(random, value, range);
+    }
+
+    public static void ApplyStatic(IRandom random, DoubleValue value, DoubleValueRange range) {
+      var strategy = new RealVector(new double[] { (range.UpperBound.Value - range.LowerBound.Value) / 10 });
+      var vector = new RealVector(1);
+      double val = value.Value;
+
+      do {
+        vector[0] = val;
+        NormalAllPositionsManipulator.Apply(random, vector, strategy);
+        value.Value = vector[0];
+        value.Value = range.ApplyStepSize(value.Value);
+      } while (!range.IsInRange(value.Value));
+    }
+  }
+}
Index: branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Manipulators/DoubleValue/UniformDoubleValueManipulator.cs
===================================================================
--- branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Manipulators/DoubleValue/UniformDoubleValueManipulator.cs	(revision 8574)
+++ branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Manipulators/DoubleValue/UniformDoubleValueManipulator.cs	(revision 8574)
@@ -0,0 +1,73 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.ParameterConfigurationEncoding {
+  /// <summary>
+  /// An operator which manipulates two double values. TODO
+  /// </summary>
+  [Item("UniformDoubleValueManipulator", "An operator which manipulates two double values. TODO")]
+  [StorableClass]
+  public class UniformDoubleValueManipulator : SingleSuccessorOperator, IDoubleValueManipulator, IStochasticOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    #region Constructors and Cloning
+    public UniformDoubleValueManipulator() : base() { }
+
+    [StorableConstructor]
+    protected UniformDoubleValueManipulator(bool deserializing) : base(deserializing) { }
+    protected UniformDoubleValueManipulator(UniformDoubleValueManipulator original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new UniformDoubleValueManipulator(this, cloner);
+    }
+    #endregion
+
+    // TODO: override Apply
+    public void Apply(IRandom random, DoubleValue value, DoubleValueRange range) {
+      ApplyStatic(random, value, range);
+    }
+
+    public static void ApplyStatic(IRandom random, DoubleValue value, DoubleValueRange range) {
+      var vector = new RealVector(1);
+      var bounds = new DoubleMatrix(1, 2);
+      bounds[0, 0] = range.LowerBound.Value;
+      bounds[0, 1] = range.UpperBound.Value;
+      double val = value.Value;
+
+      do {
+        vector[0] = val;
+        UniformOnePositionManipulator.Apply(random, vector, bounds);
+        value.Value = vector[0];
+        value.Value = range.ApplyStepSize(value.Value);
+      } while (!range.IsInRange(value.Value));
+    }
+  }
+}
Index: branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Manipulators/IntValue/NormalIntValueManipulator.cs
===================================================================
--- branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Manipulators/IntValue/NormalIntValueManipulator.cs	(revision 8574)
+++ branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Manipulators/IntValue/NormalIntValueManipulator.cs	(revision 8574)
@@ -0,0 +1,72 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.ParameterConfigurationEncoding {
+  /// <summary>
+  /// An operator which manipulates two integer values. TODO
+  /// </summary>
+  [Item("NormalIntValueManipulator", "An operator which manipulates two integer values. TODO")]
+  [StorableClass]
+  public class NormalIntValueManipulator : SingleSuccessorOperator, IIntValueManipulator, IStochasticOperator {
+
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    #region Constructors and Cloning
+    public NormalIntValueManipulator() : base() { }
+
+    [StorableConstructor]
+    protected NormalIntValueManipulator(bool deserializing) : base(deserializing) { }
+    protected NormalIntValueManipulator(NormalIntValueManipulator original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new NormalIntValueManipulator(this, cloner);
+    }
+    #endregion
+
+    // TODO: override Apply
+    public void Apply(IRandom random, IntValue value, IntValueRange range) {
+      ApplyStatic(random, value, range);
+    }
+
+    public static void ApplyStatic(IRandom random, IntValue value, IntValueRange range) {
+      var strategy = new RealVector(new double[] { (range.UpperBound.Value - range.LowerBound.Value) / 10 });
+      var vector = new RealVector(new double[] { value.Value });
+      int val = value.Value;
+
+      do {
+        vector[0] = val;
+        NormalAllPositionsManipulator.Apply(random, vector, strategy);
+        value.Value = (int)vector[0];
+        value.Value = range.ApplyStepSize(value.Value);
+      } while (!range.IsInRange(value.Value));
+    }
+  }
+}
Index: branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Manipulators/IntValue/UniformIntValueManipulator.cs
===================================================================
--- branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Manipulators/IntValue/UniformIntValueManipulator.cs	(revision 8574)
+++ branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Operators/Manipulators/IntValue/UniformIntValueManipulator.cs	(revision 8574)
@@ -0,0 +1,71 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.ParameterConfigurationEncoding {
+  /// <summary>
+  /// An operator which manipulates two integer values. TODO
+  /// </summary>
+  [Item("UniformIntValueManipulator", "An operator which manipulates two integer values. TODO")]
+  [StorableClass]
+  public class UniformIntValueManipulator : SingleSuccessorOperator, IIntValueManipulator, IStochasticOperator {
+
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    #region Constructors and Cloning
+    public UniformIntValueManipulator() : base() { }
+
+    [StorableConstructor]
+    protected UniformIntValueManipulator(bool deserializing) : base(deserializing) { }
+    protected UniformIntValueManipulator(UniformIntValueManipulator original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new UniformIntValueManipulator(this, cloner);
+    }
+    #endregion
+
+    // TODO: override Apply
+    public void Apply(IRandom random, IntValue value, IntValueRange range) {
+      ApplyStatic(random, value, range);
+    }
+
+    public static void ApplyStatic(IRandom random, IntValue value, IntValueRange range) {
+      var vector = new IntegerVector(new int[] { value.Value });
+      int val = value.Value;
+
+      do {
+        vector[0] = val;
+        UniformOnePositionManipulator.Apply(random, vector, new IntMatrix(new int[,] { { range.LowerBound.Value, range.UpperBound.Value } }));
+        value.Value = vector[0];
+        value.Value = range.ApplyStepSize(value.Value);
+      } while (!range.IsInRange(value.Value));
+    }
+  }
+}
Index: branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/ParameterConfigurationTree.cs
===================================================================
--- branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/ParameterConfigurationTree.cs	(revision 8535)
+++ branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/ParameterConfigurationTree.cs	(revision 8574)
@@ -166,16 +166,4 @@
       get { return parameters; }
       set { parameters = value; }
-    }
-
-    [Storable]
-    private double experimentGenerationProgress;
-    public double ExperimentGenerationProgress {
-      get { return experimentGenerationProgress; }
-      private set {
-        if (experimentGenerationProgress != value) {
-          experimentGenerationProgress = value;
-          OnExperimentGenerationProgressChanged();
-        }
-      }
     }
 
@@ -291,10 +279,4 @@
       CombinationsCount = GetCombinationCount(0);
     }
-
-    public event EventHandler ExperimentGenerationProgressChanged;
-    private void OnExperimentGenerationProgressChanged() {
-      var handler = ExperimentGenerationProgressChanged;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
     #endregion
 
@@ -308,44 +290,4 @@
 
       algorithm.CollectParameterValues(this.Parameters);
-    }
-
-    public Experiment GenerateExperiment(IAlgorithm algorithm, bool createBatchRuns, int repetitions, Dictionary<IProblemInstanceProvider, HashSet<IDataDescriptor>> problemInstances, CancellationToken ct) {
-      Experiment experiment = new Experiment();
-      var algorithms = new List<IAlgorithm>(1 + problemInstances.Values.Count) { (IAlgorithm)algorithm.Clone() };
-      foreach (var provider in problemInstances) {
-        foreach (var descriptor in provider.Value) {
-          var alg = (IAlgorithm)algorithm.Clone();
-          ProblemInstanceManager.LoadData(provider.Key, descriptor, (IProblemInstanceConsumer)alg.Problem);
-          algorithms.Add(alg);
-        }
-      }
-      ExperimentGenerationProgress = 0;
-      foreach (var alg in algorithms) {
-        foreach (ParameterizedValueConfiguration combination in this) {
-          ct.ThrowIfCancellationRequested();
-          var clonedAlg = (IAlgorithm)alg.Clone();
-          clonedAlg.Name = combination.ParameterInfoString;
-          combination.Parameterize(clonedAlg);
-          clonedAlg.StoreAlgorithmInEachRun = false;
-          if (createBatchRuns) {
-            BatchRun batchRun = new BatchRun(string.Format("BatchRun: {0}", combination.ParameterInfoString));
-            batchRun.Optimizer = clonedAlg;
-            batchRun.Repetitions = repetitions;
-            experiment.Optimizers.Add(batchRun);
-          } else {
-            experiment.Optimizers.Add(clonedAlg);
-          }
-          ExperimentGenerationProgress = (double)experiment.Optimizers.Count / (this.GetCombinationCount(0) * algorithms.Count);
-        }
-      }
-      return experiment;
-    }
-
-    public Experiment GenerateExperiment(IAlgorithm algorithm) {
-      return GenerateExperiment(algorithm, false, 0, null, CancellationToken.None);
-    }
-
-    public Experiment GenerateExperiment(IAlgorithm algorithm, bool createBatchRuns, int repetitions) {
-      return GenerateExperiment(algorithm, createBatchRuns, repetitions, null, CancellationToken.None);
     }
 
Index: branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/ParameterConfigurations/ParameterConfiguration.cs
===================================================================
--- branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/ParameterConfigurations/ParameterConfiguration.cs	(revision 8535)
+++ branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/ParameterConfigurations/ParameterConfiguration.cs	(revision 8574)
@@ -573,7 +573,24 @@
         }
       }
+
       var clonedValue = this.ActualValue.Value != null ? (IItem)this.ActualValue.Value.Clone() : null;
       if (clonedValue != null) AdaptValidValues(parameter, clonedValue);
-      parameter.Value = clonedValue;
+
+      if (!(parameter is IFixedValueParameter)) {
+        parameter.Value = clonedValue;
+      } else {
+        var original = (dynamic)parameter.Value;
+        var clone = (dynamic)clonedValue;
+        if (typeof(ValueTypeValue<>).IsAssignableFrom(parameter.DataType) && !original.ReadOnly) {
+          original.Value = clone.Value;
+        } else if (typeof(ValueTypeArray<>).IsAssignableFrom(parameter.DataType) && !original.ReadOnly) {
+          for (int i = 0; i < original.Length; i++)
+            original[i] = clone[i];
+        } else if (typeof(ValueTypeMatrix<>).IsAssignableFrom(parameter.DataType) && !original.ReadOnly) {
+          for (int i = 0; i < original.Rows; i++)
+            for (int j = 0; j < original.Columns; j++)
+              original[i, j] = clone[i, j];
+        } // StringConvertibleValueTuple<,> not supported
+      }
     }
 
Index: branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Plugin.cs.frame
===================================================================
--- branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Plugin.cs.frame	(revision 8535)
+++ branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/Plugin.cs.frame	(revision 8574)
@@ -33,10 +33,15 @@
   [PluginDependency("HeuristicLab.Core", "3.3")]
   [PluginDependency("HeuristicLab.Data", "3.3")]
+  [PluginDependency("HeuristicLab.Encodings.IntegerVectorEncoding", "3.3")]
+  [PluginDependency("HeuristicLab.Encodings.RealVectorEncoding", "3.3")]
   [PluginDependency("HeuristicLab.Encodings.SymbolicExpressionTreeEncoding", "3.4")]
+  [PluginDependency("HeuristicLab.Operators", "3.3")]
   [PluginDependency("HeuristicLab.Optimization", "3.3")]
   [PluginDependency("HeuristicLab.Parameters", "3.3")]
   [PluginDependency("HeuristicLab.Persistence", "3.3")]
+  [PluginDependency("HeuristicLab.Problems.DataAnalysis", "3.4")]
   [PluginDependency("HeuristicLab.Problems.DataAnalysis.Symbolic", "3.4")]
   [PluginDependency("HeuristicLab.Problems.Instances", "3.3")]
+  [PluginDependency("HeuristicLab.Random", "3.3")]
   public class HeuristicLabEncodingsParameterConfigurationEncodingPlugin : PluginBase {
   }
Index: branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/RangeConstraints/Range.cs
===================================================================
--- branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/RangeConstraints/Range.cs	(revision 8535)
+++ branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/RangeConstraints/Range.cs	(revision 8574)
@@ -219,5 +219,4 @@
         errorMessage = "Could not parse range."; return false;
       }
-
       if (lowerBound.SetValue(parts2[0]) &&
           upperBound.SetValue(parts2[1]) &&
