Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/Crossovers/ParameterConfigurationCrossover.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/Crossovers/ParameterConfigurationCrossover.cs	(revision 5927)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/Crossovers/ParameterConfigurationCrossover.cs	(revision 6017)
@@ -1,12 +1,10 @@
-﻿using HeuristicLab.Common;
+﻿using System;
+using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
 using HeuristicLab.Encodings.IntegerVectorEncoding;
-using HeuristicLab.Encodings.RealVectorEncoding;
 using HeuristicLab.Operators;
-using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using System;
 
 namespace HeuristicLab.Problems.MetaOptimization {
@@ -96,7 +94,7 @@
     }
 
-    private static void Cross(IRandom random, IOptimizable configuartion, IOptimizable other, IIntValueCrossover intValueCrossover, IDoubleValueCrossover doubleValueCrossover) {
-      var vc = configuartion as RangeValueConfiguration;
-      var pc = configuartion as IParameterConfiguration;
+    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;
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/Manipulators/ParameterConfigurationManipulator.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/Manipulators/ParameterConfigurationManipulator.cs	(revision 5927)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/Manipulators/ParameterConfigurationManipulator.cs	(revision 6017)
@@ -51,5 +51,5 @@
     }
 
-    protected static void Mutate(IRandom random, IOptimizable configuration, IIntValueManipulator intValueManipulator, IDoubleValueManipulator doubleValueManipulator) {
+    public static void Mutate(IRandom random, IOptimizable configuration, IIntValueManipulator intValueManipulator, IDoubleValueManipulator doubleValueManipulator) {
       var vc = configuration as RangeValueConfiguration;
       var pc = configuration as IParameterConfiguration;
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/ParameterConfigurations/ParameterConfiguration.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/ParameterConfigurations/ParameterConfiguration.cs	(revision 5927)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/ParameterConfigurations/ParameterConfiguration.cs	(revision 6017)
@@ -138,6 +138,15 @@
     protected IItemSet<IItem> validValues;
 
+    [Storable]
+    private bool autoPopulateValueConfigurations = true;
+    public bool AutoPopulateValueConfigurations {
+      get { return autoPopulateValueConfigurations; }
+      set { autoPopulateValueConfigurations = value; }
+    }
+    
+
     #region Constructors and Cloning
     public ParameterConfiguration(string parameterName, IValueParameter valueParameter, bool discoverValidValues) {
+      this.AutoPopulateValueConfigurations = true;
       this.ParameterName = parameterName;
       this.parameterDataType = valueParameter.GetType();
@@ -162,4 +171,5 @@
     }
     public ParameterConfiguration(string parameterName, Type type, IItem actualValue, IEnumerable<IValueConfiguration> valueConfigurations) {
+      this.AutoPopulateValueConfigurations = false;
       this.ParameterName = parameterName;
       this.parameterDataType = type;
@@ -174,4 +184,5 @@
     }
     public ParameterConfiguration(string parameterName, Type type, IItem actualValue) {
+      this.AutoPopulateValueConfigurations = true;
       this.ParameterName = parameterName;
       this.parameterDataType = type;
@@ -206,4 +217,5 @@
       this.discoverValidValues = original.discoverValidValues;
       if (this.valueConfigurations != null) RegisterValueConfigurationEvents();
+      this.AutoPopulateValueConfigurations = original.AutoPopulateValueConfigurations;
     }
 
@@ -238,4 +250,7 @@
 
     protected virtual void PopulateValueConfigurations() {
+      if (!this.AutoPopulateValueConfigurations)
+        return;
+
       foreach (Type t in this.validTypes) {
         if (t == typeof(NullValue)) {
@@ -266,4 +281,7 @@
 
     protected virtual void ClearValueConfigurations() {
+      if (!this.AutoPopulateValueConfigurations)
+        return;
+
       this.ValueConfigurations.Clear();
     }
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Evaluators/AlgorithmEvaluator.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Evaluators/AlgorithmEvaluator.cs	(revision 5927)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Evaluators/AlgorithmEvaluator.cs	(revision 6017)
@@ -1,11 +1,14 @@
 ﻿using System;
 using System.Diagnostics;
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Operators;
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis.Symbolic.Regression;
 
 namespace HeuristicLab.Problems.MetaOptimization {
@@ -54,9 +57,14 @@
       IAlgorithm algorithm = AlgorithmParameter.ActualValue;
 
+      #region Debug Code for SymbolicRegressionGrammar
+      var srp = (SymbolicRegressionSingleObjectiveProblem)algorithm.Problem;
+      //Console.WriteLine("Evaluating Grammar: " + PrintGrammar(srp.SymbolicExpressionTreeGrammar));
+      #endregion
+
       var sw = new Stopwatch();
       sw.Start();
       algorithm.StartSync();
       sw.Stop();
-      Console.WriteLine("{0},{1}: {2}", ProblemIndexParameter.ActualValue.Value, RepetitionIndexParameter.ActualValue.Value, sw.Elapsed);
+      Console.WriteLine("{0},{1}: {2} (Grammar: {3})", ProblemIndexParameter.ActualValue.Value, RepetitionIndexParameter.ActualValue.Value, sw.Elapsed, PrintGrammar(srp.SymbolicExpressionTreeGrammar));
 
       RunsParameter.Value = new ItemList<IRun>(algorithm.Runs);
@@ -72,4 +80,12 @@
       parameterConfiguration.Randomize(random);
     }
+
+    // for debug purposes, remove later
+    private static string PrintGrammar(ISymbolicExpressionGrammar grammar) {
+      return string.Join(string.Empty, grammar.Symbols.Select(x => x.InitialFrequency).ToArray());
+      //foreach (var symbol in grammar.Symbols) {
+      //  Console.WriteLine("{0} ({1})", symbol.ToString(), symbol.InitialFrequency);
+      //}
+    }
   }
 }
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/HeuristicLab.Problems.MetaOptimization-3.3.csproj
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/HeuristicLab.Problems.MetaOptimization-3.3.csproj	(revision 5927)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/HeuristicLab.Problems.MetaOptimization-3.3.csproj	(revision 6017)
@@ -126,4 +126,7 @@
       <HintPath>..\..\..\..\..\..\..\Program Files\HeuristicLab 3.3\HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.dll</HintPath>
     </Reference>
+    <Reference Include="HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4">
+      <HintPath>..\..\..\..\..\..\..\Program Files\HeuristicLab 3.3\HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4.dll</HintPath>
+    </Reference>
     <Reference Include="HeuristicLab.Problems.TestFunctions-3.3">
       <HintPath>C:\Program Files\HeuristicLab 3.3\HeuristicLab.Problems.TestFunctions-3.3.dll</HintPath>
@@ -154,6 +157,6 @@
     <Compile Include="Encoding\AlgorithmProblemItem.cs" />
     <Compile Include="Encoding\ParameterConfigurations\SingleValuedParameterConfiguration.cs" />
-    <Compile Include="Encoding\SymbolicRegression\SymbolValueConfiguration.cs" />
-    <Compile Include="Encoding\SymbolicRegression\SymbolicExpressionGrammarValueConfiguration.cs" />
+    <Compile Include="Encoding\SymbolicExpressionGrammar\SymbolValueConfiguration.cs" />
+    <Compile Include="Encoding\SymbolicExpressionGrammar\SymbolicExpressionGrammarValueConfiguration.cs" />
     <Compile Include="Encoding\ValueConfigurations\RangeValueConfiguration.cs" />
     <Compile Include="Encoding\ValueConfigurations\ParameterizedValueConfiguration.cs" />
@@ -163,5 +166,5 @@
     <Compile Include="Evaluators\PMOEvaluator.cs" />
     <Compile Include="MetaOptimizationUtil.cs" />
-    <Compile Include="Operators\Crossovers\MultiIntValueCrossover.cs" />
+    <Compile Include="Operators\Crossovers\IntValue\MultiIntValueCrossover.cs" />
     <Compile Include="TypeValue.cs" />
     <None Include="Properties\AssemblyInfo.cs.frame" />
@@ -189,10 +192,10 @@
     <Compile Include="Interfaces\IParameterConfigurationCrossover.cs" />
     <Compile Include="Interfaces\ICheckedValueConfigurationCollection.cs" />
-    <Compile Include="Operators\Crossovers\AverageDoubleValueCrossover.cs" />
-    <Compile Include="Operators\Crossovers\AverageIntValueCrossover.cs" />
-    <Compile Include="Operators\Crossovers\NormalIntValueCrossover.cs" />
-    <Compile Include="Operators\Crossovers\NormalDoubleValueCrossover.cs" />
-    <Compile Include="Operators\Crossovers\DiscreteDoubleValueCrossover.cs" />
-    <Compile Include="Operators\Crossovers\DiscreteIntValueCrossover.cs" />
+    <Compile Include="Operators\Crossovers\DoubleValue\AverageDoubleValueCrossover.cs" />
+    <Compile Include="Operators\Crossovers\IntValue\AverageIntValueCrossover.cs" />
+    <Compile Include="Operators\Crossovers\IntValue\NormalIntValueCrossover.cs" />
+    <Compile Include="Operators\Crossovers\DoubleValue\NormalDoubleValueCrossover.cs" />
+    <Compile Include="Operators\Crossovers\DoubleValue\DiscreteDoubleValueCrossover.cs" />
+    <Compile Include="Operators\Crossovers\IntValue\DiscreteIntValueCrossover.cs" />
     <Compile Include="Operators\Interfaces\IDoubleValueCrossover.cs" />
     <Compile Include="Operators\Interfaces\IDoubleValueManipulator.cs" />
@@ -213,8 +216,8 @@
     <Compile Include="Operators\Interfaces\IIntValueCrossover.cs" />
     <Compile Include="Operators\Interfaces\IValueManipulator.cs" />
-    <Compile Include="Operators\Manipulators\NormalIntValueManipulator.cs" />
-    <Compile Include="Operators\Manipulators\UniformIntValueManipulator.cs" />
-    <Compile Include="Operators\Manipulators\UniformDoubleValueManipulator.cs" />
-    <Compile Include="Operators\Manipulators\NormalDoubleValueManipulator.cs" />
+    <Compile Include="Operators\Manipulators\IntValue\NormalIntValueManipulator.cs" />
+    <Compile Include="Operators\Manipulators\IntValue\UniformIntValueManipulator.cs" />
+    <Compile Include="Operators\Manipulators\DoubleValue\UniformDoubleValueManipulator.cs" />
+    <Compile Include="Operators\Manipulators\DoubleValue\NormalDoubleValueManipulator.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="MetaOptimizationProblem.cs" />
@@ -225,5 +228,7 @@
     <None Include="UpdateLocalInstallation.cmd" />
   </ItemGroup>
-  <ItemGroup />
+  <ItemGroup>
+    <Folder Include="Operators\Crossovers\SymbolicExpressionGrammar\" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <PropertyGroup>
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/MetaOptimizationProblem.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/MetaOptimizationProblem.cs	(revision 5927)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/MetaOptimizationProblem.cs	(revision 6017)
@@ -309,5 +309,4 @@
       }
       ParameterConfigurationTreeParameter.ActualValue = new ParameterConfigurationTree(algorithm, Problems.First());
-      
     }
   }
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/AverageDoubleValueCrossover.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/AverageDoubleValueCrossover.cs	(revision 5927)
+++ 	(revision )
@@ -1,39 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Operators;
-using HeuristicLab.Optimization;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Core;
-using HeuristicLab.Parameters;
-using HeuristicLab.Common;
-using HeuristicLab.Data;
-
-namespace HeuristicLab.Problems.MetaOptimization {
-  [StorableClass]
-  public class AverageDoubleValueCrossover : SingleSuccessorOperator, IDoubleValueCrossover, IStochasticOperator {
-    public ILookupParameter<IRandom> RandomParameter {
-      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
-    }
-
-    public AverageDoubleValueCrossover() { }
-    [StorableConstructor]
-    protected AverageDoubleValueCrossover(bool deserializing) : base(deserializing) { }
-    protected AverageDoubleValueCrossover(AverageDoubleValueCrossover original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new AverageDoubleValueCrossover(this, cloner);
-    }
-
-    public void Apply(IRandom random, DoubleValue value, DoubleValue other, DoubleValueRange range) {
-      ApplyStatic(random, value, other, range);
-    }
-
-    public static void ApplyStatic(IRandom random, DoubleValue value, DoubleValue other, DoubleValueRange range) {
-      value.Value = (value.Value + other.Value) / 2;
-      value.Value = range.ApplyStepSize(value.Value);
-    }
-  }
-}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/AverageIntValueCrossover.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/AverageIntValueCrossover.cs	(revision 5927)
+++ 	(revision )
@@ -1,38 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Operators;
-using HeuristicLab.Optimization;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Core;
-using HeuristicLab.Parameters;
-using HeuristicLab.Common;
-using HeuristicLab.Data;
-
-namespace HeuristicLab.Problems.MetaOptimization {
-  [StorableClass]
-  public class AverageIntValueCrossover : SingleSuccessorOperator, IIntValueCrossover, IStochasticOperator {
-    public ILookupParameter<IRandom> RandomParameter {
-      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
-    }
-
-    public AverageIntValueCrossover() { }
-    [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);
-    }
-
-    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/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/DiscreteDoubleValueCrossover.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/DiscreteDoubleValueCrossover.cs	(revision 5927)
+++ 	(revision )
@@ -1,40 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Operators;
-using HeuristicLab.Optimization;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Core;
-using HeuristicLab.Parameters;
-using HeuristicLab.Common;
-using HeuristicLab.Data;
-
-namespace HeuristicLab.Problems.MetaOptimization {
-  [StorableClass]
-  public class DiscreteDoubleValueCrossover : SingleSuccessorOperator, IDoubleValueCrossover, IStochasticOperator {
-    public ILookupParameter<IRandom> RandomParameter {
-      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
-    }
-
-    public DiscreteDoubleValueCrossover() { }
-    [StorableConstructor]
-    protected DiscreteDoubleValueCrossover(bool deserializing) : base(deserializing) { }
-    protected DiscreteDoubleValueCrossover(DiscreteDoubleValueCrossover original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new DiscreteDoubleValueCrossover(this, cloner);
-    }
-
-    public void Apply(IRandom random, DoubleValue value, DoubleValue other, DoubleValueRange range) {
-      ApplyStatic(random, value, other, range);
-    }
-
-    public static void ApplyStatic(IRandom random, DoubleValue value, DoubleValue other, DoubleValueRange range) {
-      if (random.NextDouble() > 0.5) {
-        value.Value = other.Value;
-      }
-    }
-  }
-}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/DiscreteIntValueCrossover.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/DiscreteIntValueCrossover.cs	(revision 5927)
+++ 	(revision )
@@ -1,40 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Operators;
-using HeuristicLab.Optimization;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Core;
-using HeuristicLab.Parameters;
-using HeuristicLab.Common;
-using HeuristicLab.Data;
-
-namespace HeuristicLab.Problems.MetaOptimization {
-  [StorableClass]
-  public class DiscreteIntValueCrossover : SingleSuccessorOperator, IIntValueCrossover, IStochasticOperator {
-    public ILookupParameter<IRandom> RandomParameter {
-      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
-    }
-
-    public DiscreteIntValueCrossover() { }
-    [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);
-    }
-
-    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/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/DoubleValue/AverageDoubleValueCrossover.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/DoubleValue/AverageDoubleValueCrossover.cs	(revision 6017)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/DoubleValue/AverageDoubleValueCrossover.cs	(revision 6017)
@@ -0,0 +1,39 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Parameters;
+using HeuristicLab.Common;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.MetaOptimization {
+  [StorableClass]
+  public class AverageDoubleValueCrossover : SingleSuccessorOperator, IDoubleValueCrossover, IStochasticOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    public AverageDoubleValueCrossover() { }
+    [StorableConstructor]
+    protected AverageDoubleValueCrossover(bool deserializing) : base(deserializing) { }
+    protected AverageDoubleValueCrossover(AverageDoubleValueCrossover original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new AverageDoubleValueCrossover(this, cloner);
+    }
+
+    public void Apply(IRandom random, DoubleValue value, DoubleValue other, DoubleValueRange range) {
+      ApplyStatic(random, value, other, range);
+    }
+
+    public static void ApplyStatic(IRandom random, DoubleValue value, DoubleValue other, DoubleValueRange range) {
+      value.Value = (value.Value + other.Value) / 2;
+      value.Value = range.ApplyStepSize(value.Value);
+    }
+  }
+}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/DoubleValue/DiscreteDoubleValueCrossover.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/DoubleValue/DiscreteDoubleValueCrossover.cs	(revision 6017)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/DoubleValue/DiscreteDoubleValueCrossover.cs	(revision 6017)
@@ -0,0 +1,40 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Parameters;
+using HeuristicLab.Common;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.MetaOptimization {
+  [StorableClass]
+  public class DiscreteDoubleValueCrossover : SingleSuccessorOperator, IDoubleValueCrossover, IStochasticOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    public DiscreteDoubleValueCrossover() { }
+    [StorableConstructor]
+    protected DiscreteDoubleValueCrossover(bool deserializing) : base(deserializing) { }
+    protected DiscreteDoubleValueCrossover(DiscreteDoubleValueCrossover original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new DiscreteDoubleValueCrossover(this, cloner);
+    }
+
+    public void Apply(IRandom random, DoubleValue value, DoubleValue other, DoubleValueRange range) {
+      ApplyStatic(random, value, other, range);
+    }
+
+    public static void ApplyStatic(IRandom random, DoubleValue value, DoubleValue other, DoubleValueRange range) {
+      if (random.NextDouble() > 0.5) {
+        value.Value = other.Value;
+      }
+    }
+  }
+}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/DoubleValue/NormalDoubleValueCrossover.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/DoubleValue/NormalDoubleValueCrossover.cs	(revision 6017)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/DoubleValue/NormalDoubleValueCrossover.cs	(revision 6017)
@@ -0,0 +1,46 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Parameters;
+using HeuristicLab.Common;
+using HeuristicLab.Data;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.MetaOptimization {
+  [StorableClass]
+  public class NormalDoubleValueCrossover : SingleSuccessorOperator, IDoubleValueCrossover, IStochasticOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    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);
+    }
+
+    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));
+      var offspring = new DoubleValue();
+      do {
+        offspring.Value = N.NextDouble();
+        offspring.Value = range.ApplyStepSize(offspring.Value);
+      } while (!range.IsInRange(offspring.Value));
+      return offspring;
+    }
+  }
+}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/IntValue/AverageIntValueCrossover.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/IntValue/AverageIntValueCrossover.cs	(revision 6017)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/IntValue/AverageIntValueCrossover.cs	(revision 6017)
@@ -0,0 +1,38 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Parameters;
+using HeuristicLab.Common;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.MetaOptimization {
+  [StorableClass]
+  public class AverageIntValueCrossover : SingleSuccessorOperator, IIntValueCrossover, IStochasticOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    public AverageIntValueCrossover() { }
+    [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);
+    }
+
+    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/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/IntValue/DiscreteIntValueCrossover.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/IntValue/DiscreteIntValueCrossover.cs	(revision 6017)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/IntValue/DiscreteIntValueCrossover.cs	(revision 6017)
@@ -0,0 +1,40 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Parameters;
+using HeuristicLab.Common;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.MetaOptimization {
+  [StorableClass]
+  public class DiscreteIntValueCrossover : SingleSuccessorOperator, IIntValueCrossover, IStochasticOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    public DiscreteIntValueCrossover() { }
+    [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);
+    }
+
+    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/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/IntValue/MultiIntValueCrossover.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/IntValue/MultiIntValueCrossover.cs	(revision 6017)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/IntValue/MultiIntValueCrossover.cs	(revision 6017)
@@ -0,0 +1,47 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.PluginInfrastructure;
+using HeuristicLab.Data;
+using HeuristicLab.Core;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.MetaOptimization.Operators.Crossovers {
+  [Item("MultiIntValueCrossover", "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; }
+    }
+
+    [StorableConstructor]
+    protected MultiIntValueCrossover(bool deserializing) : base(deserializing) { }
+    public MultiIntValueCrossover() {
+      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);
+      }
+    }
+    protected MultiIntValueCrossover(MultiIntValueCrossover original, Cloner cloner) : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MultiIntValueCrossover(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      if (Operators.Count == 0) throw new InvalidOperationException(Name + ": Please add at least one permutation crossover to choose from.");
+      return base.Apply();
+    }
+
+    public void Apply(IRandom random, IntValue value, IntValue other, IntValueRange range) {
+
+    }
+  }
+}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/IntValue/NormalIntValueCrossover.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/IntValue/NormalIntValueCrossover.cs	(revision 6017)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/IntValue/NormalIntValueCrossover.cs	(revision 6017)
@@ -0,0 +1,45 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Parameters;
+using HeuristicLab.Common;
+using HeuristicLab.Data;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.MetaOptimization {
+  [StorableClass]
+  public class NormalIntValueCrossover : SingleSuccessorOperator, IIntValueCrossover, IStochasticOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    public NormalIntValueCrossover() { }
+    [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);
+    }
+
+    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));
+      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/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/MultiIntValueCrossover.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/MultiIntValueCrossover.cs	(revision 5927)
+++ 	(revision )
@@ -1,47 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Operators;
-using HeuristicLab.Optimization;
-using HeuristicLab.PluginInfrastructure;
-using HeuristicLab.Data;
-using HeuristicLab.Core;
-using HeuristicLab.Common;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Problems.MetaOptimization.Operators.Crossovers {
-  [Item("MultiIntValueCrossover", "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; }
-    }
-
-    [StorableConstructor]
-    protected MultiIntValueCrossover(bool deserializing) : base(deserializing) { }
-    public MultiIntValueCrossover() {
-      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);
-      }
-    }
-    protected MultiIntValueCrossover(MultiIntValueCrossover original, Cloner cloner) : base(original, cloner) {
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new MultiIntValueCrossover(this, cloner);
-    }
-
-    public override IOperation Apply() {
-      if (Operators.Count == 0) throw new InvalidOperationException(Name + ": Please add at least one permutation crossover to choose from.");
-      return base.Apply();
-    }
-
-    public void Apply(IRandom random, IntValue value, IntValue other, IntValueRange range) {
-
-    }
-  }
-}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/NormalDoubleValueCrossover.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/NormalDoubleValueCrossover.cs	(revision 5927)
+++ 	(revision )
@@ -1,46 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Operators;
-using HeuristicLab.Optimization;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Core;
-using HeuristicLab.Parameters;
-using HeuristicLab.Common;
-using HeuristicLab.Data;
-using HeuristicLab.Random;
-
-namespace HeuristicLab.Problems.MetaOptimization {
-  [StorableClass]
-  public class NormalDoubleValueCrossover : SingleSuccessorOperator, IDoubleValueCrossover, IStochasticOperator {
-    public ILookupParameter<IRandom> RandomParameter {
-      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
-    }
-
-    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);
-    }
-
-    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));
-      var offspring = new DoubleValue();
-      do {
-        offspring.Value = N.NextDouble();
-        offspring.Value = range.ApplyStepSize(offspring.Value);
-      } while (!range.IsInRange(offspring.Value));
-      return offspring;
-    }
-  }
-}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/NormalIntValueCrossover.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/NormalIntValueCrossover.cs	(revision 5927)
+++ 	(revision )
@@ -1,45 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Operators;
-using HeuristicLab.Optimization;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Core;
-using HeuristicLab.Parameters;
-using HeuristicLab.Common;
-using HeuristicLab.Data;
-using HeuristicLab.Random;
-
-namespace HeuristicLab.Problems.MetaOptimization {
-  [StorableClass]
-  public class NormalIntValueCrossover : SingleSuccessorOperator, IIntValueCrossover, IStochasticOperator {
-    public ILookupParameter<IRandom> RandomParameter {
-      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
-    }
-
-    public NormalIntValueCrossover() { }
-    [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);
-    }
-
-    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));
-      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/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/SymbolicExpressionGrammar/SymbolicExpressionGrammarCrossover.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/SymbolicExpressionGrammar/SymbolicExpressionGrammarCrossover.cs	(revision 6017)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/SymbolicExpressionGrammar/SymbolicExpressionGrammarCrossover.cs	(revision 6017)
@@ -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.Problems.MetaOptimization {
+  [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/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Manipulators/DoubleValue/NormalDoubleValueManipulator.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Manipulators/DoubleValue/NormalDoubleValueManipulator.cs	(revision 6017)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Manipulators/DoubleValue/NormalDoubleValueManipulator.cs	(revision 6017)
@@ -0,0 +1,52 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Parameters;
+using HeuristicLab.Common;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.MetaOptimization {
+  [StorableClass]
+  public class NormalDoubleValueManipulator : SingleSuccessorOperator, IDoubleValueManipulator, IStochasticOperator {
+
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    public NormalDoubleValueManipulator() { }
+    [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);
+    }
+    
+    // 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) {
+      bool ok = false;
+      var strategy = new RealVector(new double[] { (range.UpperBound.Value - range.LowerBound.Value) / 10}); // todo: add strategy parameter
+      var vector = new RealVector(1);
+      double val = value.Value;
+
+      while (!ok) { 
+        vector[0] = val;
+        NormalAllPositionsManipulator.Apply(random, vector, strategy);
+        value.Value = vector[0];
+        value.Value = range.ApplyStepSize(value.Value);
+        ok = range.IsInRange(value.Value);
+      }
+    }
+  }
+}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Manipulators/DoubleValue/UniformDoubleValueManipulator.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Manipulators/DoubleValue/UniformDoubleValueManipulator.cs	(revision 6017)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Manipulators/DoubleValue/UniformDoubleValueManipulator.cs	(revision 6017)
@@ -0,0 +1,54 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Parameters;
+using HeuristicLab.Common;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.MetaOptimization {
+  [StorableClass]
+  public class UniformDoubleValueManipulator : SingleSuccessorOperator, IDoubleValueManipulator, IStochasticOperator {
+
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    public UniformDoubleValueManipulator() { }
+    [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);
+    }
+
+    // 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) {
+      bool ok = false;
+      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;
+
+      while (!ok) {
+        vector[0] = val;
+        UniformOnePositionManipulator.Apply(random, vector, bounds);
+        value.Value = vector[0];
+        value.Value = range.ApplyStepSize(value.Value);
+        ok = range.IsInRange(value.Value);
+      }
+    }
+  }
+}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Manipulators/IntValue/NormalIntValueManipulator.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Manipulators/IntValue/NormalIntValueManipulator.cs	(revision 6017)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Manipulators/IntValue/NormalIntValueManipulator.cs	(revision 6017)
@@ -0,0 +1,54 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Parameters;
+using HeuristicLab.Common;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+
+namespace HeuristicLab.Problems.MetaOptimization {
+  [StorableClass]
+  public class NormalIntValueManipulator : SingleSuccessorOperator, IIntValueManipulator, IStochasticOperator {
+
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    public NormalIntValueManipulator() { }
+    [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);
+    }
+
+    // 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) {
+      bool ok = false;
+      var strategy = new RealVector(new double[] { (range.UpperBound.Value - range.LowerBound.Value) / 10 }); // todo: add strategy parameter
+      var vector = new RealVector(new double[] { value.Value });
+      int val = value.Value;
+
+      while (!ok) {
+        vector[0] = val;
+        NormalAllPositionsManipulator.Apply(random, vector, strategy);
+        value.Value = (int)vector[0];
+        value.Value = range.ApplyStepSize(value.Value);
+        ok = range.IsInRange(value.Value);
+      }
+    }
+  }
+}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Manipulators/IntValue/UniformIntValueManipulator.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Manipulators/IntValue/UniformIntValueManipulator.cs	(revision 6017)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Manipulators/IntValue/UniformIntValueManipulator.cs	(revision 6017)
@@ -0,0 +1,52 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Parameters;
+using HeuristicLab.Common;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.MetaOptimization {
+  [StorableClass]
+  public class UniformIntValueManipulator : SingleSuccessorOperator, IIntValueManipulator, IStochasticOperator {
+
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    public UniformIntValueManipulator() { }
+    [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);
+    }
+
+    // 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) {
+      bool ok = false;
+      var vector = new IntegerVector(new int[] { value.Value });
+      int val = value.Value;
+
+      while (!ok) {
+        vector[0] = val;
+        UniformOnePositionManipulator.Apply(random, vector, range.LowerBound, new IntValue(range.UpperBound.Value + 1));
+        value.Value = vector[0];
+        value.Value = range.ApplyStepSize(value.Value);
+        ok = range.IsInRange(value.Value);
+      }
+    }
+  }
+}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Manipulators/NormalDoubleValueManipulator.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Manipulators/NormalDoubleValueManipulator.cs	(revision 5927)
+++ 	(revision )
@@ -1,52 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Operators;
-using HeuristicLab.Optimization;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Core;
-using HeuristicLab.Parameters;
-using HeuristicLab.Common;
-using HeuristicLab.Encodings.RealVectorEncoding;
-using HeuristicLab.Data;
-
-namespace HeuristicLab.Problems.MetaOptimization {
-  [StorableClass]
-  public class NormalDoubleValueManipulator : SingleSuccessorOperator, IDoubleValueManipulator, IStochasticOperator {
-
-    public ILookupParameter<IRandom> RandomParameter {
-      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
-    }
-
-    public NormalDoubleValueManipulator() { }
-    [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);
-    }
-    
-    // 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) {
-      bool ok = false;
-      var strategy = new RealVector(new double[] { (range.UpperBound.Value - range.LowerBound.Value) / 10}); // todo: add strategy parameter
-      var vector = new RealVector(1);
-      double val = value.Value;
-
-      while (!ok) { 
-        vector[0] = val;
-        NormalAllPositionsManipulator.Apply(random, vector, strategy);
-        value.Value = vector[0];
-        value.Value = range.ApplyStepSize(value.Value);
-        ok = range.IsInRange(value.Value);
-      }
-    }
-  }
-}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Manipulators/NormalIntValueManipulator.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Manipulators/NormalIntValueManipulator.cs	(revision 5927)
+++ 	(revision )
@@ -1,54 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Operators;
-using HeuristicLab.Optimization;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Core;
-using HeuristicLab.Parameters;
-using HeuristicLab.Common;
-using HeuristicLab.Encodings.IntegerVectorEncoding;
-using HeuristicLab.Data;
-using HeuristicLab.Encodings.RealVectorEncoding;
-
-namespace HeuristicLab.Problems.MetaOptimization {
-  [StorableClass]
-  public class NormalIntValueManipulator : SingleSuccessorOperator, IIntValueManipulator, IStochasticOperator {
-
-    public ILookupParameter<IRandom> RandomParameter {
-      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
-    }
-
-    public NormalIntValueManipulator() { }
-    [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);
-    }
-
-    // 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) {
-      bool ok = false;
-      var strategy = new RealVector(new double[] { (range.UpperBound.Value - range.LowerBound.Value) / 10 }); // todo: add strategy parameter
-      var vector = new RealVector(new double[] { value.Value });
-      int val = value.Value;
-
-      while (!ok) {
-        vector[0] = val;
-        NormalAllPositionsManipulator.Apply(random, vector, strategy);
-        value.Value = (int)vector[0];
-        value.Value = range.ApplyStepSize(value.Value);
-        ok = range.IsInRange(value.Value);
-      }
-    }
-  }
-}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Manipulators/UniformDoubleValueManipulator.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Manipulators/UniformDoubleValueManipulator.cs	(revision 5927)
+++ 	(revision )
@@ -1,54 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Operators;
-using HeuristicLab.Optimization;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Core;
-using HeuristicLab.Parameters;
-using HeuristicLab.Common;
-using HeuristicLab.Encodings.RealVectorEncoding;
-using HeuristicLab.Data;
-
-namespace HeuristicLab.Problems.MetaOptimization {
-  [StorableClass]
-  public class UniformDoubleValueManipulator : SingleSuccessorOperator, IDoubleValueManipulator, IStochasticOperator {
-
-    public ILookupParameter<IRandom> RandomParameter {
-      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
-    }
-
-    public UniformDoubleValueManipulator() { }
-    [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);
-    }
-
-    // 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) {
-      bool ok = false;
-      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;
-
-      while (!ok) {
-        vector[0] = val;
-        UniformOnePositionManipulator.Apply(random, vector, bounds);
-        value.Value = vector[0];
-        value.Value = range.ApplyStepSize(value.Value);
-        ok = range.IsInRange(value.Value);
-      }
-    }
-  }
-}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Manipulators/UniformIntValueManipulator.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Manipulators/UniformIntValueManipulator.cs	(revision 5927)
+++ 	(revision )
@@ -1,52 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Operators;
-using HeuristicLab.Optimization;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Core;
-using HeuristicLab.Parameters;
-using HeuristicLab.Common;
-using HeuristicLab.Encodings.IntegerVectorEncoding;
-using HeuristicLab.Data;
-
-namespace HeuristicLab.Problems.MetaOptimization {
-  [StorableClass]
-  public class UniformIntValueManipulator : SingleSuccessorOperator, IIntValueManipulator, IStochasticOperator {
-
-    public ILookupParameter<IRandom> RandomParameter {
-      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
-    }
-
-    public UniformIntValueManipulator() { }
-    [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);
-    }
-
-    // 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) {
-      bool ok = false;
-      var vector = new IntegerVector(new int[] { value.Value });
-      int val = value.Value;
-
-      while (!ok) {
-        vector[0] = val;
-        UniformOnePositionManipulator.Apply(random, vector, range.LowerBound, new IntValue(range.UpperBound.Value + 1));
-        value.Value = vector[0];
-        value.Value = range.ApplyStepSize(value.Value);
-        ok = range.IsInRange(value.Value);
-      }
-    }
-  }
-}
