Index: /branches/HeuristicLab.MetaOptimization/HeuristicLab.MetaOptimization.Test/Program.cs
===================================================================
--- /branches/HeuristicLab.MetaOptimization/HeuristicLab.MetaOptimization.Test/Program.cs	(revision 5292)
+++ /branches/HeuristicLab.MetaOptimization/HeuristicLab.MetaOptimization.Test/Program.cs	(revision 5293)
@@ -33,5 +33,5 @@
     private static int metaAlgorithmPopulationSize = 7;
     private static int metaAlgorithmMaxGenerations = 20;
-    private static int metaProblemRepetitions = 3;
+    private static int metaProblemRepetitions = 6;
     private static int baseAlgorithmMaxGenerations = 50;
     private static double mutationProbability = 0.35;
@@ -56,4 +56,5 @@
       //TestExecutionTimeUpdateInvervalPerformance();
       //TestMemoryConsumption();
+      //TestNormalCrossover();
 
       GeneticAlgorithm baseLevelAlgorithm = new GeneticAlgorithm();
@@ -83,4 +84,27 @@
 
       Console.ReadLine();
+    }
+
+    private static void TestNormalCrossover() {
+      var random = new MersenneTwister();
+      double d1 = 0.5;
+      double d2 = 0.6;
+      var doubleRange = new DoubleValueRange(new DoubleValue(0.0), new DoubleValue(1.0), new DoubleValue(0.01));
+
+      using (var sw = new StreamWriter("normalCrossover-DoubleValue.txt")) {
+        for (int i = 0; i < 10000; i++) {
+          sw.WriteLine(NormalDoubleValueCrossover.ApplyStatic(random, new DoubleValue(d1), new DoubleValue(d2), doubleRange));
+        }
+      }
+
+      int i1 = 180;
+      int i2 = 160;
+      var intRange = new IntValueRange(new IntValue(100), new IntValue(200), new IntValue(1));
+
+      using (var sw = new StreamWriter("normalCrossover-IntValue.txt")) {
+        for (int i = 0; i < 10000; i++) {
+         sw.WriteLine(NormalIntValueCrossover.ApplyStatic(random, new IntValue(i1), new IntValue(i2), intRange));
+        }
+      }
     }
 
@@ -510,21 +534,21 @@
       ParameterConfigurationTree algorithmVc = metaOptimizationProblem.ParameterConfigurationTree;
 
-      metaOptimizationProblem.Problems.Add(new HeuristicLab.Problems.TestFunctions.SingleObjectiveTestFunctionProblem() {
-        Evaluator = new GriewankEvaluator(),
-        ProblemSize = new IntValue(5)
-      });
+      //metaOptimizationProblem.Problems.Add(new HeuristicLab.Problems.TestFunctions.SingleObjectiveTestFunctionProblem() {
+      //  Evaluator = new GriewankEvaluator(),
+      //  ProblemSize = new IntValue(2)
+      //});
+      //metaOptimizationProblem.Problems.Add(new HeuristicLab.Problems.TestFunctions.SingleObjectiveTestFunctionProblem() {
+      //  Evaluator = new GriewankEvaluator(),
+      //  ProblemSize = new IntValue(20)
+      //});
       metaOptimizationProblem.Problems.Add(new HeuristicLab.Problems.TestFunctions.SingleObjectiveTestFunctionProblem() {
         Evaluator = new GriewankEvaluator(),
         ProblemSize = new IntValue(50)
       });
-      metaOptimizationProblem.Problems.Add(new HeuristicLab.Problems.TestFunctions.SingleObjectiveTestFunctionProblem() {
-        Evaluator = new GriewankEvaluator(),
-        ProblemSize = new IntValue(500)
-      });
 
       ConfigurePopulationSize(algorithmVc, 12, 100, 1);
-      ConfigureMutationRate(algorithmVc, 0.0, 1.0, 0.01);
+      ConfigureMutationRate(algorithmVc, 0.0, 1.0, 0.0001);
       ConfigureMutationOperator(algorithmVc);
-      //ConfigureElites(algorithmVc, 0, 10, 1);
+      ConfigureElites(algorithmVc, 0, 10, 1);
       //ConfigureSelectionOperator(algorithmVc, true);
       return algorithmVc;
@@ -738,8 +762,8 @@
 
                   tb.AppendRow(
-                    ((DoubleValue)run.Results["AverageQualityNormalized"]).Value.ToString("#0.00"),
+                    ((DoubleValue)run.Results["AverageQualityNormalized"]).Value.ToString("#0.0000"),
                     ((DoubleArray)run.Results["RunsAverageQualities"]).ToString(),
                     ((IntValue)run.Parameters["PopulationSize"]).Value.ToString(),
-                    ((DoubleValue)run.Parameters["MutationProbability"]).Value.ToString("0.00"),
+                    ((DoubleValue)run.Parameters["MutationProbability"]).Value.ToString("0.0000"),
                     ((IntValue)run.Parameters["Elites"]).Value.ToString(),
                     Shorten(selector, 20),
Index: /branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Analyzers/BestParameterConfigurationAnalyzer.cs
===================================================================
--- /branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Analyzers/BestParameterConfigurationAnalyzer.cs	(revision 5292)
+++ /branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Analyzers/BestParameterConfigurationAnalyzer.cs	(revision 5293)
@@ -39,6 +39,6 @@
       get { return (LookupParameter<RunCollection>)Parameters["Population"]; }
     }
-    public LookupParameter<DoubleArray> ProblemQualityMediansParameter {
-      get { return (LookupParameter<DoubleArray>)Parameters["ProblemQualityMedians"]; }
+    public LookupParameter<DoubleArray> ProblemQualityReferencesParameter {
+      get { return (LookupParameter<DoubleArray>)Parameters["ProblemQualityReferences"]; }
     }
     public LookupParameter<ConstrainedItemList<ISingleObjectiveProblem>> ProblemsParameter {
@@ -55,5 +55,5 @@
       Parameters.Add(new LookupParameter<IRun>("BestKnownSolution", ""));
       Parameters.Add(new LookupParameter<RunCollection>("Population", ""));
-      Parameters.Add(new LookupParameter<DoubleArray>("ProblemQualityMedians", ""));
+      Parameters.Add(new LookupParameter<DoubleArray>("ProblemQualityReferences", ""));
       Parameters.Add(new LookupParameter<ConstrainedItemList<ISingleObjectiveProblem>>(MetaOptimizationProblem.ProblemsParameterName));
     }
Index: anches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Analyzers/MedianQualityAnalyzer.cs
===================================================================
--- /branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Analyzers/MedianQualityAnalyzer.cs	(revision 5292)
+++ 	(revision )
@@ -1,81 +1,0 @@
-﻿using System.Linq;
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Operators;
-using HeuristicLab.Optimization;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using System.Collections.Generic;
-using System;
-
-namespace HeuristicLab.Problems.MetaOptimization {
-  /// <summary>
-  /// TODO An operator for analyzing the best solution of Traveling Salesman Problems given in path representation using city coordinates.
-  /// </summary>
-  [Item("MedianQualityAnalyzer", "")]
-  [StorableClass]
-  public sealed class MedianQualityAnalyzer : SingleSuccessorOperator, IAnalyzer {
-    
-    public ValueLookupParameter<ResultCollection> ResultsParameter {
-      get { return (ValueLookupParameter<ResultCollection>)Parameters["Results"]; }
-    }
-    public ScopeTreeLookupParameter<ParameterConfigurationTree> ParameterConfigurationParameter {
-      get { return (ScopeTreeLookupParameter<ParameterConfigurationTree>)Parameters["ParameterConfigurationTree"]; }
-    }
-    public ScopeTreeLookupParameter<DoubleValue> QualityParameter {
-      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
-    }
-    public LookupParameter<DoubleArray> ProblemQualityMediansParameter {
-      get { return (LookupParameter<DoubleArray>)Parameters["ProblemQualityMedians"]; }
-    }
-    public LookupParameter<ConstrainedItemList<ISingleObjectiveProblem>> ProblemsParameter {
-      get { return (LookupParameter<ConstrainedItemList<ISingleObjectiveProblem>>)Parameters[MetaOptimizationProblem.ProblemsParameterName]; }
-    }
-
-    public MedianQualityAnalyzer()
-      : base() {
-        Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", ""));
-      Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", ""));
-      Parameters.Add(new ScopeTreeLookupParameter<ParameterConfigurationTree>("ParameterConfigurationTree", ""));
-      Parameters.Add(new LookupParameter<DoubleArray>("ProblemQualityMedians", ""));
-      Parameters.Add(new LookupParameter<ConstrainedItemList<ISingleObjectiveProblem>>(MetaOptimizationProblem.ProblemsParameterName, ""));
-    }
-
-    [StorableConstructor]
-    private MedianQualityAnalyzer(bool deserializing) : base(deserializing) { }
-    private MedianQualityAnalyzer(MedianQualityAnalyzer original, Cloner cloner) : base(original, cloner) { }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new MedianQualityAnalyzer(this, cloner);
-    }
-
-    public override IOperation Apply() {
-      ResultCollection results = ResultsParameter.ActualValue;
-      ItemArray<ParameterConfigurationTree> solutions = ParameterConfigurationParameter.ActualValue;
-      ItemArray<DoubleValue> qualities = QualityParameter.ActualValue;
-
-      if (ProblemQualityMediansParameter.ActualValue == null) {
-        DoubleArray medians = CalculateMedians(solutions);
-        ProblemQualityMediansParameter.ActualValue = medians;
-        NormalizePopulation(solutions, qualities, medians);
-        results.Add(new Result("ProblemsAverageQualityMedians", medians));
-      }
-
-      return base.Apply();
-    }
-
-    private DoubleArray CalculateMedians(ItemArray<ParameterConfigurationTree> solutions) {
-      DoubleArray medians = new DoubleArray(ProblemsParameter.ActualValue.Count);
-      for (int pi = 0; pi < ProblemsParameter.ActualValue.Count; pi++) {
-        medians[pi] = solutions.Select(x => x.AverageQualities[pi]).Median();
-      }
-      return medians;
-    }
-
-    private void NormalizePopulation(ItemArray<ParameterConfigurationTree> solutions, ItemArray<DoubleValue> qualities, DoubleArray medians) {
-      for (int i = 0; i < solutions.Length; i++) {
-        qualities[i].Value = ParameterConfigurationEvaluator.NormalizeQualities(solutions[i], medians.ToArray());
-      }
-    }
-  }
-}
Index: /branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Analyzers/ReferenceQualityAnalyzer.cs
===================================================================
--- /branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Analyzers/ReferenceQualityAnalyzer.cs	(revision 5293)
+++ /branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Analyzers/ReferenceQualityAnalyzer.cs	(revision 5293)
@@ -0,0 +1,81 @@
+﻿using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using System.Collections.Generic;
+using System;
+
+namespace HeuristicLab.Problems.MetaOptimization {
+  /// <summary>
+  /// TODO
+  /// </summary>
+  [Item("ReferenceQualityAnalyzer", "")]
+  [StorableClass]
+  public sealed class ReferenceQualityAnalyzer : SingleSuccessorOperator, IAnalyzer {
+    
+    public ValueLookupParameter<ResultCollection> ResultsParameter {
+      get { return (ValueLookupParameter<ResultCollection>)Parameters["Results"]; }
+    }
+    public ScopeTreeLookupParameter<ParameterConfigurationTree> ParameterConfigurationParameter {
+      get { return (ScopeTreeLookupParameter<ParameterConfigurationTree>)Parameters["ParameterConfigurationTree"]; }
+    }
+    public ScopeTreeLookupParameter<DoubleValue> QualityParameter {
+      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    public LookupParameter<DoubleArray> ProblemQualityReferenceParameter {
+      get { return (LookupParameter<DoubleArray>)Parameters["ProblemQualityReferences"]; }
+    }
+    public LookupParameter<ConstrainedItemList<ISingleObjectiveProblem>> ProblemsParameter {
+      get { return (LookupParameter<ConstrainedItemList<ISingleObjectiveProblem>>)Parameters[MetaOptimizationProblem.ProblemsParameterName]; }
+    }
+
+    public ReferenceQualityAnalyzer()
+      : base() {
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", ""));
+      Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", ""));
+      Parameters.Add(new ScopeTreeLookupParameter<ParameterConfigurationTree>("ParameterConfigurationTree", ""));
+      Parameters.Add(new LookupParameter<DoubleArray>("ProblemQualityReferences", ""));
+      Parameters.Add(new LookupParameter<ConstrainedItemList<ISingleObjectiveProblem>>(MetaOptimizationProblem.ProblemsParameterName, ""));
+    }
+
+    [StorableConstructor]
+    private ReferenceQualityAnalyzer(bool deserializing) : base(deserializing) { }
+    private ReferenceQualityAnalyzer(ReferenceQualityAnalyzer original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ReferenceQualityAnalyzer(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      ResultCollection results = ResultsParameter.ActualValue;
+      ItemArray<ParameterConfigurationTree> solutions = ParameterConfigurationParameter.ActualValue;
+      ItemArray<DoubleValue> qualities = QualityParameter.ActualValue;
+
+      if (ProblemQualityReferenceParameter.ActualValue == null) {
+        DoubleArray referenceQualities = CalculateReferenceQualities(solutions);
+        ProblemQualityReferenceParameter.ActualValue = referenceQualities;
+        NormalizePopulation(solutions, qualities, referenceQualities);
+        results.Add(new Result("ProblemsAverageQualityReferences", referenceQualities));
+      }
+
+      return base.Apply();
+    }
+
+    private DoubleArray CalculateReferenceQualities(ItemArray<ParameterConfigurationTree> solutions) {
+      DoubleArray referenceQualities = new DoubleArray(ProblemsParameter.ActualValue.Count);
+      for (int pi = 0; pi < ProblemsParameter.ActualValue.Count; pi++) {
+        referenceQualities[pi] = solutions.Select(x => x.AverageQualities[pi]).Min(); // todo: respect minimization / maximization
+      }
+      return referenceQualities;
+    }
+
+    private void NormalizePopulation(ItemArray<ParameterConfigurationTree> solutions, ItemArray<DoubleValue> qualities, DoubleArray referenceQualities) {
+      for (int i = 0; i < solutions.Length; i++) {
+        qualities[i].Value = ParameterConfigurationEvaluator.NormalizeQualities(solutions[i], referenceQualities.ToArray());
+      }
+    }
+  }
+}
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 5292)
+++ /branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/Crossovers/ParameterConfigurationCrossover.cs	(revision 5293)
@@ -38,4 +38,18 @@
     }
 
+    /// <summary>
+    /// Whether the problem is a maximization or minimization problem.
+    /// </summary>
+    public ValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (ValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+
+    /// <summary>
+    /// The quality of the parents.
+    /// </summary>
+    public ScopeTreeLookupParameter<DoubleValue> QualityParameter {
+      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+
     [StorableConstructor]
     protected ParameterConfigurationCrossover(bool deserializing) : base(deserializing) { }
@@ -46,5 +60,6 @@
       Parameters.Add(new ScopeTreeLookupParameter<ParameterConfigurationTree>("Parents", "The parent vectors which should be crossed."));
       Parameters.Add(new LookupParameter<ParameterConfigurationTree>("Child", "The child vector resulting from the crossover."));
-
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "Whether the problem is a maximization problem or not."));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The quality values of the parents."));
       Parameters.Add(new ValueLookupParameter<IIntValueCrossover>(MetaOptimizationProblem.IntValueCrossoverParameterName, ""));
       Parameters.Add(new ValueLookupParameter<IDoubleValueCrossover>(MetaOptimizationProblem.DoubleValueCrossoverParameterName, ""));
@@ -55,6 +70,19 @@
 
     public override IOperation Apply() {
-      ParameterConfigurationTree child1 = (ParameterConfigurationTree)ParentsParameter.ActualValue[0].Clone();
-      ParameterConfigurationTree child2 = (ParameterConfigurationTree)ParentsParameter.ActualValue[1];
+      if (MaximizationParameter.ActualValue == null) throw new InvalidOperationException("HeuristicCrossover: Parameter " + MaximizationParameter.ActualName + " could not be found.");
+      if (QualityParameter.ActualValue == null || QualityParameter.ActualValue.Length != 2) throw new InvalidOperationException("ParameterConfigurationCrossover: Parameter " + QualityParameter.ActualName + " could not be found, or not in the same quantity as there are parents.");
+      ItemArray<DoubleValue> qualities = QualityParameter.ActualValue;
+      bool maximization = MaximizationParameter.ActualValue.Value;
+
+      ParameterConfigurationTree child1; 
+      ParameterConfigurationTree child2; 
+
+      if (maximization && qualities[0].Value >= qualities[1].Value || !maximization && qualities[0].Value <= qualities[1].Value) {
+        child1 = (ParameterConfigurationTree)ParentsParameter.ActualValue[0].Clone();
+        child2 = (ParameterConfigurationTree)ParentsParameter.ActualValue[1];
+      } else {
+        child1 = (ParameterConfigurationTree)ParentsParameter.ActualValue[1].Clone();
+        child2 = (ParameterConfigurationTree)ParentsParameter.ActualValue[0];
+      }
 
       child1.Cross(RandomParameter.ActualValue, child2, Cross, IntValueCrossoverParameter.ActualValue, DoubleValueCrossoverParameter.ActualValue);
Index: /branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Evaluators/ParameterConfigurationEvaluator.cs
===================================================================
--- /branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Evaluators/ParameterConfigurationEvaluator.cs	(revision 5292)
+++ /branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Evaluators/ParameterConfigurationEvaluator.cs	(revision 5293)
@@ -40,6 +40,6 @@
     }
 
-    public LookupParameter<DoubleArray> ProblemQualityMediansParameter {
-      get { return (LookupParameter<DoubleArray>)Parameters["ProblemQualityMedians"]; }
+    public LookupParameter<DoubleArray> ProblemQualityReferencesParameter {
+      get { return (LookupParameter<DoubleArray>)Parameters["ProblemQualityReferences"]; }
     }
 
@@ -55,5 +55,5 @@
       Parameters.Add(new LookupParameter<ParameterConfigurationTree>("ParameterConfigurationTree", "Missing description."));
       Parameters.Add(new LookupParameter<IntValue>(MetaOptimizationProblem.RepetitionsParameterName, "Number of evaluations on one problem."));
-      Parameters.Add(new LookupParameter<DoubleArray>("ProblemQualityMedians", ""));
+      Parameters.Add(new LookupParameter<DoubleArray>("ProblemQualityReferences", ""));
     }
 
@@ -72,13 +72,13 @@
       ParameterConfigurationTree parameterConfiguration = ParameterConfigurationParameter.ActualValue;
 
-      double[] medians;
-      if (ProblemQualityMediansParameter.ActualValue == null) {
+      double[] referenceQualities;
+      if (ProblemQualityReferencesParameter.ActualValue == null) {
         // this is generation zero. no reference qualities for normalization have been calculated yet.
-        medians = new double[problems.Count];
-        for (int i = 0; i < medians.Length; i++) {
-          medians[i] = 1;
+        referenceQualities = new double[problems.Count];
+        for (int i = 0; i < referenceQualities.Length; i++) {
+          referenceQualities[i] = 1;
         }
       } else {
-        medians = ProblemQualityMediansParameter.ActualValue.ToArray();
+        referenceQualities = ProblemQualityReferencesParameter.ActualValue.ToArray();
       }
 
@@ -131,13 +131,13 @@
       parameterConfiguration.Runs = (RunCollection)algorithm.Runs.Clone();
 
-      this.QualityParameter.ActualValue = new DoubleValue(NormalizeQualities(parameterConfiguration, medians));
+      this.QualityParameter.ActualValue = new DoubleValue(NormalizeQualities(parameterConfiguration, referenceQualities));
 
       return base.Apply();
     }
 
-    public static double NormalizeQualities(ParameterConfigurationTree parameterConfigurationTree, double[] medians) {
-      double[] qualitiesNormalized = new double[medians.Length];
-      for (int i = 0; i < medians.Length; i++) {
-        qualitiesNormalized[i] = parameterConfigurationTree.AverageQualities[i] / medians[i];
+    public static double NormalizeQualities(ParameterConfigurationTree parameterConfigurationTree, double[] referenceQualities) {
+      double[] qualitiesNormalized = new double[referenceQualities.Length];
+      for (int i = 0; i < referenceQualities.Length; i++) {
+        qualitiesNormalized[i] = parameterConfigurationTree.AverageQualities[i] / referenceQualities[i];
       }
       parameterConfigurationTree.QualitiesNormalized = new DoubleArray(qualitiesNormalized);
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 5292)
+++ /branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/HeuristicLab.Problems.MetaOptimization-3.3.csproj	(revision 5293)
@@ -117,4 +117,7 @@
       <HintPath>..\..\..\..\..\..\..\..\Program Files\HeuristicLab 3.3\HeuristicLab.Problems.TestFunctions-3.3.dll</HintPath>
     </Reference>
+    <Reference Include="HeuristicLab.Random-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <HintPath>..\..\..\..\..\..\..\..\Program Files\HeuristicLab 3.3\HeuristicLab.Random-3.3.dll</HintPath>
+    </Reference>
     <Reference Include="HeuristicLab.SequentialEngine-3.3">
       <HintPath>..\..\..\..\..\..\..\..\Program Files\HeuristicLab 3.3\HeuristicLab.SequentialEngine-3.3.dll</HintPath>
@@ -132,5 +135,5 @@
     <None Include="Properties\AssemblyInfo.cs.frame" />
     <None Include="HeuristicLabProblemsMetaOptimizationPlugin.cs.frame" />
-    <Compile Include="Analyzers\MedianQualityAnalyzer.cs" />
+    <Compile Include="Analyzers\ReferenceQualityAnalyzer.cs" />
     <Compile Include="ConstrainedItemList.cs" />
     <Compile Include="Encoding\NullValue.cs" />
@@ -152,4 +155,7 @@
     <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" />
@@ -173,4 +179,5 @@
     <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" />
Index: /branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/MetaOptimizationProblem.cs
===================================================================
--- /branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/MetaOptimizationProblem.cs	(revision 5292)
+++ /branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/MetaOptimizationProblem.cs	(revision 5293)
@@ -98,6 +98,6 @@
       get { return Operators.OfType<BestParameterConfigurationAnalyzer>().FirstOrDefault(); }
     }
-    private MedianQualityAnalyzer MedianQualityAnalyzer {
-      get { return Operators.OfType<MedianQualityAnalyzer>().FirstOrDefault(); }
+    private ReferenceQualityAnalyzer ReferenceQualityAnalyzer {
+      get { return Operators.OfType<ReferenceQualityAnalyzer>().FirstOrDefault(); }
     }
     #endregion
@@ -114,8 +114,8 @@
       var validIntCrossovers = new ItemSet<IIntValueCrossover>(ApplicationManager.Manager.GetInstances<IIntValueCrossover>());
       var validDoubleCrossovers = new ItemSet<IDoubleValueCrossover>(ApplicationManager.Manager.GetInstances<IDoubleValueCrossover>());
-      Parameters.Add(new ConstrainedValueParameter<IIntValueManipulator>(IntValueManipulatorParameterName, "", validIntManipulators, validIntManipulators.First()));
-      Parameters.Add(new ConstrainedValueParameter<IDoubleValueManipulator>(DoubleValueManipulatorParameterName, "", validDoubleManipulators, validDoubleManipulators.First()));
-      Parameters.Add(new ConstrainedValueParameter<IIntValueCrossover>(IntValueCrossoverParameterName, "", validIntCrossovers, validIntCrossovers.First()));
-      Parameters.Add(new ConstrainedValueParameter<IDoubleValueCrossover>(DoubleValueCrossoverParameterName, "", validDoubleCrossovers, validDoubleCrossovers.Where(x => x.GetType() == typeof(AverageDoubleValueCrossover)).SingleOrDefault()));
+      Parameters.Add(new ConstrainedValueParameter<IIntValueManipulator>(IntValueManipulatorParameterName, "", validIntManipulators, validIntManipulators.Where(x => x.GetType() == typeof(NormalIntValueManipulator)).SingleOrDefault()));
+      Parameters.Add(new ConstrainedValueParameter<IDoubleValueManipulator>(DoubleValueManipulatorParameterName, "", validDoubleManipulators, validDoubleManipulators.Where(x => x.GetType() == typeof(NormalDoubleValueManipulator)).SingleOrDefault()));
+      Parameters.Add(new ConstrainedValueParameter<IIntValueCrossover>(IntValueCrossoverParameterName, "", validIntCrossovers, validIntCrossovers.Where(x => x.GetType() == typeof(NormalIntValueCrossover)).SingleOrDefault()));
+      Parameters.Add(new ConstrainedValueParameter<IDoubleValueCrossover>(DoubleValueCrossoverParameterName, "", validDoubleCrossovers, validDoubleCrossovers.Where(x => x.GetType() == typeof(NormalDoubleValueCrossover)).SingleOrDefault()));
 
       Maximization = new BoolValue(false);
@@ -161,5 +161,5 @@
       Operators.AddRange(ApplicationManager.Manager.GetInstances<IParameterConfigurationOperator>().Cast<IOperator>());
       Operators.Add(new BestParameterConfigurationAnalyzer());
-      Operators.Add(new MedianQualityAnalyzer());
+      Operators.Add(new ReferenceQualityAnalyzer());
     }
     private void ParameterizeSolutionCreator() {
@@ -172,6 +172,6 @@
         BestParameterConfigurationAnalyzer.ParameterConfigurationParameter.ActualName = ((RandomParameterConfigurationCreator)SolutionCreator).ParameterConfigurationParameter.ActualName;
       }
-      if (MedianQualityAnalyzer != null) {
-        MedianQualityAnalyzer.ParameterConfigurationParameter.ActualName = ((RandomParameterConfigurationCreator)SolutionCreator).ParameterConfigurationParameter.ActualName;
+      if (ReferenceQualityAnalyzer != null) {
+        ReferenceQualityAnalyzer.ParameterConfigurationParameter.ActualName = ((RandomParameterConfigurationCreator)SolutionCreator).ParameterConfigurationParameter.ActualName;
       }
     }
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 5293)
+++ /branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/AverageIntValueCrossover.cs	(revision 5293)
@@ -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/NormalDoubleValueCrossover.cs
===================================================================
--- /branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/NormalDoubleValueCrossover.cs	(revision 5293)
+++ /branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/NormalDoubleValueCrossover.cs	(revision 5293)
@@ -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();
+        range.ApplyStepSize(offspring);
+      } 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 5293)
+++ /branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/NormalIntValueCrossover.cs	(revision 5293)
@@ -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();
+        range.ApplyStepSize(offspring);
+      } while (!range.IsInRange(offspring.Value));
+      return offspring;
+    }
+  }
+}
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 5292)
+++ /branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Manipulators/NormalDoubleValueManipulator.cs	(revision 5293)
@@ -37,6 +37,6 @@
     public static void ApplyStatic(IRandom random, DoubleValue value, DoubleValueRange range) {
       bool ok = false;
-      RealVector strategy = new RealVector(new double[] { (range.UpperBound.Value - range.LowerBound.Value) / 15});
-      RealVector vector = new RealVector(1);
+      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;
 
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 5293)
+++ /branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Manipulators/NormalIntValueManipulator.cs	(revision 5293)
@@ -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];
+        range.ApplyStepSize(value);
+        ok = range.IsInRange(value.Value);
+      }
+    }
+  }
+}
