Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Analyzers/BestParameterConfigurationAnalyzer.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Analyzers/BestParameterConfigurationAnalyzer.cs	(revision 5009)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Analyzers/BestParameterConfigurationAnalyzer.cs	(revision 5023)
@@ -17,5 +17,4 @@
   [StorableClass]
   public sealed class BestParameterConfigurationAnalyzer : SingleSuccessorOperator, IAnalyzer {
-    // Wagner: Spezielle View für die Lösungen (ParameterConfigurations): So wie bei Runs: die zu Optimierenden Parameter(-werte) der besten solution anzeigen
 
     public ScopeTreeLookupParameter<ParameterConfigurationTree> ParameterConfigurationParameter {
@@ -62,12 +61,13 @@
       ResultCollection results = ResultsParameter.ActualValue;
       DoubleValue bestKnownQuality = BestKnownQualityParameter.ActualValue;
-      ItemArray<ParameterConfigurationTree> parameterConfigurations = ParameterConfigurationParameter.ActualValue;
+      ItemArray<ParameterConfigurationTree> parameterTrees = ParameterConfigurationParameter.ActualValue;
 
       int i = qualities.Select((x, index) => new { index, x.Value }).OrderBy(x => x.Value).First().index;
 
-      EngineAlgorithm bestAlg = ((EngineAlgorithm)((ParameterConfigurationTree)parameterConfigurations[i]).ActualValue.Value);
+      EngineAlgorithm bestAlg = ((EngineAlgorithm)((ParameterConfigurationTree)parameterTrees[i]).ActualValue.Value);
       Run bestRun = new Run(bestAlg);
+      ((ParameterConfigurationTree)parameterTrees[i]).CollectResultValues(bestRun.Results);
 
-      if (bestKnownQuality == null || qualities[i].Value < bestKnownQuality.Value) {
+      if (bestKnownQuality == null || qualities[i].Value < bestKnownQuality.Value) { // todo: respect Maximization:true/false
         BestKnownQualityParameter.ActualValue = new DoubleValue(qualities[i].Value);
         BestKnownSolutionParameter.ActualValue = bestRun;
@@ -83,10 +83,11 @@
       }
 
+      // population
       RunCollection rc = new RunCollection();
-      
-      foreach (ParameterConfigurationTree pc in parameterConfigurations.OrderBy(x => x.Quality.Value*-1)) {
-        IAlgorithm alg = (IAlgorithm)pc.ActualValue.Value;
+      foreach (ParameterConfigurationTree pt in parameterTrees.OrderByDescending(x => x.BestQuality.Value)) { // todo: respect Maximization:true/false
+        IAlgorithm alg = (IAlgorithm)pt.ActualValue.Value;
         alg.StoreAlgorithmInEachRun = false;
         IRun run = new Run(alg);
+        pt.CollectResultValues(run.Results);
         rc.Add(run);
       }
@@ -98,5 +99,4 @@
         results["Population"].Value = rc;
       }
-      GC.Collect();
 
       return base.Apply();
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ParameterConfigurationTree.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ParameterConfigurationTree.cs	(revision 5009)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ParameterConfigurationTree.cs	(revision 5023)
@@ -13,27 +13,21 @@
   [StorableClass]
   public class ParameterConfigurationTree : ValueConfiguration {
-    //[Storable]
-    //protected EngineAlgorithm algorithm;
-    //public EngineAlgorithm Algorithm {
-    //  get { return algorithm; }
-    //  set {
-    //    if (algorithm != value) {
-    //      if (algorithm != null) DeregisterAlgorithmEvents();
-    //      algorithm = value;
-    //      if (algorithm != null) RegisterAlgorithmEvents();
-    //      OnAlgorithmChanged();
-    //    }
-    //  }
-    //}
+    [Storable]
+    public EngineAlgorithm Algorithm {
+      get { return (EngineAlgorithm)base.ActualValue.Value; }
+      set {
+        base.ActualValue.Value = value;
+      }
+    }
 
     [Storable]
-    private DoubleValue quality;
-    public DoubleValue Quality {
-      get { return quality; }
+    private DoubleValue bestQuality;
+    public DoubleValue BestQuality {
+      get { return bestQuality; }
       set {
-        if (quality != value) {
-          if (quality != null) DeregisterQualityEvents();
-          quality = value;
-          if (quality != null) RegisterQualityEvents();
+        if (bestQuality != value) {
+          if (bestQuality != null) DeregisterQualityEvents();
+          bestQuality = value;
+          if (bestQuality != null) RegisterQualityEvents();
           OnQualityChanged();
         }
@@ -41,9 +35,53 @@
     }
 
+    [Storable]
+    private DoubleValue averageQuality;
+    public DoubleValue AverageQuality {
+      get { return averageQuality; }
+      set { averageQuality = value; }
+    }
+
+    [Storable]
+    private DoubleValue worstQuality;
+    public DoubleValue WorstQuality {
+      get { return worstQuality; }
+      set { worstQuality = value; }
+    }
+    
+    [Storable]
+    private DoubleValue qualityVariance;
+    public DoubleValue QualityVariance {
+      get { return qualityVariance; }
+      set { qualityVariance = value; }
+    }
+    
+    [Storable]
+    private DoubleValue qualityStandardDeviation;
+    public DoubleValue QualityStandardDeviation {
+      get { return qualityStandardDeviation; }
+      set { qualityStandardDeviation = value; }
+    }
+    
+    [Storable]
+    private TimeSpanValue averageExecutionTime;
+    public TimeSpanValue AverageExecutionTime {
+      get { return averageExecutionTime; }
+      set { averageExecutionTime = value; }
+    }
+
+    [Storable]
+    private IntValue repetitions;
+    public IntValue Repetitions {
+      get { return repetitions; }
+      set { repetitions = value; }
+    }
+
+    [Storable]
+    public RunCollection Runs { get; set; }
+    
     #region constructors and cloning
     public ParameterConfigurationTree(EngineAlgorithm algorithm) : base(algorithm, algorithm.GetType()) {
       this.Optimize = true; // root must always be optimized
-      this.Quality = new DoubleValue();
-      //this.algorithm = algorithm;
+      this.BestQuality = new DoubleValue();
     }
     public ParameterConfigurationTree() {
@@ -53,5 +91,7 @@
     protected ParameterConfigurationTree(bool deserializing) : base(deserializing) { }
     protected ParameterConfigurationTree(ParameterConfigurationTree original, Cloner cloner) : base(original, cloner) {
-      this.quality = cloner.Clone(original.Quality);
+      this.bestQuality = cloner.Clone(original.BestQuality);
+      this.Algorithm.Prepare();
+      this.Algorithm.Runs.Clear();
       Initialize();
     }
@@ -67,5 +107,16 @@
     private void Initialize() {
       //if (algorithm != null) RegisterAlgorithmEvents();
-      if (quality != null) RegisterQualityEvents();
+      if (bestQuality != null) RegisterQualityEvents();
+    }
+
+    public virtual void CollectResultValues(IDictionary<string, IItem> values) {
+      values.Add("RunsAverageExecutionTime", AverageExecutionTime);
+      values.Add("Repetitions", Repetitions);
+      values.Add("RunsBestQuality", BestQuality);
+      values.Add("RunsAverageQuality", AverageQuality);
+      values.Add("RunsWorstQuality", WorstQuality);
+      values.Add("RunsQualityVariance", QualityVariance);
+      values.Add("RunsQualityStandardDeviation", QualityStandardDeviation);
+      values.Add("Runs", Runs);
     }
 
@@ -89,8 +140,8 @@
     //}
     private void RegisterQualityEvents() {
-      Quality.ValueChanged += new EventHandler(Quality_ValueChanged);
+      BestQuality.ValueChanged += new EventHandler(Quality_ValueChanged);
     }
     private void DeregisterQualityEvents() {
-      Quality.ValueChanged -= new EventHandler(Quality_ValueChanged);
+      BestQuality.ValueChanged -= new EventHandler(Quality_ValueChanged);
     }
 
@@ -99,4 +150,5 @@
     }
     #endregion
+
   }
 }
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ParameterConfigurations/ParameterConfiguration.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ParameterConfigurations/ParameterConfiguration.cs	(revision 5009)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ParameterConfigurations/ParameterConfiguration.cs	(revision 5023)
@@ -127,4 +127,5 @@
       this.ActualValue = cloner.Clone(original.ActualValue);
       this.optimize = original.optimize;
+      this.actualValueConfigurationIndex = original.actualValueConfigurationIndex;
       if (this.valueConfigurations != null) RegisterValueConfigurationEvents();
     }
@@ -270,5 +271,10 @@
 
     public void Parameterize(IValueParameter parameter) {
-      parameter.ActualValue = this.ActualValue.Value;
+      if (Optimize) {
+        if (this.ActualValue.Value is IParameterizedItem) {
+          this.ValueConfigurations.CheckedItems.ElementAt(actualValueConfigurationIndex).Parameterize((IParameterizedItem)this.ActualValue.Value);
+        }
+      }
+      parameter.Value = this.ActualValue.Value;
     }
 
@@ -298,4 +304,7 @@
           this.ValueConfigurations.ElementAt(i).Cross(otherPc.ValueConfigurations.ElementAt(i), random);
         }
+        if (random.NextDouble() > 0.5) {
+          actualValueConfigurationIndex = ((ParameterConfiguration)other).actualValueConfigurationIndex;
+        }
         this.ActualValue = this.ValueConfigurations.CheckedItems.ElementAt(actualValueConfigurationIndex).ActualValue;
       }
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/RangeConstraints/DoubleValueRange.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/RangeConstraints/DoubleValueRange.cs	(revision 5009)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/RangeConstraints/DoubleValueRange.cs	(revision 5023)
@@ -21,5 +21,5 @@
     }
 
-    public override DoubleValue GetRandomValue(IRandom random) {
+    protected override DoubleValue GetRandomSample(IRandom random) {
       double val;
       do {
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/RangeConstraints/IntValueRange.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/RangeConstraints/IntValueRange.cs	(revision 5009)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/RangeConstraints/IntValueRange.cs	(revision 5023)
@@ -21,5 +21,5 @@
     }
 
-    public override IntValue GetRandomValue(IRandom random) {
+    protected override IntValue GetRandomSample(IRandom random) {
       int val;
       do {
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/RangeConstraints/PercentValueRange.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/RangeConstraints/PercentValueRange.cs	(revision 5009)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/RangeConstraints/PercentValueRange.cs	(revision 5023)
@@ -21,5 +21,5 @@
     }
 
-    public override PercentValue GetRandomValue(IRandom random) {
+    protected override PercentValue GetRandomSample(IRandom random) {
       double val;
       do {
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/RangeConstraints/Range.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/RangeConstraints/Range.cs	(revision 5009)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/RangeConstraints/Range.cs	(revision 5023)
@@ -191,5 +191,19 @@
     #endregion
 
-    public abstract T GetRandomValue(IRandom random);
+    public T GetRandomValue(IRandom random) {
+      // by a chance return the extreme values of this range to intensify search in those regions
+      if (random.NextDouble() < 0.1) {
+        if (random.NextDouble() < 0.5) {
+          return LowerBound;
+        } else {
+          return UpperBound;
+        }
+      }
+
+      // otherwise sample a random value from the range
+      return GetRandomSample(random);
+    }
+
+    protected abstract T GetRandomSample(IRandom random);
 
     IItem IRange.GetRandomValue(IRandom random) {
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ValueConfigurations/ValueConfiguration.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ValueConfigurations/ValueConfiguration.cs	(revision 5009)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ValueConfigurations/ValueConfiguration.cs	(revision 5023)
@@ -6,4 +6,6 @@
 using HeuristicLab.Data;
 using System.Drawing;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
 
 namespace HeuristicLab.Problems.MetaOptimization {
@@ -92,5 +94,6 @@
     [StorableConstructor]
     protected ValueConfiguration(bool deserializing) { }
-    protected ValueConfiguration(ValueConfiguration original, Cloner cloner) : base(original, cloner) {
+    protected ValueConfiguration(ValueConfiguration original, Cloner cloner)
+      : base(original, cloner) {
       this.ParameterConfigurations = cloner.Clone(original.parameterConfigurations);
       this.actualValue = cloner.Clone(original.ActualValue);
@@ -228,22 +231,43 @@
         if (rangeConstraint != null) {
           if (this.actualValue.ValueDataType == typeof(IntValue)) {
-            this.actualValue.Value = new IntValue((((IntValue)this.actualValue.Value).Value + ((IntValue)other.ActualValue.Value).Value) / 2);
+            //this.actualValue.Value = new IntValue((((IntValue)this.actualValue.Value).Value + ((IntValue)other.ActualValue.Value).Value) / 2);
+
+            IntegerVector[] parents = new IntegerVector[2];
+            parents[0] = new IntegerVector(new int[] { ((IntValue)this.actualValue.Value).Value });
+            parents[1] = new IntegerVector(new int[] { ((IntValue)other.ActualValue.Value).Value });
+
+            this.actualValue.Value = new IntValue(HeuristicLab.Encodings.IntegerVectorEncoding.DiscreteCrossover.Apply(random, parents[0], parents[1]).First());
+
           } else if (this.actualValue.ValueDataType == typeof(DoubleValue)) {
-            this.actualValue.Value = new DoubleValue((((DoubleValue)this.actualValue.Value).Value + ((DoubleValue)other.ActualValue.Value).Value) / 2);
+            //this.actualValue.Value = new DoubleValue((((DoubleValue)this.actualValue.Value).Value + ((DoubleValue)other.ActualValue.Value).Value) / 2);
+            RealVector[] parents = new RealVector[2];
+            parents[0] = new RealVector( new double[] {((DoubleValue)this.actualValue.Value).Value} );
+            parents[1] = new RealVector( new double[] {((DoubleValue)other.ActualValue.Value).Value} );
+
+            if (random.NextDouble() < 0.5) {
+              this.actualValue.Value = new DoubleValue(AverageCrossover.Apply(random, new ItemArray<RealVector>(parents)).First());
+            } else {
+              this.actualValue.Value = new DoubleValue(HeuristicLab.Encodings.RealVectorEncoding.DiscreteCrossover.Apply(random, new ItemArray<RealVector>(parents)).First());
+            }
+            //this.actualValue.Value = new DoubleValue(AverageCrossover.Apply(random, new ItemArray<RealVector>(parents)).First());
+            
           } else if (this.actualValue.ValueDataType == typeof(PercentValue)) {
-            this.actualValue.Value = new PercentValue((((PercentValue)this.actualValue.Value).Value + ((PercentValue)other.ActualValue.Value).Value) / 2);
+            //this.actualValue.Value = new PercentValue((((PercentValue)this.actualValue.Value).Value + ((PercentValue)other.ActualValue.Value).Value) / 2);
+
+            RealVector[] parents = new RealVector[2];
+            parents[0] = new RealVector(new double[] { ((PercentValue)this.actualValue.Value).Value });
+            parents[1] = new RealVector(new double[] { ((PercentValue)other.ActualValue.Value).Value });
+
+            if (random.NextDouble() < 0.5) {
+              this.actualValue.Value = new PercentValue(AverageCrossover.Apply(random, new ItemArray<RealVector>(parents)).First());
+            } else {
+              this.actualValue.Value = new PercentValue(HeuristicLab.Encodings.RealVectorEncoding.DiscreteCrossover.Apply(random, new ItemArray<RealVector>(parents)).First());
+            }
+
           } else if (this.actualValue.ValueDataType == typeof(BoolValue)) {
-            bool first = ((BoolValue)this.actualValue.Value).Value;
-            bool second = ((BoolValue)other.ActualValue.Value).Value;
-            if (first && second) {
-              this.actualValue.Value = new BoolValue(true);
-            } else if (!first && !second) {
-              this.actualValue.Value = new BoolValue(false);
-            } else {
-              if (random.NextDouble() > 0.5)
-                this.actualValue.Value = new BoolValue(true);
-              else
-                this.actualValue.Value = new BoolValue(false);
-            }
+            if (random.NextDouble() > 0.5)
+              this.actualValue.Value = this.actualValue.Value;
+            else
+              this.actualValue.Value = other.ActualValue.Value;
           } else {
             throw new NotImplementedException();
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Evaluators/MetaOptimizationEvaluator.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Evaluators/MetaOptimizationEvaluator.cs	(revision 5009)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Evaluators/MetaOptimizationEvaluator.cs	(revision 5023)
@@ -1,3 +1,4 @@
 ﻿using System;
+using System.Linq;
 using System.Threading;
 using HeuristicLab.Common;
@@ -8,4 +9,5 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using System.Collections.Generic;
 
 namespace HeuristicLab.Problems.MetaOptimization {
@@ -69,26 +71,47 @@
       algorithm.Stopped += new EventHandler(ActualValue_Stopped);
 
-      double qualitySum = 0;
+      List<double> qualities = new List<double>();
+      List<TimeSpan> executionTimes = new List<TimeSpan>();
+      algorithm.Prepare(true);
 
-      //foreach (ISingleObjectiveProblem problem in ProblemsParameter.ActualValue) {
-      algorithm.Engine = new SequentialEngine.SequentialEngine();
-      //algorithm.Problem = problem;
-      algorithm.Prepare();
-      algorithm.Start();
-      while (!algorithmStopped) {
-        Thread.Sleep(1000); // wait for algorithm to complete; do not rely on Algorithm.ExecutionState here, because change of ExecutionState happens before Run is added (which causes problems because Algorithm might get cloned when its started already)
+      for (int i = 0; i < Repetitions.Value; i++) {
+        algorithm.Engine = new SequentialEngine.SequentialEngine();
+        algorithm.Prepare();
+        algorithm.Start();
+        while (!algorithmStopped) {
+          Thread.Sleep(200); // wait for algorithm to complete; do not rely on Algorithm.ExecutionState here, because change of ExecutionState happens before Run is added (which causes problems because Algorithm might get cloned when its started already)
+        }
+        qualities.Add(((DoubleValue)algorithm.Results["BestQuality"].Value).Value);
+        executionTimes.Add(algorithm.ExecutionTime);
+
+        algorithmStopped = false;
       }
-      double quality = ((DoubleValue)algorithm.Results["BestQuality"].Value).Value;
-      ParameterConfigurationParameter.ActualValue.Quality.Value = quality;
-      qualitySum += quality;
-      //}
-
       algorithm.Stopped -= new EventHandler(ActualValue_Stopped);
 
-      //double qualityAvg = qualitySum / ProblemsParameter.ActualValue.Count;
-      //this.QualityParameter.ActualValue = new DoubleValue(qualityAvg);
+      qualities = qualities.OrderBy(x => x).ToList();  // todo: respect Maximization:true/false
+      
+      ParameterConfigurationParameter.ActualValue.AverageExecutionTime = new TimeSpanValue(TimeSpan.FromMilliseconds(executionTimes.Average(t => t.TotalMilliseconds)));
+      ParameterConfigurationParameter.ActualValue.Repetitions = Repetitions;
+      ParameterConfigurationParameter.ActualValue.BestQuality = new DoubleValue(qualities.First());
+      ParameterConfigurationParameter.ActualValue.AverageQuality = new DoubleValue(qualities.Average());
+      ParameterConfigurationParameter.ActualValue.WorstQuality = new DoubleValue(qualities.Last());
+      ParameterConfigurationParameter.ActualValue.QualityVariance = new DoubleValue(qualities.Variance());
+      ParameterConfigurationParameter.ActualValue.QualityStandardDeviation = new DoubleValue(qualities.StandardDeviation());
+      ParameterConfigurationParameter.ActualValue.Runs = algorithm.Runs;
+
+      double quality = ParameterConfigurationParameter.ActualValue.AverageQuality.Value; // todo: also include other measures (executiontime, variance)
       this.QualityParameter.ActualValue = new DoubleValue(quality);
+      
+      return base.Apply();
+    }
 
-      return base.Apply();
+    public static double Variance(IEnumerable<double> source) {
+      double avg = source.Average();
+      double d = source.Aggregate(0.0, (total, next) => total += Math.Pow(next - avg, 2));
+      return d / (source.Count() - 1);
+    }
+
+    public static double StandardDeviation(IEnumerable<double> source) {
+      return Math.Sqrt(source.Variance());
     }
 
@@ -96,14 +119,4 @@
       algorithmStopped = true;
     }
-
-    //private void ParameterizeAlgorithm() {
-    //  foreach (IParameterConfiguration parameter in ParameterVectorParameter.ActualValue) {
-    //    if (typeof(IAlgorithm).IsAssignableFrom(parameter.OperatorType)) {
-    //      this.AlgorithmParameter.ActualValue.Parameters[parameter.Parameter.Name].ActualValue = parameter.Parameter.ActualValue;
-    //    } else if (typeof(IProblem).IsAssignableFrom(parameter.OperatorType)) {
-    //      this.AlgorithmParameter.ActualValue.Problem.Parameters[parameter.Parameter.Name].ActualValue = parameter.Parameter.ActualValue;
-    //    }
-    //  }
-    //}
   }
 }
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 5009)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/HeuristicLab.Problems.MetaOptimization-3.3.csproj	(revision 5023)
@@ -91,4 +91,5 @@
   <ItemGroup>
     <Compile Include="Analyzers\BestParameterConfigurationAnalyzer.cs" />
+    <None Include="ClassDiagram1.cd" />
     <None Include="Properties\AssemblyInfo.cs.frame" />
     <None Include="HeuristicLabProblemsMetaOptimizationPlugin.cs.frame" />
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IOptimizable.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IOptimizable.cs	(revision 5009)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IOptimizable.cs	(revision 5023)
@@ -15,5 +15,5 @@
     void Mutate(IRandom random);
     void Cross(IOptimizable other, IRandom random);
-
+    
     event EventHandler IsOptimizableChanged;
     event EventHandler OptimizeChanged;
