Index: /branches/HeuristicLab.MetaOptimization/HeuristicLab.MetaOptimization.Test/HeuristicLab.MetaOptimization.Test.csproj
===================================================================
--- /branches/HeuristicLab.MetaOptimization/HeuristicLab.MetaOptimization.Test/HeuristicLab.MetaOptimization.Test.csproj	(revision 6016)
+++ /branches/HeuristicLab.MetaOptimization/HeuristicLab.MetaOptimization.Test/HeuristicLab.MetaOptimization.Test.csproj	(revision 6017)
@@ -379,5 +379,4 @@
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="PluginLoader.cs" />
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
Index: anches/HeuristicLab.MetaOptimization/HeuristicLab.MetaOptimization.Test/PluginLoader.cs
===================================================================
--- /branches/HeuristicLab.MetaOptimization/HeuristicLab.MetaOptimization.Test/PluginLoader.cs	(revision 6016)
+++ 	(revision )
@@ -1,27 +1,0 @@
-﻿
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Reflection;
-using HeuristicLab.PluginInfrastructure;
-
-namespace HeuristicLab.MetaOptimization.Test {
-  internal static class PluginLoader {
-    public const string AssemblyExtension = ".dll";
-    public static List<Assembly> pluginAssemblies;
-
-    static PluginLoader() {
-      foreach (string path in Directory.GetFiles(Environment.CurrentDirectory)
-        .Where(s => s.EndsWith(AssemblyExtension)))
-        Assembly.LoadFrom(path);
-
-      pluginAssemblies = AppDomain.CurrentDomain.GetAssemblies().Where(IsPluginAssembly).ToList();
-    }
-
-    private static bool IsPluginAssembly(Assembly assembly) {
-      return assembly.GetExportedTypes()
-        .Where(t => typeof(IPlugin).IsAssignableFrom(t) && !t.IsAbstract && !t.IsInterface).Any();
-    }
-  }
-}
Index: /branches/HeuristicLab.MetaOptimization/HeuristicLab.MetaOptimization.Test/Program.cs
===================================================================
--- /branches/HeuristicLab.MetaOptimization/HeuristicLab.MetaOptimization.Test/Program.cs	(revision 6016)
+++ /branches/HeuristicLab.MetaOptimization/HeuristicLab.MetaOptimization.Test/Program.cs	(revision 6017)
@@ -15,5 +15,5 @@
 using HeuristicLab.Data;
 using HeuristicLab.Encodings.RealVectorEncoding;
-using HeuristicLab.Hive.ExperimentManager;
+//using HeuristicLab.Hive.ExperimentManager;
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
@@ -30,8 +30,6 @@
   class Program {
     static void Main(string[] args) {
-      //PluginLoader.pluginAssemblies.Any();
       PluginManager pm = new PluginManager(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location));
       pm.DiscoverAndCheckPlugins();
-
       pm.Run(pm.Applications.Where(x => x.Name == "TestApp").SingleOrDefault());
     }
@@ -49,8 +47,8 @@
     //private static int baseAlgorithmMaxGenerations = 1000;
 
-    private static int metaAlgorithmPopulationSize = 10;
-    private static int metaAlgorithmMaxGenerations = 15;
+    private static int metaAlgorithmPopulationSize = 20;
+    private static int metaAlgorithmMaxGenerations = 20;
     private static int metaProblemRepetitions = 3;
-    private static int baseAlgorithmMaxGenerations = 10;
+    private static int baseAlgorithmMaxGenerations = 100;
     private static double mutationProbability = 0.10;
 
@@ -82,6 +80,6 @@
       MetaOptimizationProblem metaOptimizationProblem = new MetaOptimizationProblem();
       metaOptimizationProblem.Repetitions = new IntValue(metaProblemRepetitions);
-      GeneticAlgorithm metaLevelAlgorithm = GetMetaGA(metaOptimizationProblem);
-      //GeneticAlgorithm metaLevelAlgorithm = GetParallelMetaGA(metaOptimizationProblem);
+      //GeneticAlgorithm metaLevelAlgorithm = GetMetaGA(metaOptimizationProblem);
+      GeneticAlgorithm metaLevelAlgorithm = GetParallelMetaGA(metaOptimizationProblem);
       //GeneticAlgorithm metaLevelAlgorithm = GetHiveParallelMetaGA(metaOptimizationProblem);
 
@@ -95,8 +93,8 @@
       //Console.WriteLine("Press enter to start");
       //Console.ReadLine();
-      TestConfiguration(algorithmVc, typeof(GeneticAlgorithm), metaOptimizationProblem.Problems.First());
-
-      Console.WriteLine("Press enter to start");
-      Console.ReadLine();
+      //TestConfiguration(algorithmVc, typeof(GeneticAlgorithm), metaOptimizationProblem.Problems.First());
+
+      //Console.WriteLine("Press enter to start");
+      //Console.ReadLine();
       TestOptimization(metaLevelAlgorithm);
 
@@ -111,25 +109,39 @@
       var grammar1 = new TypeCoherentExpressionGrammar();
       var grammar2 = new TypeCoherentExpressionGrammar();
-
-      grammar2.Symbols.Single(x => x.Name == "Addition").InitialFrequency = 0.5;
-
+      
       Console.WriteLine("========== Grammar1: ==========");
       PrintGrammar(grammar1);
-      Console.WriteLine("========== Grammar2: ==========");
-      PrintGrammar(grammar2);
-
-
-      RealVector v1 = GetInitialFrequenciesAsRealVector(grammar1);
-      RealVector v2 = GetInitialFrequenciesAsRealVector(grammar2);
-
-      for (int i = 0; i < 10; i++) {
-        RealVector v3 = DiscreteCrossover.Apply(random, new ItemArray<RealVector>(new List<RealVector> { v1, v2 }));
-
-        var grammar3 = new TypeCoherentExpressionGrammar();
-        SetInitialFrequenciesFromRealVector(grammar3, v3);
-
-        Console.WriteLine("\n========== Crossed: ==========");
-        PrintGrammar(grammar3);
-      }
+      //Console.WriteLine("========== Grammar2: ==========");
+      //PrintGrammar(grammar2);
+
+      var vc1 = new SymbolicExpressionGrammarValueConfiguration(grammar1);
+      ConfigureSymbolicExpressionGrammarVc(vc1);
+      var vc2 = new SymbolicExpressionGrammarValueConfiguration(grammar2);
+      ConfigureSymbolicExpressionGrammarVc(vc2);
+
+      vc1.Mutate(random, new MutateDelegate(ParameterConfigurationManipulator.Mutate), new UniformIntValueManipulator(), new UniformDoubleValueManipulator());
+      vc1.Parameterize(grammar1);
+
+      Console.WriteLine("========== Grammar1 (mutated): ==========");
+      PrintGrammar(grammar1);
+
+      vc1.Cross(random, vc2, new CrossDelegate(ParameterConfigurationCrossover.Cross), new DiscreteIntValueCrossover(), new AverageDoubleValueCrossover());
+      vc1.Parameterize(grammar1);
+
+      Console.WriteLine("========== Grammar1 (crossed): ==========");
+      PrintGrammar(grammar1);
+
+      //RealVector v1 = GetInitialFrequenciesAsRealVector(grammar1);
+      //RealVector v2 = GetInitialFrequenciesAsRealVector(grammar2);
+
+      //for (int i = 0; i < 10; i++) {
+      //  RealVector v3 = DiscreteCrossover.Apply(random, new ItemArray<RealVector>(new List<RealVector> { v1, v2 }));
+
+      //  var grammar3 = new TypeCoherentExpressionGrammar();
+      //  SetInitialFrequenciesFromRealVector(grammar3, v3);
+
+      //  Console.WriteLine("\n========== Crossed: ==========");
+      //  PrintGrammar(grammar3);
+      //}
 
     }
@@ -421,14 +433,14 @@
 
       GeneticAlgorithm ga = new GeneticAlgorithm();
-      ga.PopulationSize.Value = 3;
-      ga.MaximumGenerations.Value = 1;
+      ga.PopulationSize.Value = 5;
+      ga.MaximumGenerations.Value = 5;
       ga.Engine = new SequentialEngine.SequentialEngine();
       ga.Problem = new SingleObjectiveTestFunctionProblem();
 
-      MetaOptimizationProblem metaOptimizationProblem = new MetaOptimizationProblem();
-      //metaOptimizationProblem.Repetitions = new IntValue(metaProblemRepetitions);
-      GeneticAlgorithm metaLevelAlgorithm = GetMetaGA(metaOptimizationProblem);
-      ParameterConfigurationTree algorithmVc = SetupGAAlgorithm(typeof(GeneticAlgorithm), metaOptimizationProblem);
-      algorithmVc.Randomize(random);
+      //MetaOptimizationProblem metaOptimizationProblem = new MetaOptimizationProblem();
+      ////metaOptimizationProblem.Repetitions = new IntValue(metaProblemRepetitions);
+      //GeneticAlgorithm metaLevelAlgorithm = GetMetaGA(metaOptimizationProblem);
+      //ParameterConfigurationTree algorithmVc = SetupGAAlgorithm(typeof(GeneticAlgorithm), metaOptimizationProblem);
+      //algorithmVc.Randomize(random);
       Stopwatch sw = new Stopwatch();
 
@@ -449,6 +461,6 @@
         algs.Enqueue(clonedGa);
 
-        if (algs.Count > 24)
-          algs.Dequeue();
+        //if (algs.Count > 24)
+        //  algs.Dequeue();
         clonedGa.StartSync();
         sw.Stop();
@@ -610,6 +622,4 @@
 
     private static void TestTypeDiscovery() {
-      PluginLoader.pluginAssemblies.Any();
-
       var items = ApplicationManager.Manager.GetInstances(typeof(DoubleArray)).ToArray();
 
@@ -667,13 +677,13 @@
     }
 
-    private static GeneticAlgorithm GetHiveParallelMetaGA(MetaOptimizationProblem metaOptimizationProblem) {
-      GeneticAlgorithm metaLevelAlgorithm = GetParallelMetaGA(metaOptimizationProblem);
-      metaLevelAlgorithm.Engine = new HiveEngine.HiveEngine();
-      ServiceLocator.Instance.ClientFacadePool.UserName = "cneumuel";
-      ServiceLocator.Instance.ClientFacadePool.Password = "cneumuel";
-      ServiceLocator.Instance.StreamedClientFacadePool.UserName = "cneumuel";
-      ServiceLocator.Instance.StreamedClientFacadePool.Password = "cneumuel";
-      return metaLevelAlgorithm;
-    }
+    //private static GeneticAlgorithm GetHiveParallelMetaGA(MetaOptimizationProblem metaOptimizationProblem) {
+    //  GeneticAlgorithm metaLevelAlgorithm = GetParallelMetaGA(metaOptimizationProblem);
+    //  metaLevelAlgorithm.Engine = new HiveEngine.HiveEngine();
+    //  ServiceLocator.Instance.ClientFacadePool.UserName = "cneumuel";
+    //  ServiceLocator.Instance.ClientFacadePool.Password = "cneumuel";
+    //  ServiceLocator.Instance.StreamedClientFacadePool.UserName = "cneumuel";
+    //  ServiceLocator.Instance.StreamedClientFacadePool.Password = "cneumuel";
+    //  return metaLevelAlgorithm;
+    //}
 
     private static EvolutionStrategy GetMetaES(MetaOptimizationProblem metaOptimizationProblem) {
@@ -714,6 +724,6 @@
 
       //ConfigurePopulationSize(algorithmVc, 15, 20, 1);
-      ConfigureMutationRate(algorithmVc, 0.0, 1.0, 0.01);
-      ConfigureMutationOperator(algorithmVc);
+      //ConfigureMutationRate(algorithmVc, 0.0, 1.0, 0.01);
+      //ConfigureMutationOperator(algorithmVc);
       //ConfigureElites(algorithmVc, 0, 8, 1);
       //ConfigureSelectionOperator(algorithmVc, true);
@@ -736,10 +746,22 @@
         }
       }
+
+      ConfigureSymbolicExpressionGrammarVc(symbolicExpressionGrammarVc);
+    }
+
+    private static void ConfigureSymbolicExpressionGrammarVc(SymbolicExpressionGrammarValueConfiguration symbolicExpressionGrammarVc) {
       symbolicExpressionGrammarVc.Optimize = true;
-
-      var additionPc = symbolicExpressionGrammarVc.ParameterConfigurations.Single(x => x.Name == "Addition");
-      additionPc.Optimize = true;
-      var initialFrequencyVc = ((ParameterizedValueConfiguration)additionPc.ValueConfigurations.First()).ParameterConfigurations.Single(x => x.Name == "InitialFrequency");
-      initialFrequencyVc.Optimize = true;
+      foreach (var pc in symbolicExpressionGrammarVc.ParameterConfigurations) {
+        if (pc.Name != "Constant"
+          && pc.Name != "Variable" 
+          && pc.Name != "ProgramRootSymbol"
+          && pc.Name != "StartSymbol") {
+          pc.Optimize = true;
+          var initialFrequencyVc = ((ParameterizedValueConfiguration)pc.ValueConfigurations.First()).ParameterConfigurations.Single(x => x.Name == "InitialFrequency");
+          initialFrequencyVc.Optimize = true;
+        }
+      }
+      //var additionPc = symbolicExpressionGrammarVc.ParameterConfigurations.Single(x => x.Name == "Addition");
+      //additionPc.Optimize = true;
     }
 
@@ -896,4 +918,6 @@
       string resultPath = Path.Combine(path, string.Format("{0} - Result.hl", id));
       string outputPath = Path.Combine(path, string.Format("{0} - Console.txt", id));
+
+      ContentManager.Save((IStorableContent)metaLevelAlgorithm, resultPath+"-before.hl", true);
 
       using (var sw = new StreamWriter(outputPath)) {
@@ -946,5 +970,5 @@
                 var orderedRuns = rc.OrderBy(x => x.Results["AverageQualityNormalized"]);
 
-                TableBuilder tb = new TableBuilder("QNorm", "Qualities"/*, "PoSi"*/ ,"MutRa" /*,"Eli", "SelOp"*/, "MutOp"/*, "NrSelSubScopes"*/);
+                TableBuilder tb = new TableBuilder("QNorm", "Qualities"/*, "PoSi"*/ /*,"MutRa"*/ /*,"Eli", "SelOp",*/ /*"MutOp"*//*, "NrSelSubScopes"*/);
                 foreach (IRun run in orderedRuns) {
                   //string selector;
@@ -959,8 +983,8 @@
                     ,((DoubleArray)run.Results["RunsAverageQualities"]).ToString()
                     //,((IntValue)run.Parameters["PopulationSize"]).Value.ToString()
-                    ,((DoubleValue)run.Parameters["MutationProbability"]).Value.ToString("0.0000")
+                    //,((DoubleValue)run.Parameters["MutationProbability"]).Value.ToString("0.0000")
                     //,((IntValue)run.Parameters["Elites"]).Value.ToString()
                     //,Shorten(selector, 20)
-                    ,Shorten(run.Parameters.ContainsKey("Mutator") ? run.Parameters["Mutator"].ToString() : "null", 40)
+                    //,Shorten(run.Parameters.ContainsKey("Mutator") ? run.Parameters["Mutator"].ToString() : "null", 40)
                     //,((ISelector)run.Parameters["Selector"]).NumberOfSelectedSubScopesParameter.Value.ToString()
                     );
Index: /branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization.Views/3.3/MetaOptimizationProblemView.cs
===================================================================
--- /branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization.Views/3.3/MetaOptimizationProblemView.cs	(revision 6016)
+++ /branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization.Views/3.3/MetaOptimizationProblemView.cs	(revision 6017)
@@ -2,4 +2,5 @@
 using System.Linq;
 using System.Windows.Forms;
+using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.MainForm;
@@ -89,7 +90,7 @@
     private void parameterCollectionView_DragEnterOver(object sender, System.Windows.Forms.DragEventArgs e) {
       e.Effect = DragDropEffects.None;
-      Type type = e.Data.GetData("Type") as Type;
-      if ((type != null) && (Content.AlgorithmType.ValidTypes.Contains(type))) {
-        IAlgorithm algorithm = e.Data.GetData("Value") as IAlgorithm;
+      var type = e.Data.GetData(Constants.DragDropDataFormat).GetType();
+      if (!ReadOnly && (Content.AlgorithmType.ValidTypes.Contains(type))) {
+        IAlgorithm algorithm = e.Data.GetData(Constants.DragDropDataFormat) as IAlgorithm;
         if (algorithm != null && algorithm.Problem == null || Content.ProblemType.ValidTypes.Contains(algorithm.Problem.GetType())) {
           e.Effect = DragDropEffects.Copy;
@@ -99,5 +100,5 @@
     private void parameterCollectionView_DragDrop(object sender, System.Windows.Forms.DragEventArgs e) {
       if (e.Effect != DragDropEffects.None) {
-        IAlgorithm algorithm = e.Data.GetData("Value") as IAlgorithm;
+        IAlgorithm algorithm = e.Data.GetData(Constants.DragDropDataFormat) as IAlgorithm;
         Content.ImportAlgorithm(algorithm);
       }
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 6016)
+++ /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 6016)
+++ /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 6016)
+++ /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 6016)
+++ /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 6016)
+++ /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 6016)
+++ /branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/MetaOptimizationProblem.cs	(revision 6017)
@@ -309,5 +309,4 @@
       }
       ParameterConfigurationTreeParameter.ActualValue = new ParameterConfigurationTree(algorithm, Problems.First());
-      
     }
   }
Index: anches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/AverageDoubleValueCrossover.cs
===================================================================
--- /branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/AverageDoubleValueCrossover.cs	(revision 6016)
+++ 	(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: anches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/AverageIntValueCrossover.cs
===================================================================
--- /branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/AverageIntValueCrossover.cs	(revision 6016)
+++ 	(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: anches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/DiscreteDoubleValueCrossover.cs
===================================================================
--- /branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/DiscreteDoubleValueCrossover.cs	(revision 6016)
+++ 	(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: anches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/DiscreteIntValueCrossover.cs
===================================================================
--- /branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/DiscreteIntValueCrossover.cs	(revision 6016)
+++ 	(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: anches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/MultiIntValueCrossover.cs
===================================================================
--- /branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/MultiIntValueCrossover.cs	(revision 6016)
+++ 	(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: anches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/NormalDoubleValueCrossover.cs
===================================================================
--- /branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/NormalDoubleValueCrossover.cs	(revision 6016)
+++ 	(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: anches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/NormalIntValueCrossover.cs
===================================================================
--- /branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/NormalIntValueCrossover.cs	(revision 6016)
+++ 	(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: anches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Manipulators/NormalDoubleValueManipulator.cs
===================================================================
--- /branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Manipulators/NormalDoubleValueManipulator.cs	(revision 6016)
+++ 	(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: anches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Manipulators/NormalIntValueManipulator.cs
===================================================================
--- /branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Manipulators/NormalIntValueManipulator.cs	(revision 6016)
+++ 	(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: anches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Manipulators/UniformDoubleValueManipulator.cs
===================================================================
--- /branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Manipulators/UniformDoubleValueManipulator.cs	(revision 6016)
+++ 	(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: anches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Manipulators/UniformIntValueManipulator.cs
===================================================================
--- /branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Manipulators/UniformIntValueManipulator.cs	(revision 6016)
+++ 	(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);
-      }
-    }
-  }
-}
